X-Git-Url: http://git.ipfire.org/?a=blobdiff_plain;f=fast-import.c;h=1ae125a040e6dfcf83b2cdc4aeea8fa248d2ba22;hb=41b200179dfac7bf4c3b98270951937b537e2b24;hp=12127168bd91355813c7c76ad9caee859f757be8;hpb=80144727acc401070039434987692276dcb9273c;p=thirdparty%2Fgit.git diff --git a/fast-import.c b/fast-import.c index 12127168bd..1ae125a040 100644 --- a/fast-import.c +++ b/fast-import.c @@ -7,6 +7,7 @@ Format of STDIN stream: | new_commit | new_tag | reset_branch + | checkpoint ; new_blob ::= 'blob' lf @@ -16,8 +17,8 @@ Format of STDIN stream: new_commit ::= 'commit' sp ref_str lf mark? - ('author' sp name '<' email '>' ts tz lf)? - 'committer' sp name '<' email '>' ts tz lf + ('author' sp name '<' email '>' when lf)? + 'committer' sp name '<' email '>' when lf commit_msg ('from' sp (ref_str | hexsha1 | sha1exp_str | idnum) lf)? ('merge' sp (ref_str | hexsha1 | sha1exp_str | idnum) lf)* @@ -25,14 +26,16 @@ Format of STDIN stream: lf; commit_msg ::= data; - file_change ::= 'M' sp mode sp (hexsha1 | idnum) sp path_str lf - | 'D' sp path_str lf - ; - mode ::= '644' | '755'; + file_change ::= file_clr | file_del | file_obm | file_inm; + file_clr ::= 'deleteall' lf; + file_del ::= 'D' sp path_str lf; + file_obm ::= 'M' sp mode sp (hexsha1 | idnum) sp path_str lf; + file_inm ::= 'M' sp mode sp 'inline' sp path_str lf + data; new_tag ::= 'tag' sp tag_str lf 'from' sp (ref_str | hexsha1 | sha1exp_str | idnum) lf - 'tagger' sp name '<' email '>' ts tz lf + 'tagger' sp name '<' email '>' when lf tag_msg; tag_msg ::= data; @@ -40,6 +43,9 @@ Format of STDIN stream: ('from' sp (ref_str | hexsha1 | sha1exp_str | idnum) lf)? lf; + checkpoint ::= 'checkpoint' lf + lf; + # note: the first idnum in a stream should be 1 and subsequent # idnums should not have gaps between values as this will cause # the stream parser to reserve space for the gapped values. An @@ -47,14 +53,21 @@ Format of STDIN stream: # a new mark directive with the old idnum. # mark ::= 'mark' sp idnum lf; + data ::= (delimited_data | exact_data) + lf; + + # note: delim may be any string but must not contain lf. + # data_line may contain any data but must not be exactly + # delim. + delimited_data ::= 'data' sp '<<' delim lf + (data_line lf)* + delim lf; # note: declen indicates the length of binary_data in bytes. - # declen does not include the lf preceeding or trailing the - # binary data. + # declen does not include the lf preceeding the binary data. # - data ::= 'data' sp declen lf - binary_data - lf; + exact_data ::= 'data' sp declen lf + binary_data; # note: quoted strings are C-style quoting supporting \c for # common escapes of 'c' (e..g \n, \t, \\, \") or \nnn where nnn @@ -63,14 +76,23 @@ Format of STDIN stream: # stream formatting is: \, " and LF. Otherwise these values # are UTF8. # - ref_str ::= ref | '"' quoted(ref) '"' ; - sha1exp_str ::= sha1exp | '"' quoted(sha1exp) '"' ; - tag_str ::= tag | '"' quoted(tag) '"' ; + ref_str ::= ref; + sha1exp_str ::= sha1exp; + tag_str ::= tag; path_str ::= path | '"' quoted(path) '"' ; + mode ::= '100644' | '644' + | '100755' | '755' + | '120000' + ; declen ::= # unsigned 32 bit value, ascii base10 notation; + bigint ::= # unsigned integer value, ascii base10 notation; binary_data ::= # file content, not interpreted; + when ::= raw_when | rfc2822_when; + raw_when ::= ts sp tz; + rfc2822_when ::= # Valid RFC 2822 date and time; + sp ::= # ASCII space character; lf ::= # ASCII newline (LF) character; @@ -78,7 +100,7 @@ Format of STDIN stream: # an idnum. This is to distinguish it from a ref or tag name as # GIT does not permit ':' in ref or tag strings. # - idnum ::= ':' declen; + idnum ::= ':' bigint; path ::= # GIT style file path, e.g. "a/b/c"; ref ::= # GIT ref name, e.g. "refs/heads/MOZ_GECKO_EXPERIMENT"; tag ::= # GIT tag name, e.g. "FIREFOX_1_5"; @@ -100,6 +122,7 @@ Format of STDIN stream: #include "object.h" #include "blob.h" #include "tree.h" +#include "commit.h" #include "delta.h" #include "pack.h" #include "refs.h" @@ -107,11 +130,19 @@ Format of STDIN stream: #include "strbuf.h" #include "quote.h" +#define PACK_ID_BITS 16 +#define MAX_PACK_ID ((1<buffer = xmalloc(b->capacity); } -static void insert_mark(unsigned long idnum, struct object_entry *oe) +static void insert_mark(uintmax_t idnum, struct object_entry *oe) { struct mark_set *s = marks; while ((idnum >> s->shift) >= 1024) { @@ -410,7 +451,7 @@ static void insert_mark(unsigned long idnum, struct object_entry *oe) marks = s; } while (s->shift) { - unsigned long i = idnum >> s->shift; + uintmax_t i = idnum >> s->shift; idnum -= i << s->shift; if (!s->data.sets[i]) { s->data.sets[i] = pool_calloc(1, sizeof(struct mark_set)); @@ -423,14 +464,14 @@ static void insert_mark(unsigned long idnum, struct object_entry *oe) s->data.marked[idnum] = oe; } -static struct object_entry* find_mark(unsigned long idnum) +static struct object_entry *find_mark(uintmax_t idnum) { - unsigned long orig_idnum = idnum; + uintmax_t orig_idnum = idnum; struct mark_set *s = marks; struct object_entry *oe = NULL; if ((idnum >> s->shift) < 1024) { while (s && s->shift) { - unsigned long i = idnum >> s->shift; + uintmax_t i = idnum >> s->shift; idnum -= i << s->shift; s = s->data.sets[i]; } @@ -438,11 +479,11 @@ static struct object_entry* find_mark(unsigned long idnum) oe = s->data.marked[idnum]; } if (!oe) - die("mark :%lu not declared", orig_idnum); + die("mark :%" PRIuMAX " not declared", orig_idnum); return oe; } -static struct atom_str* to_atom(const char *s, size_t len) +static struct atom_str *to_atom(const char *s, unsigned short len) { unsigned int hc = hc_str(s, len) % atom_table_sz; struct atom_str *c; @@ -461,7 +502,7 @@ static struct atom_str* to_atom(const char *s, size_t len) return c; } -static struct branch* lookup_branch(const char *name) +static struct branch *lookup_branch(const char *name) { unsigned int hc = hc_str(name, strlen(name)) % branch_table_sz; struct branch *b; @@ -472,7 +513,7 @@ static struct branch* lookup_branch(const char *name) return NULL; } -static struct branch* new_branch(const char *name) +static struct branch *new_branch(const char *name) { unsigned int hc = hc_str(name, strlen(name)) % branch_table_sz; struct branch* b = lookup_branch(name); @@ -487,6 +528,7 @@ static struct branch* new_branch(const char *name) b->table_next_branch = branch_table[hc]; b->branch_tree.versions[0].mode = S_IFDIR; b->branch_tree.versions[1].mode = S_IFDIR; + b->pack_id = MAX_PACK_ID; branch_table[hc] = b; branch_count++; return b; @@ -498,7 +540,7 @@ static unsigned int hc_entries(unsigned int cnt) return cnt < avail_tree_table_sz ? cnt : avail_tree_table_sz - 1; } -static struct tree_content* new_tree_content(unsigned int cnt) +static struct tree_content *new_tree_content(unsigned int cnt) { struct avail_tree_content *f, *l = NULL; struct tree_content *t; @@ -542,7 +584,7 @@ static void release_tree_content_recursive(struct tree_content *t) release_tree_content(t); } -static struct tree_content* grow_tree_content( +static struct tree_content *grow_tree_content( struct tree_content *t, int amt) { @@ -554,7 +596,7 @@ static struct tree_content* grow_tree_content( return r; } -static struct tree_entry* new_tree_entry() +static struct tree_entry *new_tree_entry(void) { struct tree_entry *e; @@ -582,75 +624,69 @@ static void release_tree_entry(struct tree_entry *e) avail_tree_entry = e; } -static void yread(int fd, void *buffer, size_t length) -{ - ssize_t ret = 0; - while (ret < length) { - ssize_t size = xread(fd, (char *) buffer + ret, length - ret); - if (!size) - die("Read from descriptor %i: end of stream", fd); - if (size < 0) - die("Read from descriptor %i: %s", fd, strerror(errno)); - ret += size; - } -} - -static void start_packfile() +static void start_packfile(void) { + static char tmpfile[PATH_MAX]; + struct packed_git *p; struct pack_header hdr; + int pack_fd; - pack_count++; - pack_name = xmalloc(strlen(base_name) + 11); - idx_name = xmalloc(strlen(base_name) + 11); - sprintf(pack_name, "%s%5.5i.pack", base_name, pack_count); - sprintf(idx_name, "%s%5.5i.idx", base_name, pack_count); - - pack_fd = open(pack_name, O_RDWR|O_CREAT|O_EXCL, 0666); + snprintf(tmpfile, sizeof(tmpfile), + "%s/pack_XXXXXX", get_object_directory()); + pack_fd = mkstemp(tmpfile); if (pack_fd < 0) - die("Can't create %s: %s", pack_name, strerror(errno)); - - pack_data = xcalloc(1, sizeof(*pack_data) + strlen(pack_name) + 2); - strcpy(pack_data->pack_name, pack_name); - pack_data->pack_fd = pack_fd; + die("Can't create %s: %s", tmpfile, strerror(errno)); + p = xcalloc(1, sizeof(*p) + strlen(tmpfile) + 2); + strcpy(p->pack_name, tmpfile); + p->pack_fd = pack_fd; hdr.hdr_signature = htonl(PACK_SIGNATURE); hdr.hdr_version = htonl(2); hdr.hdr_entries = 0; + write_or_die(p->pack_fd, &hdr, sizeof(hdr)); - write_or_die(pack_fd, &hdr, sizeof(hdr)); + pack_data = p; pack_size = sizeof(hdr); object_count = 0; + + all_packs = xrealloc(all_packs, sizeof(*all_packs) * (pack_id + 1)); + all_packs[pack_id] = p; } -static void fixup_header_footer() +static void fixup_header_footer(void) { + static const int buf_sz = 128 * 1024; + int pack_fd = pack_data->pack_fd; SHA_CTX c; - char hdr[8]; - unsigned long cnt; + struct pack_header hdr; char *buf; if (lseek(pack_fd, 0, SEEK_SET) != 0) die("Failed seeking to start: %s", strerror(errno)); + if (read_in_full(pack_fd, &hdr, sizeof(hdr)) != sizeof(hdr)) + die("Unable to reread header of %s", pack_data->pack_name); + if (lseek(pack_fd, 0, SEEK_SET) != 0) + die("Failed seeking to start: %s", strerror(errno)); + hdr.hdr_entries = htonl(object_count); + write_or_die(pack_fd, &hdr, sizeof(hdr)); SHA1_Init(&c); - yread(pack_fd, hdr, 8); - SHA1_Update(&c, hdr, 8); + SHA1_Update(&c, &hdr, sizeof(hdr)); - cnt = htonl(object_count); - SHA1_Update(&c, &cnt, 4); - write_or_die(pack_fd, &cnt, 4); - - buf = xmalloc(128 * 1024); + buf = xmalloc(buf_sz); for (;;) { - size_t n = xread(pack_fd, buf, 128 * 1024); - if (n <= 0) + size_t n = xread(pack_fd, buf, buf_sz); + if (!n) break; + if (n < 0) + die("Failed to checksum %s", pack_data->pack_name); SHA1_Update(&c, buf, n); } free(buf); - SHA1_Final(pack_sha1, &c); - write_or_die(pack_fd, pack_sha1, sizeof(pack_sha1)); + SHA1_Final(pack_data->sha1, &c); + write_or_die(pack_fd, pack_data->sha1, sizeof(pack_data->sha1)); + close(pack_fd); } static int oecmp (const void *a_, const void *b_) @@ -660,21 +696,26 @@ static int oecmp (const void *a_, const void *b_) return hashcmp(a->sha1, b->sha1); } -static void write_index(const char *idx_name) +static char *create_index(void) { + static char tmpfile[PATH_MAX]; + SHA_CTX ctx; struct sha1file *f; struct object_entry **idx, **c, **last, *e; struct object_entry_pool *o; - unsigned int array[256]; - int i; + uint32_t array[256]; + int i, idx_fd; /* Build the sorted table of object IDs. */ idx = xmalloc(object_count * sizeof(struct object_entry*)); c = idx; for (o = blocks; o; o = o->next_pool) - for (e = o->entries; e != o->next_free; e++) - *c++ = e; + for (e = o->next_free; e-- != o->entries;) + if (pack_id == e->pack_id) + *c++ = e; last = idx + object_count; + if (c != last) + die("internal consistency error creating the index"); qsort(idx, object_count, sizeof(struct object_entry*), oecmp); /* Generate the fan-out array. */ @@ -690,27 +731,125 @@ static void write_index(const char *idx_name) c = next; } - f = sha1create("%s", idx_name); + snprintf(tmpfile, sizeof(tmpfile), + "%s/index_XXXXXX", get_object_directory()); + idx_fd = mkstemp(tmpfile); + if (idx_fd < 0) + die("Can't create %s: %s", tmpfile, strerror(errno)); + f = sha1fd(idx_fd, tmpfile); sha1write(f, array, 256 * sizeof(int)); + SHA1_Init(&ctx); for (c = idx; c != last; c++) { - unsigned int offset = htonl((*c)->offset); + uint32_t offset = htonl((*c)->offset); sha1write(f, &offset, 4); sha1write(f, (*c)->sha1, sizeof((*c)->sha1)); + SHA1_Update(&ctx, (*c)->sha1, 20); } - sha1write(f, pack_sha1, sizeof(pack_sha1)); + sha1write(f, pack_data->sha1, sizeof(pack_data->sha1)); sha1close(f, NULL, 1); free(idx); + SHA1_Final(pack_data->sha1, &ctx); + return tmpfile; } -static void end_packfile() +static char *keep_pack(char *curr_index_name) +{ + static char name[PATH_MAX]; + static char *keep_msg = "fast-import"; + int keep_fd; + + chmod(pack_data->pack_name, 0444); + chmod(curr_index_name, 0444); + + snprintf(name, sizeof(name), "%s/pack/pack-%s.keep", + get_object_directory(), sha1_to_hex(pack_data->sha1)); + keep_fd = open(name, O_RDWR|O_CREAT|O_EXCL, 0600); + if (keep_fd < 0) + die("cannot create keep file"); + write(keep_fd, keep_msg, strlen(keep_msg)); + close(keep_fd); + + snprintf(name, sizeof(name), "%s/pack/pack-%s.pack", + get_object_directory(), sha1_to_hex(pack_data->sha1)); + if (move_temp_to_file(pack_data->pack_name, name)) + die("cannot store pack file"); + + snprintf(name, sizeof(name), "%s/pack/pack-%s.idx", + get_object_directory(), sha1_to_hex(pack_data->sha1)); + if (move_temp_to_file(curr_index_name, name)) + die("cannot store index file"); + return name; +} + +static void unkeep_all_packs(void) { - fixup_header_footer(); - close(pack_fd); - write_index(idx_name); + static char name[PATH_MAX]; + int k; + + for (k = 0; k < pack_id; k++) { + struct packed_git *p = all_packs[k]; + snprintf(name, sizeof(name), "%s/pack/pack-%s.keep", + get_object_directory(), sha1_to_hex(p->sha1)); + unlink(name); + } +} + +static void end_packfile(void) +{ + struct packed_git *old_p = pack_data, *new_p; + + if (object_count) { + char *idx_name; + int i; + struct branch *b; + struct tag *t; + + fixup_header_footer(); + idx_name = keep_pack(create_index()); + + /* Register the packfile with core git's machinary. */ + new_p = add_packed_git(idx_name, strlen(idx_name), 1); + if (!new_p) + die("core git rejected index %s", idx_name); + new_p->windows = old_p->windows; + all_packs[pack_id] = new_p; + install_packed_git(new_p); + + /* Print the boundary */ + if (pack_edges) { + fprintf(pack_edges, "%s:", new_p->pack_name); + for (i = 0; i < branch_table_sz; i++) { + for (b = branch_table[i]; b; b = b->table_next_branch) { + if (b->pack_id == pack_id) + fprintf(pack_edges, " %s", sha1_to_hex(b->sha1)); + } + } + for (t = first_tag; t; t = t->next_tag) { + if (t->pack_id == pack_id) + fprintf(pack_edges, " %s", sha1_to_hex(t->sha1)); + } + fputc('\n', pack_edges); + fflush(pack_edges); + } + + pack_id++; + } + else + unlink(old_p->pack_name); + free(old_p); + + /* We can't carry a delta across packfiles. */ + free(last_blob.data); + last_blob.data = NULL; + last_blob.len = 0; + last_blob.offset = 0; + last_blob.depth = 0; +} - free(pack_name); - free(idx_name); - free(pack_data); +static void cycle_packfile(void) +{ + end_packfile(); + start_packfile(); } static size_t encode_header( @@ -742,7 +881,7 @@ static int store_object( size_t datlen, struct last_object *last, unsigned char *sha1out, - unsigned long mark) + uintmax_t mark) { void *out, *delta; struct object_entry *e; @@ -752,7 +891,8 @@ static int store_object( SHA_CTX c; z_stream s; - hdrlen = sprintf((char*)hdr,"%s %lu",type_names[type],datlen) + 1; + hdrlen = sprintf((char*)hdr,"%s %lu", type_names[type], + (unsigned long)datlen) + 1; SHA1_Init(&c); SHA1_Update(&c, hdr, hdrlen); SHA1_Update(&c, dat, datlen); @@ -767,20 +907,63 @@ static int store_object( duplicate_count_by_type[type]++; return 1; } - e->type = type; - e->offset = pack_size; - object_count++; - object_count_by_type[type]++; - if (last && last->data && last->depth < max_depth) + if (last && last->data && last->depth < max_depth) { delta = diff_delta(last->data, last->len, dat, datlen, &deltalen, 0); - else - delta = 0; + if (delta && deltalen >= datlen) { + free(delta); + delta = NULL; + } + } else + delta = NULL; memset(&s, 0, sizeof(s)); deflateInit(&s, zlib_compression_level); + if (delta) { + s.next_in = delta; + s.avail_in = deltalen; + } else { + s.next_in = dat; + s.avail_in = datlen; + } + s.avail_out = deflateBound(&s, s.avail_in); + s.next_out = out = xmalloc(s.avail_out); + while (deflate(&s, Z_FINISH) == Z_OK) + /* nothing */; + deflateEnd(&s); + + /* Determine if we should auto-checkpoint. */ + if ((pack_size + 60 + s.total_out) > max_packsize + || (pack_size + 60 + s.total_out) < pack_size) { + + /* This new object needs to *not* have the current pack_id. */ + e->pack_id = pack_id + 1; + cycle_packfile(); + + /* We cannot carry a delta into the new pack. */ + if (delta) { + free(delta); + delta = NULL; + + memset(&s, 0, sizeof(s)); + deflateInit(&s, zlib_compression_level); + s.next_in = dat; + s.avail_in = datlen; + s.avail_out = deflateBound(&s, s.avail_in); + s.next_out = out = xrealloc(out, s.avail_out); + while (deflate(&s, Z_FINISH) == Z_OK) + /* nothing */; + deflateEnd(&s); + } + } + + e->type = type; + e->pack_id = pack_id; + e->offset = pack_size; + object_count++; + object_count_by_type[type]++; if (delta) { unsigned long ofs = e->offset - last->offset; @@ -788,42 +971,31 @@ static int store_object( delta_count_by_type[type]++; last->depth++; - s.next_in = delta; - s.avail_in = deltalen; hdrlen = encode_header(OBJ_OFS_DELTA, deltalen, hdr); - write_or_die(pack_fd, hdr, hdrlen); + write_or_die(pack_data->pack_fd, hdr, hdrlen); pack_size += hdrlen; hdr[pos] = ofs & 127; while (ofs >>= 7) hdr[--pos] = 128 | (--ofs & 127); - write_or_die(pack_fd, hdr + pos, sizeof(hdr) - pos); + write_or_die(pack_data->pack_fd, hdr + pos, sizeof(hdr) - pos); pack_size += sizeof(hdr) - pos; } else { if (last) last->depth = 0; - s.next_in = dat; - s.avail_in = datlen; hdrlen = encode_header(type, datlen, hdr); - write_or_die(pack_fd, hdr, hdrlen); + write_or_die(pack_data->pack_fd, hdr, hdrlen); pack_size += hdrlen; } - s.avail_out = deflateBound(&s, s.avail_in); - s.next_out = out = xmalloc(s.avail_out); - while (deflate(&s, Z_FINISH) == Z_OK) - /* nothing */; - deflateEnd(&s); - - write_or_die(pack_fd, out, s.total_out); + write_or_die(pack_data->pack_fd, out, s.total_out); pack_size += s.total_out; free(out); - if (delta) - free(delta); + free(delta); if (last) { - if (last->data && !last->no_free) + if (!last->no_free) free(last->data); last->data = dat; last->offset = e->offset; @@ -832,17 +1004,21 @@ static int store_object( return 0; } -static void *gfi_unpack_entry(unsigned long ofs, unsigned long *sizep) +static void *gfi_unpack_entry( + struct object_entry *oe, + unsigned long *sizep) { - char type[20]; - pack_data->pack_size = pack_size + 20; - return unpack_entry(pack_data, ofs, type, sizep); + static char type[20]; + struct packed_git *p = all_packs[oe->pack_id]; + if (p == pack_data) + p->pack_size = pack_size + 20; + return unpack_entry(p, oe->offset, type, sizep); } -static const char *get_mode(const char *str, unsigned int *modep) +static const char *get_mode(const char *str, uint16_t *modep) { unsigned char c; - unsigned int mode = 0; + uint16_t mode = 0; while ((c = *str++) != ' ') { if (c < '0' || c > '7') @@ -871,7 +1047,7 @@ static void load_tree(struct tree_entry *root) if (myoe->type != OBJ_TREE) die("Not a tree: %s", sha1_to_hex(sha1)); t->delta_depth = 0; - buf = gfi_unpack_entry(myoe->offset, &size); + buf = gfi_unpack_entry(myoe, &size); } else { char type[20]; buf = read_sha1_file(sha1, type, &size); @@ -892,7 +1068,7 @@ static void load_tree(struct tree_entry *root) if (!c) die("Corrupt mode in %s", sha1_to_hex(sha1)); e->versions[0].mode = e->versions[1].mode; - e->name = to_atom(c, strlen(c)); + e->name = to_atom(c, (unsigned short)strlen(c)); c += e->name->str_len + 1; hashcpy(e->versions[0].sha1, (unsigned char*)c); hashcpy(e->versions[1].sha1, (unsigned char*)c); @@ -944,7 +1120,7 @@ static void mktree(struct tree_content *t, struct tree_entry *e = t->entries[i]; if (!e->versions[v].mode) continue; - c += sprintf(c, "%o", e->versions[v].mode); + c += sprintf(c, "%o", (unsigned int)e->versions[v].mode); *c++ = ' '; strcpy(c, e->name->str_dat); c += e->name->str_len + 1; @@ -971,7 +1147,9 @@ static void store_tree(struct tree_entry *root) } le = find_object(root->versions[0].sha1); - if (!S_ISDIR(root->versions[0].mode) || !le) { + if (!S_ISDIR(root->versions[0].mode) + || !le + || le->pack_id != pack_id) { lo.data = NULL; lo.depth = 0; } else { @@ -1005,7 +1183,7 @@ static int tree_content_set( struct tree_entry *root, const char *p, const unsigned char *sha1, - const unsigned int mode) + const uint16_t mode) { struct tree_content *t = root->tree; const char *slash1; @@ -1051,7 +1229,7 @@ static int tree_content_set( if (t->entry_count == t->entry_capacity) root->tree = t = grow_tree_content(t, 8); e = new_tree_entry(); - e->name = to_atom(p, n); + e->name = to_atom(p, (unsigned short)n); e->versions[0].mode = 0; hashclr(e->versions[0].sha1); t->entries[t->entry_count++] = e; @@ -1113,42 +1291,71 @@ del_entry: return 1; } -static void dump_branches() +static int update_branch(struct branch *b) { static const char *msg = "fast-import"; + struct ref_lock *lock; + unsigned char old_sha1[20]; + + if (read_ref(b->name, old_sha1)) + hashclr(old_sha1); + lock = lock_any_ref_for_update(b->name, old_sha1); + if (!lock) + return error("Unable to lock %s", b->name); + if (!force_update && !is_null_sha1(old_sha1)) { + struct commit *old_cmit, *new_cmit; + + old_cmit = lookup_commit_reference_gently(old_sha1, 0); + new_cmit = lookup_commit_reference_gently(b->sha1, 0); + if (!old_cmit || !new_cmit) { + unlock_ref(lock); + return error("Branch %s is missing commits.", b->name); + } + + if (!in_merge_bases(old_cmit, new_cmit)) { + unlock_ref(lock); + warn("Not updating %s" + " (new tip %s does not contain %s)", + b->name, sha1_to_hex(b->sha1), sha1_to_hex(old_sha1)); + return -1; + } + } + if (write_ref_sha1(lock, b->sha1, msg) < 0) + return error("Unable to update %s", b->name); + return 0; +} + +static void dump_branches(void) +{ unsigned int i; struct branch *b; - struct ref_lock *lock; for (i = 0; i < branch_table_sz; i++) { - for (b = branch_table[i]; b; b = b->table_next_branch) { - lock = lock_any_ref_for_update(b->name, NULL); - if (!lock || write_ref_sha1(lock, b->sha1, msg) < 0) - die("Can't write %s", b->name); - } + for (b = branch_table[i]; b; b = b->table_next_branch) + failure |= update_branch(b); } } -static void dump_tags() +static void dump_tags(void) { static const char *msg = "fast-import"; struct tag *t; struct ref_lock *lock; - char path[PATH_MAX]; + char ref_name[PATH_MAX]; for (t = first_tag; t; t = t->next_tag) { - sprintf(path, "refs/tags/%s", t->name); - lock = lock_any_ref_for_update(path, NULL); + sprintf(ref_name, "tags/%s", t->name); + lock = lock_ref_sha1(ref_name, NULL); if (!lock || write_ref_sha1(lock, t->sha1, msg) < 0) - die("Can't write %s", path); + failure |= error("Unable to update %s", ref_name); } } static void dump_marks_helper(FILE *f, - unsigned long base, + uintmax_t base, struct mark_set *m) { - int k; + uintmax_t k; if (m->shift) { for (k = 0; k < 1024; k++) { if (m->data.sets[k]) @@ -1158,54 +1365,86 @@ static void dump_marks_helper(FILE *f, } else { for (k = 0; k < 1024; k++) { if (m->data.marked[k]) - fprintf(f, ":%lu %s\n", base + k, + fprintf(f, ":%" PRIuMAX " %s\n", base + k, sha1_to_hex(m->data.marked[k]->sha1)); } } } -static void dump_marks() +static void dump_marks(void) { if (mark_file) { FILE *f = fopen(mark_file, "w"); - dump_marks_helper(f, 0, marks); - fclose(f); + if (f) { + dump_marks_helper(f, 0, marks); + fclose(f); + } else + failure |= error("Unable to write marks file %s: %s", + mark_file, strerror(errno)); } } -static void read_next_command() +static void read_next_command(void) { read_line(&command_buf, stdin, '\n'); } -static void cmd_mark() +static void cmd_mark(void) { if (!strncmp("mark :", command_buf.buf, 6)) { - next_mark = strtoul(command_buf.buf + 6, NULL, 10); + next_mark = strtoumax(command_buf.buf + 6, NULL, 10); read_next_command(); } else next_mark = 0; } -static void* cmd_data (size_t *size) +static void *cmd_data (size_t *size) { - size_t n = 0; - void *buffer; size_t length; + char *buffer; if (strncmp("data ", command_buf.buf, 5)) die("Expected 'data n' command, found: %s", command_buf.buf); - length = strtoul(command_buf.buf + 5, NULL, 10); - buffer = xmalloc(length); - - while (n < length) { - size_t s = fread((char*)buffer + n, 1, length - n, stdin); - if (!s && feof(stdin)) - die("EOF in data (%lu bytes remaining)", length - n); - n += s; + if (!strncmp("<<", command_buf.buf + 5, 2)) { + char *term = xstrdup(command_buf.buf + 5 + 2); + size_t sz = 8192, term_len = command_buf.len - 5 - 2; + length = 0; + buffer = xmalloc(sz); + for (;;) { + read_next_command(); + if (command_buf.eof) + die("EOF in data (terminator '%s' not found)", term); + if (term_len == command_buf.len + && !strcmp(term, command_buf.buf)) + break; + if (sz < (length + command_buf.len)) { + sz = sz * 3 / 2 + 16; + if (sz < (length + command_buf.len)) + sz = length + command_buf.len; + buffer = xrealloc(buffer, sz); + } + memcpy(buffer + length, + command_buf.buf, + command_buf.len - 1); + length += command_buf.len - 1; + buffer[length++] = '\n'; + } + free(term); + } + else { + size_t n = 0; + length = strtoul(command_buf.buf + 5, NULL, 10); + buffer = xmalloc(length); + while (n < length) { + size_t s = fread(buffer + n, 1, length - n, stdin); + if (!s && feof(stdin)) + die("EOF in data (%lu bytes remaining)", + (unsigned long)(length - n)); + n += s; + } } if (fgetc(stdin) != '\n') @@ -1215,7 +1454,65 @@ static void* cmd_data (size_t *size) return buffer; } -static void cmd_new_blob() +static int validate_raw_date(const char *src, char *result, int maxlen) +{ + const char *orig_src = src; + char *endp, sign; + + strtoul(src, &endp, 10); + if (endp == src || *endp != ' ') + return -1; + + src = endp + 1; + if (*src != '-' && *src != '+') + return -1; + sign = *src; + + strtoul(src + 1, &endp, 10); + if (endp == src || *endp || (endp - orig_src) >= maxlen) + return -1; + + strcpy(result, orig_src); + return 0; +} + +static char *parse_ident(const char *buf) +{ + const char *gt; + size_t name_len; + char *ident; + + gt = strrchr(buf, '>'); + if (!gt) + die("Missing > in ident string: %s", buf); + gt++; + if (*gt != ' ') + die("Missing space after > in ident string: %s", buf); + gt++; + name_len = gt - buf; + ident = xmalloc(name_len + 24); + strncpy(ident, buf, name_len); + + switch (whenspec) { + case WHENSPEC_RAW: + if (validate_raw_date(gt, ident + name_len, 24) < 0) + die("Invalid raw date \"%s\" in ident: %s", gt, buf); + break; + case WHENSPEC_RFC2822: + if (parse_date(gt, ident + name_len, 24) < 0) + die("Invalid rfc2822 date \"%s\" in ident: %s", gt, buf); + break; + case WHENSPEC_NOW: + if (strcmp("now", gt)) + die("Date in ident must be 'now': %s", buf); + datestamp(ident + name_len, 24); + break; + } + + return ident; +} + +static void cmd_new_blob(void) { size_t l; void *d; @@ -1228,7 +1525,7 @@ static void cmd_new_blob() free(d); } -static void unload_one_branch() +static void unload_one_branch(void) { while (cur_active_branches && cur_active_branches >= max_active_branches) { @@ -1273,9 +1570,9 @@ static void file_change_m(struct branch *b) const char *p = command_buf.buf + 2; char *p_uq; const char *endp; - struct object_entry *oe; + struct object_entry *oe = oe; unsigned char sha1[20]; - unsigned int mode; + uint16_t mode, inline_data = 0; char type[20]; p = get_mode(p, &mode); @@ -1295,9 +1592,12 @@ static void file_change_m(struct branch *b) if (*p == ':') { char *x; - oe = find_mark(strtoul(p + 1, &x, 10)); + oe = find_mark(strtoumax(p + 1, &x, 10)); hashcpy(sha1, oe->sha1); p = x; + } else if (!strncmp("inline", p, 6)) { + inline_data = 1; + p += 6; } else { if (get_sha1_hex(p, sha1)) die("Invalid SHA1: %s", command_buf.buf); @@ -1314,7 +1614,16 @@ static void file_change_m(struct branch *b) p = p_uq; } - if (oe) { + if (inline_data) { + size_t l; + void *d; + if (!p_uq) + p = p_uq = xstrdup(p); + read_next_command(); + d = cmd_data(&l); + if (store_object(OBJ_BLOB, d, l, &last_blob, sha1, 0)) + free(d); + } else if (oe) { if (oe->type != OBJ_BLOB) die("Not a blob (actually a %s): %s", command_buf.buf, type_names[oe->type]); @@ -1327,9 +1636,7 @@ static void file_change_m(struct branch *b) } tree_content_set(&b->branch_tree, p, sha1, S_IFREG | mode); - - if (p_uq) - free(p_uq); + free(p_uq); } static void file_change_d(struct branch *b) @@ -1345,30 +1652,31 @@ static void file_change_d(struct branch *b) p = p_uq; } tree_content_remove(&b->branch_tree, p); - if (p_uq) - free(p_uq); + free(p_uq); +} + +static void file_change_deleteall(struct branch *b) +{ + release_tree_content_recursive(b->branch_tree.tree); + hashclr(b->branch_tree.versions[0].sha1); + hashclr(b->branch_tree.versions[1].sha1); + load_tree(&b->branch_tree); } static void cmd_from(struct branch *b) { - const char *from, *endp; - char *str_uq; + const char *from; struct branch *s; if (strncmp("from ", command_buf.buf, 5)) return; - if (b->last_commit) - die("Can't reinitailize branch %s", b->name); - - from = strchr(command_buf.buf, ' ') + 1; - str_uq = unquote_c_style(from, &endp); - if (str_uq) { - if (*endp) - die("Garbage after string in: %s", command_buf.buf); - from = str_uq; + if (b->branch_tree.tree) { + release_tree_content_recursive(b->branch_tree.tree); + b->branch_tree.tree = NULL; } + from = strchr(command_buf.buf, ' ') + 1; s = lookup_branch(from); if (b == s) die("Can't create a branch from itself: %s", b->name); @@ -1378,14 +1686,14 @@ static void cmd_from(struct branch *b) hashcpy(b->branch_tree.versions[0].sha1, t); hashcpy(b->branch_tree.versions[1].sha1, t); } else if (*from == ':') { - unsigned long idnum = strtoul(from + 1, NULL, 10); + uintmax_t idnum = strtoumax(from + 1, NULL, 10); struct object_entry *oe = find_mark(idnum); unsigned long size; char *buf; if (oe->type != OBJ_COMMIT) - die("Mark :%lu not a commit", idnum); + die("Mark :%" PRIuMAX " not a commit", idnum); hashcpy(b->sha1, oe->sha1); - buf = gfi_unpack_entry(oe->offset, &size); + buf = gfi_unpack_entry(oe, &size); if (!buf || size < 46) die("Not a valid commit: %s", from); if (memcmp("tree ", buf, 5) @@ -1419,32 +1727,24 @@ static void cmd_from(struct branch *b) read_next_command(); } -static struct hash_list* cmd_merge(unsigned int *count) +static struct hash_list *cmd_merge(unsigned int *count) { - struct hash_list *list = NULL, *n, *e; - const char *from, *endp; - char *str_uq; + struct hash_list *list = NULL, *n, *e = e; + const char *from; struct branch *s; *count = 0; while (!strncmp("merge ", command_buf.buf, 6)) { from = strchr(command_buf.buf, ' ') + 1; - str_uq = unquote_c_style(from, &endp); - if (str_uq) { - if (*endp) - die("Garbage after string in: %s", command_buf.buf); - from = str_uq; - } - n = xmalloc(sizeof(*n)); s = lookup_branch(from); if (s) hashcpy(n->sha1, s->sha1); else if (*from == ':') { - unsigned long idnum = strtoul(from + 1, NULL, 10); + uintmax_t idnum = strtoumax(from + 1, NULL, 10); struct object_entry *oe = find_mark(idnum); if (oe->type != OBJ_COMMIT) - die("Mark :%lu not a commit", idnum); + die("Mark :%" PRIuMAX " not a commit", idnum); hashcpy(n->sha1, oe->sha1); } else if (get_sha1(from, n->sha1)) die("Invalid ref name or SHA1 expression: %s", from); @@ -1455,19 +1755,17 @@ static struct hash_list* cmd_merge(unsigned int *count) else list = n; e = n; - *count++; + (*count)++; read_next_command(); } return list; } -static void cmd_new_commit() +static void cmd_new_commit(void) { struct branch *b; void *msg; size_t msglen; - char *str_uq; - const char *endp; char *sp; char *author = NULL; char *committer = NULL; @@ -1476,26 +1774,18 @@ static void cmd_new_commit() /* Obtain the branch name from the rest of our command */ sp = strchr(command_buf.buf, ' ') + 1; - str_uq = unquote_c_style(sp, &endp); - if (str_uq) { - if (*endp) - die("Garbage after ref in: %s", command_buf.buf); - sp = str_uq; - } b = lookup_branch(sp); if (!b) b = new_branch(sp); - if (str_uq) - free(str_uq); read_next_command(); cmd_mark(); if (!strncmp("author ", command_buf.buf, 7)) { - author = strdup(command_buf.buf); + author = parse_ident(command_buf.buf + 7); read_next_command(); } if (!strncmp("committer ", command_buf.buf, 10)) { - committer = strdup(command_buf.buf); + committer = parse_ident(command_buf.buf + 10); read_next_command(); } if (!committer) @@ -1519,6 +1809,8 @@ static void cmd_new_commit() file_change_m(b); else if (!strncmp("D ", command_buf.buf, 2)) file_change_d(b); + else if (!strcmp("deleteall", command_buf.buf)) + file_change_deleteall(b); else die("Unsupported file_change: %s", command_buf.buf); read_next_command(); @@ -1528,7 +1820,7 @@ static void cmd_new_commit() store_tree(&b->branch_tree); hashcpy(b->branch_tree.versions[0].sha1, b->branch_tree.versions[1].sha1); - size_dbuf(&new_data, 97 + msglen + size_dbuf(&new_data, 114 + msglen + merge_count * 49 + (author ? strlen(author) + strlen(committer) @@ -1544,40 +1836,24 @@ static void cmd_new_commit() free(merge_list); merge_list = next; } - if (author) - sp += sprintf(sp, "%s\n", author); - else - sp += sprintf(sp, "author %s\n", committer + 10); - sp += sprintf(sp, "%s\n\n", committer); + sp += sprintf(sp, "author %s\n", author ? author : committer); + sp += sprintf(sp, "committer %s\n", committer); + *sp++ = '\n'; memcpy(sp, msg, msglen); sp += msglen; - if (author) - free(author); + free(author); free(committer); free(msg); - store_object(OBJ_COMMIT, + if (!store_object(OBJ_COMMIT, new_data.buffer, sp - (char*)new_data.buffer, - NULL, b->sha1, next_mark); + NULL, b->sha1, next_mark)) + b->pack_id = pack_id; b->last_commit = object_count_by_type[OBJ_COMMIT]; - - if (branch_log) { - int need_dq = quote_c_style(b->name, NULL, NULL, 0); - fprintf(branch_log, "commit "); - if (need_dq) { - fputc('"', branch_log); - quote_c_style(b->name, NULL, branch_log, 0); - fputc('"', branch_log); - } else - fprintf(branch_log, "%s", b->name); - fprintf(branch_log," :%lu %s\n",next_mark,sha1_to_hex(b->sha1)); - } } -static void cmd_new_tag() +static void cmd_new_tag(void) { - char *str_uq; - const char *endp; char *sp; const char *from; char *tagger; @@ -1585,17 +1861,11 @@ static void cmd_new_tag() void *msg; size_t msglen; struct tag *t; - unsigned long from_mark = 0; + uintmax_t from_mark = 0; unsigned char sha1[20]; /* Obtain the new tag name from the rest of our command */ sp = strchr(command_buf.buf, ' ') + 1; - str_uq = unquote_c_style(sp, &endp); - if (str_uq) { - if (*endp) - die("Garbage after tag name in: %s", command_buf.buf); - sp = str_uq; - } t = pool_alloc(sizeof(struct tag)); t->next_tag = NULL; t->name = pool_strdup(sp); @@ -1604,30 +1874,21 @@ static void cmd_new_tag() else first_tag = t; last_tag = t; - if (str_uq) - free(str_uq); read_next_command(); /* from ... */ if (strncmp("from ", command_buf.buf, 5)) die("Expected from command, got %s", command_buf.buf); - from = strchr(command_buf.buf, ' ') + 1; - str_uq = unquote_c_style(from, &endp); - if (str_uq) { - if (*endp) - die("Garbage after string in: %s", command_buf.buf); - from = str_uq; - } - s = lookup_branch(from); if (s) { hashcpy(sha1, s->sha1); } else if (*from == ':') { - from_mark = strtoul(from + 1, NULL, 10); - struct object_entry *oe = find_mark(from_mark); + struct object_entry *oe; + from_mark = strtoumax(from + 1, NULL, 10); + oe = find_mark(from_mark); if (oe->type != OBJ_COMMIT) - die("Mark :%lu not a commit", from_mark); + die("Mark :%" PRIuMAX " not a commit", from_mark); hashcpy(sha1, oe->sha1); } else if (!get_sha1(from, sha1)) { unsigned long size; @@ -1640,15 +1901,12 @@ static void cmd_new_tag() free(buf); } else die("Invalid ref name or SHA1 expression: %s", from); - - if (str_uq) - free(str_uq); read_next_command(); /* tagger ... */ if (strncmp("tagger ", command_buf.buf, 7)) die("Expected tagger command, got %s", command_buf.buf); - tagger = strdup(command_buf.buf); + tagger = parse_ident(command_buf.buf + 7); /* tag payload/message */ read_next_command(); @@ -1660,46 +1918,33 @@ static void cmd_new_tag() sp += sprintf(sp, "object %s\n", sha1_to_hex(sha1)); sp += sprintf(sp, "type %s\n", type_names[OBJ_COMMIT]); sp += sprintf(sp, "tag %s\n", t->name); - sp += sprintf(sp, "%s\n\n", tagger); + sp += sprintf(sp, "tagger %s\n", tagger); + *sp++ = '\n'; memcpy(sp, msg, msglen); sp += msglen; free(tagger); free(msg); - store_object(OBJ_TAG, new_data.buffer, sp - (char*)new_data.buffer, - NULL, t->sha1, 0); - - if (branch_log) { - int need_dq = quote_c_style(t->name, NULL, NULL, 0); - fprintf(branch_log, "tag "); - if (need_dq) { - fputc('"', branch_log); - quote_c_style(t->name, NULL, branch_log, 0); - fputc('"', branch_log); - } else - fprintf(branch_log, "%s", t->name); - fprintf(branch_log," :%lu %s\n",from_mark,sha1_to_hex(t->sha1)); - } + if (store_object(OBJ_TAG, new_data.buffer, + sp - (char*)new_data.buffer, + NULL, t->sha1, 0)) + t->pack_id = MAX_PACK_ID; + else + t->pack_id = pack_id; } -static void cmd_reset_branch() +static void cmd_reset_branch(void) { struct branch *b; - char *str_uq; - const char *endp; char *sp; /* Obtain the branch name from the rest of our command */ sp = strchr(command_buf.buf, ' ') + 1; - str_uq = unquote_c_style(sp, &endp); - if (str_uq) { - if (*endp) - die("Garbage after ref in: %s", command_buf.buf); - sp = str_uq; - } b = lookup_branch(sp); if (b) { - b->last_commit = 0; + hashclr(b->sha1); + hashclr(b->branch_tree.versions[0].sha1); + hashclr(b->branch_tree.versions[1].sha1); if (b->branch_tree.tree) { release_tree_content_recursive(b->branch_tree.tree); b->branch_tree.tree = NULL; @@ -1707,22 +1952,28 @@ static void cmd_reset_branch() } else b = new_branch(sp); - if (str_uq) - free(str_uq); read_next_command(); cmd_from(b); } +static void cmd_checkpoint(void) +{ + if (object_count) { + cycle_packfile(); + dump_branches(); + dump_tags(); + dump_marks(); + } + read_next_command(); +} + static const char fast_import_usage[] = -"git-fast-import [--objects=n] [--depth=n] [--active-branches=n] [--export-marks=marks.file] [--branch-log=log] temp.pack"; +"git-fast-import [--date-format=f] [--max-pack-size=n] [--depth=n] [--active-branches=n] [--export-marks=marks.file]"; int main(int argc, const char **argv) { - int i; - unsigned long est_obj_cnt = object_entry_alloc; - unsigned long duplicate_count; + int i, show_stats = 1; - setup_ident(); git_config(git_default_config); for (i = 1; i < argc; i++) { @@ -1730,27 +1981,44 @@ int main(int argc, const char **argv) if (*a != '-' || !strcmp(a, "--")) break; - else if (!strncmp(a, "--objects=", 10)) - est_obj_cnt = strtoul(a + 10, NULL, 0); + else if (!strncmp(a, "--date-format=", 14)) { + const char *fmt = a + 14; + if (!strcmp(fmt, "raw")) + whenspec = WHENSPEC_RAW; + else if (!strcmp(fmt, "rfc2822")) + whenspec = WHENSPEC_RFC2822; + else if (!strcmp(fmt, "now")) + whenspec = WHENSPEC_NOW; + else + die("unknown --date-format argument %s", fmt); + } + else if (!strncmp(a, "--max-pack-size=", 16)) + max_packsize = strtoumax(a + 16, NULL, 0) * 1024 * 1024; else if (!strncmp(a, "--depth=", 8)) max_depth = strtoul(a + 8, NULL, 0); else if (!strncmp(a, "--active-branches=", 18)) max_active_branches = strtoul(a + 18, NULL, 0); else if (!strncmp(a, "--export-marks=", 15)) mark_file = a + 15; - else if (!strncmp(a, "--branch-log=", 13)) { - branch_log = fopen(a + 13, "w"); - if (!branch_log) - die("Can't create %s: %s", a + 13, strerror(errno)); - } + else if (!strncmp(a, "--export-pack-edges=", 20)) { + if (pack_edges) + fclose(pack_edges); + pack_edges = fopen(a + 20, "a"); + if (!pack_edges) + die("Cannot open %s: %s", a + 20, strerror(errno)); + } else if (!strcmp(a, "--force")) + force_update = 1; + else if (!strcmp(a, "--quiet")) + show_stats = 0; + else if (!strcmp(a, "--stats")) + show_stats = 1; else die("unknown option %s", a); } - if ((i+1) != argc) + if (i != argc) usage(fast_import_usage); - base_name = argv[i]; - alloc_objects(est_obj_cnt); + alloc_objects(object_entry_alloc); strbuf_init(&command_buf); atom_table = xcalloc(atom_table_sz, sizeof(struct atom_str*)); @@ -1771,6 +2039,8 @@ int main(int argc, const char **argv) cmd_new_tag(); else if (!strncmp("reset ", command_buf.buf, 6)) cmd_reset_branch(); + else if (!strcmp("checkpoint", command_buf.buf)) + cmd_checkpoint(); else die("Unsupported command: %s", command_buf.buf); } @@ -1778,29 +2048,38 @@ int main(int argc, const char **argv) dump_branches(); dump_tags(); + unkeep_all_packs(); dump_marks(); - if (branch_log) - fclose(branch_log); - - for (i = 0; i < ARRAY_SIZE(duplicate_count_by_type); i++) - duplicate_count += duplicate_count_by_type[i]; - - fprintf(stderr, "%s statistics:\n", argv[0]); - fprintf(stderr, "---------------------------------------------------------------------\n"); - fprintf(stderr, "Alloc'd objects: %10lu (%10lu overflow )\n", alloc_count, alloc_count - est_obj_cnt); - fprintf(stderr, "Total objects: %10lu (%10lu duplicates )\n", object_count, duplicate_count); - fprintf(stderr, " blobs : %10lu (%10lu duplicates %10lu deltas)\n", object_count_by_type[OBJ_BLOB], duplicate_count_by_type[OBJ_BLOB], delta_count_by_type[OBJ_BLOB]); - fprintf(stderr, " trees : %10lu (%10lu duplicates %10lu deltas)\n", object_count_by_type[OBJ_TREE], duplicate_count_by_type[OBJ_TREE], delta_count_by_type[OBJ_TREE]); - fprintf(stderr, " commits: %10lu (%10lu duplicates %10lu deltas)\n", object_count_by_type[OBJ_COMMIT], duplicate_count_by_type[OBJ_COMMIT], delta_count_by_type[OBJ_COMMIT]); - fprintf(stderr, " tags : %10lu (%10lu duplicates %10lu deltas)\n", object_count_by_type[OBJ_TAG], duplicate_count_by_type[OBJ_TAG], delta_count_by_type[OBJ_TAG]); - fprintf(stderr, "Total branches: %10lu (%10lu loads )\n", branch_count, branch_load_count); - fprintf(stderr, " marks: %10u (%10lu unique )\n", (1 << marks->shift) * 1024, marks_set_count); - fprintf(stderr, " atoms: %10u\n", atom_cnt); - fprintf(stderr, "Memory total: %10lu KiB\n", (total_allocd + alloc_count*sizeof(struct object_entry))/1024); - fprintf(stderr, " pools: %10lu KiB\n", total_allocd/1024); - fprintf(stderr, " objects: %10lu KiB\n", (alloc_count*sizeof(struct object_entry))/1024); - fprintf(stderr, "---------------------------------------------------------------------\n"); - fprintf(stderr, "\n"); - return 0; + if (pack_edges) + fclose(pack_edges); + + if (show_stats) { + uintmax_t total_count = 0, duplicate_count = 0; + for (i = 0; i < ARRAY_SIZE(object_count_by_type); i++) + total_count += object_count_by_type[i]; + for (i = 0; i < ARRAY_SIZE(duplicate_count_by_type); i++) + duplicate_count += duplicate_count_by_type[i]; + + fprintf(stderr, "%s statistics:\n", argv[0]); + fprintf(stderr, "---------------------------------------------------------------------\n"); + fprintf(stderr, "Alloc'd objects: %10" PRIuMAX "\n", alloc_count); + fprintf(stderr, "Total objects: %10" PRIuMAX " (%10" PRIuMAX " duplicates )\n", total_count, duplicate_count); + fprintf(stderr, " blobs : %10" PRIuMAX " (%10" PRIuMAX " duplicates %10" PRIuMAX " deltas)\n", object_count_by_type[OBJ_BLOB], duplicate_count_by_type[OBJ_BLOB], delta_count_by_type[OBJ_BLOB]); + fprintf(stderr, " trees : %10" PRIuMAX " (%10" PRIuMAX " duplicates %10" PRIuMAX " deltas)\n", object_count_by_type[OBJ_TREE], duplicate_count_by_type[OBJ_TREE], delta_count_by_type[OBJ_TREE]); + fprintf(stderr, " commits: %10" PRIuMAX " (%10" PRIuMAX " duplicates %10" PRIuMAX " deltas)\n", object_count_by_type[OBJ_COMMIT], duplicate_count_by_type[OBJ_COMMIT], delta_count_by_type[OBJ_COMMIT]); + fprintf(stderr, " tags : %10" PRIuMAX " (%10" PRIuMAX " duplicates %10" PRIuMAX " deltas)\n", object_count_by_type[OBJ_TAG], duplicate_count_by_type[OBJ_TAG], delta_count_by_type[OBJ_TAG]); + fprintf(stderr, "Total branches: %10lu (%10lu loads )\n", branch_count, branch_load_count); + fprintf(stderr, " marks: %10" PRIuMAX " (%10" PRIuMAX " unique )\n", (((uintmax_t)1) << marks->shift) * 1024, marks_set_count); + fprintf(stderr, " atoms: %10u\n", atom_cnt); + fprintf(stderr, "Memory total: %10" PRIuMAX " KiB\n", (total_allocd + alloc_count*sizeof(struct object_entry))/1024); + fprintf(stderr, " pools: %10lu KiB\n", (unsigned long)(total_allocd/1024)); + fprintf(stderr, " objects: %10" PRIuMAX " KiB\n", (alloc_count*sizeof(struct object_entry))/1024); + fprintf(stderr, "---------------------------------------------------------------------\n"); + pack_report(); + fprintf(stderr, "---------------------------------------------------------------------\n"); + fprintf(stderr, "\n"); + } + + return failure ? 1 : 0; }