return ret;
}
-void unuse_pack(struct pack_window **w_cursor)
-{
- struct pack_window *w = *w_cursor;
- if (w) {
- w->inuse_cnt--;
- *w_cursor = NULL;
- }
-}
-
-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;
-}
-
-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)
{
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)
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,