2 (See Documentation/git-fast-import.txt for maintained documentation.)
3 Format of STDIN stream:
15 new_blob ::= 'blob' lf
18 file_content ::= data;
20 new_commit ::= 'commit' sp ref_str lf
22 ('author' (sp name)? sp '<' email '>' sp when lf)?
23 'committer' (sp name)? sp '<' email '>' sp when lf
25 ('from' sp commit-ish lf)?
26 ('merge' sp commit-ish lf)*
31 ls ::= 'ls' sp '"' quoted(path) '"' lf;
33 file_change ::= file_clr
39 file_clr ::= 'deleteall' lf;
40 file_del ::= 'D' sp path_str lf;
41 file_rnm ::= 'R' sp path_str sp path_str lf;
42 file_cpy ::= 'C' sp path_str sp path_str lf;
43 file_obm ::= 'M' sp mode sp (hexsha1 | idnum) sp path_str lf;
44 file_inm ::= 'M' sp mode sp 'inline' sp path_str lf
46 note_obm ::= 'N' sp (hexsha1 | idnum) sp commit-ish lf;
47 note_inm ::= 'N' sp 'inline' sp commit-ish lf
50 new_tag ::= 'tag' sp tag_str lf
51 'from' sp commit-ish lf
52 ('tagger' (sp name)? sp '<' email '>' sp when lf)?
56 reset_branch ::= 'reset' sp ref_str lf
57 ('from' sp commit-ish lf)?
60 checkpoint ::= 'checkpoint' lf
63 progress ::= 'progress' sp not_lf* lf
66 # note: the first idnum in a stream should be 1 and subsequent
67 # idnums should not have gaps between values as this will cause
68 # the stream parser to reserve space for the gapped values. An
69 # idnum can be updated in the future to a new object by issuing
70 # a new mark directive with the old idnum.
72 mark ::= 'mark' sp idnum lf;
73 data ::= (delimited_data | exact_data)
76 # note: delim may be any string but must not contain lf.
77 # data_line may contain any data but must not be exactly
79 delimited_data ::= 'data' sp '<<' delim lf
83 # note: declen indicates the length of binary_data in bytes.
84 # declen does not include the lf preceding the binary data.
86 exact_data ::= 'data' sp declen lf
89 # note: quoted strings are C-style quoting supporting \c for
90 # common escapes of 'c' (e..g \n, \t, \\, \") or \nnn where nnn
91 # is the signed byte value in octal. Note that the only
92 # characters which must actually be escaped to protect the
93 # stream formatting is: \, " and LF. Otherwise these values
96 commit-ish ::= (ref_str | hexsha1 | sha1exp_str | idnum);
98 sha1exp_str ::= sha1exp;
100 path_str ::= path | '"' quoted(path) '"' ;
101 mode ::= '100644' | '644'
106 declen ::= # unsigned 32 bit value, ascii base10 notation;
107 bigint ::= # unsigned integer value, ascii base10 notation;
108 binary_data ::= # file content, not interpreted;
110 when ::= raw_when | rfc2822_when;
111 raw_when ::= ts sp tz;
112 rfc2822_when ::= # Valid RFC 2822 date and time;
114 sp ::= # ASCII space character;
115 lf ::= # ASCII newline (LF) character;
117 # note: a colon (':') must precede the numerical value assigned to
118 # an idnum. This is to distinguish it from a ref or tag name as
119 # GIT does not permit ':' in ref or tag strings.
121 idnum ::= ':' bigint;
122 path ::= # GIT style file path, e.g. "a/b/c";
123 ref ::= # GIT ref name, e.g. "refs/heads/MOZ_GECKO_EXPERIMENT";
124 tag ::= # GIT tag name, e.g. "FIREFOX_1_5";
125 sha1exp ::= # Any valid GIT SHA1 expression;
126 hexsha1 ::= # SHA1 in hexadecimal format;
128 # note: name and email are UTF8 strings, however name must not
129 # contain '<' or lf and email must not contain any of the
130 # following: '<', '>', lf.
132 name ::= # valid GIT author/committer name;
133 email ::= # valid GIT author/committer email;
134 ts ::= # time since the epoch in seconds, ascii base10 notation;
135 tz ::= # GIT style timezone;
137 # note: comments, get-mark, ls-tree, and cat-blob requests may
138 # appear anywhere in the input, except within a data command. Any
139 # form of the data command always escapes the related input from
140 # comment processing.
142 # In case it is not clear, the '#' that starts the comment
143 # must be the first character on that line (an lf
147 get_mark ::= 'get-mark' sp idnum lf;
148 cat_blob ::= 'cat-blob' sp (hexsha1 | idnum) lf;
149 ls_tree ::= 'ls' sp (hexsha1 | idnum) sp path_str lf;
151 comment ::= '#' not_lf* lf;
152 not_lf ::= # Any byte that is not ASCII newline (LF);
157 #include "lockfile.h"
165 #include "csum-file.h"
167 #include "exec_cmd.h"
169 #include "run-command.h"
171 #define PACK_ID_BITS 16
172 #define MAX_PACK_ID ((1<<PACK_ID_BITS)-1)
173 #define DEPTH_BITS 13
174 #define MAX_DEPTH ((1<<DEPTH_BITS)-1)
177 * We abuse the setuid bit on directories to mean "do not delta".
179 #define NO_DELTA S_ISUID
181 struct object_entry
{
182 struct pack_idx_entry idx
;
183 struct object_entry
*next
;
184 uint32_t type
: TYPE_BITS
,
185 pack_id
: PACK_ID_BITS
,
189 struct object_entry_pool
{
190 struct object_entry_pool
*next_pool
;
191 struct object_entry
*next_free
;
192 struct object_entry
*end
;
193 struct object_entry entries
[FLEX_ARRAY
]; /* more */
198 struct object_entry
*marked
[1024];
199 struct mark_set
*sets
[1024];
208 unsigned no_swap
: 1;
212 struct mem_pool
*next_pool
;
215 uintmax_t space
[FLEX_ARRAY
]; /* more */
219 struct atom_str
*next_atom
;
220 unsigned short str_len
;
221 char str_dat
[FLEX_ARRAY
]; /* more */
226 struct tree_content
*tree
;
227 struct atom_str
*name
;
228 struct tree_entry_ms
{
230 unsigned char sha1
[20];
234 struct tree_content
{
235 unsigned int entry_capacity
; /* must match avail_tree_content */
236 unsigned int entry_count
;
237 unsigned int delta_depth
;
238 struct tree_entry
*entries
[FLEX_ARRAY
]; /* more */
241 struct avail_tree_content
{
242 unsigned int entry_capacity
; /* must match tree_content */
243 struct avail_tree_content
*next_avail
;
247 struct branch
*table_next_branch
;
248 struct branch
*active_next_branch
;
250 struct tree_entry branch_tree
;
251 uintmax_t last_commit
;
255 unsigned pack_id
: PACK_ID_BITS
;
256 unsigned char sha1
[20];
260 struct tag
*next_tag
;
262 unsigned int pack_id
;
263 unsigned char sha1
[20];
267 struct hash_list
*next
;
268 unsigned char sha1
[20];
277 struct recent_command
{
278 struct recent_command
*prev
;
279 struct recent_command
*next
;
283 /* Configured limits on output */
284 static unsigned long max_depth
= 10;
285 static off_t max_packsize
;
286 static int unpack_limit
= 100;
287 static int force_update
;
288 static int pack_compression_level
= Z_DEFAULT_COMPRESSION
;
289 static int pack_compression_seen
;
291 /* Stats and misc. counters */
292 static uintmax_t alloc_count
;
293 static uintmax_t marks_set_count
;
294 static uintmax_t object_count_by_type
[1 << TYPE_BITS
];
295 static uintmax_t duplicate_count_by_type
[1 << TYPE_BITS
];
296 static uintmax_t delta_count_by_type
[1 << TYPE_BITS
];
297 static uintmax_t delta_count_attempts_by_type
[1 << TYPE_BITS
];
298 static unsigned long object_count
;
299 static unsigned long branch_count
;
300 static unsigned long branch_load_count
;
302 static FILE *pack_edges
;
303 static unsigned int show_stats
= 1;
304 static int global_argc
;
305 static char **global_argv
;
308 static size_t mem_pool_alloc
= 2*1024*1024 - sizeof(struct mem_pool
);
309 static size_t total_allocd
;
310 static struct mem_pool
*mem_pool
;
312 /* Atom management */
313 static unsigned int atom_table_sz
= 4451;
314 static unsigned int atom_cnt
;
315 static struct atom_str
**atom_table
;
317 /* The .pack file being generated */
318 static struct pack_idx_option pack_idx_opts
;
319 static unsigned int pack_id
;
320 static struct sha1file
*pack_file
;
321 static struct packed_git
*pack_data
;
322 static struct packed_git
**all_packs
;
323 static off_t pack_size
;
325 /* Table of objects we've written. */
326 static unsigned int object_entry_alloc
= 5000;
327 static struct object_entry_pool
*blocks
;
328 static struct object_entry
*object_table
[1 << 16];
329 static struct mark_set
*marks
;
330 static const char *export_marks_file
;
331 static const char *import_marks_file
;
332 static int import_marks_file_from_stream
;
333 static int import_marks_file_ignore_missing
;
334 static int relative_marks_paths
;
337 static struct last_object last_blob
= { STRBUF_INIT
, 0, 0, 0 };
339 /* Tree management */
340 static unsigned int tree_entry_alloc
= 1000;
341 static void *avail_tree_entry
;
342 static unsigned int avail_tree_table_sz
= 100;
343 static struct avail_tree_content
**avail_tree_table
;
344 static struct strbuf old_tree
= STRBUF_INIT
;
345 static struct strbuf new_tree
= STRBUF_INIT
;
348 static unsigned long max_active_branches
= 5;
349 static unsigned long cur_active_branches
;
350 static unsigned long branch_table_sz
= 1039;
351 static struct branch
**branch_table
;
352 static struct branch
*active_branches
;
355 static struct tag
*first_tag
;
356 static struct tag
*last_tag
;
358 /* Input stream parsing */
359 static whenspec_type whenspec
= WHENSPEC_RAW
;
360 static struct strbuf command_buf
= STRBUF_INIT
;
361 static int unread_command_buf
;
362 static struct recent_command cmd_hist
= {&cmd_hist
, &cmd_hist
, NULL
};
363 static struct recent_command
*cmd_tail
= &cmd_hist
;
364 static struct recent_command
*rc_free
;
365 static unsigned int cmd_save
= 100;
366 static uintmax_t next_mark
;
367 static struct strbuf new_data
= STRBUF_INIT
;
368 static int seen_data_command
;
369 static int require_explicit_termination
;
371 /* Signal handling */
372 static volatile sig_atomic_t checkpoint_requested
;
374 /* Where to write output of cat-blob commands */
375 static int cat_blob_fd
= STDOUT_FILENO
;
377 static void parse_argv(void);
378 static void parse_get_mark(const char *p
);
379 static void parse_cat_blob(const char *p
);
380 static void parse_ls(const char *p
, struct branch
*b
);
382 static void write_branch_report(FILE *rpt
, struct branch
*b
)
384 fprintf(rpt
, "%s:\n", b
->name
);
386 fprintf(rpt
, " status :");
388 fputs(" active", rpt
);
389 if (b
->branch_tree
.tree
)
390 fputs(" loaded", rpt
);
391 if (is_null_sha1(b
->branch_tree
.versions
[1].sha1
))
392 fputs(" dirty", rpt
);
395 fprintf(rpt
, " tip commit : %s\n", sha1_to_hex(b
->sha1
));
396 fprintf(rpt
, " old tree : %s\n", sha1_to_hex(b
->branch_tree
.versions
[0].sha1
));
397 fprintf(rpt
, " cur tree : %s\n", sha1_to_hex(b
->branch_tree
.versions
[1].sha1
));
398 fprintf(rpt
, " commit clock: %" PRIuMAX
"\n", b
->last_commit
);
400 fputs(" last pack : ", rpt
);
401 if (b
->pack_id
< MAX_PACK_ID
)
402 fprintf(rpt
, "%u", b
->pack_id
);
408 static void dump_marks_helper(FILE *, uintmax_t, struct mark_set
*);
410 static void write_crash_report(const char *err
)
412 char *loc
= git_pathdup("fast_import_crash_%"PRIuMAX
, (uintmax_t) getpid());
413 FILE *rpt
= fopen(loc
, "w");
416 struct recent_command
*rc
;
419 error("can't write crash report %s: %s", loc
, strerror(errno
));
424 fprintf(stderr
, "fast-import: dumping crash report to %s\n", loc
);
426 fprintf(rpt
, "fast-import crash report:\n");
427 fprintf(rpt
, " fast-import process: %"PRIuMAX
"\n", (uintmax_t) getpid());
428 fprintf(rpt
, " parent process : %"PRIuMAX
"\n", (uintmax_t) getppid());
429 fprintf(rpt
, " at %s\n", show_date(time(NULL
), 0, DATE_MODE(ISO8601
)));
432 fputs("fatal: ", rpt
);
437 fputs("Most Recent Commands Before Crash\n", rpt
);
438 fputs("---------------------------------\n", rpt
);
439 for (rc
= cmd_hist
.next
; rc
!= &cmd_hist
; rc
= rc
->next
) {
440 if (rc
->next
== &cmd_hist
)
449 fputs("Active Branch LRU\n", rpt
);
450 fputs("-----------------\n", rpt
);
451 fprintf(rpt
, " active_branches = %lu cur, %lu max\n",
453 max_active_branches
);
455 fputs(" pos clock name\n", rpt
);
456 fputs(" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n", rpt
);
457 for (b
= active_branches
, lu
= 0; b
; b
= b
->active_next_branch
)
458 fprintf(rpt
, " %2lu) %6" PRIuMAX
" %s\n",
459 ++lu
, b
->last_commit
, b
->name
);
462 fputs("Inactive Branches\n", rpt
);
463 fputs("-----------------\n", rpt
);
464 for (lu
= 0; lu
< branch_table_sz
; lu
++) {
465 for (b
= branch_table
[lu
]; b
; b
= b
->table_next_branch
)
466 write_branch_report(rpt
, b
);
472 fputs("Annotated Tags\n", rpt
);
473 fputs("--------------\n", rpt
);
474 for (tg
= first_tag
; tg
; tg
= tg
->next_tag
) {
475 fputs(sha1_to_hex(tg
->sha1
), rpt
);
477 fputs(tg
->name
, rpt
);
483 fputs("Marks\n", rpt
);
484 fputs("-----\n", rpt
);
485 if (export_marks_file
)
486 fprintf(rpt
, " exported to %s\n", export_marks_file
);
488 dump_marks_helper(rpt
, 0, marks
);
491 fputs("-------------------\n", rpt
);
492 fputs("END OF CRASH REPORT\n", rpt
);
497 static void end_packfile(void);
498 static void unkeep_all_packs(void);
499 static void dump_marks(void);
501 static NORETURN
void die_nicely(const char *err
, va_list params
)
504 char message
[2 * PATH_MAX
];
506 vsnprintf(message
, sizeof(message
), err
, params
);
507 fputs("fatal: ", stderr
);
508 fputs(message
, stderr
);
513 write_crash_report(message
);
521 #ifndef SIGUSR1 /* Windows, for example */
523 static void set_checkpoint_signal(void)
529 static void checkpoint_signal(int signo
)
531 checkpoint_requested
= 1;
534 static void set_checkpoint_signal(void)
538 memset(&sa
, 0, sizeof(sa
));
539 sa
.sa_handler
= checkpoint_signal
;
540 sigemptyset(&sa
.sa_mask
);
541 sa
.sa_flags
= SA_RESTART
;
542 sigaction(SIGUSR1
, &sa
, NULL
);
547 static void alloc_objects(unsigned int cnt
)
549 struct object_entry_pool
*b
;
551 b
= xmalloc(sizeof(struct object_entry_pool
)
552 + cnt
* sizeof(struct object_entry
));
553 b
->next_pool
= blocks
;
554 b
->next_free
= b
->entries
;
555 b
->end
= b
->entries
+ cnt
;
560 static struct object_entry
*new_object(unsigned char *sha1
)
562 struct object_entry
*e
;
564 if (blocks
->next_free
== blocks
->end
)
565 alloc_objects(object_entry_alloc
);
567 e
= blocks
->next_free
++;
568 hashcpy(e
->idx
.sha1
, sha1
);
572 static struct object_entry
*find_object(unsigned char *sha1
)
574 unsigned int h
= sha1
[0] << 8 | sha1
[1];
575 struct object_entry
*e
;
576 for (e
= object_table
[h
]; e
; e
= e
->next
)
577 if (!hashcmp(sha1
, e
->idx
.sha1
))
582 static struct object_entry
*insert_object(unsigned char *sha1
)
584 unsigned int h
= sha1
[0] << 8 | sha1
[1];
585 struct object_entry
*e
= object_table
[h
];
588 if (!hashcmp(sha1
, e
->idx
.sha1
))
593 e
= new_object(sha1
);
594 e
->next
= object_table
[h
];
600 static unsigned int hc_str(const char *s
, size_t len
)
608 static void *pool_alloc(size_t len
)
613 /* round up to a 'uintmax_t' alignment */
614 if (len
& (sizeof(uintmax_t) - 1))
615 len
+= sizeof(uintmax_t) - (len
& (sizeof(uintmax_t) - 1));
617 for (p
= mem_pool
; p
; p
= p
->next_pool
)
618 if ((p
->end
- p
->next_free
>= len
))
622 if (len
>= (mem_pool_alloc
/2)) {
626 total_allocd
+= sizeof(struct mem_pool
) + mem_pool_alloc
;
627 p
= xmalloc(st_add(sizeof(struct mem_pool
), mem_pool_alloc
));
628 p
->next_pool
= mem_pool
;
629 p
->next_free
= (char *) p
->space
;
630 p
->end
= p
->next_free
+ mem_pool_alloc
;
639 static void *pool_calloc(size_t count
, size_t size
)
641 size_t len
= count
* size
;
642 void *r
= pool_alloc(len
);
647 static char *pool_strdup(const char *s
)
649 size_t len
= strlen(s
) + 1;
650 char *r
= pool_alloc(len
);
655 static void insert_mark(uintmax_t idnum
, struct object_entry
*oe
)
657 struct mark_set
*s
= marks
;
658 while ((idnum
>> s
->shift
) >= 1024) {
659 s
= pool_calloc(1, sizeof(struct mark_set
));
660 s
->shift
= marks
->shift
+ 10;
661 s
->data
.sets
[0] = marks
;
665 uintmax_t i
= idnum
>> s
->shift
;
666 idnum
-= i
<< s
->shift
;
667 if (!s
->data
.sets
[i
]) {
668 s
->data
.sets
[i
] = pool_calloc(1, sizeof(struct mark_set
));
669 s
->data
.sets
[i
]->shift
= s
->shift
- 10;
673 if (!s
->data
.marked
[idnum
])
675 s
->data
.marked
[idnum
] = oe
;
678 static struct object_entry
*find_mark(uintmax_t idnum
)
680 uintmax_t orig_idnum
= idnum
;
681 struct mark_set
*s
= marks
;
682 struct object_entry
*oe
= NULL
;
683 if ((idnum
>> s
->shift
) < 1024) {
684 while (s
&& s
->shift
) {
685 uintmax_t i
= idnum
>> s
->shift
;
686 idnum
-= i
<< s
->shift
;
690 oe
= s
->data
.marked
[idnum
];
693 die("mark :%" PRIuMAX
" not declared", orig_idnum
);
697 static struct atom_str
*to_atom(const char *s
, unsigned short len
)
699 unsigned int hc
= hc_str(s
, len
) % atom_table_sz
;
702 for (c
= atom_table
[hc
]; c
; c
= c
->next_atom
)
703 if (c
->str_len
== len
&& !strncmp(s
, c
->str_dat
, len
))
706 c
= pool_alloc(sizeof(struct atom_str
) + len
+ 1);
708 memcpy(c
->str_dat
, s
, len
);
710 c
->next_atom
= atom_table
[hc
];
716 static struct branch
*lookup_branch(const char *name
)
718 unsigned int hc
= hc_str(name
, strlen(name
)) % branch_table_sz
;
721 for (b
= branch_table
[hc
]; b
; b
= b
->table_next_branch
)
722 if (!strcmp(name
, b
->name
))
727 static struct branch
*new_branch(const char *name
)
729 unsigned int hc
= hc_str(name
, strlen(name
)) % branch_table_sz
;
730 struct branch
*b
= lookup_branch(name
);
733 die("Invalid attempt to create duplicate branch: %s", name
);
734 if (check_refname_format(name
, REFNAME_ALLOW_ONELEVEL
))
735 die("Branch name doesn't conform to GIT standards: %s", name
);
737 b
= pool_calloc(1, sizeof(struct branch
));
738 b
->name
= pool_strdup(name
);
739 b
->table_next_branch
= branch_table
[hc
];
740 b
->branch_tree
.versions
[0].mode
= S_IFDIR
;
741 b
->branch_tree
.versions
[1].mode
= S_IFDIR
;
744 b
->pack_id
= MAX_PACK_ID
;
745 branch_table
[hc
] = b
;
750 static unsigned int hc_entries(unsigned int cnt
)
752 cnt
= cnt
& 7 ? (cnt
/ 8) + 1 : cnt
/ 8;
753 return cnt
< avail_tree_table_sz
? cnt
: avail_tree_table_sz
- 1;
756 static struct tree_content
*new_tree_content(unsigned int cnt
)
758 struct avail_tree_content
*f
, *l
= NULL
;
759 struct tree_content
*t
;
760 unsigned int hc
= hc_entries(cnt
);
762 for (f
= avail_tree_table
[hc
]; f
; l
= f
, f
= f
->next_avail
)
763 if (f
->entry_capacity
>= cnt
)
768 l
->next_avail
= f
->next_avail
;
770 avail_tree_table
[hc
] = f
->next_avail
;
772 cnt
= cnt
& 7 ? ((cnt
/ 8) + 1) * 8 : cnt
;
773 f
= pool_alloc(sizeof(*t
) + sizeof(t
->entries
[0]) * cnt
);
774 f
->entry_capacity
= cnt
;
777 t
= (struct tree_content
*)f
;
783 static void release_tree_entry(struct tree_entry
*e
);
784 static void release_tree_content(struct tree_content
*t
)
786 struct avail_tree_content
*f
= (struct avail_tree_content
*)t
;
787 unsigned int hc
= hc_entries(f
->entry_capacity
);
788 f
->next_avail
= avail_tree_table
[hc
];
789 avail_tree_table
[hc
] = f
;
792 static void release_tree_content_recursive(struct tree_content
*t
)
795 for (i
= 0; i
< t
->entry_count
; i
++)
796 release_tree_entry(t
->entries
[i
]);
797 release_tree_content(t
);
800 static struct tree_content
*grow_tree_content(
801 struct tree_content
*t
,
804 struct tree_content
*r
= new_tree_content(t
->entry_count
+ amt
);
805 r
->entry_count
= t
->entry_count
;
806 r
->delta_depth
= t
->delta_depth
;
807 memcpy(r
->entries
,t
->entries
,t
->entry_count
*sizeof(t
->entries
[0]));
808 release_tree_content(t
);
812 static struct tree_entry
*new_tree_entry(void)
814 struct tree_entry
*e
;
816 if (!avail_tree_entry
) {
817 unsigned int n
= tree_entry_alloc
;
818 total_allocd
+= n
* sizeof(struct tree_entry
);
820 avail_tree_entry
= e
;
822 *((void**)e
) = e
+ 1;
828 e
= avail_tree_entry
;
829 avail_tree_entry
= *((void**)e
);
833 static void release_tree_entry(struct tree_entry
*e
)
836 release_tree_content_recursive(e
->tree
);
837 *((void**)e
) = avail_tree_entry
;
838 avail_tree_entry
= e
;
841 static struct tree_content
*dup_tree_content(struct tree_content
*s
)
843 struct tree_content
*d
;
844 struct tree_entry
*a
, *b
;
849 d
= new_tree_content(s
->entry_count
);
850 for (i
= 0; i
< s
->entry_count
; i
++) {
852 b
= new_tree_entry();
853 memcpy(b
, a
, sizeof(*a
));
854 if (a
->tree
&& is_null_sha1(b
->versions
[1].sha1
))
855 b
->tree
= dup_tree_content(a
->tree
);
860 d
->entry_count
= s
->entry_count
;
861 d
->delta_depth
= s
->delta_depth
;
866 static void start_packfile(void)
868 static char tmp_file
[PATH_MAX
];
869 struct packed_git
*p
;
870 struct pack_header hdr
;
873 pack_fd
= odb_mkstemp(tmp_file
, sizeof(tmp_file
),
874 "pack/tmp_pack_XXXXXX");
875 FLEX_ALLOC_STR(p
, pack_name
, tmp_file
);
876 p
->pack_fd
= pack_fd
;
878 pack_file
= sha1fd(pack_fd
, p
->pack_name
);
880 hdr
.hdr_signature
= htonl(PACK_SIGNATURE
);
881 hdr
.hdr_version
= htonl(2);
883 sha1write(pack_file
, &hdr
, sizeof(hdr
));
886 pack_size
= sizeof(hdr
);
889 REALLOC_ARRAY(all_packs
, pack_id
+ 1);
890 all_packs
[pack_id
] = p
;
893 static const char *create_index(void)
896 struct pack_idx_entry
**idx
, **c
, **last
;
897 struct object_entry
*e
;
898 struct object_entry_pool
*o
;
900 /* Build the table of object IDs. */
901 ALLOC_ARRAY(idx
, object_count
);
903 for (o
= blocks
; o
; o
= o
->next_pool
)
904 for (e
= o
->next_free
; e
-- != o
->entries
;)
905 if (pack_id
== e
->pack_id
)
907 last
= idx
+ object_count
;
909 die("internal consistency error creating the index");
911 tmpfile
= write_idx_file(NULL
, idx
, object_count
, &pack_idx_opts
, pack_data
->sha1
);
916 static char *keep_pack(const char *curr_index_name
)
918 static char name
[PATH_MAX
];
919 static const char *keep_msg
= "fast-import";
922 keep_fd
= odb_pack_keep(name
, sizeof(name
), pack_data
->sha1
);
924 die_errno("cannot create keep file");
925 write_or_die(keep_fd
, keep_msg
, strlen(keep_msg
));
927 die_errno("failed to write keep file");
929 snprintf(name
, sizeof(name
), "%s/pack/pack-%s.pack",
930 get_object_directory(), sha1_to_hex(pack_data
->sha1
));
931 if (finalize_object_file(pack_data
->pack_name
, name
))
932 die("cannot store pack file");
934 snprintf(name
, sizeof(name
), "%s/pack/pack-%s.idx",
935 get_object_directory(), sha1_to_hex(pack_data
->sha1
));
936 if (finalize_object_file(curr_index_name
, name
))
937 die("cannot store index file");
938 free((void *)curr_index_name
);
942 static void unkeep_all_packs(void)
944 static char name
[PATH_MAX
];
947 for (k
= 0; k
< pack_id
; k
++) {
948 struct packed_git
*p
= all_packs
[k
];
949 snprintf(name
, sizeof(name
), "%s/pack/pack-%s.keep",
950 get_object_directory(), sha1_to_hex(p
->sha1
));
951 unlink_or_warn(name
);
955 static int loosen_small_pack(const struct packed_git
*p
)
957 struct child_process unpack
= CHILD_PROCESS_INIT
;
959 if (lseek(p
->pack_fd
, 0, SEEK_SET
) < 0)
960 die_errno("Failed seeking to start of '%s'", p
->pack_name
);
962 unpack
.in
= p
->pack_fd
;
964 unpack
.stdout_to_stderr
= 1;
965 argv_array_push(&unpack
.args
, "unpack-objects");
967 argv_array_push(&unpack
.args
, "-q");
969 return run_command(&unpack
);
972 static void end_packfile(void)
976 if (running
|| !pack_data
)
980 clear_delta_base_cache();
982 struct packed_git
*new_p
;
983 unsigned char cur_pack_sha1
[20];
989 close_pack_windows(pack_data
);
990 sha1close(pack_file
, cur_pack_sha1
, 0);
991 fixup_pack_header_footer(pack_data
->pack_fd
, pack_data
->sha1
,
992 pack_data
->pack_name
, object_count
,
993 cur_pack_sha1
, pack_size
);
995 if (object_count
<= unpack_limit
) {
996 if (!loosen_small_pack(pack_data
))
1000 close(pack_data
->pack_fd
);
1001 idx_name
= keep_pack(create_index());
1003 /* Register the packfile with core git's machinery. */
1004 new_p
= add_packed_git(idx_name
, strlen(idx_name
), 1);
1006 die("core git rejected index %s", idx_name
);
1007 all_packs
[pack_id
] = new_p
;
1008 install_packed_git(new_p
);
1010 /* Print the boundary */
1012 fprintf(pack_edges
, "%s:", new_p
->pack_name
);
1013 for (i
= 0; i
< branch_table_sz
; i
++) {
1014 for (b
= branch_table
[i
]; b
; b
= b
->table_next_branch
) {
1015 if (b
->pack_id
== pack_id
)
1016 fprintf(pack_edges
, " %s", sha1_to_hex(b
->sha1
));
1019 for (t
= first_tag
; t
; t
= t
->next_tag
) {
1020 if (t
->pack_id
== pack_id
)
1021 fprintf(pack_edges
, " %s", sha1_to_hex(t
->sha1
));
1023 fputc('\n', pack_edges
);
1031 close(pack_data
->pack_fd
);
1032 unlink_or_warn(pack_data
->pack_name
);
1038 /* We can't carry a delta across packfiles. */
1039 strbuf_release(&last_blob
.data
);
1040 last_blob
.offset
= 0;
1041 last_blob
.depth
= 0;
1044 static void cycle_packfile(void)
1050 static int store_object(
1051 enum object_type type
,
1053 struct last_object
*last
,
1054 unsigned char *sha1out
,
1058 struct object_entry
*e
;
1059 unsigned char hdr
[96];
1060 unsigned char sha1
[20];
1061 unsigned long hdrlen
, deltalen
;
1065 hdrlen
= xsnprintf((char *)hdr
, sizeof(hdr
), "%s %lu",
1066 typename(type
), (unsigned long)dat
->len
) + 1;
1068 git_SHA1_Update(&c
, hdr
, hdrlen
);
1069 git_SHA1_Update(&c
, dat
->buf
, dat
->len
);
1070 git_SHA1_Final(sha1
, &c
);
1072 hashcpy(sha1out
, sha1
);
1074 e
= insert_object(sha1
);
1076 insert_mark(mark
, e
);
1077 if (e
->idx
.offset
) {
1078 duplicate_count_by_type
[type
]++;
1080 } else if (find_sha1_pack(sha1
, packed_git
)) {
1082 e
->pack_id
= MAX_PACK_ID
;
1083 e
->idx
.offset
= 1; /* just not zero! */
1084 duplicate_count_by_type
[type
]++;
1088 if (last
&& last
->data
.buf
&& last
->depth
< max_depth
&& dat
->len
> 20) {
1089 delta_count_attempts_by_type
[type
]++;
1090 delta
= diff_delta(last
->data
.buf
, last
->data
.len
,
1092 &deltalen
, dat
->len
- 20);
1096 git_deflate_init(&s
, pack_compression_level
);
1099 s
.avail_in
= deltalen
;
1101 s
.next_in
= (void *)dat
->buf
;
1102 s
.avail_in
= dat
->len
;
1104 s
.avail_out
= git_deflate_bound(&s
, s
.avail_in
);
1105 s
.next_out
= out
= xmalloc(s
.avail_out
);
1106 while (git_deflate(&s
, Z_FINISH
) == Z_OK
)
1108 git_deflate_end(&s
);
1110 /* Determine if we should auto-checkpoint. */
1111 if ((max_packsize
&& (pack_size
+ 60 + s
.total_out
) > max_packsize
)
1112 || (pack_size
+ 60 + s
.total_out
) < pack_size
) {
1114 /* This new object needs to *not* have the current pack_id. */
1115 e
->pack_id
= pack_id
+ 1;
1118 /* We cannot carry a delta into the new pack. */
1123 git_deflate_init(&s
, pack_compression_level
);
1124 s
.next_in
= (void *)dat
->buf
;
1125 s
.avail_in
= dat
->len
;
1126 s
.avail_out
= git_deflate_bound(&s
, s
.avail_in
);
1127 s
.next_out
= out
= xrealloc(out
, s
.avail_out
);
1128 while (git_deflate(&s
, Z_FINISH
) == Z_OK
)
1130 git_deflate_end(&s
);
1135 e
->pack_id
= pack_id
;
1136 e
->idx
.offset
= pack_size
;
1138 object_count_by_type
[type
]++;
1140 crc32_begin(pack_file
);
1143 off_t ofs
= e
->idx
.offset
- last
->offset
;
1144 unsigned pos
= sizeof(hdr
) - 1;
1146 delta_count_by_type
[type
]++;
1147 e
->depth
= last
->depth
+ 1;
1149 hdrlen
= encode_in_pack_object_header(OBJ_OFS_DELTA
, deltalen
, hdr
);
1150 sha1write(pack_file
, hdr
, hdrlen
);
1151 pack_size
+= hdrlen
;
1153 hdr
[pos
] = ofs
& 127;
1155 hdr
[--pos
] = 128 | (--ofs
& 127);
1156 sha1write(pack_file
, hdr
+ pos
, sizeof(hdr
) - pos
);
1157 pack_size
+= sizeof(hdr
) - pos
;
1160 hdrlen
= encode_in_pack_object_header(type
, dat
->len
, hdr
);
1161 sha1write(pack_file
, hdr
, hdrlen
);
1162 pack_size
+= hdrlen
;
1165 sha1write(pack_file
, out
, s
.total_out
);
1166 pack_size
+= s
.total_out
;
1168 e
->idx
.crc32
= crc32_end(pack_file
);
1173 if (last
->no_swap
) {
1176 strbuf_swap(&last
->data
, dat
);
1178 last
->offset
= e
->idx
.offset
;
1179 last
->depth
= e
->depth
;
1184 static void truncate_pack(struct sha1file_checkpoint
*checkpoint
)
1186 if (sha1file_truncate(pack_file
, checkpoint
))
1187 die_errno("cannot truncate pack to skip duplicate");
1188 pack_size
= checkpoint
->offset
;
1191 static void stream_blob(uintmax_t len
, unsigned char *sha1out
, uintmax_t mark
)
1193 size_t in_sz
= 64 * 1024, out_sz
= 64 * 1024;
1194 unsigned char *in_buf
= xmalloc(in_sz
);
1195 unsigned char *out_buf
= xmalloc(out_sz
);
1196 struct object_entry
*e
;
1197 unsigned char sha1
[20];
1198 unsigned long hdrlen
;
1202 struct sha1file_checkpoint checkpoint
;
1205 /* Determine if we should auto-checkpoint. */
1206 if ((max_packsize
&& (pack_size
+ 60 + len
) > max_packsize
)
1207 || (pack_size
+ 60 + len
) < pack_size
)
1210 sha1file_checkpoint(pack_file
, &checkpoint
);
1211 offset
= checkpoint
.offset
;
1213 hdrlen
= snprintf((char *)out_buf
, out_sz
, "blob %" PRIuMAX
, len
) + 1;
1214 if (out_sz
<= hdrlen
)
1215 die("impossibly large object header");
1218 git_SHA1_Update(&c
, out_buf
, hdrlen
);
1220 crc32_begin(pack_file
);
1222 git_deflate_init(&s
, pack_compression_level
);
1224 hdrlen
= encode_in_pack_object_header(OBJ_BLOB
, len
, out_buf
);
1225 if (out_sz
<= hdrlen
)
1226 die("impossibly large object header");
1228 s
.next_out
= out_buf
+ hdrlen
;
1229 s
.avail_out
= out_sz
- hdrlen
;
1231 while (status
!= Z_STREAM_END
) {
1232 if (0 < len
&& !s
.avail_in
) {
1233 size_t cnt
= in_sz
< len
? in_sz
: (size_t)len
;
1234 size_t n
= fread(in_buf
, 1, cnt
, stdin
);
1235 if (!n
&& feof(stdin
))
1236 die("EOF in data (%" PRIuMAX
" bytes remaining)", len
);
1238 git_SHA1_Update(&c
, in_buf
, n
);
1244 status
= git_deflate(&s
, len
? 0 : Z_FINISH
);
1246 if (!s
.avail_out
|| status
== Z_STREAM_END
) {
1247 size_t n
= s
.next_out
- out_buf
;
1248 sha1write(pack_file
, out_buf
, n
);
1250 s
.next_out
= out_buf
;
1251 s
.avail_out
= out_sz
;
1260 die("unexpected deflate failure: %d", status
);
1263 git_deflate_end(&s
);
1264 git_SHA1_Final(sha1
, &c
);
1267 hashcpy(sha1out
, sha1
);
1269 e
= insert_object(sha1
);
1272 insert_mark(mark
, e
);
1274 if (e
->idx
.offset
) {
1275 duplicate_count_by_type
[OBJ_BLOB
]++;
1276 truncate_pack(&checkpoint
);
1278 } else if (find_sha1_pack(sha1
, packed_git
)) {
1280 e
->pack_id
= MAX_PACK_ID
;
1281 e
->idx
.offset
= 1; /* just not zero! */
1282 duplicate_count_by_type
[OBJ_BLOB
]++;
1283 truncate_pack(&checkpoint
);
1288 e
->pack_id
= pack_id
;
1289 e
->idx
.offset
= offset
;
1290 e
->idx
.crc32
= crc32_end(pack_file
);
1292 object_count_by_type
[OBJ_BLOB
]++;
1299 /* All calls must be guarded by find_object() or find_mark() to
1300 * ensure the 'struct object_entry' passed was written by this
1301 * process instance. We unpack the entry by the offset, avoiding
1302 * the need for the corresponding .idx file. This unpacking rule
1303 * works because we only use OBJ_REF_DELTA within the packfiles
1304 * created by fast-import.
1306 * oe must not be NULL. Such an oe usually comes from giving
1307 * an unknown SHA-1 to find_object() or an undefined mark to
1308 * find_mark(). Callers must test for this condition and use
1309 * the standard read_sha1_file() when it happens.
1311 * oe->pack_id must not be MAX_PACK_ID. Such an oe is usually from
1312 * find_mark(), where the mark was reloaded from an existing marks
1313 * file and is referencing an object that this fast-import process
1314 * instance did not write out to a packfile. Callers must test for
1315 * this condition and use read_sha1_file() instead.
1317 static void *gfi_unpack_entry(
1318 struct object_entry
*oe
,
1319 unsigned long *sizep
)
1321 enum object_type type
;
1322 struct packed_git
*p
= all_packs
[oe
->pack_id
];
1323 if (p
== pack_data
&& p
->pack_size
< (pack_size
+ 20)) {
1324 /* The object is stored in the packfile we are writing to
1325 * and we have modified it since the last time we scanned
1326 * back to read a previously written object. If an old
1327 * window covered [p->pack_size, p->pack_size + 20) its
1328 * data is stale and is not valid. Closing all windows
1329 * and updating the packfile length ensures we can read
1330 * the newly written data.
1332 close_pack_windows(p
);
1333 sha1flush(pack_file
);
1335 /* We have to offer 20 bytes additional on the end of
1336 * the packfile as the core unpacker code assumes the
1337 * footer is present at the file end and must promise
1338 * at least 20 bytes within any window it maps. But
1339 * we don't actually create the footer here.
1341 p
->pack_size
= pack_size
+ 20;
1343 return unpack_entry(p
, oe
->idx
.offset
, &type
, sizep
);
1346 static const char *get_mode(const char *str
, uint16_t *modep
)
1351 while ((c
= *str
++) != ' ') {
1352 if (c
< '0' || c
> '7')
1354 mode
= (mode
<< 3) + (c
- '0');
1360 static void load_tree(struct tree_entry
*root
)
1362 unsigned char *sha1
= root
->versions
[1].sha1
;
1363 struct object_entry
*myoe
;
1364 struct tree_content
*t
;
1369 root
->tree
= t
= new_tree_content(8);
1370 if (is_null_sha1(sha1
))
1373 myoe
= find_object(sha1
);
1374 if (myoe
&& myoe
->pack_id
!= MAX_PACK_ID
) {
1375 if (myoe
->type
!= OBJ_TREE
)
1376 die("Not a tree: %s", sha1_to_hex(sha1
));
1377 t
->delta_depth
= myoe
->depth
;
1378 buf
= gfi_unpack_entry(myoe
, &size
);
1380 die("Can't load tree %s", sha1_to_hex(sha1
));
1382 enum object_type type
;
1383 buf
= read_sha1_file(sha1
, &type
, &size
);
1384 if (!buf
|| type
!= OBJ_TREE
)
1385 die("Can't load tree %s", sha1_to_hex(sha1
));
1389 while (c
!= (buf
+ size
)) {
1390 struct tree_entry
*e
= new_tree_entry();
1392 if (t
->entry_count
== t
->entry_capacity
)
1393 root
->tree
= t
= grow_tree_content(t
, t
->entry_count
);
1394 t
->entries
[t
->entry_count
++] = e
;
1397 c
= get_mode(c
, &e
->versions
[1].mode
);
1399 die("Corrupt mode in %s", sha1_to_hex(sha1
));
1400 e
->versions
[0].mode
= e
->versions
[1].mode
;
1401 e
->name
= to_atom(c
, strlen(c
));
1402 c
+= e
->name
->str_len
+ 1;
1403 hashcpy(e
->versions
[0].sha1
, (unsigned char *)c
);
1404 hashcpy(e
->versions
[1].sha1
, (unsigned char *)c
);
1410 static int tecmp0 (const void *_a
, const void *_b
)
1412 struct tree_entry
*a
= *((struct tree_entry
**)_a
);
1413 struct tree_entry
*b
= *((struct tree_entry
**)_b
);
1414 return base_name_compare(
1415 a
->name
->str_dat
, a
->name
->str_len
, a
->versions
[0].mode
,
1416 b
->name
->str_dat
, b
->name
->str_len
, b
->versions
[0].mode
);
1419 static int tecmp1 (const void *_a
, const void *_b
)
1421 struct tree_entry
*a
= *((struct tree_entry
**)_a
);
1422 struct tree_entry
*b
= *((struct tree_entry
**)_b
);
1423 return base_name_compare(
1424 a
->name
->str_dat
, a
->name
->str_len
, a
->versions
[1].mode
,
1425 b
->name
->str_dat
, b
->name
->str_len
, b
->versions
[1].mode
);
1428 static void mktree(struct tree_content
*t
, int v
, struct strbuf
*b
)
1434 qsort(t
->entries
,t
->entry_count
,sizeof(t
->entries
[0]),tecmp0
);
1436 qsort(t
->entries
,t
->entry_count
,sizeof(t
->entries
[0]),tecmp1
);
1438 for (i
= 0; i
< t
->entry_count
; i
++) {
1439 if (t
->entries
[i
]->versions
[v
].mode
)
1440 maxlen
+= t
->entries
[i
]->name
->str_len
+ 34;
1444 strbuf_grow(b
, maxlen
);
1445 for (i
= 0; i
< t
->entry_count
; i
++) {
1446 struct tree_entry
*e
= t
->entries
[i
];
1447 if (!e
->versions
[v
].mode
)
1449 strbuf_addf(b
, "%o %s%c",
1450 (unsigned int)(e
->versions
[v
].mode
& ~NO_DELTA
),
1451 e
->name
->str_dat
, '\0');
1452 strbuf_add(b
, e
->versions
[v
].sha1
, 20);
1456 static void store_tree(struct tree_entry
*root
)
1458 struct tree_content
*t
;
1459 unsigned int i
, j
, del
;
1460 struct last_object lo
= { STRBUF_INIT
, 0, 0, /* no_swap */ 1 };
1461 struct object_entry
*le
= NULL
;
1463 if (!is_null_sha1(root
->versions
[1].sha1
))
1470 for (i
= 0; i
< t
->entry_count
; i
++) {
1471 if (t
->entries
[i
]->tree
)
1472 store_tree(t
->entries
[i
]);
1475 if (!(root
->versions
[0].mode
& NO_DELTA
))
1476 le
= find_object(root
->versions
[0].sha1
);
1477 if (S_ISDIR(root
->versions
[0].mode
) && le
&& le
->pack_id
== pack_id
) {
1478 mktree(t
, 0, &old_tree
);
1480 lo
.offset
= le
->idx
.offset
;
1481 lo
.depth
= t
->delta_depth
;
1484 mktree(t
, 1, &new_tree
);
1485 store_object(OBJ_TREE
, &new_tree
, &lo
, root
->versions
[1].sha1
, 0);
1487 t
->delta_depth
= lo
.depth
;
1488 for (i
= 0, j
= 0, del
= 0; i
< t
->entry_count
; i
++) {
1489 struct tree_entry
*e
= t
->entries
[i
];
1490 if (e
->versions
[1].mode
) {
1491 e
->versions
[0].mode
= e
->versions
[1].mode
;
1492 hashcpy(e
->versions
[0].sha1
, e
->versions
[1].sha1
);
1493 t
->entries
[j
++] = e
;
1495 release_tree_entry(e
);
1499 t
->entry_count
-= del
;
1502 static void tree_content_replace(
1503 struct tree_entry
*root
,
1504 const unsigned char *sha1
,
1505 const uint16_t mode
,
1506 struct tree_content
*newtree
)
1509 die("Root cannot be a non-directory");
1510 hashclr(root
->versions
[0].sha1
);
1511 hashcpy(root
->versions
[1].sha1
, sha1
);
1513 release_tree_content_recursive(root
->tree
);
1514 root
->tree
= newtree
;
1517 static int tree_content_set(
1518 struct tree_entry
*root
,
1520 const unsigned char *sha1
,
1521 const uint16_t mode
,
1522 struct tree_content
*subtree
)
1524 struct tree_content
*t
;
1527 struct tree_entry
*e
;
1529 slash1
= strchrnul(p
, '/');
1532 die("Empty path component found in input");
1533 if (!*slash1
&& !S_ISDIR(mode
) && subtree
)
1534 die("Non-directories cannot have subtrees");
1539 for (i
= 0; i
< t
->entry_count
; i
++) {
1541 if (e
->name
->str_len
== n
&& !strncmp_icase(p
, e
->name
->str_dat
, n
)) {
1544 && e
->versions
[1].mode
== mode
1545 && !hashcmp(e
->versions
[1].sha1
, sha1
))
1547 e
->versions
[1].mode
= mode
;
1548 hashcpy(e
->versions
[1].sha1
, sha1
);
1550 release_tree_content_recursive(e
->tree
);
1554 * We need to leave e->versions[0].sha1 alone
1555 * to avoid modifying the preimage tree used
1556 * when writing out the parent directory.
1557 * But after replacing the subdir with a
1558 * completely different one, it's not a good
1559 * delta base any more, and besides, we've
1560 * thrown away the tree entries needed to
1561 * make a delta against it.
1563 * So let's just explicitly disable deltas
1566 if (S_ISDIR(e
->versions
[0].mode
))
1567 e
->versions
[0].mode
|= NO_DELTA
;
1569 hashclr(root
->versions
[1].sha1
);
1572 if (!S_ISDIR(e
->versions
[1].mode
)) {
1573 e
->tree
= new_tree_content(8);
1574 e
->versions
[1].mode
= S_IFDIR
;
1578 if (tree_content_set(e
, slash1
+ 1, sha1
, mode
, subtree
)) {
1579 hashclr(root
->versions
[1].sha1
);
1586 if (t
->entry_count
== t
->entry_capacity
)
1587 root
->tree
= t
= grow_tree_content(t
, t
->entry_count
);
1588 e
= new_tree_entry();
1589 e
->name
= to_atom(p
, n
);
1590 e
->versions
[0].mode
= 0;
1591 hashclr(e
->versions
[0].sha1
);
1592 t
->entries
[t
->entry_count
++] = e
;
1594 e
->tree
= new_tree_content(8);
1595 e
->versions
[1].mode
= S_IFDIR
;
1596 tree_content_set(e
, slash1
+ 1, sha1
, mode
, subtree
);
1599 e
->versions
[1].mode
= mode
;
1600 hashcpy(e
->versions
[1].sha1
, sha1
);
1602 hashclr(root
->versions
[1].sha1
);
1606 static int tree_content_remove(
1607 struct tree_entry
*root
,
1609 struct tree_entry
*backup_leaf
,
1612 struct tree_content
*t
;
1615 struct tree_entry
*e
;
1617 slash1
= strchrnul(p
, '/');
1623 if (!*p
&& allow_root
) {
1629 for (i
= 0; i
< t
->entry_count
; i
++) {
1631 if (e
->name
->str_len
== n
&& !strncmp_icase(p
, e
->name
->str_dat
, n
)) {
1632 if (*slash1
&& !S_ISDIR(e
->versions
[1].mode
))
1634 * If p names a file in some subdirectory, and a
1635 * file or symlink matching the name of the
1636 * parent directory of p exists, then p cannot
1637 * exist and need not be deleted.
1640 if (!*slash1
|| !S_ISDIR(e
->versions
[1].mode
))
1644 if (tree_content_remove(e
, slash1
+ 1, backup_leaf
, 0)) {
1645 for (n
= 0; n
< e
->tree
->entry_count
; n
++) {
1646 if (e
->tree
->entries
[n
]->versions
[1].mode
) {
1647 hashclr(root
->versions
[1].sha1
);
1661 memcpy(backup_leaf
, e
, sizeof(*backup_leaf
));
1663 release_tree_content_recursive(e
->tree
);
1665 e
->versions
[1].mode
= 0;
1666 hashclr(e
->versions
[1].sha1
);
1667 hashclr(root
->versions
[1].sha1
);
1671 static int tree_content_get(
1672 struct tree_entry
*root
,
1674 struct tree_entry
*leaf
,
1677 struct tree_content
*t
;
1680 struct tree_entry
*e
;
1682 slash1
= strchrnul(p
, '/');
1684 if (!n
&& !allow_root
)
1685 die("Empty path component found in input");
1696 for (i
= 0; i
< t
->entry_count
; i
++) {
1698 if (e
->name
->str_len
== n
&& !strncmp_icase(p
, e
->name
->str_dat
, n
)) {
1701 if (!S_ISDIR(e
->versions
[1].mode
))
1705 return tree_content_get(e
, slash1
+ 1, leaf
, 0);
1711 memcpy(leaf
, e
, sizeof(*leaf
));
1712 if (e
->tree
&& is_null_sha1(e
->versions
[1].sha1
))
1713 leaf
->tree
= dup_tree_content(e
->tree
);
1719 static int update_branch(struct branch
*b
)
1721 static const char *msg
= "fast-import";
1722 struct ref_transaction
*transaction
;
1723 unsigned char old_sha1
[20];
1724 struct strbuf err
= STRBUF_INIT
;
1726 if (is_null_sha1(b
->sha1
)) {
1728 delete_ref(b
->name
, NULL
, 0);
1731 if (read_ref(b
->name
, old_sha1
))
1733 if (!force_update
&& !is_null_sha1(old_sha1
)) {
1734 struct commit
*old_cmit
, *new_cmit
;
1736 old_cmit
= lookup_commit_reference_gently(old_sha1
, 0);
1737 new_cmit
= lookup_commit_reference_gently(b
->sha1
, 0);
1738 if (!old_cmit
|| !new_cmit
)
1739 return error("Branch %s is missing commits.", b
->name
);
1741 if (!in_merge_bases(old_cmit
, new_cmit
)) {
1742 warning("Not updating %s"
1743 " (new tip %s does not contain %s)",
1744 b
->name
, sha1_to_hex(b
->sha1
), sha1_to_hex(old_sha1
));
1748 transaction
= ref_transaction_begin(&err
);
1750 ref_transaction_update(transaction
, b
->name
, b
->sha1
, old_sha1
,
1752 ref_transaction_commit(transaction
, &err
)) {
1753 ref_transaction_free(transaction
);
1754 error("%s", err
.buf
);
1755 strbuf_release(&err
);
1758 ref_transaction_free(transaction
);
1759 strbuf_release(&err
);
1763 static void dump_branches(void)
1768 for (i
= 0; i
< branch_table_sz
; i
++) {
1769 for (b
= branch_table
[i
]; b
; b
= b
->table_next_branch
)
1770 failure
|= update_branch(b
);
1774 static void dump_tags(void)
1776 static const char *msg
= "fast-import";
1778 struct strbuf ref_name
= STRBUF_INIT
;
1779 struct strbuf err
= STRBUF_INIT
;
1780 struct ref_transaction
*transaction
;
1782 transaction
= ref_transaction_begin(&err
);
1784 failure
|= error("%s", err
.buf
);
1787 for (t
= first_tag
; t
; t
= t
->next_tag
) {
1788 strbuf_reset(&ref_name
);
1789 strbuf_addf(&ref_name
, "refs/tags/%s", t
->name
);
1791 if (ref_transaction_update(transaction
, ref_name
.buf
,
1792 t
->sha1
, NULL
, 0, msg
, &err
)) {
1793 failure
|= error("%s", err
.buf
);
1797 if (ref_transaction_commit(transaction
, &err
))
1798 failure
|= error("%s", err
.buf
);
1801 ref_transaction_free(transaction
);
1802 strbuf_release(&ref_name
);
1803 strbuf_release(&err
);
1806 static void dump_marks_helper(FILE *f
,
1812 for (k
= 0; k
< 1024; k
++) {
1813 if (m
->data
.sets
[k
])
1814 dump_marks_helper(f
, base
+ (k
<< m
->shift
),
1818 for (k
= 0; k
< 1024; k
++) {
1819 if (m
->data
.marked
[k
])
1820 fprintf(f
, ":%" PRIuMAX
" %s\n", base
+ k
,
1821 sha1_to_hex(m
->data
.marked
[k
]->idx
.sha1
));
1826 static void dump_marks(void)
1828 static struct lock_file mark_lock
;
1831 if (!export_marks_file
)
1834 if (hold_lock_file_for_update(&mark_lock
, export_marks_file
, 0) < 0) {
1835 failure
|= error("Unable to write marks file %s: %s",
1836 export_marks_file
, strerror(errno
));
1840 f
= fdopen_lock_file(&mark_lock
, "w");
1842 int saved_errno
= errno
;
1843 rollback_lock_file(&mark_lock
);
1844 failure
|= error("Unable to write marks file %s: %s",
1845 export_marks_file
, strerror(saved_errno
));
1849 dump_marks_helper(f
, 0, marks
);
1850 if (commit_lock_file(&mark_lock
)) {
1851 failure
|= error("Unable to write file %s: %s",
1852 export_marks_file
, strerror(errno
));
1857 static void read_marks(void)
1860 FILE *f
= fopen(import_marks_file
, "r");
1863 else if (import_marks_file_ignore_missing
&& errno
== ENOENT
)
1864 return; /* Marks file does not exist */
1866 die_errno("cannot read '%s'", import_marks_file
);
1867 while (fgets(line
, sizeof(line
), f
)) {
1870 unsigned char sha1
[20];
1871 struct object_entry
*e
;
1873 end
= strchr(line
, '\n');
1874 if (line
[0] != ':' || !end
)
1875 die("corrupt mark line: %s", line
);
1877 mark
= strtoumax(line
+ 1, &end
, 10);
1878 if (!mark
|| end
== line
+ 1
1879 || *end
!= ' ' || get_sha1_hex(end
+ 1, sha1
))
1880 die("corrupt mark line: %s", line
);
1881 e
= find_object(sha1
);
1883 enum object_type type
= sha1_object_info(sha1
, NULL
);
1885 die("object not found: %s", sha1_to_hex(sha1
));
1886 e
= insert_object(sha1
);
1888 e
->pack_id
= MAX_PACK_ID
;
1889 e
->idx
.offset
= 1; /* just not zero! */
1891 insert_mark(mark
, e
);
1897 static int read_next_command(void)
1899 static int stdin_eof
= 0;
1902 unread_command_buf
= 0;
1909 if (unread_command_buf
) {
1910 unread_command_buf
= 0;
1912 struct recent_command
*rc
;
1914 strbuf_detach(&command_buf
, NULL
);
1915 stdin_eof
= strbuf_getline_lf(&command_buf
, stdin
);
1919 if (!seen_data_command
1920 && !starts_with(command_buf
.buf
, "feature ")
1921 && !starts_with(command_buf
.buf
, "option ")) {
1930 cmd_hist
.next
= rc
->next
;
1931 cmd_hist
.next
->prev
= &cmd_hist
;
1935 rc
->buf
= command_buf
.buf
;
1936 rc
->prev
= cmd_tail
;
1937 rc
->next
= cmd_hist
.prev
;
1938 rc
->prev
->next
= rc
;
1941 if (skip_prefix(command_buf
.buf
, "get-mark ", &p
)) {
1945 if (skip_prefix(command_buf
.buf
, "cat-blob ", &p
)) {
1949 if (command_buf
.buf
[0] == '#')
1955 static void skip_optional_lf(void)
1957 int term_char
= fgetc(stdin
);
1958 if (term_char
!= '\n' && term_char
!= EOF
)
1959 ungetc(term_char
, stdin
);
1962 static void parse_mark(void)
1965 if (skip_prefix(command_buf
.buf
, "mark :", &v
)) {
1966 next_mark
= strtoumax(v
, NULL
, 10);
1967 read_next_command();
1973 static int parse_data(struct strbuf
*sb
, uintmax_t limit
, uintmax_t *len_res
)
1978 if (!skip_prefix(command_buf
.buf
, "data ", &data
))
1979 die("Expected 'data n' command, found: %s", command_buf
.buf
);
1981 if (skip_prefix(data
, "<<", &data
)) {
1982 char *term
= xstrdup(data
);
1983 size_t term_len
= command_buf
.len
- (data
- command_buf
.buf
);
1985 strbuf_detach(&command_buf
, NULL
);
1987 if (strbuf_getline_lf(&command_buf
, stdin
) == EOF
)
1988 die("EOF in data (terminator '%s' not found)", term
);
1989 if (term_len
== command_buf
.len
1990 && !strcmp(term
, command_buf
.buf
))
1992 strbuf_addbuf(sb
, &command_buf
);
1993 strbuf_addch(sb
, '\n');
1998 uintmax_t len
= strtoumax(data
, NULL
, 10);
1999 size_t n
= 0, length
= (size_t)len
;
2001 if (limit
&& limit
< len
) {
2006 die("data is too large to use in this context");
2008 while (n
< length
) {
2009 size_t s
= strbuf_fread(sb
, length
- n
, stdin
);
2010 if (!s
&& feof(stdin
))
2011 die("EOF in data (%lu bytes remaining)",
2012 (unsigned long)(length
- n
));
2021 static int validate_raw_date(const char *src
, struct strbuf
*result
)
2023 const char *orig_src
= src
;
2029 num
= strtoul(src
, &endp
, 10);
2030 /* NEEDSWORK: perhaps check for reasonable values? */
2031 if (errno
|| endp
== src
|| *endp
!= ' ')
2035 if (*src
!= '-' && *src
!= '+')
2038 num
= strtoul(src
+ 1, &endp
, 10);
2039 if (errno
|| endp
== src
+ 1 || *endp
|| 1400 < num
)
2042 strbuf_addstr(result
, orig_src
);
2046 static char *parse_ident(const char *buf
)
2050 struct strbuf ident
= STRBUF_INIT
;
2052 /* ensure there is a space delimiter even if there is no name */
2056 ltgt
= buf
+ strcspn(buf
, "<>");
2058 die("Missing < in ident string: %s", buf
);
2059 if (ltgt
!= buf
&& ltgt
[-1] != ' ')
2060 die("Missing space before < in ident string: %s", buf
);
2061 ltgt
= ltgt
+ 1 + strcspn(ltgt
+ 1, "<>");
2063 die("Missing > in ident string: %s", buf
);
2066 die("Missing space after > in ident string: %s", buf
);
2068 name_len
= ltgt
- buf
;
2069 strbuf_add(&ident
, buf
, name_len
);
2073 if (validate_raw_date(ltgt
, &ident
) < 0)
2074 die("Invalid raw date \"%s\" in ident: %s", ltgt
, buf
);
2076 case WHENSPEC_RFC2822
:
2077 if (parse_date(ltgt
, &ident
) < 0)
2078 die("Invalid rfc2822 date \"%s\" in ident: %s", ltgt
, buf
);
2081 if (strcmp("now", ltgt
))
2082 die("Date in ident must be 'now': %s", buf
);
2087 return strbuf_detach(&ident
, NULL
);
2090 static void parse_and_store_blob(
2091 struct last_object
*last
,
2092 unsigned char *sha1out
,
2095 static struct strbuf buf
= STRBUF_INIT
;
2098 if (parse_data(&buf
, big_file_threshold
, &len
))
2099 store_object(OBJ_BLOB
, &buf
, last
, sha1out
, mark
);
2102 strbuf_release(&last
->data
);
2106 stream_blob(len
, sha1out
, mark
);
2111 static void parse_new_blob(void)
2113 read_next_command();
2115 parse_and_store_blob(&last_blob
, NULL
, next_mark
);
2118 static void unload_one_branch(void)
2120 while (cur_active_branches
2121 && cur_active_branches
>= max_active_branches
) {
2122 uintmax_t min_commit
= ULONG_MAX
;
2123 struct branch
*e
, *l
= NULL
, *p
= NULL
;
2125 for (e
= active_branches
; e
; e
= e
->active_next_branch
) {
2126 if (e
->last_commit
< min_commit
) {
2128 min_commit
= e
->last_commit
;
2134 e
= p
->active_next_branch
;
2135 p
->active_next_branch
= e
->active_next_branch
;
2137 e
= active_branches
;
2138 active_branches
= e
->active_next_branch
;
2141 e
->active_next_branch
= NULL
;
2142 if (e
->branch_tree
.tree
) {
2143 release_tree_content_recursive(e
->branch_tree
.tree
);
2144 e
->branch_tree
.tree
= NULL
;
2146 cur_active_branches
--;
2150 static void load_branch(struct branch
*b
)
2152 load_tree(&b
->branch_tree
);
2155 b
->active_next_branch
= active_branches
;
2156 active_branches
= b
;
2157 cur_active_branches
++;
2158 branch_load_count
++;
2162 static unsigned char convert_num_notes_to_fanout(uintmax_t num_notes
)
2164 unsigned char fanout
= 0;
2165 while ((num_notes
>>= 8))
2170 static void construct_path_with_fanout(const char *hex_sha1
,
2171 unsigned char fanout
, char *path
)
2173 unsigned int i
= 0, j
= 0;
2175 die("Too large fanout (%u)", fanout
);
2177 path
[i
++] = hex_sha1
[j
++];
2178 path
[i
++] = hex_sha1
[j
++];
2182 memcpy(path
+ i
, hex_sha1
+ j
, 40 - j
);
2183 path
[i
+ 40 - j
] = '\0';
2186 static uintmax_t do_change_note_fanout(
2187 struct tree_entry
*orig_root
, struct tree_entry
*root
,
2188 char *hex_sha1
, unsigned int hex_sha1_len
,
2189 char *fullpath
, unsigned int fullpath_len
,
2190 unsigned char fanout
)
2192 struct tree_content
*t
= root
->tree
;
2193 struct tree_entry
*e
, leaf
;
2194 unsigned int i
, tmp_hex_sha1_len
, tmp_fullpath_len
;
2195 uintmax_t num_notes
= 0;
2196 unsigned char sha1
[20];
2199 for (i
= 0; t
&& i
< t
->entry_count
; i
++) {
2201 tmp_hex_sha1_len
= hex_sha1_len
+ e
->name
->str_len
;
2202 tmp_fullpath_len
= fullpath_len
;
2205 * We're interested in EITHER existing note entries (entries
2206 * with exactly 40 hex chars in path, not including directory
2207 * separators), OR directory entries that may contain note
2208 * entries (with < 40 hex chars in path).
2209 * Also, each path component in a note entry must be a multiple
2212 if (!e
->versions
[1].mode
||
2213 tmp_hex_sha1_len
> 40 ||
2214 e
->name
->str_len
% 2)
2217 /* This _may_ be a note entry, or a subdir containing notes */
2218 memcpy(hex_sha1
+ hex_sha1_len
, e
->name
->str_dat
,
2220 if (tmp_fullpath_len
)
2221 fullpath
[tmp_fullpath_len
++] = '/';
2222 memcpy(fullpath
+ tmp_fullpath_len
, e
->name
->str_dat
,
2224 tmp_fullpath_len
+= e
->name
->str_len
;
2225 fullpath
[tmp_fullpath_len
] = '\0';
2227 if (tmp_hex_sha1_len
== 40 && !get_sha1_hex(hex_sha1
, sha1
)) {
2228 /* This is a note entry */
2229 if (fanout
== 0xff) {
2230 /* Counting mode, no rename */
2234 construct_path_with_fanout(hex_sha1
, fanout
, realpath
);
2235 if (!strcmp(fullpath
, realpath
)) {
2236 /* Note entry is in correct location */
2241 /* Rename fullpath to realpath */
2242 if (!tree_content_remove(orig_root
, fullpath
, &leaf
, 0))
2243 die("Failed to remove path %s", fullpath
);
2244 tree_content_set(orig_root
, realpath
,
2245 leaf
.versions
[1].sha1
,
2246 leaf
.versions
[1].mode
,
2248 } else if (S_ISDIR(e
->versions
[1].mode
)) {
2249 /* This is a subdir that may contain note entries */
2252 num_notes
+= do_change_note_fanout(orig_root
, e
,
2253 hex_sha1
, tmp_hex_sha1_len
,
2254 fullpath
, tmp_fullpath_len
, fanout
);
2257 /* The above may have reallocated the current tree_content */
2263 static uintmax_t change_note_fanout(struct tree_entry
*root
,
2264 unsigned char fanout
)
2266 char hex_sha1
[40], path
[60];
2267 return do_change_note_fanout(root
, root
, hex_sha1
, 0, path
, 0, fanout
);
2271 * Given a pointer into a string, parse a mark reference:
2273 * idnum ::= ':' bigint;
2275 * Return the first character after the value in *endptr.
2277 * Complain if the following character is not what is expected,
2278 * either a space or end of the string.
2280 static uintmax_t parse_mark_ref(const char *p
, char **endptr
)
2286 mark
= strtoumax(p
, endptr
, 10);
2288 die("No value after ':' in mark: %s", command_buf
.buf
);
2293 * Parse the mark reference, and complain if this is not the end of
2296 static uintmax_t parse_mark_ref_eol(const char *p
)
2301 mark
= parse_mark_ref(p
, &end
);
2303 die("Garbage after mark: %s", command_buf
.buf
);
2308 * Parse the mark reference, demanding a trailing space. Return a
2309 * pointer to the space.
2311 static uintmax_t parse_mark_ref_space(const char **p
)
2316 mark
= parse_mark_ref(*p
, &end
);
2318 die("Missing space after mark: %s", command_buf
.buf
);
2323 static void file_change_m(const char *p
, struct branch
*b
)
2325 static struct strbuf uq
= STRBUF_INIT
;
2327 struct object_entry
*oe
;
2328 unsigned char sha1
[20];
2329 uint16_t mode
, inline_data
= 0;
2331 p
= get_mode(p
, &mode
);
2333 die("Corrupt mode: %s", command_buf
.buf
);
2338 case S_IFREG
| 0644:
2339 case S_IFREG
| 0755:
2346 die("Corrupt mode: %s", command_buf
.buf
);
2350 oe
= find_mark(parse_mark_ref_space(&p
));
2351 hashcpy(sha1
, oe
->idx
.sha1
);
2352 } else if (skip_prefix(p
, "inline ", &p
)) {
2354 oe
= NULL
; /* not used with inline_data, but makes gcc happy */
2356 if (get_sha1_hex(p
, sha1
))
2357 die("Invalid dataref: %s", command_buf
.buf
);
2358 oe
= find_object(sha1
);
2361 die("Missing space after SHA1: %s", command_buf
.buf
);
2365 if (!unquote_c_style(&uq
, p
, &endp
)) {
2367 die("Garbage after path in: %s", command_buf
.buf
);
2371 /* Git does not track empty, non-toplevel directories. */
2372 if (S_ISDIR(mode
) && !hashcmp(sha1
, EMPTY_TREE_SHA1_BIN
) && *p
) {
2373 tree_content_remove(&b
->branch_tree
, p
, NULL
, 0);
2377 if (S_ISGITLINK(mode
)) {
2379 die("Git links cannot be specified 'inline': %s",
2382 if (oe
->type
!= OBJ_COMMIT
)
2383 die("Not a commit (actually a %s): %s",
2384 typename(oe
->type
), command_buf
.buf
);
2387 * Accept the sha1 without checking; it expected to be in
2388 * another repository.
2390 } else if (inline_data
) {
2392 die("Directories cannot be specified 'inline': %s",
2395 strbuf_addstr(&uq
, p
);
2398 read_next_command();
2399 parse_and_store_blob(&last_blob
, sha1
, 0);
2401 enum object_type expected
= S_ISDIR(mode
) ?
2403 enum object_type type
= oe
? oe
->type
:
2404 sha1_object_info(sha1
, NULL
);
2406 die("%s not found: %s",
2407 S_ISDIR(mode
) ? "Tree" : "Blob",
2409 if (type
!= expected
)
2410 die("Not a %s (actually a %s): %s",
2411 typename(expected
), typename(type
),
2416 tree_content_replace(&b
->branch_tree
, sha1
, mode
, NULL
);
2419 tree_content_set(&b
->branch_tree
, p
, sha1
, mode
, NULL
);
2422 static void file_change_d(const char *p
, struct branch
*b
)
2424 static struct strbuf uq
= STRBUF_INIT
;
2428 if (!unquote_c_style(&uq
, p
, &endp
)) {
2430 die("Garbage after path in: %s", command_buf
.buf
);
2433 tree_content_remove(&b
->branch_tree
, p
, NULL
, 1);
2436 static void file_change_cr(const char *s
, struct branch
*b
, int rename
)
2439 static struct strbuf s_uq
= STRBUF_INIT
;
2440 static struct strbuf d_uq
= STRBUF_INIT
;
2442 struct tree_entry leaf
;
2444 strbuf_reset(&s_uq
);
2445 if (!unquote_c_style(&s_uq
, s
, &endp
)) {
2447 die("Missing space after source: %s", command_buf
.buf
);
2449 endp
= strchr(s
, ' ');
2451 die("Missing space after source: %s", command_buf
.buf
);
2452 strbuf_add(&s_uq
, s
, endp
- s
);
2458 die("Missing dest: %s", command_buf
.buf
);
2461 strbuf_reset(&d_uq
);
2462 if (!unquote_c_style(&d_uq
, d
, &endp
)) {
2464 die("Garbage after dest in: %s", command_buf
.buf
);
2468 memset(&leaf
, 0, sizeof(leaf
));
2470 tree_content_remove(&b
->branch_tree
, s
, &leaf
, 1);
2472 tree_content_get(&b
->branch_tree
, s
, &leaf
, 1);
2473 if (!leaf
.versions
[1].mode
)
2474 die("Path %s not in branch", s
);
2475 if (!*d
) { /* C "path/to/subdir" "" */
2476 tree_content_replace(&b
->branch_tree
,
2477 leaf
.versions
[1].sha1
,
2478 leaf
.versions
[1].mode
,
2482 tree_content_set(&b
->branch_tree
, d
,
2483 leaf
.versions
[1].sha1
,
2484 leaf
.versions
[1].mode
,
2488 static void note_change_n(const char *p
, struct branch
*b
, unsigned char *old_fanout
)
2490 static struct strbuf uq
= STRBUF_INIT
;
2491 struct object_entry
*oe
;
2493 unsigned char sha1
[20], commit_sha1
[20];
2495 uint16_t inline_data
= 0;
2496 unsigned char new_fanout
;
2499 * When loading a branch, we don't traverse its tree to count the real
2500 * number of notes (too expensive to do this for all non-note refs).
2501 * This means that recently loaded notes refs might incorrectly have
2502 * b->num_notes == 0, and consequently, old_fanout might be wrong.
2504 * Fix this by traversing the tree and counting the number of notes
2505 * when b->num_notes == 0. If the notes tree is truly empty, the
2506 * calculation should not take long.
2508 if (b
->num_notes
== 0 && *old_fanout
== 0) {
2509 /* Invoke change_note_fanout() in "counting mode". */
2510 b
->num_notes
= change_note_fanout(&b
->branch_tree
, 0xff);
2511 *old_fanout
= convert_num_notes_to_fanout(b
->num_notes
);
2514 /* Now parse the notemodify command. */
2515 /* <dataref> or 'inline' */
2517 oe
= find_mark(parse_mark_ref_space(&p
));
2518 hashcpy(sha1
, oe
->idx
.sha1
);
2519 } else if (skip_prefix(p
, "inline ", &p
)) {
2521 oe
= NULL
; /* not used with inline_data, but makes gcc happy */
2523 if (get_sha1_hex(p
, sha1
))
2524 die("Invalid dataref: %s", command_buf
.buf
);
2525 oe
= find_object(sha1
);
2528 die("Missing space after SHA1: %s", command_buf
.buf
);
2532 s
= lookup_branch(p
);
2534 if (is_null_sha1(s
->sha1
))
2535 die("Can't add a note on empty branch.");
2536 hashcpy(commit_sha1
, s
->sha1
);
2537 } else if (*p
== ':') {
2538 uintmax_t commit_mark
= parse_mark_ref_eol(p
);
2539 struct object_entry
*commit_oe
= find_mark(commit_mark
);
2540 if (commit_oe
->type
!= OBJ_COMMIT
)
2541 die("Mark :%" PRIuMAX
" not a commit", commit_mark
);
2542 hashcpy(commit_sha1
, commit_oe
->idx
.sha1
);
2543 } else if (!get_sha1(p
, commit_sha1
)) {
2545 char *buf
= read_object_with_reference(commit_sha1
,
2546 commit_type
, &size
, commit_sha1
);
2547 if (!buf
|| size
< 46)
2548 die("Not a valid commit: %s", p
);
2551 die("Invalid ref name or SHA1 expression: %s", p
);
2555 strbuf_addstr(&uq
, p
);
2558 read_next_command();
2559 parse_and_store_blob(&last_blob
, sha1
, 0);
2561 if (oe
->type
!= OBJ_BLOB
)
2562 die("Not a blob (actually a %s): %s",
2563 typename(oe
->type
), command_buf
.buf
);
2564 } else if (!is_null_sha1(sha1
)) {
2565 enum object_type type
= sha1_object_info(sha1
, NULL
);
2567 die("Blob not found: %s", command_buf
.buf
);
2568 if (type
!= OBJ_BLOB
)
2569 die("Not a blob (actually a %s): %s",
2570 typename(type
), command_buf
.buf
);
2573 construct_path_with_fanout(sha1_to_hex(commit_sha1
), *old_fanout
, path
);
2574 if (tree_content_remove(&b
->branch_tree
, path
, NULL
, 0))
2577 if (is_null_sha1(sha1
))
2578 return; /* nothing to insert */
2581 new_fanout
= convert_num_notes_to_fanout(b
->num_notes
);
2582 construct_path_with_fanout(sha1_to_hex(commit_sha1
), new_fanout
, path
);
2583 tree_content_set(&b
->branch_tree
, path
, sha1
, S_IFREG
| 0644, NULL
);
2586 static void file_change_deleteall(struct branch
*b
)
2588 release_tree_content_recursive(b
->branch_tree
.tree
);
2589 hashclr(b
->branch_tree
.versions
[0].sha1
);
2590 hashclr(b
->branch_tree
.versions
[1].sha1
);
2591 load_tree(&b
->branch_tree
);
2595 static void parse_from_commit(struct branch
*b
, char *buf
, unsigned long size
)
2597 if (!buf
|| size
< 46)
2598 die("Not a valid commit: %s", sha1_to_hex(b
->sha1
));
2599 if (memcmp("tree ", buf
, 5)
2600 || get_sha1_hex(buf
+ 5, b
->branch_tree
.versions
[1].sha1
))
2601 die("The commit %s is corrupt", sha1_to_hex(b
->sha1
));
2602 hashcpy(b
->branch_tree
.versions
[0].sha1
,
2603 b
->branch_tree
.versions
[1].sha1
);
2606 static void parse_from_existing(struct branch
*b
)
2608 if (is_null_sha1(b
->sha1
)) {
2609 hashclr(b
->branch_tree
.versions
[0].sha1
);
2610 hashclr(b
->branch_tree
.versions
[1].sha1
);
2615 buf
= read_object_with_reference(b
->sha1
,
2616 commit_type
, &size
, b
->sha1
);
2617 parse_from_commit(b
, buf
, size
);
2622 static int parse_from(struct branch
*b
)
2626 unsigned char sha1
[20];
2628 if (!skip_prefix(command_buf
.buf
, "from ", &from
))
2631 hashcpy(sha1
, b
->branch_tree
.versions
[1].sha1
);
2633 s
= lookup_branch(from
);
2635 die("Can't create a branch from itself: %s", b
->name
);
2637 unsigned char *t
= s
->branch_tree
.versions
[1].sha1
;
2638 hashcpy(b
->sha1
, s
->sha1
);
2639 hashcpy(b
->branch_tree
.versions
[0].sha1
, t
);
2640 hashcpy(b
->branch_tree
.versions
[1].sha1
, t
);
2641 } else if (*from
== ':') {
2642 uintmax_t idnum
= parse_mark_ref_eol(from
);
2643 struct object_entry
*oe
= find_mark(idnum
);
2644 if (oe
->type
!= OBJ_COMMIT
)
2645 die("Mark :%" PRIuMAX
" not a commit", idnum
);
2646 if (hashcmp(b
->sha1
, oe
->idx
.sha1
)) {
2647 hashcpy(b
->sha1
, oe
->idx
.sha1
);
2648 if (oe
->pack_id
!= MAX_PACK_ID
) {
2650 char *buf
= gfi_unpack_entry(oe
, &size
);
2651 parse_from_commit(b
, buf
, size
);
2654 parse_from_existing(b
);
2656 } else if (!get_sha1(from
, b
->sha1
)) {
2657 parse_from_existing(b
);
2658 if (is_null_sha1(b
->sha1
))
2662 die("Invalid ref name or SHA1 expression: %s", from
);
2664 if (b
->branch_tree
.tree
&& hashcmp(sha1
, b
->branch_tree
.versions
[1].sha1
)) {
2665 release_tree_content_recursive(b
->branch_tree
.tree
);
2666 b
->branch_tree
.tree
= NULL
;
2669 read_next_command();
2673 static struct hash_list
*parse_merge(unsigned int *count
)
2675 struct hash_list
*list
= NULL
, **tail
= &list
, *n
;
2680 while (skip_prefix(command_buf
.buf
, "merge ", &from
)) {
2681 n
= xmalloc(sizeof(*n
));
2682 s
= lookup_branch(from
);
2684 hashcpy(n
->sha1
, s
->sha1
);
2685 else if (*from
== ':') {
2686 uintmax_t idnum
= parse_mark_ref_eol(from
);
2687 struct object_entry
*oe
= find_mark(idnum
);
2688 if (oe
->type
!= OBJ_COMMIT
)
2689 die("Mark :%" PRIuMAX
" not a commit", idnum
);
2690 hashcpy(n
->sha1
, oe
->idx
.sha1
);
2691 } else if (!get_sha1(from
, n
->sha1
)) {
2693 char *buf
= read_object_with_reference(n
->sha1
,
2694 commit_type
, &size
, n
->sha1
);
2695 if (!buf
|| size
< 46)
2696 die("Not a valid commit: %s", from
);
2699 die("Invalid ref name or SHA1 expression: %s", from
);
2706 read_next_command();
2711 static void parse_new_commit(const char *arg
)
2713 static struct strbuf msg
= STRBUF_INIT
;
2715 char *author
= NULL
;
2716 char *committer
= NULL
;
2717 struct hash_list
*merge_list
= NULL
;
2718 unsigned int merge_count
;
2719 unsigned char prev_fanout
, new_fanout
;
2722 b
= lookup_branch(arg
);
2724 b
= new_branch(arg
);
2726 read_next_command();
2728 if (skip_prefix(command_buf
.buf
, "author ", &v
)) {
2729 author
= parse_ident(v
);
2730 read_next_command();
2732 if (skip_prefix(command_buf
.buf
, "committer ", &v
)) {
2733 committer
= parse_ident(v
);
2734 read_next_command();
2737 die("Expected committer but didn't get one");
2738 parse_data(&msg
, 0, NULL
);
2739 read_next_command();
2741 merge_list
= parse_merge(&merge_count
);
2743 /* ensure the branch is active/loaded */
2744 if (!b
->branch_tree
.tree
|| !max_active_branches
) {
2745 unload_one_branch();
2749 prev_fanout
= convert_num_notes_to_fanout(b
->num_notes
);
2752 while (command_buf
.len
> 0) {
2753 if (skip_prefix(command_buf
.buf
, "M ", &v
))
2754 file_change_m(v
, b
);
2755 else if (skip_prefix(command_buf
.buf
, "D ", &v
))
2756 file_change_d(v
, b
);
2757 else if (skip_prefix(command_buf
.buf
, "R ", &v
))
2758 file_change_cr(v
, b
, 1);
2759 else if (skip_prefix(command_buf
.buf
, "C ", &v
))
2760 file_change_cr(v
, b
, 0);
2761 else if (skip_prefix(command_buf
.buf
, "N ", &v
))
2762 note_change_n(v
, b
, &prev_fanout
);
2763 else if (!strcmp("deleteall", command_buf
.buf
))
2764 file_change_deleteall(b
);
2765 else if (skip_prefix(command_buf
.buf
, "ls ", &v
))
2768 unread_command_buf
= 1;
2771 if (read_next_command() == EOF
)
2775 new_fanout
= convert_num_notes_to_fanout(b
->num_notes
);
2776 if (new_fanout
!= prev_fanout
)
2777 b
->num_notes
= change_note_fanout(&b
->branch_tree
, new_fanout
);
2779 /* build the tree and the commit */
2780 store_tree(&b
->branch_tree
);
2781 hashcpy(b
->branch_tree
.versions
[0].sha1
,
2782 b
->branch_tree
.versions
[1].sha1
);
2784 strbuf_reset(&new_data
);
2785 strbuf_addf(&new_data
, "tree %s\n",
2786 sha1_to_hex(b
->branch_tree
.versions
[1].sha1
));
2787 if (!is_null_sha1(b
->sha1
))
2788 strbuf_addf(&new_data
, "parent %s\n", sha1_to_hex(b
->sha1
));
2789 while (merge_list
) {
2790 struct hash_list
*next
= merge_list
->next
;
2791 strbuf_addf(&new_data
, "parent %s\n", sha1_to_hex(merge_list
->sha1
));
2795 strbuf_addf(&new_data
,
2799 author
? author
: committer
, committer
);
2800 strbuf_addbuf(&new_data
, &msg
);
2804 if (!store_object(OBJ_COMMIT
, &new_data
, NULL
, b
->sha1
, next_mark
))
2805 b
->pack_id
= pack_id
;
2806 b
->last_commit
= object_count_by_type
[OBJ_COMMIT
];
2809 static void parse_new_tag(const char *arg
)
2811 static struct strbuf msg
= STRBUF_INIT
;
2816 uintmax_t from_mark
= 0;
2817 unsigned char sha1
[20];
2818 enum object_type type
;
2821 t
= pool_alloc(sizeof(struct tag
));
2822 memset(t
, 0, sizeof(struct tag
));
2823 t
->name
= pool_strdup(arg
);
2825 last_tag
->next_tag
= t
;
2829 read_next_command();
2832 if (!skip_prefix(command_buf
.buf
, "from ", &from
))
2833 die("Expected from command, got %s", command_buf
.buf
);
2834 s
= lookup_branch(from
);
2836 if (is_null_sha1(s
->sha1
))
2837 die("Can't tag an empty branch.");
2838 hashcpy(sha1
, s
->sha1
);
2840 } else if (*from
== ':') {
2841 struct object_entry
*oe
;
2842 from_mark
= parse_mark_ref_eol(from
);
2843 oe
= find_mark(from_mark
);
2845 hashcpy(sha1
, oe
->idx
.sha1
);
2846 } else if (!get_sha1(from
, sha1
)) {
2847 struct object_entry
*oe
= find_object(sha1
);
2849 type
= sha1_object_info(sha1
, NULL
);
2851 die("Not a valid object: %s", from
);
2855 die("Invalid ref name or SHA1 expression: %s", from
);
2856 read_next_command();
2859 if (skip_prefix(command_buf
.buf
, "tagger ", &v
)) {
2860 tagger
= parse_ident(v
);
2861 read_next_command();
2865 /* tag payload/message */
2866 parse_data(&msg
, 0, NULL
);
2868 /* build the tag object */
2869 strbuf_reset(&new_data
);
2871 strbuf_addf(&new_data
,
2875 sha1_to_hex(sha1
), typename(type
), t
->name
);
2877 strbuf_addf(&new_data
,
2878 "tagger %s\n", tagger
);
2879 strbuf_addch(&new_data
, '\n');
2880 strbuf_addbuf(&new_data
, &msg
);
2883 if (store_object(OBJ_TAG
, &new_data
, NULL
, t
->sha1
, 0))
2884 t
->pack_id
= MAX_PACK_ID
;
2886 t
->pack_id
= pack_id
;
2889 static void parse_reset_branch(const char *arg
)
2893 b
= lookup_branch(arg
);
2896 hashclr(b
->branch_tree
.versions
[0].sha1
);
2897 hashclr(b
->branch_tree
.versions
[1].sha1
);
2898 if (b
->branch_tree
.tree
) {
2899 release_tree_content_recursive(b
->branch_tree
.tree
);
2900 b
->branch_tree
.tree
= NULL
;
2904 b
= new_branch(arg
);
2905 read_next_command();
2907 if (command_buf
.len
> 0)
2908 unread_command_buf
= 1;
2911 static void cat_blob_write(const char *buf
, unsigned long size
)
2913 if (write_in_full(cat_blob_fd
, buf
, size
) != size
)
2914 die_errno("Write to frontend failed");
2917 static void cat_blob(struct object_entry
*oe
, unsigned char sha1
[20])
2919 struct strbuf line
= STRBUF_INIT
;
2921 enum object_type type
= 0;
2924 if (!oe
|| oe
->pack_id
== MAX_PACK_ID
) {
2925 buf
= read_sha1_file(sha1
, &type
, &size
);
2928 buf
= gfi_unpack_entry(oe
, &size
);
2932 * Output based on batch_one_object() from cat-file.c.
2935 strbuf_reset(&line
);
2936 strbuf_addf(&line
, "%s missing\n", sha1_to_hex(sha1
));
2937 cat_blob_write(line
.buf
, line
.len
);
2938 strbuf_release(&line
);
2943 die("Can't read object %s", sha1_to_hex(sha1
));
2944 if (type
!= OBJ_BLOB
)
2945 die("Object %s is a %s but a blob was expected.",
2946 sha1_to_hex(sha1
), typename(type
));
2947 strbuf_reset(&line
);
2948 strbuf_addf(&line
, "%s %s %lu\n", sha1_to_hex(sha1
),
2949 typename(type
), size
);
2950 cat_blob_write(line
.buf
, line
.len
);
2951 strbuf_release(&line
);
2952 cat_blob_write(buf
, size
);
2953 cat_blob_write("\n", 1);
2954 if (oe
&& oe
->pack_id
== pack_id
) {
2955 last_blob
.offset
= oe
->idx
.offset
;
2956 strbuf_attach(&last_blob
.data
, buf
, size
, size
);
2957 last_blob
.depth
= oe
->depth
;
2962 static void parse_get_mark(const char *p
)
2964 struct object_entry
*oe
= oe
;
2967 /* get-mark SP <object> LF */
2969 die("Not a mark: %s", p
);
2971 oe
= find_mark(parse_mark_ref_eol(p
));
2973 die("Unknown mark: %s", command_buf
.buf
);
2975 snprintf(output
, sizeof(output
), "%s\n", sha1_to_hex(oe
->idx
.sha1
));
2976 cat_blob_write(output
, 41);
2979 static void parse_cat_blob(const char *p
)
2981 struct object_entry
*oe
= oe
;
2982 unsigned char sha1
[20];
2984 /* cat-blob SP <object> LF */
2986 oe
= find_mark(parse_mark_ref_eol(p
));
2988 die("Unknown mark: %s", command_buf
.buf
);
2989 hashcpy(sha1
, oe
->idx
.sha1
);
2991 if (get_sha1_hex(p
, sha1
))
2992 die("Invalid dataref: %s", command_buf
.buf
);
2994 die("Garbage after SHA1: %s", command_buf
.buf
);
2995 oe
= find_object(sha1
);
3001 static struct object_entry
*dereference(struct object_entry
*oe
,
3002 unsigned char sha1
[20])
3007 enum object_type type
= sha1_object_info(sha1
, NULL
);
3009 die("object not found: %s", sha1_to_hex(sha1
));
3011 oe
= insert_object(sha1
);
3013 oe
->pack_id
= MAX_PACK_ID
;
3017 case OBJ_TREE
: /* easy case. */
3023 die("Not a tree-ish: %s", command_buf
.buf
);
3026 if (oe
->pack_id
!= MAX_PACK_ID
) { /* in a pack being written */
3027 buf
= gfi_unpack_entry(oe
, &size
);
3029 enum object_type unused
;
3030 buf
= read_sha1_file(sha1
, &unused
, &size
);
3033 die("Can't load object %s", sha1_to_hex(sha1
));
3035 /* Peel one layer. */
3038 if (size
< 40 + strlen("object ") ||
3039 get_sha1_hex(buf
+ strlen("object "), sha1
))
3040 die("Invalid SHA1 in tag: %s", command_buf
.buf
);
3043 if (size
< 40 + strlen("tree ") ||
3044 get_sha1_hex(buf
+ strlen("tree "), sha1
))
3045 die("Invalid SHA1 in commit: %s", command_buf
.buf
);
3049 return find_object(sha1
);
3052 static struct object_entry
*parse_treeish_dataref(const char **p
)
3054 unsigned char sha1
[20];
3055 struct object_entry
*e
;
3057 if (**p
== ':') { /* <mark> */
3058 e
= find_mark(parse_mark_ref_space(p
));
3060 die("Unknown mark: %s", command_buf
.buf
);
3061 hashcpy(sha1
, e
->idx
.sha1
);
3062 } else { /* <sha1> */
3063 if (get_sha1_hex(*p
, sha1
))
3064 die("Invalid dataref: %s", command_buf
.buf
);
3065 e
= find_object(sha1
);
3068 die("Missing space after tree-ish: %s", command_buf
.buf
);
3071 while (!e
|| e
->type
!= OBJ_TREE
)
3072 e
= dereference(e
, sha1
);
3076 static void print_ls(int mode
, const unsigned char *sha1
, const char *path
)
3078 static struct strbuf line
= STRBUF_INIT
;
3080 /* See show_tree(). */
3082 S_ISGITLINK(mode
) ? commit_type
:
3083 S_ISDIR(mode
) ? tree_type
:
3087 /* missing SP path LF */
3088 strbuf_reset(&line
);
3089 strbuf_addstr(&line
, "missing ");
3090 quote_c_style(path
, &line
, NULL
, 0);
3091 strbuf_addch(&line
, '\n');
3093 /* mode SP type SP object_name TAB path LF */
3094 strbuf_reset(&line
);
3095 strbuf_addf(&line
, "%06o %s %s\t",
3096 mode
& ~NO_DELTA
, type
, sha1_to_hex(sha1
));
3097 quote_c_style(path
, &line
, NULL
, 0);
3098 strbuf_addch(&line
, '\n');
3100 cat_blob_write(line
.buf
, line
.len
);
3103 static void parse_ls(const char *p
, struct branch
*b
)
3105 struct tree_entry
*root
= NULL
;
3106 struct tree_entry leaf
= {NULL
};
3108 /* ls SP (<tree-ish> SP)? <path> */
3111 die("Not in a commit: %s", command_buf
.buf
);
3112 root
= &b
->branch_tree
;
3114 struct object_entry
*e
= parse_treeish_dataref(&p
);
3115 root
= new_tree_entry();
3116 hashcpy(root
->versions
[1].sha1
, e
->idx
.sha1
);
3117 if (!is_null_sha1(root
->versions
[1].sha1
))
3118 root
->versions
[1].mode
= S_IFDIR
;
3122 static struct strbuf uq
= STRBUF_INIT
;
3125 if (unquote_c_style(&uq
, p
, &endp
))
3126 die("Invalid path: %s", command_buf
.buf
);
3128 die("Garbage after path in: %s", command_buf
.buf
);
3131 tree_content_get(root
, p
, &leaf
, 1);
3133 * A directory in preparation would have a sha1 of zero
3134 * until it is saved. Save, for simplicity.
3136 if (S_ISDIR(leaf
.versions
[1].mode
))
3139 print_ls(leaf
.versions
[1].mode
, leaf
.versions
[1].sha1
, p
);
3141 release_tree_content_recursive(leaf
.tree
);
3142 if (!b
|| root
!= &b
->branch_tree
)
3143 release_tree_entry(root
);
3146 static void checkpoint(void)
3148 checkpoint_requested
= 0;
3157 static void parse_checkpoint(void)
3159 checkpoint_requested
= 1;
3163 static void parse_progress(void)
3165 fwrite(command_buf
.buf
, 1, command_buf
.len
, stdout
);
3166 fputc('\n', stdout
);
3171 static char* make_fast_import_path(const char *path
)
3173 if (!relative_marks_paths
|| is_absolute_path(path
))
3174 return xstrdup(path
);
3175 return xstrdup(git_path("info/fast-import/%s", path
));
3178 static void option_import_marks(const char *marks
,
3179 int from_stream
, int ignore_missing
)
3181 if (import_marks_file
) {
3183 die("Only one import-marks command allowed per stream");
3185 /* read previous mark file */
3186 if(!import_marks_file_from_stream
)
3190 import_marks_file
= make_fast_import_path(marks
);
3191 safe_create_leading_directories_const(import_marks_file
);
3192 import_marks_file_from_stream
= from_stream
;
3193 import_marks_file_ignore_missing
= ignore_missing
;
3196 static void option_date_format(const char *fmt
)
3198 if (!strcmp(fmt
, "raw"))
3199 whenspec
= WHENSPEC_RAW
;
3200 else if (!strcmp(fmt
, "rfc2822"))
3201 whenspec
= WHENSPEC_RFC2822
;
3202 else if (!strcmp(fmt
, "now"))
3203 whenspec
= WHENSPEC_NOW
;
3205 die("unknown --date-format argument %s", fmt
);
3208 static unsigned long ulong_arg(const char *option
, const char *arg
)
3211 unsigned long rv
= strtoul(arg
, &endptr
, 0);
3212 if (strchr(arg
, '-') || endptr
== arg
|| *endptr
)
3213 die("%s: argument must be a non-negative integer", option
);
3217 static void option_depth(const char *depth
)
3219 max_depth
= ulong_arg("--depth", depth
);
3220 if (max_depth
> MAX_DEPTH
)
3221 die("--depth cannot exceed %u", MAX_DEPTH
);
3224 static void option_active_branches(const char *branches
)
3226 max_active_branches
= ulong_arg("--active-branches", branches
);
3229 static void option_export_marks(const char *marks
)
3231 export_marks_file
= make_fast_import_path(marks
);
3232 safe_create_leading_directories_const(export_marks_file
);
3235 static void option_cat_blob_fd(const char *fd
)
3237 unsigned long n
= ulong_arg("--cat-blob-fd", fd
);
3238 if (n
> (unsigned long) INT_MAX
)
3239 die("--cat-blob-fd cannot exceed %d", INT_MAX
);
3240 cat_blob_fd
= (int) n
;
3243 static void option_export_pack_edges(const char *edges
)
3247 pack_edges
= fopen(edges
, "a");
3249 die_errno("Cannot open '%s'", edges
);
3252 static int parse_one_option(const char *option
)
3254 if (skip_prefix(option
, "max-pack-size=", &option
)) {
3256 if (!git_parse_ulong(option
, &v
))
3259 warning("max-pack-size is now in bytes, assuming --max-pack-size=%lum", v
);
3261 } else if (v
< 1024 * 1024) {
3262 warning("minimum max-pack-size is 1 MiB");
3266 } else if (skip_prefix(option
, "big-file-threshold=", &option
)) {
3268 if (!git_parse_ulong(option
, &v
))
3270 big_file_threshold
= v
;
3271 } else if (skip_prefix(option
, "depth=", &option
)) {
3272 option_depth(option
);
3273 } else if (skip_prefix(option
, "active-branches=", &option
)) {
3274 option_active_branches(option
);
3275 } else if (skip_prefix(option
, "export-pack-edges=", &option
)) {
3276 option_export_pack_edges(option
);
3277 } else if (starts_with(option
, "quiet")) {
3279 } else if (starts_with(option
, "stats")) {
3288 static int parse_one_feature(const char *feature
, int from_stream
)
3292 if (skip_prefix(feature
, "date-format=", &arg
)) {
3293 option_date_format(arg
);
3294 } else if (skip_prefix(feature
, "import-marks=", &arg
)) {
3295 option_import_marks(arg
, from_stream
, 0);
3296 } else if (skip_prefix(feature
, "import-marks-if-exists=", &arg
)) {
3297 option_import_marks(arg
, from_stream
, 1);
3298 } else if (skip_prefix(feature
, "export-marks=", &arg
)) {
3299 option_export_marks(arg
);
3300 } else if (!strcmp(feature
, "get-mark")) {
3301 ; /* Don't die - this feature is supported */
3302 } else if (!strcmp(feature
, "cat-blob")) {
3303 ; /* Don't die - this feature is supported */
3304 } else if (!strcmp(feature
, "relative-marks")) {
3305 relative_marks_paths
= 1;
3306 } else if (!strcmp(feature
, "no-relative-marks")) {
3307 relative_marks_paths
= 0;
3308 } else if (!strcmp(feature
, "done")) {
3309 require_explicit_termination
= 1;
3310 } else if (!strcmp(feature
, "force")) {
3312 } else if (!strcmp(feature
, "notes") || !strcmp(feature
, "ls")) {
3313 ; /* do nothing; we have the feature */
3321 static void parse_feature(const char *feature
)
3323 if (seen_data_command
)
3324 die("Got feature command '%s' after data command", feature
);
3326 if (parse_one_feature(feature
, 1))
3329 die("This version of fast-import does not support feature %s.", feature
);
3332 static void parse_option(const char *option
)
3334 if (seen_data_command
)
3335 die("Got option command '%s' after data command", option
);
3337 if (parse_one_option(option
))
3340 die("This version of fast-import does not support option: %s", option
);
3343 static void git_pack_config(void)
3345 int indexversion_value
;
3347 unsigned long packsizelimit_value
;
3349 if (!git_config_get_ulong("pack.depth", &max_depth
)) {
3350 if (max_depth
> MAX_DEPTH
)
3351 max_depth
= MAX_DEPTH
;
3353 if (!git_config_get_int("pack.compression", &pack_compression_level
)) {
3354 if (pack_compression_level
== -1)
3355 pack_compression_level
= Z_DEFAULT_COMPRESSION
;
3356 else if (pack_compression_level
< 0 ||
3357 pack_compression_level
> Z_BEST_COMPRESSION
)
3358 git_die_config("pack.compression",
3359 "bad pack compression level %d", pack_compression_level
);
3360 pack_compression_seen
= 1;
3362 if (!git_config_get_int("pack.indexversion", &indexversion_value
)) {
3363 pack_idx_opts
.version
= indexversion_value
;
3364 if (pack_idx_opts
.version
> 2)
3365 git_die_config("pack.indexversion",
3366 "bad pack.indexversion=%"PRIu32
, pack_idx_opts
.version
);
3368 if (!git_config_get_ulong("pack.packsizelimit", &packsizelimit_value
))
3369 max_packsize
= packsizelimit_value
;
3371 if (!git_config_get_int("fastimport.unpacklimit", &limit
))
3372 unpack_limit
= limit
;
3373 else if (!git_config_get_int("transfer.unpacklimit", &limit
))
3374 unpack_limit
= limit
;
3376 git_config(git_default_config
, NULL
);
3379 static const char fast_import_usage
[] =
3380 "git fast-import [--date-format=<f>] [--max-pack-size=<n>] [--big-file-threshold=<n>] [--depth=<n>] [--active-branches=<n>] [--export-marks=<marks.file>]";
3382 static void parse_argv(void)
3386 for (i
= 1; i
< global_argc
; i
++) {
3387 const char *a
= global_argv
[i
];
3389 if (*a
!= '-' || !strcmp(a
, "--"))
3392 if (!skip_prefix(a
, "--", &a
))
3393 die("unknown option %s", a
);
3395 if (parse_one_option(a
))
3398 if (parse_one_feature(a
, 0))
3401 if (skip_prefix(a
, "cat-blob-fd=", &a
)) {
3402 option_cat_blob_fd(a
);
3406 die("unknown option --%s", a
);
3408 if (i
!= global_argc
)
3409 usage(fast_import_usage
);
3411 seen_data_command
= 1;
3412 if (import_marks_file
)
3416 int main(int argc
, char **argv
)
3420 git_extract_argv0_path(argv
[0]);
3422 git_setup_gettext();
3424 if (argc
== 2 && !strcmp(argv
[1], "-h"))
3425 usage(fast_import_usage
);
3427 setup_git_directory();
3428 reset_pack_idx_option(&pack_idx_opts
);
3430 if (!pack_compression_seen
&& core_compression_seen
)
3431 pack_compression_level
= core_compression_level
;
3433 alloc_objects(object_entry_alloc
);
3434 strbuf_init(&command_buf
, 0);
3435 atom_table
= xcalloc(atom_table_sz
, sizeof(struct atom_str
*));
3436 branch_table
= xcalloc(branch_table_sz
, sizeof(struct branch
*));
3437 avail_tree_table
= xcalloc(avail_tree_table_sz
, sizeof(struct avail_tree_content
*));
3438 marks
= pool_calloc(1, sizeof(struct mark_set
));
3443 rc_free
= pool_alloc(cmd_save
* sizeof(*rc_free
));
3444 for (i
= 0; i
< (cmd_save
- 1); i
++)
3445 rc_free
[i
].next
= &rc_free
[i
+ 1];
3446 rc_free
[cmd_save
- 1].next
= NULL
;
3448 prepare_packed_git();
3450 set_die_routine(die_nicely
);
3451 set_checkpoint_signal();
3452 while (read_next_command() != EOF
) {
3454 if (!strcmp("blob", command_buf
.buf
))
3456 else if (skip_prefix(command_buf
.buf
, "ls ", &v
))
3458 else if (skip_prefix(command_buf
.buf
, "commit ", &v
))
3459 parse_new_commit(v
);
3460 else if (skip_prefix(command_buf
.buf
, "tag ", &v
))
3462 else if (skip_prefix(command_buf
.buf
, "reset ", &v
))
3463 parse_reset_branch(v
);
3464 else if (!strcmp("checkpoint", command_buf
.buf
))
3466 else if (!strcmp("done", command_buf
.buf
))
3468 else if (starts_with(command_buf
.buf
, "progress "))
3470 else if (skip_prefix(command_buf
.buf
, "feature ", &v
))
3472 else if (skip_prefix(command_buf
.buf
, "option git ", &v
))
3474 else if (starts_with(command_buf
.buf
, "option "))
3475 /* ignore non-git options*/;
3477 die("Unsupported command: %s", command_buf
.buf
);
3479 if (checkpoint_requested
)
3483 /* argv hasn't been parsed yet, do so */
3484 if (!seen_data_command
)
3487 if (require_explicit_termination
&& feof(stdin
))
3488 die("stream ends early");
3501 uintmax_t total_count
= 0, duplicate_count
= 0;
3502 for (i
= 0; i
< ARRAY_SIZE(object_count_by_type
); i
++)
3503 total_count
+= object_count_by_type
[i
];
3504 for (i
= 0; i
< ARRAY_SIZE(duplicate_count_by_type
); i
++)
3505 duplicate_count
+= duplicate_count_by_type
[i
];
3507 fprintf(stderr
, "%s statistics:\n", argv
[0]);
3508 fprintf(stderr
, "---------------------------------------------------------------------\n");
3509 fprintf(stderr
, "Alloc'd objects: %10" PRIuMAX
"\n", alloc_count
);
3510 fprintf(stderr
, "Total objects: %10" PRIuMAX
" (%10" PRIuMAX
" duplicates )\n", total_count
, duplicate_count
);
3511 fprintf(stderr
, " blobs : %10" PRIuMAX
" (%10" PRIuMAX
" duplicates %10" PRIuMAX
" deltas of %10" PRIuMAX
" attempts)\n", object_count_by_type
[OBJ_BLOB
], duplicate_count_by_type
[OBJ_BLOB
], delta_count_by_type
[OBJ_BLOB
], delta_count_attempts_by_type
[OBJ_BLOB
]);
3512 fprintf(stderr
, " trees : %10" PRIuMAX
" (%10" PRIuMAX
" duplicates %10" PRIuMAX
" deltas of %10" PRIuMAX
" attempts)\n", object_count_by_type
[OBJ_TREE
], duplicate_count_by_type
[OBJ_TREE
], delta_count_by_type
[OBJ_TREE
], delta_count_attempts_by_type
[OBJ_TREE
]);
3513 fprintf(stderr
, " commits: %10" PRIuMAX
" (%10" PRIuMAX
" duplicates %10" PRIuMAX
" deltas of %10" PRIuMAX
" attempts)\n", object_count_by_type
[OBJ_COMMIT
], duplicate_count_by_type
[OBJ_COMMIT
], delta_count_by_type
[OBJ_COMMIT
], delta_count_attempts_by_type
[OBJ_COMMIT
]);
3514 fprintf(stderr
, " tags : %10" PRIuMAX
" (%10" PRIuMAX
" duplicates %10" PRIuMAX
" deltas of %10" PRIuMAX
" attempts)\n", object_count_by_type
[OBJ_TAG
], duplicate_count_by_type
[OBJ_TAG
], delta_count_by_type
[OBJ_TAG
], delta_count_attempts_by_type
[OBJ_TAG
]);
3515 fprintf(stderr
, "Total branches: %10lu (%10lu loads )\n", branch_count
, branch_load_count
);
3516 fprintf(stderr
, " marks: %10" PRIuMAX
" (%10" PRIuMAX
" unique )\n", (((uintmax_t)1) << marks
->shift
) * 1024, marks_set_count
);
3517 fprintf(stderr
, " atoms: %10u\n", atom_cnt
);
3518 fprintf(stderr
, "Memory total: %10" PRIuMAX
" KiB\n", (total_allocd
+ alloc_count
*sizeof(struct object_entry
))/1024);
3519 fprintf(stderr
, " pools: %10lu KiB\n", (unsigned long)(total_allocd
/1024));
3520 fprintf(stderr
, " objects: %10" PRIuMAX
" KiB\n", (alloc_count
*sizeof(struct object_entry
))/1024);
3521 fprintf(stderr
, "---------------------------------------------------------------------\n");
3523 fprintf(stderr
, "---------------------------------------------------------------------\n");
3524 fprintf(stderr
, "\n");
3527 return failure
? 1 : 0;