1#include"builtin.h" 2#include"cache.h" 3#include"config.h" 4#include"attr.h" 5#include"object.h" 6#include"blob.h" 7#include"commit.h" 8#include"tag.h" 9#include"tree.h" 10#include"delta.h" 11#include"pack.h" 12#include"pack-revindex.h" 13#include"csum-file.h" 14#include"tree-walk.h" 15#include"diff.h" 16#include"revision.h" 17#include"list-objects.h" 18#include"list-objects-filter.h" 19#include"list-objects-filter-options.h" 20#include"pack-objects.h" 21#include"progress.h" 22#include"refs.h" 23#include"streaming.h" 24#include"thread-utils.h" 25#include"pack-bitmap.h" 26#include"reachable.h" 27#include"sha1-array.h" 28#include"argv-array.h" 29#include"list.h" 30#include"packfile.h" 31 32static const char*pack_usage[] = { 33N_("git pack-objects --stdout [<options>...] [< <ref-list> | < <object-list>]"), 34N_("git pack-objects [<options>...] <base-name> [< <ref-list> | < <object-list>]"), 35 NULL 36}; 37 38/* 39 * Objects we are going to pack are collected in the `to_pack` structure. 40 * It contains an array (dynamically expanded) of the object data, and a map 41 * that can resolve SHA1s to their position in the array. 42 */ 43static struct packing_data to_pack; 44 45static struct pack_idx_entry **written_list; 46static uint32_t nr_result, nr_written; 47 48static int non_empty; 49static int reuse_delta =1, reuse_object =1; 50static int keep_unreachable, unpack_unreachable, include_tag; 51static timestamp_t unpack_unreachable_expiration; 52static int pack_loose_unreachable; 53static int local; 54static int have_non_local_packs; 55static int incremental; 56static int ignore_packed_keep; 57static int allow_ofs_delta; 58static struct pack_idx_option pack_idx_opts; 59static const char*base_name; 60static int progress =1; 61static int window =10; 62static unsigned long pack_size_limit; 63static int depth =50; 64static int delta_search_threads; 65static int pack_to_stdout; 66static int num_preferred_base; 67static struct progress *progress_state; 68 69static struct packed_git *reuse_packfile; 70static uint32_t reuse_packfile_objects; 71static off_t reuse_packfile_offset; 72 73static int use_bitmap_index_default =1; 74static int use_bitmap_index = -1; 75static int write_bitmap_index; 76static uint16_t write_bitmap_options; 77 78static int exclude_promisor_objects; 79 80static unsigned long delta_cache_size =0; 81static unsigned long max_delta_cache_size =256*1024*1024; 82static unsigned long cache_max_small_delta_size =1000; 83 84static unsigned long window_memory_limit =0; 85 86static struct list_objects_filter_options filter_options; 87 88enum missing_action { 89 MA_ERROR =0,/* fail if any missing objects are encountered */ 90 MA_ALLOW_ANY,/* silently allow ALL missing objects */ 91 MA_ALLOW_PROMISOR,/* silently allow all missing PROMISOR objects */ 92}; 93static enum missing_action arg_missing_action; 94static show_object_fn fn_show_object; 95 96/* 97 * stats 98 */ 99static uint32_t written, written_delta; 100static uint32_t reused, reused_delta; 101 102/* 103 * Indexed commits 104 */ 105static struct commit **indexed_commits; 106static unsigned int indexed_commits_nr; 107static unsigned int indexed_commits_alloc; 108 109static voidindex_commit_for_bitmap(struct commit *commit) 110{ 111if(indexed_commits_nr >= indexed_commits_alloc) { 112 indexed_commits_alloc = (indexed_commits_alloc +32) *2; 113REALLOC_ARRAY(indexed_commits, indexed_commits_alloc); 114} 115 116 indexed_commits[indexed_commits_nr++] = commit; 117} 118 119static void*get_delta(struct object_entry *entry) 120{ 121unsigned long size, base_size, delta_size; 122void*buf, *base_buf, *delta_buf; 123enum object_type type; 124 125 buf =read_sha1_file(entry->idx.oid.hash, &type, &size); 126if(!buf) 127die("unable to read%s",oid_to_hex(&entry->idx.oid)); 128 base_buf =read_sha1_file(entry->delta->idx.oid.hash, &type, 129&base_size); 130if(!base_buf) 131die("unable to read%s", 132oid_to_hex(&entry->delta->idx.oid)); 133 delta_buf =diff_delta(base_buf, base_size, 134 buf, size, &delta_size,0); 135if(!delta_buf || delta_size != entry->delta_size) 136die("delta size changed"); 137free(buf); 138free(base_buf); 139return delta_buf; 140} 141 142static unsigned longdo_compress(void**pptr,unsigned long size) 143{ 144 git_zstream stream; 145void*in, *out; 146unsigned long maxsize; 147 148git_deflate_init(&stream, pack_compression_level); 149 maxsize =git_deflate_bound(&stream, size); 150 151 in = *pptr; 152 out =xmalloc(maxsize); 153*pptr = out; 154 155 stream.next_in = in; 156 stream.avail_in = size; 157 stream.next_out = out; 158 stream.avail_out = maxsize; 159while(git_deflate(&stream, Z_FINISH) == Z_OK) 160;/* nothing */ 161git_deflate_end(&stream); 162 163free(in); 164return stream.total_out; 165} 166 167static unsigned longwrite_large_blob_data(struct git_istream *st,struct hashfile *f, 168const struct object_id *oid) 169{ 170 git_zstream stream; 171unsigned char ibuf[1024*16]; 172unsigned char obuf[1024*16]; 173unsigned long olen =0; 174 175git_deflate_init(&stream, pack_compression_level); 176 177for(;;) { 178 ssize_t readlen; 179int zret = Z_OK; 180 readlen =read_istream(st, ibuf,sizeof(ibuf)); 181if(readlen == -1) 182die(_("unable to read%s"),oid_to_hex(oid)); 183 184 stream.next_in = ibuf; 185 stream.avail_in = readlen; 186while((stream.avail_in || readlen ==0) && 187(zret == Z_OK || zret == Z_BUF_ERROR)) { 188 stream.next_out = obuf; 189 stream.avail_out =sizeof(obuf); 190 zret =git_deflate(&stream, readlen ?0: Z_FINISH); 191hashwrite(f, obuf, stream.next_out - obuf); 192 olen += stream.next_out - obuf; 193} 194if(stream.avail_in) 195die(_("deflate error (%d)"), zret); 196if(readlen ==0) { 197if(zret != Z_STREAM_END) 198die(_("deflate error (%d)"), zret); 199break; 200} 201} 202git_deflate_end(&stream); 203return olen; 204} 205 206/* 207 * we are going to reuse the existing object data as is. make 208 * sure it is not corrupt. 209 */ 210static intcheck_pack_inflate(struct packed_git *p, 211struct pack_window **w_curs, 212 off_t offset, 213 off_t len, 214unsigned long expect) 215{ 216 git_zstream stream; 217unsigned char fakebuf[4096], *in; 218int st; 219 220memset(&stream,0,sizeof(stream)); 221git_inflate_init(&stream); 222do{ 223 in =use_pack(p, w_curs, offset, &stream.avail_in); 224 stream.next_in = in; 225 stream.next_out = fakebuf; 226 stream.avail_out =sizeof(fakebuf); 227 st =git_inflate(&stream, Z_FINISH); 228 offset += stream.next_in - in; 229}while(st == Z_OK || st == Z_BUF_ERROR); 230git_inflate_end(&stream); 231return(st == Z_STREAM_END && 232 stream.total_out == expect && 233 stream.total_in == len) ?0: -1; 234} 235 236static voidcopy_pack_data(struct hashfile *f, 237struct packed_git *p, 238struct pack_window **w_curs, 239 off_t offset, 240 off_t len) 241{ 242unsigned char*in; 243unsigned long avail; 244 245while(len) { 246 in =use_pack(p, w_curs, offset, &avail); 247if(avail > len) 248 avail = (unsigned long)len; 249hashwrite(f, in, avail); 250 offset += avail; 251 len -= avail; 252} 253} 254 255/* Return 0 if we will bust the pack-size limit */ 256static unsigned longwrite_no_reuse_object(struct hashfile *f,struct object_entry *entry, 257unsigned long limit,int usable_delta) 258{ 259unsigned long size, datalen; 260unsigned char header[MAX_PACK_OBJECT_HEADER], 261 dheader[MAX_PACK_OBJECT_HEADER]; 262unsigned hdrlen; 263enum object_type type; 264void*buf; 265struct git_istream *st = NULL; 266 267if(!usable_delta) { 268if(entry->type == OBJ_BLOB && 269 entry->size > big_file_threshold && 270(st =open_istream(entry->idx.oid.hash, &type, &size, NULL)) != NULL) 271 buf = NULL; 272else{ 273 buf =read_sha1_file(entry->idx.oid.hash, &type, 274&size); 275if(!buf) 276die(_("unable to read%s"), 277oid_to_hex(&entry->idx.oid)); 278} 279/* 280 * make sure no cached delta data remains from a 281 * previous attempt before a pack split occurred. 282 */ 283FREE_AND_NULL(entry->delta_data); 284 entry->z_delta_size =0; 285}else if(entry->delta_data) { 286 size = entry->delta_size; 287 buf = entry->delta_data; 288 entry->delta_data = NULL; 289 type = (allow_ofs_delta && entry->delta->idx.offset) ? 290 OBJ_OFS_DELTA : OBJ_REF_DELTA; 291}else{ 292 buf =get_delta(entry); 293 size = entry->delta_size; 294 type = (allow_ofs_delta && entry->delta->idx.offset) ? 295 OBJ_OFS_DELTA : OBJ_REF_DELTA; 296} 297 298if(st)/* large blob case, just assume we don't compress well */ 299 datalen = size; 300else if(entry->z_delta_size) 301 datalen = entry->z_delta_size; 302else 303 datalen =do_compress(&buf, size); 304 305/* 306 * The object header is a byte of 'type' followed by zero or 307 * more bytes of length. 308 */ 309 hdrlen =encode_in_pack_object_header(header,sizeof(header), 310 type, size); 311 312if(type == OBJ_OFS_DELTA) { 313/* 314 * Deltas with relative base contain an additional 315 * encoding of the relative offset for the delta 316 * base from this object's position in the pack. 317 */ 318 off_t ofs = entry->idx.offset - entry->delta->idx.offset; 319unsigned pos =sizeof(dheader) -1; 320 dheader[pos] = ofs &127; 321while(ofs >>=7) 322 dheader[--pos] =128| (--ofs &127); 323if(limit && hdrlen +sizeof(dheader) - pos + datalen +20>= limit) { 324if(st) 325close_istream(st); 326free(buf); 327return0; 328} 329hashwrite(f, header, hdrlen); 330hashwrite(f, dheader + pos,sizeof(dheader) - pos); 331 hdrlen +=sizeof(dheader) - pos; 332}else if(type == OBJ_REF_DELTA) { 333/* 334 * Deltas with a base reference contain 335 * an additional 20 bytes for the base sha1. 336 */ 337if(limit && hdrlen +20+ datalen +20>= limit) { 338if(st) 339close_istream(st); 340free(buf); 341return0; 342} 343hashwrite(f, header, hdrlen); 344hashwrite(f, entry->delta->idx.oid.hash,20); 345 hdrlen +=20; 346}else{ 347if(limit && hdrlen + datalen +20>= limit) { 348if(st) 349close_istream(st); 350free(buf); 351return0; 352} 353hashwrite(f, header, hdrlen); 354} 355if(st) { 356 datalen =write_large_blob_data(st, f, &entry->idx.oid); 357close_istream(st); 358}else{ 359hashwrite(f, buf, datalen); 360free(buf); 361} 362 363return hdrlen + datalen; 364} 365 366/* Return 0 if we will bust the pack-size limit */ 367static off_t write_reuse_object(struct hashfile *f,struct object_entry *entry, 368unsigned long limit,int usable_delta) 369{ 370struct packed_git *p = entry->in_pack; 371struct pack_window *w_curs = NULL; 372struct revindex_entry *revidx; 373 off_t offset; 374enum object_type type = entry->type; 375 off_t datalen; 376unsigned char header[MAX_PACK_OBJECT_HEADER], 377 dheader[MAX_PACK_OBJECT_HEADER]; 378unsigned hdrlen; 379 380if(entry->delta) 381 type = (allow_ofs_delta && entry->delta->idx.offset) ? 382 OBJ_OFS_DELTA : OBJ_REF_DELTA; 383 hdrlen =encode_in_pack_object_header(header,sizeof(header), 384 type, entry->size); 385 386 offset = entry->in_pack_offset; 387 revidx =find_pack_revindex(p, offset); 388 datalen = revidx[1].offset - offset; 389if(!pack_to_stdout && p->index_version >1&& 390check_pack_crc(p, &w_curs, offset, datalen, revidx->nr)) { 391error("bad packed object CRC for%s", 392oid_to_hex(&entry->idx.oid)); 393unuse_pack(&w_curs); 394returnwrite_no_reuse_object(f, entry, limit, usable_delta); 395} 396 397 offset += entry->in_pack_header_size; 398 datalen -= entry->in_pack_header_size; 399 400if(!pack_to_stdout && p->index_version ==1&& 401check_pack_inflate(p, &w_curs, offset, datalen, entry->size)) { 402error("corrupt packed object for%s", 403oid_to_hex(&entry->idx.oid)); 404unuse_pack(&w_curs); 405returnwrite_no_reuse_object(f, entry, limit, usable_delta); 406} 407 408if(type == OBJ_OFS_DELTA) { 409 off_t ofs = entry->idx.offset - entry->delta->idx.offset; 410unsigned pos =sizeof(dheader) -1; 411 dheader[pos] = ofs &127; 412while(ofs >>=7) 413 dheader[--pos] =128| (--ofs &127); 414if(limit && hdrlen +sizeof(dheader) - pos + datalen +20>= limit) { 415unuse_pack(&w_curs); 416return0; 417} 418hashwrite(f, header, hdrlen); 419hashwrite(f, dheader + pos,sizeof(dheader) - pos); 420 hdrlen +=sizeof(dheader) - pos; 421 reused_delta++; 422}else if(type == OBJ_REF_DELTA) { 423if(limit && hdrlen +20+ datalen +20>= limit) { 424unuse_pack(&w_curs); 425return0; 426} 427hashwrite(f, header, hdrlen); 428hashwrite(f, entry->delta->idx.oid.hash,20); 429 hdrlen +=20; 430 reused_delta++; 431}else{ 432if(limit && hdrlen + datalen +20>= limit) { 433unuse_pack(&w_curs); 434return0; 435} 436hashwrite(f, header, hdrlen); 437} 438copy_pack_data(f, p, &w_curs, offset, datalen); 439unuse_pack(&w_curs); 440 reused++; 441return hdrlen + datalen; 442} 443 444/* Return 0 if we will bust the pack-size limit */ 445static off_t write_object(struct hashfile *f, 446struct object_entry *entry, 447 off_t write_offset) 448{ 449unsigned long limit; 450 off_t len; 451int usable_delta, to_reuse; 452 453if(!pack_to_stdout) 454crc32_begin(f); 455 456/* apply size limit if limited packsize and not first object */ 457if(!pack_size_limit || !nr_written) 458 limit =0; 459else if(pack_size_limit <= write_offset) 460/* 461 * the earlier object did not fit the limit; avoid 462 * mistaking this with unlimited (i.e. limit = 0). 463 */ 464 limit =1; 465else 466 limit = pack_size_limit - write_offset; 467 468if(!entry->delta) 469 usable_delta =0;/* no delta */ 470else if(!pack_size_limit) 471 usable_delta =1;/* unlimited packfile */ 472else if(entry->delta->idx.offset == (off_t)-1) 473 usable_delta =0;/* base was written to another pack */ 474else if(entry->delta->idx.offset) 475 usable_delta =1;/* base already exists in this pack */ 476else 477 usable_delta =0;/* base could end up in another pack */ 478 479if(!reuse_object) 480 to_reuse =0;/* explicit */ 481else if(!entry->in_pack) 482 to_reuse =0;/* can't reuse what we don't have */ 483else if(entry->type == OBJ_REF_DELTA || entry->type == OBJ_OFS_DELTA) 484/* check_object() decided it for us ... */ 485 to_reuse = usable_delta; 486/* ... but pack split may override that */ 487else if(entry->type != entry->in_pack_type) 488 to_reuse =0;/* pack has delta which is unusable */ 489else if(entry->delta) 490 to_reuse =0;/* we want to pack afresh */ 491else 492 to_reuse =1;/* we have it in-pack undeltified, 493 * and we do not need to deltify it. 494 */ 495 496if(!to_reuse) 497 len =write_no_reuse_object(f, entry, limit, usable_delta); 498else 499 len =write_reuse_object(f, entry, limit, usable_delta); 500if(!len) 501return0; 502 503if(usable_delta) 504 written_delta++; 505 written++; 506if(!pack_to_stdout) 507 entry->idx.crc32 =crc32_end(f); 508return len; 509} 510 511enum write_one_status { 512 WRITE_ONE_SKIP = -1,/* already written */ 513 WRITE_ONE_BREAK =0,/* writing this will bust the limit; not written */ 514 WRITE_ONE_WRITTEN =1,/* normal */ 515 WRITE_ONE_RECURSIVE =2/* already scheduled to be written */ 516}; 517 518static enum write_one_status write_one(struct hashfile *f, 519struct object_entry *e, 520 off_t *offset) 521{ 522 off_t size; 523int recursing; 524 525/* 526 * we set offset to 1 (which is an impossible value) to mark 527 * the fact that this object is involved in "write its base 528 * first before writing a deltified object" recursion. 529 */ 530 recursing = (e->idx.offset ==1); 531if(recursing) { 532warning("recursive delta detected for object%s", 533oid_to_hex(&e->idx.oid)); 534return WRITE_ONE_RECURSIVE; 535}else if(e->idx.offset || e->preferred_base) { 536/* offset is non zero if object is written already. */ 537return WRITE_ONE_SKIP; 538} 539 540/* if we are deltified, write out base object first. */ 541if(e->delta) { 542 e->idx.offset =1;/* now recurse */ 543switch(write_one(f, e->delta, offset)) { 544case WRITE_ONE_RECURSIVE: 545/* we cannot depend on this one */ 546 e->delta = NULL; 547break; 548default: 549break; 550case WRITE_ONE_BREAK: 551 e->idx.offset = recursing; 552return WRITE_ONE_BREAK; 553} 554} 555 556 e->idx.offset = *offset; 557 size =write_object(f, e, *offset); 558if(!size) { 559 e->idx.offset = recursing; 560return WRITE_ONE_BREAK; 561} 562 written_list[nr_written++] = &e->idx; 563 564/* make sure off_t is sufficiently large not to wrap */ 565if(signed_add_overflows(*offset, size)) 566die("pack too large for current definition of off_t"); 567*offset += size; 568return WRITE_ONE_WRITTEN; 569} 570 571static intmark_tagged(const char*path,const struct object_id *oid,int flag, 572void*cb_data) 573{ 574struct object_id peeled; 575struct object_entry *entry =packlist_find(&to_pack, oid->hash, NULL); 576 577if(entry) 578 entry->tagged =1; 579if(!peel_ref(path, &peeled)) { 580 entry =packlist_find(&to_pack, peeled.hash, NULL); 581if(entry) 582 entry->tagged =1; 583} 584return0; 585} 586 587staticinlinevoidadd_to_write_order(struct object_entry **wo, 588unsigned int*endp, 589struct object_entry *e) 590{ 591if(e->filled) 592return; 593 wo[(*endp)++] = e; 594 e->filled =1; 595} 596 597static voidadd_descendants_to_write_order(struct object_entry **wo, 598unsigned int*endp, 599struct object_entry *e) 600{ 601int add_to_order =1; 602while(e) { 603if(add_to_order) { 604struct object_entry *s; 605/* add this node... */ 606add_to_write_order(wo, endp, e); 607/* all its siblings... */ 608for(s = e->delta_sibling; s; s = s->delta_sibling) { 609add_to_write_order(wo, endp, s); 610} 611} 612/* drop down a level to add left subtree nodes if possible */ 613if(e->delta_child) { 614 add_to_order =1; 615 e = e->delta_child; 616}else{ 617 add_to_order =0; 618/* our sibling might have some children, it is next */ 619if(e->delta_sibling) { 620 e = e->delta_sibling; 621continue; 622} 623/* go back to our parent node */ 624 e = e->delta; 625while(e && !e->delta_sibling) { 626/* we're on the right side of a subtree, keep 627 * going up until we can go right again */ 628 e = e->delta; 629} 630if(!e) { 631/* done- we hit our original root node */ 632return; 633} 634/* pass it off to sibling at this level */ 635 e = e->delta_sibling; 636} 637}; 638} 639 640static voidadd_family_to_write_order(struct object_entry **wo, 641unsigned int*endp, 642struct object_entry *e) 643{ 644struct object_entry *root; 645 646for(root = e; root->delta; root = root->delta) 647;/* nothing */ 648add_descendants_to_write_order(wo, endp, root); 649} 650 651static struct object_entry **compute_write_order(void) 652{ 653unsigned int i, wo_end, last_untagged; 654 655struct object_entry **wo; 656struct object_entry *objects = to_pack.objects; 657 658for(i =0; i < to_pack.nr_objects; i++) { 659 objects[i].tagged =0; 660 objects[i].filled =0; 661 objects[i].delta_child = NULL; 662 objects[i].delta_sibling = NULL; 663} 664 665/* 666 * Fully connect delta_child/delta_sibling network. 667 * Make sure delta_sibling is sorted in the original 668 * recency order. 669 */ 670for(i = to_pack.nr_objects; i >0;) { 671struct object_entry *e = &objects[--i]; 672if(!e->delta) 673continue; 674/* Mark me as the first child */ 675 e->delta_sibling = e->delta->delta_child; 676 e->delta->delta_child = e; 677} 678 679/* 680 * Mark objects that are at the tip of tags. 681 */ 682for_each_tag_ref(mark_tagged, NULL); 683 684/* 685 * Give the objects in the original recency order until 686 * we see a tagged tip. 687 */ 688ALLOC_ARRAY(wo, to_pack.nr_objects); 689for(i = wo_end =0; i < to_pack.nr_objects; i++) { 690if(objects[i].tagged) 691break; 692add_to_write_order(wo, &wo_end, &objects[i]); 693} 694 last_untagged = i; 695 696/* 697 * Then fill all the tagged tips. 698 */ 699for(; i < to_pack.nr_objects; i++) { 700if(objects[i].tagged) 701add_to_write_order(wo, &wo_end, &objects[i]); 702} 703 704/* 705 * And then all remaining commits and tags. 706 */ 707for(i = last_untagged; i < to_pack.nr_objects; i++) { 708if(objects[i].type != OBJ_COMMIT && 709 objects[i].type != OBJ_TAG) 710continue; 711add_to_write_order(wo, &wo_end, &objects[i]); 712} 713 714/* 715 * And then all the trees. 716 */ 717for(i = last_untagged; i < to_pack.nr_objects; i++) { 718if(objects[i].type != OBJ_TREE) 719continue; 720add_to_write_order(wo, &wo_end, &objects[i]); 721} 722 723/* 724 * Finally all the rest in really tight order 725 */ 726for(i = last_untagged; i < to_pack.nr_objects; i++) { 727if(!objects[i].filled) 728add_family_to_write_order(wo, &wo_end, &objects[i]); 729} 730 731if(wo_end != to_pack.nr_objects) 732die("ordered%uobjects, expected %"PRIu32, wo_end, to_pack.nr_objects); 733 734return wo; 735} 736 737static off_t write_reused_pack(struct hashfile *f) 738{ 739unsigned char buffer[8192]; 740 off_t to_write, total; 741int fd; 742 743if(!is_pack_valid(reuse_packfile)) 744die("packfile is invalid:%s", reuse_packfile->pack_name); 745 746 fd =git_open(reuse_packfile->pack_name); 747if(fd <0) 748die_errno("unable to open packfile for reuse:%s", 749 reuse_packfile->pack_name); 750 751if(lseek(fd,sizeof(struct pack_header), SEEK_SET) == -1) 752die_errno("unable to seek in reused packfile"); 753 754if(reuse_packfile_offset <0) 755 reuse_packfile_offset = reuse_packfile->pack_size -20; 756 757 total = to_write = reuse_packfile_offset -sizeof(struct pack_header); 758 759while(to_write) { 760int read_pack =xread(fd, buffer,sizeof(buffer)); 761 762if(read_pack <=0) 763die_errno("unable to read from reused packfile"); 764 765if(read_pack > to_write) 766 read_pack = to_write; 767 768hashwrite(f, buffer, read_pack); 769 to_write -= read_pack; 770 771/* 772 * We don't know the actual number of objects written, 773 * only how many bytes written, how many bytes total, and 774 * how many objects total. So we can fake it by pretending all 775 * objects we are writing are the same size. This gives us a 776 * smooth progress meter, and at the end it matches the true 777 * answer. 778 */ 779 written = reuse_packfile_objects * 780(((double)(total - to_write)) / total); 781display_progress(progress_state, written); 782} 783 784close(fd); 785 written = reuse_packfile_objects; 786display_progress(progress_state, written); 787return reuse_packfile_offset -sizeof(struct pack_header); 788} 789 790static const char no_split_warning[] =N_( 791"disabling bitmap writing, packs are split due to pack.packSizeLimit" 792); 793 794static voidwrite_pack_file(void) 795{ 796uint32_t i =0, j; 797struct hashfile *f; 798 off_t offset; 799uint32_t nr_remaining = nr_result; 800time_t last_mtime =0; 801struct object_entry **write_order; 802 803if(progress > pack_to_stdout) 804 progress_state =start_progress(_("Writing objects"), nr_result); 805ALLOC_ARRAY(written_list, to_pack.nr_objects); 806 write_order =compute_write_order(); 807 808do{ 809struct object_id oid; 810char*pack_tmp_name = NULL; 811 812if(pack_to_stdout) 813 f =hashfd_throughput(1,"<stdout>", progress_state); 814else 815 f =create_tmp_packfile(&pack_tmp_name); 816 817 offset =write_pack_header(f, nr_remaining); 818 819if(reuse_packfile) { 820 off_t packfile_size; 821assert(pack_to_stdout); 822 823 packfile_size =write_reused_pack(f); 824 offset += packfile_size; 825} 826 827 nr_written =0; 828for(; i < to_pack.nr_objects; i++) { 829struct object_entry *e = write_order[i]; 830if(write_one(f, e, &offset) == WRITE_ONE_BREAK) 831break; 832display_progress(progress_state, written); 833} 834 835/* 836 * Did we write the wrong # entries in the header? 837 * If so, rewrite it like in fast-import 838 */ 839if(pack_to_stdout) { 840finalize_hashfile(f, oid.hash, CSUM_HASH_IN_STREAM | CSUM_CLOSE); 841}else if(nr_written == nr_remaining) { 842finalize_hashfile(f, oid.hash, CSUM_HASH_IN_STREAM | CSUM_FSYNC | CSUM_CLOSE); 843}else{ 844int fd =finalize_hashfile(f, oid.hash,0); 845fixup_pack_header_footer(fd, oid.hash, pack_tmp_name, 846 nr_written, oid.hash, offset); 847close(fd); 848if(write_bitmap_index) { 849warning(_(no_split_warning)); 850 write_bitmap_index =0; 851} 852} 853 854if(!pack_to_stdout) { 855struct stat st; 856struct strbuf tmpname = STRBUF_INIT; 857 858/* 859 * Packs are runtime accessed in their mtime 860 * order since newer packs are more likely to contain 861 * younger objects. So if we are creating multiple 862 * packs then we should modify the mtime of later ones 863 * to preserve this property. 864 */ 865if(stat(pack_tmp_name, &st) <0) { 866warning_errno("failed to stat%s", pack_tmp_name); 867}else if(!last_mtime) { 868 last_mtime = st.st_mtime; 869}else{ 870struct utimbuf utb; 871 utb.actime = st.st_atime; 872 utb.modtime = --last_mtime; 873if(utime(pack_tmp_name, &utb) <0) 874warning_errno("failed utime() on%s", pack_tmp_name); 875} 876 877strbuf_addf(&tmpname,"%s-", base_name); 878 879if(write_bitmap_index) { 880bitmap_writer_set_checksum(oid.hash); 881bitmap_writer_build_type_index(written_list, nr_written); 882} 883 884finish_tmp_packfile(&tmpname, pack_tmp_name, 885 written_list, nr_written, 886&pack_idx_opts, oid.hash); 887 888if(write_bitmap_index) { 889strbuf_addf(&tmpname,"%s.bitmap",oid_to_hex(&oid)); 890 891stop_progress(&progress_state); 892 893bitmap_writer_show_progress(progress); 894bitmap_writer_reuse_bitmaps(&to_pack); 895bitmap_writer_select_commits(indexed_commits, indexed_commits_nr, -1); 896bitmap_writer_build(&to_pack); 897bitmap_writer_finish(written_list, nr_written, 898 tmpname.buf, write_bitmap_options); 899 write_bitmap_index =0; 900} 901 902strbuf_release(&tmpname); 903free(pack_tmp_name); 904puts(oid_to_hex(&oid)); 905} 906 907/* mark written objects as written to previous pack */ 908for(j =0; j < nr_written; j++) { 909 written_list[j]->offset = (off_t)-1; 910} 911 nr_remaining -= nr_written; 912}while(nr_remaining && i < to_pack.nr_objects); 913 914free(written_list); 915free(write_order); 916stop_progress(&progress_state); 917if(written != nr_result) 918die("wrote %"PRIu32" objects while expecting %"PRIu32, 919 written, nr_result); 920} 921 922static intno_try_delta(const char*path) 923{ 924static struct attr_check *check; 925 926if(!check) 927 check =attr_check_initl("delta", NULL); 928if(git_check_attr(path, check)) 929return0; 930if(ATTR_FALSE(check->items[0].value)) 931return1; 932return0; 933} 934 935/* 936 * When adding an object, check whether we have already added it 937 * to our packing list. If so, we can skip. However, if we are 938 * being asked to excludei t, but the previous mention was to include 939 * it, make sure to adjust its flags and tweak our numbers accordingly. 940 * 941 * As an optimization, we pass out the index position where we would have 942 * found the item, since that saves us from having to look it up again a 943 * few lines later when we want to add the new entry. 944 */ 945static inthave_duplicate_entry(const struct object_id *oid, 946int exclude, 947uint32_t*index_pos) 948{ 949struct object_entry *entry; 950 951 entry =packlist_find(&to_pack, oid->hash, index_pos); 952if(!entry) 953return0; 954 955if(exclude) { 956if(!entry->preferred_base) 957 nr_result--; 958 entry->preferred_base =1; 959} 960 961return1; 962} 963 964static intwant_found_object(int exclude,struct packed_git *p) 965{ 966if(exclude) 967return1; 968if(incremental) 969return0; 970 971/* 972 * When asked to do --local (do not include an object that appears in a 973 * pack we borrow from elsewhere) or --honor-pack-keep (do not include 974 * an object that appears in a pack marked with .keep), finding a pack 975 * that matches the criteria is sufficient for us to decide to omit it. 976 * However, even if this pack does not satisfy the criteria, we need to 977 * make sure no copy of this object appears in _any_ pack that makes us 978 * to omit the object, so we need to check all the packs. 979 * 980 * We can however first check whether these options can possible matter; 981 * if they do not matter we know we want the object in generated pack. 982 * Otherwise, we signal "-1" at the end to tell the caller that we do 983 * not know either way, and it needs to check more packs. 984 */ 985if(!ignore_packed_keep && 986(!local || !have_non_local_packs)) 987return1; 988 989if(local && !p->pack_local) 990return0; 991if(ignore_packed_keep && p->pack_local && p->pack_keep) 992return0; 993 994/* we don't know yet; keep looking for more packs */ 995return-1; 996} 997 998/* 999 * Check whether we want the object in the pack (e.g., we do not want1000 * objects found in non-local stores if the "--local" option was used).1001 *1002 * If the caller already knows an existing pack it wants to take the object1003 * from, that is passed in *found_pack and *found_offset; otherwise this1004 * function finds if there is any pack that has the object and returns the pack1005 * and its offset in these variables.1006 */1007static intwant_object_in_pack(const struct object_id *oid,1008int exclude,1009struct packed_git **found_pack,1010 off_t *found_offset)1011{1012int want;1013struct list_head *pos;10141015if(!exclude && local &&has_loose_object_nonlocal(oid->hash))1016return0;10171018/*1019 * If we already know the pack object lives in, start checks from that1020 * pack - in the usual case when neither --local was given nor .keep files1021 * are present we will determine the answer right now.1022 */1023if(*found_pack) {1024 want =want_found_object(exclude, *found_pack);1025if(want != -1)1026return want;1027}10281029list_for_each(pos, &packed_git_mru) {1030struct packed_git *p =list_entry(pos,struct packed_git, mru);1031 off_t offset;10321033if(p == *found_pack)1034 offset = *found_offset;1035else1036 offset =find_pack_entry_one(oid->hash, p);10371038if(offset) {1039if(!*found_pack) {1040if(!is_pack_valid(p))1041continue;1042*found_offset = offset;1043*found_pack = p;1044}1045 want =want_found_object(exclude, p);1046if(!exclude && want >0)1047list_move(&p->mru, &packed_git_mru);1048if(want != -1)1049return want;1050}1051}10521053return1;1054}10551056static voidcreate_object_entry(const struct object_id *oid,1057enum object_type type,1058uint32_t hash,1059int exclude,1060int no_try_delta,1061uint32_t index_pos,1062struct packed_git *found_pack,1063 off_t found_offset)1064{1065struct object_entry *entry;10661067 entry =packlist_alloc(&to_pack, oid->hash, index_pos);1068 entry->hash = hash;1069if(type)1070 entry->type = type;1071if(exclude)1072 entry->preferred_base =1;1073else1074 nr_result++;1075if(found_pack) {1076 entry->in_pack = found_pack;1077 entry->in_pack_offset = found_offset;1078}10791080 entry->no_try_delta = no_try_delta;1081}10821083static const char no_closure_warning[] =N_(1084"disabling bitmap writing, as some objects are not being packed"1085);10861087static intadd_object_entry(const struct object_id *oid,enum object_type type,1088const char*name,int exclude)1089{1090struct packed_git *found_pack = NULL;1091 off_t found_offset =0;1092uint32_t index_pos;10931094if(have_duplicate_entry(oid, exclude, &index_pos))1095return0;10961097if(!want_object_in_pack(oid, exclude, &found_pack, &found_offset)) {1098/* The pack is missing an object, so it will not have closure */1099if(write_bitmap_index) {1100warning(_(no_closure_warning));1101 write_bitmap_index =0;1102}1103return0;1104}11051106create_object_entry(oid, type,pack_name_hash(name),1107 exclude, name &&no_try_delta(name),1108 index_pos, found_pack, found_offset);11091110display_progress(progress_state, nr_result);1111return1;1112}11131114static intadd_object_entry_from_bitmap(const struct object_id *oid,1115enum object_type type,1116int flags,uint32_t name_hash,1117struct packed_git *pack, off_t offset)1118{1119uint32_t index_pos;11201121if(have_duplicate_entry(oid,0, &index_pos))1122return0;11231124if(!want_object_in_pack(oid,0, &pack, &offset))1125return0;11261127create_object_entry(oid, type, name_hash,0,0, index_pos, pack, offset);11281129display_progress(progress_state, nr_result);1130return1;1131}11321133struct pbase_tree_cache {1134struct object_id oid;1135int ref;1136int temporary;1137void*tree_data;1138unsigned long tree_size;1139};11401141static struct pbase_tree_cache *(pbase_tree_cache[256]);1142static intpbase_tree_cache_ix(const struct object_id *oid)1143{1144return oid->hash[0] %ARRAY_SIZE(pbase_tree_cache);1145}1146static intpbase_tree_cache_ix_incr(int ix)1147{1148return(ix+1) %ARRAY_SIZE(pbase_tree_cache);1149}11501151static struct pbase_tree {1152struct pbase_tree *next;1153/* This is a phony "cache" entry; we are not1154 * going to evict it or find it through _get()1155 * mechanism -- this is for the toplevel node that1156 * would almost always change with any commit.1157 */1158struct pbase_tree_cache pcache;1159} *pbase_tree;11601161static struct pbase_tree_cache *pbase_tree_get(const struct object_id *oid)1162{1163struct pbase_tree_cache *ent, *nent;1164void*data;1165unsigned long size;1166enum object_type type;1167int neigh;1168int my_ix =pbase_tree_cache_ix(oid);1169int available_ix = -1;11701171/* pbase-tree-cache acts as a limited hashtable.1172 * your object will be found at your index or within a few1173 * slots after that slot if it is cached.1174 */1175for(neigh =0; neigh <8; neigh++) {1176 ent = pbase_tree_cache[my_ix];1177if(ent && !oidcmp(&ent->oid, oid)) {1178 ent->ref++;1179return ent;1180}1181else if(((available_ix <0) && (!ent || !ent->ref)) ||1182((0<= available_ix) &&1183(!ent && pbase_tree_cache[available_ix])))1184 available_ix = my_ix;1185if(!ent)1186break;1187 my_ix =pbase_tree_cache_ix_incr(my_ix);1188}11891190/* Did not find one. Either we got a bogus request or1191 * we need to read and perhaps cache.1192 */1193 data =read_sha1_file(oid->hash, &type, &size);1194if(!data)1195return NULL;1196if(type != OBJ_TREE) {1197free(data);1198return NULL;1199}12001201/* We need to either cache or return a throwaway copy */12021203if(available_ix <0)1204 ent = NULL;1205else{1206 ent = pbase_tree_cache[available_ix];1207 my_ix = available_ix;1208}12091210if(!ent) {1211 nent =xmalloc(sizeof(*nent));1212 nent->temporary = (available_ix <0);1213}1214else{1215/* evict and reuse */1216free(ent->tree_data);1217 nent = ent;1218}1219oidcpy(&nent->oid, oid);1220 nent->tree_data = data;1221 nent->tree_size = size;1222 nent->ref =1;1223if(!nent->temporary)1224 pbase_tree_cache[my_ix] = nent;1225return nent;1226}12271228static voidpbase_tree_put(struct pbase_tree_cache *cache)1229{1230if(!cache->temporary) {1231 cache->ref--;1232return;1233}1234free(cache->tree_data);1235free(cache);1236}12371238static intname_cmp_len(const char*name)1239{1240int i;1241for(i =0; name[i] && name[i] !='\n'&& name[i] !='/'; i++)1242;1243return i;1244}12451246static voidadd_pbase_object(struct tree_desc *tree,1247const char*name,1248int cmplen,1249const char*fullname)1250{1251struct name_entry entry;1252int cmp;12531254while(tree_entry(tree,&entry)) {1255if(S_ISGITLINK(entry.mode))1256continue;1257 cmp =tree_entry_len(&entry) != cmplen ?1:1258memcmp(name, entry.path, cmplen);1259if(cmp >0)1260continue;1261if(cmp <0)1262return;1263if(name[cmplen] !='/') {1264add_object_entry(entry.oid,1265object_type(entry.mode),1266 fullname,1);1267return;1268}1269if(S_ISDIR(entry.mode)) {1270struct tree_desc sub;1271struct pbase_tree_cache *tree;1272const char*down = name+cmplen+1;1273int downlen =name_cmp_len(down);12741275 tree =pbase_tree_get(entry.oid);1276if(!tree)1277return;1278init_tree_desc(&sub, tree->tree_data, tree->tree_size);12791280add_pbase_object(&sub, down, downlen, fullname);1281pbase_tree_put(tree);1282}1283}1284}12851286static unsigned*done_pbase_paths;1287static int done_pbase_paths_num;1288static int done_pbase_paths_alloc;1289static intdone_pbase_path_pos(unsigned hash)1290{1291int lo =0;1292int hi = done_pbase_paths_num;1293while(lo < hi) {1294int mi = lo + (hi - lo) /2;1295if(done_pbase_paths[mi] == hash)1296return mi;1297if(done_pbase_paths[mi] < hash)1298 hi = mi;1299else1300 lo = mi +1;1301}1302return-lo-1;1303}13041305static intcheck_pbase_path(unsigned hash)1306{1307int pos =done_pbase_path_pos(hash);1308if(0<= pos)1309return1;1310 pos = -pos -1;1311ALLOC_GROW(done_pbase_paths,1312 done_pbase_paths_num +1,1313 done_pbase_paths_alloc);1314 done_pbase_paths_num++;1315if(pos < done_pbase_paths_num)1316MOVE_ARRAY(done_pbase_paths + pos +1, done_pbase_paths + pos,1317 done_pbase_paths_num - pos -1);1318 done_pbase_paths[pos] = hash;1319return0;1320}13211322static voidadd_preferred_base_object(const char*name)1323{1324struct pbase_tree *it;1325int cmplen;1326unsigned hash =pack_name_hash(name);13271328if(!num_preferred_base ||check_pbase_path(hash))1329return;13301331 cmplen =name_cmp_len(name);1332for(it = pbase_tree; it; it = it->next) {1333if(cmplen ==0) {1334add_object_entry(&it->pcache.oid, OBJ_TREE, NULL,1);1335}1336else{1337struct tree_desc tree;1338init_tree_desc(&tree, it->pcache.tree_data, it->pcache.tree_size);1339add_pbase_object(&tree, name, cmplen, name);1340}1341}1342}13431344static voidadd_preferred_base(struct object_id *oid)1345{1346struct pbase_tree *it;1347void*data;1348unsigned long size;1349struct object_id tree_oid;13501351if(window <= num_preferred_base++)1352return;13531354 data =read_object_with_reference(oid->hash, tree_type, &size, tree_oid.hash);1355if(!data)1356return;13571358for(it = pbase_tree; it; it = it->next) {1359if(!oidcmp(&it->pcache.oid, &tree_oid)) {1360free(data);1361return;1362}1363}13641365 it =xcalloc(1,sizeof(*it));1366 it->next = pbase_tree;1367 pbase_tree = it;13681369oidcpy(&it->pcache.oid, &tree_oid);1370 it->pcache.tree_data = data;1371 it->pcache.tree_size = size;1372}13731374static voidcleanup_preferred_base(void)1375{1376struct pbase_tree *it;1377unsigned i;13781379 it = pbase_tree;1380 pbase_tree = NULL;1381while(it) {1382struct pbase_tree *this= it;1383 it =this->next;1384free(this->pcache.tree_data);1385free(this);1386}13871388for(i =0; i <ARRAY_SIZE(pbase_tree_cache); i++) {1389if(!pbase_tree_cache[i])1390continue;1391free(pbase_tree_cache[i]->tree_data);1392FREE_AND_NULL(pbase_tree_cache[i]);1393}13941395FREE_AND_NULL(done_pbase_paths);1396 done_pbase_paths_num = done_pbase_paths_alloc =0;1397}13981399static voidcheck_object(struct object_entry *entry)1400{1401if(entry->in_pack) {1402struct packed_git *p = entry->in_pack;1403struct pack_window *w_curs = NULL;1404const unsigned char*base_ref = NULL;1405struct object_entry *base_entry;1406unsigned long used, used_0;1407unsigned long avail;1408 off_t ofs;1409unsigned char*buf, c;14101411 buf =use_pack(p, &w_curs, entry->in_pack_offset, &avail);14121413/*1414 * We want in_pack_type even if we do not reuse delta1415 * since non-delta representations could still be reused.1416 */1417 used =unpack_object_header_buffer(buf, avail,1418&entry->in_pack_type,1419&entry->size);1420if(used ==0)1421goto give_up;14221423/*1424 * Determine if this is a delta and if so whether we can1425 * reuse it or not. Otherwise let's find out as cheaply as1426 * possible what the actual type and size for this object is.1427 */1428switch(entry->in_pack_type) {1429default:1430/* Not a delta hence we've already got all we need. */1431 entry->type = entry->in_pack_type;1432 entry->in_pack_header_size = used;1433if(entry->type < OBJ_COMMIT || entry->type > OBJ_BLOB)1434goto give_up;1435unuse_pack(&w_curs);1436return;1437case OBJ_REF_DELTA:1438if(reuse_delta && !entry->preferred_base)1439 base_ref =use_pack(p, &w_curs,1440 entry->in_pack_offset + used, NULL);1441 entry->in_pack_header_size = used +20;1442break;1443case OBJ_OFS_DELTA:1444 buf =use_pack(p, &w_curs,1445 entry->in_pack_offset + used, NULL);1446 used_0 =0;1447 c = buf[used_0++];1448 ofs = c &127;1449while(c &128) {1450 ofs +=1;1451if(!ofs ||MSB(ofs,7)) {1452error("delta base offset overflow in pack for%s",1453oid_to_hex(&entry->idx.oid));1454goto give_up;1455}1456 c = buf[used_0++];1457 ofs = (ofs <<7) + (c &127);1458}1459 ofs = entry->in_pack_offset - ofs;1460if(ofs <=0|| ofs >= entry->in_pack_offset) {1461error("delta base offset out of bound for%s",1462oid_to_hex(&entry->idx.oid));1463goto give_up;1464}1465if(reuse_delta && !entry->preferred_base) {1466struct revindex_entry *revidx;1467 revidx =find_pack_revindex(p, ofs);1468if(!revidx)1469goto give_up;1470 base_ref =nth_packed_object_sha1(p, revidx->nr);1471}1472 entry->in_pack_header_size = used + used_0;1473break;1474}14751476if(base_ref && (base_entry =packlist_find(&to_pack, base_ref, NULL))) {1477/*1478 * If base_ref was set above that means we wish to1479 * reuse delta data, and we even found that base1480 * in the list of objects we want to pack. Goodie!1481 *1482 * Depth value does not matter - find_deltas() will1483 * never consider reused delta as the base object to1484 * deltify other objects against, in order to avoid1485 * circular deltas.1486 */1487 entry->type = entry->in_pack_type;1488 entry->delta = base_entry;1489 entry->delta_size = entry->size;1490 entry->delta_sibling = base_entry->delta_child;1491 base_entry->delta_child = entry;1492unuse_pack(&w_curs);1493return;1494}14951496if(entry->type) {1497/*1498 * This must be a delta and we already know what the1499 * final object type is. Let's extract the actual1500 * object size from the delta header.1501 */1502 entry->size =get_size_from_delta(p, &w_curs,1503 entry->in_pack_offset + entry->in_pack_header_size);1504if(entry->size ==0)1505goto give_up;1506unuse_pack(&w_curs);1507return;1508}15091510/*1511 * No choice but to fall back to the recursive delta walk1512 * with sha1_object_info() to find about the object type1513 * at this point...1514 */1515 give_up:1516unuse_pack(&w_curs);1517}15181519 entry->type =sha1_object_info(entry->idx.oid.hash, &entry->size);1520/*1521 * The error condition is checked in prepare_pack(). This is1522 * to permit a missing preferred base object to be ignored1523 * as a preferred base. Doing so can result in a larger1524 * pack file, but the transfer will still take place.1525 */1526}15271528static intpack_offset_sort(const void*_a,const void*_b)1529{1530const struct object_entry *a = *(struct object_entry **)_a;1531const struct object_entry *b = *(struct object_entry **)_b;15321533/* avoid filesystem trashing with loose objects */1534if(!a->in_pack && !b->in_pack)1535returnoidcmp(&a->idx.oid, &b->idx.oid);15361537if(a->in_pack < b->in_pack)1538return-1;1539if(a->in_pack > b->in_pack)1540return1;1541return a->in_pack_offset < b->in_pack_offset ? -1:1542(a->in_pack_offset > b->in_pack_offset);1543}15441545/*1546 * Drop an on-disk delta we were planning to reuse. Naively, this would1547 * just involve blanking out the "delta" field, but we have to deal1548 * with some extra book-keeping:1549 *1550 * 1. Removing ourselves from the delta_sibling linked list.1551 *1552 * 2. Updating our size/type to the non-delta representation. These were1553 * either not recorded initially (size) or overwritten with the delta type1554 * (type) when check_object() decided to reuse the delta.1555 *1556 * 3. Resetting our delta depth, as we are now a base object.1557 */1558static voiddrop_reused_delta(struct object_entry *entry)1559{1560struct object_entry **p = &entry->delta->delta_child;1561struct object_info oi = OBJECT_INFO_INIT;15621563while(*p) {1564if(*p == entry)1565*p = (*p)->delta_sibling;1566else1567 p = &(*p)->delta_sibling;1568}1569 entry->delta = NULL;1570 entry->depth =0;15711572 oi.sizep = &entry->size;1573 oi.typep = &entry->type;1574if(packed_object_info(entry->in_pack, entry->in_pack_offset, &oi) <0) {1575/*1576 * We failed to get the info from this pack for some reason;1577 * fall back to sha1_object_info, which may find another copy.1578 * And if that fails, the error will be recorded in entry->type1579 * and dealt with in prepare_pack().1580 */1581 entry->type =sha1_object_info(entry->idx.oid.hash,1582&entry->size);1583}1584}15851586/*1587 * Follow the chain of deltas from this entry onward, throwing away any links1588 * that cause us to hit a cycle (as determined by the DFS state flags in1589 * the entries).1590 *1591 * We also detect too-long reused chains that would violate our --depth1592 * limit.1593 */1594static voidbreak_delta_chains(struct object_entry *entry)1595{1596/*1597 * The actual depth of each object we will write is stored as an int,1598 * as it cannot exceed our int "depth" limit. But before we break1599 * changes based no that limit, we may potentially go as deep as the1600 * number of objects, which is elsewhere bounded to a uint32_t.1601 */1602uint32_t total_depth;1603struct object_entry *cur, *next;16041605for(cur = entry, total_depth =0;1606 cur;1607 cur = cur->delta, total_depth++) {1608if(cur->dfs_state == DFS_DONE) {1609/*1610 * We've already seen this object and know it isn't1611 * part of a cycle. We do need to append its depth1612 * to our count.1613 */1614 total_depth += cur->depth;1615break;1616}16171618/*1619 * We break cycles before looping, so an ACTIVE state (or any1620 * other cruft which made its way into the state variable)1621 * is a bug.1622 */1623if(cur->dfs_state != DFS_NONE)1624die("BUG: confusing delta dfs state in first pass:%d",1625 cur->dfs_state);16261627/*1628 * Now we know this is the first time we've seen the object. If1629 * it's not a delta, we're done traversing, but we'll mark it1630 * done to save time on future traversals.1631 */1632if(!cur->delta) {1633 cur->dfs_state = DFS_DONE;1634break;1635}16361637/*1638 * Mark ourselves as active and see if the next step causes1639 * us to cycle to another active object. It's important to do1640 * this _before_ we loop, because it impacts where we make the1641 * cut, and thus how our total_depth counter works.1642 * E.g., We may see a partial loop like:1643 *1644 * A -> B -> C -> D -> B1645 *1646 * Cutting B->C breaks the cycle. But now the depth of A is1647 * only 1, and our total_depth counter is at 3. The size of the1648 * error is always one less than the size of the cycle we1649 * broke. Commits C and D were "lost" from A's chain.1650 *1651 * If we instead cut D->B, then the depth of A is correct at 3.1652 * We keep all commits in the chain that we examined.1653 */1654 cur->dfs_state = DFS_ACTIVE;1655if(cur->delta->dfs_state == DFS_ACTIVE) {1656drop_reused_delta(cur);1657 cur->dfs_state = DFS_DONE;1658break;1659}1660}16611662/*1663 * And now that we've gone all the way to the bottom of the chain, we1664 * need to clear the active flags and set the depth fields as1665 * appropriate. Unlike the loop above, which can quit when it drops a1666 * delta, we need to keep going to look for more depth cuts. So we need1667 * an extra "next" pointer to keep going after we reset cur->delta.1668 */1669for(cur = entry; cur; cur = next) {1670 next = cur->delta;16711672/*1673 * We should have a chain of zero or more ACTIVE states down to1674 * a final DONE. We can quit after the DONE, because either it1675 * has no bases, or we've already handled them in a previous1676 * call.1677 */1678if(cur->dfs_state == DFS_DONE)1679break;1680else if(cur->dfs_state != DFS_ACTIVE)1681die("BUG: confusing delta dfs state in second pass:%d",1682 cur->dfs_state);16831684/*1685 * If the total_depth is more than depth, then we need to snip1686 * the chain into two or more smaller chains that don't exceed1687 * the maximum depth. Most of the resulting chains will contain1688 * (depth + 1) entries (i.e., depth deltas plus one base), and1689 * the last chain (i.e., the one containing entry) will contain1690 * whatever entries are left over, namely1691 * (total_depth % (depth + 1)) of them.1692 *1693 * Since we are iterating towards decreasing depth, we need to1694 * decrement total_depth as we go, and we need to write to the1695 * entry what its final depth will be after all of the1696 * snipping. Since we're snipping into chains of length (depth1697 * + 1) entries, the final depth of an entry will be its1698 * original depth modulo (depth + 1). Any time we encounter an1699 * entry whose final depth is supposed to be zero, we snip it1700 * from its delta base, thereby making it so.1701 */1702 cur->depth = (total_depth--) % (depth +1);1703if(!cur->depth)1704drop_reused_delta(cur);17051706 cur->dfs_state = DFS_DONE;1707}1708}17091710static voidget_object_details(void)1711{1712uint32_t i;1713struct object_entry **sorted_by_offset;17141715 sorted_by_offset =xcalloc(to_pack.nr_objects,sizeof(struct object_entry *));1716for(i =0; i < to_pack.nr_objects; i++)1717 sorted_by_offset[i] = to_pack.objects + i;1718QSORT(sorted_by_offset, to_pack.nr_objects, pack_offset_sort);17191720for(i =0; i < to_pack.nr_objects; i++) {1721struct object_entry *entry = sorted_by_offset[i];1722check_object(entry);1723if(big_file_threshold < entry->size)1724 entry->no_try_delta =1;1725}17261727/*1728 * This must happen in a second pass, since we rely on the delta1729 * information for the whole list being completed.1730 */1731for(i =0; i < to_pack.nr_objects; i++)1732break_delta_chains(&to_pack.objects[i]);17331734free(sorted_by_offset);1735}17361737/*1738 * We search for deltas in a list sorted by type, by filename hash, and then1739 * by size, so that we see progressively smaller and smaller files.1740 * That's because we prefer deltas to be from the bigger file1741 * to the smaller -- deletes are potentially cheaper, but perhaps1742 * more importantly, the bigger file is likely the more recent1743 * one. The deepest deltas are therefore the oldest objects which are1744 * less susceptible to be accessed often.1745 */1746static inttype_size_sort(const void*_a,const void*_b)1747{1748const struct object_entry *a = *(struct object_entry **)_a;1749const struct object_entry *b = *(struct object_entry **)_b;17501751if(a->type > b->type)1752return-1;1753if(a->type < b->type)1754return1;1755if(a->hash > b->hash)1756return-1;1757if(a->hash < b->hash)1758return1;1759if(a->preferred_base > b->preferred_base)1760return-1;1761if(a->preferred_base < b->preferred_base)1762return1;1763if(a->size > b->size)1764return-1;1765if(a->size < b->size)1766return1;1767return a < b ? -1: (a > b);/* newest first */1768}17691770struct unpacked {1771struct object_entry *entry;1772void*data;1773struct delta_index *index;1774unsigned depth;1775};17761777static intdelta_cacheable(unsigned long src_size,unsigned long trg_size,1778unsigned long delta_size)1779{1780if(max_delta_cache_size && delta_cache_size + delta_size > max_delta_cache_size)1781return0;17821783if(delta_size < cache_max_small_delta_size)1784return1;17851786/* cache delta, if objects are large enough compared to delta size */1787if((src_size >>20) + (trg_size >>21) > (delta_size >>10))1788return1;17891790return0;1791}17921793#ifndef NO_PTHREADS17941795static pthread_mutex_t read_mutex;1796#define read_lock() pthread_mutex_lock(&read_mutex)1797#define read_unlock() pthread_mutex_unlock(&read_mutex)17981799static pthread_mutex_t cache_mutex;1800#define cache_lock() pthread_mutex_lock(&cache_mutex)1801#define cache_unlock() pthread_mutex_unlock(&cache_mutex)18021803static pthread_mutex_t progress_mutex;1804#define progress_lock() pthread_mutex_lock(&progress_mutex)1805#define progress_unlock() pthread_mutex_unlock(&progress_mutex)18061807#else18081809#define read_lock() (void)01810#define read_unlock() (void)01811#define cache_lock() (void)01812#define cache_unlock() (void)01813#define progress_lock() (void)01814#define progress_unlock() (void)018151816#endif18171818static inttry_delta(struct unpacked *trg,struct unpacked *src,1819unsigned max_depth,unsigned long*mem_usage)1820{1821struct object_entry *trg_entry = trg->entry;1822struct object_entry *src_entry = src->entry;1823unsigned long trg_size, src_size, delta_size, sizediff, max_size, sz;1824unsigned ref_depth;1825enum object_type type;1826void*delta_buf;18271828/* Don't bother doing diffs between different types */1829if(trg_entry->type != src_entry->type)1830return-1;18311832/*1833 * We do not bother to try a delta that we discarded on an1834 * earlier try, but only when reusing delta data. Note that1835 * src_entry that is marked as the preferred_base should always1836 * be considered, as even if we produce a suboptimal delta against1837 * it, we will still save the transfer cost, as we already know1838 * the other side has it and we won't send src_entry at all.1839 */1840if(reuse_delta && trg_entry->in_pack &&1841 trg_entry->in_pack == src_entry->in_pack &&1842!src_entry->preferred_base &&1843 trg_entry->in_pack_type != OBJ_REF_DELTA &&1844 trg_entry->in_pack_type != OBJ_OFS_DELTA)1845return0;18461847/* Let's not bust the allowed depth. */1848if(src->depth >= max_depth)1849return0;18501851/* Now some size filtering heuristics. */1852 trg_size = trg_entry->size;1853if(!trg_entry->delta) {1854 max_size = trg_size/2-20;1855 ref_depth =1;1856}else{1857 max_size = trg_entry->delta_size;1858 ref_depth = trg->depth;1859}1860 max_size = (uint64_t)max_size * (max_depth - src->depth) /1861(max_depth - ref_depth +1);1862if(max_size ==0)1863return0;1864 src_size = src_entry->size;1865 sizediff = src_size < trg_size ? trg_size - src_size :0;1866if(sizediff >= max_size)1867return0;1868if(trg_size < src_size /32)1869return0;18701871/* Load data if not already done */1872if(!trg->data) {1873read_lock();1874 trg->data =read_sha1_file(trg_entry->idx.oid.hash, &type,1875&sz);1876read_unlock();1877if(!trg->data)1878die("object%scannot be read",1879oid_to_hex(&trg_entry->idx.oid));1880if(sz != trg_size)1881die("object%sinconsistent object length (%lu vs%lu)",1882oid_to_hex(&trg_entry->idx.oid), sz,1883 trg_size);1884*mem_usage += sz;1885}1886if(!src->data) {1887read_lock();1888 src->data =read_sha1_file(src_entry->idx.oid.hash, &type,1889&sz);1890read_unlock();1891if(!src->data) {1892if(src_entry->preferred_base) {1893static int warned =0;1894if(!warned++)1895warning("object%scannot be read",1896oid_to_hex(&src_entry->idx.oid));1897/*1898 * Those objects are not included in the1899 * resulting pack. Be resilient and ignore1900 * them if they can't be read, in case the1901 * pack could be created nevertheless.1902 */1903return0;1904}1905die("object%scannot be read",1906oid_to_hex(&src_entry->idx.oid));1907}1908if(sz != src_size)1909die("object%sinconsistent object length (%lu vs%lu)",1910oid_to_hex(&src_entry->idx.oid), sz,1911 src_size);1912*mem_usage += sz;1913}1914if(!src->index) {1915 src->index =create_delta_index(src->data, src_size);1916if(!src->index) {1917static int warned =0;1918if(!warned++)1919warning("suboptimal pack - out of memory");1920return0;1921}1922*mem_usage +=sizeof_delta_index(src->index);1923}19241925 delta_buf =create_delta(src->index, trg->data, trg_size, &delta_size, max_size);1926if(!delta_buf)1927return0;19281929if(trg_entry->delta) {1930/* Prefer only shallower same-sized deltas. */1931if(delta_size == trg_entry->delta_size &&1932 src->depth +1>= trg->depth) {1933free(delta_buf);1934return0;1935}1936}19371938/*1939 * Handle memory allocation outside of the cache1940 * accounting lock. Compiler will optimize the strangeness1941 * away when NO_PTHREADS is defined.1942 */1943free(trg_entry->delta_data);1944cache_lock();1945if(trg_entry->delta_data) {1946 delta_cache_size -= trg_entry->delta_size;1947 trg_entry->delta_data = NULL;1948}1949if(delta_cacheable(src_size, trg_size, delta_size)) {1950 delta_cache_size += delta_size;1951cache_unlock();1952 trg_entry->delta_data =xrealloc(delta_buf, delta_size);1953}else{1954cache_unlock();1955free(delta_buf);1956}19571958 trg_entry->delta = src_entry;1959 trg_entry->delta_size = delta_size;1960 trg->depth = src->depth +1;19611962return1;1963}19641965static unsigned intcheck_delta_limit(struct object_entry *me,unsigned int n)1966{1967struct object_entry *child = me->delta_child;1968unsigned int m = n;1969while(child) {1970unsigned int c =check_delta_limit(child, n +1);1971if(m < c)1972 m = c;1973 child = child->delta_sibling;1974}1975return m;1976}19771978static unsigned longfree_unpacked(struct unpacked *n)1979{1980unsigned long freed_mem =sizeof_delta_index(n->index);1981free_delta_index(n->index);1982 n->index = NULL;1983if(n->data) {1984 freed_mem += n->entry->size;1985FREE_AND_NULL(n->data);1986}1987 n->entry = NULL;1988 n->depth =0;1989return freed_mem;1990}19911992static voidfind_deltas(struct object_entry **list,unsigned*list_size,1993int window,int depth,unsigned*processed)1994{1995uint32_t i, idx =0, count =0;1996struct unpacked *array;1997unsigned long mem_usage =0;19981999 array =xcalloc(window,sizeof(struct unpacked));20002001for(;;) {2002struct object_entry *entry;2003struct unpacked *n = array + idx;2004int j, max_depth, best_base = -1;20052006progress_lock();2007if(!*list_size) {2008progress_unlock();2009break;2010}2011 entry = *list++;2012(*list_size)--;2013if(!entry->preferred_base) {2014(*processed)++;2015display_progress(progress_state, *processed);2016}2017progress_unlock();20182019 mem_usage -=free_unpacked(n);2020 n->entry = entry;20212022while(window_memory_limit &&2023 mem_usage > window_memory_limit &&2024 count >1) {2025uint32_t tail = (idx + window - count) % window;2026 mem_usage -=free_unpacked(array + tail);2027 count--;2028}20292030/* We do not compute delta to *create* objects we are not2031 * going to pack.2032 */2033if(entry->preferred_base)2034goto next;20352036/*2037 * If the current object is at pack edge, take the depth the2038 * objects that depend on the current object into account2039 * otherwise they would become too deep.2040 */2041 max_depth = depth;2042if(entry->delta_child) {2043 max_depth -=check_delta_limit(entry,0);2044if(max_depth <=0)2045goto next;2046}20472048 j = window;2049while(--j >0) {2050int ret;2051uint32_t other_idx = idx + j;2052struct unpacked *m;2053if(other_idx >= window)2054 other_idx -= window;2055 m = array + other_idx;2056if(!m->entry)2057break;2058 ret =try_delta(n, m, max_depth, &mem_usage);2059if(ret <0)2060break;2061else if(ret >0)2062 best_base = other_idx;2063}20642065/*2066 * If we decided to cache the delta data, then it is best2067 * to compress it right away. First because we have to do2068 * it anyway, and doing it here while we're threaded will2069 * save a lot of time in the non threaded write phase,2070 * as well as allow for caching more deltas within2071 * the same cache size limit.2072 * ...2073 * But only if not writing to stdout, since in that case2074 * the network is most likely throttling writes anyway,2075 * and therefore it is best to go to the write phase ASAP2076 * instead, as we can afford spending more time compressing2077 * between writes at that moment.2078 */2079if(entry->delta_data && !pack_to_stdout) {2080 entry->z_delta_size =do_compress(&entry->delta_data,2081 entry->delta_size);2082cache_lock();2083 delta_cache_size -= entry->delta_size;2084 delta_cache_size += entry->z_delta_size;2085cache_unlock();2086}20872088/* if we made n a delta, and if n is already at max2089 * depth, leaving it in the window is pointless. we2090 * should evict it first.2091 */2092if(entry->delta && max_depth <= n->depth)2093continue;20942095/*2096 * Move the best delta base up in the window, after the2097 * currently deltified object, to keep it longer. It will2098 * be the first base object to be attempted next.2099 */2100if(entry->delta) {2101struct unpacked swap = array[best_base];2102int dist = (window + idx - best_base) % window;2103int dst = best_base;2104while(dist--) {2105int src = (dst +1) % window;2106 array[dst] = array[src];2107 dst = src;2108}2109 array[dst] = swap;2110}21112112 next:2113 idx++;2114if(count +1< window)2115 count++;2116if(idx >= window)2117 idx =0;2118}21192120for(i =0; i < window; ++i) {2121free_delta_index(array[i].index);2122free(array[i].data);2123}2124free(array);2125}21262127#ifndef NO_PTHREADS21282129static voidtry_to_free_from_threads(size_t size)2130{2131read_lock();2132release_pack_memory(size);2133read_unlock();2134}21352136static try_to_free_t old_try_to_free_routine;21372138/*2139 * The main thread waits on the condition that (at least) one of the workers2140 * has stopped working (which is indicated in the .working member of2141 * struct thread_params).2142 * When a work thread has completed its work, it sets .working to 0 and2143 * signals the main thread and waits on the condition that .data_ready2144 * becomes 1.2145 */21462147struct thread_params {2148 pthread_t thread;2149struct object_entry **list;2150unsigned list_size;2151unsigned remaining;2152int window;2153int depth;2154int working;2155int data_ready;2156 pthread_mutex_t mutex;2157 pthread_cond_t cond;2158unsigned*processed;2159};21602161static pthread_cond_t progress_cond;21622163/*2164 * Mutex and conditional variable can't be statically-initialized on Windows.2165 */2166static voidinit_threaded_search(void)2167{2168init_recursive_mutex(&read_mutex);2169pthread_mutex_init(&cache_mutex, NULL);2170pthread_mutex_init(&progress_mutex, NULL);2171pthread_cond_init(&progress_cond, NULL);2172 old_try_to_free_routine =set_try_to_free_routine(try_to_free_from_threads);2173}21742175static voidcleanup_threaded_search(void)2176{2177set_try_to_free_routine(old_try_to_free_routine);2178pthread_cond_destroy(&progress_cond);2179pthread_mutex_destroy(&read_mutex);2180pthread_mutex_destroy(&cache_mutex);2181pthread_mutex_destroy(&progress_mutex);2182}21832184static void*threaded_find_deltas(void*arg)2185{2186struct thread_params *me = arg;21872188progress_lock();2189while(me->remaining) {2190progress_unlock();21912192find_deltas(me->list, &me->remaining,2193 me->window, me->depth, me->processed);21942195progress_lock();2196 me->working =0;2197pthread_cond_signal(&progress_cond);2198progress_unlock();21992200/*2201 * We must not set ->data_ready before we wait on the2202 * condition because the main thread may have set it to 12203 * before we get here. In order to be sure that new2204 * work is available if we see 1 in ->data_ready, it2205 * was initialized to 0 before this thread was spawned2206 * and we reset it to 0 right away.2207 */2208pthread_mutex_lock(&me->mutex);2209while(!me->data_ready)2210pthread_cond_wait(&me->cond, &me->mutex);2211 me->data_ready =0;2212pthread_mutex_unlock(&me->mutex);22132214progress_lock();2215}2216progress_unlock();2217/* leave ->working 1 so that this doesn't get more work assigned */2218return NULL;2219}22202221static voidll_find_deltas(struct object_entry **list,unsigned list_size,2222int window,int depth,unsigned*processed)2223{2224struct thread_params *p;2225int i, ret, active_threads =0;22262227init_threaded_search();22282229if(delta_search_threads <=1) {2230find_deltas(list, &list_size, window, depth, processed);2231cleanup_threaded_search();2232return;2233}2234if(progress > pack_to_stdout)2235fprintf(stderr,"Delta compression using up to%dthreads.\n",2236 delta_search_threads);2237 p =xcalloc(delta_search_threads,sizeof(*p));22382239/* Partition the work amongst work threads. */2240for(i =0; i < delta_search_threads; i++) {2241unsigned sub_size = list_size / (delta_search_threads - i);22422243/* don't use too small segments or no deltas will be found */2244if(sub_size <2*window && i+1< delta_search_threads)2245 sub_size =0;22462247 p[i].window = window;2248 p[i].depth = depth;2249 p[i].processed = processed;2250 p[i].working =1;2251 p[i].data_ready =0;22522253/* try to split chunks on "path" boundaries */2254while(sub_size && sub_size < list_size &&2255 list[sub_size]->hash &&2256 list[sub_size]->hash == list[sub_size-1]->hash)2257 sub_size++;22582259 p[i].list = list;2260 p[i].list_size = sub_size;2261 p[i].remaining = sub_size;22622263 list += sub_size;2264 list_size -= sub_size;2265}22662267/* Start work threads. */2268for(i =0; i < delta_search_threads; i++) {2269if(!p[i].list_size)2270continue;2271pthread_mutex_init(&p[i].mutex, NULL);2272pthread_cond_init(&p[i].cond, NULL);2273 ret =pthread_create(&p[i].thread, NULL,2274 threaded_find_deltas, &p[i]);2275if(ret)2276die("unable to create thread:%s",strerror(ret));2277 active_threads++;2278}22792280/*2281 * Now let's wait for work completion. Each time a thread is done2282 * with its work, we steal half of the remaining work from the2283 * thread with the largest number of unprocessed objects and give2284 * it to that newly idle thread. This ensure good load balancing2285 * until the remaining object list segments are simply too short2286 * to be worth splitting anymore.2287 */2288while(active_threads) {2289struct thread_params *target = NULL;2290struct thread_params *victim = NULL;2291unsigned sub_size =0;22922293progress_lock();2294for(;;) {2295for(i =0; !target && i < delta_search_threads; i++)2296if(!p[i].working)2297 target = &p[i];2298if(target)2299break;2300pthread_cond_wait(&progress_cond, &progress_mutex);2301}23022303for(i =0; i < delta_search_threads; i++)2304if(p[i].remaining >2*window &&2305(!victim || victim->remaining < p[i].remaining))2306 victim = &p[i];2307if(victim) {2308 sub_size = victim->remaining /2;2309 list = victim->list + victim->list_size - sub_size;2310while(sub_size && list[0]->hash &&2311 list[0]->hash == list[-1]->hash) {2312 list++;2313 sub_size--;2314}2315if(!sub_size) {2316/*2317 * It is possible for some "paths" to have2318 * so many objects that no hash boundary2319 * might be found. Let's just steal the2320 * exact half in that case.2321 */2322 sub_size = victim->remaining /2;2323 list -= sub_size;2324}2325 target->list = list;2326 victim->list_size -= sub_size;2327 victim->remaining -= sub_size;2328}2329 target->list_size = sub_size;2330 target->remaining = sub_size;2331 target->working =1;2332progress_unlock();23332334pthread_mutex_lock(&target->mutex);2335 target->data_ready =1;2336pthread_cond_signal(&target->cond);2337pthread_mutex_unlock(&target->mutex);23382339if(!sub_size) {2340pthread_join(target->thread, NULL);2341pthread_cond_destroy(&target->cond);2342pthread_mutex_destroy(&target->mutex);2343 active_threads--;2344}2345}2346cleanup_threaded_search();2347free(p);2348}23492350#else2351#define ll_find_deltas(l, s, w, d, p) find_deltas(l, &s, w, d, p)2352#endif23532354static voidadd_tag_chain(const struct object_id *oid)2355{2356struct tag *tag;23572358/*2359 * We catch duplicates already in add_object_entry(), but we'd2360 * prefer to do this extra check to avoid having to parse the2361 * tag at all if we already know that it's being packed (e.g., if2362 * it was included via bitmaps, we would not have parsed it2363 * previously).2364 */2365if(packlist_find(&to_pack, oid->hash, NULL))2366return;23672368 tag =lookup_tag(oid);2369while(1) {2370if(!tag ||parse_tag(tag) || !tag->tagged)2371die("unable to pack objects reachable from tag%s",2372oid_to_hex(oid));23732374add_object_entry(&tag->object.oid, OBJ_TAG, NULL,0);23752376if(tag->tagged->type != OBJ_TAG)2377return;23782379 tag = (struct tag *)tag->tagged;2380}2381}23822383static intadd_ref_tag(const char*path,const struct object_id *oid,int flag,void*cb_data)2384{2385struct object_id peeled;23862387if(starts_with(path,"refs/tags/") &&/* is a tag? */2388!peel_ref(path, &peeled) &&/* peelable? */2389packlist_find(&to_pack, peeled.hash, NULL))/* object packed? */2390add_tag_chain(oid);2391return0;2392}23932394static voidprepare_pack(int window,int depth)2395{2396struct object_entry **delta_list;2397uint32_t i, nr_deltas;2398unsigned n;23992400get_object_details();24012402/*2403 * If we're locally repacking then we need to be doubly careful2404 * from now on in order to make sure no stealth corruption gets2405 * propagated to the new pack. Clients receiving streamed packs2406 * should validate everything they get anyway so no need to incur2407 * the additional cost here in that case.2408 */2409if(!pack_to_stdout)2410 do_check_packed_object_crc =1;24112412if(!to_pack.nr_objects || !window || !depth)2413return;24142415ALLOC_ARRAY(delta_list, to_pack.nr_objects);2416 nr_deltas = n =0;24172418for(i =0; i < to_pack.nr_objects; i++) {2419struct object_entry *entry = to_pack.objects + i;24202421if(entry->delta)2422/* This happens if we decided to reuse existing2423 * delta from a pack. "reuse_delta &&" is implied.2424 */2425continue;24262427if(entry->size <50)2428continue;24292430if(entry->no_try_delta)2431continue;24322433if(!entry->preferred_base) {2434 nr_deltas++;2435if(entry->type <0)2436die("unable to get type of object%s",2437oid_to_hex(&entry->idx.oid));2438}else{2439if(entry->type <0) {2440/*2441 * This object is not found, but we2442 * don't have to include it anyway.2443 */2444continue;2445}2446}24472448 delta_list[n++] = entry;2449}24502451if(nr_deltas && n >1) {2452unsigned nr_done =0;2453if(progress)2454 progress_state =start_progress(_("Compressing objects"),2455 nr_deltas);2456QSORT(delta_list, n, type_size_sort);2457ll_find_deltas(delta_list, n, window+1, depth, &nr_done);2458stop_progress(&progress_state);2459if(nr_done != nr_deltas)2460die("inconsistency with delta count");2461}2462free(delta_list);2463}24642465static intgit_pack_config(const char*k,const char*v,void*cb)2466{2467if(!strcmp(k,"pack.window")) {2468 window =git_config_int(k, v);2469return0;2470}2471if(!strcmp(k,"pack.windowmemory")) {2472 window_memory_limit =git_config_ulong(k, v);2473return0;2474}2475if(!strcmp(k,"pack.depth")) {2476 depth =git_config_int(k, v);2477return0;2478}2479if(!strcmp(k,"pack.deltacachesize")) {2480 max_delta_cache_size =git_config_int(k, v);2481return0;2482}2483if(!strcmp(k,"pack.deltacachelimit")) {2484 cache_max_small_delta_size =git_config_int(k, v);2485return0;2486}2487if(!strcmp(k,"pack.writebitmaphashcache")) {2488if(git_config_bool(k, v))2489 write_bitmap_options |= BITMAP_OPT_HASH_CACHE;2490else2491 write_bitmap_options &= ~BITMAP_OPT_HASH_CACHE;2492}2493if(!strcmp(k,"pack.usebitmaps")) {2494 use_bitmap_index_default =git_config_bool(k, v);2495return0;2496}2497if(!strcmp(k,"pack.threads")) {2498 delta_search_threads =git_config_int(k, v);2499if(delta_search_threads <0)2500die("invalid number of threads specified (%d)",2501 delta_search_threads);2502#ifdef NO_PTHREADS2503if(delta_search_threads !=1) {2504warning("no threads support, ignoring%s", k);2505 delta_search_threads =0;2506}2507#endif2508return0;2509}2510if(!strcmp(k,"pack.indexversion")) {2511 pack_idx_opts.version =git_config_int(k, v);2512if(pack_idx_opts.version >2)2513die("bad pack.indexversion=%"PRIu32,2514 pack_idx_opts.version);2515return0;2516}2517returngit_default_config(k, v, cb);2518}25192520static voidread_object_list_from_stdin(void)2521{2522char line[GIT_MAX_HEXSZ +1+ PATH_MAX +2];2523struct object_id oid;2524const char*p;25252526for(;;) {2527if(!fgets(line,sizeof(line), stdin)) {2528if(feof(stdin))2529break;2530if(!ferror(stdin))2531die("fgets returned NULL, not EOF, not error!");2532if(errno != EINTR)2533die_errno("fgets");2534clearerr(stdin);2535continue;2536}2537if(line[0] =='-') {2538if(get_oid_hex(line+1, &oid))2539die("expected edge object ID, got garbage:\n%s",2540 line);2541add_preferred_base(&oid);2542continue;2543}2544if(parse_oid_hex(line, &oid, &p))2545die("expected object ID, got garbage:\n%s", line);25462547add_preferred_base_object(p +1);2548add_object_entry(&oid,0, p +1,0);2549}2550}25512552#define OBJECT_ADDED (1u<<20)25532554static voidshow_commit(struct commit *commit,void*data)2555{2556add_object_entry(&commit->object.oid, OBJ_COMMIT, NULL,0);2557 commit->object.flags |= OBJECT_ADDED;25582559if(write_bitmap_index)2560index_commit_for_bitmap(commit);2561}25622563static voidshow_object(struct object *obj,const char*name,void*data)2564{2565add_preferred_base_object(name);2566add_object_entry(&obj->oid, obj->type, name,0);2567 obj->flags |= OBJECT_ADDED;2568}25692570static voidshow_object__ma_allow_any(struct object *obj,const char*name,void*data)2571{2572assert(arg_missing_action == MA_ALLOW_ANY);25732574/*2575 * Quietly ignore ALL missing objects. This avoids problems with2576 * staging them now and getting an odd error later.2577 */2578if(!has_object_file(&obj->oid))2579return;25802581show_object(obj, name, data);2582}25832584static voidshow_object__ma_allow_promisor(struct object *obj,const char*name,void*data)2585{2586assert(arg_missing_action == MA_ALLOW_PROMISOR);25872588/*2589 * Quietly ignore EXPECTED missing objects. This avoids problems with2590 * staging them now and getting an odd error later.2591 */2592if(!has_object_file(&obj->oid) &&is_promisor_object(&obj->oid))2593return;25942595show_object(obj, name, data);2596}25972598static intoption_parse_missing_action(const struct option *opt,2599const char*arg,int unset)2600{2601assert(arg);2602assert(!unset);26032604if(!strcmp(arg,"error")) {2605 arg_missing_action = MA_ERROR;2606 fn_show_object = show_object;2607return0;2608}26092610if(!strcmp(arg,"allow-any")) {2611 arg_missing_action = MA_ALLOW_ANY;2612 fetch_if_missing =0;2613 fn_show_object = show_object__ma_allow_any;2614return0;2615}26162617if(!strcmp(arg,"allow-promisor")) {2618 arg_missing_action = MA_ALLOW_PROMISOR;2619 fetch_if_missing =0;2620 fn_show_object = show_object__ma_allow_promisor;2621return0;2622}26232624die(_("invalid value for --missing"));2625return0;2626}26272628static voidshow_edge(struct commit *commit)2629{2630add_preferred_base(&commit->object.oid);2631}26322633struct in_pack_object {2634 off_t offset;2635struct object *object;2636};26372638struct in_pack {2639unsigned int alloc;2640unsigned int nr;2641struct in_pack_object *array;2642};26432644static voidmark_in_pack_object(struct object *object,struct packed_git *p,struct in_pack *in_pack)2645{2646 in_pack->array[in_pack->nr].offset =find_pack_entry_one(object->oid.hash, p);2647 in_pack->array[in_pack->nr].object = object;2648 in_pack->nr++;2649}26502651/*2652 * Compare the objects in the offset order, in order to emulate the2653 * "git rev-list --objects" output that produced the pack originally.2654 */2655static intofscmp(const void*a_,const void*b_)2656{2657struct in_pack_object *a = (struct in_pack_object *)a_;2658struct in_pack_object *b = (struct in_pack_object *)b_;26592660if(a->offset < b->offset)2661return-1;2662else if(a->offset > b->offset)2663return1;2664else2665returnoidcmp(&a->object->oid, &b->object->oid);2666}26672668static voidadd_objects_in_unpacked_packs(struct rev_info *revs)2669{2670struct packed_git *p;2671struct in_pack in_pack;2672uint32_t i;26732674memset(&in_pack,0,sizeof(in_pack));26752676for(p = packed_git; p; p = p->next) {2677struct object_id oid;2678struct object *o;26792680if(!p->pack_local || p->pack_keep)2681continue;2682if(open_pack_index(p))2683die("cannot open pack index");26842685ALLOC_GROW(in_pack.array,2686 in_pack.nr + p->num_objects,2687 in_pack.alloc);26882689for(i =0; i < p->num_objects; i++) {2690nth_packed_object_oid(&oid, p, i);2691 o =lookup_unknown_object(oid.hash);2692if(!(o->flags & OBJECT_ADDED))2693mark_in_pack_object(o, p, &in_pack);2694 o->flags |= OBJECT_ADDED;2695}2696}26972698if(in_pack.nr) {2699QSORT(in_pack.array, in_pack.nr, ofscmp);2700for(i =0; i < in_pack.nr; i++) {2701struct object *o = in_pack.array[i].object;2702add_object_entry(&o->oid, o->type,"",0);2703}2704}2705free(in_pack.array);2706}27072708static intadd_loose_object(const struct object_id *oid,const char*path,2709void*data)2710{2711enum object_type type =sha1_object_info(oid->hash, NULL);27122713if(type <0) {2714warning("loose object at%scould not be examined", path);2715return0;2716}27172718add_object_entry(oid, type,"",0);2719return0;2720}27212722/*2723 * We actually don't even have to worry about reachability here.2724 * add_object_entry will weed out duplicates, so we just add every2725 * loose object we find.2726 */2727static voidadd_unreachable_loose_objects(void)2728{2729for_each_loose_file_in_objdir(get_object_directory(),2730 add_loose_object,2731 NULL, NULL, NULL);2732}27332734static inthas_sha1_pack_kept_or_nonlocal(const struct object_id *oid)2735{2736static struct packed_git *last_found = (void*)1;2737struct packed_git *p;27382739 p = (last_found != (void*)1) ? last_found : packed_git;27402741while(p) {2742if((!p->pack_local || p->pack_keep) &&2743find_pack_entry_one(oid->hash, p)) {2744 last_found = p;2745return1;2746}2747if(p == last_found)2748 p = packed_git;2749else2750 p = p->next;2751if(p == last_found)2752 p = p->next;2753}2754return0;2755}27562757/*2758 * Store a list of sha1s that are should not be discarded2759 * because they are either written too recently, or are2760 * reachable from another object that was.2761 *2762 * This is filled by get_object_list.2763 */2764static struct oid_array recent_objects;27652766static intloosened_object_can_be_discarded(const struct object_id *oid,2767 timestamp_t mtime)2768{2769if(!unpack_unreachable_expiration)2770return0;2771if(mtime > unpack_unreachable_expiration)2772return0;2773if(oid_array_lookup(&recent_objects, oid) >=0)2774return0;2775return1;2776}27772778static voidloosen_unused_packed_objects(struct rev_info *revs)2779{2780struct packed_git *p;2781uint32_t i;2782struct object_id oid;27832784for(p = packed_git; p; p = p->next) {2785if(!p->pack_local || p->pack_keep)2786continue;27872788if(open_pack_index(p))2789die("cannot open pack index");27902791for(i =0; i < p->num_objects; i++) {2792nth_packed_object_oid(&oid, p, i);2793if(!packlist_find(&to_pack, oid.hash, NULL) &&2794!has_sha1_pack_kept_or_nonlocal(&oid) &&2795!loosened_object_can_be_discarded(&oid, p->mtime))2796if(force_object_loose(&oid, p->mtime))2797die("unable to force loose object");2798}2799}2800}28012802/*2803 * This tracks any options which pack-reuse code expects to be on, or which a2804 * reader of the pack might not understand, and which would therefore prevent2805 * blind reuse of what we have on disk.2806 */2807static intpack_options_allow_reuse(void)2808{2809return pack_to_stdout &&2810 allow_ofs_delta &&2811!ignore_packed_keep &&2812(!local || !have_non_local_packs) &&2813!incremental;2814}28152816static intget_object_list_from_bitmap(struct rev_info *revs)2817{2818if(prepare_bitmap_walk(revs) <0)2819return-1;28202821if(pack_options_allow_reuse() &&2822!reuse_partial_packfile_from_bitmap(2823&reuse_packfile,2824&reuse_packfile_objects,2825&reuse_packfile_offset)) {2826assert(reuse_packfile_objects);2827 nr_result += reuse_packfile_objects;2828display_progress(progress_state, nr_result);2829}28302831traverse_bitmap_commit_list(&add_object_entry_from_bitmap);2832return0;2833}28342835static voidrecord_recent_object(struct object *obj,2836const char*name,2837void*data)2838{2839oid_array_append(&recent_objects, &obj->oid);2840}28412842static voidrecord_recent_commit(struct commit *commit,void*data)2843{2844oid_array_append(&recent_objects, &commit->object.oid);2845}28462847static voidget_object_list(int ac,const char**av)2848{2849struct rev_info revs;2850char line[1000];2851int flags =0;28522853init_revisions(&revs, NULL);2854 save_commit_buffer =0;2855setup_revisions(ac, av, &revs, NULL);28562857/* make sure shallows are read */2858is_repository_shallow();28592860while(fgets(line,sizeof(line), stdin) != NULL) {2861int len =strlen(line);2862if(len && line[len -1] =='\n')2863 line[--len] =0;2864if(!len)2865break;2866if(*line =='-') {2867if(!strcmp(line,"--not")) {2868 flags ^= UNINTERESTING;2869 write_bitmap_index =0;2870continue;2871}2872if(starts_with(line,"--shallow ")) {2873struct object_id oid;2874if(get_oid_hex(line +10, &oid))2875die("not an SHA-1 '%s'", line +10);2876register_shallow(&oid);2877 use_bitmap_index =0;2878continue;2879}2880die("not a rev '%s'", line);2881}2882if(handle_revision_arg(line, &revs, flags, REVARG_CANNOT_BE_FILENAME))2883die("bad revision '%s'", line);2884}28852886if(use_bitmap_index && !get_object_list_from_bitmap(&revs))2887return;28882889if(prepare_revision_walk(&revs))2890die("revision walk setup failed");2891mark_edges_uninteresting(&revs, show_edge);28922893if(!fn_show_object)2894 fn_show_object = show_object;2895traverse_commit_list_filtered(&filter_options, &revs,2896 show_commit, fn_show_object, NULL,2897 NULL);28982899if(unpack_unreachable_expiration) {2900 revs.ignore_missing_links =1;2901if(add_unseen_recent_objects_to_traversal(&revs,2902 unpack_unreachable_expiration))2903die("unable to add recent objects");2904if(prepare_revision_walk(&revs))2905die("revision walk setup failed");2906traverse_commit_list(&revs, record_recent_commit,2907 record_recent_object, NULL);2908}29092910if(keep_unreachable)2911add_objects_in_unpacked_packs(&revs);2912if(pack_loose_unreachable)2913add_unreachable_loose_objects();2914if(unpack_unreachable)2915loosen_unused_packed_objects(&revs);29162917oid_array_clear(&recent_objects);2918}29192920static intoption_parse_index_version(const struct option *opt,2921const char*arg,int unset)2922{2923char*c;2924const char*val = arg;2925 pack_idx_opts.version =strtoul(val, &c,10);2926if(pack_idx_opts.version >2)2927die(_("unsupported index version%s"), val);2928if(*c ==','&& c[1])2929 pack_idx_opts.off32_limit =strtoul(c+1, &c,0);2930if(*c || pack_idx_opts.off32_limit &0x80000000)2931die(_("bad index version '%s'"), val);2932return0;2933}29342935static intoption_parse_unpack_unreachable(const struct option *opt,2936const char*arg,int unset)2937{2938if(unset) {2939 unpack_unreachable =0;2940 unpack_unreachable_expiration =0;2941}2942else{2943 unpack_unreachable =1;2944if(arg)2945 unpack_unreachable_expiration =approxidate(arg);2946}2947return0;2948}29492950intcmd_pack_objects(int argc,const char**argv,const char*prefix)2951{2952int use_internal_rev_list =0;2953int thin =0;2954int shallow =0;2955int all_progress_implied =0;2956struct argv_array rp = ARGV_ARRAY_INIT;2957int rev_list_unpacked =0, rev_list_all =0, rev_list_reflog =0;2958int rev_list_index =0;2959struct option pack_objects_options[] = {2960OPT_SET_INT('q',"quiet", &progress,2961N_("do not show progress meter"),0),2962OPT_SET_INT(0,"progress", &progress,2963N_("show progress meter"),1),2964OPT_SET_INT(0,"all-progress", &progress,2965N_("show progress meter during object writing phase"),2),2966OPT_BOOL(0,"all-progress-implied",2967&all_progress_implied,2968N_("similar to --all-progress when progress meter is shown")),2969{ OPTION_CALLBACK,0,"index-version", NULL,N_("version[,offset]"),2970N_("write the pack index file in the specified idx format version"),29710, option_parse_index_version },2972OPT_MAGNITUDE(0,"max-pack-size", &pack_size_limit,2973N_("maximum size of each output pack file")),2974OPT_BOOL(0,"local", &local,2975N_("ignore borrowed objects from alternate object store")),2976OPT_BOOL(0,"incremental", &incremental,2977N_("ignore packed objects")),2978OPT_INTEGER(0,"window", &window,2979N_("limit pack window by objects")),2980OPT_MAGNITUDE(0,"window-memory", &window_memory_limit,2981N_("limit pack window by memory in addition to object limit")),2982OPT_INTEGER(0,"depth", &depth,2983N_("maximum length of delta chain allowed in the resulting pack")),2984OPT_BOOL(0,"reuse-delta", &reuse_delta,2985N_("reuse existing deltas")),2986OPT_BOOL(0,"reuse-object", &reuse_object,2987N_("reuse existing objects")),2988OPT_BOOL(0,"delta-base-offset", &allow_ofs_delta,2989N_("use OFS_DELTA objects")),2990OPT_INTEGER(0,"threads", &delta_search_threads,2991N_("use threads when searching for best delta matches")),2992OPT_BOOL(0,"non-empty", &non_empty,2993N_("do not create an empty pack output")),2994OPT_BOOL(0,"revs", &use_internal_rev_list,2995N_("read revision arguments from standard input")),2996{ OPTION_SET_INT,0,"unpacked", &rev_list_unpacked, NULL,2997N_("limit the objects to those that are not yet packed"),2998 PARSE_OPT_NOARG | PARSE_OPT_NONEG, NULL,1},2999{ OPTION_SET_INT,0,"all", &rev_list_all, NULL,3000N_("include objects reachable from any reference"),3001 PARSE_OPT_NOARG | PARSE_OPT_NONEG, NULL,1},3002{ OPTION_SET_INT,0,"reflog", &rev_list_reflog, NULL,3003N_("include objects referred by reflog entries"),3004 PARSE_OPT_NOARG | PARSE_OPT_NONEG, NULL,1},3005{ OPTION_SET_INT,0,"indexed-objects", &rev_list_index, NULL,3006N_("include objects referred to by the index"),3007 PARSE_OPT_NOARG | PARSE_OPT_NONEG, NULL,1},3008OPT_BOOL(0,"stdout", &pack_to_stdout,3009N_("output pack to stdout")),3010OPT_BOOL(0,"include-tag", &include_tag,3011N_("include tag objects that refer to objects to be packed")),3012OPT_BOOL(0,"keep-unreachable", &keep_unreachable,3013N_("keep unreachable objects")),3014OPT_BOOL(0,"pack-loose-unreachable", &pack_loose_unreachable,3015N_("pack loose unreachable objects")),3016{ OPTION_CALLBACK,0,"unpack-unreachable", NULL,N_("time"),3017N_("unpack unreachable objects newer than <time>"),3018 PARSE_OPT_OPTARG, option_parse_unpack_unreachable },3019OPT_BOOL(0,"thin", &thin,3020N_("create thin packs")),3021OPT_BOOL(0,"shallow", &shallow,3022N_("create packs suitable for shallow fetches")),3023OPT_BOOL(0,"honor-pack-keep", &ignore_packed_keep,3024N_("ignore packs that have companion .keep file")),3025OPT_INTEGER(0,"compression", &pack_compression_level,3026N_("pack compression level")),3027OPT_SET_INT(0,"keep-true-parents", &grafts_replace_parents,3028N_("do not hide commits by grafts"),0),3029OPT_BOOL(0,"use-bitmap-index", &use_bitmap_index,3030N_("use a bitmap index if available to speed up counting objects")),3031OPT_BOOL(0,"write-bitmap-index", &write_bitmap_index,3032N_("write a bitmap index together with the pack index")),3033OPT_PARSE_LIST_OBJECTS_FILTER(&filter_options),3034{ OPTION_CALLBACK,0,"missing", NULL,N_("action"),3035N_("handling for missing objects"), PARSE_OPT_NONEG,3036 option_parse_missing_action },3037OPT_BOOL(0,"exclude-promisor-objects", &exclude_promisor_objects,3038N_("do not pack objects in promisor packfiles")),3039OPT_END(),3040};30413042 check_replace_refs =0;30433044reset_pack_idx_option(&pack_idx_opts);3045git_config(git_pack_config, NULL);30463047 progress =isatty(2);3048 argc =parse_options(argc, argv, prefix, pack_objects_options,3049 pack_usage,0);30503051if(argc) {3052 base_name = argv[0];3053 argc--;3054}3055if(pack_to_stdout != !base_name || argc)3056usage_with_options(pack_usage, pack_objects_options);30573058argv_array_push(&rp,"pack-objects");3059if(thin) {3060 use_internal_rev_list =1;3061argv_array_push(&rp, shallow3062?"--objects-edge-aggressive"3063:"--objects-edge");3064}else3065argv_array_push(&rp,"--objects");30663067if(rev_list_all) {3068 use_internal_rev_list =1;3069argv_array_push(&rp,"--all");3070}3071if(rev_list_reflog) {3072 use_internal_rev_list =1;3073argv_array_push(&rp,"--reflog");3074}3075if(rev_list_index) {3076 use_internal_rev_list =1;3077argv_array_push(&rp,"--indexed-objects");3078}3079if(rev_list_unpacked) {3080 use_internal_rev_list =1;3081argv_array_push(&rp,"--unpacked");3082}30833084if(exclude_promisor_objects) {3085 use_internal_rev_list =1;3086 fetch_if_missing =0;3087argv_array_push(&rp,"--exclude-promisor-objects");3088}30893090if(!reuse_object)3091 reuse_delta =0;3092if(pack_compression_level == -1)3093 pack_compression_level = Z_DEFAULT_COMPRESSION;3094else if(pack_compression_level <0|| pack_compression_level > Z_BEST_COMPRESSION)3095die("bad pack compression level%d", pack_compression_level);30963097if(!delta_search_threads)/* --threads=0 means autodetect */3098 delta_search_threads =online_cpus();30993100#ifdef NO_PTHREADS3101if(delta_search_threads !=1)3102warning("no threads support, ignoring --threads");3103#endif3104if(!pack_to_stdout && !pack_size_limit)3105 pack_size_limit = pack_size_limit_cfg;3106if(pack_to_stdout && pack_size_limit)3107die("--max-pack-size cannot be used to build a pack for transfer.");3108if(pack_size_limit && pack_size_limit <1024*1024) {3109warning("minimum pack size limit is 1 MiB");3110 pack_size_limit =1024*1024;3111}31123113if(!pack_to_stdout && thin)3114die("--thin cannot be used to build an indexable pack.");31153116if(keep_unreachable && unpack_unreachable)3117die("--keep-unreachable and --unpack-unreachable are incompatible.");3118if(!rev_list_all || !rev_list_reflog || !rev_list_index)3119 unpack_unreachable_expiration =0;31203121if(filter_options.choice) {3122if(!pack_to_stdout)3123die("cannot use --filter without --stdout.");3124 use_bitmap_index =0;3125}31263127/*3128 * "soft" reasons not to use bitmaps - for on-disk repack by default we want3129 *3130 * - to produce good pack (with bitmap index not-yet-packed objects are3131 * packed in suboptimal order).3132 *3133 * - to use more robust pack-generation codepath (avoiding possible3134 * bugs in bitmap code and possible bitmap index corruption).3135 */3136if(!pack_to_stdout)3137 use_bitmap_index_default =0;31383139if(use_bitmap_index <0)3140 use_bitmap_index = use_bitmap_index_default;31413142/* "hard" reasons not to use bitmaps; these just won't work at all */3143if(!use_internal_rev_list || (!pack_to_stdout && write_bitmap_index) ||is_repository_shallow())3144 use_bitmap_index =0;31453146if(pack_to_stdout || !rev_list_all)3147 write_bitmap_index =0;31483149if(progress && all_progress_implied)3150 progress =2;31513152prepare_packed_git();3153if(ignore_packed_keep) {3154struct packed_git *p;3155for(p = packed_git; p; p = p->next)3156if(p->pack_local && p->pack_keep)3157break;3158if(!p)/* no keep-able packs found */3159 ignore_packed_keep =0;3160}3161if(local) {3162/*3163 * unlike ignore_packed_keep above, we do not want to3164 * unset "local" based on looking at packs, as it3165 * also covers non-local objects3166 */3167struct packed_git *p;3168for(p = packed_git; p; p = p->next) {3169if(!p->pack_local) {3170 have_non_local_packs =1;3171break;3172}3173}3174}31753176if(progress)3177 progress_state =start_progress(_("Counting objects"),0);3178if(!use_internal_rev_list)3179read_object_list_from_stdin();3180else{3181get_object_list(rp.argc, rp.argv);3182argv_array_clear(&rp);3183}3184cleanup_preferred_base();3185if(include_tag && nr_result)3186for_each_ref(add_ref_tag, NULL);3187stop_progress(&progress_state);31883189if(non_empty && !nr_result)3190return0;3191if(nr_result)3192prepare_pack(window, depth);3193write_pack_file();3194if(progress)3195fprintf(stderr,"Total %"PRIu32" (delta %"PRIu32"),"3196" reused %"PRIu32" (delta %"PRIu32")\n",3197 written, written_delta, reused, reused_delta);3198return0;3199}