2
Format of STDIN stream:
13
new_blob ::= 'blob' lf
16
file_content ::= data;
18
new_commit ::= 'commit' sp ref_str lf
20
('author' sp name '<' email '>' when lf)?
21
'committer' sp name '<' email '>' when lf
23
('from' sp (ref_str | hexsha1 | sha1exp_str | idnum) lf)?
24
('merge' sp (ref_str | hexsha1 | sha1exp_str | idnum) lf)*
29
file_change ::= file_clr | file_del | file_obm | file_inm;
30
file_clr ::= 'deleteall' lf;
31
file_del ::= 'D' sp path_str lf;
32
file_obm ::= 'M' sp mode sp (hexsha1 | idnum) sp path_str lf;
33
file_inm ::= 'M' sp mode sp 'inline' sp path_str lf
36
new_tag ::= 'tag' sp tag_str lf
37
'from' sp (ref_str | hexsha1 | sha1exp_str | idnum) lf
38
'tagger' sp name '<' email '>' when lf
42
reset_branch ::= 'reset' sp ref_str lf
43
('from' sp (ref_str | hexsha1 | sha1exp_str | idnum) lf)?
46
checkpoint ::= 'checkpoint' lf
49
# note: the first idnum in a stream should be 1 and subsequent
50
# idnums should not have gaps between values as this will cause
51
# the stream parser to reserve space for the gapped values. An
52
# idnum can be updated in the future to a new object by issuing
53
# a new mark directive with the old idnum.
55
mark ::= 'mark' sp idnum lf;
56
data ::= (delimited_data | exact_data)
59
# note: delim may be any string but must not contain lf.
60
# data_line may contain any data but must not be exactly
62
delimited_data ::= 'data' sp '<<' delim lf
66
# note: declen indicates the length of binary_data in bytes.
67
# declen does not include the lf preceeding the binary data.
69
exact_data ::= 'data' sp declen lf
72
# note: quoted strings are C-style quoting supporting \c for
73
# common escapes of 'c' (e..g \n, \t, \\, \") or \nnn where nnn
74
# is the signed byte value in octal. Note that the only
75
# characters which must actually be escaped to protect the
76
# stream formatting is: \, " and LF. Otherwise these values
80
sha1exp_str ::= sha1exp;
82
path_str ::= path | '"' quoted(path) '"' ;
83
mode ::= '100644' | '644'
88
declen ::= # unsigned 32 bit value, ascii base10 notation;
89
bigint ::= # unsigned integer value, ascii base10 notation;
90
binary_data ::= # file content, not interpreted;
92
when ::= raw_when | rfc2822_when;
93
raw_when ::= ts sp tz;
94
rfc2822_when ::= # Valid RFC 2822 date and time;
96
sp ::= # ASCII space character;
97
lf ::= # ASCII newline (LF) character;
99
# note: a colon (':') must precede the numerical value assigned to
100
# an idnum. This is to distinguish it from a ref or tag name as
101
# GIT does not permit ':' in ref or tag strings.
103
idnum ::= ':' bigint;
104
path ::= # GIT style file path, e.g. "a/b/c";
105
ref ::= # GIT ref name, e.g. "refs/heads/MOZ_GECKO_EXPERIMENT";
106
tag ::= # GIT tag name, e.g. "FIREFOX_1_5";
107
sha1exp ::= # Any valid GIT SHA1 expression;
108
hexsha1 ::= # SHA1 in hexadecimal format;
110
# note: name and email are UTF8 strings, however name must not
111
# contain '<' or lf and email must not contain any of the
112
# following: '<', '>', lf.
114
name ::= # valid GIT author/committer name;
115
email ::= # valid GIT author/committer email;
116
ts ::= # time since the epoch in seconds, ascii base10 notation;
117
tz ::= # GIT style timezone;
129
#include "csum-file.h"
133
#define PACK_ID_BITS 16
134
#define MAX_PACK_ID ((1<<PACK_ID_BITS)-1)
138
struct object_entry *next;
140
unsigned type : TYPE_BITS;
141
unsigned pack_id : PACK_ID_BITS;
142
unsigned char sha1[20];
145
struct object_entry_pool
147
struct object_entry_pool *next_pool;
148
struct object_entry *next_free;
149
struct object_entry *end;
150
struct object_entry entries[FLEX_ARRAY]; /* more */
156
struct object_entry *marked[1024];
157
struct mark_set *sets[1024];
173
struct mem_pool *next_pool;
176
char space[FLEX_ARRAY]; /* more */
181
struct atom_str *next_atom;
182
unsigned short str_len;
183
char str_dat[FLEX_ARRAY]; /* more */
189
struct tree_content *tree;
190
struct atom_str* name;
194
unsigned char sha1[20];
200
unsigned int entry_capacity; /* must match avail_tree_content */
201
unsigned int entry_count;
202
unsigned int delta_depth;
203
struct tree_entry *entries[FLEX_ARRAY]; /* more */
206
struct avail_tree_content
208
unsigned int entry_capacity; /* must match tree_content */
209
struct avail_tree_content *next_avail;
214
struct branch *table_next_branch;
215
struct branch *active_next_branch;
217
struct tree_entry branch_tree;
218
uintmax_t last_commit;
220
unsigned pack_id : PACK_ID_BITS;
221
unsigned char sha1[20];
226
struct tag *next_tag;
228
unsigned int pack_id;
229
unsigned char sha1[20];
240
struct hash_list *next;
241
unsigned char sha1[20];
250
/* Configured limits on output */
251
static unsigned long max_depth = 10;
252
static off_t max_packsize = (1LL << 32) - 1;
253
static int force_update;
255
/* Stats and misc. counters */
256
static uintmax_t alloc_count;
257
static uintmax_t marks_set_count;
258
static uintmax_t object_count_by_type[1 << TYPE_BITS];
259
static uintmax_t duplicate_count_by_type[1 << TYPE_BITS];
260
static uintmax_t delta_count_by_type[1 << TYPE_BITS];
261
static unsigned long object_count;
262
static unsigned long branch_count;
263
static unsigned long branch_load_count;
265
static FILE *pack_edges;
268
static size_t mem_pool_alloc = 2*1024*1024 - sizeof(struct mem_pool);
269
static size_t total_allocd;
270
static struct mem_pool *mem_pool;
272
/* Atom management */
273
static unsigned int atom_table_sz = 4451;
274
static unsigned int atom_cnt;
275
static struct atom_str **atom_table;
277
/* The .pack file being generated */
278
static unsigned int pack_id;
279
static struct packed_git *pack_data;
280
static struct packed_git **all_packs;
281
static unsigned long pack_size;
283
/* Table of objects we've written. */
284
static unsigned int object_entry_alloc = 5000;
285
static struct object_entry_pool *blocks;
286
static struct object_entry *object_table[1 << 16];
287
static struct mark_set *marks;
288
static const char* mark_file;
291
static struct last_object last_blob;
293
/* Tree management */
294
static unsigned int tree_entry_alloc = 1000;
295
static void *avail_tree_entry;
296
static unsigned int avail_tree_table_sz = 100;
297
static struct avail_tree_content **avail_tree_table;
298
static struct dbuf old_tree;
299
static struct dbuf new_tree;
302
static unsigned long max_active_branches = 5;
303
static unsigned long cur_active_branches;
304
static unsigned long branch_table_sz = 1039;
305
static struct branch **branch_table;
306
static struct branch *active_branches;
309
static struct tag *first_tag;
310
static struct tag *last_tag;
312
/* Input stream parsing */
313
static whenspec_type whenspec = WHENSPEC_RAW;
314
static struct strbuf command_buf;
315
static uintmax_t next_mark;
316
static struct dbuf new_data;
319
static void alloc_objects(unsigned int cnt)
321
struct object_entry_pool *b;
323
b = xmalloc(sizeof(struct object_entry_pool)
324
+ cnt * sizeof(struct object_entry));
325
b->next_pool = blocks;
326
b->next_free = b->entries;
327
b->end = b->entries + cnt;
332
static struct object_entry *new_object(unsigned char *sha1)
334
struct object_entry *e;
336
if (blocks->next_free == blocks->end)
337
alloc_objects(object_entry_alloc);
339
e = blocks->next_free++;
340
hashcpy(e->sha1, sha1);
344
static struct object_entry *find_object(unsigned char *sha1)
346
unsigned int h = sha1[0] << 8 | sha1[1];
347
struct object_entry *e;
348
for (e = object_table[h]; e; e = e->next)
349
if (!hashcmp(sha1, e->sha1))
354
static struct object_entry *insert_object(unsigned char *sha1)
356
unsigned int h = sha1[0] << 8 | sha1[1];
357
struct object_entry *e = object_table[h];
358
struct object_entry *p = NULL;
361
if (!hashcmp(sha1, e->sha1))
367
e = new_object(sha1);
377
static unsigned int hc_str(const char *s, size_t len)
385
static void *pool_alloc(size_t len)
390
for (p = mem_pool; p; p = p->next_pool)
391
if ((p->end - p->next_free >= len))
395
if (len >= (mem_pool_alloc/2)) {
399
total_allocd += sizeof(struct mem_pool) + mem_pool_alloc;
400
p = xmalloc(sizeof(struct mem_pool) + mem_pool_alloc);
401
p->next_pool = mem_pool;
402
p->next_free = p->space;
403
p->end = p->next_free + mem_pool_alloc;
408
/* round out to a pointer alignment */
409
if (len & (sizeof(void*) - 1))
410
len += sizeof(void*) - (len & (sizeof(void*) - 1));
415
static void *pool_calloc(size_t count, size_t size)
417
size_t len = count * size;
418
void *r = pool_alloc(len);
423
static char *pool_strdup(const char *s)
425
char *r = pool_alloc(strlen(s) + 1);
430
static void size_dbuf(struct dbuf *b, size_t maxlen)
433
if (b->capacity >= maxlen)
437
b->capacity = ((maxlen / 1024) + 1) * 1024;
438
b->buffer = xmalloc(b->capacity);
441
static void insert_mark(uintmax_t idnum, struct object_entry *oe)
443
struct mark_set *s = marks;
444
while ((idnum >> s->shift) >= 1024) {
445
s = pool_calloc(1, sizeof(struct mark_set));
446
s->shift = marks->shift + 10;
447
s->data.sets[0] = marks;
451
uintmax_t i = idnum >> s->shift;
452
idnum -= i << s->shift;
453
if (!s->data.sets[i]) {
454
s->data.sets[i] = pool_calloc(1, sizeof(struct mark_set));
455
s->data.sets[i]->shift = s->shift - 10;
459
if (!s->data.marked[idnum])
461
s->data.marked[idnum] = oe;
464
static struct object_entry *find_mark(uintmax_t idnum)
466
uintmax_t orig_idnum = idnum;
467
struct mark_set *s = marks;
468
struct object_entry *oe = NULL;
469
if ((idnum >> s->shift) < 1024) {
470
while (s && s->shift) {
471
uintmax_t i = idnum >> s->shift;
472
idnum -= i << s->shift;
476
oe = s->data.marked[idnum];
479
die("mark :%" PRIuMAX " not declared", orig_idnum);
483
static struct atom_str *to_atom(const char *s, unsigned short len)
485
unsigned int hc = hc_str(s, len) % atom_table_sz;
488
for (c = atom_table[hc]; c; c = c->next_atom)
489
if (c->str_len == len && !strncmp(s, c->str_dat, len))
492
c = pool_alloc(sizeof(struct atom_str) + len + 1);
494
strncpy(c->str_dat, s, len);
496
c->next_atom = atom_table[hc];
502
static struct branch *lookup_branch(const char *name)
504
unsigned int hc = hc_str(name, strlen(name)) % branch_table_sz;
507
for (b = branch_table[hc]; b; b = b->table_next_branch)
508
if (!strcmp(name, b->name))
513
static struct branch *new_branch(const char *name)
515
unsigned int hc = hc_str(name, strlen(name)) % branch_table_sz;
516
struct branch* b = lookup_branch(name);
519
die("Invalid attempt to create duplicate branch: %s", name);
520
if (check_ref_format(name))
521
die("Branch name doesn't conform to GIT standards: %s", name);
523
b = pool_calloc(1, sizeof(struct branch));
524
b->name = pool_strdup(name);
525
b->table_next_branch = branch_table[hc];
526
b->branch_tree.versions[0].mode = S_IFDIR;
527
b->branch_tree.versions[1].mode = S_IFDIR;
529
b->pack_id = MAX_PACK_ID;
530
branch_table[hc] = b;
535
static unsigned int hc_entries(unsigned int cnt)
537
cnt = cnt & 7 ? (cnt / 8) + 1 : cnt / 8;
538
return cnt < avail_tree_table_sz ? cnt : avail_tree_table_sz - 1;
541
static struct tree_content *new_tree_content(unsigned int cnt)
543
struct avail_tree_content *f, *l = NULL;
544
struct tree_content *t;
545
unsigned int hc = hc_entries(cnt);
547
for (f = avail_tree_table[hc]; f; l = f, f = f->next_avail)
548
if (f->entry_capacity >= cnt)
553
l->next_avail = f->next_avail;
555
avail_tree_table[hc] = f->next_avail;
557
cnt = cnt & 7 ? ((cnt / 8) + 1) * 8 : cnt;
558
f = pool_alloc(sizeof(*t) + sizeof(t->entries[0]) * cnt);
559
f->entry_capacity = cnt;
562
t = (struct tree_content*)f;
568
static void release_tree_entry(struct tree_entry *e);
569
static void release_tree_content(struct tree_content *t)
571
struct avail_tree_content *f = (struct avail_tree_content*)t;
572
unsigned int hc = hc_entries(f->entry_capacity);
573
f->next_avail = avail_tree_table[hc];
574
avail_tree_table[hc] = f;
577
static void release_tree_content_recursive(struct tree_content *t)
580
for (i = 0; i < t->entry_count; i++)
581
release_tree_entry(t->entries[i]);
582
release_tree_content(t);
585
static struct tree_content *grow_tree_content(
586
struct tree_content *t,
589
struct tree_content *r = new_tree_content(t->entry_count + amt);
590
r->entry_count = t->entry_count;
591
r->delta_depth = t->delta_depth;
592
memcpy(r->entries,t->entries,t->entry_count*sizeof(t->entries[0]));
593
release_tree_content(t);
597
static struct tree_entry *new_tree_entry(void)
599
struct tree_entry *e;
601
if (!avail_tree_entry) {
602
unsigned int n = tree_entry_alloc;
603
total_allocd += n * sizeof(struct tree_entry);
604
avail_tree_entry = e = xmalloc(n * sizeof(struct tree_entry));
606
*((void**)e) = e + 1;
612
e = avail_tree_entry;
613
avail_tree_entry = *((void**)e);
617
static void release_tree_entry(struct tree_entry *e)
620
release_tree_content_recursive(e->tree);
621
*((void**)e) = avail_tree_entry;
622
avail_tree_entry = e;
625
static void start_packfile(void)
627
static char tmpfile[PATH_MAX];
628
struct packed_git *p;
629
struct pack_header hdr;
632
snprintf(tmpfile, sizeof(tmpfile),
633
"%s/tmp_pack_XXXXXX", get_object_directory());
634
pack_fd = mkstemp(tmpfile);
636
die("Can't create %s: %s", tmpfile, strerror(errno));
637
p = xcalloc(1, sizeof(*p) + strlen(tmpfile) + 2);
638
strcpy(p->pack_name, tmpfile);
639
p->pack_fd = pack_fd;
641
hdr.hdr_signature = htonl(PACK_SIGNATURE);
642
hdr.hdr_version = htonl(2);
644
write_or_die(p->pack_fd, &hdr, sizeof(hdr));
647
pack_size = sizeof(hdr);
650
all_packs = xrealloc(all_packs, sizeof(*all_packs) * (pack_id + 1));
651
all_packs[pack_id] = p;
654
static void fixup_header_footer(void)
656
static const int buf_sz = 128 * 1024;
657
int pack_fd = pack_data->pack_fd;
659
struct pack_header hdr;
662
if (lseek(pack_fd, 0, SEEK_SET) != 0)
663
die("Failed seeking to start: %s", strerror(errno));
664
if (read_in_full(pack_fd, &hdr, sizeof(hdr)) != sizeof(hdr))
665
die("Unable to reread header of %s", pack_data->pack_name);
666
if (lseek(pack_fd, 0, SEEK_SET) != 0)
667
die("Failed seeking to start: %s", strerror(errno));
668
hdr.hdr_entries = htonl(object_count);
669
write_or_die(pack_fd, &hdr, sizeof(hdr));
672
SHA1_Update(&c, &hdr, sizeof(hdr));
674
buf = xmalloc(buf_sz);
676
size_t n = xread(pack_fd, buf, buf_sz);
680
die("Failed to checksum %s", pack_data->pack_name);
681
SHA1_Update(&c, buf, n);
685
SHA1_Final(pack_data->sha1, &c);
686
write_or_die(pack_fd, pack_data->sha1, sizeof(pack_data->sha1));
690
static int oecmp (const void *a_, const void *b_)
692
struct object_entry *a = *((struct object_entry**)a_);
693
struct object_entry *b = *((struct object_entry**)b_);
694
return hashcmp(a->sha1, b->sha1);
697
static char *create_index(void)
699
static char tmpfile[PATH_MAX];
702
struct object_entry **idx, **c, **last, *e;
703
struct object_entry_pool *o;
707
/* Build the sorted table of object IDs. */
708
idx = xmalloc(object_count * sizeof(struct object_entry*));
710
for (o = blocks; o; o = o->next_pool)
711
for (e = o->next_free; e-- != o->entries;)
712
if (pack_id == e->pack_id)
714
last = idx + object_count;
716
die("internal consistency error creating the index");
717
qsort(idx, object_count, sizeof(struct object_entry*), oecmp);
719
/* Generate the fan-out array. */
721
for (i = 0; i < 256; i++) {
722
struct object_entry **next = c;;
723
while (next < last) {
724
if ((*next)->sha1[0] != i)
728
array[i] = htonl(next - idx);
732
snprintf(tmpfile, sizeof(tmpfile),
733
"%s/tmp_idx_XXXXXX", get_object_directory());
734
idx_fd = mkstemp(tmpfile);
736
die("Can't create %s: %s", tmpfile, strerror(errno));
737
f = sha1fd(idx_fd, tmpfile);
738
sha1write(f, array, 256 * sizeof(int));
740
for (c = idx; c != last; c++) {
741
uint32_t offset = htonl((*c)->offset);
742
sha1write(f, &offset, 4);
743
sha1write(f, (*c)->sha1, sizeof((*c)->sha1));
744
SHA1_Update(&ctx, (*c)->sha1, 20);
746
sha1write(f, pack_data->sha1, sizeof(pack_data->sha1));
747
sha1close(f, NULL, 1);
749
SHA1_Final(pack_data->sha1, &ctx);
753
static char *keep_pack(char *curr_index_name)
755
static char name[PATH_MAX];
756
static const char *keep_msg = "fast-import";
759
chmod(pack_data->pack_name, 0444);
760
chmod(curr_index_name, 0444);
762
snprintf(name, sizeof(name), "%s/pack/pack-%s.keep",
763
get_object_directory(), sha1_to_hex(pack_data->sha1));
764
keep_fd = open(name, O_RDWR|O_CREAT|O_EXCL, 0600);
766
die("cannot create keep file");
767
write(keep_fd, keep_msg, strlen(keep_msg));
770
snprintf(name, sizeof(name), "%s/pack/pack-%s.pack",
771
get_object_directory(), sha1_to_hex(pack_data->sha1));
772
if (move_temp_to_file(pack_data->pack_name, name))
773
die("cannot store pack file");
775
snprintf(name, sizeof(name), "%s/pack/pack-%s.idx",
776
get_object_directory(), sha1_to_hex(pack_data->sha1));
777
if (move_temp_to_file(curr_index_name, name))
778
die("cannot store index file");
782
static void unkeep_all_packs(void)
784
static char name[PATH_MAX];
787
for (k = 0; k < pack_id; k++) {
788
struct packed_git *p = all_packs[k];
789
snprintf(name, sizeof(name), "%s/pack/pack-%s.keep",
790
get_object_directory(), sha1_to_hex(p->sha1));
795
static void end_packfile(void)
797
struct packed_git *old_p = pack_data, *new_p;
805
fixup_header_footer();
806
idx_name = keep_pack(create_index());
808
/* Register the packfile with core git's machinary. */
809
new_p = add_packed_git(idx_name, strlen(idx_name), 1);
811
die("core git rejected index %s", idx_name);
812
new_p->windows = old_p->windows;
813
all_packs[pack_id] = new_p;
814
install_packed_git(new_p);
816
/* Print the boundary */
818
fprintf(pack_edges, "%s:", new_p->pack_name);
819
for (i = 0; i < branch_table_sz; i++) {
820
for (b = branch_table[i]; b; b = b->table_next_branch) {
821
if (b->pack_id == pack_id)
822
fprintf(pack_edges, " %s", sha1_to_hex(b->sha1));
825
for (t = first_tag; t; t = t->next_tag) {
826
if (t->pack_id == pack_id)
827
fprintf(pack_edges, " %s", sha1_to_hex(t->sha1));
829
fputc('\n', pack_edges);
836
unlink(old_p->pack_name);
839
/* We can't carry a delta across packfiles. */
840
free(last_blob.data);
841
last_blob.data = NULL;
843
last_blob.offset = 0;
847
static void cycle_packfile(void)
853
static size_t encode_header(
854
enum object_type type,
861
if (type < OBJ_COMMIT || type > OBJ_REF_DELTA)
862
die("bad type %d", type);
864
c = (type << 4) | (size & 15);
876
static int store_object(
877
enum object_type type,
880
struct last_object *last,
881
unsigned char *sha1out,
885
struct object_entry *e;
886
unsigned char hdr[96];
887
unsigned char sha1[20];
888
unsigned long hdrlen, deltalen;
892
hdrlen = sprintf((char*)hdr,"%s %lu", typename(type),
893
(unsigned long)datlen) + 1;
895
SHA1_Update(&c, hdr, hdrlen);
896
SHA1_Update(&c, dat, datlen);
897
SHA1_Final(sha1, &c);
899
hashcpy(sha1out, sha1);
901
e = insert_object(sha1);
903
insert_mark(mark, e);
905
duplicate_count_by_type[type]++;
909
if (last && last->data && last->depth < max_depth) {
910
delta = diff_delta(last->data, last->len,
913
if (delta && deltalen >= datlen) {
920
memset(&s, 0, sizeof(s));
921
deflateInit(&s, zlib_compression_level);
924
s.avail_in = deltalen;
929
s.avail_out = deflateBound(&s, s.avail_in);
930
s.next_out = out = xmalloc(s.avail_out);
931
while (deflate(&s, Z_FINISH) == Z_OK)
935
/* Determine if we should auto-checkpoint. */
936
if ((pack_size + 60 + s.total_out) > max_packsize
937
|| (pack_size + 60 + s.total_out) < pack_size) {
939
/* This new object needs to *not* have the current pack_id. */
940
e->pack_id = pack_id + 1;
943
/* We cannot carry a delta into the new pack. */
948
memset(&s, 0, sizeof(s));
949
deflateInit(&s, zlib_compression_level);
952
s.avail_out = deflateBound(&s, s.avail_in);
953
s.next_out = out = xrealloc(out, s.avail_out);
954
while (deflate(&s, Z_FINISH) == Z_OK)
961
e->pack_id = pack_id;
962
e->offset = pack_size;
964
object_count_by_type[type]++;
967
unsigned long ofs = e->offset - last->offset;
968
unsigned pos = sizeof(hdr) - 1;
970
delta_count_by_type[type]++;
973
hdrlen = encode_header(OBJ_OFS_DELTA, deltalen, hdr);
974
write_or_die(pack_data->pack_fd, hdr, hdrlen);
977
hdr[pos] = ofs & 127;
979
hdr[--pos] = 128 | (--ofs & 127);
980
write_or_die(pack_data->pack_fd, hdr + pos, sizeof(hdr) - pos);
981
pack_size += sizeof(hdr) - pos;
985
hdrlen = encode_header(type, datlen, hdr);
986
write_or_die(pack_data->pack_fd, hdr, hdrlen);
990
write_or_die(pack_data->pack_fd, out, s.total_out);
991
pack_size += s.total_out;
999
last->offset = e->offset;
1005
static void *gfi_unpack_entry(
1006
struct object_entry *oe,
1007
unsigned long *sizep)
1009
enum object_type type;
1010
struct packed_git *p = all_packs[oe->pack_id];
1012
p->pack_size = pack_size + 20;
1013
return unpack_entry(p, oe->offset, &type, sizep);
1016
static const char *get_mode(const char *str, uint16_t *modep)
1021
while ((c = *str++) != ' ') {
1022
if (c < '0' || c > '7')
1024
mode = (mode << 3) + (c - '0');
1030
static void load_tree(struct tree_entry *root)
1032
unsigned char* sha1 = root->versions[1].sha1;
1033
struct object_entry *myoe;
1034
struct tree_content *t;
1039
root->tree = t = new_tree_content(8);
1040
if (is_null_sha1(sha1))
1043
myoe = find_object(sha1);
1045
if (myoe->type != OBJ_TREE)
1046
die("Not a tree: %s", sha1_to_hex(sha1));
1048
buf = gfi_unpack_entry(myoe, &size);
1050
enum object_type type;
1051
buf = read_sha1_file(sha1, &type, &size);
1052
if (!buf || type != OBJ_TREE)
1053
die("Can't load tree %s", sha1_to_hex(sha1));
1057
while (c != (buf + size)) {
1058
struct tree_entry *e = new_tree_entry();
1060
if (t->entry_count == t->entry_capacity)
1061
root->tree = t = grow_tree_content(t, t->entry_count);
1062
t->entries[t->entry_count++] = e;
1065
c = get_mode(c, &e->versions[1].mode);
1067
die("Corrupt mode in %s", sha1_to_hex(sha1));
1068
e->versions[0].mode = e->versions[1].mode;
1069
e->name = to_atom(c, strlen(c));
1070
c += e->name->str_len + 1;
1071
hashcpy(e->versions[0].sha1, (unsigned char*)c);
1072
hashcpy(e->versions[1].sha1, (unsigned char*)c);
1078
static int tecmp0 (const void *_a, const void *_b)
1080
struct tree_entry *a = *((struct tree_entry**)_a);
1081
struct tree_entry *b = *((struct tree_entry**)_b);
1082
return base_name_compare(
1083
a->name->str_dat, a->name->str_len, a->versions[0].mode,
1084
b->name->str_dat, b->name->str_len, b->versions[0].mode);
1087
static int tecmp1 (const void *_a, const void *_b)
1089
struct tree_entry *a = *((struct tree_entry**)_a);
1090
struct tree_entry *b = *((struct tree_entry**)_b);
1091
return base_name_compare(
1092
a->name->str_dat, a->name->str_len, a->versions[1].mode,
1093
b->name->str_dat, b->name->str_len, b->versions[1].mode);
1096
static void mktree(struct tree_content *t,
1106
qsort(t->entries,t->entry_count,sizeof(t->entries[0]),tecmp0);
1108
qsort(t->entries,t->entry_count,sizeof(t->entries[0]),tecmp1);
1110
for (i = 0; i < t->entry_count; i++) {
1111
if (t->entries[i]->versions[v].mode)
1112
maxlen += t->entries[i]->name->str_len + 34;
1115
size_dbuf(b, maxlen);
1117
for (i = 0; i < t->entry_count; i++) {
1118
struct tree_entry *e = t->entries[i];
1119
if (!e->versions[v].mode)
1121
c += sprintf(c, "%o", (unsigned int)e->versions[v].mode);
1123
strcpy(c, e->name->str_dat);
1124
c += e->name->str_len + 1;
1125
hashcpy((unsigned char*)c, e->versions[v].sha1);
1128
*szp = c - (char*)b->buffer;
1131
static void store_tree(struct tree_entry *root)
1133
struct tree_content *t = root->tree;
1134
unsigned int i, j, del;
1135
unsigned long new_len;
1136
struct last_object lo;
1137
struct object_entry *le;
1139
if (!is_null_sha1(root->versions[1].sha1))
1142
for (i = 0; i < t->entry_count; i++) {
1143
if (t->entries[i]->tree)
1144
store_tree(t->entries[i]);
1147
le = find_object(root->versions[0].sha1);
1148
if (!S_ISDIR(root->versions[0].mode)
1150
|| le->pack_id != pack_id) {
1154
mktree(t, 0, &lo.len, &old_tree);
1155
lo.data = old_tree.buffer;
1156
lo.offset = le->offset;
1157
lo.depth = t->delta_depth;
1161
mktree(t, 1, &new_len, &new_tree);
1162
store_object(OBJ_TREE, new_tree.buffer, new_len,
1163
&lo, root->versions[1].sha1, 0);
1165
t->delta_depth = lo.depth;
1166
for (i = 0, j = 0, del = 0; i < t->entry_count; i++) {
1167
struct tree_entry *e = t->entries[i];
1168
if (e->versions[1].mode) {
1169
e->versions[0].mode = e->versions[1].mode;
1170
hashcpy(e->versions[0].sha1, e->versions[1].sha1);
1171
t->entries[j++] = e;
1173
release_tree_entry(e);
1177
t->entry_count -= del;
1180
static int tree_content_set(
1181
struct tree_entry *root,
1183
const unsigned char *sha1,
1184
const uint16_t mode)
1186
struct tree_content *t = root->tree;
1189
struct tree_entry *e;
1191
slash1 = strchr(p, '/');
1197
for (i = 0; i < t->entry_count; i++) {
1199
if (e->name->str_len == n && !strncmp(p, e->name->str_dat, n)) {
1201
if (e->versions[1].mode == mode
1202
&& !hashcmp(e->versions[1].sha1, sha1))
1204
e->versions[1].mode = mode;
1205
hashcpy(e->versions[1].sha1, sha1);
1207
release_tree_content_recursive(e->tree);
1210
hashclr(root->versions[1].sha1);
1213
if (!S_ISDIR(e->versions[1].mode)) {
1214
e->tree = new_tree_content(8);
1215
e->versions[1].mode = S_IFDIR;
1219
if (tree_content_set(e, slash1 + 1, sha1, mode)) {
1220
hashclr(root->versions[1].sha1);
1227
if (t->entry_count == t->entry_capacity)
1228
root->tree = t = grow_tree_content(t, t->entry_count);
1229
e = new_tree_entry();
1230
e->name = to_atom(p, n);
1231
e->versions[0].mode = 0;
1232
hashclr(e->versions[0].sha1);
1233
t->entries[t->entry_count++] = e;
1235
e->tree = new_tree_content(8);
1236
e->versions[1].mode = S_IFDIR;
1237
tree_content_set(e, slash1 + 1, sha1, mode);
1240
e->versions[1].mode = mode;
1241
hashcpy(e->versions[1].sha1, sha1);
1243
hashclr(root->versions[1].sha1);
1247
static int tree_content_remove(struct tree_entry *root, const char *p)
1249
struct tree_content *t = root->tree;
1252
struct tree_entry *e;
1254
slash1 = strchr(p, '/');
1260
for (i = 0; i < t->entry_count; i++) {
1262
if (e->name->str_len == n && !strncmp(p, e->name->str_dat, n)) {
1263
if (!slash1 || !S_ISDIR(e->versions[1].mode))
1267
if (tree_content_remove(e, slash1 + 1)) {
1268
for (n = 0; n < e->tree->entry_count; n++) {
1269
if (e->tree->entries[n]->versions[1].mode) {
1270
hashclr(root->versions[1].sha1);
1283
release_tree_content_recursive(e->tree);
1286
e->versions[1].mode = 0;
1287
hashclr(e->versions[1].sha1);
1288
hashclr(root->versions[1].sha1);
1292
static int update_branch(struct branch *b)
1294
static const char *msg = "fast-import";
1295
struct ref_lock *lock;
1296
unsigned char old_sha1[20];
1298
if (read_ref(b->name, old_sha1))
1300
lock = lock_any_ref_for_update(b->name, old_sha1);
1302
return error("Unable to lock %s", b->name);
1303
if (!force_update && !is_null_sha1(old_sha1)) {
1304
struct commit *old_cmit, *new_cmit;
1306
old_cmit = lookup_commit_reference_gently(old_sha1, 0);
1307
new_cmit = lookup_commit_reference_gently(b->sha1, 0);
1308
if (!old_cmit || !new_cmit) {
1310
return error("Branch %s is missing commits.", b->name);
1313
if (!in_merge_bases(old_cmit, &new_cmit, 1)) {
1315
warning("Not updating %s"
1316
" (new tip %s does not contain %s)",
1317
b->name, sha1_to_hex(b->sha1), sha1_to_hex(old_sha1));
1321
if (write_ref_sha1(lock, b->sha1, msg) < 0)
1322
return error("Unable to update %s", b->name);
1326
static void dump_branches(void)
1331
for (i = 0; i < branch_table_sz; i++) {
1332
for (b = branch_table[i]; b; b = b->table_next_branch)
1333
failure |= update_branch(b);
1337
static void dump_tags(void)
1339
static const char *msg = "fast-import";
1341
struct ref_lock *lock;
1342
char ref_name[PATH_MAX];
1344
for (t = first_tag; t; t = t->next_tag) {
1345
sprintf(ref_name, "tags/%s", t->name);
1346
lock = lock_ref_sha1(ref_name, NULL);
1347
if (!lock || write_ref_sha1(lock, t->sha1, msg) < 0)
1348
failure |= error("Unable to update %s", ref_name);
1352
static void dump_marks_helper(FILE *f,
1358
for (k = 0; k < 1024; k++) {
1359
if (m->data.sets[k])
1360
dump_marks_helper(f, (base + k) << m->shift,
1364
for (k = 0; k < 1024; k++) {
1365
if (m->data.marked[k])
1366
fprintf(f, ":%" PRIuMAX " %s\n", base + k,
1367
sha1_to_hex(m->data.marked[k]->sha1));
1372
static void dump_marks(void)
1374
static struct lock_file mark_lock;
1381
mark_fd = hold_lock_file_for_update(&mark_lock, mark_file, 0);
1383
failure |= error("Unable to write marks file %s: %s",
1384
mark_file, strerror(errno));
1388
f = fdopen(mark_fd, "w");
1390
rollback_lock_file(&mark_lock);
1391
failure |= error("Unable to write marks file %s: %s",
1392
mark_file, strerror(errno));
1396
dump_marks_helper(f, 0, marks);
1398
if (commit_lock_file(&mark_lock))
1399
failure |= error("Unable to write marks file %s: %s",
1400
mark_file, strerror(errno));
1403
static void read_next_command(void)
1405
read_line(&command_buf, stdin, '\n');
1408
static void cmd_mark(void)
1410
if (!prefixcmp(command_buf.buf, "mark :")) {
1411
next_mark = strtoumax(command_buf.buf + 6, NULL, 10);
1412
read_next_command();
1418
static void *cmd_data (size_t *size)
1423
if (prefixcmp(command_buf.buf, "data "))
1424
die("Expected 'data n' command, found: %s", command_buf.buf);
1426
if (!prefixcmp(command_buf.buf + 5, "<<")) {
1427
char *term = xstrdup(command_buf.buf + 5 + 2);
1428
size_t sz = 8192, term_len = command_buf.len - 5 - 2;
1430
buffer = xmalloc(sz);
1432
read_next_command();
1433
if (command_buf.eof)
1434
die("EOF in data (terminator '%s' not found)", term);
1435
if (term_len == command_buf.len
1436
&& !strcmp(term, command_buf.buf))
1438
if (sz < (length + command_buf.len)) {
1439
sz = sz * 3 / 2 + 16;
1440
if (sz < (length + command_buf.len))
1441
sz = length + command_buf.len;
1442
buffer = xrealloc(buffer, sz);
1444
memcpy(buffer + length,
1446
command_buf.len - 1);
1447
length += command_buf.len - 1;
1448
buffer[length++] = '\n';
1454
length = strtoul(command_buf.buf + 5, NULL, 10);
1455
buffer = xmalloc(length);
1456
while (n < length) {
1457
size_t s = fread(buffer + n, 1, length - n, stdin);
1458
if (!s && feof(stdin))
1459
die("EOF in data (%lu bytes remaining)",
1460
(unsigned long)(length - n));
1465
if (fgetc(stdin) != '\n')
1466
die("An lf did not trail the binary data as expected.");
1472
static int validate_raw_date(const char *src, char *result, int maxlen)
1474
const char *orig_src = src;
1477
strtoul(src, &endp, 10);
1478
if (endp == src || *endp != ' ')
1482
if (*src != '-' && *src != '+')
1486
strtoul(src + 1, &endp, 10);
1487
if (endp == src || *endp || (endp - orig_src) >= maxlen)
1490
strcpy(result, orig_src);
1494
static char *parse_ident(const char *buf)
1500
gt = strrchr(buf, '>');
1502
die("Missing > in ident string: %s", buf);
1505
die("Missing space after > in ident string: %s", buf);
1507
name_len = gt - buf;
1508
ident = xmalloc(name_len + 24);
1509
strncpy(ident, buf, name_len);
1513
if (validate_raw_date(gt, ident + name_len, 24) < 0)
1514
die("Invalid raw date \"%s\" in ident: %s", gt, buf);
1516
case WHENSPEC_RFC2822:
1517
if (parse_date(gt, ident + name_len, 24) < 0)
1518
die("Invalid rfc2822 date \"%s\" in ident: %s", gt, buf);
1521
if (strcmp("now", gt))
1522
die("Date in ident must be 'now': %s", buf);
1523
datestamp(ident + name_len, 24);
1530
static void cmd_new_blob(void)
1535
read_next_command();
1539
if (store_object(OBJ_BLOB, d, l, &last_blob, NULL, next_mark))
1543
static void unload_one_branch(void)
1545
while (cur_active_branches
1546
&& cur_active_branches >= max_active_branches) {
1547
uintmax_t min_commit = ULONG_MAX;
1548
struct branch *e, *l = NULL, *p = NULL;
1550
for (e = active_branches; e; e = e->active_next_branch) {
1551
if (e->last_commit < min_commit) {
1553
min_commit = e->last_commit;
1559
e = p->active_next_branch;
1560
p->active_next_branch = e->active_next_branch;
1562
e = active_branches;
1563
active_branches = e->active_next_branch;
1566
e->active_next_branch = NULL;
1567
if (e->branch_tree.tree) {
1568
release_tree_content_recursive(e->branch_tree.tree);
1569
e->branch_tree.tree = NULL;
1571
cur_active_branches--;
1575
static void load_branch(struct branch *b)
1577
load_tree(&b->branch_tree);
1580
b->active_next_branch = active_branches;
1581
active_branches = b;
1582
cur_active_branches++;
1583
branch_load_count++;
1587
static void file_change_m(struct branch *b)
1589
const char *p = command_buf.buf + 2;
1592
struct object_entry *oe = oe;
1593
unsigned char sha1[20];
1594
uint16_t mode, inline_data = 0;
1596
p = get_mode(p, &mode);
1598
die("Corrupt mode: %s", command_buf.buf);
1600
case S_IFREG | 0644:
1601
case S_IFREG | 0755:
1608
die("Corrupt mode: %s", command_buf.buf);
1613
oe = find_mark(strtoumax(p + 1, &x, 10));
1614
hashcpy(sha1, oe->sha1);
1616
} else if (!prefixcmp(p, "inline")) {
1620
if (get_sha1_hex(p, sha1))
1621
die("Invalid SHA1: %s", command_buf.buf);
1622
oe = find_object(sha1);
1626
die("Missing space after SHA1: %s", command_buf.buf);
1628
p_uq = unquote_c_style(p, &endp);
1631
die("Garbage after path in: %s", command_buf.buf);
1639
p = p_uq = xstrdup(p);
1640
read_next_command();
1642
if (store_object(OBJ_BLOB, d, l, &last_blob, sha1, 0))
1645
if (oe->type != OBJ_BLOB)
1646
die("Not a blob (actually a %s): %s",
1647
command_buf.buf, typename(oe->type));
1649
enum object_type type = sha1_object_info(sha1, NULL);
1651
die("Blob not found: %s", command_buf.buf);
1652
if (type != OBJ_BLOB)
1653
die("Not a blob (actually a %s): %s",
1654
typename(type), command_buf.buf);
1657
tree_content_set(&b->branch_tree, p, sha1, S_IFREG | mode);
1661
static void file_change_d(struct branch *b)
1663
const char *p = command_buf.buf + 2;
1667
p_uq = unquote_c_style(p, &endp);
1670
die("Garbage after path in: %s", command_buf.buf);
1673
tree_content_remove(&b->branch_tree, p);
1677
static void file_change_deleteall(struct branch *b)
1679
release_tree_content_recursive(b->branch_tree.tree);
1680
hashclr(b->branch_tree.versions[0].sha1);
1681
hashclr(b->branch_tree.versions[1].sha1);
1682
load_tree(&b->branch_tree);
1685
static void cmd_from(struct branch *b)
1690
if (prefixcmp(command_buf.buf, "from "))
1693
if (b->branch_tree.tree) {
1694
release_tree_content_recursive(b->branch_tree.tree);
1695
b->branch_tree.tree = NULL;
1698
from = strchr(command_buf.buf, ' ') + 1;
1699
s = lookup_branch(from);
1701
die("Can't create a branch from itself: %s", b->name);
1703
unsigned char *t = s->branch_tree.versions[1].sha1;
1704
hashcpy(b->sha1, s->sha1);
1705
hashcpy(b->branch_tree.versions[0].sha1, t);
1706
hashcpy(b->branch_tree.versions[1].sha1, t);
1707
} else if (*from == ':') {
1708
uintmax_t idnum = strtoumax(from + 1, NULL, 10);
1709
struct object_entry *oe = find_mark(idnum);
1712
if (oe->type != OBJ_COMMIT)
1713
die("Mark :%" PRIuMAX " not a commit", idnum);
1714
hashcpy(b->sha1, oe->sha1);
1715
buf = gfi_unpack_entry(oe, &size);
1716
if (!buf || size < 46)
1717
die("Not a valid commit: %s", from);
1718
if (memcmp("tree ", buf, 5)
1719
|| get_sha1_hex(buf + 5, b->branch_tree.versions[1].sha1))
1720
die("The commit %s is corrupt", sha1_to_hex(b->sha1));
1722
hashcpy(b->branch_tree.versions[0].sha1,
1723
b->branch_tree.versions[1].sha1);
1724
} else if (!get_sha1(from, b->sha1)) {
1725
if (is_null_sha1(b->sha1)) {
1726
hashclr(b->branch_tree.versions[0].sha1);
1727
hashclr(b->branch_tree.versions[1].sha1);
1732
buf = read_object_with_reference(b->sha1,
1733
commit_type, &size, b->sha1);
1734
if (!buf || size < 46)
1735
die("Not a valid commit: %s", from);
1736
if (memcmp("tree ", buf, 5)
1737
|| get_sha1_hex(buf + 5, b->branch_tree.versions[1].sha1))
1738
die("The commit %s is corrupt", sha1_to_hex(b->sha1));
1740
hashcpy(b->branch_tree.versions[0].sha1,
1741
b->branch_tree.versions[1].sha1);
1744
die("Invalid ref name or SHA1 expression: %s", from);
1746
read_next_command();
1749
static struct hash_list *cmd_merge(unsigned int *count)
1751
struct hash_list *list = NULL, *n, *e = e;
1756
while (!prefixcmp(command_buf.buf, "merge ")) {
1757
from = strchr(command_buf.buf, ' ') + 1;
1758
n = xmalloc(sizeof(*n));
1759
s = lookup_branch(from);
1761
hashcpy(n->sha1, s->sha1);
1762
else if (*from == ':') {
1763
uintmax_t idnum = strtoumax(from + 1, NULL, 10);
1764
struct object_entry *oe = find_mark(idnum);
1765
if (oe->type != OBJ_COMMIT)
1766
die("Mark :%" PRIuMAX " not a commit", idnum);
1767
hashcpy(n->sha1, oe->sha1);
1768
} else if (!get_sha1(from, n->sha1)) {
1770
char *buf = read_object_with_reference(n->sha1,
1771
commit_type, &size, n->sha1);
1772
if (!buf || size < 46)
1773
die("Not a valid commit: %s", from);
1776
die("Invalid ref name or SHA1 expression: %s", from);
1785
read_next_command();
1790
static void cmd_new_commit(void)
1796
char *author = NULL;
1797
char *committer = NULL;
1798
struct hash_list *merge_list = NULL;
1799
unsigned int merge_count;
1801
/* Obtain the branch name from the rest of our command */
1802
sp = strchr(command_buf.buf, ' ') + 1;
1803
b = lookup_branch(sp);
1807
read_next_command();
1809
if (!prefixcmp(command_buf.buf, "author ")) {
1810
author = parse_ident(command_buf.buf + 7);
1811
read_next_command();
1813
if (!prefixcmp(command_buf.buf, "committer ")) {
1814
committer = parse_ident(command_buf.buf + 10);
1815
read_next_command();
1818
die("Expected committer but didn't get one");
1819
msg = cmd_data(&msglen);
1820
read_next_command();
1822
merge_list = cmd_merge(&merge_count);
1824
/* ensure the branch is active/loaded */
1825
if (!b->branch_tree.tree || !max_active_branches) {
1826
unload_one_branch();
1832
if (1 == command_buf.len)
1834
else if (!prefixcmp(command_buf.buf, "M "))
1836
else if (!prefixcmp(command_buf.buf, "D "))
1838
else if (!strcmp("deleteall", command_buf.buf))
1839
file_change_deleteall(b);
1841
die("Unsupported file_change: %s", command_buf.buf);
1842
read_next_command();
1845
/* build the tree and the commit */
1846
store_tree(&b->branch_tree);
1847
hashcpy(b->branch_tree.versions[0].sha1,
1848
b->branch_tree.versions[1].sha1);
1849
size_dbuf(&new_data, 114 + msglen
1852
? strlen(author) + strlen(committer)
1853
: 2 * strlen(committer)));
1854
sp = new_data.buffer;
1855
sp += sprintf(sp, "tree %s\n",
1856
sha1_to_hex(b->branch_tree.versions[1].sha1));
1857
if (!is_null_sha1(b->sha1))
1858
sp += sprintf(sp, "parent %s\n", sha1_to_hex(b->sha1));
1859
while (merge_list) {
1860
struct hash_list *next = merge_list->next;
1861
sp += sprintf(sp, "parent %s\n", sha1_to_hex(merge_list->sha1));
1865
sp += sprintf(sp, "author %s\n", author ? author : committer);
1866
sp += sprintf(sp, "committer %s\n", committer);
1868
memcpy(sp, msg, msglen);
1874
if (!store_object(OBJ_COMMIT,
1875
new_data.buffer, sp - (char*)new_data.buffer,
1876
NULL, b->sha1, next_mark))
1877
b->pack_id = pack_id;
1878
b->last_commit = object_count_by_type[OBJ_COMMIT];
1881
static void cmd_new_tag(void)
1890
uintmax_t from_mark = 0;
1891
unsigned char sha1[20];
1893
/* Obtain the new tag name from the rest of our command */
1894
sp = strchr(command_buf.buf, ' ') + 1;
1895
t = pool_alloc(sizeof(struct tag));
1897
t->name = pool_strdup(sp);
1899
last_tag->next_tag = t;
1903
read_next_command();
1906
if (prefixcmp(command_buf.buf, "from "))
1907
die("Expected from command, got %s", command_buf.buf);
1908
from = strchr(command_buf.buf, ' ') + 1;
1909
s = lookup_branch(from);
1911
hashcpy(sha1, s->sha1);
1912
} else if (*from == ':') {
1913
struct object_entry *oe;
1914
from_mark = strtoumax(from + 1, NULL, 10);
1915
oe = find_mark(from_mark);
1916
if (oe->type != OBJ_COMMIT)
1917
die("Mark :%" PRIuMAX " not a commit", from_mark);
1918
hashcpy(sha1, oe->sha1);
1919
} else if (!get_sha1(from, sha1)) {
1923
buf = read_object_with_reference(sha1,
1924
commit_type, &size, sha1);
1925
if (!buf || size < 46)
1926
die("Not a valid commit: %s", from);
1929
die("Invalid ref name or SHA1 expression: %s", from);
1930
read_next_command();
1933
if (prefixcmp(command_buf.buf, "tagger "))
1934
die("Expected tagger command, got %s", command_buf.buf);
1935
tagger = parse_ident(command_buf.buf + 7);
1937
/* tag payload/message */
1938
read_next_command();
1939
msg = cmd_data(&msglen);
1941
/* build the tag object */
1942
size_dbuf(&new_data, 67+strlen(t->name)+strlen(tagger)+msglen);
1943
sp = new_data.buffer;
1944
sp += sprintf(sp, "object %s\n", sha1_to_hex(sha1));
1945
sp += sprintf(sp, "type %s\n", commit_type);
1946
sp += sprintf(sp, "tag %s\n", t->name);
1947
sp += sprintf(sp, "tagger %s\n", tagger);
1949
memcpy(sp, msg, msglen);
1954
if (store_object(OBJ_TAG, new_data.buffer,
1955
sp - (char*)new_data.buffer,
1957
t->pack_id = MAX_PACK_ID;
1959
t->pack_id = pack_id;
1962
static void cmd_reset_branch(void)
1967
/* Obtain the branch name from the rest of our command */
1968
sp = strchr(command_buf.buf, ' ') + 1;
1969
b = lookup_branch(sp);
1972
hashclr(b->branch_tree.versions[0].sha1);
1973
hashclr(b->branch_tree.versions[1].sha1);
1974
if (b->branch_tree.tree) {
1975
release_tree_content_recursive(b->branch_tree.tree);
1976
b->branch_tree.tree = NULL;
1981
read_next_command();
1985
static void cmd_checkpoint(void)
1993
read_next_command();
1996
static void import_marks(const char *input_file)
1999
FILE *f = fopen(input_file, "r");
2001
die("cannot read %s: %s", input_file, strerror(errno));
2002
while (fgets(line, sizeof(line), f)) {
2005
unsigned char sha1[20];
2006
struct object_entry *e;
2008
end = strchr(line, '\n');
2009
if (line[0] != ':' || !end)
2010
die("corrupt mark line: %s", line);
2012
mark = strtoumax(line + 1, &end, 10);
2013
if (!mark || end == line + 1
2014
|| *end != ' ' || get_sha1(end + 1, sha1))
2015
die("corrupt mark line: %s", line);
2016
e = find_object(sha1);
2018
enum object_type type = sha1_object_info(sha1, NULL);
2020
die("object not found: %s", sha1_to_hex(sha1));
2021
e = insert_object(sha1);
2023
e->pack_id = MAX_PACK_ID;
2025
insert_mark(mark, e);
2030
static const char fast_import_usage[] =
2031
"git-fast-import [--date-format=f] [--max-pack-size=n] [--depth=n] [--active-branches=n] [--export-marks=marks.file]";
2033
int main(int argc, const char **argv)
2035
int i, show_stats = 1;
2037
git_config(git_default_config);
2038
alloc_objects(object_entry_alloc);
2039
strbuf_init(&command_buf);
2040
atom_table = xcalloc(atom_table_sz, sizeof(struct atom_str*));
2041
branch_table = xcalloc(branch_table_sz, sizeof(struct branch*));
2042
avail_tree_table = xcalloc(avail_tree_table_sz, sizeof(struct avail_tree_content*));
2043
marks = pool_calloc(1, sizeof(struct mark_set));
2045
for (i = 1; i < argc; i++) {
2046
const char *a = argv[i];
2048
if (*a != '-' || !strcmp(a, "--"))
2050
else if (!prefixcmp(a, "--date-format=")) {
2051
const char *fmt = a + 14;
2052
if (!strcmp(fmt, "raw"))
2053
whenspec = WHENSPEC_RAW;
2054
else if (!strcmp(fmt, "rfc2822"))
2055
whenspec = WHENSPEC_RFC2822;
2056
else if (!strcmp(fmt, "now"))
2057
whenspec = WHENSPEC_NOW;
2059
die("unknown --date-format argument %s", fmt);
2061
else if (!prefixcmp(a, "--max-pack-size="))
2062
max_packsize = strtoumax(a + 16, NULL, 0) * 1024 * 1024;
2063
else if (!prefixcmp(a, "--depth="))
2064
max_depth = strtoul(a + 8, NULL, 0);
2065
else if (!prefixcmp(a, "--active-branches="))
2066
max_active_branches = strtoul(a + 18, NULL, 0);
2067
else if (!prefixcmp(a, "--import-marks="))
2068
import_marks(a + 15);
2069
else if (!prefixcmp(a, "--export-marks="))
2071
else if (!prefixcmp(a, "--export-pack-edges=")) {
2074
pack_edges = fopen(a + 20, "a");
2076
die("Cannot open %s: %s", a + 20, strerror(errno));
2077
} else if (!strcmp(a, "--force"))
2079
else if (!strcmp(a, "--quiet"))
2081
else if (!strcmp(a, "--stats"))
2084
die("unknown option %s", a);
2087
usage(fast_import_usage);
2091
read_next_command();
2092
if (command_buf.eof)
2094
else if (!strcmp("blob", command_buf.buf))
2096
else if (!prefixcmp(command_buf.buf, "commit "))
2098
else if (!prefixcmp(command_buf.buf, "tag "))
2100
else if (!prefixcmp(command_buf.buf, "reset "))
2102
else if (!strcmp("checkpoint", command_buf.buf))
2105
die("Unsupported command: %s", command_buf.buf);
2118
uintmax_t total_count = 0, duplicate_count = 0;
2119
for (i = 0; i < ARRAY_SIZE(object_count_by_type); i++)
2120
total_count += object_count_by_type[i];
2121
for (i = 0; i < ARRAY_SIZE(duplicate_count_by_type); i++)
2122
duplicate_count += duplicate_count_by_type[i];
2124
fprintf(stderr, "%s statistics:\n", argv[0]);
2125
fprintf(stderr, "---------------------------------------------------------------------\n");
2126
fprintf(stderr, "Alloc'd objects: %10" PRIuMAX "\n", alloc_count);
2127
fprintf(stderr, "Total objects: %10" PRIuMAX " (%10" PRIuMAX " duplicates )\n", total_count, duplicate_count);
2128
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]);
2129
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]);
2130
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]);
2131
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]);
2132
fprintf(stderr, "Total branches: %10lu (%10lu loads )\n", branch_count, branch_load_count);
2133
fprintf(stderr, " marks: %10" PRIuMAX " (%10" PRIuMAX " unique )\n", (((uintmax_t)1) << marks->shift) * 1024, marks_set_count);
2134
fprintf(stderr, " atoms: %10u\n", atom_cnt);
2135
fprintf(stderr, "Memory total: %10" PRIuMAX " KiB\n", (total_allocd + alloc_count*sizeof(struct object_entry))/1024);
2136
fprintf(stderr, " pools: %10lu KiB\n", (unsigned long)(total_allocd/1024));
2137
fprintf(stderr, " objects: %10" PRIuMAX " KiB\n", (alloc_count*sizeof(struct object_entry))/1024);
2138
fprintf(stderr, "---------------------------------------------------------------------\n");
2140
fprintf(stderr, "---------------------------------------------------------------------\n");
2141
fprintf(stderr, "\n");
2144
return failure ? 1 : 0;