?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'xl/record-partial-clone-origin'
[git/raj.git] / builtin / index-pack.c
blobccf4eb7e9b3361ee7eb209180d98ce8df757d92d
1 #include "builtin.h"
2 #include "config.h"
3 #include "delta.h"
4 #include "pack.h"
5 #include "csum-file.h"
6 #include "blob.h"
7 #include "commit.h"
8 #include "tag.h"
9 #include "tree.h"
10 #include "progress.h"
11 #include "fsck.h"
12 #include "exec-cmd.h"
13 #include "streaming.h"
14 #include "thread-utils.h"
15 #include "packfile.h"
16 #include "object-store.h"
17
18 static const char index_pack_usage[] =
19 "git index-pack [-v] [-o <index-file>] [--keep | --keep=<msg>] [--verify] [--strict] (<pack-file> | --stdin [--fix-thin] [<pack-file>])";
20
21 struct object_entry {
22 struct pack_idx_entry idx;
23 unsigned long size;
24 unsigned char hdr_size;
25 signed char type;
26 signed char real_type;
27 };
28
29 struct object_stat {
30 unsigned delta_depth;
31 int base_object_no;
32 };
33
34 struct base_data {
35 struct base_data *base;
36 struct base_data *child;
37 struct object_entry *obj;
38 void *data;
39 unsigned long size;
40 int ref_first, ref_last;
41 int ofs_first, ofs_last;
42 };
43
44 struct thread_local {
45 pthread_t thread;
46 struct base_data *base_cache;
47 size_t base_cache_used;
48 int pack_fd;
49 };
50
51 /* Remember to update object flag allocation in object.h */
52 #define FLAG_LINK (1u<<20)
53 #define FLAG_CHECKED (1u<<21)
54
55 struct ofs_delta_entry {
56 off_t offset;
57 int obj_no;
58 };
59
60 struct ref_delta_entry {
61 struct object_id oid;
62 int obj_no;
63 };
64
65 static struct object_entry *objects;
66 static struct object_stat *obj_stat;
67 static struct ofs_delta_entry *ofs_deltas;
68 static struct ref_delta_entry *ref_deltas;
69 static struct thread_local nothread_data;
70 static int nr_objects;
71 static int nr_ofs_deltas;
72 static int nr_ref_deltas;
73 static int ref_deltas_alloc;
74 static int nr_resolved_deltas;
75 static int nr_threads;
76
77 static int from_stdin;
78 static int strict;
79 static int do_fsck_object;
80 static struct fsck_options fsck_options = FSCK_OPTIONS_STRICT;
81 static int verbose;
82 static int show_resolving_progress;
83 static int show_stat;
84 static int check_self_contained_and_connected;
85
86 static struct progress *progress;
87
88 /* We always read in 4kB chunks. */
89 static unsigned char input_buffer[4096];
90 static unsigned int input_offset, input_len;
91 static off_t consumed_bytes;
92 static off_t max_input_size;
93 static unsigned deepest_delta;
94 static git_hash_ctx input_ctx;
95 static uint32_t input_crc32;
96 static int input_fd, output_fd;
97 static const char *curr_pack;
98
99 static struct thread_local *thread_data;
100 static int nr_dispatched;
101 static int threads_active;
102
103 static pthread_mutex_t read_mutex;
104 #define read_lock() lock_mutex(&read_mutex)
105 #define read_unlock() unlock_mutex(&read_mutex)
106
107 static pthread_mutex_t counter_mutex;
108 #define counter_lock() lock_mutex(&counter_mutex)
109 #define counter_unlock() unlock_mutex(&counter_mutex)
110
111 static pthread_mutex_t work_mutex;
112 #define work_lock() lock_mutex(&work_mutex)
113 #define work_unlock() unlock_mutex(&work_mutex)
114
115 static pthread_mutex_t deepest_delta_mutex;
116 #define deepest_delta_lock() lock_mutex(&deepest_delta_mutex)
117 #define deepest_delta_unlock() unlock_mutex(&deepest_delta_mutex)
118
119 static pthread_mutex_t type_cas_mutex;
120 #define type_cas_lock() lock_mutex(&type_cas_mutex)
121 #define type_cas_unlock() unlock_mutex(&type_cas_mutex)
122
123 static pthread_key_t key;
124
125 static inline void lock_mutex(pthread_mutex_t *mutex)
126 {
127 if (threads_active)
128 pthread_mutex_lock(mutex);
129 }
130
131 static inline void unlock_mutex(pthread_mutex_t *mutex)
132 {
133 if (threads_active)
134 pthread_mutex_unlock(mutex);
135 }
136
137 /*
138 * Mutex and conditional variable can't be statically-initialized on Windows.
139 */
140 static void init_thread(void)
141 {
142 int i;
143 init_recursive_mutex(&read_mutex);
144 pthread_mutex_init(&counter_mutex, NULL);
145 pthread_mutex_init(&work_mutex, NULL);
146 pthread_mutex_init(&type_cas_mutex, NULL);
147 if (show_stat)
148 pthread_mutex_init(&deepest_delta_mutex, NULL);
149 pthread_key_create(&key, NULL);
150 thread_data = xcalloc(nr_threads, sizeof(*thread_data));
151 for (i = 0; i < nr_threads; i++) {
152 thread_data[i].pack_fd = open(curr_pack, O_RDONLY);
153 if (thread_data[i].pack_fd == -1)
154 die_errno(_("unable to open %s"), curr_pack);
155 }
156
157 threads_active = 1;
158 }
159
160 static void cleanup_thread(void)
161 {
162 int i;
163 if (!threads_active)
164 return;
165 threads_active = 0;
166 pthread_mutex_destroy(&read_mutex);
167 pthread_mutex_destroy(&counter_mutex);
168 pthread_mutex_destroy(&work_mutex);
169 pthread_mutex_destroy(&type_cas_mutex);
170 if (show_stat)
171 pthread_mutex_destroy(&deepest_delta_mutex);
172 for (i = 0; i < nr_threads; i++)
173 close(thread_data[i].pack_fd);
174 pthread_key_delete(key);
175 free(thread_data);
176 }
177
178 static int mark_link(struct object *obj, int type, void *data, struct fsck_options *options)
179 {
180 if (!obj)
181 return -1;
182
183 if (type != OBJ_ANY && obj->type != type)
184 die(_("object type mismatch at %s"), oid_to_hex(&obj->oid));
185
186 obj->flags |= FLAG_LINK;
187 return 0;
188 }
189
190 /* The content of each linked object must have been checked
191 or it must be already present in the object database */
192 static unsigned check_object(struct object *obj)
193 {
194 if (!obj)
195 return 0;
196
197 if (!(obj->flags & FLAG_LINK))
198 return 0;
199
200 if (!(obj->flags & FLAG_CHECKED)) {
201 unsigned long size;
202 int type = oid_object_info(the_repository, &obj->oid, &size);
203 if (type <= 0)
204 die(_("did not receive expected object %s"),
205 oid_to_hex(&obj->oid));
206 if (type != obj->type)
207 die(_("object %s: expected type %s, found %s"),
208 oid_to_hex(&obj->oid),
209 type_name(obj->type), type_name(type));
210 obj->flags |= FLAG_CHECKED;
211 return 1;
212 }
213
214 return 0;
215 }
216
217 static unsigned check_objects(void)
218 {
219 unsigned i, max, foreign_nr = 0;
220
221 max = get_max_object_index();
222
223 if (verbose)
224 progress = start_delayed_progress(_("Checking objects"), max);
225
226 for (i = 0; i < max; i++) {
227 foreign_nr += check_object(get_indexed_object(i));
228 display_progress(progress, i + 1);
229 }
230
231 stop_progress(&progress);
232 return foreign_nr;
233 }
234
235
236 /* Discard current buffer used content. */
237 static void flush(void)
238 {
239 if (input_offset) {
240 if (output_fd >= 0)
241 write_or_die(output_fd, input_buffer, input_offset);
242 the_hash_algo->update_fn(&input_ctx, input_buffer, input_offset);
243 memmove(input_buffer, input_buffer + input_offset, input_len);
244 input_offset = 0;
245 }
246 }
247
248 /*
249 * Make sure at least "min" bytes are available in the buffer, and
250 * return the pointer to the buffer.
251 */
252 static void *fill(int min)
253 {
254 if (min <= input_len)
255 return input_buffer + input_offset;
256 if (min > sizeof(input_buffer))
257 die(Q_("cannot fill %d byte",
258 "cannot fill %d bytes",
259 min),
260 min);
261 flush();
262 do {
263 ssize_t ret = xread(input_fd, input_buffer + input_len,
264 sizeof(input_buffer) - input_len);
265 if (ret <= 0) {
266 if (!ret)
267 die(_("early EOF"));
268 die_errno(_("read error on input"));
269 }
270 input_len += ret;
271 if (from_stdin)
272 display_throughput(progress, consumed_bytes + input_len);
273 } while (input_len < min);
274 return input_buffer;
275 }
276
277 static void use(int bytes)
278 {
279 if (bytes > input_len)
280 die(_("used more bytes than were available"));
281 input_crc32 = crc32(input_crc32, input_buffer + input_offset, bytes);
282 input_len -= bytes;
283 input_offset += bytes;
284
285 /* make sure off_t is sufficiently large not to wrap */
286 if (signed_add_overflows(consumed_bytes, bytes))
287 die(_("pack too large for current definition of off_t"));
288 consumed_bytes += bytes;
289 if (max_input_size && consumed_bytes > max_input_size)
290 die(_("pack exceeds maximum allowed size"));
291 }
292
293 static const char *open_pack_file(const char *pack_name)
294 {
295 if (from_stdin) {
296 input_fd = 0;
297 if (!pack_name) {
298 struct strbuf tmp_file = STRBUF_INIT;
299 output_fd = odb_mkstemp(&tmp_file,
300 "pack/tmp_pack_XXXXXX");
301 pack_name = strbuf_detach(&tmp_file, NULL);
302 } else {
303 output_fd = open(pack_name, O_CREAT|O_EXCL|O_RDWR, 0600);
304 if (output_fd < 0)
305 die_errno(_("unable to create '%s'"), pack_name);
306 }
307 nothread_data.pack_fd = output_fd;
308 } else {
309 input_fd = open(pack_name, O_RDONLY);
310 if (input_fd < 0)
311 die_errno(_("cannot open packfile '%s'"), pack_name);
312 output_fd = -1;
313 nothread_data.pack_fd = input_fd;
314 }
315 the_hash_algo->init_fn(&input_ctx);
316 return pack_name;
317 }
318
319 static void parse_pack_header(void)
320 {
321 struct pack_header *hdr = fill(sizeof(struct pack_header));
322
323 /* Header consistency check */
324 if (hdr->hdr_signature != htonl(PACK_SIGNATURE))
325 die(_("pack signature mismatch"));
326 if (!pack_version_ok(hdr->hdr_version))
327 die(_("pack version %"PRIu32" unsupported"),
328 ntohl(hdr->hdr_version));
329
330 nr_objects = ntohl(hdr->hdr_entries);
331 use(sizeof(struct pack_header));
332 }
333
334 static NORETURN void bad_object(off_t offset, const char *format,
335 ...) __attribute__((format (printf, 2, 3)));
336
337 static NORETURN void bad_object(off_t offset, const char *format, ...)
338 {
339 va_list params;
340 char buf[1024];
341
342 va_start(params, format);
343 vsnprintf(buf, sizeof(buf), format, params);
344 va_end(params);
345 die(_("pack has bad object at offset %"PRIuMAX": %s"),
346 (uintmax_t)offset, buf);
347 }
348
349 static inline struct thread_local *get_thread_data(void)
350 {
351 if (HAVE_THREADS) {
352 if (threads_active)
353 return pthread_getspecific(key);
354 assert(!threads_active &&
355 "This should only be reached when all threads are gone");
356 }
357 return &nothread_data;
358 }
359
360 static void set_thread_data(struct thread_local *data)
361 {
362 if (threads_active)
363 pthread_setspecific(key, data);
364 }
365
366 static struct base_data *alloc_base_data(void)
367 {
368 struct base_data *base = xcalloc(1, sizeof(struct base_data));
369 base->ref_last = -1;
370 base->ofs_last = -1;
371 return base;
372 }
373
374 static void free_base_data(struct base_data *c)
375 {
376 if (c->data) {
377 FREE_AND_NULL(c->data);
378 get_thread_data()->base_cache_used -= c->size;
379 }
380 }
381
382 static void prune_base_data(struct base_data *retain)
383 {
384 struct base_data *b;
385 struct thread_local *data = get_thread_data();
386 for (b = data->base_cache;
387 data->base_cache_used > delta_base_cache_limit && b;
388 b = b->child) {
389 if (b->data && b != retain)
390 free_base_data(b);
391 }
392 }
393
394 static void link_base_data(struct base_data *base, struct base_data *c)
395 {
396 if (base)
397 base->child = c;
398 else
399 get_thread_data()->base_cache = c;
400
401 c->base = base;
402 c->child = NULL;
403 if (c->data)
404 get_thread_data()->base_cache_used += c->size;
405 prune_base_data(c);
406 }
407
408 static void unlink_base_data(struct base_data *c)
409 {
410 struct base_data *base = c->base;
411 if (base)
412 base->child = NULL;
413 else
414 get_thread_data()->base_cache = NULL;
415 free_base_data(c);
416 }
417
418 static int is_delta_type(enum object_type type)
419 {
420 return (type == OBJ_REF_DELTA || type == OBJ_OFS_DELTA);
421 }
422
423 static void *unpack_entry_data(off_t offset, unsigned long size,
424 enum object_type type, struct object_id *oid)
425 {
426 static char fixed_buf[8192];
427 int status;
428 git_zstream stream;
429 void *buf;
430 git_hash_ctx c;
431 char hdr[32];
432 int hdrlen;
433
434 if (!is_delta_type(type)) {
435 hdrlen = xsnprintf(hdr, sizeof(hdr), "%s %"PRIuMAX,
436 type_name(type),(uintmax_t)size) + 1;
437 the_hash_algo->init_fn(&c);
438 the_hash_algo->update_fn(&c, hdr, hdrlen);
439 } else
440 oid = NULL;
441 if (type == OBJ_BLOB && size > big_file_threshold)
442 buf = fixed_buf;
443 else
444 buf = xmallocz(size);
445
446 memset(&stream, 0, sizeof(stream));
447 git_inflate_init(&stream);
448 stream.next_out = buf;
449 stream.avail_out = buf == fixed_buf ? sizeof(fixed_buf) : size;
450
451 do {
452 unsigned char *last_out = stream.next_out;
453 stream.next_in = fill(1);
454 stream.avail_in = input_len;
455 status = git_inflate(&stream, 0);
456 use(input_len - stream.avail_in);
457 if (oid)
458 the_hash_algo->update_fn(&c, last_out, stream.next_out - last_out);
459 if (buf == fixed_buf) {
460 stream.next_out = buf;
461 stream.avail_out = sizeof(fixed_buf);
462 }
463 } while (status == Z_OK);
464 if (stream.total_out != size || status != Z_STREAM_END)
465 bad_object(offset, _("inflate returned %d"), status);
466 git_inflate_end(&stream);
467 if (oid)
468 the_hash_algo->final_fn(oid->hash, &c);
469 return buf == fixed_buf ? NULL : buf;
470 }
471
472 static void *unpack_raw_entry(struct object_entry *obj,
473 off_t *ofs_offset,
474 struct object_id *ref_oid,
475 struct object_id *oid)
476 {
477 unsigned char *p;
478 unsigned long size, c;
479 off_t base_offset;
480 unsigned shift;
481 void *data;
482
483 obj->idx.offset = consumed_bytes;
484 input_crc32 = crc32(0, NULL, 0);
485
486 p = fill(1);
487 c = *p;
488 use(1);
489 obj->type = (c >> 4) & 7;
490 size = (c & 15);
491 shift = 4;
492 while (c & 0x80) {
493 p = fill(1);
494 c = *p;
495 use(1);
496 size += (c & 0x7f) << shift;
497 shift += 7;
498 }
499 obj->size = size;
500
501 switch (obj->type) {
502 case OBJ_REF_DELTA:
503 hashcpy(ref_oid->hash, fill(the_hash_algo->rawsz));
504 use(the_hash_algo->rawsz);
505 break;
506 case OBJ_OFS_DELTA:
507 p = fill(1);
508 c = *p;
509 use(1);
510 base_offset = c & 127;
511 while (c & 128) {
512 base_offset += 1;
513 if (!base_offset || MSB(base_offset, 7))
514 bad_object(obj->idx.offset, _("offset value overflow for delta base object"));
515 p = fill(1);
516 c = *p;
517 use(1);
518 base_offset = (base_offset << 7) + (c & 127);
519 }
520 *ofs_offset = obj->idx.offset - base_offset;
521 if (*ofs_offset <= 0 || *ofs_offset >= obj->idx.offset)
522 bad_object(obj->idx.offset, _("delta base offset is out of bound"));
523 break;
524 case OBJ_COMMIT:
525 case OBJ_TREE:
526 case OBJ_BLOB:
527 case OBJ_TAG:
528 break;
529 default:
530 bad_object(obj->idx.offset, _("unknown object type %d"), obj->type);
531 }
532 obj->hdr_size = consumed_bytes - obj->idx.offset;
533
534 data = unpack_entry_data(obj->idx.offset, obj->size, obj->type, oid);
535 obj->idx.crc32 = input_crc32;
536 return data;
537 }
538
539 static void *unpack_data(struct object_entry *obj,
540 int (*consume)(const unsigned char *, unsigned long, void *),
541 void *cb_data)
542 {
543 off_t from = obj[0].idx.offset + obj[0].hdr_size;
544 off_t len = obj[1].idx.offset - from;
545 unsigned char *data, *inbuf;
546 git_zstream stream;
547 int status;
548
549 data = xmallocz(consume ? 64*1024 : obj->size);
550 inbuf = xmalloc((len < 64*1024) ? (int)len : 64*1024);
551
552 memset(&stream, 0, sizeof(stream));
553 git_inflate_init(&stream);
554 stream.next_out = data;
555 stream.avail_out = consume ? 64*1024 : obj->size;
556
557 do {
558 ssize_t n = (len < 64*1024) ? (ssize_t)len : 64*1024;
559 n = xpread(get_thread_data()->pack_fd, inbuf, n, from);
560 if (n < 0)
561 die_errno(_("cannot pread pack file"));
562 if (!n)
563 die(Q_("premature end of pack file, %"PRIuMAX" byte missing",
564 "premature end of pack file, %"PRIuMAX" bytes missing",
565 (unsigned int)len),
566 (uintmax_t)len);
567 from += n;
568 len -= n;
569 stream.next_in = inbuf;
570 stream.avail_in = n;
571 if (!consume)
572 status = git_inflate(&stream, 0);
573 else {
574 do {
575 status = git_inflate(&stream, 0);
576 if (consume(data, stream.next_out - data, cb_data)) {
577 free(inbuf);
578 free(data);
579 return NULL;
580 }
581 stream.next_out = data;
582 stream.avail_out = 64*1024;
583 } while (status == Z_OK && stream.avail_in);
584 }
585 } while (len && status == Z_OK && !stream.avail_in);
586
587 /* This has been inflated OK when first encountered, so... */
588 if (status != Z_STREAM_END || stream.total_out != obj->size)
589 die(_("serious inflate inconsistency"));
590
591 git_inflate_end(&stream);
592 free(inbuf);
593 if (consume) {
594 FREE_AND_NULL(data);
595 }
596 return data;
597 }
598
599 static void *get_data_from_pack(struct object_entry *obj)
600 {
601 return unpack_data(obj, NULL, NULL);
602 }
603
604 static int compare_ofs_delta_bases(off_t offset1, off_t offset2,
605 enum object_type type1,
606 enum object_type type2)
607 {
608 int cmp = type1 - type2;
609 if (cmp)
610 return cmp;
611 return offset1 < offset2 ? -1 :
612 offset1 > offset2 ? 1 :
613 0;
614 }
615
616 static int find_ofs_delta(const off_t offset, enum object_type type)
617 {
618 int first = 0, last = nr_ofs_deltas;
619
620 while (first < last) {
621 int next = first + (last - first) / 2;
622 struct ofs_delta_entry *delta = &ofs_deltas[next];
623 int cmp;
624
625 cmp = compare_ofs_delta_bases(offset, delta->offset,
626 type, objects[delta->obj_no].type);
627 if (!cmp)
628 return next;
629 if (cmp < 0) {
630 last = next;
631 continue;
632 }
633 first = next+1;
634 }
635 return -first-1;
636 }
637
638 static void find_ofs_delta_children(off_t offset,
639 int *first_index, int *last_index,
640 enum object_type type)
641 {
642 int first = find_ofs_delta(offset, type);
643 int last = first;
644 int end = nr_ofs_deltas - 1;
645
646 if (first < 0) {
647 *first_index = 0;
648 *last_index = -1;
649 return;
650 }
651 while (first > 0 && ofs_deltas[first - 1].offset == offset)
652 --first;
653 while (last < end && ofs_deltas[last + 1].offset == offset)
654 ++last;
655 *first_index = first;
656 *last_index = last;
657 }
658
659 static int compare_ref_delta_bases(const struct object_id *oid1,
660 const struct object_id *oid2,
661 enum object_type type1,
662 enum object_type type2)
663 {
664 int cmp = type1 - type2;
665 if (cmp)
666 return cmp;
667 return oidcmp(oid1, oid2);
668 }
669
670 static int find_ref_delta(const struct object_id *oid, enum object_type type)
671 {
672 int first = 0, last = nr_ref_deltas;
673
674 while (first < last) {
675 int next = first + (last - first) / 2;
676 struct ref_delta_entry *delta = &ref_deltas[next];
677 int cmp;
678
679 cmp = compare_ref_delta_bases(oid, &delta->oid,
680 type, objects[delta->obj_no].type);
681 if (!cmp)
682 return next;
683 if (cmp < 0) {
684 last = next;
685 continue;
686 }
687 first = next+1;
688 }
689 return -first-1;
690 }
691
692 static void find_ref_delta_children(const struct object_id *oid,
693 int *first_index, int *last_index,
694 enum object_type type)
695 {
696 int first = find_ref_delta(oid, type);
697 int last = first;
698 int end = nr_ref_deltas - 1;
699
700 if (first < 0) {
701 *first_index = 0;
702 *last_index = -1;
703 return;
704 }
705 while (first > 0 && oideq(&ref_deltas[first - 1].oid, oid))
706 --first;
707 while (last < end && oideq(&ref_deltas[last + 1].oid, oid))
708 ++last;
709 *first_index = first;
710 *last_index = last;
711 }
712
713 struct compare_data {
714 struct object_entry *entry;
715 struct git_istream *st;
716 unsigned char *buf;
717 unsigned long buf_size;
718 };
719
720 static int compare_objects(const unsigned char *buf, unsigned long size,
721 void *cb_data)
722 {
723 struct compare_data *data = cb_data;
724
725 if (data->buf_size < size) {
726 free(data->buf);
727 data->buf = xmalloc(size);
728 data->buf_size = size;
729 }
730
731 while (size) {
732 ssize_t len = read_istream(data->st, data->buf, size);
733 if (len == 0)
734 die(_("SHA1 COLLISION FOUND WITH %s !"),
735 oid_to_hex(&data->entry->idx.oid));
736 if (len < 0)
737 die(_("unable to read %s"),
738 oid_to_hex(&data->entry->idx.oid));
739 if (memcmp(buf, data->buf, len))
740 die(_("SHA1 COLLISION FOUND WITH %s !"),
741 oid_to_hex(&data->entry->idx.oid));
742 size -= len;
743 buf += len;
744 }
745 return 0;
746 }
747
748 static int check_collison(struct object_entry *entry)
749 {
750 struct compare_data data;
751 enum object_type type;
752 unsigned long size;
753
754 if (entry->size <= big_file_threshold || entry->type != OBJ_BLOB)
755 return -1;
756
757 memset(&data, 0, sizeof(data));
758 data.entry = entry;
759 data.st = open_istream(&entry->idx.oid, &type, &size, NULL);
760 if (!data.st)
761 return -1;
762 if (size != entry->size || type != entry->type)
763 die(_("SHA1 COLLISION FOUND WITH %s !"),
764 oid_to_hex(&entry->idx.oid));
765 unpack_data(entry, compare_objects, &data);
766 close_istream(data.st);
767 free(data.buf);
768 return 0;
769 }
770
771 static void sha1_object(const void *data, struct object_entry *obj_entry,
772 unsigned long size, enum object_type type,
773 const struct object_id *oid)
774 {
775 void *new_data = NULL;
776 int collision_test_needed = 0;
777
778 assert(data || obj_entry);
779
780 if (startup_info->have_repository) {
781 read_lock();
782 collision_test_needed =
783 has_object_file_with_flags(oid, OBJECT_INFO_QUICK);
784 read_unlock();
785 }
786
787 if (collision_test_needed && !data) {
788 read_lock();
789 if (!check_collison(obj_entry))
790 collision_test_needed = 0;
791 read_unlock();
792 }
793 if (collision_test_needed) {
794 void *has_data;
795 enum object_type has_type;
796 unsigned long has_size;
797 read_lock();
798 has_type = oid_object_info(the_repository, oid, &has_size);
799 if (has_type < 0)
800 die(_("cannot read existing object info %s"), oid_to_hex(oid));
801 if (has_type != type || has_size != size)
802 die(_("SHA1 COLLISION FOUND WITH %s !"), oid_to_hex(oid));
803 has_data = read_object_file(oid, &has_type, &has_size);
804 read_unlock();
805 if (!data)
806 data = new_data = get_data_from_pack(obj_entry);
807 if (!has_data)
808 die(_("cannot read existing object %s"), oid_to_hex(oid));
809 if (size != has_size || type != has_type ||
810 memcmp(data, has_data, size) != 0)
811 die(_("SHA1 COLLISION FOUND WITH %s !"), oid_to_hex(oid));
812 free(has_data);
813 }
814
815 if (strict || do_fsck_object) {
816 read_lock();
817 if (type == OBJ_BLOB) {
818 struct blob *blob = lookup_blob(the_repository, oid);
819 if (blob)
820 blob->object.flags |= FLAG_CHECKED;
821 else
822 die(_("invalid blob object %s"), oid_to_hex(oid));
823 if (do_fsck_object &&
824 fsck_object(&blob->object, (void *)data, size, &fsck_options))
825 die(_("fsck error in packed object"));
826 } else {
827 struct object *obj;
828 int eaten;
829 void *buf = (void *) data;
830
831 assert(data && "data can only be NULL for large _blobs_");
832
833 /*
834 * we do not need to free the memory here, as the
835 * buf is deleted by the caller.
836 */
837 obj = parse_object_buffer(the_repository, oid, type,
838 size, buf,
839 &eaten);
840 if (!obj)
841 die(_("invalid %s"), type_name(type));
842 if (do_fsck_object &&
843 fsck_object(obj, buf, size, &fsck_options))
844 die(_("fsck error in packed object"));
845 if (strict && fsck_walk(obj, NULL, &fsck_options))
846 die(_("Not all child objects of %s are reachable"), oid_to_hex(&obj->oid));
847
848 if (obj->type == OBJ_TREE) {
849 struct tree *item = (struct tree *) obj;
850 item->buffer = NULL;
851 obj->parsed = 0;
852 }
853 if (obj->type == OBJ_COMMIT) {
854 struct commit *commit = (struct commit *) obj;
855 if (detach_commit_buffer(commit, NULL) != data)
856 BUG("parse_object_buffer transmogrified our buffer");
857 }
858 obj->flags |= FLAG_CHECKED;
859 }
860 read_unlock();
861 }
862
863 free(new_data);
864 }
865
866 /*
867 * This function is part of find_unresolved_deltas(). There are two
868 * walkers going in the opposite ways.
869 *
870 * The first one in find_unresolved_deltas() traverses down from
871 * parent node to children, deflating nodes along the way. However,
872 * memory for deflated nodes is limited by delta_base_cache_limit, so
873 * at some point parent node's deflated content may be freed.
874 *
875 * The second walker is this function, which goes from current node up
876 * to top parent if necessary to deflate the node. In normal
877 * situation, its parent node would be already deflated, so it just
878 * needs to apply delta.
879 *
880 * In the worst case scenario, parent node is no longer deflated because
881 * we're running out of delta_base_cache_limit; we need to re-deflate
882 * parents, possibly up to the top base.
883 *
884 * All deflated objects here are subject to be freed if we exceed
885 * delta_base_cache_limit, just like in find_unresolved_deltas(), we
886 * just need to make sure the last node is not freed.
887 */
888 static void *get_base_data(struct base_data *c)
889 {
890 if (!c->data) {
891 struct object_entry *obj = c->obj;
892 struct base_data **delta = NULL;
893 int delta_nr = 0, delta_alloc = 0;
894
895 while (is_delta_type(c->obj->type) && !c->data) {
896 ALLOC_GROW(delta, delta_nr + 1, delta_alloc);
897 delta[delta_nr++] = c;
898 c = c->base;
899 }
900 if (!delta_nr) {
901 c->data = get_data_from_pack(obj);
902 c->size = obj->size;
903 get_thread_data()->base_cache_used += c->size;
904 prune_base_data(c);
905 }
906 for (; delta_nr > 0; delta_nr--) {
907 void *base, *raw;
908 c = delta[delta_nr - 1];
909 obj = c->obj;
910 base = get_base_data(c->base);
911 raw = get_data_from_pack(obj);
912 c->data = patch_delta(
913 base, c->base->size,
914 raw, obj->size,
915 &c->size);
916 free(raw);
917 if (!c->data)
918 bad_object(obj->idx.offset, _("failed to apply delta"));
919 get_thread_data()->base_cache_used += c->size;
920 prune_base_data(c);
921 }
922 free(delta);
923 }
924 return c->data;
925 }
926
927 static void resolve_delta(struct object_entry *delta_obj,
928 struct base_data *base, struct base_data *result)
929 {
930 void *base_data, *delta_data;
931
932 if (show_stat) {
933 int i = delta_obj - objects;
934 int j = base->obj - objects;
935 obj_stat[i].delta_depth = obj_stat[j].delta_depth + 1;
936 deepest_delta_lock();
937 if (deepest_delta < obj_stat[i].delta_depth)
938 deepest_delta = obj_stat[i].delta_depth;
939 deepest_delta_unlock();
940 obj_stat[i].base_object_no = j;
941 }
942 delta_data = get_data_from_pack(delta_obj);
943 base_data = get_base_data(base);
944 result->obj = delta_obj;
945 result->data = patch_delta(base_data, base->size,
946 delta_data, delta_obj->size, &result->size);
947 free(delta_data);
948 if (!result->data)
949 bad_object(delta_obj->idx.offset, _("failed to apply delta"));
950 hash_object_file(result->data, result->size,
951 type_name(delta_obj->real_type), &delta_obj->idx.oid);
952 sha1_object(result->data, NULL, result->size, delta_obj->real_type,
953 &delta_obj->idx.oid);
954 counter_lock();
955 nr_resolved_deltas++;
956 counter_unlock();
957 }
958
959 /*
960 * Standard boolean compare-and-swap: atomically check whether "*type" is
961 * "want"; if so, swap in "set" and return true. Otherwise, leave it untouched
962 * and return false.
963 */
964 static int compare_and_swap_type(signed char *type,
965 enum object_type want,
966 enum object_type set)
967 {
968 enum object_type old;
969
970 type_cas_lock();
971 old = *type;
972 if (old == want)
973 *type = set;
974 type_cas_unlock();
975
976 return old == want;
977 }
978
979 static struct base_data *find_unresolved_deltas_1(struct base_data *base,
980 struct base_data *prev_base)
981 {
982 if (base->ref_last == -1 && base->ofs_last == -1) {
983 find_ref_delta_children(&base->obj->idx.oid,
984 &base->ref_first, &base->ref_last,
985 OBJ_REF_DELTA);
986
987 find_ofs_delta_children(base->obj->idx.offset,
988 &base->ofs_first, &base->ofs_last,
989 OBJ_OFS_DELTA);
990
991 if (base->ref_last == -1 && base->ofs_last == -1) {
992 free(base->data);
993 return NULL;
994 }
995
996 link_base_data(prev_base, base);
997 }
998
999 if (base->ref_first <= base->ref_last) {
1000 struct object_entry *child = objects + ref_deltas[base->ref_first].obj_no;
1001 struct base_data *result = alloc_base_data();
1002
1003 if (!compare_and_swap_type(&child->real_type, OBJ_REF_DELTA,
1004 base->obj->real_type))
1005 BUG("child->real_type != OBJ_REF_DELTA");
1006
1007 resolve_delta(child, base, result);
1008 if (base->ref_first == base->ref_last && base->ofs_last == -1)
1009 free_base_data(base);
1010
1011 base->ref_first++;
1012 return result;
1013 }
1014
1015 if (base->ofs_first <= base->ofs_last) {
1016 struct object_entry *child = objects + ofs_deltas[base->ofs_first].obj_no;
1017 struct base_data *result = alloc_base_data();
1018
1019 assert(child->real_type == OBJ_OFS_DELTA);
1020 child->real_type = base->obj->real_type;
1021 resolve_delta(child, base, result);
1022 if (base->ofs_first == base->ofs_last)
1023 free_base_data(base);
1024
1025 base->ofs_first++;
1026 return result;
1027 }
1028
1029 unlink_base_data(base);
1030 return NULL;
1031 }
1032
1033 static void find_unresolved_deltas(struct base_data *base)
1034 {
1035 struct base_data *new_base, *prev_base = NULL;
1036 for (;;) {
1037 new_base = find_unresolved_deltas_1(base, prev_base);
1038
1039 if (new_base) {
1040 prev_base = base;
1041 base = new_base;
1042 } else {
1043 free(base);
1044 base = prev_base;
1045 if (!base)
1046 return;
1047 prev_base = base->base;
1048 }
1049 }
1050 }
1051
1052 static int compare_ofs_delta_entry(const void *a, const void *b)
1053 {
1054 const struct ofs_delta_entry *delta_a = a;
1055 const struct ofs_delta_entry *delta_b = b;
1056
1057 return delta_a->offset < delta_b->offset ? -1 :
1058 delta_a->offset > delta_b->offset ? 1 :
1059 0;
1060 }
1061
1062 static int compare_ref_delta_entry(const void *a, const void *b)
1063 {
1064 const struct ref_delta_entry *delta_a = a;
1065 const struct ref_delta_entry *delta_b = b;
1066
1067 return oidcmp(&delta_a->oid, &delta_b->oid);
1068 }
1069
1070 static void resolve_base(struct object_entry *obj)
1071 {
1072 struct base_data *base_obj = alloc_base_data();
1073 base_obj->obj = obj;
1074 base_obj->data = NULL;
1075 find_unresolved_deltas(base_obj);
1076 }
1077
1078 static void *threaded_second_pass(void *data)
1079 {
1080 set_thread_data(data);
1081 for (;;) {
1082 int i;
1083 counter_lock();
1084 display_progress(progress, nr_resolved_deltas);
1085 counter_unlock();
1086 work_lock();
1087 while (nr_dispatched < nr_objects &&
1088 is_delta_type(objects[nr_dispatched].type))
1089 nr_dispatched++;
1090 if (nr_dispatched >= nr_objects) {
1091 work_unlock();
1092 break;
1093 }
1094 i = nr_dispatched++;
1095 work_unlock();
1096
1097 resolve_base(&objects[i]);
1098 }
1099 return NULL;
1100 }
1101
1102 /*
1103 * First pass:
1104 * - find locations of all objects;
1105 * - calculate SHA1 of all non-delta objects;
1106 * - remember base (SHA1 or offset) for all deltas.
1107 */
1108 static void parse_pack_objects(unsigned char *hash)
1109 {
1110 int i, nr_delays = 0;
1111 struct ofs_delta_entry *ofs_delta = ofs_deltas;
1112 struct object_id ref_delta_oid;
1113 struct stat st;
1114
1115 if (verbose)
1116 progress = start_progress(
1117 from_stdin ? _("Receiving objects") : _("Indexing objects"),
1118 nr_objects);
1119 for (i = 0; i < nr_objects; i++) {
1120 struct object_entry *obj = &objects[i];
1121 void *data = unpack_raw_entry(obj, &ofs_delta->offset,
1122 &ref_delta_oid,
1123 &obj->idx.oid);
1124 obj->real_type = obj->type;
1125 if (obj->type == OBJ_OFS_DELTA) {
1126 nr_ofs_deltas++;
1127 ofs_delta->obj_no = i;
1128 ofs_delta++;
1129 } else if (obj->type == OBJ_REF_DELTA) {
1130 ALLOC_GROW(ref_deltas, nr_ref_deltas + 1, ref_deltas_alloc);
1131 oidcpy(&ref_deltas[nr_ref_deltas].oid, &ref_delta_oid);
1132 ref_deltas[nr_ref_deltas].obj_no = i;
1133 nr_ref_deltas++;
1134 } else if (!data) {
1135 /* large blobs, check later */
1136 obj->real_type = OBJ_BAD;
1137 nr_delays++;
1138 } else
1139 sha1_object(data, NULL, obj->size, obj->type,
1140 &obj->idx.oid);
1141 free(data);
1142 display_progress(progress, i+1);
1143 }
1144 objects[i].idx.offset = consumed_bytes;
1145 stop_progress(&progress);
1146
1147 /* Check pack integrity */
1148 flush();
1149 the_hash_algo->final_fn(hash, &input_ctx);
1150 if (!hasheq(fill(the_hash_algo->rawsz), hash))
1151 die(_("pack is corrupted (SHA1 mismatch)"));
1152 use(the_hash_algo->rawsz);
1153
1154 /* If input_fd is a file, we should have reached its end now. */
1155 if (fstat(input_fd, &st))
1156 die_errno(_("cannot fstat packfile"));
1157 if (S_ISREG(st.st_mode) &&
1158 lseek(input_fd, 0, SEEK_CUR) - input_len != st.st_size)
1159 die(_("pack has junk at the end"));
1160
1161 for (i = 0; i < nr_objects; i++) {
1162 struct object_entry *obj = &objects[i];
1163 if (obj->real_type != OBJ_BAD)
1164 continue;
1165 obj->real_type = obj->type;
1166 sha1_object(NULL, obj, obj->size, obj->type,
1167 &obj->idx.oid);
1168 nr_delays--;
1169 }
1170 if (nr_delays)
1171 die(_("confusion beyond insanity in parse_pack_objects()"));
1172 }
1173
1174 /*
1175 * Second pass:
1176 * - for all non-delta objects, look if it is used as a base for
1177 * deltas;
1178 * - if used as a base, uncompress the object and apply all deltas,
1179 * recursively checking if the resulting object is used as a base
1180 * for some more deltas.
1181 */
1182 static void resolve_deltas(void)
1183 {
1184 int i;
1185
1186 if (!nr_ofs_deltas && !nr_ref_deltas)
1187 return;
1188
1189 /* Sort deltas by base SHA1/offset for fast searching */
1190 QSORT(ofs_deltas, nr_ofs_deltas, compare_ofs_delta_entry);
1191 QSORT(ref_deltas, nr_ref_deltas, compare_ref_delta_entry);
1192
1193 if (verbose || show_resolving_progress)
1194 progress = start_progress(_("Resolving deltas"),
1195 nr_ref_deltas + nr_ofs_deltas);
1196
1197 nr_dispatched = 0;
1198 if (nr_threads > 1 || getenv("GIT_FORCE_THREADS")) {
1199 init_thread();
1200 for (i = 0; i < nr_threads; i++) {
1201 int ret = pthread_create(&thread_data[i].thread, NULL,
1202 threaded_second_pass, thread_data + i);
1203 if (ret)
1204 die(_("unable to create thread: %s"),
1205 strerror(ret));
1206 }
1207 for (i = 0; i < nr_threads; i++)
1208 pthread_join(thread_data[i].thread, NULL);
1209 cleanup_thread();
1210 return;
1211 }
1212
1213 for (i = 0; i < nr_objects; i++) {
1214 struct object_entry *obj = &objects[i];
1215
1216 if (is_delta_type(obj->type))
1217 continue;
1218 resolve_base(obj);
1219 display_progress(progress, nr_resolved_deltas);
1220 }
1221 }
1222
1223 /*
1224 * Third pass:
1225 * - append objects to convert thin pack to full pack if required
1226 * - write the final pack hash
1227 */
1228 static void fix_unresolved_deltas(struct hashfile *f);
1229 static void conclude_pack(int fix_thin_pack, const char *curr_pack, unsigned char *pack_hash)
1230 {
1231 if (nr_ref_deltas + nr_ofs_deltas == nr_resolved_deltas) {
1232 stop_progress(&progress);
1233 /* Flush remaining pack final hash. */
1234 flush();
1235 return;
1236 }
1237
1238 if (fix_thin_pack) {
1239 struct hashfile *f;
1240 unsigned char read_hash[GIT_MAX_RAWSZ], tail_hash[GIT_MAX_RAWSZ];
1241 struct strbuf msg = STRBUF_INIT;
1242 int nr_unresolved = nr_ofs_deltas + nr_ref_deltas - nr_resolved_deltas;
1243 int nr_objects_initial = nr_objects;
1244 if (nr_unresolved <= 0)
1245 die(_("confusion beyond insanity"));
1246 REALLOC_ARRAY(objects, nr_objects + nr_unresolved + 1);
1247 memset(objects + nr_objects + 1, 0,
1248 nr_unresolved * sizeof(*objects));
1249 f = hashfd(output_fd, curr_pack);
1250 fix_unresolved_deltas(f);
1251 strbuf_addf(&msg, Q_("completed with %d local object",
1252 "completed with %d local objects",
1253 nr_objects - nr_objects_initial),
1254 nr_objects - nr_objects_initial);
1255 stop_progress_msg(&progress, msg.buf);
1256 strbuf_release(&msg);
1257 finalize_hashfile(f, tail_hash, 0);
1258 hashcpy(read_hash, pack_hash);
1259 fixup_pack_header_footer(output_fd, pack_hash,
1260 curr_pack, nr_objects,
1261 read_hash, consumed_bytes-the_hash_algo->rawsz);
1262 if (!hasheq(read_hash, tail_hash))
1263 die(_("Unexpected tail checksum for %s "
1264 "(disk corruption?)"), curr_pack);
1265 }
1266 if (nr_ofs_deltas + nr_ref_deltas != nr_resolved_deltas)
1267 die(Q_("pack has %d unresolved delta",
1268 "pack has %d unresolved deltas",
1269 nr_ofs_deltas + nr_ref_deltas - nr_resolved_deltas),
1270 nr_ofs_deltas + nr_ref_deltas - nr_resolved_deltas);
1271 }
1272
1273 static int write_compressed(struct hashfile *f, void *in, unsigned int size)
1274 {
1275 git_zstream stream;
1276 int status;
1277 unsigned char outbuf[4096];
1278
1279 git_deflate_init(&stream, zlib_compression_level);
1280 stream.next_in = in;
1281 stream.avail_in = size;
1282
1283 do {
1284 stream.next_out = outbuf;
1285 stream.avail_out = sizeof(outbuf);
1286 status = git_deflate(&stream, Z_FINISH);
1287 hashwrite(f, outbuf, sizeof(outbuf) - stream.avail_out);
1288 } while (status == Z_OK);
1289
1290 if (status != Z_STREAM_END)
1291 die(_("unable to deflate appended object (%d)"), status);
1292 size = stream.total_out;
1293 git_deflate_end(&stream);
1294 return size;
1295 }
1296
1297 static struct object_entry *append_obj_to_pack(struct hashfile *f,
1298 const unsigned char *sha1, void *buf,
1299 unsigned long size, enum object_type type)
1300 {
1301 struct object_entry *obj = &objects[nr_objects++];
1302 unsigned char header[10];
1303 unsigned long s = size;
1304 int n = 0;
1305 unsigned char c = (type << 4) | (s & 15);
1306 s >>= 4;
1307 while (s) {
1308 header[n++] = c | 0x80;
1309 c = s & 0x7f;
1310 s >>= 7;
1311 }
1312 header[n++] = c;
1313 crc32_begin(f);
1314 hashwrite(f, header, n);
1315 obj[0].size = size;
1316 obj[0].hdr_size = n;
1317 obj[0].type = type;
1318 obj[0].real_type = type;
1319 obj[1].idx.offset = obj[0].idx.offset + n;
1320 obj[1].idx.offset += write_compressed(f, buf, size);
1321 obj[0].idx.crc32 = crc32_end(f);
1322 hashflush(f);
1323 hashcpy(obj->idx.oid.hash, sha1);
1324 return obj;
1325 }
1326
1327 static int delta_pos_compare(const void *_a, const void *_b)
1328 {
1329 struct ref_delta_entry *a = *(struct ref_delta_entry **)_a;
1330 struct ref_delta_entry *b = *(struct ref_delta_entry **)_b;
1331 return a->obj_no - b->obj_no;
1332 }
1333
1334 static void fix_unresolved_deltas(struct hashfile *f)
1335 {
1336 struct ref_delta_entry **sorted_by_pos;
1337 int i;
1338
1339 /*
1340 * Since many unresolved deltas may well be themselves base objects
1341 * for more unresolved deltas, we really want to include the
1342 * smallest number of base objects that would cover as much delta
1343 * as possible by picking the
1344 * trunc deltas first, allowing for other deltas to resolve without
1345 * additional base objects. Since most base objects are to be found
1346 * before deltas depending on them, a good heuristic is to start
1347 * resolving deltas in the same order as their position in the pack.
1348 */
1349 ALLOC_ARRAY(sorted_by_pos, nr_ref_deltas);
1350 for (i = 0; i < nr_ref_deltas; i++)
1351 sorted_by_pos[i] = &ref_deltas[i];
1352 QSORT(sorted_by_pos, nr_ref_deltas, delta_pos_compare);
1353
1354 for (i = 0; i < nr_ref_deltas; i++) {
1355 struct ref_delta_entry *d = sorted_by_pos[i];
1356 enum object_type type;
1357 struct base_data *base_obj = alloc_base_data();
1358
1359 if (objects[d->obj_no].real_type != OBJ_REF_DELTA)
1360 continue;
1361 base_obj->data = read_object_file(&d->oid, &type,
1362 &base_obj->size);
1363 if (!base_obj->data)
1364 continue;
1365
1366 if (check_object_signature(&d->oid, base_obj->data,
1367 base_obj->size, type_name(type)))
1368 die(_("local object %s is corrupt"), oid_to_hex(&d->oid));
1369 base_obj->obj = append_obj_to_pack(f, d->oid.hash,
1370 base_obj->data, base_obj->size, type);
1371 find_unresolved_deltas(base_obj);
1372 display_progress(progress, nr_resolved_deltas);
1373 }
1374 free(sorted_by_pos);
1375 }
1376
1377 static const char *derive_filename(const char *pack_name, const char *suffix,
1378 struct strbuf *buf)
1379 {
1380 size_t len;
1381 if (!strip_suffix(pack_name, ".pack", &len))
1382 die(_("packfile name '%s' does not end with '.pack'"),
1383 pack_name);
1384 strbuf_add(buf, pack_name, len);
1385 strbuf_addch(buf, '.');
1386 strbuf_addstr(buf, suffix);
1387 return buf->buf;
1388 }
1389
1390 static void write_special_file(const char *suffix, const char *msg,
1391 const char *pack_name, const unsigned char *hash,
1392 const char **report)
1393 {
1394 struct strbuf name_buf = STRBUF_INIT;
1395 const char *filename;
1396 int fd;
1397 int msg_len = strlen(msg);
1398
1399 if (pack_name)
1400 filename = derive_filename(pack_name, suffix, &name_buf);
1401 else
1402 filename = odb_pack_name(&name_buf, hash, suffix);
1403
1404 fd = odb_pack_keep(filename);
1405 if (fd < 0) {
1406 if (errno != EEXIST)
1407 die_errno(_("cannot write %s file '%s'"),
1408 suffix, filename);
1409 } else {
1410 if (msg_len > 0) {
1411 write_or_die(fd, msg, msg_len);
1412 write_or_die(fd, "\n", 1);
1413 }
1414 if (close(fd) != 0)
1415 die_errno(_("cannot close written %s file '%s'"),
1416 suffix, filename);
1417 if (report)
1418 *report = suffix;
1419 }
1420 strbuf_release(&name_buf);
1421 }
1422
1423 static void final(const char *final_pack_name, const char *curr_pack_name,
1424 const char *final_index_name, const char *curr_index_name,
1425 const char *keep_msg, const char *promisor_msg,
1426 unsigned char *hash)
1427 {
1428 const char *report = "pack";
1429 struct strbuf pack_name = STRBUF_INIT;
1430 struct strbuf index_name = STRBUF_INIT;
1431 int err;
1432
1433 if (!from_stdin) {
1434 close(input_fd);
1435 } else {
1436 fsync_or_die(output_fd, curr_pack_name);
1437 err = close(output_fd);
1438 if (err)
1439 die_errno(_("error while closing pack file"));
1440 }
1441
1442 if (keep_msg)
1443 write_special_file("keep", keep_msg, final_pack_name, hash,
1444 &report);
1445 if (promisor_msg)
1446 write_special_file("promisor", promisor_msg, final_pack_name,
1447 hash, NULL);
1448
1449 if (final_pack_name != curr_pack_name) {
1450 if (!final_pack_name)
1451 final_pack_name = odb_pack_name(&pack_name, hash, "pack");
1452 if (finalize_object_file(curr_pack_name, final_pack_name))
1453 die(_("cannot store pack file"));
1454 } else if (from_stdin)
1455 chmod(final_pack_name, 0444);
1456
1457 if (final_index_name != curr_index_name) {
1458 if (!final_index_name)
1459 final_index_name = odb_pack_name(&index_name, hash, "idx");
1460 if (finalize_object_file(curr_index_name, final_index_name))
1461 die(_("cannot store index file"));
1462 } else
1463 chmod(final_index_name, 0444);
1464
1465 if (do_fsck_object) {
1466 struct packed_git *p;
1467 p = add_packed_git(final_index_name, strlen(final_index_name), 0);
1468 if (p)
1469 install_packed_git(the_repository, p);
1470 }
1471
1472 if (!from_stdin) {
1473 printf("%s\n", sha1_to_hex(hash));
1474 } else {
1475 struct strbuf buf = STRBUF_INIT;
1476
1477 strbuf_addf(&buf, "%s\t%s\n", report, sha1_to_hex(hash));
1478 write_or_die(1, buf.buf, buf.len);
1479 strbuf_release(&buf);
1480
1481 /*
1482 * Let's just mimic git-unpack-objects here and write
1483 * the last part of the input buffer to stdout.
1484 */
1485 while (input_len) {
1486 err = xwrite(1, input_buffer + input_offset, input_len);
1487 if (err <= 0)
1488 break;
1489 input_len -= err;
1490 input_offset += err;
1491 }
1492 }
1493
1494 strbuf_release(&index_name);
1495 strbuf_release(&pack_name);
1496 }
1497
1498 static int git_index_pack_config(const char *k, const char *v, void *cb)
1499 {
1500 struct pack_idx_option *opts = cb;
1501
1502 if (!strcmp(k, "pack.indexversion")) {
1503 opts->version = git_config_int(k, v);
1504 if (opts->version > 2)
1505 die(_("bad pack.indexversion=%"PRIu32), opts->version);
1506 return 0;
1507 }
1508 if (!strcmp(k, "pack.threads")) {
1509 nr_threads = git_config_int(k, v);
1510 if (nr_threads < 0)
1511 die(_("invalid number of threads specified (%d)"),
1512 nr_threads);
1513 if (!HAVE_THREADS && nr_threads != 1) {
1514 warning(_("no threads support, ignoring %s"), k);
1515 nr_threads = 1;
1516 }
1517 return 0;
1518 }
1519 return git_default_config(k, v, cb);
1520 }
1521
1522 static int cmp_uint32(const void *a_, const void *b_)
1523 {
1524 uint32_t a = *((uint32_t *)a_);
1525 uint32_t b = *((uint32_t *)b_);
1526
1527 return (a < b) ? -1 : (a != b);
1528 }
1529
1530 static void read_v2_anomalous_offsets(struct packed_git *p,
1531 struct pack_idx_option *opts)
1532 {
1533 const uint32_t *idx1, *idx2;
1534 uint32_t i;
1535 const uint32_t hashwords = the_hash_algo->rawsz / sizeof(uint32_t);
1536
1537 /* The address of the 4-byte offset table */
1538 idx1 = (((const uint32_t *)p->index_data)
1539 + 2 /* 8-byte header */
1540 + 256 /* fan out */
1541 + hashwords * p->num_objects /* object ID table */
1542 + p->num_objects /* CRC32 table */
1543 );
1544
1545 /* The address of the 8-byte offset table */
1546 idx2 = idx1 + p->num_objects;
1547
1548 for (i = 0; i < p->num_objects; i++) {
1549 uint32_t off = ntohl(idx1[i]);
1550 if (!(off & 0x80000000))
1551 continue;
1552 off = off & 0x7fffffff;
1553 check_pack_index_ptr(p, &idx2[off * 2]);
1554 if (idx2[off * 2])
1555 continue;
1556 /*
1557 * The real offset is ntohl(idx2[off * 2]) in high 4
1558 * octets, and ntohl(idx2[off * 2 + 1]) in low 4
1559 * octets. But idx2[off * 2] is Zero!!!
1560 */
1561 ALLOC_GROW(opts->anomaly, opts->anomaly_nr + 1, opts->anomaly_alloc);
1562 opts->anomaly[opts->anomaly_nr++] = ntohl(idx2[off * 2 + 1]);
1563 }
1564
1565 QSORT(opts->anomaly, opts->anomaly_nr, cmp_uint32);
1566 }
1567
1568 static void read_idx_option(struct pack_idx_option *opts, const char *pack_name)
1569 {
1570 struct packed_git *p = add_packed_git(pack_name, strlen(pack_name), 1);
1571
1572 if (!p)
1573 die(_("Cannot open existing pack file '%s'"), pack_name);
1574 if (open_pack_index(p))
1575 die(_("Cannot open existing pack idx file for '%s'"), pack_name);
1576
1577 /* Read the attributes from the existing idx file */
1578 opts->version = p->index_version;
1579
1580 if (opts->version == 2)
1581 read_v2_anomalous_offsets(p, opts);
1582
1583 /*
1584 * Get rid of the idx file as we do not need it anymore.
1585 * NEEDSWORK: extract this bit from free_pack_by_name() in
1586 * sha1-file.c, perhaps? It shouldn't matter very much as we
1587 * know we haven't installed this pack (hence we never have
1588 * read anything from it).
1589 */
1590 close_pack_index(p);
1591 free(p);
1592 }
1593
1594 static void show_pack_info(int stat_only)
1595 {
1596 int i, baseobjects = nr_objects - nr_ref_deltas - nr_ofs_deltas;
1597 unsigned long *chain_histogram = NULL;
1598
1599 if (deepest_delta)
1600 chain_histogram = xcalloc(deepest_delta, sizeof(unsigned long));
1601
1602 for (i = 0; i < nr_objects; i++) {
1603 struct object_entry *obj = &objects[i];
1604
1605 if (is_delta_type(obj->type))
1606 chain_histogram[obj_stat[i].delta_depth - 1]++;
1607 if (stat_only)
1608 continue;
1609 printf("%s %-6s %"PRIuMAX" %"PRIuMAX" %"PRIuMAX,
1610 oid_to_hex(&obj->idx.oid),
1611 type_name(obj->real_type), (uintmax_t)obj->size,
1612 (uintmax_t)(obj[1].idx.offset - obj->idx.offset),
1613 (uintmax_t)obj->idx.offset);
1614 if (is_delta_type(obj->type)) {
1615 struct object_entry *bobj = &objects[obj_stat[i].base_object_no];
1616 printf(" %u %s", obj_stat[i].delta_depth,
1617 oid_to_hex(&bobj->idx.oid));
1618 }
1619 putchar('\n');
1620 }
1621
1622 if (baseobjects)
1623 printf_ln(Q_("non delta: %d object",
1624 "non delta: %d objects",
1625 baseobjects),
1626 baseobjects);
1627 for (i = 0; i < deepest_delta; i++) {
1628 if (!chain_histogram[i])
1629 continue;
1630 printf_ln(Q_("chain length = %d: %lu object",
1631 "chain length = %d: %lu objects",
1632 chain_histogram[i]),
1633 i + 1,
1634 chain_histogram[i]);
1635 }
1636 }
1637
1638 int cmd_index_pack(int argc, const char **argv, const char *prefix)
1639 {
1640 int i, fix_thin_pack = 0, verify = 0, stat_only = 0;
1641 const char *curr_index;
1642 const char *index_name = NULL, *pack_name = NULL;
1643 const char *keep_msg = NULL;
1644 const char *promisor_msg = NULL;
1645 struct strbuf index_name_buf = STRBUF_INIT;
1646 struct pack_idx_entry **idx_objects;
1647 struct pack_idx_option opts;
1648 unsigned char pack_hash[GIT_MAX_RAWSZ];
1649 unsigned foreign_nr = 1; /* zero is a "good" value, assume bad */
1650 int report_end_of_input = 0;
1651
1652 /*
1653 * index-pack never needs to fetch missing objects, since it only
1654 * accesses the repo to do hash collision checks
1655 */
1656 fetch_if_missing = 0;
1657
1658 if (argc == 2 && !strcmp(argv[1], "-h"))
1659 usage(index_pack_usage);
1660
1661 read_replace_refs = 0;
1662 fsck_options.walk = mark_link;
1663
1664 reset_pack_idx_option(&opts);
1665 git_config(git_index_pack_config, &opts);
1666 if (prefix && chdir(prefix))
1667 die(_("Cannot come back to cwd"));
1668
1669 for (i = 1; i < argc; i++) {
1670 const char *arg = argv[i];
1671
1672 if (*arg == '-') {
1673 if (!strcmp(arg, "--stdin")) {
1674 from_stdin = 1;
1675 } else if (!strcmp(arg, "--fix-thin")) {
1676 fix_thin_pack = 1;
1677 } else if (skip_to_optional_arg(arg, "--strict", &arg)) {
1678 strict = 1;
1679 do_fsck_object = 1;
1680 fsck_set_msg_types(&fsck_options, arg);
1681 } else if (!strcmp(arg, "--check-self-contained-and-connected")) {
1682 strict = 1;
1683 check_self_contained_and_connected = 1;
1684 } else if (!strcmp(arg, "--fsck-objects")) {
1685 do_fsck_object = 1;
1686 } else if (!strcmp(arg, "--verify")) {
1687 verify = 1;
1688 } else if (!strcmp(arg, "--verify-stat")) {
1689 verify = 1;
1690 show_stat = 1;
1691 } else if (!strcmp(arg, "--verify-stat-only")) {
1692 verify = 1;
1693 show_stat = 1;
1694 stat_only = 1;
1695 } else if (skip_to_optional_arg(arg, "--keep", &keep_msg)) {
1696 ; /* nothing to do */
1697 } else if (skip_to_optional_arg(arg, "--promisor", &promisor_msg)) {
1698 ; /* already parsed */
1699 } else if (starts_with(arg, "--threads=")) {
1700 char *end;
1701 nr_threads = strtoul(arg+10, &end, 0);
1702 if (!arg[10] || *end || nr_threads < 0)
1703 usage(index_pack_usage);
1704 if (!HAVE_THREADS && nr_threads != 1) {
1705 warning(_("no threads support, ignoring %s"), arg);
1706 nr_threads = 1;
1707 }
1708 } else if (starts_with(arg, "--pack_header=")) {
1709 struct pack_header *hdr;
1710 char *c;
1711
1712 hdr = (struct pack_header *)input_buffer;
1713 hdr->hdr_signature = htonl(PACK_SIGNATURE);
1714 hdr->hdr_version = htonl(strtoul(arg + 14, &c, 10));
1715 if (*c != ',')
1716 die(_("bad %s"), arg);
1717 hdr->hdr_entries = htonl(strtoul(c + 1, &c, 10));
1718 if (*c)
1719 die(_("bad %s"), arg);
1720 input_len = sizeof(*hdr);
1721 } else if (!strcmp(arg, "-v")) {
1722 verbose = 1;
1723 } else if (!strcmp(arg, "--show-resolving-progress")) {
1724 show_resolving_progress = 1;
1725 } else if (!strcmp(arg, "--report-end-of-input")) {
1726 report_end_of_input = 1;
1727 } else if (!strcmp(arg, "-o")) {
1728 if (index_name || (i+1) >= argc)
1729 usage(index_pack_usage);
1730 index_name = argv[++i];
1731 } else if (starts_with(arg, "--index-version=")) {
1732 char *c;
1733 opts.version = strtoul(arg + 16, &c, 10);
1734 if (opts.version > 2)
1735 die(_("bad %s"), arg);
1736 if (*c == ',')
1737 opts.off32_limit = strtoul(c+1, &c, 0);
1738 if (*c || opts.off32_limit & 0x80000000)
1739 die(_("bad %s"), arg);
1740 } else if (skip_prefix(arg, "--max-input-size=", &arg)) {
1741 max_input_size = strtoumax(arg, NULL, 10);
1742 } else
1743 usage(index_pack_usage);
1744 continue;
1745 }
1746
1747 if (pack_name)
1748 usage(index_pack_usage);
1749 pack_name = arg;
1750 }
1751
1752 if (!pack_name && !from_stdin)
1753 usage(index_pack_usage);
1754 if (fix_thin_pack && !from_stdin)
1755 die(_("--fix-thin cannot be used without --stdin"));
1756 if (from_stdin && !startup_info->have_repository)
1757 die(_("--stdin requires a git repository"));
1758 if (!index_name && pack_name)
1759 index_name = derive_filename(pack_name, "idx", &index_name_buf);
1760
1761 if (verify) {
1762 if (!index_name)
1763 die(_("--verify with no packfile name given"));
1764 read_idx_option(&opts, index_name);
1765 opts.flags |= WRITE_IDX_VERIFY | WRITE_IDX_STRICT;
1766 }
1767 if (strict)
1768 opts.flags |= WRITE_IDX_STRICT;
1769
1770 if (HAVE_THREADS && !nr_threads) {
1771 nr_threads = online_cpus();
1772 /* An experiment showed that more threads does not mean faster */
1773 if (nr_threads > 3)
1774 nr_threads = 3;
1775 }
1776
1777 curr_pack = open_pack_file(pack_name);
1778 parse_pack_header();
1779 objects = xcalloc(st_add(nr_objects, 1), sizeof(struct object_entry));
1780 if (show_stat)
1781 obj_stat = xcalloc(st_add(nr_objects, 1), sizeof(struct object_stat));
1782 ofs_deltas = xcalloc(nr_objects, sizeof(struct ofs_delta_entry));
1783 parse_pack_objects(pack_hash);
1784 if (report_end_of_input)
1785 write_in_full(2, "\0", 1);
1786 resolve_deltas();
1787 conclude_pack(fix_thin_pack, curr_pack, pack_hash);
1788 free(ofs_deltas);
1789 free(ref_deltas);
1790 if (strict)
1791 foreign_nr = check_objects();
1792
1793 if (show_stat)
1794 show_pack_info(stat_only);
1795
1796 ALLOC_ARRAY(idx_objects, nr_objects);
1797 for (i = 0; i < nr_objects; i++)
1798 idx_objects[i] = &objects[i].idx;
1799 curr_index = write_idx_file(index_name, idx_objects, nr_objects, &opts, pack_hash);
1800 free(idx_objects);
1801
1802 if (!verify)
1803 final(pack_name, curr_pack,
1804 index_name, curr_index,
1805 keep_msg, promisor_msg,
1806 pack_hash);
1807 else
1808 close(input_fd);
1809
1810 if (do_fsck_object && fsck_finish(&fsck_options))
1811 die(_("fsck error in pack objects"));
1812
1813 free(objects);
1814 strbuf_release(&index_name_buf);
1815 if (pack_name == NULL)
1816 free((void *) curr_pack);
1817 if (index_name == NULL)
1818 free((void *) curr_index);
1819
1820 /*
1821 * Let the caller know this pack is not self contained
1822 */
1823 if (check_self_contained_and_connected && foreign_nr)
1824 return 1;
1825
1826 return 0;
1827 }
ramsay's fork of git