2 * GIT - The information manager from hell
4 * Copyright (C) Linus Torvalds, 2005
6 * This handles basic git sha1 object files - packing, unpacking,
10 #include "string-list.h"
16 #include "run-command.h"
19 #include "tree-walk.h"
21 #include "pack-revindex.h"
22 #include "sha1-lookup.h"
23 #include "bulk-checkin.h"
24 #include "streaming.h"
28 #include "mergesort.h"
31 #define SZ_FMT PRIuMAX
32 static inline uintmax_t sz_fmt(size_t s) { return s; }
34 const unsigned char null_sha1[20];
35 const struct object_id null_oid;
36 const struct object_id empty_tree_oid = {
37 EMPTY_TREE_SHA1_BIN_LITERAL
39 const struct object_id empty_blob_oid = {
40 EMPTY_BLOB_SHA1_BIN_LITERAL
44 * This is meant to hold a *small* number of objects that you would
45 * want read_sha1_file() to be able to return, but yet you do not want
46 * to write them into the object store (e.g. a browse-only
49 static struct cached_object {
50 unsigned char sha1[20];
51 enum object_type type;
55 static int cached_object_nr, cached_object_alloc;
57 static struct cached_object empty_tree = {
58 EMPTY_TREE_SHA1_BIN_LITERAL,
64 static struct cached_object *find_cached_object(const unsigned char *sha1)
67 struct cached_object *co = cached_objects;
69 for (i = 0; i < cached_object_nr; i++, co++) {
70 if (!hashcmp(co->sha1, sha1))
73 if (!hashcmp(sha1, empty_tree.sha1))
78 int mkdir_in_gitdir(const char *path)
80 if (mkdir(path, 0777)) {
81 int saved_errno = errno;
83 struct strbuf sb = STRBUF_INIT;
88 * Are we looking at a path in a symlinked worktree
89 * whose original repository does not yet have it?
90 * e.g. .git/rr-cache pointing at its original
91 * repository in which the user hasn't performed any
92 * conflict resolution yet?
94 if (lstat(path, &st) || !S_ISLNK(st.st_mode) ||
95 strbuf_readlink(&sb, path, st.st_size) ||
96 !is_absolute_path(sb.buf) ||
97 mkdir(sb.buf, 0777)) {
104 return adjust_shared_perm(path);
107 enum scld_error safe_create_leading_directories(char *path)
109 char *next_component = path + offset_1st_component(path);
110 enum scld_error ret = SCLD_OK;
112 while (ret == SCLD_OK && next_component) {
114 char *slash = next_component, slash_character;
116 while (*slash && !is_dir_sep(*slash))
122 next_component = slash + 1;
123 while (is_dir_sep(*next_component))
125 if (!*next_component)
128 slash_character = *slash;
130 if (!stat(path, &st)) {
132 if (!S_ISDIR(st.st_mode)) {
136 } else if (mkdir(path, 0777)) {
137 if (errno == EEXIST &&
138 !stat(path, &st) && S_ISDIR(st.st_mode))
139 ; /* somebody created it since we checked */
140 else if (errno == ENOENT)
142 * Either mkdir() failed because
143 * somebody just pruned the containing
144 * directory, or stat() failed because
145 * the file that was in our way was
146 * just removed. Either way, inform
147 * the caller that it might be worth
153 } else if (adjust_shared_perm(path)) {
156 *slash = slash_character;
161 enum scld_error safe_create_leading_directories_const(const char *path)
164 /* path points to cache entries, so xstrdup before messing with it */
165 char *buf = xstrdup(path);
166 enum scld_error result = safe_create_leading_directories(buf);
174 int raceproof_create_file(const char *path, create_file_fn fn, void *cb)
177 * The number of times we will try to remove empty directories
178 * in the way of path. This is only 1 because if another
179 * process is racily creating directories that conflict with
180 * us, we don't want to fight against them.
182 int remove_directories_remaining = 1;
185 * The number of times that we will try to create the
186 * directories containing path. We are willing to attempt this
187 * more than once, because another process could be trying to
188 * clean up empty directories at the same time as we are
189 * trying to create them.
191 int create_directories_remaining = 3;
193 /* A scratch copy of path, filled lazily if we need it: */
194 struct strbuf path_copy = STRBUF_INIT;
207 if (errno == EISDIR && remove_directories_remaining-- > 0) {
209 * A directory is in the way. Maybe it is empty; try
213 strbuf_addstr(&path_copy, path);
215 if (!remove_dir_recursively(&path_copy, REMOVE_DIR_EMPTY_ONLY))
217 } else if (errno == ENOENT && create_directories_remaining-- > 0) {
219 * Maybe the containing directory didn't exist, or
220 * maybe it was just deleted by a process that is
221 * racing with us to clean up empty directories. Try
224 enum scld_error scld_result;
227 strbuf_addstr(&path_copy, path);
230 scld_result = safe_create_leading_directories(path_copy.buf);
231 if (scld_result == SCLD_OK)
233 } while (scld_result == SCLD_VANISHED && create_directories_remaining-- > 0);
237 strbuf_release(&path_copy);
242 static void fill_sha1_path(struct strbuf *buf, const unsigned char *sha1)
245 for (i = 0; i < 20; i++) {
246 static char hex[] = "0123456789abcdef";
247 unsigned int val = sha1[i];
248 strbuf_addch(buf, hex[val >> 4]);
249 strbuf_addch(buf, hex[val & 0xf]);
251 strbuf_addch(buf, '/');
255 const char *sha1_file_name(const unsigned char *sha1)
257 static struct strbuf buf = STRBUF_INIT;
260 strbuf_addf(&buf, "%s/", get_object_directory());
262 fill_sha1_path(&buf, sha1);
266 struct strbuf *alt_scratch_buf(struct alternate_object_database *alt)
268 strbuf_setlen(&alt->scratch, alt->base_len);
269 return &alt->scratch;
272 static const char *alt_sha1_path(struct alternate_object_database *alt,
273 const unsigned char *sha1)
275 struct strbuf *buf = alt_scratch_buf(alt);
276 fill_sha1_path(buf, sha1);
281 * Return the name of the pack or index file with the specified sha1
282 * in its filename. *base and *name are scratch space that must be
283 * provided by the caller. which should be "pack" or "idx".
285 static char *sha1_get_pack_name(const unsigned char *sha1,
290 strbuf_addf(buf, "%s/pack/pack-%s.%s", get_object_directory(),
291 sha1_to_hex(sha1), which);
295 char *sha1_pack_name(const unsigned char *sha1)
297 static struct strbuf buf = STRBUF_INIT;
298 return sha1_get_pack_name(sha1, &buf, "pack");
301 char *sha1_pack_index_name(const unsigned char *sha1)
303 static struct strbuf buf = STRBUF_INIT;
304 return sha1_get_pack_name(sha1, &buf, "idx");
307 struct alternate_object_database *alt_odb_list;
308 static struct alternate_object_database **alt_odb_tail;
311 * Return non-zero iff the path is usable as an alternate object database.
313 static int alt_odb_usable(struct strbuf *path, const char *normalized_objdir)
315 struct alternate_object_database *alt;
317 /* Detect cases where alternate disappeared */
318 if (!is_directory(path->buf)) {
319 error("object directory %s does not exist; "
320 "check .git/objects/info/alternates.",
326 * Prevent the common mistake of listing the same
327 * thing twice, or object directory itself.
329 for (alt = alt_odb_list; alt; alt = alt->next) {
330 if (!fspathcmp(path->buf, alt->path))
333 if (!fspathcmp(path->buf, normalized_objdir))
340 * Prepare alternate object database registry.
342 * The variable alt_odb_list points at the list of struct
343 * alternate_object_database. The elements on this list come from
344 * non-empty elements from colon separated ALTERNATE_DB_ENVIRONMENT
345 * environment variable, and $GIT_OBJECT_DIRECTORY/info/alternates,
346 * whose contents is similar to that environment variable but can be
347 * LF separated. Its base points at a statically allocated buffer that
348 * contains "/the/directory/corresponding/to/.git/objects/...", while
349 * its name points just after the slash at the end of ".git/objects/"
350 * in the example above, and has enough space to hold 40-byte hex
351 * SHA1, an extra slash for the first level indirection, and the
354 static int link_alt_odb_entry(const char *entry, const char *relative_base,
355 int depth, const char *normalized_objdir)
357 struct alternate_object_database *ent;
358 struct strbuf pathbuf = STRBUF_INIT;
360 if (!is_absolute_path(entry) && relative_base) {
361 strbuf_realpath(&pathbuf, relative_base, 1);
362 strbuf_addch(&pathbuf, '/');
364 strbuf_addstr(&pathbuf, entry);
366 if (strbuf_normalize_path(&pathbuf) < 0 && relative_base) {
367 error("unable to normalize alternate object path: %s",
369 strbuf_release(&pathbuf);
374 * The trailing slash after the directory name is given by
375 * this function at the end. Remove duplicates.
377 while (pathbuf.len && pathbuf.buf[pathbuf.len - 1] == '/')
378 strbuf_setlen(&pathbuf, pathbuf.len - 1);
380 if (!alt_odb_usable(&pathbuf, normalized_objdir)) {
381 strbuf_release(&pathbuf);
385 ent = alloc_alt_odb(pathbuf.buf);
387 /* add the alternate entry */
389 alt_odb_tail = &(ent->next);
392 /* recursively add alternates */
393 read_info_alternates(pathbuf.buf, depth + 1);
395 strbuf_release(&pathbuf);
399 static const char *parse_alt_odb_entry(const char *string,
407 if (*string == '#') {
408 /* comment; consume up to next separator */
409 end = strchrnul(string, sep);
410 } else if (*string == '"' && !unquote_c_style(out, string, &end)) {
412 * quoted path; unquote_c_style has copied the
413 * data for us and set "end". Broken quoting (e.g.,
414 * an entry that doesn't end with a quote) falls
415 * back to the unquoted case below.
418 /* normal, unquoted path */
419 end = strchrnul(string, sep);
420 strbuf_add(out, string, end - string);
428 static void link_alt_odb_entries(const char *alt, int len, int sep,
429 const char *relative_base, int depth)
431 struct strbuf objdirbuf = STRBUF_INIT;
432 struct strbuf entry = STRBUF_INIT;
435 error("%s: ignoring alternate object stores, nesting too deep.",
440 strbuf_add_absolute_path(&objdirbuf, get_object_directory());
441 if (strbuf_normalize_path(&objdirbuf) < 0)
442 die("unable to normalize object directory: %s",
446 alt = parse_alt_odb_entry(alt, sep, &entry);
449 link_alt_odb_entry(entry.buf, relative_base, depth, objdirbuf.buf);
451 strbuf_release(&entry);
452 strbuf_release(&objdirbuf);
455 void read_info_alternates(const char * relative_base, int depth)
463 path = xstrfmt("%s/info/alternates", relative_base);
468 if (fstat(fd, &st) || (st.st_size == 0)) {
472 mapsz = xsize_t(st.st_size);
473 map = xmmap(NULL, mapsz, PROT_READ, MAP_PRIVATE, fd, 0);
476 link_alt_odb_entries(map, mapsz, '\n', relative_base, depth);
481 struct alternate_object_database *alloc_alt_odb(const char *dir)
483 struct alternate_object_database *ent;
485 FLEX_ALLOC_STR(ent, path, dir);
486 strbuf_init(&ent->scratch, 0);
487 strbuf_addf(&ent->scratch, "%s/", dir);
488 ent->base_len = ent->scratch.len;
493 void add_to_alternates_file(const char *reference)
495 struct lock_file *lock = xcalloc(1, sizeof(struct lock_file));
496 char *alts = git_pathdup("objects/info/alternates");
499 hold_lock_file_for_update(lock, alts, LOCK_DIE_ON_ERROR);
500 out = fdopen_lock_file(lock, "w");
502 die_errno("unable to fdopen alternates lockfile");
504 in = fopen(alts, "r");
506 struct strbuf line = STRBUF_INIT;
509 while (strbuf_getline(&line, in) != EOF) {
510 if (!strcmp(reference, line.buf)) {
514 fprintf_or_die(out, "%s\n", line.buf);
517 strbuf_release(&line);
521 rollback_lock_file(lock);
525 else if (errno != ENOENT)
526 die_errno("unable to read alternates file");
529 fprintf_or_die(out, "%s\n", reference);
530 if (commit_lock_file(lock))
531 die_errno("unable to move new alternates file into place");
533 link_alt_odb_entries(reference, strlen(reference), '\n', NULL, 0);
538 void add_to_alternates_memory(const char *reference)
541 * Make sure alternates are initialized, or else our entry may be
542 * overwritten when they are.
546 link_alt_odb_entries(reference, strlen(reference), '\n', NULL, 0);
550 * Compute the exact path an alternate is at and returns it. In case of
551 * error NULL is returned and the human readable error is added to `err`
552 * `path` may be relative and should point to $GITDIR.
553 * `err` must not be null.
555 char *compute_alternate_path(const char *path, struct strbuf *err)
557 char *ref_git = NULL;
558 const char *repo, *ref_git_s;
561 ref_git_s = real_path_if_valid(path);
564 strbuf_addf(err, _("path '%s' does not exist"), path);
568 * Beware: read_gitfile(), real_path() and mkpath()
569 * return static buffer
571 ref_git = xstrdup(ref_git_s);
573 repo = read_gitfile(ref_git);
575 repo = read_gitfile(mkpath("%s/.git", ref_git));
578 ref_git = xstrdup(repo);
581 if (!repo && is_directory(mkpath("%s/.git/objects", ref_git))) {
582 char *ref_git_git = mkpathdup("%s/.git", ref_git);
584 ref_git = ref_git_git;
585 } else if (!is_directory(mkpath("%s/objects", ref_git))) {
586 struct strbuf sb = STRBUF_INIT;
588 if (get_common_dir(&sb, ref_git)) {
590 _("reference repository '%s' as a linked "
591 "checkout is not supported yet."),
596 strbuf_addf(err, _("reference repository '%s' is not a "
597 "local repository."), path);
601 if (!access(mkpath("%s/shallow", ref_git), F_OK)) {
602 strbuf_addf(err, _("reference repository '%s' is shallow"),
608 if (!access(mkpath("%s/info/grafts", ref_git), F_OK)) {
610 _("reference repository '%s' is grafted"),
625 int foreach_alt_odb(alt_odb_fn fn, void *cb)
627 struct alternate_object_database *ent;
631 for (ent = alt_odb_list; ent; ent = ent->next) {
639 void prepare_alt_odb(void)
646 alt = getenv(ALTERNATE_DB_ENVIRONMENT);
649 alt_odb_tail = &alt_odb_list;
650 link_alt_odb_entries(alt, strlen(alt), PATH_SEP, NULL, 0);
652 read_info_alternates(get_object_directory(), 0);
655 /* Returns 1 if we have successfully freshened the file, 0 otherwise. */
656 static int freshen_file(const char *fn)
659 t.actime = t.modtime = time(NULL);
660 return !utime(fn, &t);
664 * All of the check_and_freshen functions return 1 if the file exists and was
665 * freshened (if freshening was requested), 0 otherwise. If they return
666 * 0, you should not assume that it is safe to skip a write of the object (it
667 * either does not exist on disk, or has a stale mtime and may be subject to
670 int check_and_freshen_file(const char *fn, int freshen)
672 if (access(fn, F_OK))
674 if (freshen && !freshen_file(fn))
679 static int check_and_freshen_local(const unsigned char *sha1, int freshen)
681 return check_and_freshen_file(sha1_file_name(sha1), freshen);
684 static int check_and_freshen_nonlocal(const unsigned char *sha1, int freshen)
686 struct alternate_object_database *alt;
688 for (alt = alt_odb_list; alt; alt = alt->next) {
689 const char *path = alt_sha1_path(alt, sha1);
690 if (check_and_freshen_file(path, freshen))
696 static int check_and_freshen(const unsigned char *sha1, int freshen)
698 return check_and_freshen_local(sha1, freshen) ||
699 check_and_freshen_nonlocal(sha1, freshen);
702 int has_loose_object_nonlocal(const unsigned char *sha1)
704 return check_and_freshen_nonlocal(sha1, 0);
707 static int has_loose_object(const unsigned char *sha1)
709 return check_and_freshen(sha1, 0);
712 static unsigned int pack_used_ctr;
713 static unsigned int pack_mmap_calls;
714 static unsigned int peak_pack_open_windows;
715 static unsigned int pack_open_windows;
716 static unsigned int pack_open_fds;
717 static unsigned int pack_max_fds;
718 static size_t peak_pack_mapped;
719 static size_t pack_mapped;
720 struct packed_git *packed_git;
722 static struct mru packed_git_mru_storage;
723 struct mru *packed_git_mru = &packed_git_mru_storage;
725 void pack_report(void)
728 "pack_report: getpagesize() = %10" SZ_FMT "\n"
729 "pack_report: core.packedGitWindowSize = %10" SZ_FMT "\n"
730 "pack_report: core.packedGitLimit = %10" SZ_FMT "\n",
731 sz_fmt(getpagesize()),
732 sz_fmt(packed_git_window_size),
733 sz_fmt(packed_git_limit));
735 "pack_report: pack_used_ctr = %10u\n"
736 "pack_report: pack_mmap_calls = %10u\n"
737 "pack_report: pack_open_windows = %10u / %10u\n"
738 "pack_report: pack_mapped = "
739 "%10" SZ_FMT " / %10" SZ_FMT "\n",
742 pack_open_windows, peak_pack_open_windows,
743 sz_fmt(pack_mapped), sz_fmt(peak_pack_mapped));
747 * Open and mmap the index file at path, perform a couple of
748 * consistency checks, then record its information to p. Return 0 on
751 static int check_packed_git_idx(const char *path, struct packed_git *p)
754 struct pack_idx_header *hdr;
756 uint32_t version, nr, i, *index;
757 int fd = git_open(path);
762 if (fstat(fd, &st)) {
766 idx_size = xsize_t(st.st_size);
767 if (idx_size < 4 * 256 + 20 + 20) {
769 return error("index file %s is too small", path);
771 idx_map = xmmap(NULL, idx_size, PROT_READ, MAP_PRIVATE, fd, 0);
775 if (hdr->idx_signature == htonl(PACK_IDX_SIGNATURE)) {
776 version = ntohl(hdr->idx_version);
777 if (version < 2 || version > 2) {
778 munmap(idx_map, idx_size);
779 return error("index file %s is version %"PRIu32
780 " and is not supported by this binary"
781 " (try upgrading GIT to a newer version)",
790 index += 2; /* skip index header */
791 for (i = 0; i < 256; i++) {
792 uint32_t n = ntohl(index[i]);
794 munmap(idx_map, idx_size);
795 return error("non-monotonic index %s", path);
803 * - 256 index entries 4 bytes each
804 * - 24-byte entries * nr (20-byte sha1 + 4-byte offset)
805 * - 20-byte SHA1 of the packfile
806 * - 20-byte SHA1 file checksum
808 if (idx_size != 4*256 + nr * 24 + 20 + 20) {
809 munmap(idx_map, idx_size);
810 return error("wrong index v1 file size in %s", path);
812 } else if (version == 2) {
815 * - 8 bytes of header
816 * - 256 index entries 4 bytes each
817 * - 20-byte sha1 entry * nr
818 * - 4-byte crc entry * nr
819 * - 4-byte offset entry * nr
820 * - 20-byte SHA1 of the packfile
821 * - 20-byte SHA1 file checksum
822 * And after the 4-byte offset table might be a
823 * variable sized table containing 8-byte entries
824 * for offsets larger than 2^31.
826 unsigned long min_size = 8 + 4*256 + nr*(20 + 4 + 4) + 20 + 20;
827 unsigned long max_size = min_size;
829 max_size += (nr - 1)*8;
830 if (idx_size < min_size || idx_size > max_size) {
831 munmap(idx_map, idx_size);
832 return error("wrong index v2 file size in %s", path);
834 if (idx_size != min_size &&
836 * make sure we can deal with large pack offsets.
837 * 31-bit signed offset won't be enough, neither
838 * 32-bit unsigned one will be.
840 (sizeof(off_t) <= 4)) {
841 munmap(idx_map, idx_size);
842 return error("pack too large for current definition of off_t in %s", path);
846 p->index_version = version;
847 p->index_data = idx_map;
848 p->index_size = idx_size;
853 int open_pack_index(struct packed_git *p)
862 if (!strip_suffix(p->pack_name, ".pack", &len))
863 die("BUG: pack_name does not end in .pack");
864 idx_name = xstrfmt("%.*s.idx", (int)len, p->pack_name);
865 ret = check_packed_git_idx(idx_name, p);
870 static void scan_windows(struct packed_git *p,
871 struct packed_git **lru_p,
872 struct pack_window **lru_w,
873 struct pack_window **lru_l)
875 struct pack_window *w, *w_l;
877 for (w_l = NULL, w = p->windows; w; w = w->next) {
879 if (!*lru_w || w->last_used < (*lru_w)->last_used) {
889 static int unuse_one_window(struct packed_git *current)
891 struct packed_git *p, *lru_p = NULL;
892 struct pack_window *lru_w = NULL, *lru_l = NULL;
895 scan_windows(current, &lru_p, &lru_w, &lru_l);
896 for (p = packed_git; p; p = p->next)
897 scan_windows(p, &lru_p, &lru_w, &lru_l);
899 munmap(lru_w->base, lru_w->len);
900 pack_mapped -= lru_w->len;
902 lru_l->next = lru_w->next;
904 lru_p->windows = lru_w->next;
912 void release_pack_memory(size_t need)
914 size_t cur = pack_mapped;
915 while (need >= (cur - pack_mapped) && unuse_one_window(NULL))
919 static void mmap_limit_check(size_t length)
921 static size_t limit = 0;
923 limit = git_env_ulong("GIT_MMAP_LIMIT", 0);
928 die("attempting to mmap %"PRIuMAX" over limit %"PRIuMAX,
929 (uintmax_t)length, (uintmax_t)limit);
932 void *xmmap_gently(void *start, size_t length,
933 int prot, int flags, int fd, off_t offset)
937 mmap_limit_check(length);
938 ret = mmap(start, length, prot, flags, fd, offset);
939 if (ret == MAP_FAILED) {
942 release_pack_memory(length);
943 ret = mmap(start, length, prot, flags, fd, offset);
948 void *xmmap(void *start, size_t length,
949 int prot, int flags, int fd, off_t offset)
951 void *ret = xmmap_gently(start, length, prot, flags, fd, offset);
952 if (ret == MAP_FAILED)
953 die_errno("mmap failed");
957 void close_pack_windows(struct packed_git *p)
960 struct pack_window *w = p->windows;
963 die("pack '%s' still has open windows to it",
965 munmap(w->base, w->len);
966 pack_mapped -= w->len;
968 p->windows = w->next;
973 static int close_pack_fd(struct packed_git *p)
985 static void close_pack(struct packed_git *p)
987 close_pack_windows(p);
992 void close_all_packs(void)
994 struct packed_git *p;
996 for (p = packed_git; p; p = p->next)
998 die("BUG: want to close pack marked 'do-not-close'");
1005 * The LRU pack is the one with the oldest MRU window, preferring packs
1006 * with no used windows, or the oldest mtime if it has no windows allocated.
1008 static void find_lru_pack(struct packed_git *p, struct packed_git **lru_p, struct pack_window **mru_w, int *accept_windows_inuse)
1010 struct pack_window *w, *this_mru_w;
1011 int has_windows_inuse = 0;
1014 * Reject this pack if it has windows and the previously selected
1015 * one does not. If this pack does not have windows, reject
1016 * it if the pack file is newer than the previously selected one.
1018 if (*lru_p && !*mru_w && (p->windows || p->mtime > (*lru_p)->mtime))
1021 for (w = this_mru_w = p->windows; w; w = w->next) {
1023 * Reject this pack if any of its windows are in use,
1024 * but the previously selected pack did not have any
1025 * inuse windows. Otherwise, record that this pack
1026 * has windows in use.
1029 if (*accept_windows_inuse)
1030 has_windows_inuse = 1;
1035 if (w->last_used > this_mru_w->last_used)
1039 * Reject this pack if it has windows that have been
1040 * used more recently than the previously selected pack.
1041 * If the previously selected pack had windows inuse and
1042 * we have not encountered a window in this pack that is
1043 * inuse, skip this check since we prefer a pack with no
1044 * inuse windows to one that has inuse windows.
1046 if (*mru_w && *accept_windows_inuse == has_windows_inuse &&
1047 this_mru_w->last_used > (*mru_w)->last_used)
1054 *mru_w = this_mru_w;
1056 *accept_windows_inuse = has_windows_inuse;
1059 static int close_one_pack(void)
1061 struct packed_git *p, *lru_p = NULL;
1062 struct pack_window *mru_w = NULL;
1063 int accept_windows_inuse = 1;
1065 for (p = packed_git; p; p = p->next) {
1066 if (p->pack_fd == -1)
1068 find_lru_pack(p, &lru_p, &mru_w, &accept_windows_inuse);
1072 return close_pack_fd(lru_p);
1077 void unuse_pack(struct pack_window **w_cursor)
1079 struct pack_window *w = *w_cursor;
1086 void close_pack_index(struct packed_git *p)
1088 if (p->index_data) {
1089 munmap((void *)p->index_data, p->index_size);
1090 p->index_data = NULL;
1094 static unsigned int get_max_fd_limit(void)
1096 #ifdef RLIMIT_NOFILE
1100 if (!getrlimit(RLIMIT_NOFILE, &lim))
1101 return lim.rlim_cur;
1107 long open_max = sysconf(_SC_OPEN_MAX);
1111 * Otherwise, we got -1 for one of the two
1114 * (1) sysconf() did not understand _SC_OPEN_MAX
1115 * and signaled an error with -1; or
1116 * (2) sysconf() said there is no limit.
1118 * We _could_ clear errno before calling sysconf() to
1119 * tell these two cases apart and return a huge number
1120 * in the latter case to let the caller cap it to a
1121 * value that is not so selfish, but letting the
1122 * fallback OPEN_MAX codepath take care of these cases
1131 return 1; /* see the caller ;-) */
1136 * Do not call this directly as this leaks p->pack_fd on error return;
1137 * call open_packed_git() instead.
1139 static int open_packed_git_1(struct packed_git *p)
1142 struct pack_header hdr;
1143 unsigned char sha1[20];
1144 unsigned char *idx_sha1;
1147 if (!p->index_data && open_pack_index(p))
1148 return error("packfile %s index unavailable", p->pack_name);
1150 if (!pack_max_fds) {
1151 unsigned int max_fds = get_max_fd_limit();
1153 /* Save 3 for stdin/stdout/stderr, 22 for work */
1155 pack_max_fds = max_fds - 25;
1160 while (pack_max_fds <= pack_open_fds && close_one_pack())
1163 p->pack_fd = git_open(p->pack_name);
1164 if (p->pack_fd < 0 || fstat(p->pack_fd, &st))
1168 /* If we created the struct before we had the pack we lack size. */
1169 if (!p->pack_size) {
1170 if (!S_ISREG(st.st_mode))
1171 return error("packfile %s not a regular file", p->pack_name);
1172 p->pack_size = st.st_size;
1173 } else if (p->pack_size != st.st_size)
1174 return error("packfile %s size changed", p->pack_name);
1176 /* We leave these file descriptors open with sliding mmap;
1177 * there is no point keeping them open across exec(), though.
1179 fd_flag = fcntl(p->pack_fd, F_GETFD, 0);
1181 return error("cannot determine file descriptor flags");
1182 fd_flag |= FD_CLOEXEC;
1183 if (fcntl(p->pack_fd, F_SETFD, fd_flag) == -1)
1184 return error("cannot set FD_CLOEXEC");
1186 /* Verify we recognize this pack file format. */
1187 if (read_in_full(p->pack_fd, &hdr, sizeof(hdr)) != sizeof(hdr))
1188 return error("file %s is far too short to be a packfile", p->pack_name);
1189 if (hdr.hdr_signature != htonl(PACK_SIGNATURE))
1190 return error("file %s is not a GIT packfile", p->pack_name);
1191 if (!pack_version_ok(hdr.hdr_version))
1192 return error("packfile %s is version %"PRIu32" and not"
1193 " supported (try upgrading GIT to a newer version)",
1194 p->pack_name, ntohl(hdr.hdr_version));
1196 /* Verify the pack matches its index. */
1197 if (p->num_objects != ntohl(hdr.hdr_entries))
1198 return error("packfile %s claims to have %"PRIu32" objects"
1199 " while index indicates %"PRIu32" objects",
1200 p->pack_name, ntohl(hdr.hdr_entries),
1202 if (lseek(p->pack_fd, p->pack_size - sizeof(sha1), SEEK_SET) == -1)
1203 return error("end of packfile %s is unavailable", p->pack_name);
1204 if (read_in_full(p->pack_fd, sha1, sizeof(sha1)) != sizeof(sha1))
1205 return error("packfile %s signature is unavailable", p->pack_name);
1206 idx_sha1 = ((unsigned char *)p->index_data) + p->index_size - 40;
1207 if (hashcmp(sha1, idx_sha1))
1208 return error("packfile %s does not match index", p->pack_name);
1212 static int open_packed_git(struct packed_git *p)
1214 if (!open_packed_git_1(p))
1220 static int in_window(struct pack_window *win, off_t offset)
1222 /* We must promise at least 20 bytes (one hash) after the
1223 * offset is available from this window, otherwise the offset
1224 * is not actually in this window and a different window (which
1225 * has that one hash excess) must be used. This is to support
1226 * the object header and delta base parsing routines below.
1228 off_t win_off = win->offset;
1229 return win_off <= offset
1230 && (offset + 20) <= (win_off + win->len);
1233 unsigned char *use_pack(struct packed_git *p,
1234 struct pack_window **w_cursor,
1236 unsigned long *left)
1238 struct pack_window *win = *w_cursor;
1240 /* Since packfiles end in a hash of their content and it's
1241 * pointless to ask for an offset into the middle of that
1242 * hash, and the in_window function above wouldn't match
1243 * don't allow an offset too close to the end of the file.
1245 if (!p->pack_size && p->pack_fd == -1 && open_packed_git(p))
1246 die("packfile %s cannot be accessed", p->pack_name);
1247 if (offset > (p->pack_size - 20))
1248 die("offset beyond end of packfile (truncated pack?)");
1250 die(_("offset before end of packfile (broken .idx?)"));
1252 if (!win || !in_window(win, offset)) {
1255 for (win = p->windows; win; win = win->next) {
1256 if (in_window(win, offset))
1260 size_t window_align = packed_git_window_size / 2;
1263 if (p->pack_fd == -1 && open_packed_git(p))
1264 die("packfile %s cannot be accessed", p->pack_name);
1266 win = xcalloc(1, sizeof(*win));
1267 win->offset = (offset / window_align) * window_align;
1268 len = p->pack_size - win->offset;
1269 if (len > packed_git_window_size)
1270 len = packed_git_window_size;
1271 win->len = (size_t)len;
1272 pack_mapped += win->len;
1273 while (packed_git_limit < pack_mapped
1274 && unuse_one_window(p))
1276 win->base = xmmap(NULL, win->len,
1277 PROT_READ, MAP_PRIVATE,
1278 p->pack_fd, win->offset);
1279 if (win->base == MAP_FAILED)
1280 die_errno("packfile %s cannot be mapped",
1282 if (!win->offset && win->len == p->pack_size
1283 && !p->do_not_close)
1286 pack_open_windows++;
1287 if (pack_mapped > peak_pack_mapped)
1288 peak_pack_mapped = pack_mapped;
1289 if (pack_open_windows > peak_pack_open_windows)
1290 peak_pack_open_windows = pack_open_windows;
1291 win->next = p->windows;
1295 if (win != *w_cursor) {
1296 win->last_used = pack_used_ctr++;
1300 offset -= win->offset;
1302 *left = win->len - xsize_t(offset);
1303 return win->base + offset;
1306 static struct packed_git *alloc_packed_git(int extra)
1308 struct packed_git *p = xmalloc(st_add(sizeof(*p), extra));
1309 memset(p, 0, sizeof(*p));
1314 static void try_to_free_pack_memory(size_t size)
1316 release_pack_memory(size);
1319 struct packed_git *add_packed_git(const char *path, size_t path_len, int local)
1321 static int have_set_try_to_free_routine;
1324 struct packed_git *p;
1326 if (!have_set_try_to_free_routine) {
1327 have_set_try_to_free_routine = 1;
1328 set_try_to_free_routine(try_to_free_pack_memory);
1332 * Make sure a corresponding .pack file exists and that
1333 * the index looks sane.
1335 if (!strip_suffix_mem(path, &path_len, ".idx"))
1339 * ".pack" is long enough to hold any suffix we're adding (and
1340 * the use xsnprintf double-checks that)
1342 alloc = st_add3(path_len, strlen(".pack"), 1);
1343 p = alloc_packed_git(alloc);
1344 memcpy(p->pack_name, path, path_len);
1346 xsnprintf(p->pack_name + path_len, alloc - path_len, ".keep");
1347 if (!access(p->pack_name, F_OK))
1350 xsnprintf(p->pack_name + path_len, alloc - path_len, ".pack");
1351 if (stat(p->pack_name, &st) || !S_ISREG(st.st_mode)) {
1356 /* ok, it looks sane as far as we can check without
1357 * actually mapping the pack file.
1359 p->pack_size = st.st_size;
1360 p->pack_local = local;
1361 p->mtime = st.st_mtime;
1362 if (path_len < 40 || get_sha1_hex(path + path_len - 40, p->sha1))
1367 struct packed_git *parse_pack_index(unsigned char *sha1, const char *idx_path)
1369 const char *path = sha1_pack_name(sha1);
1370 size_t alloc = st_add(strlen(path), 1);
1371 struct packed_git *p = alloc_packed_git(alloc);
1373 memcpy(p->pack_name, path, alloc); /* includes NUL */
1374 hashcpy(p->sha1, sha1);
1375 if (check_packed_git_idx(idx_path, p)) {
1383 void install_packed_git(struct packed_git *pack)
1385 if (pack->pack_fd != -1)
1388 pack->next = packed_git;
1392 void (*report_garbage)(unsigned seen_bits, const char *path);
1394 static void report_helper(const struct string_list *list,
1395 int seen_bits, int first, int last)
1397 if (seen_bits == (PACKDIR_FILE_PACK|PACKDIR_FILE_IDX))
1400 for (; first < last; first++)
1401 report_garbage(seen_bits, list->items[first].string);
1404 static void report_pack_garbage(struct string_list *list)
1406 int i, baselen = -1, first = 0, seen_bits = 0;
1408 if (!report_garbage)
1411 string_list_sort(list);
1413 for (i = 0; i < list->nr; i++) {
1414 const char *path = list->items[i].string;
1415 if (baselen != -1 &&
1416 strncmp(path, list->items[first].string, baselen)) {
1417 report_helper(list, seen_bits, first, i);
1421 if (baselen == -1) {
1422 const char *dot = strrchr(path, '.');
1424 report_garbage(PACKDIR_FILE_GARBAGE, path);
1427 baselen = dot - path + 1;
1430 if (!strcmp(path + baselen, "pack"))
1432 else if (!strcmp(path + baselen, "idx"))
1435 report_helper(list, seen_bits, first, list->nr);
1438 static void prepare_packed_git_one(char *objdir, int local)
1440 struct strbuf path = STRBUF_INIT;
1444 struct string_list garbage = STRING_LIST_INIT_DUP;
1446 strbuf_addstr(&path, objdir);
1447 strbuf_addstr(&path, "/pack");
1448 dir = opendir(path.buf);
1450 if (errno != ENOENT)
1451 error_errno("unable to open object pack directory: %s",
1453 strbuf_release(&path);
1456 strbuf_addch(&path, '/');
1457 dirnamelen = path.len;
1458 while ((de = readdir(dir)) != NULL) {
1459 struct packed_git *p;
1462 if (is_dot_or_dotdot(de->d_name))
1465 strbuf_setlen(&path, dirnamelen);
1466 strbuf_addstr(&path, de->d_name);
1468 base_len = path.len;
1469 if (strip_suffix_mem(path.buf, &base_len, ".idx")) {
1470 /* Don't reopen a pack we already have. */
1471 for (p = packed_git; p; p = p->next) {
1473 if (strip_suffix(p->pack_name, ".pack", &len) &&
1475 !memcmp(p->pack_name, path.buf, len))
1480 * See if it really is a valid .idx file with
1481 * corresponding .pack file that we can map.
1483 (p = add_packed_git(path.buf, path.len, local)) != NULL)
1484 install_packed_git(p);
1487 if (!report_garbage)
1490 if (ends_with(de->d_name, ".idx") ||
1491 ends_with(de->d_name, ".pack") ||
1492 ends_with(de->d_name, ".bitmap") ||
1493 ends_with(de->d_name, ".keep"))
1494 string_list_append(&garbage, path.buf);
1496 report_garbage(PACKDIR_FILE_GARBAGE, path.buf);
1499 report_pack_garbage(&garbage);
1500 string_list_clear(&garbage, 0);
1501 strbuf_release(&path);
1504 static int approximate_object_count_valid;
1507 * Give a fast, rough count of the number of objects in the repository. This
1508 * ignores loose objects completely. If you have a lot of them, then either
1509 * you should repack because your performance will be awful, or they are
1510 * all unreachable objects about to be pruned, in which case they're not really
1511 * interesting as a measure of repo size in the first place.
1513 unsigned long approximate_object_count(void)
1515 static unsigned long count;
1516 if (!approximate_object_count_valid) {
1517 struct packed_git *p;
1519 prepare_packed_git();
1521 for (p = packed_git; p; p = p->next) {
1522 if (open_pack_index(p))
1524 count += p->num_objects;
1530 static void *get_next_packed_git(const void *p)
1532 return ((const struct packed_git *)p)->next;
1535 static void set_next_packed_git(void *p, void *next)
1537 ((struct packed_git *)p)->next = next;
1540 static int sort_pack(const void *a_, const void *b_)
1542 const struct packed_git *a = a_;
1543 const struct packed_git *b = b_;
1547 * Local packs tend to contain objects specific to our
1548 * variant of the project than remote ones. In addition,
1549 * remote ones could be on a network mounted filesystem.
1550 * Favor local ones for these reasons.
1552 st = a->pack_local - b->pack_local;
1557 * Younger packs tend to contain more recent objects,
1558 * and more recent objects tend to get accessed more
1561 if (a->mtime < b->mtime)
1563 else if (a->mtime == b->mtime)
1568 static void rearrange_packed_git(void)
1570 packed_git = llist_mergesort(packed_git, get_next_packed_git,
1571 set_next_packed_git, sort_pack);
1574 static void prepare_packed_git_mru(void)
1576 struct packed_git *p;
1578 mru_clear(packed_git_mru);
1579 for (p = packed_git; p; p = p->next)
1580 mru_append(packed_git_mru, p);
1583 static int prepare_packed_git_run_once = 0;
1584 void prepare_packed_git(void)
1586 struct alternate_object_database *alt;
1588 if (prepare_packed_git_run_once)
1590 prepare_packed_git_one(get_object_directory(), 1);
1592 for (alt = alt_odb_list; alt; alt = alt->next)
1593 prepare_packed_git_one(alt->path, 0);
1594 rearrange_packed_git();
1595 prepare_packed_git_mru();
1596 prepare_packed_git_run_once = 1;
1599 void reprepare_packed_git(void)
1601 approximate_object_count_valid = 0;
1602 prepare_packed_git_run_once = 0;
1603 prepare_packed_git();
1606 static void mark_bad_packed_object(struct packed_git *p,
1607 const unsigned char *sha1)
1610 for (i = 0; i < p->num_bad_objects; i++)
1611 if (!hashcmp(sha1, p->bad_object_sha1 + GIT_SHA1_RAWSZ * i))
1613 p->bad_object_sha1 = xrealloc(p->bad_object_sha1,
1614 st_mult(GIT_SHA1_RAWSZ,
1615 st_add(p->num_bad_objects, 1)));
1616 hashcpy(p->bad_object_sha1 + GIT_SHA1_RAWSZ * p->num_bad_objects, sha1);
1617 p->num_bad_objects++;
1620 static const struct packed_git *has_packed_and_bad(const unsigned char *sha1)
1622 struct packed_git *p;
1625 for (p = packed_git; p; p = p->next)
1626 for (i = 0; i < p->num_bad_objects; i++)
1627 if (!hashcmp(sha1, p->bad_object_sha1 + 20 * i))
1633 * With an in-core object data in "map", rehash it to make sure the
1634 * object name actually matches "sha1" to detect object corruption.
1635 * With "map" == NULL, try reading the object named with "sha1" using
1636 * the streaming interface and rehash it to do the same.
1638 int check_sha1_signature(const unsigned char *sha1, void *map,
1639 unsigned long size, const char *type)
1641 unsigned char real_sha1[20];
1642 enum object_type obj_type;
1643 struct git_istream *st;
1649 hash_sha1_file(map, size, type, real_sha1);
1650 return hashcmp(sha1, real_sha1) ? -1 : 0;
1653 st = open_istream(sha1, &obj_type, &size, NULL);
1657 /* Generate the header */
1658 hdrlen = xsnprintf(hdr, sizeof(hdr), "%s %lu", typename(obj_type), size) + 1;
1662 git_SHA1_Update(&c, hdr, hdrlen);
1664 char buf[1024 * 16];
1665 ssize_t readlen = read_istream(st, buf, sizeof(buf));
1673 git_SHA1_Update(&c, buf, readlen);
1675 git_SHA1_Final(real_sha1, &c);
1677 return hashcmp(sha1, real_sha1) ? -1 : 0;
1680 int git_open_cloexec(const char *name, int flags)
1683 static int o_cloexec = O_CLOEXEC;
1685 fd = open(name, flags | o_cloexec);
1686 if ((o_cloexec & O_CLOEXEC) && fd < 0 && errno == EINVAL) {
1687 /* Try again w/o O_CLOEXEC: the kernel might not support it */
1688 o_cloexec &= ~O_CLOEXEC;
1689 fd = open(name, flags | o_cloexec);
1692 #if defined(F_GETFL) && defined(F_SETFL) && defined(FD_CLOEXEC)
1694 static int fd_cloexec = FD_CLOEXEC;
1696 if (!o_cloexec && 0 <= fd && fd_cloexec) {
1697 /* Opened w/o O_CLOEXEC? try with fcntl(2) to add it */
1698 int flags = fcntl(fd, F_GETFL);
1699 if (fcntl(fd, F_SETFL, flags | fd_cloexec))
1708 * Find "sha1" as a loose object in the local repository or in an alternate.
1709 * Returns 0 on success, negative on failure.
1711 * The "path" out-parameter will give the path of the object we found (if any).
1712 * Note that it may point to static storage and is only valid until another
1713 * call to sha1_file_name(), etc.
1715 static int stat_sha1_file(const unsigned char *sha1, struct stat *st,
1718 struct alternate_object_database *alt;
1720 *path = sha1_file_name(sha1);
1721 if (!lstat(*path, st))
1726 for (alt = alt_odb_list; alt; alt = alt->next) {
1727 *path = alt_sha1_path(alt, sha1);
1728 if (!lstat(*path, st))
1736 * Like stat_sha1_file(), but actually open the object and return the
1737 * descriptor. See the caveats on the "path" parameter above.
1739 static int open_sha1_file(const unsigned char *sha1, const char **path)
1742 struct alternate_object_database *alt;
1743 int most_interesting_errno;
1745 *path = sha1_file_name(sha1);
1746 fd = git_open(*path);
1749 most_interesting_errno = errno;
1752 for (alt = alt_odb_list; alt; alt = alt->next) {
1753 *path = alt_sha1_path(alt, sha1);
1754 fd = git_open(*path);
1757 if (most_interesting_errno == ENOENT)
1758 most_interesting_errno = errno;
1760 errno = most_interesting_errno;
1765 * Map the loose object at "path" if it is not NULL, or the path found by
1766 * searching for a loose object named "sha1".
1768 static void *map_sha1_file_1(const char *path,
1769 const unsigned char *sha1,
1770 unsigned long *size)
1776 fd = git_open(path);
1778 fd = open_sha1_file(sha1, &path);
1783 if (!fstat(fd, &st)) {
1784 *size = xsize_t(st.st_size);
1786 /* mmap() is forbidden on empty files */
1787 error("object file %s is empty", path);
1790 map = xmmap(NULL, *size, PROT_READ, MAP_PRIVATE, fd, 0);
1797 void *map_sha1_file(const unsigned char *sha1, unsigned long *size)
1799 return map_sha1_file_1(NULL, sha1, size);
1802 unsigned long unpack_object_header_buffer(const unsigned char *buf,
1803 unsigned long len, enum object_type *type, unsigned long *sizep)
1806 unsigned long size, c;
1807 unsigned long used = 0;
1810 *type = (c >> 4) & 7;
1814 if (len <= used || bitsizeof(long) <= shift) {
1815 error("bad object header");
1820 size += (c & 0x7f) << shift;
1827 static int unpack_sha1_short_header(git_zstream *stream,
1828 unsigned char *map, unsigned long mapsize,
1829 void *buffer, unsigned long bufsiz)
1831 /* Get the data stream */
1832 memset(stream, 0, sizeof(*stream));
1833 stream->next_in = map;
1834 stream->avail_in = mapsize;
1835 stream->next_out = buffer;
1836 stream->avail_out = bufsiz;
1838 git_inflate_init(stream);
1839 return git_inflate(stream, 0);
1842 int unpack_sha1_header(git_zstream *stream,
1843 unsigned char *map, unsigned long mapsize,
1844 void *buffer, unsigned long bufsiz)
1846 int status = unpack_sha1_short_header(stream, map, mapsize,
1852 /* Make sure we have the terminating NUL */
1853 if (!memchr(buffer, '\0', stream->next_out - (unsigned char *)buffer))
1858 static int unpack_sha1_header_to_strbuf(git_zstream *stream, unsigned char *map,
1859 unsigned long mapsize, void *buffer,
1860 unsigned long bufsiz, struct strbuf *header)
1864 status = unpack_sha1_short_header(stream, map, mapsize, buffer, bufsiz);
1869 * Check if entire header is unpacked in the first iteration.
1871 if (memchr(buffer, '\0', stream->next_out - (unsigned char *)buffer))
1875 * buffer[0..bufsiz] was not large enough. Copy the partial
1876 * result out to header, and then append the result of further
1877 * reading the stream.
1879 strbuf_add(header, buffer, stream->next_out - (unsigned char *)buffer);
1880 stream->next_out = buffer;
1881 stream->avail_out = bufsiz;
1884 status = git_inflate(stream, 0);
1885 strbuf_add(header, buffer, stream->next_out - (unsigned char *)buffer);
1886 if (memchr(buffer, '\0', stream->next_out - (unsigned char *)buffer))
1888 stream->next_out = buffer;
1889 stream->avail_out = bufsiz;
1890 } while (status != Z_STREAM_END);
1894 static void *unpack_sha1_rest(git_zstream *stream, void *buffer, unsigned long size, const unsigned char *sha1)
1896 int bytes = strlen(buffer) + 1;
1897 unsigned char *buf = xmallocz(size);
1901 n = stream->total_out - bytes;
1904 memcpy(buf, (char *) buffer + bytes, n);
1906 if (bytes <= size) {
1908 * The above condition must be (bytes <= size), not
1909 * (bytes < size). In other words, even though we
1910 * expect no more output and set avail_out to zero,
1911 * the input zlib stream may have bytes that express
1912 * "this concludes the stream", and we *do* want to
1915 * Otherwise we would not be able to test that we
1916 * consumed all the input to reach the expected size;
1917 * we also want to check that zlib tells us that all
1918 * went well with status == Z_STREAM_END at the end.
1920 stream->next_out = buf + bytes;
1921 stream->avail_out = size - bytes;
1922 while (status == Z_OK)
1923 status = git_inflate(stream, Z_FINISH);
1925 if (status == Z_STREAM_END && !stream->avail_in) {
1926 git_inflate_end(stream);
1931 error("corrupt loose object '%s'", sha1_to_hex(sha1));
1932 else if (stream->avail_in)
1933 error("garbage at end of loose object '%s'",
1940 * We used to just use "sscanf()", but that's actually way
1941 * too permissive for what we want to check. So do an anal
1942 * object header parse by hand.
1944 static int parse_sha1_header_extended(const char *hdr, struct object_info *oi,
1947 const char *type_buf = hdr;
1949 int type, type_len = 0;
1952 * The type can be of any size but is followed by
1964 type = type_from_string_gently(type_buf, type_len, 1);
1966 strbuf_add(oi->typename, type_buf, type_len);
1968 * Set type to 0 if its an unknown object and
1969 * we're obtaining the type using '--allow-unknown-type'
1972 if ((flags & LOOKUP_UNKNOWN_OBJECT) && (type < 0))
1975 die("invalid object type");
1980 * The length must follow immediately, and be in canonical
1981 * decimal format (ie "010" is not valid).
1983 size = *hdr++ - '0';
1988 unsigned long c = *hdr - '0';
1992 size = size * 10 + c;
2000 * The length must be followed by a zero byte
2002 return *hdr ? -1 : type;
2005 int parse_sha1_header(const char *hdr, unsigned long *sizep)
2007 struct object_info oi = OBJECT_INFO_INIT;
2010 return parse_sha1_header_extended(hdr, &oi, LOOKUP_REPLACE_OBJECT);
2013 static void *unpack_sha1_file(void *map, unsigned long mapsize, enum object_type *type, unsigned long *size, const unsigned char *sha1)
2019 ret = unpack_sha1_header(&stream, map, mapsize, hdr, sizeof(hdr));
2020 if (ret < Z_OK || (*type = parse_sha1_header(hdr, size)) < 0)
2023 return unpack_sha1_rest(&stream, hdr, *size, sha1);
2026 unsigned long get_size_from_delta(struct packed_git *p,
2027 struct pack_window **w_curs,
2030 const unsigned char *data;
2031 unsigned char delta_head[20], *in;
2035 memset(&stream, 0, sizeof(stream));
2036 stream.next_out = delta_head;
2037 stream.avail_out = sizeof(delta_head);
2039 git_inflate_init(&stream);
2041 in = use_pack(p, w_curs, curpos, &stream.avail_in);
2042 stream.next_in = in;
2043 st = git_inflate(&stream, Z_FINISH);
2044 curpos += stream.next_in - in;
2045 } while ((st == Z_OK || st == Z_BUF_ERROR) &&
2046 stream.total_out < sizeof(delta_head));
2047 git_inflate_end(&stream);
2048 if ((st != Z_STREAM_END) && stream.total_out != sizeof(delta_head)) {
2049 error("delta data unpack-initial failed");
2053 /* Examine the initial part of the delta to figure out
2058 /* ignore base size */
2059 get_delta_hdr_size(&data, delta_head+sizeof(delta_head));
2061 /* Read the result size */
2062 return get_delta_hdr_size(&data, delta_head+sizeof(delta_head));
2065 static off_t get_delta_base(struct packed_git *p,
2066 struct pack_window **w_curs,
2068 enum object_type type,
2069 off_t delta_obj_offset)
2071 unsigned char *base_info = use_pack(p, w_curs, *curpos, NULL);
2074 /* use_pack() assured us we have [base_info, base_info + 20)
2075 * as a range that we can look at without walking off the
2076 * end of the mapped window. Its actually the hash size
2077 * that is assured. An OFS_DELTA longer than the hash size
2078 * is stupid, as then a REF_DELTA would be smaller to store.
2080 if (type == OBJ_OFS_DELTA) {
2082 unsigned char c = base_info[used++];
2083 base_offset = c & 127;
2086 if (!base_offset || MSB(base_offset, 7))
2087 return 0; /* overflow */
2088 c = base_info[used++];
2089 base_offset = (base_offset << 7) + (c & 127);
2091 base_offset = delta_obj_offset - base_offset;
2092 if (base_offset <= 0 || base_offset >= delta_obj_offset)
2093 return 0; /* out of bound */
2095 } else if (type == OBJ_REF_DELTA) {
2096 /* The base entry _must_ be in the same pack */
2097 base_offset = find_pack_entry_one(base_info, p);
2100 die("I am totally screwed");
2105 * Like get_delta_base above, but we return the sha1 instead of the pack
2106 * offset. This means it is cheaper for REF deltas (we do not have to do
2107 * the final object lookup), but more expensive for OFS deltas (we
2108 * have to load the revidx to convert the offset back into a sha1).
2110 static const unsigned char *get_delta_base_sha1(struct packed_git *p,
2111 struct pack_window **w_curs,
2113 enum object_type type,
2114 off_t delta_obj_offset)
2116 if (type == OBJ_REF_DELTA) {
2117 unsigned char *base = use_pack(p, w_curs, curpos, NULL);
2119 } else if (type == OBJ_OFS_DELTA) {
2120 struct revindex_entry *revidx;
2121 off_t base_offset = get_delta_base(p, w_curs, &curpos,
2122 type, delta_obj_offset);
2127 revidx = find_pack_revindex(p, base_offset);
2131 return nth_packed_object_sha1(p, revidx->nr);
2136 int unpack_object_header(struct packed_git *p,
2137 struct pack_window **w_curs,
2139 unsigned long *sizep)
2141 unsigned char *base;
2144 enum object_type type;
2146 /* use_pack() assures us we have [base, base + 20) available
2147 * as a range that we can look at. (Its actually the hash
2148 * size that is assured.) With our object header encoding
2149 * the maximum deflated object size is 2^137, which is just
2150 * insane, so we know won't exceed what we have been given.
2152 base = use_pack(p, w_curs, *curpos, &left);
2153 used = unpack_object_header_buffer(base, left, &type, sizep);
2162 static int retry_bad_packed_offset(struct packed_git *p, off_t obj_offset)
2165 struct revindex_entry *revidx;
2166 const unsigned char *sha1;
2167 revidx = find_pack_revindex(p, obj_offset);
2170 sha1 = nth_packed_object_sha1(p, revidx->nr);
2171 mark_bad_packed_object(p, sha1);
2172 type = sha1_object_info(sha1, NULL);
2173 if (type <= OBJ_NONE)
2178 #define POI_STACK_PREALLOC 64
2180 static enum object_type packed_to_object_type(struct packed_git *p,
2182 enum object_type type,
2183 struct pack_window **w_curs,
2186 off_t small_poi_stack[POI_STACK_PREALLOC];
2187 off_t *poi_stack = small_poi_stack;
2188 int poi_stack_nr = 0, poi_stack_alloc = POI_STACK_PREALLOC;
2190 while (type == OBJ_OFS_DELTA || type == OBJ_REF_DELTA) {
2193 /* Push the object we're going to leave behind */
2194 if (poi_stack_nr >= poi_stack_alloc && poi_stack == small_poi_stack) {
2195 poi_stack_alloc = alloc_nr(poi_stack_nr);
2196 ALLOC_ARRAY(poi_stack, poi_stack_alloc);
2197 memcpy(poi_stack, small_poi_stack, sizeof(off_t)*poi_stack_nr);
2199 ALLOC_GROW(poi_stack, poi_stack_nr+1, poi_stack_alloc);
2201 poi_stack[poi_stack_nr++] = obj_offset;
2202 /* If parsing the base offset fails, just unwind */
2203 base_offset = get_delta_base(p, w_curs, &curpos, type, obj_offset);
2206 curpos = obj_offset = base_offset;
2207 type = unpack_object_header(p, w_curs, &curpos, &size);
2208 if (type <= OBJ_NONE) {
2209 /* If getting the base itself fails, we first
2210 * retry the base, otherwise unwind */
2211 type = retry_bad_packed_offset(p, base_offset);
2212 if (type > OBJ_NONE)
2226 error("unknown object type %i at offset %"PRIuMAX" in %s",
2227 type, (uintmax_t)obj_offset, p->pack_name);
2232 if (poi_stack != small_poi_stack)
2237 while (poi_stack_nr) {
2238 obj_offset = poi_stack[--poi_stack_nr];
2239 type = retry_bad_packed_offset(p, obj_offset);
2240 if (type > OBJ_NONE)
2247 int packed_object_info(struct packed_git *p, off_t obj_offset,
2248 struct object_info *oi)
2250 struct pack_window *w_curs = NULL;
2252 off_t curpos = obj_offset;
2253 enum object_type type;
2256 * We always get the representation type, but only convert it to
2257 * a "real" type later if the caller is interested.
2259 type = unpack_object_header(p, &w_curs, &curpos, &size);
2262 if (type == OBJ_OFS_DELTA || type == OBJ_REF_DELTA) {
2263 off_t tmp_pos = curpos;
2264 off_t base_offset = get_delta_base(p, &w_curs, &tmp_pos,
2270 *oi->sizep = get_size_from_delta(p, &w_curs, tmp_pos);
2271 if (*oi->sizep == 0) {
2280 if (oi->disk_sizep) {
2281 struct revindex_entry *revidx = find_pack_revindex(p, obj_offset);
2282 *oi->disk_sizep = revidx[1].offset - obj_offset;
2286 *oi->typep = packed_to_object_type(p, obj_offset, type, &w_curs, curpos);
2287 if (*oi->typep < 0) {
2293 if (oi->delta_base_sha1) {
2294 if (type == OBJ_OFS_DELTA || type == OBJ_REF_DELTA) {
2295 const unsigned char *base;
2297 base = get_delta_base_sha1(p, &w_curs, curpos,
2304 hashcpy(oi->delta_base_sha1, base);
2306 hashclr(oi->delta_base_sha1);
2310 unuse_pack(&w_curs);
2314 static void *unpack_compressed_entry(struct packed_git *p,
2315 struct pack_window **w_curs,
2321 unsigned char *buffer, *in;
2323 buffer = xmallocz_gently(size);
2326 memset(&stream, 0, sizeof(stream));
2327 stream.next_out = buffer;
2328 stream.avail_out = size + 1;
2330 git_inflate_init(&stream);
2332 in = use_pack(p, w_curs, curpos, &stream.avail_in);
2333 stream.next_in = in;
2334 st = git_inflate(&stream, Z_FINISH);
2335 if (!stream.avail_out)
2336 break; /* the payload is larger than it should be */
2337 curpos += stream.next_in - in;
2338 } while (st == Z_OK || st == Z_BUF_ERROR);
2339 git_inflate_end(&stream);
2340 if ((st != Z_STREAM_END) || stream.total_out != size) {
2348 static struct hashmap delta_base_cache;
2349 static size_t delta_base_cached;
2351 static LIST_HEAD(delta_base_cache_lru);
2353 struct delta_base_cache_key {
2354 struct packed_git *p;
2358 struct delta_base_cache_entry {
2359 struct hashmap hash;
2360 struct delta_base_cache_key key;
2361 struct list_head lru;
2364 enum object_type type;
2367 static unsigned int pack_entry_hash(struct packed_git *p, off_t base_offset)
2371 hash = (unsigned int)(intptr_t)p + (unsigned int)base_offset;
2372 hash += (hash >> 8) + (hash >> 16);
2376 static struct delta_base_cache_entry *
2377 get_delta_base_cache_entry(struct packed_git *p, off_t base_offset)
2379 struct hashmap_entry entry;
2380 struct delta_base_cache_key key;
2382 if (!delta_base_cache.cmpfn)
2385 hashmap_entry_init(&entry, pack_entry_hash(p, base_offset));
2387 key.base_offset = base_offset;
2388 return hashmap_get(&delta_base_cache, &entry, &key);
2391 static int delta_base_cache_key_eq(const struct delta_base_cache_key *a,
2392 const struct delta_base_cache_key *b)
2394 return a->p == b->p && a->base_offset == b->base_offset;
2397 static int delta_base_cache_hash_cmp(const void *va, const void *vb,
2400 const struct delta_base_cache_entry *a = va, *b = vb;
2401 const struct delta_base_cache_key *key = vkey;
2403 return !delta_base_cache_key_eq(&a->key, key);
2405 return !delta_base_cache_key_eq(&a->key, &b->key);
2408 static int in_delta_base_cache(struct packed_git *p, off_t base_offset)
2410 return !!get_delta_base_cache_entry(p, base_offset);
2414 * Remove the entry from the cache, but do _not_ free the associated
2415 * entry data. The caller takes ownership of the "data" buffer, and
2416 * should copy out any fields it wants before detaching.
2418 static void detach_delta_base_cache_entry(struct delta_base_cache_entry *ent)
2420 hashmap_remove(&delta_base_cache, ent, &ent->key);
2421 list_del(&ent->lru);
2422 delta_base_cached -= ent->size;
2426 static void *cache_or_unpack_entry(struct packed_git *p, off_t base_offset,
2427 unsigned long *base_size, enum object_type *type)
2429 struct delta_base_cache_entry *ent;
2431 ent = get_delta_base_cache_entry(p, base_offset);
2433 return unpack_entry(p, base_offset, type, base_size);
2436 *base_size = ent->size;
2437 return xmemdupz(ent->data, ent->size);
2440 static inline void release_delta_base_cache(struct delta_base_cache_entry *ent)
2443 detach_delta_base_cache_entry(ent);
2446 void clear_delta_base_cache(void)
2448 struct list_head *lru, *tmp;
2449 list_for_each_safe(lru, tmp, &delta_base_cache_lru) {
2450 struct delta_base_cache_entry *entry =
2451 list_entry(lru, struct delta_base_cache_entry, lru);
2452 release_delta_base_cache(entry);
2456 static void add_delta_base_cache(struct packed_git *p, off_t base_offset,
2457 void *base, unsigned long base_size, enum object_type type)
2459 struct delta_base_cache_entry *ent = xmalloc(sizeof(*ent));
2460 struct list_head *lru, *tmp;
2462 delta_base_cached += base_size;
2464 list_for_each_safe(lru, tmp, &delta_base_cache_lru) {
2465 struct delta_base_cache_entry *f =
2466 list_entry(lru, struct delta_base_cache_entry, lru);
2467 if (delta_base_cached <= delta_base_cache_limit)
2469 release_delta_base_cache(f);
2473 ent->key.base_offset = base_offset;
2476 ent->size = base_size;
2477 list_add_tail(&ent->lru, &delta_base_cache_lru);
2479 if (!delta_base_cache.cmpfn)
2480 hashmap_init(&delta_base_cache, delta_base_cache_hash_cmp, 0);
2481 hashmap_entry_init(ent, pack_entry_hash(p, base_offset));
2482 hashmap_add(&delta_base_cache, ent);
2485 static void *read_object(const unsigned char *sha1, enum object_type *type,
2486 unsigned long *size);
2488 static void write_pack_access_log(struct packed_git *p, off_t obj_offset)
2490 static struct trace_key pack_access = TRACE_KEY_INIT(PACK_ACCESS);
2491 trace_printf_key(&pack_access, "%s %"PRIuMAX"\n",
2492 p->pack_name, (uintmax_t)obj_offset);
2495 int do_check_packed_object_crc;
2497 #define UNPACK_ENTRY_STACK_PREALLOC 64
2498 struct unpack_entry_stack_ent {
2504 void *unpack_entry(struct packed_git *p, off_t obj_offset,
2505 enum object_type *final_type, unsigned long *final_size)
2507 struct pack_window *w_curs = NULL;
2508 off_t curpos = obj_offset;
2511 enum object_type type;
2512 struct unpack_entry_stack_ent small_delta_stack[UNPACK_ENTRY_STACK_PREALLOC];
2513 struct unpack_entry_stack_ent *delta_stack = small_delta_stack;
2514 int delta_stack_nr = 0, delta_stack_alloc = UNPACK_ENTRY_STACK_PREALLOC;
2515 int base_from_cache = 0;
2517 write_pack_access_log(p, obj_offset);
2519 /* PHASE 1: drill down to the innermost base object */
2523 struct delta_base_cache_entry *ent;
2525 ent = get_delta_base_cache_entry(p, curpos);
2530 detach_delta_base_cache_entry(ent);
2531 base_from_cache = 1;
2535 if (do_check_packed_object_crc && p->index_version > 1) {
2536 struct revindex_entry *revidx = find_pack_revindex(p, obj_offset);
2537 off_t len = revidx[1].offset - obj_offset;
2538 if (check_pack_crc(p, &w_curs, obj_offset, len, revidx->nr)) {
2539 const unsigned char *sha1 =
2540 nth_packed_object_sha1(p, revidx->nr);
2541 error("bad packed object CRC for %s",
2543 mark_bad_packed_object(p, sha1);
2544 unuse_pack(&w_curs);
2549 type = unpack_object_header(p, &w_curs, &curpos, &size);
2550 if (type != OBJ_OFS_DELTA && type != OBJ_REF_DELTA)
2553 base_offset = get_delta_base(p, &w_curs, &curpos, type, obj_offset);
2555 error("failed to validate delta base reference "
2556 "at offset %"PRIuMAX" from %s",
2557 (uintmax_t)curpos, p->pack_name);
2558 /* bail to phase 2, in hopes of recovery */
2563 /* push object, proceed to base */
2564 if (delta_stack_nr >= delta_stack_alloc
2565 && delta_stack == small_delta_stack) {
2566 delta_stack_alloc = alloc_nr(delta_stack_nr);
2567 ALLOC_ARRAY(delta_stack, delta_stack_alloc);
2568 memcpy(delta_stack, small_delta_stack,
2569 sizeof(*delta_stack)*delta_stack_nr);
2571 ALLOC_GROW(delta_stack, delta_stack_nr+1, delta_stack_alloc);
2573 i = delta_stack_nr++;
2574 delta_stack[i].obj_offset = obj_offset;
2575 delta_stack[i].curpos = curpos;
2576 delta_stack[i].size = size;
2578 curpos = obj_offset = base_offset;
2581 /* PHASE 2: handle the base */
2586 die("BUG: unpack_entry: left loop at a valid delta");
2592 if (!base_from_cache)
2593 data = unpack_compressed_entry(p, &w_curs, curpos, size);
2597 error("unknown object type %i at offset %"PRIuMAX" in %s",
2598 type, (uintmax_t)obj_offset, p->pack_name);
2601 /* PHASE 3: apply deltas in order */
2604 * 'data' holds the base data, or NULL if there was corruption
2606 while (delta_stack_nr) {
2609 void *external_base = NULL;
2610 unsigned long delta_size, base_size = size;
2616 add_delta_base_cache(p, obj_offset, base, base_size, type);
2620 * We're probably in deep shit, but let's try to fetch
2621 * the required base anyway from another pack or loose.
2622 * This is costly but should happen only in the presence
2623 * of a corrupted pack, and is better than failing outright.
2625 struct revindex_entry *revidx;
2626 const unsigned char *base_sha1;
2627 revidx = find_pack_revindex(p, obj_offset);
2629 base_sha1 = nth_packed_object_sha1(p, revidx->nr);
2630 error("failed to read delta base object %s"
2631 " at offset %"PRIuMAX" from %s",
2632 sha1_to_hex(base_sha1), (uintmax_t)obj_offset,
2634 mark_bad_packed_object(p, base_sha1);
2635 base = read_object(base_sha1, &type, &base_size);
2636 external_base = base;
2640 i = --delta_stack_nr;
2641 obj_offset = delta_stack[i].obj_offset;
2642 curpos = delta_stack[i].curpos;
2643 delta_size = delta_stack[i].size;
2648 delta_data = unpack_compressed_entry(p, &w_curs, curpos, delta_size);
2651 error("failed to unpack compressed delta "
2652 "at offset %"PRIuMAX" from %s",
2653 (uintmax_t)curpos, p->pack_name);
2655 free(external_base);
2659 data = patch_delta(base, base_size,
2660 delta_data, delta_size,
2664 * We could not apply the delta; warn the user, but keep going.
2665 * Our failure will be noticed either in the next iteration of
2666 * the loop, or if this is the final delta, in the caller when
2667 * we return NULL. Those code paths will take care of making
2668 * a more explicit warning and retrying with another copy of
2672 error("failed to apply delta");
2675 free(external_base);
2681 unuse_pack(&w_curs);
2683 if (delta_stack != small_delta_stack)
2689 const unsigned char *nth_packed_object_sha1(struct packed_git *p,
2692 const unsigned char *index = p->index_data;
2694 if (open_pack_index(p))
2696 index = p->index_data;
2698 if (n >= p->num_objects)
2701 if (p->index_version == 1) {
2702 return index + 24 * n + 4;
2705 return index + 20 * n;
2709 const struct object_id *nth_packed_object_oid(struct object_id *oid,
2710 struct packed_git *p,
2713 const unsigned char *hash = nth_packed_object_sha1(p, n);
2716 hashcpy(oid->hash, hash);
2720 void check_pack_index_ptr(const struct packed_git *p, const void *vptr)
2722 const unsigned char *ptr = vptr;
2723 const unsigned char *start = p->index_data;
2724 const unsigned char *end = start + p->index_size;
2726 die(_("offset before start of pack index for %s (corrupt index?)"),
2728 /* No need to check for underflow; .idx files must be at least 8 bytes */
2730 die(_("offset beyond end of pack index for %s (truncated index?)"),
2734 off_t nth_packed_object_offset(const struct packed_git *p, uint32_t n)
2736 const unsigned char *index = p->index_data;
2738 if (p->index_version == 1) {
2739 return ntohl(*((uint32_t *)(index + 24 * n)));
2742 index += 8 + p->num_objects * (20 + 4);
2743 off = ntohl(*((uint32_t *)(index + 4 * n)));
2744 if (!(off & 0x80000000))
2746 index += p->num_objects * 4 + (off & 0x7fffffff) * 8;
2747 check_pack_index_ptr(p, index);
2748 return (((uint64_t)ntohl(*((uint32_t *)(index + 0)))) << 32) |
2749 ntohl(*((uint32_t *)(index + 4)));
2753 off_t find_pack_entry_one(const unsigned char *sha1,
2754 struct packed_git *p)
2756 const uint32_t *level1_ofs = p->index_data;
2757 const unsigned char *index = p->index_data;
2758 unsigned hi, lo, stride;
2759 static int use_lookup = -1;
2760 static int debug_lookup = -1;
2762 if (debug_lookup < 0)
2763 debug_lookup = !!getenv("GIT_DEBUG_LOOKUP");
2766 if (open_pack_index(p))
2768 level1_ofs = p->index_data;
2769 index = p->index_data;
2771 if (p->index_version > 1) {
2776 hi = ntohl(level1_ofs[*sha1]);
2777 lo = ((*sha1 == 0x0) ? 0 : ntohl(level1_ofs[*sha1 - 1]));
2778 if (p->index_version > 1) {
2786 printf("%02x%02x%02x... lo %u hi %u nr %"PRIu32"\n",
2787 sha1[0], sha1[1], sha1[2], lo, hi, p->num_objects);
2790 use_lookup = !!getenv("GIT_USE_LOOKUP");
2792 int pos = sha1_entry_pos(index, stride, 0,
2793 lo, hi, p->num_objects, sha1);
2796 return nth_packed_object_offset(p, pos);
2800 unsigned mi = (lo + hi) / 2;
2801 int cmp = hashcmp(index + mi * stride, sha1);
2804 printf("lo %u hi %u rg %u mi %u\n",
2805 lo, hi, hi - lo, mi);
2807 return nth_packed_object_offset(p, mi);
2816 int is_pack_valid(struct packed_git *p)
2818 /* An already open pack is known to be valid. */
2819 if (p->pack_fd != -1)
2822 /* If the pack has one window completely covering the
2823 * file size, the pack is known to be valid even if
2824 * the descriptor is not currently open.
2827 struct pack_window *w = p->windows;
2829 if (!w->offset && w->len == p->pack_size)
2833 /* Force the pack to open to prove its valid. */
2834 return !open_packed_git(p);
2837 static int fill_pack_entry(const unsigned char *sha1,
2838 struct pack_entry *e,
2839 struct packed_git *p)
2843 if (p->num_bad_objects) {
2845 for (i = 0; i < p->num_bad_objects; i++)
2846 if (!hashcmp(sha1, p->bad_object_sha1 + 20 * i))
2850 offset = find_pack_entry_one(sha1, p);
2855 * We are about to tell the caller where they can locate the
2856 * requested object. We better make sure the packfile is
2857 * still here and can be accessed before supplying that
2858 * answer, as it may have been deleted since the index was
2861 if (!is_pack_valid(p))
2865 hashcpy(e->sha1, sha1);
2870 * Iff a pack file contains the object named by sha1, return true and
2871 * store its location to e.
2873 static int find_pack_entry(const unsigned char *sha1, struct pack_entry *e)
2875 struct mru_entry *p;
2877 prepare_packed_git();
2881 for (p = packed_git_mru->head; p; p = p->next) {
2882 if (fill_pack_entry(sha1, e, p->item)) {
2883 mru_mark(packed_git_mru, p);
2890 struct packed_git *find_sha1_pack(const unsigned char *sha1,
2891 struct packed_git *packs)
2893 struct packed_git *p;
2895 for (p = packs; p; p = p->next) {
2896 if (find_pack_entry_one(sha1, p))
2903 static int sha1_loose_object_info(const unsigned char *sha1,
2904 struct object_info *oi,
2908 unsigned long mapsize;
2912 struct strbuf hdrbuf = STRBUF_INIT;
2914 if (oi->delta_base_sha1)
2915 hashclr(oi->delta_base_sha1);
2918 * If we don't care about type or size, then we don't
2919 * need to look inside the object at all. Note that we
2920 * do not optimize out the stat call, even if the
2921 * caller doesn't care about the disk-size, since our
2922 * return value implicitly indicates whether the
2923 * object even exists.
2925 if (!oi->typep && !oi->typename && !oi->sizep) {
2928 if (stat_sha1_file(sha1, &st, &path) < 0)
2931 *oi->disk_sizep = st.st_size;
2935 map = map_sha1_file(sha1, &mapsize);
2939 *oi->disk_sizep = mapsize;
2940 if ((flags & LOOKUP_UNKNOWN_OBJECT)) {
2941 if (unpack_sha1_header_to_strbuf(&stream, map, mapsize, hdr, sizeof(hdr), &hdrbuf) < 0)
2942 status = error("unable to unpack %s header with --allow-unknown-type",
2944 } else if (unpack_sha1_header(&stream, map, mapsize, hdr, sizeof(hdr)) < 0)
2945 status = error("unable to unpack %s header",
2949 else if (hdrbuf.len) {
2950 if ((status = parse_sha1_header_extended(hdrbuf.buf, oi, flags)) < 0)
2951 status = error("unable to parse %s header with --allow-unknown-type",
2953 } else if ((status = parse_sha1_header_extended(hdr, oi, flags)) < 0)
2954 status = error("unable to parse %s header", sha1_to_hex(sha1));
2955 git_inflate_end(&stream);
2956 munmap(map, mapsize);
2957 if (status && oi->typep)
2958 *oi->typep = status;
2959 strbuf_release(&hdrbuf);
2963 int sha1_object_info_extended(const unsigned char *sha1, struct object_info *oi, unsigned flags)
2965 struct cached_object *co;
2966 struct pack_entry e;
2968 enum object_type real_type;
2969 const unsigned char *real = lookup_replace_object_extended(sha1, flags);
2971 co = find_cached_object(real);
2974 *(oi->typep) = co->type;
2976 *(oi->sizep) = co->size;
2978 *(oi->disk_sizep) = 0;
2979 if (oi->delta_base_sha1)
2980 hashclr(oi->delta_base_sha1);
2982 strbuf_addstr(oi->typename, typename(co->type));
2983 oi->whence = OI_CACHED;
2987 if (!find_pack_entry(real, &e)) {
2988 /* Most likely it's a loose object. */
2989 if (!sha1_loose_object_info(real, oi, flags)) {
2990 oi->whence = OI_LOOSE;
2994 /* Not a loose object; someone else may have just packed it. */
2995 reprepare_packed_git();
2996 if (!find_pack_entry(real, &e))
3001 * packed_object_info() does not follow the delta chain to
3002 * find out the real type, unless it is given oi->typep.
3004 if (oi->typename && !oi->typep)
3005 oi->typep = &real_type;
3007 rtype = packed_object_info(e.p, e.offset, oi);
3009 mark_bad_packed_object(e.p, real);
3010 if (oi->typep == &real_type)
3012 return sha1_object_info_extended(real, oi, 0);
3013 } else if (in_delta_base_cache(e.p, e.offset)) {
3014 oi->whence = OI_DBCACHED;
3016 oi->whence = OI_PACKED;
3017 oi->u.packed.offset = e.offset;
3018 oi->u.packed.pack = e.p;
3019 oi->u.packed.is_delta = (rtype == OBJ_REF_DELTA ||
3020 rtype == OBJ_OFS_DELTA);
3023 strbuf_addstr(oi->typename, typename(*oi->typep));
3024 if (oi->typep == &real_type)
3030 /* returns enum object_type or negative */
3031 int sha1_object_info(const unsigned char *sha1, unsigned long *sizep)
3033 enum object_type type;
3034 struct object_info oi = OBJECT_INFO_INIT;
3038 if (sha1_object_info_extended(sha1, &oi, LOOKUP_REPLACE_OBJECT) < 0)
3043 static void *read_packed_sha1(const unsigned char *sha1,
3044 enum object_type *type, unsigned long *size)
3046 struct pack_entry e;
3049 if (!find_pack_entry(sha1, &e))
3051 data = cache_or_unpack_entry(e.p, e.offset, size, type);
3054 * We're probably in deep shit, but let's try to fetch
3055 * the required object anyway from another pack or loose.
3056 * This should happen only in the presence of a corrupted
3057 * pack, and is better than failing outright.
3059 error("failed to read object %s at offset %"PRIuMAX" from %s",
3060 sha1_to_hex(sha1), (uintmax_t)e.offset, e.p->pack_name);
3061 mark_bad_packed_object(e.p, sha1);
3062 data = read_object(sha1, type, size);
3067 int pretend_sha1_file(void *buf, unsigned long len, enum object_type type,
3068 unsigned char *sha1)
3070 struct cached_object *co;
3072 hash_sha1_file(buf, len, typename(type), sha1);
3073 if (has_sha1_file(sha1) || find_cached_object(sha1))
3075 ALLOC_GROW(cached_objects, cached_object_nr + 1, cached_object_alloc);
3076 co = &cached_objects[cached_object_nr++];
3079 co->buf = xmalloc(len);
3080 memcpy(co->buf, buf, len);
3081 hashcpy(co->sha1, sha1);
3085 static void *read_object(const unsigned char *sha1, enum object_type *type,
3086 unsigned long *size)
3088 unsigned long mapsize;
3090 struct cached_object *co;
3092 co = find_cached_object(sha1);
3096 return xmemdupz(co->buf, co->size);
3099 buf = read_packed_sha1(sha1, type, size);
3102 map = map_sha1_file(sha1, &mapsize);
3104 buf = unpack_sha1_file(map, mapsize, type, size, sha1);
3105 munmap(map, mapsize);
3108 reprepare_packed_git();
3109 return read_packed_sha1(sha1, type, size);
3113 * This function dies on corrupt objects; the callers who want to
3114 * deal with them should arrange to call read_object() and give error
3115 * messages themselves.
3117 void *read_sha1_file_extended(const unsigned char *sha1,
3118 enum object_type *type,
3119 unsigned long *size,
3123 const struct packed_git *p;
3126 const unsigned char *repl = lookup_replace_object_extended(sha1, flag);
3129 data = read_object(repl, type, size);
3133 if (errno && errno != ENOENT)
3134 die_errno("failed to read object %s", sha1_to_hex(sha1));
3136 /* die if we replaced an object with one that does not exist */
3138 die("replacement %s not found for %s",
3139 sha1_to_hex(repl), sha1_to_hex(sha1));
3141 if (!stat_sha1_file(repl, &st, &path))
3142 die("loose object %s (stored in %s) is corrupt",
3143 sha1_to_hex(repl), path);
3145 if ((p = has_packed_and_bad(repl)) != NULL)
3146 die("packed object %s (stored in %s) is corrupt",
3147 sha1_to_hex(repl), p->pack_name);
3152 void *read_object_with_reference(const unsigned char *sha1,
3153 const char *required_type_name,
3154 unsigned long *size,
3155 unsigned char *actual_sha1_return)
3157 enum object_type type, required_type;
3159 unsigned long isize;
3160 unsigned char actual_sha1[20];
3162 required_type = type_from_string(required_type_name);
3163 hashcpy(actual_sha1, sha1);
3165 int ref_length = -1;
3166 const char *ref_type = NULL;
3168 buffer = read_sha1_file(actual_sha1, &type, &isize);
3171 if (type == required_type) {
3173 if (actual_sha1_return)
3174 hashcpy(actual_sha1_return, actual_sha1);
3177 /* Handle references */
3178 else if (type == OBJ_COMMIT)
3180 else if (type == OBJ_TAG)
3181 ref_type = "object ";
3186 ref_length = strlen(ref_type);
3188 if (ref_length + 40 > isize ||
3189 memcmp(buffer, ref_type, ref_length) ||
3190 get_sha1_hex((char *) buffer + ref_length, actual_sha1)) {
3195 /* Now we have the ID of the referred-to object in
3196 * actual_sha1. Check again. */
3200 static void write_sha1_file_prepare(const void *buf, unsigned long len,
3201 const char *type, unsigned char *sha1,
3202 char *hdr, int *hdrlen)
3206 /* Generate the header */
3207 *hdrlen = xsnprintf(hdr, *hdrlen, "%s %lu", type, len)+1;
3211 git_SHA1_Update(&c, hdr, *hdrlen);
3212 git_SHA1_Update(&c, buf, len);
3213 git_SHA1_Final(sha1, &c);
3217 * Move the just written object into its final resting place.
3219 int finalize_object_file(const char *tmpfile, const char *filename)
3223 if (object_creation_mode == OBJECT_CREATION_USES_RENAMES)
3225 else if (link(tmpfile, filename))
3229 * Coda hack - coda doesn't like cross-directory links,
3230 * so we fall back to a rename, which will mean that it
3231 * won't be able to check collisions, but that's not a
3234 * The same holds for FAT formatted media.
3236 * When this succeeds, we just return. We have nothing
3239 if (ret && ret != EEXIST) {
3241 if (!rename(tmpfile, filename))
3245 unlink_or_warn(tmpfile);
3247 if (ret != EEXIST) {
3248 return error_errno("unable to write sha1 filename %s", filename);
3250 /* FIXME!!! Collision check here ? */
3254 if (adjust_shared_perm(filename))
3255 return error("unable to set permission to '%s'", filename);
3259 static int write_buffer(int fd, const void *buf, size_t len)
3261 if (write_in_full(fd, buf, len) < 0)
3262 return error_errno("file write error");
3266 int hash_sha1_file(const void *buf, unsigned long len, const char *type,
3267 unsigned char *sha1)
3270 int hdrlen = sizeof(hdr);
3271 write_sha1_file_prepare(buf, len, type, sha1, hdr, &hdrlen);
3275 /* Finalize a file on disk, and close it. */
3276 static void close_sha1_file(int fd)
3278 if (fsync_object_files)
3279 fsync_or_die(fd, "sha1 file");
3281 die_errno("error when closing sha1 file");
3284 /* Size of directory component, including the ending '/' */
3285 static inline int directory_size(const char *filename)
3287 const char *s = strrchr(filename, '/');
3290 return s - filename + 1;
3294 * This creates a temporary file in the same directory as the final
3297 * We want to avoid cross-directory filename renames, because those
3298 * can have problems on various filesystems (FAT, NFS, Coda).
3300 static int create_tmpfile(struct strbuf *tmp, const char *filename)
3302 int fd, dirlen = directory_size(filename);
3305 strbuf_add(tmp, filename, dirlen);
3306 strbuf_addstr(tmp, "tmp_obj_XXXXXX");
3307 fd = git_mkstemp_mode(tmp->buf, 0444);
3308 if (fd < 0 && dirlen && errno == ENOENT) {
3310 * Make sure the directory exists; note that the contents
3311 * of the buffer are undefined after mkstemp returns an
3312 * error, so we have to rewrite the whole buffer from
3316 strbuf_add(tmp, filename, dirlen - 1);
3317 if (mkdir(tmp->buf, 0777) && errno != EEXIST)
3319 if (adjust_shared_perm(tmp->buf))
3323 strbuf_addstr(tmp, "/tmp_obj_XXXXXX");
3324 fd = git_mkstemp_mode(tmp->buf, 0444);
3329 static int write_loose_object(const unsigned char *sha1, char *hdr, int hdrlen,
3330 const void *buf, unsigned long len, time_t mtime)
3333 unsigned char compressed[4096];
3336 unsigned char parano_sha1[20];
3337 static struct strbuf tmp_file = STRBUF_INIT;
3338 const char *filename = sha1_file_name(sha1);
3340 fd = create_tmpfile(&tmp_file, filename);
3342 if (errno == EACCES)
3343 return error("insufficient permission for adding an object to repository database %s", get_object_directory());
3345 return error_errno("unable to create temporary file");
3349 git_deflate_init(&stream, zlib_compression_level);
3350 stream.next_out = compressed;
3351 stream.avail_out = sizeof(compressed);
3354 /* First header.. */
3355 stream.next_in = (unsigned char *)hdr;
3356 stream.avail_in = hdrlen;
3357 while (git_deflate(&stream, 0) == Z_OK)
3359 git_SHA1_Update(&c, hdr, hdrlen);
3361 /* Then the data itself.. */
3362 stream.next_in = (void *)buf;
3363 stream.avail_in = len;
3365 unsigned char *in0 = stream.next_in;
3366 ret = git_deflate(&stream, Z_FINISH);
3367 git_SHA1_Update(&c, in0, stream.next_in - in0);
3368 if (write_buffer(fd, compressed, stream.next_out - compressed) < 0)
3369 die("unable to write sha1 file");
3370 stream.next_out = compressed;
3371 stream.avail_out = sizeof(compressed);
3372 } while (ret == Z_OK);
3374 if (ret != Z_STREAM_END)
3375 die("unable to deflate new object %s (%d)", sha1_to_hex(sha1), ret);
3376 ret = git_deflate_end_gently(&stream);
3378 die("deflateEnd on object %s failed (%d)", sha1_to_hex(sha1), ret);
3379 git_SHA1_Final(parano_sha1, &c);
3380 if (hashcmp(sha1, parano_sha1) != 0)
3381 die("confused by unstable object source data for %s", sha1_to_hex(sha1));
3383 close_sha1_file(fd);
3388 utb.modtime = mtime;
3389 if (utime(tmp_file.buf, &utb) < 0)
3390 warning_errno("failed utime() on %s", tmp_file.buf);
3393 return finalize_object_file(tmp_file.buf, filename);
3396 static int freshen_loose_object(const unsigned char *sha1)
3398 return check_and_freshen(sha1, 1);
3401 static int freshen_packed_object(const unsigned char *sha1)
3403 struct pack_entry e;
3404 if (!find_pack_entry(sha1, &e))
3408 if (!freshen_file(e.p->pack_name))
3414 int write_sha1_file(const void *buf, unsigned long len, const char *type, unsigned char *sha1)
3417 int hdrlen = sizeof(hdr);
3419 /* Normally if we have it in the pack then we do not bother writing
3420 * it out into .git/objects/??/?{38} file.
3422 write_sha1_file_prepare(buf, len, type, sha1, hdr, &hdrlen);
3423 if (freshen_packed_object(sha1) || freshen_loose_object(sha1))
3425 return write_loose_object(sha1, hdr, hdrlen, buf, len, 0);
3428 int hash_sha1_file_literally(const void *buf, unsigned long len, const char *type,
3429 unsigned char *sha1, unsigned flags)
3432 int hdrlen, status = 0;
3434 /* type string, SP, %lu of the length plus NUL must fit this */
3435 hdrlen = strlen(type) + 32;
3436 header = xmalloc(hdrlen);
3437 write_sha1_file_prepare(buf, len, type, sha1, header, &hdrlen);
3439 if (!(flags & HASH_WRITE_OBJECT))
3441 if (freshen_packed_object(sha1) || freshen_loose_object(sha1))
3443 status = write_loose_object(sha1, header, hdrlen, buf, len, 0);
3450 int force_object_loose(const unsigned char *sha1, time_t mtime)
3454 enum object_type type;
3459 if (has_loose_object(sha1))
3461 buf = read_packed_sha1(sha1, &type, &len);
3463 return error("cannot read sha1_file for %s", sha1_to_hex(sha1));
3464 hdrlen = xsnprintf(hdr, sizeof(hdr), "%s %lu", typename(type), len) + 1;
3465 ret = write_loose_object(sha1, hdr, hdrlen, buf, len, mtime);
3471 int has_pack_index(const unsigned char *sha1)
3474 if (stat(sha1_pack_index_name(sha1), &st))
3479 int has_sha1_pack(const unsigned char *sha1)
3481 struct pack_entry e;
3482 return find_pack_entry(sha1, &e);
3485 int has_sha1_file_with_flags(const unsigned char *sha1, int flags)
3487 struct pack_entry e;
3489 if (find_pack_entry(sha1, &e))
3491 if (has_loose_object(sha1))
3493 if (flags & HAS_SHA1_QUICK)
3495 reprepare_packed_git();
3496 return find_pack_entry(sha1, &e);
3499 int has_object_file(const struct object_id *oid)
3501 return has_sha1_file(oid->hash);
3504 int has_object_file_with_flags(const struct object_id *oid, int flags)
3506 return has_sha1_file_with_flags(oid->hash, flags);
3509 static void check_tree(const void *buf, size_t size)
3511 struct tree_desc desc;
3512 struct name_entry entry;
3514 init_tree_desc(&desc, buf, size);
3515 while (tree_entry(&desc, &entry))
3517 * tree_entry() will die() on malformed entries */
3521 static void check_commit(const void *buf, size_t size)
3524 memset(&c, 0, sizeof(c));
3525 if (parse_commit_buffer(&c, buf, size))
3526 die("corrupt commit");
3529 static void check_tag(const void *buf, size_t size)
3532 memset(&t, 0, sizeof(t));
3533 if (parse_tag_buffer(&t, buf, size))
3537 static int index_mem(unsigned char *sha1, void *buf, size_t size,
3538 enum object_type type,
3539 const char *path, unsigned flags)
3541 int ret, re_allocated = 0;
3542 int write_object = flags & HASH_WRITE_OBJECT;
3548 * Convert blobs to git internal format
3550 if ((type == OBJ_BLOB) && path) {
3551 struct strbuf nbuf = STRBUF_INIT;
3552 if (convert_to_git(path, buf, size, &nbuf,
3553 write_object ? safe_crlf : SAFE_CRLF_FALSE)) {
3554 buf = strbuf_detach(&nbuf, &size);
3558 if (flags & HASH_FORMAT_CHECK) {
3559 if (type == OBJ_TREE)
3560 check_tree(buf, size);
3561 if (type == OBJ_COMMIT)
3562 check_commit(buf, size);
3563 if (type == OBJ_TAG)
3564 check_tag(buf, size);
3568 ret = write_sha1_file(buf, size, typename(type), sha1);
3570 ret = hash_sha1_file(buf, size, typename(type), sha1);
3576 static int index_stream_convert_blob(unsigned char *sha1, int fd,
3577 const char *path, unsigned flags)
3580 const int write_object = flags & HASH_WRITE_OBJECT;
3581 struct strbuf sbuf = STRBUF_INIT;
3584 assert(would_convert_to_git_filter_fd(path));
3586 convert_to_git_filter_fd(path, fd, &sbuf,
3587 write_object ? safe_crlf : SAFE_CRLF_FALSE);
3590 ret = write_sha1_file(sbuf.buf, sbuf.len, typename(OBJ_BLOB),
3593 ret = hash_sha1_file(sbuf.buf, sbuf.len, typename(OBJ_BLOB),
3595 strbuf_release(&sbuf);
3599 static int index_pipe(unsigned char *sha1, int fd, enum object_type type,
3600 const char *path, unsigned flags)
3602 struct strbuf sbuf = STRBUF_INIT;
3605 if (strbuf_read(&sbuf, fd, 4096) >= 0)
3606 ret = index_mem(sha1, sbuf.buf, sbuf.len, type, path, flags);
3609 strbuf_release(&sbuf);
3613 #define SMALL_FILE_SIZE (32*1024)
3615 static int index_core(unsigned char *sha1, int fd, size_t size,
3616 enum object_type type, const char *path,
3622 ret = index_mem(sha1, "", size, type, path, flags);
3623 } else if (size <= SMALL_FILE_SIZE) {
3624 char *buf = xmalloc(size);
3625 if (size == read_in_full(fd, buf, size))
3626 ret = index_mem(sha1, buf, size, type, path, flags);
3628 ret = error_errno("short read");
3631 void *buf = xmmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);
3632 ret = index_mem(sha1, buf, size, type, path, flags);
3639 * This creates one packfile per large blob unless bulk-checkin
3640 * machinery is "plugged".
3642 * This also bypasses the usual "convert-to-git" dance, and that is on
3643 * purpose. We could write a streaming version of the converting
3644 * functions and insert that before feeding the data to fast-import
3645 * (or equivalent in-core API described above). However, that is
3646 * somewhat complicated, as we do not know the size of the filter
3647 * result, which we need to know beforehand when writing a git object.
3648 * Since the primary motivation for trying to stream from the working
3649 * tree file and to avoid mmaping it in core is to deal with large
3650 * binary blobs, they generally do not want to get any conversion, and
3651 * callers should avoid this code path when filters are requested.
3653 static int index_stream(unsigned char *sha1, int fd, size_t size,
3654 enum object_type type, const char *path,
3657 return index_bulk_checkin(sha1, fd, size, type, path, flags);
3660 int index_fd(unsigned char *sha1, int fd, struct stat *st,
3661 enum object_type type, const char *path, unsigned flags)
3666 * Call xsize_t() only when needed to avoid potentially unnecessary
3667 * die() for large files.
3669 if (type == OBJ_BLOB && path && would_convert_to_git_filter_fd(path))
3670 ret = index_stream_convert_blob(sha1, fd, path, flags);
3671 else if (!S_ISREG(st->st_mode))
3672 ret = index_pipe(sha1, fd, type, path, flags);
3673 else if (st->st_size <= big_file_threshold || type != OBJ_BLOB ||
3674 (path && would_convert_to_git(path)))
3675 ret = index_core(sha1, fd, xsize_t(st->st_size), type, path,
3678 ret = index_stream(sha1, fd, xsize_t(st->st_size), type, path,
3684 int index_path(unsigned char *sha1, const char *path, struct stat *st, unsigned flags)
3687 struct strbuf sb = STRBUF_INIT;
3689 switch (st->st_mode & S_IFMT) {
3691 fd = open(path, O_RDONLY);
3693 return error_errno("open(\"%s\")", path);
3694 if (index_fd(sha1, fd, st, OBJ_BLOB, path, flags) < 0)
3695 return error("%s: failed to insert into database",
3699 if (strbuf_readlink(&sb, path, st->st_size))
3700 return error_errno("readlink(\"%s\")", path);
3701 if (!(flags & HASH_WRITE_OBJECT))
3702 hash_sha1_file(sb.buf, sb.len, blob_type, sha1);
3703 else if (write_sha1_file(sb.buf, sb.len, blob_type, sha1))
3704 return error("%s: failed to insert into database",
3706 strbuf_release(&sb);
3709 return resolve_gitlink_ref(path, "HEAD", sha1);
3711 return error("%s: unsupported file type", path);
3716 int read_pack_header(int fd, struct pack_header *header)
3718 if (read_in_full(fd, header, sizeof(*header)) < sizeof(*header))
3719 /* "eof before pack header was fully read" */
3720 return PH_ERROR_EOF;
3722 if (header->hdr_signature != htonl(PACK_SIGNATURE))
3723 /* "protocol error (pack signature mismatch detected)" */
3724 return PH_ERROR_PACK_SIGNATURE;
3725 if (!pack_version_ok(header->hdr_version))
3726 /* "protocol error (pack version unsupported)" */
3727 return PH_ERROR_PROTOCOL;
3731 void assert_sha1_type(const unsigned char *sha1, enum object_type expect)
3733 enum object_type type = sha1_object_info(sha1, NULL);
3735 die("%s is not a valid object", sha1_to_hex(sha1));
3737 die("%s is not a valid '%s' object", sha1_to_hex(sha1),
3741 static int for_each_file_in_obj_subdir(int subdir_nr,
3742 struct strbuf *path,
3743 each_loose_object_fn obj_cb,
3744 each_loose_cruft_fn cruft_cb,
3745 each_loose_subdir_fn subdir_cb,
3748 size_t baselen = path->len;
3749 DIR *dir = opendir(path->buf);
3754 if (errno == ENOENT)
3756 return error_errno("unable to open %s", path->buf);
3759 while ((de = readdir(dir))) {
3760 if (is_dot_or_dotdot(de->d_name))
3763 strbuf_setlen(path, baselen);
3764 strbuf_addf(path, "/%s", de->d_name);
3766 if (strlen(de->d_name) == GIT_SHA1_HEXSZ - 2) {
3767 char hex[GIT_SHA1_HEXSZ+1];
3768 struct object_id oid;
3770 snprintf(hex, sizeof(hex), "%02x%s",
3771 subdir_nr, de->d_name);
3772 if (!get_oid_hex(hex, &oid)) {
3774 r = obj_cb(&oid, path->buf, data);
3783 r = cruft_cb(de->d_name, path->buf, data);
3790 strbuf_setlen(path, baselen);
3791 if (!r && subdir_cb)
3792 r = subdir_cb(subdir_nr, path->buf, data);
3797 int for_each_loose_file_in_objdir_buf(struct strbuf *path,
3798 each_loose_object_fn obj_cb,
3799 each_loose_cruft_fn cruft_cb,
3800 each_loose_subdir_fn subdir_cb,
3803 size_t baselen = path->len;
3807 for (i = 0; i < 256; i++) {
3808 strbuf_addf(path, "/%02x", i);
3809 r = for_each_file_in_obj_subdir(i, path, obj_cb, cruft_cb,
3811 strbuf_setlen(path, baselen);
3819 int for_each_loose_file_in_objdir(const char *path,
3820 each_loose_object_fn obj_cb,
3821 each_loose_cruft_fn cruft_cb,
3822 each_loose_subdir_fn subdir_cb,
3825 struct strbuf buf = STRBUF_INIT;
3828 strbuf_addstr(&buf, path);
3829 r = for_each_loose_file_in_objdir_buf(&buf, obj_cb, cruft_cb,
3831 strbuf_release(&buf);
3836 struct loose_alt_odb_data {
3837 each_loose_object_fn *cb;
3841 static int loose_from_alt_odb(struct alternate_object_database *alt,
3844 struct loose_alt_odb_data *data = vdata;
3845 struct strbuf buf = STRBUF_INIT;
3848 strbuf_addstr(&buf, alt->path);
3849 r = for_each_loose_file_in_objdir_buf(&buf,
3850 data->cb, NULL, NULL,
3852 strbuf_release(&buf);
3856 int for_each_loose_object(each_loose_object_fn cb, void *data, unsigned flags)
3858 struct loose_alt_odb_data alt;
3861 r = for_each_loose_file_in_objdir(get_object_directory(),
3862 cb, NULL, NULL, data);
3866 if (flags & FOR_EACH_OBJECT_LOCAL_ONLY)
3871 return foreach_alt_odb(loose_from_alt_odb, &alt);
3874 static int for_each_object_in_pack(struct packed_git *p, each_packed_object_fn cb, void *data)
3879 for (i = 0; i < p->num_objects; i++) {
3880 struct object_id oid;
3882 if (!nth_packed_object_oid(&oid, p, i))
3883 return error("unable to get sha1 of object %u in %s",
3886 r = cb(&oid, p, i, data);
3893 int for_each_packed_object(each_packed_object_fn cb, void *data, unsigned flags)
3895 struct packed_git *p;
3897 int pack_errors = 0;
3899 prepare_packed_git();
3900 for (p = packed_git; p; p = p->next) {
3901 if ((flags & FOR_EACH_OBJECT_LOCAL_ONLY) && !p->pack_local)
3903 if (open_pack_index(p)) {
3907 r = for_each_object_in_pack(p, cb, data);
3911 return r ? r : pack_errors;
3914 static int check_stream_sha1(git_zstream *stream,
3918 const unsigned char *expected_sha1)
3921 unsigned char real_sha1[GIT_SHA1_RAWSZ];
3922 unsigned char buf[4096];
3923 unsigned long total_read;
3927 git_SHA1_Update(&c, hdr, stream->total_out);
3930 * We already read some bytes into hdr, but the ones up to the NUL
3931 * do not count against the object's content size.
3933 total_read = stream->total_out - strlen(hdr) - 1;
3936 * This size comparison must be "<=" to read the final zlib packets;
3937 * see the comment in unpack_sha1_rest for details.
3939 while (total_read <= size &&
3940 (status == Z_OK || status == Z_BUF_ERROR)) {
3941 stream->next_out = buf;
3942 stream->avail_out = sizeof(buf);
3943 if (size - total_read < stream->avail_out)
3944 stream->avail_out = size - total_read;
3945 status = git_inflate(stream, Z_FINISH);
3946 git_SHA1_Update(&c, buf, stream->next_out - buf);
3947 total_read += stream->next_out - buf;
3949 git_inflate_end(stream);
3951 if (status != Z_STREAM_END) {
3952 error("corrupt loose object '%s'", sha1_to_hex(expected_sha1));
3955 if (stream->avail_in) {
3956 error("garbage at end of loose object '%s'",
3957 sha1_to_hex(expected_sha1));
3961 git_SHA1_Final(real_sha1, &c);
3962 if (hashcmp(expected_sha1, real_sha1)) {
3963 error("sha1 mismatch for %s (expected %s)", path,
3964 sha1_to_hex(expected_sha1));
3971 int read_loose_object(const char *path,
3972 const unsigned char *expected_sha1,
3973 enum object_type *type,
3974 unsigned long *size,
3980 unsigned long mapsize;
3986 map = map_sha1_file_1(path, NULL, &mapsize);
3988 error_errno("unable to mmap %s", path);
3992 if (unpack_sha1_header(&stream, map, mapsize, hdr, sizeof(hdr)) < 0) {
3993 error("unable to unpack header of %s", path);
3997 *type = parse_sha1_header(hdr, size);
3999 error("unable to parse header of %s", path);
4000 git_inflate_end(&stream);
4004 if (*type == OBJ_BLOB) {
4005 if (check_stream_sha1(&stream, hdr, *size, path, expected_sha1) < 0)
4008 *contents = unpack_sha1_rest(&stream, hdr, *size, expected_sha1);
4010 error("unable to unpack contents of %s", path);
4011 git_inflate_end(&stream);
4014 if (check_sha1_signature(expected_sha1, *contents,
4015 *size, typename(*type))) {
4016 error("sha1 mismatch for %s (expected %s)", path,
4017 sha1_to_hex(expected_sha1));
4023 ret = 0; /* everything checks out */
4027 munmap(map, mapsize);