]>
git.ipfire.org Git - thirdparty/git.git/blob - fast-import.c
2 Format of STDIN stream:
14 new_blob ::= 'blob' lf
17 file_content ::= data;
19 new_commit ::= 'commit' sp ref_str lf
21 ('author' sp name '<' email '>' when lf)?
22 'committer' sp name '<' email '>' when lf
24 ('from' sp (ref_str | hexsha1 | sha1exp_str | idnum) lf)?
25 ('merge' sp (ref_str | hexsha1 | sha1exp_str | idnum) lf)*
30 file_change ::= file_clr
36 file_clr ::= 'deleteall' lf;
37 file_del ::= 'D' sp path_str lf;
38 file_rnm ::= 'R' sp path_str sp path_str lf;
39 file_cpy ::= 'C' sp path_str sp path_str lf;
40 file_obm ::= 'M' sp mode sp (hexsha1 | idnum) sp path_str lf;
41 file_inm ::= 'M' sp mode sp 'inline' sp path_str lf
44 new_tag ::= 'tag' sp tag_str lf
45 'from' sp (ref_str | hexsha1 | sha1exp_str | idnum) lf
46 'tagger' sp name '<' email '>' when lf
50 reset_branch ::= 'reset' sp ref_str lf
51 ('from' sp (ref_str | hexsha1 | sha1exp_str | idnum) lf)?
54 checkpoint ::= 'checkpoint' lf
57 progress ::= 'progress' sp not_lf* lf
60 # note: the first idnum in a stream should be 1 and subsequent
61 # idnums should not have gaps between values as this will cause
62 # the stream parser to reserve space for the gapped values. An
63 # idnum can be updated in the future to a new object by issuing
64 # a new mark directive with the old idnum.
66 mark ::= 'mark' sp idnum lf;
67 data ::= (delimited_data | exact_data)
70 # note: delim may be any string but must not contain lf.
71 # data_line may contain any data but must not be exactly
73 delimited_data ::= 'data' sp '<<' delim lf
77 # note: declen indicates the length of binary_data in bytes.
78 # declen does not include the lf preceeding the binary data.
80 exact_data ::= 'data' sp declen lf
83 # note: quoted strings are C-style quoting supporting \c for
84 # common escapes of 'c' (e..g \n, \t, \\, \") or \nnn where nnn
85 # is the signed byte value in octal. Note that the only
86 # characters which must actually be escaped to protect the
87 # stream formatting is: \, " and LF. Otherwise these values
91 sha1exp_str ::= sha1exp;
93 path_str ::= path | '"' quoted(path) '"' ;
94 mode ::= '100644' | '644'
99 declen ::= # unsigned 32 bit value, ascii base10 notation;
100 bigint ::= # unsigned integer value, ascii base10 notation;
101 binary_data ::= # file content, not interpreted;
103 when ::= raw_when | rfc2822_when;
104 raw_when ::= ts sp tz;
105 rfc2822_when ::= # Valid RFC 2822 date and time;
107 sp ::= # ASCII space character;
108 lf ::= # ASCII newline (LF) character;
110 # note: a colon (':') must precede the numerical value assigned to
111 # an idnum. This is to distinguish it from a ref or tag name as
112 # GIT does not permit ':' in ref or tag strings.
114 idnum ::= ':' bigint;
115 path ::= # GIT style file path, e.g. "a/b/c";
116 ref ::= # GIT ref name, e.g. "refs/heads/MOZ_GECKO_EXPERIMENT";
117 tag ::= # GIT tag name, e.g. "FIREFOX_1_5";
118 sha1exp ::= # Any valid GIT SHA1 expression;
119 hexsha1 ::= # SHA1 in hexadecimal format;
121 # note: name and email are UTF8 strings, however name must not
122 # contain '<' or lf and email must not contain any of the
123 # following: '<', '>', lf.
125 name ::= # valid GIT author/committer name;
126 email ::= # valid GIT author/committer email;
127 ts ::= # time since the epoch in seconds, ascii base10 notation;
128 tz ::= # GIT style timezone;
130 # note: comments may appear anywhere in the input, except
131 # within a data command. Any form of the data command
132 # always escapes the related input from comment processing.
134 # In case it is not clear, the '#' that starts the comment
135 # must be the first character on that the line (an lf have
138 comment ::= '#' not_lf* lf;
139 not_lf ::= # Any byte that is not ASCII newline (LF);
151 #include "csum-file.h"
155 #define PACK_ID_BITS 16
156 #define MAX_PACK_ID ((1<<PACK_ID_BITS)-1)
160 struct object_entry
*next
;
162 unsigned type
: TYPE_BITS
;
163 unsigned pack_id
: PACK_ID_BITS
;
164 unsigned char sha1
[20];
167 struct object_entry_pool
169 struct object_entry_pool
*next_pool
;
170 struct object_entry
*next_free
;
171 struct object_entry
*end
;
172 struct object_entry entries
[FLEX_ARRAY
]; /* more */
178 struct object_entry
*marked
[1024];
179 struct mark_set
*sets
[1024];
195 struct mem_pool
*next_pool
;
198 char space
[FLEX_ARRAY
]; /* more */
203 struct atom_str
*next_atom
;
204 unsigned short str_len
;
205 char str_dat
[FLEX_ARRAY
]; /* more */
211 struct tree_content
*tree
;
212 struct atom_str
* name
;
216 unsigned char sha1
[20];
222 unsigned int entry_capacity
; /* must match avail_tree_content */
223 unsigned int entry_count
;
224 unsigned int delta_depth
;
225 struct tree_entry
*entries
[FLEX_ARRAY
]; /* more */
228 struct avail_tree_content
230 unsigned int entry_capacity
; /* must match tree_content */
231 struct avail_tree_content
*next_avail
;
236 struct branch
*table_next_branch
;
237 struct branch
*active_next_branch
;
239 struct tree_entry branch_tree
;
240 uintmax_t last_commit
;
242 unsigned pack_id
: PACK_ID_BITS
;
243 unsigned char sha1
[20];
248 struct tag
*next_tag
;
250 unsigned int pack_id
;
251 unsigned char sha1
[20];
262 struct hash_list
*next
;
263 unsigned char sha1
[20];
272 /* Configured limits on output */
273 static unsigned long max_depth
= 10;
274 static off_t max_packsize
= (1LL << 32) - 1;
275 static int force_update
;
277 /* Stats and misc. counters */
278 static uintmax_t alloc_count
;
279 static uintmax_t marks_set_count
;
280 static uintmax_t object_count_by_type
[1 << TYPE_BITS
];
281 static uintmax_t duplicate_count_by_type
[1 << TYPE_BITS
];
282 static uintmax_t delta_count_by_type
[1 << TYPE_BITS
];
283 static unsigned long object_count
;
284 static unsigned long branch_count
;
285 static unsigned long branch_load_count
;
287 static FILE *pack_edges
;
290 static size_t mem_pool_alloc
= 2*1024*1024 - sizeof(struct mem_pool
);
291 static size_t total_allocd
;
292 static struct mem_pool
*mem_pool
;
294 /* Atom management */
295 static unsigned int atom_table_sz
= 4451;
296 static unsigned int atom_cnt
;
297 static struct atom_str
**atom_table
;
299 /* The .pack file being generated */
300 static unsigned int pack_id
;
301 static struct packed_git
*pack_data
;
302 static struct packed_git
**all_packs
;
303 static unsigned long pack_size
;
305 /* Table of objects we've written. */
306 static unsigned int object_entry_alloc
= 5000;
307 static struct object_entry_pool
*blocks
;
308 static struct object_entry
*object_table
[1 << 16];
309 static struct mark_set
*marks
;
310 static const char* mark_file
;
313 static struct last_object last_blob
;
315 /* Tree management */
316 static unsigned int tree_entry_alloc
= 1000;
317 static void *avail_tree_entry
;
318 static unsigned int avail_tree_table_sz
= 100;
319 static struct avail_tree_content
**avail_tree_table
;
320 static struct dbuf old_tree
;
321 static struct dbuf new_tree
;
324 static unsigned long max_active_branches
= 5;
325 static unsigned long cur_active_branches
;
326 static unsigned long branch_table_sz
= 1039;
327 static struct branch
**branch_table
;
328 static struct branch
*active_branches
;
331 static struct tag
*first_tag
;
332 static struct tag
*last_tag
;
334 /* Input stream parsing */
335 static whenspec_type whenspec
= WHENSPEC_RAW
;
336 static struct strbuf command_buf
;
337 static int unread_command_buf
;
338 static uintmax_t next_mark
;
339 static struct dbuf new_data
;
342 static void alloc_objects(unsigned int cnt
)
344 struct object_entry_pool
*b
;
346 b
= xmalloc(sizeof(struct object_entry_pool
)
347 + cnt
* sizeof(struct object_entry
));
348 b
->next_pool
= blocks
;
349 b
->next_free
= b
->entries
;
350 b
->end
= b
->entries
+ cnt
;
355 static struct object_entry
*new_object(unsigned char *sha1
)
357 struct object_entry
*e
;
359 if (blocks
->next_free
== blocks
->end
)
360 alloc_objects(object_entry_alloc
);
362 e
= blocks
->next_free
++;
363 hashcpy(e
->sha1
, sha1
);
367 static struct object_entry
*find_object(unsigned char *sha1
)
369 unsigned int h
= sha1
[0] << 8 | sha1
[1];
370 struct object_entry
*e
;
371 for (e
= object_table
[h
]; e
; e
= e
->next
)
372 if (!hashcmp(sha1
, e
->sha1
))
377 static struct object_entry
*insert_object(unsigned char *sha1
)
379 unsigned int h
= sha1
[0] << 8 | sha1
[1];
380 struct object_entry
*e
= object_table
[h
];
381 struct object_entry
*p
= NULL
;
384 if (!hashcmp(sha1
, e
->sha1
))
390 e
= new_object(sha1
);
400 static unsigned int hc_str(const char *s
, size_t len
)
408 static void *pool_alloc(size_t len
)
413 for (p
= mem_pool
; p
; p
= p
->next_pool
)
414 if ((p
->end
- p
->next_free
>= len
))
418 if (len
>= (mem_pool_alloc
/2)) {
422 total_allocd
+= sizeof(struct mem_pool
) + mem_pool_alloc
;
423 p
= xmalloc(sizeof(struct mem_pool
) + mem_pool_alloc
);
424 p
->next_pool
= mem_pool
;
425 p
->next_free
= p
->space
;
426 p
->end
= p
->next_free
+ mem_pool_alloc
;
431 /* round out to a pointer alignment */
432 if (len
& (sizeof(void*) - 1))
433 len
+= sizeof(void*) - (len
& (sizeof(void*) - 1));
438 static void *pool_calloc(size_t count
, size_t size
)
440 size_t len
= count
* size
;
441 void *r
= pool_alloc(len
);
446 static char *pool_strdup(const char *s
)
448 char *r
= pool_alloc(strlen(s
) + 1);
453 static void size_dbuf(struct dbuf
*b
, size_t maxlen
)
456 if (b
->capacity
>= maxlen
)
460 b
->capacity
= ((maxlen
/ 1024) + 1) * 1024;
461 b
->buffer
= xmalloc(b
->capacity
);
464 static void insert_mark(uintmax_t idnum
, struct object_entry
*oe
)
466 struct mark_set
*s
= marks
;
467 while ((idnum
>> s
->shift
) >= 1024) {
468 s
= pool_calloc(1, sizeof(struct mark_set
));
469 s
->shift
= marks
->shift
+ 10;
470 s
->data
.sets
[0] = marks
;
474 uintmax_t i
= idnum
>> s
->shift
;
475 idnum
-= i
<< s
->shift
;
476 if (!s
->data
.sets
[i
]) {
477 s
->data
.sets
[i
] = pool_calloc(1, sizeof(struct mark_set
));
478 s
->data
.sets
[i
]->shift
= s
->shift
- 10;
482 if (!s
->data
.marked
[idnum
])
484 s
->data
.marked
[idnum
] = oe
;
487 static struct object_entry
*find_mark(uintmax_t idnum
)
489 uintmax_t orig_idnum
= idnum
;
490 struct mark_set
*s
= marks
;
491 struct object_entry
*oe
= NULL
;
492 if ((idnum
>> s
->shift
) < 1024) {
493 while (s
&& s
->shift
) {
494 uintmax_t i
= idnum
>> s
->shift
;
495 idnum
-= i
<< s
->shift
;
499 oe
= s
->data
.marked
[idnum
];
502 die("mark :%" PRIuMAX
" not declared", orig_idnum
);
506 static struct atom_str
*to_atom(const char *s
, unsigned short len
)
508 unsigned int hc
= hc_str(s
, len
) % atom_table_sz
;
511 for (c
= atom_table
[hc
]; c
; c
= c
->next_atom
)
512 if (c
->str_len
== len
&& !strncmp(s
, c
->str_dat
, len
))
515 c
= pool_alloc(sizeof(struct atom_str
) + len
+ 1);
517 strncpy(c
->str_dat
, s
, len
);
519 c
->next_atom
= atom_table
[hc
];
525 static struct branch
*lookup_branch(const char *name
)
527 unsigned int hc
= hc_str(name
, strlen(name
)) % branch_table_sz
;
530 for (b
= branch_table
[hc
]; b
; b
= b
->table_next_branch
)
531 if (!strcmp(name
, b
->name
))
536 static struct branch
*new_branch(const char *name
)
538 unsigned int hc
= hc_str(name
, strlen(name
)) % branch_table_sz
;
539 struct branch
* b
= lookup_branch(name
);
542 die("Invalid attempt to create duplicate branch: %s", name
);
543 switch (check_ref_format(name
)) {
544 case 0: break; /* its valid */
545 case -2: break; /* valid, but too few '/', allow anyway */
547 die("Branch name doesn't conform to GIT standards: %s", name
);
550 b
= pool_calloc(1, sizeof(struct branch
));
551 b
->name
= pool_strdup(name
);
552 b
->table_next_branch
= branch_table
[hc
];
553 b
->branch_tree
.versions
[0].mode
= S_IFDIR
;
554 b
->branch_tree
.versions
[1].mode
= S_IFDIR
;
556 b
->pack_id
= MAX_PACK_ID
;
557 branch_table
[hc
] = b
;
562 static unsigned int hc_entries(unsigned int cnt
)
564 cnt
= cnt
& 7 ? (cnt
/ 8) + 1 : cnt
/ 8;
565 return cnt
< avail_tree_table_sz
? cnt
: avail_tree_table_sz
- 1;
568 static struct tree_content
*new_tree_content(unsigned int cnt
)
570 struct avail_tree_content
*f
, *l
= NULL
;
571 struct tree_content
*t
;
572 unsigned int hc
= hc_entries(cnt
);
574 for (f
= avail_tree_table
[hc
]; f
; l
= f
, f
= f
->next_avail
)
575 if (f
->entry_capacity
>= cnt
)
580 l
->next_avail
= f
->next_avail
;
582 avail_tree_table
[hc
] = f
->next_avail
;
584 cnt
= cnt
& 7 ? ((cnt
/ 8) + 1) * 8 : cnt
;
585 f
= pool_alloc(sizeof(*t
) + sizeof(t
->entries
[0]) * cnt
);
586 f
->entry_capacity
= cnt
;
589 t
= (struct tree_content
*)f
;
595 static void release_tree_entry(struct tree_entry
*e
);
596 static void release_tree_content(struct tree_content
*t
)
598 struct avail_tree_content
*f
= (struct avail_tree_content
*)t
;
599 unsigned int hc
= hc_entries(f
->entry_capacity
);
600 f
->next_avail
= avail_tree_table
[hc
];
601 avail_tree_table
[hc
] = f
;
604 static void release_tree_content_recursive(struct tree_content
*t
)
607 for (i
= 0; i
< t
->entry_count
; i
++)
608 release_tree_entry(t
->entries
[i
]);
609 release_tree_content(t
);
612 static struct tree_content
*grow_tree_content(
613 struct tree_content
*t
,
616 struct tree_content
*r
= new_tree_content(t
->entry_count
+ amt
);
617 r
->entry_count
= t
->entry_count
;
618 r
->delta_depth
= t
->delta_depth
;
619 memcpy(r
->entries
,t
->entries
,t
->entry_count
*sizeof(t
->entries
[0]));
620 release_tree_content(t
);
624 static struct tree_entry
*new_tree_entry(void)
626 struct tree_entry
*e
;
628 if (!avail_tree_entry
) {
629 unsigned int n
= tree_entry_alloc
;
630 total_allocd
+= n
* sizeof(struct tree_entry
);
631 avail_tree_entry
= e
= xmalloc(n
* sizeof(struct tree_entry
));
633 *((void**)e
) = e
+ 1;
639 e
= avail_tree_entry
;
640 avail_tree_entry
= *((void**)e
);
644 static void release_tree_entry(struct tree_entry
*e
)
647 release_tree_content_recursive(e
->tree
);
648 *((void**)e
) = avail_tree_entry
;
649 avail_tree_entry
= e
;
652 static struct tree_content
*dup_tree_content(struct tree_content
*s
)
654 struct tree_content
*d
;
655 struct tree_entry
*a
, *b
;
660 d
= new_tree_content(s
->entry_count
);
661 for (i
= 0; i
< s
->entry_count
; i
++) {
663 b
= new_tree_entry();
664 memcpy(b
, a
, sizeof(*a
));
665 if (a
->tree
&& is_null_sha1(b
->versions
[1].sha1
))
666 b
->tree
= dup_tree_content(a
->tree
);
671 d
->entry_count
= s
->entry_count
;
672 d
->delta_depth
= s
->delta_depth
;
677 static void start_packfile(void)
679 static char tmpfile
[PATH_MAX
];
680 struct packed_git
*p
;
681 struct pack_header hdr
;
684 snprintf(tmpfile
, sizeof(tmpfile
),
685 "%s/tmp_pack_XXXXXX", get_object_directory());
686 pack_fd
= xmkstemp(tmpfile
);
687 p
= xcalloc(1, sizeof(*p
) + strlen(tmpfile
) + 2);
688 strcpy(p
->pack_name
, tmpfile
);
689 p
->pack_fd
= pack_fd
;
691 hdr
.hdr_signature
= htonl(PACK_SIGNATURE
);
692 hdr
.hdr_version
= htonl(2);
694 write_or_die(p
->pack_fd
, &hdr
, sizeof(hdr
));
697 pack_size
= sizeof(hdr
);
700 all_packs
= xrealloc(all_packs
, sizeof(*all_packs
) * (pack_id
+ 1));
701 all_packs
[pack_id
] = p
;
704 static int oecmp (const void *a_
, const void *b_
)
706 struct object_entry
*a
= *((struct object_entry
**)a_
);
707 struct object_entry
*b
= *((struct object_entry
**)b_
);
708 return hashcmp(a
->sha1
, b
->sha1
);
711 static char *create_index(void)
713 static char tmpfile
[PATH_MAX
];
716 struct object_entry
**idx
, **c
, **last
, *e
;
717 struct object_entry_pool
*o
;
721 /* Build the sorted table of object IDs. */
722 idx
= xmalloc(object_count
* sizeof(struct object_entry
*));
724 for (o
= blocks
; o
; o
= o
->next_pool
)
725 for (e
= o
->next_free
; e
-- != o
->entries
;)
726 if (pack_id
== e
->pack_id
)
728 last
= idx
+ object_count
;
730 die("internal consistency error creating the index");
731 qsort(idx
, object_count
, sizeof(struct object_entry
*), oecmp
);
733 /* Generate the fan-out array. */
735 for (i
= 0; i
< 256; i
++) {
736 struct object_entry
**next
= c
;;
737 while (next
< last
) {
738 if ((*next
)->sha1
[0] != i
)
742 array
[i
] = htonl(next
- idx
);
746 snprintf(tmpfile
, sizeof(tmpfile
),
747 "%s/tmp_idx_XXXXXX", get_object_directory());
748 idx_fd
= xmkstemp(tmpfile
);
749 f
= sha1fd(idx_fd
, tmpfile
);
750 sha1write(f
, array
, 256 * sizeof(int));
752 for (c
= idx
; c
!= last
; c
++) {
753 uint32_t offset
= htonl((*c
)->offset
);
754 sha1write(f
, &offset
, 4);
755 sha1write(f
, (*c
)->sha1
, sizeof((*c
)->sha1
));
756 SHA1_Update(&ctx
, (*c
)->sha1
, 20);
758 sha1write(f
, pack_data
->sha1
, sizeof(pack_data
->sha1
));
759 sha1close(f
, NULL
, 1);
761 SHA1_Final(pack_data
->sha1
, &ctx
);
765 static char *keep_pack(char *curr_index_name
)
767 static char name
[PATH_MAX
];
768 static const char *keep_msg
= "fast-import";
771 chmod(pack_data
->pack_name
, 0444);
772 chmod(curr_index_name
, 0444);
774 snprintf(name
, sizeof(name
), "%s/pack/pack-%s.keep",
775 get_object_directory(), sha1_to_hex(pack_data
->sha1
));
776 keep_fd
= open(name
, O_RDWR
|O_CREAT
|O_EXCL
, 0600);
778 die("cannot create keep file");
779 write(keep_fd
, keep_msg
, strlen(keep_msg
));
782 snprintf(name
, sizeof(name
), "%s/pack/pack-%s.pack",
783 get_object_directory(), sha1_to_hex(pack_data
->sha1
));
784 if (move_temp_to_file(pack_data
->pack_name
, name
))
785 die("cannot store pack file");
787 snprintf(name
, sizeof(name
), "%s/pack/pack-%s.idx",
788 get_object_directory(), sha1_to_hex(pack_data
->sha1
));
789 if (move_temp_to_file(curr_index_name
, name
))
790 die("cannot store index file");
794 static void unkeep_all_packs(void)
796 static char name
[PATH_MAX
];
799 for (k
= 0; k
< pack_id
; k
++) {
800 struct packed_git
*p
= all_packs
[k
];
801 snprintf(name
, sizeof(name
), "%s/pack/pack-%s.keep",
802 get_object_directory(), sha1_to_hex(p
->sha1
));
807 static void end_packfile(void)
809 struct packed_git
*old_p
= pack_data
, *new_p
;
817 fixup_pack_header_footer(pack_data
->pack_fd
, pack_data
->sha1
,
818 pack_data
->pack_name
, object_count
);
819 close(pack_data
->pack_fd
);
820 idx_name
= keep_pack(create_index());
822 /* Register the packfile with core git's machinary. */
823 new_p
= add_packed_git(idx_name
, strlen(idx_name
), 1);
825 die("core git rejected index %s", idx_name
);
826 new_p
->windows
= old_p
->windows
;
827 all_packs
[pack_id
] = new_p
;
828 install_packed_git(new_p
);
830 /* Print the boundary */
832 fprintf(pack_edges
, "%s:", new_p
->pack_name
);
833 for (i
= 0; i
< branch_table_sz
; i
++) {
834 for (b
= branch_table
[i
]; b
; b
= b
->table_next_branch
) {
835 if (b
->pack_id
== pack_id
)
836 fprintf(pack_edges
, " %s", sha1_to_hex(b
->sha1
));
839 for (t
= first_tag
; t
; t
= t
->next_tag
) {
840 if (t
->pack_id
== pack_id
)
841 fprintf(pack_edges
, " %s", sha1_to_hex(t
->sha1
));
843 fputc('\n', pack_edges
);
850 unlink(old_p
->pack_name
);
853 /* We can't carry a delta across packfiles. */
854 free(last_blob
.data
);
855 last_blob
.data
= NULL
;
857 last_blob
.offset
= 0;
861 static void cycle_packfile(void)
867 static size_t encode_header(
868 enum object_type type
,
875 if (type
< OBJ_COMMIT
|| type
> OBJ_REF_DELTA
)
876 die("bad type %d", type
);
878 c
= (type
<< 4) | (size
& 15);
890 static int store_object(
891 enum object_type type
,
894 struct last_object
*last
,
895 unsigned char *sha1out
,
899 struct object_entry
*e
;
900 unsigned char hdr
[96];
901 unsigned char sha1
[20];
902 unsigned long hdrlen
, deltalen
;
906 hdrlen
= sprintf((char*)hdr
,"%s %lu", typename(type
),
907 (unsigned long)datlen
) + 1;
909 SHA1_Update(&c
, hdr
, hdrlen
);
910 SHA1_Update(&c
, dat
, datlen
);
911 SHA1_Final(sha1
, &c
);
913 hashcpy(sha1out
, sha1
);
915 e
= insert_object(sha1
);
917 insert_mark(mark
, e
);
919 duplicate_count_by_type
[type
]++;
921 } else if (find_sha1_pack(sha1
, packed_git
)) {
923 e
->pack_id
= MAX_PACK_ID
;
924 e
->offset
= 1; /* just not zero! */
925 duplicate_count_by_type
[type
]++;
929 if (last
&& last
->data
&& last
->depth
< max_depth
) {
930 delta
= diff_delta(last
->data
, last
->len
,
933 if (delta
&& deltalen
>= datlen
) {
940 memset(&s
, 0, sizeof(s
));
941 deflateInit(&s
, zlib_compression_level
);
944 s
.avail_in
= deltalen
;
949 s
.avail_out
= deflateBound(&s
, s
.avail_in
);
950 s
.next_out
= out
= xmalloc(s
.avail_out
);
951 while (deflate(&s
, Z_FINISH
) == Z_OK
)
955 /* Determine if we should auto-checkpoint. */
956 if ((pack_size
+ 60 + s
.total_out
) > max_packsize
957 || (pack_size
+ 60 + s
.total_out
) < pack_size
) {
959 /* This new object needs to *not* have the current pack_id. */
960 e
->pack_id
= pack_id
+ 1;
963 /* We cannot carry a delta into the new pack. */
968 memset(&s
, 0, sizeof(s
));
969 deflateInit(&s
, zlib_compression_level
);
972 s
.avail_out
= deflateBound(&s
, s
.avail_in
);
973 s
.next_out
= out
= xrealloc(out
, s
.avail_out
);
974 while (deflate(&s
, Z_FINISH
) == Z_OK
)
981 e
->pack_id
= pack_id
;
982 e
->offset
= pack_size
;
984 object_count_by_type
[type
]++;
987 unsigned long ofs
= e
->offset
- last
->offset
;
988 unsigned pos
= sizeof(hdr
) - 1;
990 delta_count_by_type
[type
]++;
993 hdrlen
= encode_header(OBJ_OFS_DELTA
, deltalen
, hdr
);
994 write_or_die(pack_data
->pack_fd
, hdr
, hdrlen
);
997 hdr
[pos
] = ofs
& 127;
999 hdr
[--pos
] = 128 | (--ofs
& 127);
1000 write_or_die(pack_data
->pack_fd
, hdr
+ pos
, sizeof(hdr
) - pos
);
1001 pack_size
+= sizeof(hdr
) - pos
;
1005 hdrlen
= encode_header(type
, datlen
, hdr
);
1006 write_or_die(pack_data
->pack_fd
, hdr
, hdrlen
);
1007 pack_size
+= hdrlen
;
1010 write_or_die(pack_data
->pack_fd
, out
, s
.total_out
);
1011 pack_size
+= s
.total_out
;
1019 last
->offset
= e
->offset
;
1025 static void *gfi_unpack_entry(
1026 struct object_entry
*oe
,
1027 unsigned long *sizep
)
1029 enum object_type type
;
1030 struct packed_git
*p
= all_packs
[oe
->pack_id
];
1032 p
->pack_size
= pack_size
+ 20;
1033 return unpack_entry(p
, oe
->offset
, &type
, sizep
);
1036 static const char *get_mode(const char *str
, uint16_t *modep
)
1041 while ((c
= *str
++) != ' ') {
1042 if (c
< '0' || c
> '7')
1044 mode
= (mode
<< 3) + (c
- '0');
1050 static void load_tree(struct tree_entry
*root
)
1052 unsigned char* sha1
= root
->versions
[1].sha1
;
1053 struct object_entry
*myoe
;
1054 struct tree_content
*t
;
1059 root
->tree
= t
= new_tree_content(8);
1060 if (is_null_sha1(sha1
))
1063 myoe
= find_object(sha1
);
1064 if (myoe
&& myoe
->pack_id
!= MAX_PACK_ID
) {
1065 if (myoe
->type
!= OBJ_TREE
)
1066 die("Not a tree: %s", sha1_to_hex(sha1
));
1068 buf
= gfi_unpack_entry(myoe
, &size
);
1070 enum object_type type
;
1071 buf
= read_sha1_file(sha1
, &type
, &size
);
1072 if (!buf
|| type
!= OBJ_TREE
)
1073 die("Can't load tree %s", sha1_to_hex(sha1
));
1077 while (c
!= (buf
+ size
)) {
1078 struct tree_entry
*e
= new_tree_entry();
1080 if (t
->entry_count
== t
->entry_capacity
)
1081 root
->tree
= t
= grow_tree_content(t
, t
->entry_count
);
1082 t
->entries
[t
->entry_count
++] = e
;
1085 c
= get_mode(c
, &e
->versions
[1].mode
);
1087 die("Corrupt mode in %s", sha1_to_hex(sha1
));
1088 e
->versions
[0].mode
= e
->versions
[1].mode
;
1089 e
->name
= to_atom(c
, strlen(c
));
1090 c
+= e
->name
->str_len
+ 1;
1091 hashcpy(e
->versions
[0].sha1
, (unsigned char*)c
);
1092 hashcpy(e
->versions
[1].sha1
, (unsigned char*)c
);
1098 static int tecmp0 (const void *_a
, const void *_b
)
1100 struct tree_entry
*a
= *((struct tree_entry
**)_a
);
1101 struct tree_entry
*b
= *((struct tree_entry
**)_b
);
1102 return base_name_compare(
1103 a
->name
->str_dat
, a
->name
->str_len
, a
->versions
[0].mode
,
1104 b
->name
->str_dat
, b
->name
->str_len
, b
->versions
[0].mode
);
1107 static int tecmp1 (const void *_a
, const void *_b
)
1109 struct tree_entry
*a
= *((struct tree_entry
**)_a
);
1110 struct tree_entry
*b
= *((struct tree_entry
**)_b
);
1111 return base_name_compare(
1112 a
->name
->str_dat
, a
->name
->str_len
, a
->versions
[1].mode
,
1113 b
->name
->str_dat
, b
->name
->str_len
, b
->versions
[1].mode
);
1116 static void mktree(struct tree_content
*t
,
1126 qsort(t
->entries
,t
->entry_count
,sizeof(t
->entries
[0]),tecmp0
);
1128 qsort(t
->entries
,t
->entry_count
,sizeof(t
->entries
[0]),tecmp1
);
1130 for (i
= 0; i
< t
->entry_count
; i
++) {
1131 if (t
->entries
[i
]->versions
[v
].mode
)
1132 maxlen
+= t
->entries
[i
]->name
->str_len
+ 34;
1135 size_dbuf(b
, maxlen
);
1137 for (i
= 0; i
< t
->entry_count
; i
++) {
1138 struct tree_entry
*e
= t
->entries
[i
];
1139 if (!e
->versions
[v
].mode
)
1141 c
+= sprintf(c
, "%o", (unsigned int)e
->versions
[v
].mode
);
1143 strcpy(c
, e
->name
->str_dat
);
1144 c
+= e
->name
->str_len
+ 1;
1145 hashcpy((unsigned char*)c
, e
->versions
[v
].sha1
);
1148 *szp
= c
- (char*)b
->buffer
;
1151 static void store_tree(struct tree_entry
*root
)
1153 struct tree_content
*t
= root
->tree
;
1154 unsigned int i
, j
, del
;
1155 unsigned long new_len
;
1156 struct last_object lo
;
1157 struct object_entry
*le
;
1159 if (!is_null_sha1(root
->versions
[1].sha1
))
1162 for (i
= 0; i
< t
->entry_count
; i
++) {
1163 if (t
->entries
[i
]->tree
)
1164 store_tree(t
->entries
[i
]);
1167 le
= find_object(root
->versions
[0].sha1
);
1168 if (!S_ISDIR(root
->versions
[0].mode
)
1170 || le
->pack_id
!= pack_id
) {
1175 mktree(t
, 0, &lo
.len
, &old_tree
);
1176 lo
.data
= old_tree
.buffer
;
1177 lo
.offset
= le
->offset
;
1178 lo
.depth
= t
->delta_depth
;
1182 mktree(t
, 1, &new_len
, &new_tree
);
1183 store_object(OBJ_TREE
, new_tree
.buffer
, new_len
,
1184 &lo
, root
->versions
[1].sha1
, 0);
1186 t
->delta_depth
= lo
.depth
;
1187 for (i
= 0, j
= 0, del
= 0; i
< t
->entry_count
; i
++) {
1188 struct tree_entry
*e
= t
->entries
[i
];
1189 if (e
->versions
[1].mode
) {
1190 e
->versions
[0].mode
= e
->versions
[1].mode
;
1191 hashcpy(e
->versions
[0].sha1
, e
->versions
[1].sha1
);
1192 t
->entries
[j
++] = e
;
1194 release_tree_entry(e
);
1198 t
->entry_count
-= del
;
1201 static int tree_content_set(
1202 struct tree_entry
*root
,
1204 const unsigned char *sha1
,
1205 const uint16_t mode
,
1206 struct tree_content
*subtree
)
1208 struct tree_content
*t
= root
->tree
;
1211 struct tree_entry
*e
;
1213 slash1
= strchr(p
, '/');
1219 die("Empty path component found in input");
1220 if (!slash1
&& !S_ISDIR(mode
) && subtree
)
1221 die("Non-directories cannot have subtrees");
1223 for (i
= 0; i
< t
->entry_count
; i
++) {
1225 if (e
->name
->str_len
== n
&& !strncmp(p
, e
->name
->str_dat
, n
)) {
1228 && e
->versions
[1].mode
== mode
1229 && !hashcmp(e
->versions
[1].sha1
, sha1
))
1231 e
->versions
[1].mode
= mode
;
1232 hashcpy(e
->versions
[1].sha1
, sha1
);
1234 release_tree_content_recursive(e
->tree
);
1236 hashclr(root
->versions
[1].sha1
);
1239 if (!S_ISDIR(e
->versions
[1].mode
)) {
1240 e
->tree
= new_tree_content(8);
1241 e
->versions
[1].mode
= S_IFDIR
;
1245 if (tree_content_set(e
, slash1
+ 1, sha1
, mode
, subtree
)) {
1246 hashclr(root
->versions
[1].sha1
);
1253 if (t
->entry_count
== t
->entry_capacity
)
1254 root
->tree
= t
= grow_tree_content(t
, t
->entry_count
);
1255 e
= new_tree_entry();
1256 e
->name
= to_atom(p
, n
);
1257 e
->versions
[0].mode
= 0;
1258 hashclr(e
->versions
[0].sha1
);
1259 t
->entries
[t
->entry_count
++] = e
;
1261 e
->tree
= new_tree_content(8);
1262 e
->versions
[1].mode
= S_IFDIR
;
1263 tree_content_set(e
, slash1
+ 1, sha1
, mode
, subtree
);
1266 e
->versions
[1].mode
= mode
;
1267 hashcpy(e
->versions
[1].sha1
, sha1
);
1269 hashclr(root
->versions
[1].sha1
);
1273 static int tree_content_remove(
1274 struct tree_entry
*root
,
1276 struct tree_entry
*backup_leaf
)
1278 struct tree_content
*t
= root
->tree
;
1281 struct tree_entry
*e
;
1283 slash1
= strchr(p
, '/');
1289 for (i
= 0; i
< t
->entry_count
; i
++) {
1291 if (e
->name
->str_len
== n
&& !strncmp(p
, e
->name
->str_dat
, n
)) {
1292 if (!slash1
|| !S_ISDIR(e
->versions
[1].mode
))
1296 if (tree_content_remove(e
, slash1
+ 1, backup_leaf
)) {
1297 for (n
= 0; n
< e
->tree
->entry_count
; n
++) {
1298 if (e
->tree
->entries
[n
]->versions
[1].mode
) {
1299 hashclr(root
->versions
[1].sha1
);
1313 memcpy(backup_leaf
, e
, sizeof(*backup_leaf
));
1315 release_tree_content_recursive(e
->tree
);
1317 e
->versions
[1].mode
= 0;
1318 hashclr(e
->versions
[1].sha1
);
1319 hashclr(root
->versions
[1].sha1
);
1323 static int tree_content_get(
1324 struct tree_entry
*root
,
1326 struct tree_entry
*leaf
)
1328 struct tree_content
*t
= root
->tree
;
1331 struct tree_entry
*e
;
1333 slash1
= strchr(p
, '/');
1339 for (i
= 0; i
< t
->entry_count
; i
++) {
1341 if (e
->name
->str_len
== n
&& !strncmp(p
, e
->name
->str_dat
, n
)) {
1343 memcpy(leaf
, e
, sizeof(*leaf
));
1344 if (e
->tree
&& is_null_sha1(e
->versions
[1].sha1
))
1345 leaf
->tree
= dup_tree_content(e
->tree
);
1350 if (!S_ISDIR(e
->versions
[1].mode
))
1354 return tree_content_get(e
, slash1
+ 1, leaf
);
1360 static int update_branch(struct branch
*b
)
1362 static const char *msg
= "fast-import";
1363 struct ref_lock
*lock
;
1364 unsigned char old_sha1
[20];
1366 if (read_ref(b
->name
, old_sha1
))
1368 lock
= lock_any_ref_for_update(b
->name
, old_sha1
, 0);
1370 return error("Unable to lock %s", b
->name
);
1371 if (!force_update
&& !is_null_sha1(old_sha1
)) {
1372 struct commit
*old_cmit
, *new_cmit
;
1374 old_cmit
= lookup_commit_reference_gently(old_sha1
, 0);
1375 new_cmit
= lookup_commit_reference_gently(b
->sha1
, 0);
1376 if (!old_cmit
|| !new_cmit
) {
1378 return error("Branch %s is missing commits.", b
->name
);
1381 if (!in_merge_bases(old_cmit
, &new_cmit
, 1)) {
1383 warning("Not updating %s"
1384 " (new tip %s does not contain %s)",
1385 b
->name
, sha1_to_hex(b
->sha1
), sha1_to_hex(old_sha1
));
1389 if (write_ref_sha1(lock
, b
->sha1
, msg
) < 0)
1390 return error("Unable to update %s", b
->name
);
1394 static void dump_branches(void)
1399 for (i
= 0; i
< branch_table_sz
; i
++) {
1400 for (b
= branch_table
[i
]; b
; b
= b
->table_next_branch
)
1401 failure
|= update_branch(b
);
1405 static void dump_tags(void)
1407 static const char *msg
= "fast-import";
1409 struct ref_lock
*lock
;
1410 char ref_name
[PATH_MAX
];
1412 for (t
= first_tag
; t
; t
= t
->next_tag
) {
1413 sprintf(ref_name
, "tags/%s", t
->name
);
1414 lock
= lock_ref_sha1(ref_name
, NULL
);
1415 if (!lock
|| write_ref_sha1(lock
, t
->sha1
, msg
) < 0)
1416 failure
|= error("Unable to update %s", ref_name
);
1420 static void dump_marks_helper(FILE *f
,
1426 for (k
= 0; k
< 1024; k
++) {
1427 if (m
->data
.sets
[k
])
1428 dump_marks_helper(f
, (base
+ k
) << m
->shift
,
1432 for (k
= 0; k
< 1024; k
++) {
1433 if (m
->data
.marked
[k
])
1434 fprintf(f
, ":%" PRIuMAX
" %s\n", base
+ k
,
1435 sha1_to_hex(m
->data
.marked
[k
]->sha1
));
1440 static void dump_marks(void)
1442 static struct lock_file mark_lock
;
1449 mark_fd
= hold_lock_file_for_update(&mark_lock
, mark_file
, 0);
1451 failure
|= error("Unable to write marks file %s: %s",
1452 mark_file
, strerror(errno
));
1456 f
= fdopen(mark_fd
, "w");
1458 rollback_lock_file(&mark_lock
);
1459 failure
|= error("Unable to write marks file %s: %s",
1460 mark_file
, strerror(errno
));
1464 dump_marks_helper(f
, 0, marks
);
1466 if (commit_lock_file(&mark_lock
))
1467 failure
|= error("Unable to write marks file %s: %s",
1468 mark_file
, strerror(errno
));
1471 static void read_next_command(void)
1474 if (unread_command_buf
)
1475 unread_command_buf
= 0;
1477 read_line(&command_buf
, stdin
, '\n');
1478 } while (!command_buf
.eof
&& command_buf
.buf
[0] == '#');
1481 static void skip_optional_lf()
1483 int term_char
= fgetc(stdin
);
1484 if (term_char
!= '\n' && term_char
!= EOF
)
1485 ungetc(term_char
, stdin
);
1488 static void cmd_mark(void)
1490 if (!prefixcmp(command_buf
.buf
, "mark :")) {
1491 next_mark
= strtoumax(command_buf
.buf
+ 6, NULL
, 10);
1492 read_next_command();
1498 static void *cmd_data (size_t *size
)
1503 if (prefixcmp(command_buf
.buf
, "data "))
1504 die("Expected 'data n' command, found: %s", command_buf
.buf
);
1506 if (!prefixcmp(command_buf
.buf
+ 5, "<<")) {
1507 char *term
= xstrdup(command_buf
.buf
+ 5 + 2);
1508 size_t sz
= 8192, term_len
= command_buf
.len
- 5 - 2;
1510 buffer
= xmalloc(sz
);
1512 read_line(&command_buf
, stdin
, '\n');
1513 if (command_buf
.eof
)
1514 die("EOF in data (terminator '%s' not found)", term
);
1515 if (term_len
== command_buf
.len
1516 && !strcmp(term
, command_buf
.buf
))
1518 ALLOC_GROW(buffer
, length
+ command_buf
.len
, sz
);
1519 memcpy(buffer
+ length
,
1521 command_buf
.len
- 1);
1522 length
+= command_buf
.len
- 1;
1523 buffer
[length
++] = '\n';
1529 length
= strtoul(command_buf
.buf
+ 5, NULL
, 10);
1530 buffer
= xmalloc(length
);
1531 while (n
< length
) {
1532 size_t s
= fread(buffer
+ n
, 1, length
- n
, stdin
);
1533 if (!s
&& feof(stdin
))
1534 die("EOF in data (%lu bytes remaining)",
1535 (unsigned long)(length
- n
));
1545 static int validate_raw_date(const char *src
, char *result
, int maxlen
)
1547 const char *orig_src
= src
;
1550 strtoul(src
, &endp
, 10);
1551 if (endp
== src
|| *endp
!= ' ')
1555 if (*src
!= '-' && *src
!= '+')
1559 strtoul(src
+ 1, &endp
, 10);
1560 if (endp
== src
|| *endp
|| (endp
- orig_src
) >= maxlen
)
1563 strcpy(result
, orig_src
);
1567 static char *parse_ident(const char *buf
)
1573 gt
= strrchr(buf
, '>');
1575 die("Missing > in ident string: %s", buf
);
1578 die("Missing space after > in ident string: %s", buf
);
1580 name_len
= gt
- buf
;
1581 ident
= xmalloc(name_len
+ 24);
1582 strncpy(ident
, buf
, name_len
);
1586 if (validate_raw_date(gt
, ident
+ name_len
, 24) < 0)
1587 die("Invalid raw date \"%s\" in ident: %s", gt
, buf
);
1589 case WHENSPEC_RFC2822
:
1590 if (parse_date(gt
, ident
+ name_len
, 24) < 0)
1591 die("Invalid rfc2822 date \"%s\" in ident: %s", gt
, buf
);
1594 if (strcmp("now", gt
))
1595 die("Date in ident must be 'now': %s", buf
);
1596 datestamp(ident
+ name_len
, 24);
1603 static void cmd_new_blob(void)
1608 read_next_command();
1612 if (store_object(OBJ_BLOB
, d
, l
, &last_blob
, NULL
, next_mark
))
1616 static void unload_one_branch(void)
1618 while (cur_active_branches
1619 && cur_active_branches
>= max_active_branches
) {
1620 uintmax_t min_commit
= ULONG_MAX
;
1621 struct branch
*e
, *l
= NULL
, *p
= NULL
;
1623 for (e
= active_branches
; e
; e
= e
->active_next_branch
) {
1624 if (e
->last_commit
< min_commit
) {
1626 min_commit
= e
->last_commit
;
1632 e
= p
->active_next_branch
;
1633 p
->active_next_branch
= e
->active_next_branch
;
1635 e
= active_branches
;
1636 active_branches
= e
->active_next_branch
;
1639 e
->active_next_branch
= NULL
;
1640 if (e
->branch_tree
.tree
) {
1641 release_tree_content_recursive(e
->branch_tree
.tree
);
1642 e
->branch_tree
.tree
= NULL
;
1644 cur_active_branches
--;
1648 static void load_branch(struct branch
*b
)
1650 load_tree(&b
->branch_tree
);
1653 b
->active_next_branch
= active_branches
;
1654 active_branches
= b
;
1655 cur_active_branches
++;
1656 branch_load_count
++;
1660 static void file_change_m(struct branch
*b
)
1662 const char *p
= command_buf
.buf
+ 2;
1665 struct object_entry
*oe
= oe
;
1666 unsigned char sha1
[20];
1667 uint16_t mode
, inline_data
= 0;
1669 p
= get_mode(p
, &mode
);
1671 die("Corrupt mode: %s", command_buf
.buf
);
1673 case S_IFREG
| 0644:
1674 case S_IFREG
| 0755:
1681 die("Corrupt mode: %s", command_buf
.buf
);
1686 oe
= find_mark(strtoumax(p
+ 1, &x
, 10));
1687 hashcpy(sha1
, oe
->sha1
);
1689 } else if (!prefixcmp(p
, "inline")) {
1693 if (get_sha1_hex(p
, sha1
))
1694 die("Invalid SHA1: %s", command_buf
.buf
);
1695 oe
= find_object(sha1
);
1699 die("Missing space after SHA1: %s", command_buf
.buf
);
1701 p_uq
= unquote_c_style(p
, &endp
);
1704 die("Garbage after path in: %s", command_buf
.buf
);
1712 p
= p_uq
= xstrdup(p
);
1713 read_next_command();
1715 if (store_object(OBJ_BLOB
, d
, l
, &last_blob
, sha1
, 0))
1718 if (oe
->type
!= OBJ_BLOB
)
1719 die("Not a blob (actually a %s): %s",
1720 command_buf
.buf
, typename(oe
->type
));
1722 enum object_type type
= sha1_object_info(sha1
, NULL
);
1724 die("Blob not found: %s", command_buf
.buf
);
1725 if (type
!= OBJ_BLOB
)
1726 die("Not a blob (actually a %s): %s",
1727 typename(type
), command_buf
.buf
);
1730 tree_content_set(&b
->branch_tree
, p
, sha1
, S_IFREG
| mode
, NULL
);
1734 static void file_change_d(struct branch
*b
)
1736 const char *p
= command_buf
.buf
+ 2;
1740 p_uq
= unquote_c_style(p
, &endp
);
1743 die("Garbage after path in: %s", command_buf
.buf
);
1746 tree_content_remove(&b
->branch_tree
, p
, NULL
);
1750 static void file_change_cr(struct branch
*b
, int rename
)
1755 struct tree_entry leaf
;
1757 s
= command_buf
.buf
+ 2;
1758 s_uq
= unquote_c_style(s
, &endp
);
1761 die("Missing space after source: %s", command_buf
.buf
);
1764 endp
= strchr(s
, ' ');
1766 die("Missing space after source: %s", command_buf
.buf
);
1767 s_uq
= xmalloc(endp
- s
+ 1);
1768 memcpy(s_uq
, s
, endp
- s
);
1775 die("Missing dest: %s", command_buf
.buf
);
1778 d_uq
= unquote_c_style(d
, &endp
);
1781 die("Garbage after dest in: %s", command_buf
.buf
);
1785 memset(&leaf
, 0, sizeof(leaf
));
1787 tree_content_remove(&b
->branch_tree
, s
, &leaf
);
1789 tree_content_get(&b
->branch_tree
, s
, &leaf
);
1790 if (!leaf
.versions
[1].mode
)
1791 die("Path %s not in branch", s
);
1792 tree_content_set(&b
->branch_tree
, d
,
1793 leaf
.versions
[1].sha1
,
1794 leaf
.versions
[1].mode
,
1801 static void file_change_deleteall(struct branch
*b
)
1803 release_tree_content_recursive(b
->branch_tree
.tree
);
1804 hashclr(b
->branch_tree
.versions
[0].sha1
);
1805 hashclr(b
->branch_tree
.versions
[1].sha1
);
1806 load_tree(&b
->branch_tree
);
1809 static void cmd_from_commit(struct branch
*b
, char *buf
, unsigned long size
)
1811 if (!buf
|| size
< 46)
1812 die("Not a valid commit: %s", sha1_to_hex(b
->sha1
));
1813 if (memcmp("tree ", buf
, 5)
1814 || get_sha1_hex(buf
+ 5, b
->branch_tree
.versions
[1].sha1
))
1815 die("The commit %s is corrupt", sha1_to_hex(b
->sha1
));
1816 hashcpy(b
->branch_tree
.versions
[0].sha1
,
1817 b
->branch_tree
.versions
[1].sha1
);
1820 static void cmd_from_existing(struct branch
*b
)
1822 if (is_null_sha1(b
->sha1
)) {
1823 hashclr(b
->branch_tree
.versions
[0].sha1
);
1824 hashclr(b
->branch_tree
.versions
[1].sha1
);
1829 buf
= read_object_with_reference(b
->sha1
,
1830 commit_type
, &size
, b
->sha1
);
1831 cmd_from_commit(b
, buf
, size
);
1836 static int cmd_from(struct branch
*b
)
1841 if (prefixcmp(command_buf
.buf
, "from "))
1844 if (b
->branch_tree
.tree
) {
1845 release_tree_content_recursive(b
->branch_tree
.tree
);
1846 b
->branch_tree
.tree
= NULL
;
1849 from
= strchr(command_buf
.buf
, ' ') + 1;
1850 s
= lookup_branch(from
);
1852 die("Can't create a branch from itself: %s", b
->name
);
1854 unsigned char *t
= s
->branch_tree
.versions
[1].sha1
;
1855 hashcpy(b
->sha1
, s
->sha1
);
1856 hashcpy(b
->branch_tree
.versions
[0].sha1
, t
);
1857 hashcpy(b
->branch_tree
.versions
[1].sha1
, t
);
1858 } else if (*from
== ':') {
1859 uintmax_t idnum
= strtoumax(from
+ 1, NULL
, 10);
1860 struct object_entry
*oe
= find_mark(idnum
);
1861 if (oe
->type
!= OBJ_COMMIT
)
1862 die("Mark :%" PRIuMAX
" not a commit", idnum
);
1863 hashcpy(b
->sha1
, oe
->sha1
);
1864 if (oe
->pack_id
!= MAX_PACK_ID
) {
1866 char *buf
= gfi_unpack_entry(oe
, &size
);
1867 cmd_from_commit(b
, buf
, size
);
1870 cmd_from_existing(b
);
1871 } else if (!get_sha1(from
, b
->sha1
))
1872 cmd_from_existing(b
);
1874 die("Invalid ref name or SHA1 expression: %s", from
);
1876 read_next_command();
1880 static struct hash_list
*cmd_merge(unsigned int *count
)
1882 struct hash_list
*list
= NULL
, *n
, *e
= e
;
1887 while (!prefixcmp(command_buf
.buf
, "merge ")) {
1888 from
= strchr(command_buf
.buf
, ' ') + 1;
1889 n
= xmalloc(sizeof(*n
));
1890 s
= lookup_branch(from
);
1892 hashcpy(n
->sha1
, s
->sha1
);
1893 else if (*from
== ':') {
1894 uintmax_t idnum
= strtoumax(from
+ 1, NULL
, 10);
1895 struct object_entry
*oe
= find_mark(idnum
);
1896 if (oe
->type
!= OBJ_COMMIT
)
1897 die("Mark :%" PRIuMAX
" not a commit", idnum
);
1898 hashcpy(n
->sha1
, oe
->sha1
);
1899 } else if (!get_sha1(from
, n
->sha1
)) {
1901 char *buf
= read_object_with_reference(n
->sha1
,
1902 commit_type
, &size
, n
->sha1
);
1903 if (!buf
|| size
< 46)
1904 die("Not a valid commit: %s", from
);
1907 die("Invalid ref name or SHA1 expression: %s", from
);
1916 read_next_command();
1921 static void cmd_new_commit(void)
1927 char *author
= NULL
;
1928 char *committer
= NULL
;
1929 struct hash_list
*merge_list
= NULL
;
1930 unsigned int merge_count
;
1932 /* Obtain the branch name from the rest of our command */
1933 sp
= strchr(command_buf
.buf
, ' ') + 1;
1934 b
= lookup_branch(sp
);
1938 read_next_command();
1940 if (!prefixcmp(command_buf
.buf
, "author ")) {
1941 author
= parse_ident(command_buf
.buf
+ 7);
1942 read_next_command();
1944 if (!prefixcmp(command_buf
.buf
, "committer ")) {
1945 committer
= parse_ident(command_buf
.buf
+ 10);
1946 read_next_command();
1949 die("Expected committer but didn't get one");
1950 msg
= cmd_data(&msglen
);
1951 read_next_command();
1953 merge_list
= cmd_merge(&merge_count
);
1955 /* ensure the branch is active/loaded */
1956 if (!b
->branch_tree
.tree
|| !max_active_branches
) {
1957 unload_one_branch();
1962 while (!command_buf
.eof
&& command_buf
.len
> 1) {
1963 if (!prefixcmp(command_buf
.buf
, "M "))
1965 else if (!prefixcmp(command_buf
.buf
, "D "))
1967 else if (!prefixcmp(command_buf
.buf
, "R "))
1968 file_change_cr(b
, 1);
1969 else if (!prefixcmp(command_buf
.buf
, "C "))
1970 file_change_cr(b
, 0);
1971 else if (!strcmp("deleteall", command_buf
.buf
))
1972 file_change_deleteall(b
);
1974 unread_command_buf
= 1;
1977 read_next_command();
1980 /* build the tree and the commit */
1981 store_tree(&b
->branch_tree
);
1982 hashcpy(b
->branch_tree
.versions
[0].sha1
,
1983 b
->branch_tree
.versions
[1].sha1
);
1984 size_dbuf(&new_data
, 114 + msglen
1987 ? strlen(author
) + strlen(committer
)
1988 : 2 * strlen(committer
)));
1989 sp
= new_data
.buffer
;
1990 sp
+= sprintf(sp
, "tree %s\n",
1991 sha1_to_hex(b
->branch_tree
.versions
[1].sha1
));
1992 if (!is_null_sha1(b
->sha1
))
1993 sp
+= sprintf(sp
, "parent %s\n", sha1_to_hex(b
->sha1
));
1994 while (merge_list
) {
1995 struct hash_list
*next
= merge_list
->next
;
1996 sp
+= sprintf(sp
, "parent %s\n", sha1_to_hex(merge_list
->sha1
));
2000 sp
+= sprintf(sp
, "author %s\n", author
? author
: committer
);
2001 sp
+= sprintf(sp
, "committer %s\n", committer
);
2003 memcpy(sp
, msg
, msglen
);
2009 if (!store_object(OBJ_COMMIT
,
2010 new_data
.buffer
, sp
- (char*)new_data
.buffer
,
2011 NULL
, b
->sha1
, next_mark
))
2012 b
->pack_id
= pack_id
;
2013 b
->last_commit
= object_count_by_type
[OBJ_COMMIT
];
2016 static void cmd_new_tag(void)
2025 uintmax_t from_mark
= 0;
2026 unsigned char sha1
[20];
2028 /* Obtain the new tag name from the rest of our command */
2029 sp
= strchr(command_buf
.buf
, ' ') + 1;
2030 t
= pool_alloc(sizeof(struct tag
));
2032 t
->name
= pool_strdup(sp
);
2034 last_tag
->next_tag
= t
;
2038 read_next_command();
2041 if (prefixcmp(command_buf
.buf
, "from "))
2042 die("Expected from command, got %s", command_buf
.buf
);
2043 from
= strchr(command_buf
.buf
, ' ') + 1;
2044 s
= lookup_branch(from
);
2046 hashcpy(sha1
, s
->sha1
);
2047 } else if (*from
== ':') {
2048 struct object_entry
*oe
;
2049 from_mark
= strtoumax(from
+ 1, NULL
, 10);
2050 oe
= find_mark(from_mark
);
2051 if (oe
->type
!= OBJ_COMMIT
)
2052 die("Mark :%" PRIuMAX
" not a commit", from_mark
);
2053 hashcpy(sha1
, oe
->sha1
);
2054 } else if (!get_sha1(from
, sha1
)) {
2058 buf
= read_object_with_reference(sha1
,
2059 commit_type
, &size
, sha1
);
2060 if (!buf
|| size
< 46)
2061 die("Not a valid commit: %s", from
);
2064 die("Invalid ref name or SHA1 expression: %s", from
);
2065 read_next_command();
2068 if (prefixcmp(command_buf
.buf
, "tagger "))
2069 die("Expected tagger command, got %s", command_buf
.buf
);
2070 tagger
= parse_ident(command_buf
.buf
+ 7);
2072 /* tag payload/message */
2073 read_next_command();
2074 msg
= cmd_data(&msglen
);
2076 /* build the tag object */
2077 size_dbuf(&new_data
, 67+strlen(t
->name
)+strlen(tagger
)+msglen
);
2078 sp
= new_data
.buffer
;
2079 sp
+= sprintf(sp
, "object %s\n", sha1_to_hex(sha1
));
2080 sp
+= sprintf(sp
, "type %s\n", commit_type
);
2081 sp
+= sprintf(sp
, "tag %s\n", t
->name
);
2082 sp
+= sprintf(sp
, "tagger %s\n", tagger
);
2084 memcpy(sp
, msg
, msglen
);
2089 if (store_object(OBJ_TAG
, new_data
.buffer
,
2090 sp
- (char*)new_data
.buffer
,
2092 t
->pack_id
= MAX_PACK_ID
;
2094 t
->pack_id
= pack_id
;
2097 static void cmd_reset_branch(void)
2102 /* Obtain the branch name from the rest of our command */
2103 sp
= strchr(command_buf
.buf
, ' ') + 1;
2104 b
= lookup_branch(sp
);
2107 hashclr(b
->branch_tree
.versions
[0].sha1
);
2108 hashclr(b
->branch_tree
.versions
[1].sha1
);
2109 if (b
->branch_tree
.tree
) {
2110 release_tree_content_recursive(b
->branch_tree
.tree
);
2111 b
->branch_tree
.tree
= NULL
;
2116 read_next_command();
2117 if (!cmd_from(b
) && command_buf
.len
> 1)
2118 unread_command_buf
= 1;
2121 static void cmd_checkpoint(void)
2132 static void cmd_progress(void)
2134 fwrite(command_buf
.buf
, 1, command_buf
.len
- 1, stdout
);
2135 fputc('\n', stdout
);
2140 static void import_marks(const char *input_file
)
2143 FILE *f
= fopen(input_file
, "r");
2145 die("cannot read %s: %s", input_file
, strerror(errno
));
2146 while (fgets(line
, sizeof(line
), f
)) {
2149 unsigned char sha1
[20];
2150 struct object_entry
*e
;
2152 end
= strchr(line
, '\n');
2153 if (line
[0] != ':' || !end
)
2154 die("corrupt mark line: %s", line
);
2156 mark
= strtoumax(line
+ 1, &end
, 10);
2157 if (!mark
|| end
== line
+ 1
2158 || *end
!= ' ' || get_sha1(end
+ 1, sha1
))
2159 die("corrupt mark line: %s", line
);
2160 e
= find_object(sha1
);
2162 enum object_type type
= sha1_object_info(sha1
, NULL
);
2164 die("object not found: %s", sha1_to_hex(sha1
));
2165 e
= insert_object(sha1
);
2167 e
->pack_id
= MAX_PACK_ID
;
2168 e
->offset
= 1; /* just not zero! */
2170 insert_mark(mark
, e
);
2175 static const char fast_import_usage
[] =
2176 "git-fast-import [--date-format=f] [--max-pack-size=n] [--depth=n] [--active-branches=n] [--export-marks=marks.file]";
2178 int main(int argc
, const char **argv
)
2180 int i
, show_stats
= 1;
2182 git_config(git_default_config
);
2183 alloc_objects(object_entry_alloc
);
2184 strbuf_init(&command_buf
);
2185 atom_table
= xcalloc(atom_table_sz
, sizeof(struct atom_str
*));
2186 branch_table
= xcalloc(branch_table_sz
, sizeof(struct branch
*));
2187 avail_tree_table
= xcalloc(avail_tree_table_sz
, sizeof(struct avail_tree_content
*));
2188 marks
= pool_calloc(1, sizeof(struct mark_set
));
2190 for (i
= 1; i
< argc
; i
++) {
2191 const char *a
= argv
[i
];
2193 if (*a
!= '-' || !strcmp(a
, "--"))
2195 else if (!prefixcmp(a
, "--date-format=")) {
2196 const char *fmt
= a
+ 14;
2197 if (!strcmp(fmt
, "raw"))
2198 whenspec
= WHENSPEC_RAW
;
2199 else if (!strcmp(fmt
, "rfc2822"))
2200 whenspec
= WHENSPEC_RFC2822
;
2201 else if (!strcmp(fmt
, "now"))
2202 whenspec
= WHENSPEC_NOW
;
2204 die("unknown --date-format argument %s", fmt
);
2206 else if (!prefixcmp(a
, "--max-pack-size="))
2207 max_packsize
= strtoumax(a
+ 16, NULL
, 0) * 1024 * 1024;
2208 else if (!prefixcmp(a
, "--depth="))
2209 max_depth
= strtoul(a
+ 8, NULL
, 0);
2210 else if (!prefixcmp(a
, "--active-branches="))
2211 max_active_branches
= strtoul(a
+ 18, NULL
, 0);
2212 else if (!prefixcmp(a
, "--import-marks="))
2213 import_marks(a
+ 15);
2214 else if (!prefixcmp(a
, "--export-marks="))
2216 else if (!prefixcmp(a
, "--export-pack-edges=")) {
2219 pack_edges
= fopen(a
+ 20, "a");
2221 die("Cannot open %s: %s", a
+ 20, strerror(errno
));
2222 } else if (!strcmp(a
, "--force"))
2224 else if (!strcmp(a
, "--quiet"))
2226 else if (!strcmp(a
, "--stats"))
2229 die("unknown option %s", a
);
2232 usage(fast_import_usage
);
2234 prepare_packed_git();
2237 read_next_command();
2238 if (command_buf
.eof
)
2240 else if (!strcmp("blob", command_buf
.buf
))
2242 else if (!prefixcmp(command_buf
.buf
, "commit "))
2244 else if (!prefixcmp(command_buf
.buf
, "tag "))
2246 else if (!prefixcmp(command_buf
.buf
, "reset "))
2248 else if (!strcmp("checkpoint", command_buf
.buf
))
2250 else if (!prefixcmp(command_buf
.buf
, "progress "))
2253 die("Unsupported command: %s", command_buf
.buf
);
2266 uintmax_t total_count
= 0, duplicate_count
= 0;
2267 for (i
= 0; i
< ARRAY_SIZE(object_count_by_type
); i
++)
2268 total_count
+= object_count_by_type
[i
];
2269 for (i
= 0; i
< ARRAY_SIZE(duplicate_count_by_type
); i
++)
2270 duplicate_count
+= duplicate_count_by_type
[i
];
2272 fprintf(stderr
, "%s statistics:\n", argv
[0]);
2273 fprintf(stderr
, "---------------------------------------------------------------------\n");
2274 fprintf(stderr
, "Alloc'd objects: %10" PRIuMAX
"\n", alloc_count
);
2275 fprintf(stderr
, "Total objects: %10" PRIuMAX
" (%10" PRIuMAX
" duplicates )\n", total_count
, duplicate_count
);
2276 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
]);
2277 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
]);
2278 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
]);
2279 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
]);
2280 fprintf(stderr
, "Total branches: %10lu (%10lu loads )\n", branch_count
, branch_load_count
);
2281 fprintf(stderr
, " marks: %10" PRIuMAX
" (%10" PRIuMAX
" unique )\n", (((uintmax_t)1) << marks
->shift
) * 1024, marks_set_count
);
2282 fprintf(stderr
, " atoms: %10u\n", atom_cnt
);
2283 fprintf(stderr
, "Memory total: %10" PRIuMAX
" KiB\n", (total_allocd
+ alloc_count
*sizeof(struct object_entry
))/1024);
2284 fprintf(stderr
, " pools: %10lu KiB\n", (unsigned long)(total_allocd
/1024));
2285 fprintf(stderr
, " objects: %10" PRIuMAX
" KiB\n", (alloc_count
*sizeof(struct object_entry
))/1024);
2286 fprintf(stderr
, "---------------------------------------------------------------------\n");
2288 fprintf(stderr
, "---------------------------------------------------------------------\n");
2289 fprintf(stderr
, "\n");
2292 return failure
? 1 : 0;