Merge branch 'jk/fewer-pack-rescan'
authorJunio C Hamano <gitster@pobox.com>
Wed, 6 Dec 2017 17:23:42 +0000 (09:23 -0800)
committerJunio C Hamano <gitster@pobox.com>
Wed, 6 Dec 2017 17:23:42 +0000 (09:23 -0800)
Internaly we use 0{40} as a placeholder object name to signal the
codepath that there is no such object (e.g. the fast-forward check
while "git fetch" stores a new remote-tracking ref says "we know
there is no 'old' thing pointed at by the ref, as we are creating
it anew" by passing 0{40} for the 'old' side), and expect that a
codepath to locate an in-core object to return NULL as a sign that
the object does not exist.  A look-up for an object that does not
exist however is quite costly with a repository with large number
of packfiles.  This access pattern has been optimized.

* jk/fewer-pack-rescan:
  sha1_file: fast-path null sha1 as a missing object
  everything_local: use "quick" object existence check
  p5551: add a script to test fetch pack-dir rescans
  t/perf/lib-pack: use fast-import checkpoint to create packs
  p5550: factor out nonsense-pack creation

1  2 
fetch-pack.c
sha1_file.c

diff --combined fetch-pack.c
@@@ -17,7 -17,6 +17,7 @@@
  #include "prio-queue.h"
  #include "sha1-array.h"
  #include "oidset.h"
 +#include "packfile.h"
  
  static int transfer_unpack_limit = -1;
  static int fetch_unpack_limit = -1;
@@@ -611,7 -610,7 +611,7 @@@ static int tip_oids_contain(struct oids
         * add to "newlist" between calls, the additions will always be for
         * oids that are already in the set.
         */
 -      if (!tip_oids->map.tablesize) {
 +      if (!tip_oids->map.map.tablesize) {
                add_refs_to_oidset(tip_oids, unmatched);
                add_refs_to_oidset(tip_oids, newlist);
        }
@@@ -716,7 -715,8 +716,8 @@@ static int everything_local(struct fetc
        for (ref = *refs; ref; ref = ref->next) {
                struct object *o;
  
-               if (!has_object_file(&ref->old_oid))
+               if (!has_object_file_with_flags(&ref->old_oid,
+                                               OBJECT_INFO_QUICK))
                        continue;
  
                o = parse_object(&ref->old_oid);
diff --combined sha1_file.c
  #include "list.h"
  #include "mergesort.h"
  #include "quote.h"
 +#include "packfile.h"
  
 -#define SZ_FMT PRIuMAX
 -static inline uintmax_t sz_fmt(size_t s) { return s; }
 -
 -const unsigned char null_sha1[20];
 +const unsigned char null_sha1[GIT_MAX_RAWSZ];
  const struct object_id null_oid;
  const struct object_id empty_tree_oid = {
        EMPTY_TREE_SHA1_BIN_LITERAL
@@@ -74,18 -76,6 +74,18 @@@ static struct cached_object *find_cache
        return NULL;
  }
  
 +
 +static enum safe_crlf get_safe_crlf(unsigned flags)
 +{
 +      if (flags & HASH_RENORMALIZE)
 +              return SAFE_CRLF_RENORMALIZE;
 +      else if (flags & HASH_WRITE_OBJECT)
 +              return safe_crlf;
 +      else
 +              return SAFE_CRLF_FALSE;
 +}
 +
 +
  int mkdir_in_gitdir(const char *path)
  {
        if (mkdir(path, 0777)) {
@@@ -288,6 -278,28 +288,6 @@@ static const char *alt_sha1_path(struc
        return buf->buf;
  }
  
 - char *odb_pack_name(struct strbuf *buf,
 -                   const unsigned char *sha1,
 -                   const char *ext)
 -{
 -      strbuf_reset(buf);
 -      strbuf_addf(buf, "%s/pack/pack-%s.%s", get_object_directory(),
 -                  sha1_to_hex(sha1), ext);
 -      return buf->buf;
 -}
 -
 -char *sha1_pack_name(const unsigned char *sha1)
 -{
 -      static struct strbuf buf = STRBUF_INIT;
 -      return odb_pack_name(&buf, sha1, "pack");
 -}
 -
 -char *sha1_pack_index_name(const unsigned char *sha1)
 -{
 -      static struct strbuf buf = STRBUF_INIT;
 -      return odb_pack_name(&buf, sha1, "idx");
 -}
 -
  struct alternate_object_database *alt_odb_list;
  static struct alternate_object_database **alt_odb_tail;
  
@@@ -416,9 -428,6 +416,9 @@@ static void link_alt_odb_entries(const 
        struct strbuf objdirbuf = STRBUF_INIT;
        struct strbuf entry = STRBUF_INIT;
  
 +      if (!alt || !*alt)
 +              return;
 +
        if (depth > 5) {
                error("%s: ignoring alternate object stores, nesting too deep.",
                                relative_base);
@@@ -471,19 -480,19 +471,19 @@@ struct alternate_object_database *alloc
  
  void add_to_alternates_file(const char *reference)
  {
 -      struct lock_file *lock = xcalloc(1, sizeof(struct lock_file));
 +      struct lock_file lock = LOCK_INIT;
        char *alts = git_pathdup("objects/info/alternates");
        FILE *in, *out;
 +      int found = 0;
  
 -      hold_lock_file_for_update(lock, alts, LOCK_DIE_ON_ERROR);
 -      out = fdopen_lock_file(lock, "w");
 +      hold_lock_file_for_update(&lock, alts, LOCK_DIE_ON_ERROR);
 +      out = fdopen_lock_file(&lock, "w");
        if (!out)
                die_errno("unable to fdopen alternates lockfile");
  
        in = fopen(alts, "r");
        if (in) {
                struct strbuf line = STRBUF_INIT;
 -              int found = 0;
  
                while (strbuf_getline(&line, in) != EOF) {
                        if (!strcmp(reference, line.buf)) {
  
                strbuf_release(&line);
                fclose(in);
 -
 -              if (found) {
 -                      rollback_lock_file(lock);
 -                      lock = NULL;
 -              }
        }
        else if (errno != ENOENT)
                die_errno("unable to read alternates file");
  
 -      if (lock) {
 +      if (found) {
 +              rollback_lock_file(&lock);
 +      } else {
                fprintf_or_die(out, "%s\n", reference);
 -              if (commit_lock_file(lock))
 +              if (commit_lock_file(&lock))
                        die_errno("unable to move new alternates file into place");
                if (alt_odb_tail)
                        link_alt_odb_entries(reference, '\n', NULL, 0);
@@@ -619,6 -631,7 +619,6 @@@ void prepare_alt_odb(void
                return;
  
        alt = getenv(ALTERNATE_DB_ENVIRONMENT);
 -      if (!alt) alt = "";
  
        alt_odb_tail = &alt_odb_list;
        link_alt_odb_entries(alt, PATH_SEP, NULL, 0);
@@@ -683,6 -696,213 +683,6 @@@ static int has_loose_object(const unsig
        return check_and_freshen(sha1, 0);
  }
  
 -static unsigned int pack_used_ctr;
 -static unsigned int pack_mmap_calls;
 -static unsigned int peak_pack_open_windows;
 -static unsigned int pack_open_windows;
 -static unsigned int pack_open_fds;
 -static unsigned int pack_max_fds;
 -static size_t peak_pack_mapped;
 -static size_t pack_mapped;
 -struct packed_git *packed_git;
 -
 -static struct mru packed_git_mru_storage;
 -struct mru *packed_git_mru = &packed_git_mru_storage;
 -
 -void pack_report(void)
 -{
 -      fprintf(stderr,
 -              "pack_report: getpagesize()            = %10" SZ_FMT "\n"
 -              "pack_report: core.packedGitWindowSize = %10" SZ_FMT "\n"
 -              "pack_report: core.packedGitLimit      = %10" SZ_FMT "\n",
 -              sz_fmt(getpagesize()),
 -              sz_fmt(packed_git_window_size),
 -              sz_fmt(packed_git_limit));
 -      fprintf(stderr,
 -              "pack_report: pack_used_ctr            = %10u\n"
 -              "pack_report: pack_mmap_calls          = %10u\n"
 -              "pack_report: pack_open_windows        = %10u / %10u\n"
 -              "pack_report: pack_mapped              = "
 -                      "%10" SZ_FMT " / %10" SZ_FMT "\n",
 -              pack_used_ctr,
 -              pack_mmap_calls,
 -              pack_open_windows, peak_pack_open_windows,
 -              sz_fmt(pack_mapped), sz_fmt(peak_pack_mapped));
 -}
 -
 -/*
 - * Open and mmap the index file at path, perform a couple of
 - * consistency checks, then record its information to p.  Return 0 on
 - * success.
 - */
 -static int check_packed_git_idx(const char *path, struct packed_git *p)
 -{
 -      void *idx_map;
 -      struct pack_idx_header *hdr;
 -      size_t idx_size;
 -      uint32_t version, nr, i, *index;
 -      int fd = git_open(path);
 -      struct stat st;
 -
 -      if (fd < 0)
 -              return -1;
 -      if (fstat(fd, &st)) {
 -              close(fd);
 -              return -1;
 -      }
 -      idx_size = xsize_t(st.st_size);
 -      if (idx_size < 4 * 256 + 20 + 20) {
 -              close(fd);
 -              return error("index file %s is too small", path);
 -      }
 -      idx_map = xmmap(NULL, idx_size, PROT_READ, MAP_PRIVATE, fd, 0);
 -      close(fd);
 -
 -      hdr = idx_map;
 -      if (hdr->idx_signature == htonl(PACK_IDX_SIGNATURE)) {
 -              version = ntohl(hdr->idx_version);
 -              if (version < 2 || version > 2) {
 -                      munmap(idx_map, idx_size);
 -                      return error("index file %s is version %"PRIu32
 -                                   " and is not supported by this binary"
 -                                   " (try upgrading GIT to a newer version)",
 -                                   path, version);
 -              }
 -      } else
 -              version = 1;
 -
 -      nr = 0;
 -      index = idx_map;
 -      if (version > 1)
 -              index += 2;  /* skip index header */
 -      for (i = 0; i < 256; i++) {
 -              uint32_t n = ntohl(index[i]);
 -              if (n < nr) {
 -                      munmap(idx_map, idx_size);
 -                      return error("non-monotonic index %s", path);
 -              }
 -              nr = n;
 -      }
 -
 -      if (version == 1) {
 -              /*
 -               * Total size:
 -               *  - 256 index entries 4 bytes each
 -               *  - 24-byte entries * nr (20-byte sha1 + 4-byte offset)
 -               *  - 20-byte SHA1 of the packfile
 -               *  - 20-byte SHA1 file checksum
 -               */
 -              if (idx_size != 4*256 + nr * 24 + 20 + 20) {
 -                      munmap(idx_map, idx_size);
 -                      return error("wrong index v1 file size in %s", path);
 -              }
 -      } else if (version == 2) {
 -              /*
 -               * Minimum size:
 -               *  - 8 bytes of header
 -               *  - 256 index entries 4 bytes each
 -               *  - 20-byte sha1 entry * nr
 -               *  - 4-byte crc entry * nr
 -               *  - 4-byte offset entry * nr
 -               *  - 20-byte SHA1 of the packfile
 -               *  - 20-byte SHA1 file checksum
 -               * And after the 4-byte offset table might be a
 -               * variable sized table containing 8-byte entries
 -               * for offsets larger than 2^31.
 -               */
 -              unsigned long min_size = 8 + 4*256 + nr*(20 + 4 + 4) + 20 + 20;
 -              unsigned long max_size = min_size;
 -              if (nr)
 -                      max_size += (nr - 1)*8;
 -              if (idx_size < min_size || idx_size > max_size) {
 -                      munmap(idx_map, idx_size);
 -                      return error("wrong index v2 file size in %s", path);
 -              }
 -              if (idx_size != min_size &&
 -                  /*
 -                   * make sure we can deal with large pack offsets.
 -                   * 31-bit signed offset won't be enough, neither
 -                   * 32-bit unsigned one will be.
 -                   */
 -                  (sizeof(off_t) <= 4)) {
 -                      munmap(idx_map, idx_size);
 -                      return error("pack too large for current definition of off_t in %s", path);
 -              }
 -      }
 -
 -      p->index_version = version;
 -      p->index_data = idx_map;
 -      p->index_size = idx_size;
 -      p->num_objects = nr;
 -      return 0;
 -}
 -
 -int open_pack_index(struct packed_git *p)
 -{
 -      char *idx_name;
 -      size_t len;
 -      int ret;
 -
 -      if (p->index_data)
 -              return 0;
 -
 -      if (!strip_suffix(p->pack_name, ".pack", &len))
 -              die("BUG: pack_name does not end in .pack");
 -      idx_name = xstrfmt("%.*s.idx", (int)len, p->pack_name);
 -      ret = check_packed_git_idx(idx_name, p);
 -      free(idx_name);
 -      return ret;
 -}
 -
 -static void scan_windows(struct packed_git *p,
 -      struct packed_git **lru_p,
 -      struct pack_window **lru_w,
 -      struct pack_window **lru_l)
 -{
 -      struct pack_window *w, *w_l;
 -
 -      for (w_l = NULL, w = p->windows; w; w = w->next) {
 -              if (!w->inuse_cnt) {
 -                      if (!*lru_w || w->last_used < (*lru_w)->last_used) {
 -                              *lru_p = p;
 -                              *lru_w = w;
 -                              *lru_l = w_l;
 -                      }
 -              }
 -              w_l = w;
 -      }
 -}
 -
 -static int unuse_one_window(struct packed_git *current)
 -{
 -      struct packed_git *p, *lru_p = NULL;
 -      struct pack_window *lru_w = NULL, *lru_l = NULL;
 -
 -      if (current)
 -              scan_windows(current, &lru_p, &lru_w, &lru_l);
 -      for (p = packed_git; p; p = p->next)
 -              scan_windows(p, &lru_p, &lru_w, &lru_l);
 -      if (lru_p) {
 -              munmap(lru_w->base, lru_w->len);
 -              pack_mapped -= lru_w->len;
 -              if (lru_l)
 -                      lru_l->next = lru_w->next;
 -              else
 -                      lru_p->windows = lru_w->next;
 -              free(lru_w);
 -              pack_open_windows--;
 -              return 1;
 -      }
 -      return 0;
 -}
 -
 -void release_pack_memory(size_t need)
 -{
 -      size_t cur = pack_mapped;
 -      while (need >= (cur - pack_mapped) && unuse_one_window(NULL))
 -              ; /* nothing */
 -}
 -
  static void mmap_limit_check(size_t length)
  {
        static size_t limit = 0;
@@@ -721,360 -941,1948 +721,360 @@@ void *xmmap(void *start, size_t length
        return ret;
  }
  
 -void close_pack_windows(struct packed_git *p)
 +/*
 + * With an in-core object data in "map", rehash it to make sure the
 + * object name actually matches "sha1" to detect object corruption.
 + * With "map" == NULL, try reading the object named with "sha1" using
 + * the streaming interface and rehash it to do the same.
 + */
 +int check_sha1_signature(const unsigned char *sha1, void *map,
 +                       unsigned long size, const char *type)
  {
 -      while (p->windows) {
 -              struct pack_window *w = p->windows;
 +      unsigned char real_sha1[20];
 +      enum object_type obj_type;
 +      struct git_istream *st;
 +      git_SHA_CTX c;
 +      char hdr[32];
 +      int hdrlen;
  
 -              if (w->inuse_cnt)
 -                      die("pack '%s' still has open windows to it",
 -                          p->pack_name);
 -              munmap(w->base, w->len);
 -              pack_mapped -= w->len;
 -              pack_open_windows--;
 -              p->windows = w->next;
 -              free(w);
 +      if (map) {
 +              hash_sha1_file(map, size, type, real_sha1);
 +              return hashcmp(sha1, real_sha1) ? -1 : 0;
        }
 -}
 -
 -static int close_pack_fd(struct packed_git *p)
 -{
 -      if (p->pack_fd < 0)
 -              return 0;
 -
 -      close(p->pack_fd);
 -      pack_open_fds--;
 -      p->pack_fd = -1;
 -
 -      return 1;
 -}
 -
 -static void close_pack(struct packed_git *p)
 -{
 -      close_pack_windows(p);
 -      close_pack_fd(p);
 -      close_pack_index(p);
 -}
 -
 -void close_all_packs(void)
 -{
 -      struct packed_git *p;
 -
 -      for (p = packed_git; p; p = p->next)
 -              if (p->do_not_close)
 -                      die("BUG: want to close pack marked 'do-not-close'");
 -              else
 -                      close_pack(p);
 -}
  
 +      st = open_istream(sha1, &obj_type, &size, NULL);
 +      if (!st)
 +              return -1;
  
 -/*
 - * The LRU pack is the one with the oldest MRU window, preferring packs
 - * with no used windows, or the oldest mtime if it has no windows allocated.
 - */
 -static void find_lru_pack(struct packed_git *p, struct packed_git **lru_p, struct pack_window **mru_w, int *accept_windows_inuse)
 -{
 -      struct pack_window *w, *this_mru_w;
 -      int has_windows_inuse = 0;
 +      /* Generate the header */
 +      hdrlen = xsnprintf(hdr, sizeof(hdr), "%s %lu", typename(obj_type), size) + 1;
  
 -      /*
 -       * Reject this pack if it has windows and the previously selected
 -       * one does not.  If this pack does not have windows, reject
 -       * it if the pack file is newer than the previously selected one.
 -       */
 -      if (*lru_p && !*mru_w && (p->windows || p->mtime > (*lru_p)->mtime))
 -              return;
 +      /* Sha1.. */
 +      git_SHA1_Init(&c);
 +      git_SHA1_Update(&c, hdr, hdrlen);
 +      for (;;) {
 +              char buf[1024 * 16];
 +              ssize_t readlen = read_istream(st, buf, sizeof(buf));
  
 -      for (w = this_mru_w = p->windows; w; w = w->next) {
 -              /*
 -               * Reject this pack if any of its windows are in use,
 -               * but the previously selected pack did not have any
 -               * inuse windows.  Otherwise, record that this pack
 -               * has windows in use.
 -               */
 -              if (w->inuse_cnt) {
 -                      if (*accept_windows_inuse)
 -                              has_windows_inuse = 1;
 -                      else
 -                              return;
 +              if (readlen < 0) {
 +                      close_istream(st);
 +                      return -1;
                }
 -
 -              if (w->last_used > this_mru_w->last_used)
 -                      this_mru_w = w;
 -
 -              /*
 -               * Reject this pack if it has windows that have been
 -               * used more recently than the previously selected pack.
 -               * If the previously selected pack had windows inuse and
 -               * we have not encountered a window in this pack that is
 -               * inuse, skip this check since we prefer a pack with no
 -               * inuse windows to one that has inuse windows.
 -               */
 -              if (*mru_w && *accept_windows_inuse == has_windows_inuse &&
 -                  this_mru_w->last_used > (*mru_w)->last_used)
 -                      return;
 +              if (!readlen)
 +                      break;
 +              git_SHA1_Update(&c, buf, readlen);
        }
 -
 -      /*
 -       * Select this pack.
 -       */
 -      *mru_w = this_mru_w;
 -      *lru_p = p;
 -      *accept_windows_inuse = has_windows_inuse;
 +      git_SHA1_Final(real_sha1, &c);
 +      close_istream(st);
 +      return hashcmp(sha1, real_sha1) ? -1 : 0;
  }
  
 -static int close_one_pack(void)
 +int git_open_cloexec(const char *name, int flags)
  {
 -      struct packed_git *p, *lru_p = NULL;
 -      struct pack_window *mru_w = NULL;
 -      int accept_windows_inuse = 1;
 +      int fd;
 +      static int o_cloexec = O_CLOEXEC;
  
 -      for (p = packed_git; p; p = p->next) {
 -              if (p->pack_fd == -1)
 -                      continue;
 -              find_lru_pack(p, &lru_p, &mru_w, &accept_windows_inuse);
 +      fd = open(name, flags | o_cloexec);
 +      if ((o_cloexec & O_CLOEXEC) && fd < 0 && errno == EINVAL) {
 +              /* Try again w/o O_CLOEXEC: the kernel might not support it */
 +              o_cloexec &= ~O_CLOEXEC;
 +              fd = open(name, flags | o_cloexec);
        }
  
 -      if (lru_p)
 -              return close_pack_fd(lru_p);
 -
 -      return 0;
 -}
 -
 -void unuse_pack(struct pack_window **w_cursor)
 -{
 -      struct pack_window *w = *w_cursor;
 -      if (w) {
 -              w->inuse_cnt--;
 -              *w_cursor = NULL;
 -      }
 -}
 +#if defined(F_GETFD) && defined(F_SETFD) && defined(FD_CLOEXEC)
 +      {
 +              static int fd_cloexec = FD_CLOEXEC;
  
 -void close_pack_index(struct packed_git *p)
 -{
 -      if (p->index_data) {
 -              munmap((void *)p->index_data, p->index_size);
 -              p->index_data = NULL;
 +              if (!o_cloexec && 0 <= fd && fd_cloexec) {
 +                      /* Opened w/o O_CLOEXEC?  try with fcntl(2) to add it */
 +                      int flags = fcntl(fd, F_GETFD);
 +                      if (fcntl(fd, F_SETFD, flags | fd_cloexec))
 +                              fd_cloexec = 0;
 +              }
        }
 +#endif
 +      return fd;
  }
  
 -static unsigned int get_max_fd_limit(void)
 +/*
 + * Find "sha1" as a loose object in the local repository or in an alternate.
 + * Returns 0 on success, negative on failure.
 + *
 + * The "path" out-parameter will give the path of the object we found (if any).
 + * Note that it may point to static storage and is only valid until another
 + * call to sha1_file_name(), etc.
 + */
 +static int stat_sha1_file(const unsigned char *sha1, struct stat *st,
 +                        const char **path)
  {
 -#ifdef RLIMIT_NOFILE
 -      {
 -              struct rlimit lim;
 +      struct alternate_object_database *alt;
  
 -              if (!getrlimit(RLIMIT_NOFILE, &lim))
 -                      return lim.rlim_cur;
 -      }
 -#endif
 +      *path = sha1_file_name(sha1);
 +      if (!lstat(*path, st))
 +              return 0;
  
 -#ifdef _SC_OPEN_MAX
 -      {
 -              long open_max = sysconf(_SC_OPEN_MAX);
 -              if (0 < open_max)
 -                      return open_max;
 -              /*
 -               * Otherwise, we got -1 for one of the two
 -               * reasons:
 -               *
 -               * (1) sysconf() did not understand _SC_OPEN_MAX
 -               *     and signaled an error with -1; or
 -               * (2) sysconf() said there is no limit.
 -               *
 -               * We _could_ clear errno before calling sysconf() to
 -               * tell these two cases apart and return a huge number
 -               * in the latter case to let the caller cap it to a
 -               * value that is not so selfish, but letting the
 -               * fallback OPEN_MAX codepath take care of these cases
 -               * is a lot simpler.
 -               */
 +      prepare_alt_odb();
 +      errno = ENOENT;
 +      for (alt = alt_odb_list; alt; alt = alt->next) {
 +              *path = alt_sha1_path(alt, sha1);
 +              if (!lstat(*path, st))
 +                      return 0;
        }
 -#endif
  
 -#ifdef OPEN_MAX
 -      return OPEN_MAX;
 -#else
 -      return 1; /* see the caller ;-) */
 -#endif
 +      return -1;
  }
  
  /*
 - * Do not call this directly as this leaks p->pack_fd on error return;
 - * call open_packed_git() instead.
 + * Like stat_sha1_file(), but actually open the object and return the
 + * descriptor. See the caveats on the "path" parameter above.
   */
 -static int open_packed_git_1(struct packed_git *p)
 +static int open_sha1_file(const unsigned char *sha1, const char **path)
  {
 -      struct stat st;
 -      struct pack_header hdr;
 -      unsigned char sha1[20];
 -      unsigned char *idx_sha1;
 -      long fd_flag;
 -
 -      if (!p->index_data && open_pack_index(p))
 -              return error("packfile %s index unavailable", p->pack_name);
 +      int fd;
 +      struct alternate_object_database *alt;
 +      int most_interesting_errno;
  
 -      if (!pack_max_fds) {
 -              unsigned int max_fds = get_max_fd_limit();
 +      *path = sha1_file_name(sha1);
 +      fd = git_open(*path);
 +      if (fd >= 0)
 +              return fd;
 +      most_interesting_errno = errno;
  
 -              /* Save 3 for stdin/stdout/stderr, 22 for work */
 -              if (25 < max_fds)
 -                      pack_max_fds = max_fds - 25;
 -              else
 -                      pack_max_fds = 1;
 +      prepare_alt_odb();
 +      for (alt = alt_odb_list; alt; alt = alt->next) {
 +              *path = alt_sha1_path(alt, sha1);
 +              fd = git_open(*path);
 +              if (fd >= 0)
 +                      return fd;
 +              if (most_interesting_errno == ENOENT)
 +                      most_interesting_errno = errno;
        }
 -
 -      while (pack_max_fds <= pack_open_fds && close_one_pack())
 -              ; /* nothing */
 -
 -      p->pack_fd = git_open(p->pack_name);
 -      if (p->pack_fd < 0 || fstat(p->pack_fd, &st))
 -              return -1;
 -      pack_open_fds++;
 -
 -      /* If we created the struct before we had the pack we lack size. */
 -      if (!p->pack_size) {
 -              if (!S_ISREG(st.st_mode))
 -                      return error("packfile %s not a regular file", p->pack_name);
 -              p->pack_size = st.st_size;
 -      } else if (p->pack_size != st.st_size)
 -              return error("packfile %s size changed", p->pack_name);
 -
 -      /* We leave these file descriptors open with sliding mmap;
 -       * there is no point keeping them open across exec(), though.
 -       */
 -      fd_flag = fcntl(p->pack_fd, F_GETFD, 0);
 -      if (fd_flag < 0)
 -              return error("cannot determine file descriptor flags");
 -      fd_flag |= FD_CLOEXEC;
 -      if (fcntl(p->pack_fd, F_SETFD, fd_flag) == -1)
 -              return error("cannot set FD_CLOEXEC");
 -
 -      /* Verify we recognize this pack file format. */
 -      if (read_in_full(p->pack_fd, &hdr, sizeof(hdr)) != sizeof(hdr))
 -              return error("file %s is far too short to be a packfile", p->pack_name);
 -      if (hdr.hdr_signature != htonl(PACK_SIGNATURE))
 -              return error("file %s is not a GIT packfile", p->pack_name);
 -      if (!pack_version_ok(hdr.hdr_version))
 -              return error("packfile %s is version %"PRIu32" and not"
 -                      " supported (try upgrading GIT to a newer version)",
 -                      p->pack_name, ntohl(hdr.hdr_version));
 -
 -      /* Verify the pack matches its index. */
 -      if (p->num_objects != ntohl(hdr.hdr_entries))
 -              return error("packfile %s claims to have %"PRIu32" objects"
 -                           " while index indicates %"PRIu32" objects",
 -                           p->pack_name, ntohl(hdr.hdr_entries),
 -                           p->num_objects);
 -      if (lseek(p->pack_fd, p->pack_size - sizeof(sha1), SEEK_SET) == -1)
 -              return error("end of packfile %s is unavailable", p->pack_name);
 -      if (read_in_full(p->pack_fd, sha1, sizeof(sha1)) != sizeof(sha1))
 -              return error("packfile %s signature is unavailable", p->pack_name);
 -      idx_sha1 = ((unsigned char *)p->index_data) + p->index_size - 40;
 -      if (hashcmp(sha1, idx_sha1))
 -              return error("packfile %s does not match index", p->pack_name);
 -      return 0;
 -}
 -
 -static int open_packed_git(struct packed_git *p)
 -{
 -      if (!open_packed_git_1(p))
 -              return 0;
 -      close_pack_fd(p);
 +      errno = most_interesting_errno;
        return -1;
  }
  
 -static int in_window(struct pack_window *win, off_t offset)
 +/*
 + * Map the loose object at "path" if it is not NULL, or the path found by
 + * searching for a loose object named "sha1".
 + */
 +static void *map_sha1_file_1(const char *path,
 +                           const unsigned char *sha1,
 +                           unsigned long *size)
  {
 -      /* We must promise at least 20 bytes (one hash) after the
 -       * offset is available from this window, otherwise the offset
 -       * is not actually in this window and a different window (which
 -       * has that one hash excess) must be used.  This is to support
 -       * the object header and delta base parsing routines below.
 -       */
 -      off_t win_off = win->offset;
 -      return win_off <= offset
 -              && (offset + 20) <= (win_off + win->len);
 -}
 -
 -unsigned char *use_pack(struct packed_git *p,
 -              struct pack_window **w_cursor,
 -              off_t offset,
 -              unsigned long *left)
 -{
 -      struct pack_window *win = *w_cursor;
 -
 -      /* Since packfiles end in a hash of their content and it's
 -       * pointless to ask for an offset into the middle of that
 -       * hash, and the in_window function above wouldn't match
 -       * don't allow an offset too close to the end of the file.
 -       */
 -      if (!p->pack_size && p->pack_fd == -1 && open_packed_git(p))
 -              die("packfile %s cannot be accessed", p->pack_name);
 -      if (offset > (p->pack_size - 20))
 -              die("offset beyond end of packfile (truncated pack?)");
 -      if (offset < 0)
 -              die(_("offset before end of packfile (broken .idx?)"));
 -
 -      if (!win || !in_window(win, offset)) {
 -              if (win)
 -                      win->inuse_cnt--;
 -              for (win = p->windows; win; win = win->next) {
 -                      if (in_window(win, offset))
 -                              break;
 -              }
 -              if (!win) {
 -                      size_t window_align = packed_git_window_size / 2;
 -                      off_t len;
 -
 -                      if (p->pack_fd == -1 && open_packed_git(p))
 -                              die("packfile %s cannot be accessed", p->pack_name);
 -
 -                      win = xcalloc(1, sizeof(*win));
 -                      win->offset = (offset / window_align) * window_align;
 -                      len = p->pack_size - win->offset;
 -                      if (len > packed_git_window_size)
 -                              len = packed_git_window_size;
 -                      win->len = (size_t)len;
 -                      pack_mapped += win->len;
 -                      while (packed_git_limit < pack_mapped
 -                              && unuse_one_window(p))
 -                              ; /* nothing */
 -                      win->base = xmmap(NULL, win->len,
 -                              PROT_READ, MAP_PRIVATE,
 -                              p->pack_fd, win->offset);
 -                      if (win->base == MAP_FAILED)
 -                              die_errno("packfile %s cannot be mapped",
 -                                        p->pack_name);
 -                      if (!win->offset && win->len == p->pack_size
 -                              && !p->do_not_close)
 -                              close_pack_fd(p);
 -                      pack_mmap_calls++;
 -                      pack_open_windows++;
 -                      if (pack_mapped > peak_pack_mapped)
 -                              peak_pack_mapped = pack_mapped;
 -                      if (pack_open_windows > peak_pack_open_windows)
 -                              peak_pack_open_windows = pack_open_windows;
 -                      win->next = p->windows;
 -                      p->windows = win;
 -              }
 -      }
 -      if (win != *w_cursor) {
 -              win->last_used = pack_used_ctr++;
 -              win->inuse_cnt++;
 -              *w_cursor = win;
 -      }
 -      offset -= win->offset;
 -      if (left)
 -              *left = win->len - xsize_t(offset);
 -      return win->base + offset;
 -}
 -
 -static struct packed_git *alloc_packed_git(int extra)
 -{
 -      struct packed_git *p = xmalloc(st_add(sizeof(*p), extra));
 -      memset(p, 0, sizeof(*p));
 -      p->pack_fd = -1;
 -      return p;
 -}
 -
 -static void try_to_free_pack_memory(size_t size)
 -{
 -      release_pack_memory(size);
 -}
 -
 -struct packed_git *add_packed_git(const char *path, size_t path_len, int local)
 -{
 -      static int have_set_try_to_free_routine;
 -      struct stat st;
 -      size_t alloc;
 -      struct packed_git *p;
 -
 -      if (!have_set_try_to_free_routine) {
 -              have_set_try_to_free_routine = 1;
 -              set_try_to_free_routine(try_to_free_pack_memory);
 -      }
 -
 -      /*
 -       * Make sure a corresponding .pack file exists and that
 -       * the index looks sane.
 -       */
 -      if (!strip_suffix_mem(path, &path_len, ".idx"))
 -              return NULL;
 -
 -      /*
 -       * ".pack" is long enough to hold any suffix we're adding (and
 -       * the use xsnprintf double-checks that)
 -       */
 -      alloc = st_add3(path_len, strlen(".pack"), 1);
 -      p = alloc_packed_git(alloc);
 -      memcpy(p->pack_name, path, path_len);
 -
 -      xsnprintf(p->pack_name + path_len, alloc - path_len, ".keep");
 -      if (!access(p->pack_name, F_OK))
 -              p->pack_keep = 1;
 -
 -      xsnprintf(p->pack_name + path_len, alloc - path_len, ".pack");
 -      if (stat(p->pack_name, &st) || !S_ISREG(st.st_mode)) {
 -              free(p);
 -              return NULL;
 -      }
 -
 -      /* ok, it looks sane as far as we can check without
 -       * actually mapping the pack file.
 -       */
 -      p->pack_size = st.st_size;
 -      p->pack_local = local;
 -      p->mtime = st.st_mtime;
 -      if (path_len < 40 || get_sha1_hex(path + path_len - 40, p->sha1))
 -              hashclr(p->sha1);
 -      return p;
 -}
 -
 -struct packed_git *parse_pack_index(unsigned char *sha1, const char *idx_path)
 -{
 -      const char *path = sha1_pack_name(sha1);
 -      size_t alloc = st_add(strlen(path), 1);
 -      struct packed_git *p = alloc_packed_git(alloc);
 -
 -      memcpy(p->pack_name, path, alloc); /* includes NUL */
 -      hashcpy(p->sha1, sha1);
 -      if (check_packed_git_idx(idx_path, p)) {
 -              free(p);
 -              return NULL;
 -      }
 -
 -      return p;
 -}
 -
 -void install_packed_git(struct packed_git *pack)
 -{
 -      if (pack->pack_fd != -1)
 -              pack_open_fds++;
 -
 -      pack->next = packed_git;
 -      packed_git = pack;
 -}
 -
 -void (*report_garbage)(unsigned seen_bits, const char *path);
 -
 -static void report_helper(const struct string_list *list,
 -                        int seen_bits, int first, int last)
 -{
 -      if (seen_bits == (PACKDIR_FILE_PACK|PACKDIR_FILE_IDX))
 -              return;
 -
 -      for (; first < last; first++)
 -              report_garbage(seen_bits, list->items[first].string);
 -}
 -
 -static void report_pack_garbage(struct string_list *list)
 -{
 -      int i, baselen = -1, first = 0, seen_bits = 0;
 -
 -      if (!report_garbage)
 -              return;
 -
 -      string_list_sort(list);
 -
 -      for (i = 0; i < list->nr; i++) {
 -              const char *path = list->items[i].string;
 -              if (baselen != -1 &&
 -                  strncmp(path, list->items[first].string, baselen)) {
 -                      report_helper(list, seen_bits, first, i);
 -                      baselen = -1;
 -                      seen_bits = 0;
 -              }
 -              if (baselen == -1) {
 -                      const char *dot = strrchr(path, '.');
 -                      if (!dot) {
 -                              report_garbage(PACKDIR_FILE_GARBAGE, path);
 -                              continue;
 -                      }
 -                      baselen = dot - path + 1;
 -                      first = i;
 -              }
 -              if (!strcmp(path + baselen, "pack"))
 -                      seen_bits |= 1;
 -              else if (!strcmp(path + baselen, "idx"))
 -                      seen_bits |= 2;
 -      }
 -      report_helper(list, seen_bits, first, list->nr);
 -}
 -
 -static void prepare_packed_git_one(char *objdir, int local)
 -{
 -      struct strbuf path = STRBUF_INIT;
 -      size_t dirnamelen;
 -      DIR *dir;
 -      struct dirent *de;
 -      struct string_list garbage = STRING_LIST_INIT_DUP;
 -
 -      strbuf_addstr(&path, objdir);
 -      strbuf_addstr(&path, "/pack");
 -      dir = opendir(path.buf);
 -      if (!dir) {
 -              if (errno != ENOENT)
 -                      error_errno("unable to open object pack directory: %s",
 -                                  path.buf);
 -              strbuf_release(&path);
 -              return;
 -      }
 -      strbuf_addch(&path, '/');
 -      dirnamelen = path.len;
 -      while ((de = readdir(dir)) != NULL) {
 -              struct packed_git *p;
 -              size_t base_len;
 -
 -              if (is_dot_or_dotdot(de->d_name))
 -                      continue;
 -
 -              strbuf_setlen(&path, dirnamelen);
 -              strbuf_addstr(&path, de->d_name);
 -
 -              base_len = path.len;
 -              if (strip_suffix_mem(path.buf, &base_len, ".idx")) {
 -                      /* Don't reopen a pack we already have. */
 -                      for (p = packed_git; p; p = p->next) {
 -                              size_t len;
 -                              if (strip_suffix(p->pack_name, ".pack", &len) &&
 -                                  len == base_len &&
 -                                  !memcmp(p->pack_name, path.buf, len))
 -                                      break;
 -                      }
 -                      if (p == NULL &&
 -                          /*
 -                           * See if it really is a valid .idx file with
 -                           * corresponding .pack file that we can map.
 -                           */
 -                          (p = add_packed_git(path.buf, path.len, local)) != NULL)
 -                              install_packed_git(p);
 -              }
 -
 -              if (!report_garbage)
 -                      continue;
 -
 -              if (ends_with(de->d_name, ".idx") ||
 -                  ends_with(de->d_name, ".pack") ||
 -                  ends_with(de->d_name, ".bitmap") ||
 -                  ends_with(de->d_name, ".keep"))
 -                      string_list_append(&garbage, path.buf);
 -              else
 -                      report_garbage(PACKDIR_FILE_GARBAGE, path.buf);
 -      }
 -      closedir(dir);
 -      report_pack_garbage(&garbage);
 -      string_list_clear(&garbage, 0);
 -      strbuf_release(&path);
 -}
 -
 -static int approximate_object_count_valid;
 -
 -/*
 - * Give a fast, rough count of the number of objects in the repository. This
 - * ignores loose objects completely. If you have a lot of them, then either
 - * you should repack because your performance will be awful, or they are
 - * all unreachable objects about to be pruned, in which case they're not really
 - * interesting as a measure of repo size in the first place.
 - */
 -unsigned long approximate_object_count(void)
 -{
 -      static unsigned long count;
 -      if (!approximate_object_count_valid) {
 -              struct packed_git *p;
 -
 -              prepare_packed_git();
 -              count = 0;
 -              for (p = packed_git; p; p = p->next) {
 -                      if (open_pack_index(p))
 -                              continue;
 -                      count += p->num_objects;
 -              }
 -      }
 -      return count;
 -}
 -
 -static void *get_next_packed_git(const void *p)
 -{
 -      return ((const struct packed_git *)p)->next;
 -}
 -
 -static void set_next_packed_git(void *p, void *next)
 -{
 -      ((struct packed_git *)p)->next = next;
 -}
 -
 -static int sort_pack(const void *a_, const void *b_)
 -{
 -      const struct packed_git *a = a_;
 -      const struct packed_git *b = b_;
 -      int st;
 -
 -      /*
 -       * Local packs tend to contain objects specific to our
 -       * variant of the project than remote ones.  In addition,
 -       * remote ones could be on a network mounted filesystem.
 -       * Favor local ones for these reasons.
 -       */
 -      st = a->pack_local - b->pack_local;
 -      if (st)
 -              return -st;
 -
 -      /*
 -       * Younger packs tend to contain more recent objects,
 -       * and more recent objects tend to get accessed more
 -       * often.
 -       */
 -      if (a->mtime < b->mtime)
 -              return 1;
 -      else if (a->mtime == b->mtime)
 -              return 0;
 -      return -1;
 -}
 -
 -static void rearrange_packed_git(void)
 -{
 -      packed_git = llist_mergesort(packed_git, get_next_packed_git,
 -                                   set_next_packed_git, sort_pack);
 -}
 -
 -static void prepare_packed_git_mru(void)
 -{
 -      struct packed_git *p;
 -
 -      mru_clear(packed_git_mru);
 -      for (p = packed_git; p; p = p->next)
 -              mru_append(packed_git_mru, p);
 -}
 -
 -static int prepare_packed_git_run_once = 0;
 -void prepare_packed_git(void)
 -{
 -      struct alternate_object_database *alt;
 -
 -      if (prepare_packed_git_run_once)
 -              return;
 -      prepare_packed_git_one(get_object_directory(), 1);
 -      prepare_alt_odb();
 -      for (alt = alt_odb_list; alt; alt = alt->next)
 -              prepare_packed_git_one(alt->path, 0);
 -      rearrange_packed_git();
 -      prepare_packed_git_mru();
 -      prepare_packed_git_run_once = 1;
 -}
 -
 -void reprepare_packed_git(void)
 -{
 -      approximate_object_count_valid = 0;
 -      prepare_packed_git_run_once = 0;
 -      prepare_packed_git();
 -}
 -
 -static void mark_bad_packed_object(struct packed_git *p,
 -                                 const unsigned char *sha1)
 -{
 -      unsigned i;
 -      for (i = 0; i < p->num_bad_objects; i++)
 -              if (!hashcmp(sha1, p->bad_object_sha1 + GIT_SHA1_RAWSZ * i))
 -                      return;
 -      p->bad_object_sha1 = xrealloc(p->bad_object_sha1,
 -                                    st_mult(GIT_MAX_RAWSZ,
 -                                            st_add(p->num_bad_objects, 1)));
 -      hashcpy(p->bad_object_sha1 + GIT_SHA1_RAWSZ * p->num_bad_objects, sha1);
 -      p->num_bad_objects++;
 -}
 -
 -static const struct packed_git *has_packed_and_bad(const unsigned char *sha1)
 -{
 -      struct packed_git *p;
 -      unsigned i;
 -
 -      for (p = packed_git; p; p = p->next)
 -              for (i = 0; i < p->num_bad_objects; i++)
 -                      if (!hashcmp(sha1, p->bad_object_sha1 + 20 * i))
 -                              return p;
 -      return NULL;
 -}
 -
 -/*
 - * With an in-core object data in "map", rehash it to make sure the
 - * object name actually matches "sha1" to detect object corruption.
 - * With "map" == NULL, try reading the object named with "sha1" using
 - * the streaming interface and rehash it to do the same.
 - */
 -int check_sha1_signature(const unsigned char *sha1, void *map,
 -                       unsigned long size, const char *type)
 -{
 -      unsigned char real_sha1[20];
 -      enum object_type obj_type;
 -      struct git_istream *st;
 -      git_SHA_CTX c;
 -      char hdr[32];
 -      int hdrlen;
 -
 -      if (map) {
 -              hash_sha1_file(map, size, type, real_sha1);
 -              return hashcmp(sha1, real_sha1) ? -1 : 0;
 -      }
 -
 -      st = open_istream(sha1, &obj_type, &size, NULL);
 -      if (!st)
 -              return -1;
 -
 -      /* Generate the header */
 -      hdrlen = xsnprintf(hdr, sizeof(hdr), "%s %lu", typename(obj_type), size) + 1;
 -
 -      /* Sha1.. */
 -      git_SHA1_Init(&c);
 -      git_SHA1_Update(&c, hdr, hdrlen);
 -      for (;;) {
 -              char buf[1024 * 16];
 -              ssize_t readlen = read_istream(st, buf, sizeof(buf));
 -
 -              if (readlen < 0) {
 -                      close_istream(st);
 -                      return -1;
 -              }
 -              if (!readlen)
 -                      break;
 -              git_SHA1_Update(&c, buf, readlen);
 -      }
 -      git_SHA1_Final(real_sha1, &c);
 -      close_istream(st);
 -      return hashcmp(sha1, real_sha1) ? -1 : 0;
 -}
 -
 -int git_open_cloexec(const char *name, int flags)
 -{
 -      int fd;
 -      static int o_cloexec = O_CLOEXEC;
 -
 -      fd = open(name, flags | o_cloexec);
 -      if ((o_cloexec & O_CLOEXEC) && fd < 0 && errno == EINVAL) {
 -              /* Try again w/o O_CLOEXEC: the kernel might not support it */
 -              o_cloexec &= ~O_CLOEXEC;
 -              fd = open(name, flags | o_cloexec);
 -      }
 -
 -#if defined(F_GETFD) && defined(F_SETFD) && defined(FD_CLOEXEC)
 -      {
 -              static int fd_cloexec = FD_CLOEXEC;
 -
 -              if (!o_cloexec && 0 <= fd && fd_cloexec) {
 -                      /* Opened w/o O_CLOEXEC?  try with fcntl(2) to add it */
 -                      int flags = fcntl(fd, F_GETFD);
 -                      if (fcntl(fd, F_SETFD, flags | fd_cloexec))
 -                              fd_cloexec = 0;
 -              }
 -      }
 -#endif
 -      return fd;
 -}
 -
 -/*
 - * Find "sha1" as a loose object in the local repository or in an alternate.
 - * Returns 0 on success, negative on failure.
 - *
 - * The "path" out-parameter will give the path of the object we found (if any).
 - * Note that it may point to static storage and is only valid until another
 - * call to sha1_file_name(), etc.
 - */
 -static int stat_sha1_file(const unsigned char *sha1, struct stat *st,
 -                        const char **path)
 -{
 -      struct alternate_object_database *alt;
 -
 -      *path = sha1_file_name(sha1);
 -      if (!lstat(*path, st))
 -              return 0;
 -
 -      prepare_alt_odb();
 -      errno = ENOENT;
 -      for (alt = alt_odb_list; alt; alt = alt->next) {
 -              *path = alt_sha1_path(alt, sha1);
 -              if (!lstat(*path, st))
 -                      return 0;
 -      }
 -
 -      return -1;
 -}
 -
 -/*
 - * Like stat_sha1_file(), but actually open the object and return the
 - * descriptor. See the caveats on the "path" parameter above.
 - */
 -static int open_sha1_file(const unsigned char *sha1, const char **path)
 -{
 -      int fd;
 -      struct alternate_object_database *alt;
 -      int most_interesting_errno;
 -
 -      *path = sha1_file_name(sha1);
 -      fd = git_open(*path);
 -      if (fd >= 0)
 -              return fd;
 -      most_interesting_errno = errno;
 -
 -      prepare_alt_odb();
 -      for (alt = alt_odb_list; alt; alt = alt->next) {
 -              *path = alt_sha1_path(alt, sha1);
 -              fd = git_open(*path);
 -              if (fd >= 0)
 -                      return fd;
 -              if (most_interesting_errno == ENOENT)
 -                      most_interesting_errno = errno;
 -      }
 -      errno = most_interesting_errno;
 -      return -1;
 -}
 -
 -/*
 - * Map the loose object at "path" if it is not NULL, or the path found by
 - * searching for a loose object named "sha1".
 - */
 -static void *map_sha1_file_1(const char *path,
 -                           const unsigned char *sha1,
 -                           unsigned long *size)
 -{
 -      void *map;
 -      int fd;
 -
 -      if (path)
 -              fd = git_open(path);
 -      else
 -              fd = open_sha1_file(sha1, &path);
 -      map = NULL;
 -      if (fd >= 0) {
 -              struct stat st;
 -
 -              if (!fstat(fd, &st)) {
 -                      *size = xsize_t(st.st_size);
 -                      if (!*size) {
 -                              /* mmap() is forbidden on empty files */
 -                              error("object file %s is empty", path);
 -                              return NULL;
 -                      }
 -                      map = xmmap(NULL, *size, PROT_READ, MAP_PRIVATE, fd, 0);
 -              }
 -              close(fd);
 -      }
 -      return map;
 -}
 -
 -void *map_sha1_file(const unsigned char *sha1, unsigned long *size)
 -{
 -      return map_sha1_file_1(NULL, sha1, size);
 -}
 -
 -unsigned long unpack_object_header_buffer(const unsigned char *buf,
 -              unsigned long len, enum object_type *type, unsigned long *sizep)
 -{
 -      unsigned shift;
 -      unsigned long size, c;
 -      unsigned long used = 0;
 -
 -      c = buf[used++];
 -      *type = (c >> 4) & 7;
 -      size = c & 15;
 -      shift = 4;
 -      while (c & 0x80) {
 -              if (len <= used || bitsizeof(long) <= shift) {
 -                      error("bad object header");
 -                      size = used = 0;
 -                      break;
 -              }
 -              c = buf[used++];
 -              size += (c & 0x7f) << shift;
 -              shift += 7;
 -      }
 -      *sizep = size;
 -      return used;
 -}
 -
 -static int unpack_sha1_short_header(git_zstream *stream,
 -                                  unsigned char *map, unsigned long mapsize,
 -                                  void *buffer, unsigned long bufsiz)
 -{
 -      /* Get the data stream */
 -      memset(stream, 0, sizeof(*stream));
 -      stream->next_in = map;
 -      stream->avail_in = mapsize;
 -      stream->next_out = buffer;
 -      stream->avail_out = bufsiz;
 -
 -      git_inflate_init(stream);
 -      return git_inflate(stream, 0);
 -}
 -
 -int unpack_sha1_header(git_zstream *stream,
 -                     unsigned char *map, unsigned long mapsize,
 -                     void *buffer, unsigned long bufsiz)
 -{
 -      int status = unpack_sha1_short_header(stream, map, mapsize,
 -                                            buffer, bufsiz);
 -
 -      if (status < Z_OK)
 -              return status;
 -
 -      /* Make sure we have the terminating NUL */
 -      if (!memchr(buffer, '\0', stream->next_out - (unsigned char *)buffer))
 -              return -1;
 -      return 0;
 -}
 -
 -static int unpack_sha1_header_to_strbuf(git_zstream *stream, unsigned char *map,
 -                                      unsigned long mapsize, void *buffer,
 -                                      unsigned long bufsiz, struct strbuf *header)
 -{
 -      int status;
 -
 -      status = unpack_sha1_short_header(stream, map, mapsize, buffer, bufsiz);
 -      if (status < Z_OK)
 -              return -1;
 -
 -      /*
 -       * Check if entire header is unpacked in the first iteration.
 -       */
 -      if (memchr(buffer, '\0', stream->next_out - (unsigned char *)buffer))
 -              return 0;
 -
 -      /*
 -       * buffer[0..bufsiz] was not large enough.  Copy the partial
 -       * result out to header, and then append the result of further
 -       * reading the stream.
 -       */
 -      strbuf_add(header, buffer, stream->next_out - (unsigned char *)buffer);
 -      stream->next_out = buffer;
 -      stream->avail_out = bufsiz;
 -
 -      do {
 -              status = git_inflate(stream, 0);
 -              strbuf_add(header, buffer, stream->next_out - (unsigned char *)buffer);
 -              if (memchr(buffer, '\0', stream->next_out - (unsigned char *)buffer))
 -                      return 0;
 -              stream->next_out = buffer;
 -              stream->avail_out = bufsiz;
 -      } while (status != Z_STREAM_END);
 -      return -1;
 -}
 -
 -static void *unpack_sha1_rest(git_zstream *stream, void *buffer, unsigned long size, const unsigned char *sha1)
 -{
 -      int bytes = strlen(buffer) + 1;
 -      unsigned char *buf = xmallocz(size);
 -      unsigned long n;
 -      int status = Z_OK;
 -
 -      n = stream->total_out - bytes;
 -      if (n > size)
 -              n = size;
 -      memcpy(buf, (char *) buffer + bytes, n);
 -      bytes = n;
 -      if (bytes <= size) {
 -              /*
 -               * The above condition must be (bytes <= size), not
 -               * (bytes < size).  In other words, even though we
 -               * expect no more output and set avail_out to zero,
 -               * the input zlib stream may have bytes that express
 -               * "this concludes the stream", and we *do* want to
 -               * eat that input.
 -               *
 -               * Otherwise we would not be able to test that we
 -               * consumed all the input to reach the expected size;
 -               * we also want to check that zlib tells us that all
 -               * went well with status == Z_STREAM_END at the end.
 -               */
 -              stream->next_out = buf + bytes;
 -              stream->avail_out = size - bytes;
 -              while (status == Z_OK)
 -                      status = git_inflate(stream, Z_FINISH);
 -      }
 -      if (status == Z_STREAM_END && !stream->avail_in) {
 -              git_inflate_end(stream);
 -              return buf;
 -      }
 -
 -      if (status < 0)
 -              error("corrupt loose object '%s'", sha1_to_hex(sha1));
 -      else if (stream->avail_in)
 -              error("garbage at end of loose object '%s'",
 -                    sha1_to_hex(sha1));
 -      free(buf);
 -      return NULL;
 -}
 -
 -/*
 - * We used to just use "sscanf()", but that's actually way
 - * too permissive for what we want to check. So do an anal
 - * object header parse by hand.
 - */
 -static int parse_sha1_header_extended(const char *hdr, struct object_info *oi,
 -                             unsigned int flags)
 -{
 -      const char *type_buf = hdr;
 -      unsigned long size;
 -      int type, type_len = 0;
 -
 -      /*
 -       * The type can be of any size but is followed by
 -       * a space.
 -       */
 -      for (;;) {
 -              char c = *hdr++;
 -              if (!c)
 -                      return -1;
 -              if (c == ' ')
 -                      break;
 -              type_len++;
 -      }
 -
 -      type = type_from_string_gently(type_buf, type_len, 1);
 -      if (oi->typename)
 -              strbuf_add(oi->typename, type_buf, type_len);
 -      /*
 -       * Set type to 0 if its an unknown object and
 -       * we're obtaining the type using '--allow-unknown-type'
 -       * option.
 -       */
 -      if ((flags & OBJECT_INFO_ALLOW_UNKNOWN_TYPE) && (type < 0))
 -              type = 0;
 -      else if (type < 0)
 -              die("invalid object type");
 -      if (oi->typep)
 -              *oi->typep = type;
 -
 -      /*
 -       * The length must follow immediately, and be in canonical
 -       * decimal format (ie "010" is not valid).
 -       */
 -      size = *hdr++ - '0';
 -      if (size > 9)
 -              return -1;
 -      if (size) {
 -              for (;;) {
 -                      unsigned long c = *hdr - '0';
 -                      if (c > 9)
 -                              break;
 -                      hdr++;
 -                      size = size * 10 + c;
 -              }
 -      }
 -
 -      if (oi->sizep)
 -              *oi->sizep = size;
 -
 -      /*
 -       * The length must be followed by a zero byte
 -       */
 -      return *hdr ? -1 : type;
 -}
 -
 -int parse_sha1_header(const char *hdr, unsigned long *sizep)
 -{
 -      struct object_info oi = OBJECT_INFO_INIT;
 -
 -      oi.sizep = sizep;
 -      return parse_sha1_header_extended(hdr, &oi, 0);
 -}
 -
 -unsigned long get_size_from_delta(struct packed_git *p,
 -                                struct pack_window **w_curs,
 -                                off_t curpos)
 -{
 -      const unsigned char *data;
 -      unsigned char delta_head[20], *in;
 -      git_zstream stream;
 -      int st;
 -
 -      memset(&stream, 0, sizeof(stream));
 -      stream.next_out = delta_head;
 -      stream.avail_out = sizeof(delta_head);
 -
 -      git_inflate_init(&stream);
 -      do {
 -              in = use_pack(p, w_curs, curpos, &stream.avail_in);
 -              stream.next_in = in;
 -              st = git_inflate(&stream, Z_FINISH);
 -              curpos += stream.next_in - in;
 -      } while ((st == Z_OK || st == Z_BUF_ERROR) &&
 -               stream.total_out < sizeof(delta_head));
 -      git_inflate_end(&stream);
 -      if ((st != Z_STREAM_END) && stream.total_out != sizeof(delta_head)) {
 -              error("delta data unpack-initial failed");
 -              return 0;
 -      }
 -
 -      /* Examine the initial part of the delta to figure out
 -       * the result size.
 -       */
 -      data = delta_head;
 -
 -      /* ignore base size */
 -      get_delta_hdr_size(&data, delta_head+sizeof(delta_head));
 -
 -      /* Read the result size */
 -      return get_delta_hdr_size(&data, delta_head+sizeof(delta_head));
 -}
 -
 -static off_t get_delta_base(struct packed_git *p,
 -                                  struct pack_window **w_curs,
 -                                  off_t *curpos,
 -                                  enum object_type type,
 -                                  off_t delta_obj_offset)
 -{
 -      unsigned char *base_info = use_pack(p, w_curs, *curpos, NULL);
 -      off_t base_offset;
 -
 -      /* use_pack() assured us we have [base_info, base_info + 20)
 -       * as a range that we can look at without walking off the
 -       * end of the mapped window.  Its actually the hash size
 -       * that is assured.  An OFS_DELTA longer than the hash size
 -       * is stupid, as then a REF_DELTA would be smaller to store.
 -       */
 -      if (type == OBJ_OFS_DELTA) {
 -              unsigned used = 0;
 -              unsigned char c = base_info[used++];
 -              base_offset = c & 127;
 -              while (c & 128) {
 -                      base_offset += 1;
 -                      if (!base_offset || MSB(base_offset, 7))
 -                              return 0;  /* overflow */
 -                      c = base_info[used++];
 -                      base_offset = (base_offset << 7) + (c & 127);
 -              }
 -              base_offset = delta_obj_offset - base_offset;
 -              if (base_offset <= 0 || base_offset >= delta_obj_offset)
 -                      return 0;  /* out of bound */
 -              *curpos += used;
 -      } else if (type == OBJ_REF_DELTA) {
 -              /* The base entry _must_ be in the same pack */
 -              base_offset = find_pack_entry_one(base_info, p);
 -              *curpos += 20;
 -      } else
 -              die("I am totally screwed");
 -      return base_offset;
 -}
 -
 -/*
 - * Like get_delta_base above, but we return the sha1 instead of the pack
 - * offset. This means it is cheaper for REF deltas (we do not have to do
 - * the final object lookup), but more expensive for OFS deltas (we
 - * have to load the revidx to convert the offset back into a sha1).
 - */
 -static const unsigned char *get_delta_base_sha1(struct packed_git *p,
 -                                              struct pack_window **w_curs,
 -                                              off_t curpos,
 -                                              enum object_type type,
 -                                              off_t delta_obj_offset)
 -{
 -      if (type == OBJ_REF_DELTA) {
 -              unsigned char *base = use_pack(p, w_curs, curpos, NULL);
 -              return base;
 -      } else if (type == OBJ_OFS_DELTA) {
 -              struct revindex_entry *revidx;
 -              off_t base_offset = get_delta_base(p, w_curs, &curpos,
 -                                                 type, delta_obj_offset);
 -
 -              if (!base_offset)
 -                      return NULL;
 -
 -              revidx = find_pack_revindex(p, base_offset);
 -              if (!revidx)
 -                      return NULL;
 -
 -              return nth_packed_object_sha1(p, revidx->nr);
 -      } else
 -              return NULL;
 -}
 -
 -int unpack_object_header(struct packed_git *p,
 -                       struct pack_window **w_curs,
 -                       off_t *curpos,
 -                       unsigned long *sizep)
 -{
 -      unsigned char *base;
 -      unsigned long left;
 -      unsigned long used;
 -      enum object_type type;
 -
 -      /* use_pack() assures us we have [base, base + 20) available
 -       * as a range that we can look at.  (Its actually the hash
 -       * size that is assured.)  With our object header encoding
 -       * the maximum deflated object size is 2^137, which is just
 -       * insane, so we know won't exceed what we have been given.
 -       */
 -      base = use_pack(p, w_curs, *curpos, &left);
 -      used = unpack_object_header_buffer(base, left, &type, sizep);
 -      if (!used) {
 -              type = OBJ_BAD;
 -      } else
 -              *curpos += used;
 -
 -      return type;
 -}
 -
 -static int retry_bad_packed_offset(struct packed_git *p, off_t obj_offset)
 -{
 -      int type;
 -      struct revindex_entry *revidx;
 -      const unsigned char *sha1;
 -      revidx = find_pack_revindex(p, obj_offset);
 -      if (!revidx)
 -              return OBJ_BAD;
 -      sha1 = nth_packed_object_sha1(p, revidx->nr);
 -      mark_bad_packed_object(p, sha1);
 -      type = sha1_object_info(sha1, NULL);
 -      if (type <= OBJ_NONE)
 -              return OBJ_BAD;
 -      return type;
 -}
 -
 -#define POI_STACK_PREALLOC 64
 -
 -static enum object_type packed_to_object_type(struct packed_git *p,
 -                                            off_t obj_offset,
 -                                            enum object_type type,
 -                                            struct pack_window **w_curs,
 -                                            off_t curpos)
 -{
 -      off_t small_poi_stack[POI_STACK_PREALLOC];
 -      off_t *poi_stack = small_poi_stack;
 -      int poi_stack_nr = 0, poi_stack_alloc = POI_STACK_PREALLOC;
 -
 -      while (type == OBJ_OFS_DELTA || type == OBJ_REF_DELTA) {
 -              off_t base_offset;
 -              unsigned long size;
 -              /* Push the object we're going to leave behind */
 -              if (poi_stack_nr >= poi_stack_alloc && poi_stack == small_poi_stack) {
 -                      poi_stack_alloc = alloc_nr(poi_stack_nr);
 -                      ALLOC_ARRAY(poi_stack, poi_stack_alloc);
 -                      memcpy(poi_stack, small_poi_stack, sizeof(off_t)*poi_stack_nr);
 -              } else {
 -                      ALLOC_GROW(poi_stack, poi_stack_nr+1, poi_stack_alloc);
 -              }
 -              poi_stack[poi_stack_nr++] = obj_offset;
 -              /* If parsing the base offset fails, just unwind */
 -              base_offset = get_delta_base(p, w_curs, &curpos, type, obj_offset);
 -              if (!base_offset)
 -                      goto unwind;
 -              curpos = obj_offset = base_offset;
 -              type = unpack_object_header(p, w_curs, &curpos, &size);
 -              if (type <= OBJ_NONE) {
 -                      /* If getting the base itself fails, we first
 -                       * retry the base, otherwise unwind */
 -                      type = retry_bad_packed_offset(p, base_offset);
 -                      if (type > OBJ_NONE)
 -                              goto out;
 -                      goto unwind;
 -              }
 -      }
 -
 -      switch (type) {
 -      case OBJ_BAD:
 -      case OBJ_COMMIT:
 -      case OBJ_TREE:
 -      case OBJ_BLOB:
 -      case OBJ_TAG:
 -              break;
 -      default:
 -              error("unknown object type %i at offset %"PRIuMAX" in %s",
 -                    type, (uintmax_t)obj_offset, p->pack_name);
 -              type = OBJ_BAD;
 -      }
 -
 -out:
 -      if (poi_stack != small_poi_stack)
 -              free(poi_stack);
 -      return type;
 -
 -unwind:
 -      while (poi_stack_nr) {
 -              obj_offset = poi_stack[--poi_stack_nr];
 -              type = retry_bad_packed_offset(p, obj_offset);
 -              if (type > OBJ_NONE)
 -                      goto out;
 -      }
 -      type = OBJ_BAD;
 -      goto out;
 -}
 -
 -static struct hashmap delta_base_cache;
 -static size_t delta_base_cached;
 -
 -static LIST_HEAD(delta_base_cache_lru);
 -
 -struct delta_base_cache_key {
 -      struct packed_git *p;
 -      off_t base_offset;
 -};
 -
 -struct delta_base_cache_entry {
 -      struct hashmap hash;
 -      struct delta_base_cache_key key;
 -      struct list_head lru;
 -      void *data;
 -      unsigned long size;
 -      enum object_type type;
 -};
 -
 -static unsigned int pack_entry_hash(struct packed_git *p, off_t base_offset)
 -{
 -      unsigned int hash;
 -
 -      hash = (unsigned int)(intptr_t)p + (unsigned int)base_offset;
 -      hash += (hash >> 8) + (hash >> 16);
 -      return hash;
 -}
 -
 -static struct delta_base_cache_entry *
 -get_delta_base_cache_entry(struct packed_git *p, off_t base_offset)
 -{
 -      struct hashmap_entry entry;
 -      struct delta_base_cache_key key;
 -
 -      if (!delta_base_cache.cmpfn)
 -              return NULL;
 -
 -      hashmap_entry_init(&entry, pack_entry_hash(p, base_offset));
 -      key.p = p;
 -      key.base_offset = base_offset;
 -      return hashmap_get(&delta_base_cache, &entry, &key);
 -}
 -
 -static int delta_base_cache_key_eq(const struct delta_base_cache_key *a,
 -                                 const struct delta_base_cache_key *b)
 -{
 -      return a->p == b->p && a->base_offset == b->base_offset;
 -}
 +      void *map;
 +      int fd;
  
 -static int delta_base_cache_hash_cmp(const void *unused_cmp_data,
 -                                   const void *va, const void *vb,
 -                                   const void *vkey)
 -{
 -      const struct delta_base_cache_entry *a = va, *b = vb;
 -      const struct delta_base_cache_key *key = vkey;
 -      if (key)
 -              return !delta_base_cache_key_eq(&a->key, key);
 +      if (path)
 +              fd = git_open(path);
        else
 -              return !delta_base_cache_key_eq(&a->key, &b->key);
 -}
 -
 -static int in_delta_base_cache(struct packed_git *p, off_t base_offset)
 -{
 -      return !!get_delta_base_cache_entry(p, base_offset);
 -}
 -
 -/*
 - * Remove the entry from the cache, but do _not_ free the associated
 - * entry data. The caller takes ownership of the "data" buffer, and
 - * should copy out any fields it wants before detaching.
 - */
 -static void detach_delta_base_cache_entry(struct delta_base_cache_entry *ent)
 -{
 -      hashmap_remove(&delta_base_cache, ent, &ent->key);
 -      list_del(&ent->lru);
 -      delta_base_cached -= ent->size;
 -      free(ent);
 -}
 -
 -static void *cache_or_unpack_entry(struct packed_git *p, off_t base_offset,
 -      unsigned long *base_size, enum object_type *type)
 -{
 -      struct delta_base_cache_entry *ent;
 -
 -      ent = get_delta_base_cache_entry(p, base_offset);
 -      if (!ent)
 -              return unpack_entry(p, base_offset, type, base_size);
 -
 -      if (type)
 -              *type = ent->type;
 -      if (base_size)
 -              *base_size = ent->size;
 -      return xmemdupz(ent->data, ent->size);
 -}
 -
 -static inline void release_delta_base_cache(struct delta_base_cache_entry *ent)
 -{
 -      free(ent->data);
 -      detach_delta_base_cache_entry(ent);
 -}
 -
 -void clear_delta_base_cache(void)
 -{
 -      struct list_head *lru, *tmp;
 -      list_for_each_safe(lru, tmp, &delta_base_cache_lru) {
 -              struct delta_base_cache_entry *entry =
 -                      list_entry(lru, struct delta_base_cache_entry, lru);
 -              release_delta_base_cache(entry);
 -      }
 -}
 -
 -static void add_delta_base_cache(struct packed_git *p, off_t base_offset,
 -      void *base, unsigned long base_size, enum object_type type)
 -{
 -      struct delta_base_cache_entry *ent = xmalloc(sizeof(*ent));
 -      struct list_head *lru, *tmp;
 -
 -      delta_base_cached += base_size;
 -
 -      list_for_each_safe(lru, tmp, &delta_base_cache_lru) {
 -              struct delta_base_cache_entry *f =
 -                      list_entry(lru, struct delta_base_cache_entry, lru);
 -              if (delta_base_cached <= delta_base_cache_limit)
 -                      break;
 -              release_delta_base_cache(f);
 -      }
 -
 -      ent->key.p = p;
 -      ent->key.base_offset = base_offset;
 -      ent->type = type;
 -      ent->data = base;
 -      ent->size = base_size;
 -      list_add_tail(&ent->lru, &delta_base_cache_lru);
 -
 -      if (!delta_base_cache.cmpfn)
 -              hashmap_init(&delta_base_cache, delta_base_cache_hash_cmp, NULL, 0);
 -      hashmap_entry_init(ent, pack_entry_hash(p, base_offset));
 -      hashmap_add(&delta_base_cache, ent);
 -}
 -
 -int packed_object_info(struct packed_git *p, off_t obj_offset,
 -                     struct object_info *oi)
 -{
 -      struct pack_window *w_curs = NULL;
 -      unsigned long size;
 -      off_t curpos = obj_offset;
 -      enum object_type type;
 -
 -      /*
 -       * We always get the representation type, but only convert it to
 -       * a "real" type later if the caller is interested.
 -       */
 -      if (oi->contentp) {
 -              *oi->contentp = cache_or_unpack_entry(p, obj_offset, oi->sizep,
 -                                                    &type);
 -              if (!*oi->contentp)
 -                      type = OBJ_BAD;
 -      } else {
 -              type = unpack_object_header(p, &w_curs, &curpos, &size);
 -      }
 -
 -      if (!oi->contentp && oi->sizep) {
 -              if (type == OBJ_OFS_DELTA || type == OBJ_REF_DELTA) {
 -                      off_t tmp_pos = curpos;
 -                      off_t base_offset = get_delta_base(p, &w_curs, &tmp_pos,
 -                                                         type, obj_offset);
 -                      if (!base_offset) {
 -                              type = OBJ_BAD;
 -                              goto out;
 -                      }
 -                      *oi->sizep = get_size_from_delta(p, &w_curs, tmp_pos);
 -                      if (*oi->sizep == 0) {
 -                              type = OBJ_BAD;
 -                              goto out;
 -                      }
 -              } else {
 -                      *oi->sizep = size;
 -              }
 -      }
 -
 -      if (oi->disk_sizep) {
 -              struct revindex_entry *revidx = find_pack_revindex(p, obj_offset);
 -              *oi->disk_sizep = revidx[1].offset - obj_offset;
 -      }
 -
 -      if (oi->typep || oi->typename) {
 -              enum object_type ptot;
 -              ptot = packed_to_object_type(p, obj_offset, type, &w_curs,
 -                                           curpos);
 -              if (oi->typep)
 -                      *oi->typep = ptot;
 -              if (oi->typename) {
 -                      const char *tn = typename(ptot);
 -                      if (tn)
 -                              strbuf_addstr(oi->typename, tn);
 -              }
 -              if (ptot < 0) {
 -                      type = OBJ_BAD;
 -                      goto out;
 -              }
 -      }
 -
 -      if (oi->delta_base_sha1) {
 -              if (type == OBJ_OFS_DELTA || type == OBJ_REF_DELTA) {
 -                      const unsigned char *base;
 -
 -                      base = get_delta_base_sha1(p, &w_curs, curpos,
 -                                                 type, obj_offset);
 -                      if (!base) {
 -                              type = OBJ_BAD;
 -                              goto out;
 -                      }
 -
 -                      hashcpy(oi->delta_base_sha1, base);
 -              } else
 -                      hashclr(oi->delta_base_sha1);
 -      }
 -
 -out:
 -      unuse_pack(&w_curs);
 -      return type;
 -}
 -
 -static void *unpack_compressed_entry(struct packed_git *p,
 -                                  struct pack_window **w_curs,
 -                                  off_t curpos,
 -                                  unsigned long size)
 -{
 -      int st;
 -      git_zstream stream;
 -      unsigned char *buffer, *in;
 -
 -      buffer = xmallocz_gently(size);
 -      if (!buffer)
 -              return NULL;
 -      memset(&stream, 0, sizeof(stream));
 -      stream.next_out = buffer;
 -      stream.avail_out = size + 1;
 -
 -      git_inflate_init(&stream);
 -      do {
 -              in = use_pack(p, w_curs, curpos, &stream.avail_in);
 -              stream.next_in = in;
 -              st = git_inflate(&stream, Z_FINISH);
 -              if (!stream.avail_out)
 -                      break; /* the payload is larger than it should be */
 -              curpos += stream.next_in - in;
 -      } while (st == Z_OK || st == Z_BUF_ERROR);
 -      git_inflate_end(&stream);
 -      if ((st != Z_STREAM_END) || stream.total_out != size) {
 -              free(buffer);
 -              return NULL;
 -      }
 -
 -      return buffer;
 -}
 -
 -static void *read_object(const unsigned char *sha1, enum object_type *type,
 -                       unsigned long *size);
 -
 -static void write_pack_access_log(struct packed_git *p, off_t obj_offset)
 -{
 -      static struct trace_key pack_access = TRACE_KEY_INIT(PACK_ACCESS);
 -      trace_printf_key(&pack_access, "%s %"PRIuMAX"\n",
 -                       p->pack_name, (uintmax_t)obj_offset);
 -}
 -
 -int do_check_packed_object_crc;
 -
 -#define UNPACK_ENTRY_STACK_PREALLOC 64
 -struct unpack_entry_stack_ent {
 -      off_t obj_offset;
 -      off_t curpos;
 -      unsigned long size;
 -};
 -
 -void *unpack_entry(struct packed_git *p, off_t obj_offset,
 -                 enum object_type *final_type, unsigned long *final_size)
 -{
 -      struct pack_window *w_curs = NULL;
 -      off_t curpos = obj_offset;
 -      void *data = NULL;
 -      unsigned long size;
 -      enum object_type type;
 -      struct unpack_entry_stack_ent small_delta_stack[UNPACK_ENTRY_STACK_PREALLOC];
 -      struct unpack_entry_stack_ent *delta_stack = small_delta_stack;
 -      int delta_stack_nr = 0, delta_stack_alloc = UNPACK_ENTRY_STACK_PREALLOC;
 -      int base_from_cache = 0;
 -
 -      write_pack_access_log(p, obj_offset);
 -
 -      /* PHASE 1: drill down to the innermost base object */
 -      for (;;) {
 -              off_t base_offset;
 -              int i;
 -              struct delta_base_cache_entry *ent;
 -
 -              ent = get_delta_base_cache_entry(p, curpos);
 -              if (ent) {
 -                      type = ent->type;
 -                      data = ent->data;
 -                      size = ent->size;
 -                      detach_delta_base_cache_entry(ent);
 -                      base_from_cache = 1;
 -                      break;
 -              }
 -
 -              if (do_check_packed_object_crc && p->index_version > 1) {
 -                      struct revindex_entry *revidx = find_pack_revindex(p, obj_offset);
 -                      off_t len = revidx[1].offset - obj_offset;
 -                      if (check_pack_crc(p, &w_curs, obj_offset, len, revidx->nr)) {
 -                              const unsigned char *sha1 =
 -                                      nth_packed_object_sha1(p, revidx->nr);
 -                              error("bad packed object CRC for %s",
 -                                    sha1_to_hex(sha1));
 -                              mark_bad_packed_object(p, sha1);
 -                              data = NULL;
 -                              goto out;
 -                      }
 -              }
 -
 -              type = unpack_object_header(p, &w_curs, &curpos, &size);
 -              if (type != OBJ_OFS_DELTA && type != OBJ_REF_DELTA)
 -                      break;
 -
 -              base_offset = get_delta_base(p, &w_curs, &curpos, type, obj_offset);
 -              if (!base_offset) {
 -                      error("failed to validate delta base reference "
 -                            "at offset %"PRIuMAX" from %s",
 -                            (uintmax_t)curpos, p->pack_name);
 -                      /* bail to phase 2, in hopes of recovery */
 -                      data = NULL;
 -                      break;
 -              }
 -
 -              /* push object, proceed to base */
 -              if (delta_stack_nr >= delta_stack_alloc
 -                  && delta_stack == small_delta_stack) {
 -                      delta_stack_alloc = alloc_nr(delta_stack_nr);
 -                      ALLOC_ARRAY(delta_stack, delta_stack_alloc);
 -                      memcpy(delta_stack, small_delta_stack,
 -                             sizeof(*delta_stack)*delta_stack_nr);
 -              } else {
 -                      ALLOC_GROW(delta_stack, delta_stack_nr+1, delta_stack_alloc);
 -              }
 -              i = delta_stack_nr++;
 -              delta_stack[i].obj_offset = obj_offset;
 -              delta_stack[i].curpos = curpos;
 -              delta_stack[i].size = size;
 -
 -              curpos = obj_offset = base_offset;
 -      }
 -
 -      /* PHASE 2: handle the base */
 -      switch (type) {
 -      case OBJ_OFS_DELTA:
 -      case OBJ_REF_DELTA:
 -              if (data)
 -                      die("BUG: unpack_entry: left loop at a valid delta");
 -              break;
 -      case OBJ_COMMIT:
 -      case OBJ_TREE:
 -      case OBJ_BLOB:
 -      case OBJ_TAG:
 -              if (!base_from_cache)
 -                      data = unpack_compressed_entry(p, &w_curs, curpos, size);
 -              break;
 -      default:
 -              data = NULL;
 -              error("unknown object type %i at offset %"PRIuMAX" in %s",
 -                    type, (uintmax_t)obj_offset, p->pack_name);
 -      }
 -
 -      /* PHASE 3: apply deltas in order */
 -
 -      /* invariants:
 -       *   'data' holds the base data, or NULL if there was corruption
 -       */
 -      while (delta_stack_nr) {
 -              void *delta_data;
 -              void *base = data;
 -              void *external_base = NULL;
 -              unsigned long delta_size, base_size = size;
 -              int i;
 -
 -              data = NULL;
 -
 -              if (base)
 -                      add_delta_base_cache(p, obj_offset, base, base_size, type);
 -
 -              if (!base) {
 -                      /*
 -                       * We're probably in deep shit, but let's try to fetch
 -                       * the required base anyway from another pack or loose.
 -                       * This is costly but should happen only in the presence
 -                       * of a corrupted pack, and is better than failing outright.
 -                       */
 -                      struct revindex_entry *revidx;
 -                      const unsigned char *base_sha1;
 -                      revidx = find_pack_revindex(p, obj_offset);
 -                      if (revidx) {
 -                              base_sha1 = nth_packed_object_sha1(p, revidx->nr);
 -                              error("failed to read delta base object %s"
 -                                    " at offset %"PRIuMAX" from %s",
 -                                    sha1_to_hex(base_sha1), (uintmax_t)obj_offset,
 -                                    p->pack_name);
 -                              mark_bad_packed_object(p, base_sha1);
 -                              base = read_object(base_sha1, &type, &base_size);
 -                              external_base = base;
 -                      }
 -              }
 -
 -              i = --delta_stack_nr;
 -              obj_offset = delta_stack[i].obj_offset;
 -              curpos = delta_stack[i].curpos;
 -              delta_size = delta_stack[i].size;
 -
 -              if (!base)
 -                      continue;
 -
 -              delta_data = unpack_compressed_entry(p, &w_curs, curpos, delta_size);
 -
 -              if (!delta_data) {
 -                      error("failed to unpack compressed delta "
 -                            "at offset %"PRIuMAX" from %s",
 -                            (uintmax_t)curpos, p->pack_name);
 -                      data = NULL;
 -                      free(external_base);
 -                      continue;
 -              }
 -
 -              data = patch_delta(base, base_size,
 -                                 delta_data, delta_size,
 -                                 &size);
 -
 -              /*
 -               * We could not apply the delta; warn the user, but keep going.
 -               * Our failure will be noticed either in the next iteration of
 -               * the loop, or if this is the final delta, in the caller when
 -               * we return NULL. Those code paths will take care of making
 -               * a more explicit warning and retrying with another copy of
 -               * the object.
 -               */
 -              if (!data)
 -                      error("failed to apply delta");
 -
 -              free(delta_data);
 -              free(external_base);
 -      }
 -
 -      if (final_type)
 -              *final_type = type;
 -      if (final_size)
 -              *final_size = size;
 -
 -out:
 -      unuse_pack(&w_curs);
 -
 -      if (delta_stack != small_delta_stack)
 -              free(delta_stack);
 -
 -      return data;
 -}
 +              fd = open_sha1_file(sha1, &path);
 +      map = NULL;
 +      if (fd >= 0) {
 +              struct stat st;
  
 -const unsigned char *nth_packed_object_sha1(struct packed_git *p,
 -                                          uint32_t n)
 -{
 -      const unsigned char *index = p->index_data;
 -      if (!index) {
 -              if (open_pack_index(p))
 -                      return NULL;
 -              index = p->index_data;
 -      }
 -      if (n >= p->num_objects)
 -              return NULL;
 -      index += 4 * 256;
 -      if (p->index_version == 1) {
 -              return index + 24 * n + 4;
 -      } else {
 -              index += 8;
 -              return index + 20 * n;
 +              if (!fstat(fd, &st)) {
 +                      *size = xsize_t(st.st_size);
 +                      if (!*size) {
 +                              /* mmap() is forbidden on empty files */
 +                              error("object file %s is empty", path);
 +                              return NULL;
 +                      }
 +                      map = xmmap(NULL, *size, PROT_READ, MAP_PRIVATE, fd, 0);
 +              }
 +              close(fd);
        }
 +      return map;
  }
  
 -const struct object_id *nth_packed_object_oid(struct object_id *oid,
 -                                            struct packed_git *p,
 -                                            uint32_t n)
 +void *map_sha1_file(const unsigned char *sha1, unsigned long *size)
  {
 -      const unsigned char *hash = nth_packed_object_sha1(p, n);
 -      if (!hash)
 -              return NULL;
 -      hashcpy(oid->hash, hash);
 -      return oid;
 +      return map_sha1_file_1(NULL, sha1, size);
  }
  
 -void check_pack_index_ptr(const struct packed_git *p, const void *vptr)
 +static int unpack_sha1_short_header(git_zstream *stream,
 +                                  unsigned char *map, unsigned long mapsize,
 +                                  void *buffer, unsigned long bufsiz)
  {
 -      const unsigned char *ptr = vptr;
 -      const unsigned char *start = p->index_data;
 -      const unsigned char *end = start + p->index_size;
 -      if (ptr < start)
 -              die(_("offset before start of pack index for %s (corrupt index?)"),
 -                  p->pack_name);
 -      /* No need to check for underflow; .idx files must be at least 8 bytes */
 -      if (ptr >= end - 8)
 -              die(_("offset beyond end of pack index for %s (truncated index?)"),
 -                  p->pack_name);
 -}
 +      /* Get the data stream */
 +      memset(stream, 0, sizeof(*stream));
 +      stream->next_in = map;
 +      stream->avail_in = mapsize;
 +      stream->next_out = buffer;
 +      stream->avail_out = bufsiz;
  
 -off_t nth_packed_object_offset(const struct packed_git *p, uint32_t n)
 -{
 -      const unsigned char *index = p->index_data;
 -      index += 4 * 256;
 -      if (p->index_version == 1) {
 -              return ntohl(*((uint32_t *)(index + 24 * n)));
 -      } else {
 -              uint32_t off;
 -              index += 8 + p->num_objects * (20 + 4);
 -              off = ntohl(*((uint32_t *)(index + 4 * n)));
 -              if (!(off & 0x80000000))
 -                      return off;
 -              index += p->num_objects * 4 + (off & 0x7fffffff) * 8;
 -              check_pack_index_ptr(p, index);
 -              return (((uint64_t)ntohl(*((uint32_t *)(index + 0)))) << 32) |
 -                                 ntohl(*((uint32_t *)(index + 4)));
 -      }
 +      git_inflate_init(stream);
 +      return git_inflate(stream, 0);
  }
  
 -off_t find_pack_entry_one(const unsigned char *sha1,
 -                                struct packed_git *p)
 +int unpack_sha1_header(git_zstream *stream,
 +                     unsigned char *map, unsigned long mapsize,
 +                     void *buffer, unsigned long bufsiz)
  {
 -      const uint32_t *level1_ofs = p->index_data;
 -      const unsigned char *index = p->index_data;
 -      unsigned hi, lo, stride;
 -      static int debug_lookup = -1;
 -
 -      if (debug_lookup < 0)
 -              debug_lookup = !!getenv("GIT_DEBUG_LOOKUP");
 +      int status = unpack_sha1_short_header(stream, map, mapsize,
 +                                            buffer, bufsiz);
  
 -      if (!index) {
 -              if (open_pack_index(p))
 -                      return 0;
 -              level1_ofs = p->index_data;
 -              index = p->index_data;
 -      }
 -      if (p->index_version > 1) {
 -              level1_ofs += 2;
 -              index += 8;
 -      }
 -      index += 4 * 256;
 -      hi = ntohl(level1_ofs[*sha1]);
 -      lo = ((*sha1 == 0x0) ? 0 : ntohl(level1_ofs[*sha1 - 1]));
 -      if (p->index_version > 1) {
 -              stride = 20;
 -      } else {
 -              stride = 24;
 -              index += 4;
 -      }
 +      if (status < Z_OK)
 +              return status;
  
 -      if (debug_lookup)
 -              printf("%02x%02x%02x... lo %u hi %u nr %"PRIu32"\n",
 -                     sha1[0], sha1[1], sha1[2], lo, hi, p->num_objects);
 -
 -      while (lo < hi) {
 -              unsigned mi = (lo + hi) / 2;
 -              int cmp = hashcmp(index + mi * stride, sha1);
 -
 -              if (debug_lookup)
 -                      printf("lo %u hi %u rg %u mi %u\n",
 -                             lo, hi, hi - lo, mi);
 -              if (!cmp)
 -                      return nth_packed_object_offset(p, mi);
 -              if (cmp > 0)
 -                      hi = mi;
 -              else
 -                      lo = mi+1;
 -      }
 +      /* Make sure we have the terminating NUL */
 +      if (!memchr(buffer, '\0', stream->next_out - (unsigned char *)buffer))
 +              return -1;
        return 0;
  }
  
 -int is_pack_valid(struct packed_git *p)
 +static int unpack_sha1_header_to_strbuf(git_zstream *stream, unsigned char *map,
 +                                      unsigned long mapsize, void *buffer,
 +                                      unsigned long bufsiz, struct strbuf *header)
  {
 -      /* An already open pack is known to be valid. */
 -      if (p->pack_fd != -1)
 -              return 1;
 +      int status;
 +
 +      status = unpack_sha1_short_header(stream, map, mapsize, buffer, bufsiz);
 +      if (status < Z_OK)
 +              return -1;
  
 -      /* If the pack has one window completely covering the
 -       * file size, the pack is known to be valid even if
 -       * the descriptor is not currently open.
 +      /*
 +       * Check if entire header is unpacked in the first iteration.
         */
 -      if (p->windows) {
 -              struct pack_window *w = p->windows;
 +      if (memchr(buffer, '\0', stream->next_out - (unsigned char *)buffer))
 +              return 0;
  
 -              if (!w->offset && w->len == p->pack_size)
 -                      return 1;
 -      }
 +      /*
 +       * buffer[0..bufsiz] was not large enough.  Copy the partial
 +       * result out to header, and then append the result of further
 +       * reading the stream.
 +       */
 +      strbuf_add(header, buffer, stream->next_out - (unsigned char *)buffer);
 +      stream->next_out = buffer;
 +      stream->avail_out = bufsiz;
  
 -      /* Force the pack to open to prove its valid. */
 -      return !open_packed_git(p);
 +      do {
 +              status = git_inflate(stream, 0);
 +              strbuf_add(header, buffer, stream->next_out - (unsigned char *)buffer);
 +              if (memchr(buffer, '\0', stream->next_out - (unsigned char *)buffer))
 +                      return 0;
 +              stream->next_out = buffer;
 +              stream->avail_out = bufsiz;
 +      } while (status != Z_STREAM_END);
 +      return -1;
  }
  
 -static int fill_pack_entry(const unsigned char *sha1,
 -                         struct pack_entry *e,
 -                         struct packed_git *p)
 +static void *unpack_sha1_rest(git_zstream *stream, void *buffer, unsigned long size, const unsigned char *sha1)
  {
 -      off_t offset;
 +      int bytes = strlen(buffer) + 1;
 +      unsigned char *buf = xmallocz(size);
 +      unsigned long n;
 +      int status = Z_OK;
  
 -      if (p->num_bad_objects) {
 -              unsigned i;
 -              for (i = 0; i < p->num_bad_objects; i++)
 -                      if (!hashcmp(sha1, p->bad_object_sha1 + 20 * i))
 -                              return 0;
 +      n = stream->total_out - bytes;
 +      if (n > size)
 +              n = size;
 +      memcpy(buf, (char *) buffer + bytes, n);
 +      bytes = n;
 +      if (bytes <= size) {
 +              /*
 +               * The above condition must be (bytes <= size), not
 +               * (bytes < size).  In other words, even though we
 +               * expect no more output and set avail_out to zero,
 +               * the input zlib stream may have bytes that express
 +               * "this concludes the stream", and we *do* want to
 +               * eat that input.
 +               *
 +               * Otherwise we would not be able to test that we
 +               * consumed all the input to reach the expected size;
 +               * we also want to check that zlib tells us that all
 +               * went well with status == Z_STREAM_END at the end.
 +               */
 +              stream->next_out = buf + bytes;
 +              stream->avail_out = size - bytes;
 +              while (status == Z_OK)
 +                      status = git_inflate(stream, Z_FINISH);
 +      }
 +      if (status == Z_STREAM_END && !stream->avail_in) {
 +              git_inflate_end(stream);
 +              return buf;
        }
  
 -      offset = find_pack_entry_one(sha1, p);
 -      if (!offset)
 -              return 0;
 -
 -      /*
 -       * We are about to tell the caller where they can locate the
 -       * requested object.  We better make sure the packfile is
 -       * still here and can be accessed before supplying that
 -       * answer, as it may have been deleted since the index was
 -       * loaded!
 -       */
 -      if (!is_pack_valid(p))
 -              return 0;
 -      e->offset = offset;
 -      e->p = p;
 -      hashcpy(e->sha1, sha1);
 -      return 1;
 +      if (status < 0)
 +              error("corrupt loose object '%s'", sha1_to_hex(sha1));
 +      else if (stream->avail_in)
 +              error("garbage at end of loose object '%s'",
 +                    sha1_to_hex(sha1));
 +      free(buf);
 +      return NULL;
  }
  
  /*
 - * Iff a pack file contains the object named by sha1, return true and
 - * store its location to e.
 + * We used to just use "sscanf()", but that's actually way
 + * too permissive for what we want to check. So do an anal
 + * object header parse by hand.
   */
 -static int find_pack_entry(const unsigned char *sha1, struct pack_entry *e)
 +static int parse_sha1_header_extended(const char *hdr, struct object_info *oi,
 +                             unsigned int flags)
  {
 -      struct mru_entry *p;
 +      const char *type_buf = hdr;
 +      unsigned long size;
 +      int type, type_len = 0;
  
 -      prepare_packed_git();
 -      if (!packed_git)
 -              return 0;
 +      /*
 +       * The type can be of any size but is followed by
 +       * a space.
 +       */
 +      for (;;) {
 +              char c = *hdr++;
 +              if (!c)
 +                      return -1;
 +              if (c == ' ')
 +                      break;
 +              type_len++;
 +      }
  
 -      for (p = packed_git_mru->head; p; p = p->next) {
 -              if (fill_pack_entry(sha1, e, p->item)) {
 -                      mru_mark(packed_git_mru, p);
 -                      return 1;
 +      type = type_from_string_gently(type_buf, type_len, 1);
 +      if (oi->typename)
 +              strbuf_add(oi->typename, type_buf, type_len);
 +      /*
 +       * Set type to 0 if its an unknown object and
 +       * we're obtaining the type using '--allow-unknown-type'
 +       * option.
 +       */
 +      if ((flags & OBJECT_INFO_ALLOW_UNKNOWN_TYPE) && (type < 0))
 +              type = 0;
 +      else if (type < 0)
 +              die("invalid object type");
 +      if (oi->typep)
 +              *oi->typep = type;
 +
 +      /*
 +       * The length must follow immediately, and be in canonical
 +       * decimal format (ie "010" is not valid).
 +       */
 +      size = *hdr++ - '0';
 +      if (size > 9)
 +              return -1;
 +      if (size) {
 +              for (;;) {
 +                      unsigned long c = *hdr - '0';
 +                      if (c > 9)
 +                              break;
 +                      hdr++;
 +                      size = size * 10 + c;
                }
        }
 -      return 0;
 +
 +      if (oi->sizep)
 +              *oi->sizep = size;
 +
 +      /*
 +       * The length must be followed by a zero byte
 +       */
 +      return *hdr ? -1 : type;
  }
  
 -struct packed_git *find_sha1_pack(const unsigned char *sha1,
 -                                struct packed_git *packs)
 +int parse_sha1_header(const char *hdr, unsigned long *sizep)
  {
 -      struct packed_git *p;
 -
 -      for (p = packs; p; p = p->next) {
 -              if (find_pack_entry_one(sha1, p))
 -                      return p;
 -      }
 -      return NULL;
 +      struct object_info oi = OBJECT_INFO_INIT;
  
 +      oi.sizep = sizep;
 +      return parse_sha1_header_extended(hdr, &oi, 0);
  }
  
  static int sha1_loose_object_info(const unsigned char *sha1,
        if (oi->sizep == &size_scratch)
                oi->sizep = NULL;
        strbuf_release(&hdrbuf);
 +      oi->whence = OI_LOOSE;
        return (status < 0) ? status : 0;
  }
  
@@@ -1164,6 -2971,9 +1164,9 @@@ int sha1_object_info_extended(const uns
                                    lookup_replace_object(sha1) :
                                    sha1;
  
+       if (is_null_sha1(real))
+               return -1;
        if (!oi)
                oi = &blank_oi;
  
  
        if (!find_pack_entry(real, &e)) {
                /* Most likely it's a loose object. */
 -              if (!sha1_loose_object_info(real, oi, flags)) {
 -                      oi->whence = OI_LOOSE;
 +              if (!sha1_loose_object_info(real, oi, flags))
                        return 0;
 -              }
  
                /* Not a loose object; someone else may have just packed it. */
                if (flags & OBJECT_INFO_QUICK) {
        if (rtype < 0) {
                mark_bad_packed_object(e.p, real);
                return sha1_object_info_extended(real, oi, 0);
 -      } else if (in_delta_base_cache(e.p, e.offset)) {
 -              oi->whence = OI_DBCACHED;
 -      } else {
 -              oi->whence = OI_PACKED;
 +      } else if (oi->whence == OI_PACKED) {
                oi->u.packed.offset = e.offset;
                oi->u.packed.pack = e.p;
                oi->u.packed.is_delta = (rtype == OBJ_REF_DELTA ||
@@@ -1237,18 -3052,28 +1240,18 @@@ int sha1_object_info(const unsigned cha
        return type;
  }
  
 -static void *read_packed_sha1(const unsigned char *sha1,
 -                            enum object_type *type, unsigned long *size)
 +static void *read_object(const unsigned char *sha1, enum object_type *type,
 +                       unsigned long *size)
  {
 -      struct pack_entry e;
 -      void *data;
 +      struct object_info oi = OBJECT_INFO_INIT;
 +      void *content;
 +      oi.typep = type;
 +      oi.sizep = size;
 +      oi.contentp = &content;
  
 -      if (!find_pack_entry(sha1, &e))
 +      if (sha1_object_info_extended(sha1, &oi, 0) < 0)
                return NULL;
 -      data = cache_or_unpack_entry(e.p, e.offset, size, type);
 -      if (!data) {
 -              /*
 -               * We're probably in deep shit, but let's try to fetch
 -               * the required object anyway from another pack or loose.
 -               * This should happen only in the presence of a corrupted
 -               * pack, and is better than failing outright.
 -               */
 -              error("failed to read object %s at offset %"PRIuMAX" from %s",
 -                    sha1_to_hex(sha1), (uintmax_t)e.offset, e.p->pack_name);
 -              mark_bad_packed_object(e.p, sha1);
 -              data = read_object(sha1, type, size);
 -      }
 -      return data;
 +      return content;
  }
  
  int pretend_sha1_file(void *buf, unsigned long len, enum object_type type,
        return 0;
  }
  
 -static void *read_object(const unsigned char *sha1, enum object_type *type,
 -                       unsigned long *size)
 -{
 -      struct object_info oi = OBJECT_INFO_INIT;
 -      void *content;
 -      oi.typep = type;
 -      oi.sizep = size;
 -      oi.contentp = &content;
 -
 -      if (sha1_object_info_extended(sha1, &oi, 0) < 0)
 -              return NULL;
 -      return content;
 -}
 -
  /*
   * This function dies on corrupt objects; the callers who want to
   * deal with them should arrange to call read_object() and give error
@@@ -1587,7 -3426,7 +1590,7 @@@ int write_sha1_file(const void *buf, un
  }
  
  int hash_sha1_file_literally(const void *buf, unsigned long len, const char *type,
 -                           unsigned char *sha1, unsigned flags)
 +                           struct object_id *oid, unsigned flags)
  {
        char *header;
        int hdrlen, status = 0;
        /* type string, SP, %lu of the length plus NUL must fit this */
        hdrlen = strlen(type) + 32;
        header = xmalloc(hdrlen);
 -      write_sha1_file_prepare(buf, len, type, sha1, header, &hdrlen);
 +      write_sha1_file_prepare(buf, len, type, oid->hash, header, &hdrlen);
  
        if (!(flags & HASH_WRITE_OBJECT))
                goto cleanup;
 -      if (freshen_packed_object(sha1) || freshen_loose_object(sha1))
 +      if (freshen_packed_object(oid->hash) || freshen_loose_object(oid->hash))
                goto cleanup;
 -      status = write_loose_object(sha1, header, hdrlen, buf, len, 0);
 +      status = write_loose_object(oid->hash, header, hdrlen, buf, len, 0);
  
  cleanup:
        free(header);
@@@ -1619,7 -3458,7 +1622,7 @@@ int force_object_loose(const unsigned c
  
        if (has_loose_object(sha1))
                return 0;
 -      buf = read_packed_sha1(sha1, &type, &len);
 +      buf = read_object(sha1, &type, &len);
        if (!buf)
                return error("cannot read sha1_file for %s", sha1_to_hex(sha1));
        hdrlen = xsnprintf(hdr, sizeof(hdr), "%s %lu", typename(type), len) + 1;
        return ret;
  }
  
 -int has_pack_index(const unsigned char *sha1)
 -{
 -      struct stat st;
 -      if (stat(sha1_pack_index_name(sha1), &st))
 -              return 0;
 -      return 1;
 -}
 -
 -int has_sha1_pack(const unsigned char *sha1)
 -{
 -      struct pack_entry e;
 -      return find_pack_entry(sha1, &e);
 -}
 -
  int has_sha1_file_with_flags(const unsigned char *sha1, int flags)
  {
        if (!startup_info->have_repository)
@@@ -1675,7 -3528,7 +1678,7 @@@ static void check_tag(const void *buf, 
                die("corrupt tag");
  }
  
 -static int index_mem(unsigned char *sha1, void *buf, size_t size,
 +static int index_mem(struct object_id *oid, void *buf, size_t size,
                     enum object_type type,
                     const char *path, unsigned flags)
  {
        if ((type == OBJ_BLOB) && path) {
                struct strbuf nbuf = STRBUF_INIT;
                if (convert_to_git(&the_index, path, buf, size, &nbuf,
 -                                 write_object ? safe_crlf : SAFE_CRLF_FALSE)) {
 +                                 get_safe_crlf(flags))) {
                        buf = strbuf_detach(&nbuf, &size);
                        re_allocated = 1;
                }
        }
  
        if (write_object)
 -              ret = write_sha1_file(buf, size, typename(type), sha1);
 +              ret = write_sha1_file(buf, size, typename(type), oid->hash);
        else
 -              ret = hash_sha1_file(buf, size, typename(type), sha1);
 +              ret = hash_sha1_file(buf, size, typename(type), oid->hash);
        if (re_allocated)
                free(buf);
        return ret;
  }
  
 -static int index_stream_convert_blob(unsigned char *sha1, int fd,
 +static int index_stream_convert_blob(struct object_id *oid, int fd,
                                     const char *path, unsigned flags)
  {
        int ret;
        assert(would_convert_to_git_filter_fd(path));
  
        convert_to_git_filter_fd(&the_index, path, fd, &sbuf,
 -                               write_object ? safe_crlf : SAFE_CRLF_FALSE);
 +                               get_safe_crlf(flags));
  
        if (write_object)
                ret = write_sha1_file(sbuf.buf, sbuf.len, typename(OBJ_BLOB),
 -                                    sha1);
 +                                    oid->hash);
        else
                ret = hash_sha1_file(sbuf.buf, sbuf.len, typename(OBJ_BLOB),
 -                                   sha1);
 +                                   oid->hash);
        strbuf_release(&sbuf);
        return ret;
  }
  
 -static int index_pipe(unsigned char *sha1, int fd, enum object_type type,
 +static int index_pipe(struct object_id *oid, int fd, enum object_type type,
                      const char *path, unsigned flags)
  {
        struct strbuf sbuf = STRBUF_INIT;
        int ret;
  
        if (strbuf_read(&sbuf, fd, 4096) >= 0)
 -              ret = index_mem(sha1, sbuf.buf, sbuf.len, type, path, flags);
 +              ret = index_mem(oid, sbuf.buf, sbuf.len, type, path, flags);
        else
                ret = -1;
        strbuf_release(&sbuf);
  
  #define SMALL_FILE_SIZE (32*1024)
  
 -static int index_core(unsigned char *sha1, int fd, size_t size,
 +static int index_core(struct object_id *oid, int fd, size_t size,
                      enum object_type type, const char *path,
                      unsigned flags)
  {
        int ret;
  
        if (!size) {
 -              ret = index_mem(sha1, "", size, type, path, flags);
 +              ret = index_mem(oid, "", size, type, path, flags);
        } else if (size <= SMALL_FILE_SIZE) {
                char *buf = xmalloc(size);
 -              if (size == read_in_full(fd, buf, size))
 -                      ret = index_mem(sha1, buf, size, type, path, flags);
 +              ssize_t read_result = read_in_full(fd, buf, size);
 +              if (read_result < 0)
 +                      ret = error_errno("read error while indexing %s",
 +                                        path ? path : "<unknown>");
 +              else if (read_result != size)
 +                      ret = error("short read while indexing %s",
 +                                  path ? path : "<unknown>");
                else
 -                      ret = error_errno("short read");
 +                      ret = index_mem(oid, buf, size, type, path, flags);
                free(buf);
        } else {
                void *buf = xmmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);
 -              ret = index_mem(sha1, buf, size, type, path, flags);
 +              ret = index_mem(oid, buf, size, type, path, flags);
                munmap(buf, size);
        }
        return ret;
   * binary blobs, they generally do not want to get any conversion, and
   * callers should avoid this code path when filters are requested.
   */
 -static int index_stream(unsigned char *sha1, int fd, size_t size,
 +static int index_stream(struct object_id *oid, int fd, size_t size,
                        enum object_type type, const char *path,
                        unsigned flags)
  {
 -      return index_bulk_checkin(sha1, fd, size, type, path, flags);
 +      return index_bulk_checkin(oid->hash, fd, size, type, path, flags);
  }
  
 -int index_fd(unsigned char *sha1, int fd, struct stat *st,
 +int index_fd(struct object_id *oid, int fd, struct stat *st,
             enum object_type type, const char *path, unsigned flags)
  {
        int ret;
         * die() for large files.
         */
        if (type == OBJ_BLOB && path && would_convert_to_git_filter_fd(path))
 -              ret = index_stream_convert_blob(sha1, fd, path, flags);
 +              ret = index_stream_convert_blob(oid, fd, path, flags);
        else if (!S_ISREG(st->st_mode))
 -              ret = index_pipe(sha1, fd, type, path, flags);
 +              ret = index_pipe(oid, fd, type, path, flags);
        else if (st->st_size <= big_file_threshold || type != OBJ_BLOB ||
                 (path && would_convert_to_git(&the_index, path)))
 -              ret = index_core(sha1, fd, xsize_t(st->st_size), type, path,
 +              ret = index_core(oid, fd, xsize_t(st->st_size), type, path,
                                 flags);
        else
 -              ret = index_stream(sha1, fd, xsize_t(st->st_size), type, path,
 +              ret = index_stream(oid, fd, xsize_t(st->st_size), type, path,
                                   flags);
        close(fd);
        return ret;
  }
  
 -int index_path(unsigned char *sha1, const char *path, struct stat *st, unsigned flags)
 +int index_path(struct object_id *oid, const char *path, struct stat *st, unsigned flags)
  {
        int fd;
        struct strbuf sb = STRBUF_INIT;
 +      int rc = 0;
  
        switch (st->st_mode & S_IFMT) {
        case S_IFREG:
                fd = open(path, O_RDONLY);
                if (fd < 0)
                        return error_errno("open(\"%s\")", path);
 -              if (index_fd(sha1, fd, st, OBJ_BLOB, path, flags) < 0)
 +              if (index_fd(oid, fd, st, OBJ_BLOB, path, flags) < 0)
                        return error("%s: failed to insert into database",
                                     path);
                break;
                if (strbuf_readlink(&sb, path, st->st_size))
                        return error_errno("readlink(\"%s\")", path);
                if (!(flags & HASH_WRITE_OBJECT))
 -                      hash_sha1_file(sb.buf, sb.len, blob_type, sha1);
 -              else if (write_sha1_file(sb.buf, sb.len, blob_type, sha1))
 -                      return error("%s: failed to insert into database",
 -                                   path);
 +                      hash_sha1_file(sb.buf, sb.len, blob_type, oid->hash);
 +              else if (write_sha1_file(sb.buf, sb.len, blob_type, oid->hash))
 +                      rc = error("%s: failed to insert into database", path);
                strbuf_release(&sb);
                break;
        case S_IFDIR:
 -              return resolve_gitlink_ref(path, "HEAD", sha1);
 +              return resolve_gitlink_ref(path, "HEAD", oid);
        default:
                return error("%s: unsupported file type", path);
        }
 -      return 0;
 +      return rc;
  }
  
  int read_pack_header(int fd, struct pack_header *header)
@@@ -1895,7 -3743,6 +1898,7 @@@ int for_each_file_in_obj_subdir(unsigne
        DIR *dir;
        struct dirent *de;
        int r = 0;
 +      struct object_id oid;
  
        if (subdir_nr > 0xff)
                BUG("invalid loose object subdirectory: %x", subdir_nr);
                return r;
        }
  
 +      oid.hash[0] = subdir_nr;
 +
        while ((de = readdir(dir))) {
                if (is_dot_or_dotdot(de->d_name))
                        continue;
                strbuf_setlen(path, baselen);
                strbuf_addf(path, "/%s", de->d_name);
  
 -              if (strlen(de->d_name) == GIT_SHA1_HEXSZ - 2)  {
 -                      char hex[GIT_MAX_HEXSZ+1];
 -                      struct object_id oid;
 -
 -                      xsnprintf(hex, sizeof(hex), "%02x%s",
 -                                subdir_nr, de->d_name);
 -                      if (!get_oid_hex(hex, &oid)) {
 -                              if (obj_cb) {
 -                                      r = obj_cb(&oid, path->buf, data);
 -                                      if (r)
 -                                              break;
 -                              }
 -                              continue;
 +              if (strlen(de->d_name) == GIT_SHA1_HEXSZ - 2 &&
 +                  !hex_to_bytes(oid.hash + 1, de->d_name,
 +                                GIT_SHA1_RAWSZ - 1)) {
 +                      if (obj_cb) {
 +                              r = obj_cb(&oid, path->buf, data);
 +                              if (r)
 +                                      break;
                        }
 +                      continue;
                }
  
                if (cruft_cb) {
@@@ -2024,6 -3874,46 +2027,6 @@@ int for_each_loose_object(each_loose_ob
        return foreach_alt_odb(loose_from_alt_odb, &alt);
  }
  
 -static int for_each_object_in_pack(struct packed_git *p, each_packed_object_fn cb, void *data)
 -{
 -      uint32_t i;
 -      int r = 0;
 -
 -      for (i = 0; i < p->num_objects; i++) {
 -              struct object_id oid;
 -
 -              if (!nth_packed_object_oid(&oid, p, i))
 -                      return error("unable to get sha1 of object %u in %s",
 -                                   i, p->pack_name);
 -
 -              r = cb(&oid, p, i, data);
 -              if (r)
 -                      break;
 -      }
 -      return r;
 -}
 -
 -int for_each_packed_object(each_packed_object_fn cb, void *data, unsigned flags)
 -{
 -      struct packed_git *p;
 -      int r = 0;
 -      int pack_errors = 0;
 -
 -      prepare_packed_git();
 -      for (p = packed_git; p; p = p->next) {
 -              if ((flags & FOR_EACH_OBJECT_LOCAL_ONLY) && !p->pack_local)
 -                      continue;
 -              if (open_pack_index(p)) {
 -                      pack_errors = 1;
 -                      continue;
 -              }
 -              r = for_each_object_in_pack(p, cb, data);
 -              if (r)
 -                      break;
 -      }
 -      return r ? r : pack_errors;
 -}
 -
  static int check_stream_sha1(git_zstream *stream,
                             const char *hdr,
                             unsigned long size,