1#include"builtin.h" 2#include"cache.h" 3#include"repository.h" 4#include"config.h" 5#include"attr.h" 6#include"object.h" 7#include"blob.h" 8#include"commit.h" 9#include"tag.h" 10#include"tree.h" 11#include"delta.h" 12#include"pack.h" 13#include"pack-revindex.h" 14#include"csum-file.h" 15#include"tree-walk.h" 16#include"diff.h" 17#include"revision.h" 18#include"list-objects.h" 19#include"list-objects-filter.h" 20#include"list-objects-filter-options.h" 21#include"pack-objects.h" 22#include"progress.h" 23#include"refs.h" 24#include"streaming.h" 25#include"thread-utils.h" 26#include"pack-bitmap.h" 27#include"reachable.h" 28#include"sha1-array.h" 29#include"argv-array.h" 30#include"list.h" 31#include"packfile.h" 32#include"object-store.h" 33#include"dir.h" 34 35static const char*pack_usage[] = { 36N_("git pack-objects --stdout [<options>...] [< <ref-list> | < <object-list>]"), 37N_("git pack-objects [<options>...] <base-name> [< <ref-list> | < <object-list>]"), 38 NULL 39}; 40 41/* 42 * Objects we are going to pack are collected in the `to_pack` structure. 43 * It contains an array (dynamically expanded) of the object data, and a map 44 * that can resolve SHA1s to their position in the array. 45 */ 46static struct packing_data to_pack; 47 48static struct pack_idx_entry **written_list; 49static uint32_t nr_result, nr_written; 50 51static int non_empty; 52static int reuse_delta =1, reuse_object =1; 53static int keep_unreachable, unpack_unreachable, include_tag; 54static timestamp_t unpack_unreachable_expiration; 55static int pack_loose_unreachable; 56static int local; 57static int have_non_local_packs; 58static int incremental; 59static int ignore_packed_keep_on_disk; 60static int ignore_packed_keep_in_core; 61static int allow_ofs_delta; 62static struct pack_idx_option pack_idx_opts; 63static const char*base_name; 64static int progress =1; 65static int window =10; 66static unsigned long pack_size_limit; 67static int depth =50; 68static int delta_search_threads; 69static int pack_to_stdout; 70static int num_preferred_base; 71static struct progress *progress_state; 72 73static struct packed_git *reuse_packfile; 74static uint32_t reuse_packfile_objects; 75static off_t reuse_packfile_offset; 76 77static int use_bitmap_index_default =1; 78static int use_bitmap_index = -1; 79static int write_bitmap_index; 80static uint16_t write_bitmap_options; 81 82static int exclude_promisor_objects; 83 84static unsigned long delta_cache_size =0; 85static unsigned long max_delta_cache_size =256*1024*1024; 86static unsigned long cache_max_small_delta_size =1000; 87 88static unsigned long window_memory_limit =0; 89 90static struct list_objects_filter_options filter_options; 91 92enum missing_action { 93 MA_ERROR =0,/* fail if any missing objects are encountered */ 94 MA_ALLOW_ANY,/* silently allow ALL missing objects */ 95 MA_ALLOW_PROMISOR,/* silently allow all missing PROMISOR objects */ 96}; 97static enum missing_action arg_missing_action; 98static show_object_fn fn_show_object; 99 100/* 101 * stats 102 */ 103static uint32_t written, written_delta; 104static uint32_t reused, reused_delta; 105 106/* 107 * Indexed commits 108 */ 109static struct commit **indexed_commits; 110static unsigned int indexed_commits_nr; 111static unsigned int indexed_commits_alloc; 112 113static voidindex_commit_for_bitmap(struct commit *commit) 114{ 115if(indexed_commits_nr >= indexed_commits_alloc) { 116 indexed_commits_alloc = (indexed_commits_alloc +32) *2; 117REALLOC_ARRAY(indexed_commits, indexed_commits_alloc); 118} 119 120 indexed_commits[indexed_commits_nr++] = commit; 121} 122 123static void*get_delta(struct object_entry *entry) 124{ 125unsigned long size, base_size, delta_size; 126void*buf, *base_buf, *delta_buf; 127enum object_type type; 128 129 buf =read_object_file(&entry->idx.oid, &type, &size); 130if(!buf) 131die("unable to read%s",oid_to_hex(&entry->idx.oid)); 132 base_buf =read_object_file(&entry->delta->idx.oid, &type, &base_size); 133if(!base_buf) 134die("unable to read%s", 135oid_to_hex(&entry->delta->idx.oid)); 136 delta_buf =diff_delta(base_buf, base_size, 137 buf, size, &delta_size,0); 138if(!delta_buf || delta_size != entry->delta_size) 139die("delta size changed"); 140free(buf); 141free(base_buf); 142return delta_buf; 143} 144 145static unsigned longdo_compress(void**pptr,unsigned long size) 146{ 147 git_zstream stream; 148void*in, *out; 149unsigned long maxsize; 150 151git_deflate_init(&stream, pack_compression_level); 152 maxsize =git_deflate_bound(&stream, size); 153 154 in = *pptr; 155 out =xmalloc(maxsize); 156*pptr = out; 157 158 stream.next_in = in; 159 stream.avail_in = size; 160 stream.next_out = out; 161 stream.avail_out = maxsize; 162while(git_deflate(&stream, Z_FINISH) == Z_OK) 163;/* nothing */ 164git_deflate_end(&stream); 165 166free(in); 167return stream.total_out; 168} 169 170static unsigned longwrite_large_blob_data(struct git_istream *st,struct hashfile *f, 171const struct object_id *oid) 172{ 173 git_zstream stream; 174unsigned char ibuf[1024*16]; 175unsigned char obuf[1024*16]; 176unsigned long olen =0; 177 178git_deflate_init(&stream, pack_compression_level); 179 180for(;;) { 181 ssize_t readlen; 182int zret = Z_OK; 183 readlen =read_istream(st, ibuf,sizeof(ibuf)); 184if(readlen == -1) 185die(_("unable to read%s"),oid_to_hex(oid)); 186 187 stream.next_in = ibuf; 188 stream.avail_in = readlen; 189while((stream.avail_in || readlen ==0) && 190(zret == Z_OK || zret == Z_BUF_ERROR)) { 191 stream.next_out = obuf; 192 stream.avail_out =sizeof(obuf); 193 zret =git_deflate(&stream, readlen ?0: Z_FINISH); 194hashwrite(f, obuf, stream.next_out - obuf); 195 olen += stream.next_out - obuf; 196} 197if(stream.avail_in) 198die(_("deflate error (%d)"), zret); 199if(readlen ==0) { 200if(zret != Z_STREAM_END) 201die(_("deflate error (%d)"), zret); 202break; 203} 204} 205git_deflate_end(&stream); 206return olen; 207} 208 209/* 210 * we are going to reuse the existing object data as is. make 211 * sure it is not corrupt. 212 */ 213static intcheck_pack_inflate(struct packed_git *p, 214struct pack_window **w_curs, 215 off_t offset, 216 off_t len, 217unsigned long expect) 218{ 219 git_zstream stream; 220unsigned char fakebuf[4096], *in; 221int st; 222 223memset(&stream,0,sizeof(stream)); 224git_inflate_init(&stream); 225do{ 226 in =use_pack(p, w_curs, offset, &stream.avail_in); 227 stream.next_in = in; 228 stream.next_out = fakebuf; 229 stream.avail_out =sizeof(fakebuf); 230 st =git_inflate(&stream, Z_FINISH); 231 offset += stream.next_in - in; 232}while(st == Z_OK || st == Z_BUF_ERROR); 233git_inflate_end(&stream); 234return(st == Z_STREAM_END && 235 stream.total_out == expect && 236 stream.total_in == len) ?0: -1; 237} 238 239static voidcopy_pack_data(struct hashfile *f, 240struct packed_git *p, 241struct pack_window **w_curs, 242 off_t offset, 243 off_t len) 244{ 245unsigned char*in; 246unsigned long avail; 247 248while(len) { 249 in =use_pack(p, w_curs, offset, &avail); 250if(avail > len) 251 avail = (unsigned long)len; 252hashwrite(f, in, avail); 253 offset += avail; 254 len -= avail; 255} 256} 257 258/* Return 0 if we will bust the pack-size limit */ 259static unsigned longwrite_no_reuse_object(struct hashfile *f,struct object_entry *entry, 260unsigned long limit,int usable_delta) 261{ 262unsigned long size, datalen; 263unsigned char header[MAX_PACK_OBJECT_HEADER], 264 dheader[MAX_PACK_OBJECT_HEADER]; 265unsigned hdrlen; 266enum object_type type; 267void*buf; 268struct git_istream *st = NULL; 269 270if(!usable_delta) { 271if(entry->type == OBJ_BLOB && 272 entry->size > big_file_threshold && 273(st =open_istream(&entry->idx.oid, &type, &size, NULL)) != NULL) 274 buf = NULL; 275else{ 276 buf =read_object_file(&entry->idx.oid, &type, &size); 277if(!buf) 278die(_("unable to read%s"), 279oid_to_hex(&entry->idx.oid)); 280} 281/* 282 * make sure no cached delta data remains from a 283 * previous attempt before a pack split occurred. 284 */ 285FREE_AND_NULL(entry->delta_data); 286 entry->z_delta_size =0; 287}else if(entry->delta_data) { 288 size = entry->delta_size; 289 buf = entry->delta_data; 290 entry->delta_data = NULL; 291 type = (allow_ofs_delta && entry->delta->idx.offset) ? 292 OBJ_OFS_DELTA : OBJ_REF_DELTA; 293}else{ 294 buf =get_delta(entry); 295 size = entry->delta_size; 296 type = (allow_ofs_delta && entry->delta->idx.offset) ? 297 OBJ_OFS_DELTA : OBJ_REF_DELTA; 298} 299 300if(st)/* large blob case, just assume we don't compress well */ 301 datalen = size; 302else if(entry->z_delta_size) 303 datalen = entry->z_delta_size; 304else 305 datalen =do_compress(&buf, size); 306 307/* 308 * The object header is a byte of 'type' followed by zero or 309 * more bytes of length. 310 */ 311 hdrlen =encode_in_pack_object_header(header,sizeof(header), 312 type, size); 313 314if(type == OBJ_OFS_DELTA) { 315/* 316 * Deltas with relative base contain an additional 317 * encoding of the relative offset for the delta 318 * base from this object's position in the pack. 319 */ 320 off_t ofs = entry->idx.offset - entry->delta->idx.offset; 321unsigned pos =sizeof(dheader) -1; 322 dheader[pos] = ofs &127; 323while(ofs >>=7) 324 dheader[--pos] =128| (--ofs &127); 325if(limit && hdrlen +sizeof(dheader) - pos + datalen +20>= limit) { 326if(st) 327close_istream(st); 328free(buf); 329return0; 330} 331hashwrite(f, header, hdrlen); 332hashwrite(f, dheader + pos,sizeof(dheader) - pos); 333 hdrlen +=sizeof(dheader) - pos; 334}else if(type == OBJ_REF_DELTA) { 335/* 336 * Deltas with a base reference contain 337 * an additional 20 bytes for the base sha1. 338 */ 339if(limit && hdrlen +20+ datalen +20>= limit) { 340if(st) 341close_istream(st); 342free(buf); 343return0; 344} 345hashwrite(f, header, hdrlen); 346hashwrite(f, entry->delta->idx.oid.hash,20); 347 hdrlen +=20; 348}else{ 349if(limit && hdrlen + datalen +20>= limit) { 350if(st) 351close_istream(st); 352free(buf); 353return0; 354} 355hashwrite(f, header, hdrlen); 356} 357if(st) { 358 datalen =write_large_blob_data(st, f, &entry->idx.oid); 359close_istream(st); 360}else{ 361hashwrite(f, buf, datalen); 362free(buf); 363} 364 365return hdrlen + datalen; 366} 367 368/* Return 0 if we will bust the pack-size limit */ 369static off_t write_reuse_object(struct hashfile *f,struct object_entry *entry, 370unsigned long limit,int usable_delta) 371{ 372struct packed_git *p = entry->in_pack; 373struct pack_window *w_curs = NULL; 374struct revindex_entry *revidx; 375 off_t offset; 376enum object_type type = entry->type; 377 off_t datalen; 378unsigned char header[MAX_PACK_OBJECT_HEADER], 379 dheader[MAX_PACK_OBJECT_HEADER]; 380unsigned hdrlen; 381 382if(entry->delta) 383 type = (allow_ofs_delta && entry->delta->idx.offset) ? 384 OBJ_OFS_DELTA : OBJ_REF_DELTA; 385 hdrlen =encode_in_pack_object_header(header,sizeof(header), 386 type, entry->size); 387 388 offset = entry->in_pack_offset; 389 revidx =find_pack_revindex(p, offset); 390 datalen = revidx[1].offset - offset; 391if(!pack_to_stdout && p->index_version >1&& 392check_pack_crc(p, &w_curs, offset, datalen, revidx->nr)) { 393error("bad packed object CRC for%s", 394oid_to_hex(&entry->idx.oid)); 395unuse_pack(&w_curs); 396returnwrite_no_reuse_object(f, entry, limit, usable_delta); 397} 398 399 offset += entry->in_pack_header_size; 400 datalen -= entry->in_pack_header_size; 401 402if(!pack_to_stdout && p->index_version ==1&& 403check_pack_inflate(p, &w_curs, offset, datalen, entry->size)) { 404error("corrupt packed object for%s", 405oid_to_hex(&entry->idx.oid)); 406unuse_pack(&w_curs); 407returnwrite_no_reuse_object(f, entry, limit, usable_delta); 408} 409 410if(type == OBJ_OFS_DELTA) { 411 off_t ofs = entry->idx.offset - entry->delta->idx.offset; 412unsigned pos =sizeof(dheader) -1; 413 dheader[pos] = ofs &127; 414while(ofs >>=7) 415 dheader[--pos] =128| (--ofs &127); 416if(limit && hdrlen +sizeof(dheader) - pos + datalen +20>= limit) { 417unuse_pack(&w_curs); 418return0; 419} 420hashwrite(f, header, hdrlen); 421hashwrite(f, dheader + pos,sizeof(dheader) - pos); 422 hdrlen +=sizeof(dheader) - pos; 423 reused_delta++; 424}else if(type == OBJ_REF_DELTA) { 425if(limit && hdrlen +20+ datalen +20>= limit) { 426unuse_pack(&w_curs); 427return0; 428} 429hashwrite(f, header, hdrlen); 430hashwrite(f, entry->delta->idx.oid.hash,20); 431 hdrlen +=20; 432 reused_delta++; 433}else{ 434if(limit && hdrlen + datalen +20>= limit) { 435unuse_pack(&w_curs); 436return0; 437} 438hashwrite(f, header, hdrlen); 439} 440copy_pack_data(f, p, &w_curs, offset, datalen); 441unuse_pack(&w_curs); 442 reused++; 443return hdrlen + datalen; 444} 445 446/* Return 0 if we will bust the pack-size limit */ 447static off_t write_object(struct hashfile *f, 448struct object_entry *entry, 449 off_t write_offset) 450{ 451unsigned long limit; 452 off_t len; 453int usable_delta, to_reuse; 454 455if(!pack_to_stdout) 456crc32_begin(f); 457 458/* apply size limit if limited packsize and not first object */ 459if(!pack_size_limit || !nr_written) 460 limit =0; 461else if(pack_size_limit <= write_offset) 462/* 463 * the earlier object did not fit the limit; avoid 464 * mistaking this with unlimited (i.e. limit = 0). 465 */ 466 limit =1; 467else 468 limit = pack_size_limit - write_offset; 469 470if(!entry->delta) 471 usable_delta =0;/* no delta */ 472else if(!pack_size_limit) 473 usable_delta =1;/* unlimited packfile */ 474else if(entry->delta->idx.offset == (off_t)-1) 475 usable_delta =0;/* base was written to another pack */ 476else if(entry->delta->idx.offset) 477 usable_delta =1;/* base already exists in this pack */ 478else 479 usable_delta =0;/* base could end up in another pack */ 480 481if(!reuse_object) 482 to_reuse =0;/* explicit */ 483else if(!entry->in_pack) 484 to_reuse =0;/* can't reuse what we don't have */ 485else if(entry->type == OBJ_REF_DELTA || entry->type == OBJ_OFS_DELTA) 486/* check_object() decided it for us ... */ 487 to_reuse = usable_delta; 488/* ... but pack split may override that */ 489else if(entry->type != entry->in_pack_type) 490 to_reuse =0;/* pack has delta which is unusable */ 491else if(entry->delta) 492 to_reuse =0;/* we want to pack afresh */ 493else 494 to_reuse =1;/* we have it in-pack undeltified, 495 * and we do not need to deltify it. 496 */ 497 498if(!to_reuse) 499 len =write_no_reuse_object(f, entry, limit, usable_delta); 500else 501 len =write_reuse_object(f, entry, limit, usable_delta); 502if(!len) 503return0; 504 505if(usable_delta) 506 written_delta++; 507 written++; 508if(!pack_to_stdout) 509 entry->idx.crc32 =crc32_end(f); 510return len; 511} 512 513enum write_one_status { 514 WRITE_ONE_SKIP = -1,/* already written */ 515 WRITE_ONE_BREAK =0,/* writing this will bust the limit; not written */ 516 WRITE_ONE_WRITTEN =1,/* normal */ 517 WRITE_ONE_RECURSIVE =2/* already scheduled to be written */ 518}; 519 520static enum write_one_status write_one(struct hashfile *f, 521struct object_entry *e, 522 off_t *offset) 523{ 524 off_t size; 525int recursing; 526 527/* 528 * we set offset to 1 (which is an impossible value) to mark 529 * the fact that this object is involved in "write its base 530 * first before writing a deltified object" recursion. 531 */ 532 recursing = (e->idx.offset ==1); 533if(recursing) { 534warning("recursive delta detected for object%s", 535oid_to_hex(&e->idx.oid)); 536return WRITE_ONE_RECURSIVE; 537}else if(e->idx.offset || e->preferred_base) { 538/* offset is non zero if object is written already. */ 539return WRITE_ONE_SKIP; 540} 541 542/* if we are deltified, write out base object first. */ 543if(e->delta) { 544 e->idx.offset =1;/* now recurse */ 545switch(write_one(f, e->delta, offset)) { 546case WRITE_ONE_RECURSIVE: 547/* we cannot depend on this one */ 548 e->delta = NULL; 549break; 550default: 551break; 552case WRITE_ONE_BREAK: 553 e->idx.offset = recursing; 554return WRITE_ONE_BREAK; 555} 556} 557 558 e->idx.offset = *offset; 559 size =write_object(f, e, *offset); 560if(!size) { 561 e->idx.offset = recursing; 562return WRITE_ONE_BREAK; 563} 564 written_list[nr_written++] = &e->idx; 565 566/* make sure off_t is sufficiently large not to wrap */ 567if(signed_add_overflows(*offset, size)) 568die("pack too large for current definition of off_t"); 569*offset += size; 570return WRITE_ONE_WRITTEN; 571} 572 573static intmark_tagged(const char*path,const struct object_id *oid,int flag, 574void*cb_data) 575{ 576struct object_id peeled; 577struct object_entry *entry =packlist_find(&to_pack, oid->hash, NULL); 578 579if(entry) 580 entry->tagged =1; 581if(!peel_ref(path, &peeled)) { 582 entry =packlist_find(&to_pack, peeled.hash, NULL); 583if(entry) 584 entry->tagged =1; 585} 586return0; 587} 588 589staticinlinevoidadd_to_write_order(struct object_entry **wo, 590unsigned int*endp, 591struct object_entry *e) 592{ 593if(e->filled) 594return; 595 wo[(*endp)++] = e; 596 e->filled =1; 597} 598 599static voidadd_descendants_to_write_order(struct object_entry **wo, 600unsigned int*endp, 601struct object_entry *e) 602{ 603int add_to_order =1; 604while(e) { 605if(add_to_order) { 606struct object_entry *s; 607/* add this node... */ 608add_to_write_order(wo, endp, e); 609/* all its siblings... */ 610for(s = e->delta_sibling; s; s = s->delta_sibling) { 611add_to_write_order(wo, endp, s); 612} 613} 614/* drop down a level to add left subtree nodes if possible */ 615if(e->delta_child) { 616 add_to_order =1; 617 e = e->delta_child; 618}else{ 619 add_to_order =0; 620/* our sibling might have some children, it is next */ 621if(e->delta_sibling) { 622 e = e->delta_sibling; 623continue; 624} 625/* go back to our parent node */ 626 e = e->delta; 627while(e && !e->delta_sibling) { 628/* we're on the right side of a subtree, keep 629 * going up until we can go right again */ 630 e = e->delta; 631} 632if(!e) { 633/* done- we hit our original root node */ 634return; 635} 636/* pass it off to sibling at this level */ 637 e = e->delta_sibling; 638} 639}; 640} 641 642static voidadd_family_to_write_order(struct object_entry **wo, 643unsigned int*endp, 644struct object_entry *e) 645{ 646struct object_entry *root; 647 648for(root = e; root->delta; root = root->delta) 649;/* nothing */ 650add_descendants_to_write_order(wo, endp, root); 651} 652 653static struct object_entry **compute_write_order(void) 654{ 655unsigned int i, wo_end, last_untagged; 656 657struct object_entry **wo; 658struct object_entry *objects = to_pack.objects; 659 660for(i =0; i < to_pack.nr_objects; i++) { 661 objects[i].tagged =0; 662 objects[i].filled =0; 663 objects[i].delta_child = NULL; 664 objects[i].delta_sibling = NULL; 665} 666 667/* 668 * Fully connect delta_child/delta_sibling network. 669 * Make sure delta_sibling is sorted in the original 670 * recency order. 671 */ 672for(i = to_pack.nr_objects; i >0;) { 673struct object_entry *e = &objects[--i]; 674if(!e->delta) 675continue; 676/* Mark me as the first child */ 677 e->delta_sibling = e->delta->delta_child; 678 e->delta->delta_child = e; 679} 680 681/* 682 * Mark objects that are at the tip of tags. 683 */ 684for_each_tag_ref(mark_tagged, NULL); 685 686/* 687 * Give the objects in the original recency order until 688 * we see a tagged tip. 689 */ 690ALLOC_ARRAY(wo, to_pack.nr_objects); 691for(i = wo_end =0; i < to_pack.nr_objects; i++) { 692if(objects[i].tagged) 693break; 694add_to_write_order(wo, &wo_end, &objects[i]); 695} 696 last_untagged = i; 697 698/* 699 * Then fill all the tagged tips. 700 */ 701for(; i < to_pack.nr_objects; i++) { 702if(objects[i].tagged) 703add_to_write_order(wo, &wo_end, &objects[i]); 704} 705 706/* 707 * And then all remaining commits and tags. 708 */ 709for(i = last_untagged; i < to_pack.nr_objects; i++) { 710if(objects[i].type != OBJ_COMMIT && 711 objects[i].type != OBJ_TAG) 712continue; 713add_to_write_order(wo, &wo_end, &objects[i]); 714} 715 716/* 717 * And then all the trees. 718 */ 719for(i = last_untagged; i < to_pack.nr_objects; i++) { 720if(objects[i].type != OBJ_TREE) 721continue; 722add_to_write_order(wo, &wo_end, &objects[i]); 723} 724 725/* 726 * Finally all the rest in really tight order 727 */ 728for(i = last_untagged; i < to_pack.nr_objects; i++) { 729if(!objects[i].filled) 730add_family_to_write_order(wo, &wo_end, &objects[i]); 731} 732 733if(wo_end != to_pack.nr_objects) 734die("ordered%uobjects, expected %"PRIu32, wo_end, to_pack.nr_objects); 735 736return wo; 737} 738 739static off_t write_reused_pack(struct hashfile *f) 740{ 741unsigned char buffer[8192]; 742 off_t to_write, total; 743int fd; 744 745if(!is_pack_valid(reuse_packfile)) 746die("packfile is invalid:%s", reuse_packfile->pack_name); 747 748 fd =git_open(reuse_packfile->pack_name); 749if(fd <0) 750die_errno("unable to open packfile for reuse:%s", 751 reuse_packfile->pack_name); 752 753if(lseek(fd,sizeof(struct pack_header), SEEK_SET) == -1) 754die_errno("unable to seek in reused packfile"); 755 756if(reuse_packfile_offset <0) 757 reuse_packfile_offset = reuse_packfile->pack_size -20; 758 759 total = to_write = reuse_packfile_offset -sizeof(struct pack_header); 760 761while(to_write) { 762int read_pack =xread(fd, buffer,sizeof(buffer)); 763 764if(read_pack <=0) 765die_errno("unable to read from reused packfile"); 766 767if(read_pack > to_write) 768 read_pack = to_write; 769 770hashwrite(f, buffer, read_pack); 771 to_write -= read_pack; 772 773/* 774 * We don't know the actual number of objects written, 775 * only how many bytes written, how many bytes total, and 776 * how many objects total. So we can fake it by pretending all 777 * objects we are writing are the same size. This gives us a 778 * smooth progress meter, and at the end it matches the true 779 * answer. 780 */ 781 written = reuse_packfile_objects * 782(((double)(total - to_write)) / total); 783display_progress(progress_state, written); 784} 785 786close(fd); 787 written = reuse_packfile_objects; 788display_progress(progress_state, written); 789return reuse_packfile_offset -sizeof(struct pack_header); 790} 791 792static const char no_split_warning[] =N_( 793"disabling bitmap writing, packs are split due to pack.packSizeLimit" 794); 795 796static voidwrite_pack_file(void) 797{ 798uint32_t i =0, j; 799struct hashfile *f; 800 off_t offset; 801uint32_t nr_remaining = nr_result; 802time_t last_mtime =0; 803struct object_entry **write_order; 804 805if(progress > pack_to_stdout) 806 progress_state =start_progress(_("Writing objects"), nr_result); 807ALLOC_ARRAY(written_list, to_pack.nr_objects); 808 write_order =compute_write_order(); 809 810do{ 811struct object_id oid; 812char*pack_tmp_name = NULL; 813 814if(pack_to_stdout) 815 f =hashfd_throughput(1,"<stdout>", progress_state); 816else 817 f =create_tmp_packfile(&pack_tmp_name); 818 819 offset =write_pack_header(f, nr_remaining); 820 821if(reuse_packfile) { 822 off_t packfile_size; 823assert(pack_to_stdout); 824 825 packfile_size =write_reused_pack(f); 826 offset += packfile_size; 827} 828 829 nr_written =0; 830for(; i < to_pack.nr_objects; i++) { 831struct object_entry *e = write_order[i]; 832if(write_one(f, e, &offset) == WRITE_ONE_BREAK) 833break; 834display_progress(progress_state, written); 835} 836 837/* 838 * Did we write the wrong # entries in the header? 839 * If so, rewrite it like in fast-import 840 */ 841if(pack_to_stdout) { 842hashclose(f, oid.hash, CSUM_CLOSE); 843}else if(nr_written == nr_remaining) { 844hashclose(f, oid.hash, CSUM_FSYNC); 845}else{ 846int fd =hashclose(f, oid.hash,0); 847fixup_pack_header_footer(fd, oid.hash, pack_tmp_name, 848 nr_written, oid.hash, offset); 849close(fd); 850if(write_bitmap_index) { 851warning(_(no_split_warning)); 852 write_bitmap_index =0; 853} 854} 855 856if(!pack_to_stdout) { 857struct stat st; 858struct strbuf tmpname = STRBUF_INIT; 859 860/* 861 * Packs are runtime accessed in their mtime 862 * order since newer packs are more likely to contain 863 * younger objects. So if we are creating multiple 864 * packs then we should modify the mtime of later ones 865 * to preserve this property. 866 */ 867if(stat(pack_tmp_name, &st) <0) { 868warning_errno("failed to stat%s", pack_tmp_name); 869}else if(!last_mtime) { 870 last_mtime = st.st_mtime; 871}else{ 872struct utimbuf utb; 873 utb.actime = st.st_atime; 874 utb.modtime = --last_mtime; 875if(utime(pack_tmp_name, &utb) <0) 876warning_errno("failed utime() on%s", pack_tmp_name); 877} 878 879strbuf_addf(&tmpname,"%s-", base_name); 880 881if(write_bitmap_index) { 882bitmap_writer_set_checksum(oid.hash); 883bitmap_writer_build_type_index(written_list, nr_written); 884} 885 886finish_tmp_packfile(&tmpname, pack_tmp_name, 887 written_list, nr_written, 888&pack_idx_opts, oid.hash); 889 890if(write_bitmap_index) { 891strbuf_addf(&tmpname,"%s.bitmap",oid_to_hex(&oid)); 892 893stop_progress(&progress_state); 894 895bitmap_writer_show_progress(progress); 896bitmap_writer_reuse_bitmaps(&to_pack); 897bitmap_writer_select_commits(indexed_commits, indexed_commits_nr, -1); 898bitmap_writer_build(&to_pack); 899bitmap_writer_finish(written_list, nr_written, 900 tmpname.buf, write_bitmap_options); 901 write_bitmap_index =0; 902} 903 904strbuf_release(&tmpname); 905free(pack_tmp_name); 906puts(oid_to_hex(&oid)); 907} 908 909/* mark written objects as written to previous pack */ 910for(j =0; j < nr_written; j++) { 911 written_list[j]->offset = (off_t)-1; 912} 913 nr_remaining -= nr_written; 914}while(nr_remaining && i < to_pack.nr_objects); 915 916free(written_list); 917free(write_order); 918stop_progress(&progress_state); 919if(written != nr_result) 920die("wrote %"PRIu32" objects while expecting %"PRIu32, 921 written, nr_result); 922} 923 924static intno_try_delta(const char*path) 925{ 926static struct attr_check *check; 927 928if(!check) 929 check =attr_check_initl("delta", NULL); 930if(git_check_attr(path, check)) 931return0; 932if(ATTR_FALSE(check->items[0].value)) 933return1; 934return0; 935} 936 937/* 938 * When adding an object, check whether we have already added it 939 * to our packing list. If so, we can skip. However, if we are 940 * being asked to excludei t, but the previous mention was to include 941 * it, make sure to adjust its flags and tweak our numbers accordingly. 942 * 943 * As an optimization, we pass out the index position where we would have 944 * found the item, since that saves us from having to look it up again a 945 * few lines later when we want to add the new entry. 946 */ 947static inthave_duplicate_entry(const struct object_id *oid, 948int exclude, 949uint32_t*index_pos) 950{ 951struct object_entry *entry; 952 953 entry =packlist_find(&to_pack, oid->hash, index_pos); 954if(!entry) 955return0; 956 957if(exclude) { 958if(!entry->preferred_base) 959 nr_result--; 960 entry->preferred_base =1; 961} 962 963return1; 964} 965 966static intwant_found_object(int exclude,struct packed_git *p) 967{ 968if(exclude) 969return1; 970if(incremental) 971return0; 972 973/* 974 * When asked to do --local (do not include an object that appears in a 975 * pack we borrow from elsewhere) or --honor-pack-keep (do not include 976 * an object that appears in a pack marked with .keep), finding a pack 977 * that matches the criteria is sufficient for us to decide to omit it. 978 * However, even if this pack does not satisfy the criteria, we need to 979 * make sure no copy of this object appears in _any_ pack that makes us 980 * to omit the object, so we need to check all the packs. 981 * 982 * We can however first check whether these options can possible matter; 983 * if they do not matter we know we want the object in generated pack. 984 * Otherwise, we signal "-1" at the end to tell the caller that we do 985 * not know either way, and it needs to check more packs. 986 */ 987if(!ignore_packed_keep_on_disk && 988!ignore_packed_keep_in_core && 989(!local || !have_non_local_packs)) 990return1; 991 992if(local && !p->pack_local) 993return0; 994if(p->pack_local && 995((ignore_packed_keep_on_disk && p->pack_keep) || 996(ignore_packed_keep_in_core && p->pack_keep_in_core))) 997return0; 998 999/* we don't know yet; keep looking for more packs */1000return-1;1001}10021003/*1004 * Check whether we want the object in the pack (e.g., we do not want1005 * objects found in non-local stores if the "--local" option was used).1006 *1007 * If the caller already knows an existing pack it wants to take the object1008 * from, that is passed in *found_pack and *found_offset; otherwise this1009 * function finds if there is any pack that has the object and returns the pack1010 * and its offset in these variables.1011 */1012static intwant_object_in_pack(const struct object_id *oid,1013int exclude,1014struct packed_git **found_pack,1015 off_t *found_offset)1016{1017int want;1018struct list_head *pos;10191020if(!exclude && local &&has_loose_object_nonlocal(oid->hash))1021return0;10221023/*1024 * If we already know the pack object lives in, start checks from that1025 * pack - in the usual case when neither --local was given nor .keep files1026 * are present we will determine the answer right now.1027 */1028if(*found_pack) {1029 want =want_found_object(exclude, *found_pack);1030if(want != -1)1031return want;1032}1033list_for_each(pos,get_packed_git_mru(the_repository)) {1034struct packed_git *p =list_entry(pos,struct packed_git, mru);1035 off_t offset;10361037if(p == *found_pack)1038 offset = *found_offset;1039else1040 offset =find_pack_entry_one(oid->hash, p);10411042if(offset) {1043if(!*found_pack) {1044if(!is_pack_valid(p))1045continue;1046*found_offset = offset;1047*found_pack = p;1048}1049 want =want_found_object(exclude, p);1050if(!exclude && want >0)1051list_move(&p->mru,1052get_packed_git_mru(the_repository));1053if(want != -1)1054return want;1055}1056}10571058return1;1059}10601061static voidcreate_object_entry(const struct object_id *oid,1062enum object_type type,1063uint32_t hash,1064int exclude,1065int no_try_delta,1066uint32_t index_pos,1067struct packed_git *found_pack,1068 off_t found_offset)1069{1070struct object_entry *entry;10711072 entry =packlist_alloc(&to_pack, oid->hash, index_pos);1073 entry->hash = hash;1074if(type)1075 entry->type = type;1076if(exclude)1077 entry->preferred_base =1;1078else1079 nr_result++;1080if(found_pack) {1081 entry->in_pack = found_pack;1082 entry->in_pack_offset = found_offset;1083}10841085 entry->no_try_delta = no_try_delta;1086}10871088static const char no_closure_warning[] =N_(1089"disabling bitmap writing, as some objects are not being packed"1090);10911092static intadd_object_entry(const struct object_id *oid,enum object_type type,1093const char*name,int exclude)1094{1095struct packed_git *found_pack = NULL;1096 off_t found_offset =0;1097uint32_t index_pos;10981099if(have_duplicate_entry(oid, exclude, &index_pos))1100return0;11011102if(!want_object_in_pack(oid, exclude, &found_pack, &found_offset)) {1103/* The pack is missing an object, so it will not have closure */1104if(write_bitmap_index) {1105warning(_(no_closure_warning));1106 write_bitmap_index =0;1107}1108return0;1109}11101111create_object_entry(oid, type,pack_name_hash(name),1112 exclude, name &&no_try_delta(name),1113 index_pos, found_pack, found_offset);11141115display_progress(progress_state, nr_result);1116return1;1117}11181119static intadd_object_entry_from_bitmap(const struct object_id *oid,1120enum object_type type,1121int flags,uint32_t name_hash,1122struct packed_git *pack, off_t offset)1123{1124uint32_t index_pos;11251126if(have_duplicate_entry(oid,0, &index_pos))1127return0;11281129if(!want_object_in_pack(oid,0, &pack, &offset))1130return0;11311132create_object_entry(oid, type, name_hash,0,0, index_pos, pack, offset);11331134display_progress(progress_state, nr_result);1135return1;1136}11371138struct pbase_tree_cache {1139struct object_id oid;1140int ref;1141int temporary;1142void*tree_data;1143unsigned long tree_size;1144};11451146static struct pbase_tree_cache *(pbase_tree_cache[256]);1147static intpbase_tree_cache_ix(const struct object_id *oid)1148{1149return oid->hash[0] %ARRAY_SIZE(pbase_tree_cache);1150}1151static intpbase_tree_cache_ix_incr(int ix)1152{1153return(ix+1) %ARRAY_SIZE(pbase_tree_cache);1154}11551156static struct pbase_tree {1157struct pbase_tree *next;1158/* This is a phony "cache" entry; we are not1159 * going to evict it or find it through _get()1160 * mechanism -- this is for the toplevel node that1161 * would almost always change with any commit.1162 */1163struct pbase_tree_cache pcache;1164} *pbase_tree;11651166static struct pbase_tree_cache *pbase_tree_get(const struct object_id *oid)1167{1168struct pbase_tree_cache *ent, *nent;1169void*data;1170unsigned long size;1171enum object_type type;1172int neigh;1173int my_ix =pbase_tree_cache_ix(oid);1174int available_ix = -1;11751176/* pbase-tree-cache acts as a limited hashtable.1177 * your object will be found at your index or within a few1178 * slots after that slot if it is cached.1179 */1180for(neigh =0; neigh <8; neigh++) {1181 ent = pbase_tree_cache[my_ix];1182if(ent && !oidcmp(&ent->oid, oid)) {1183 ent->ref++;1184return ent;1185}1186else if(((available_ix <0) && (!ent || !ent->ref)) ||1187((0<= available_ix) &&1188(!ent && pbase_tree_cache[available_ix])))1189 available_ix = my_ix;1190if(!ent)1191break;1192 my_ix =pbase_tree_cache_ix_incr(my_ix);1193}11941195/* Did not find one. Either we got a bogus request or1196 * we need to read and perhaps cache.1197 */1198 data =read_object_file(oid, &type, &size);1199if(!data)1200return NULL;1201if(type != OBJ_TREE) {1202free(data);1203return NULL;1204}12051206/* We need to either cache or return a throwaway copy */12071208if(available_ix <0)1209 ent = NULL;1210else{1211 ent = pbase_tree_cache[available_ix];1212 my_ix = available_ix;1213}12141215if(!ent) {1216 nent =xmalloc(sizeof(*nent));1217 nent->temporary = (available_ix <0);1218}1219else{1220/* evict and reuse */1221free(ent->tree_data);1222 nent = ent;1223}1224oidcpy(&nent->oid, oid);1225 nent->tree_data = data;1226 nent->tree_size = size;1227 nent->ref =1;1228if(!nent->temporary)1229 pbase_tree_cache[my_ix] = nent;1230return nent;1231}12321233static voidpbase_tree_put(struct pbase_tree_cache *cache)1234{1235if(!cache->temporary) {1236 cache->ref--;1237return;1238}1239free(cache->tree_data);1240free(cache);1241}12421243static intname_cmp_len(const char*name)1244{1245int i;1246for(i =0; name[i] && name[i] !='\n'&& name[i] !='/'; i++)1247;1248return i;1249}12501251static voidadd_pbase_object(struct tree_desc *tree,1252const char*name,1253int cmplen,1254const char*fullname)1255{1256struct name_entry entry;1257int cmp;12581259while(tree_entry(tree,&entry)) {1260if(S_ISGITLINK(entry.mode))1261continue;1262 cmp =tree_entry_len(&entry) != cmplen ?1:1263memcmp(name, entry.path, cmplen);1264if(cmp >0)1265continue;1266if(cmp <0)1267return;1268if(name[cmplen] !='/') {1269add_object_entry(entry.oid,1270object_type(entry.mode),1271 fullname,1);1272return;1273}1274if(S_ISDIR(entry.mode)) {1275struct tree_desc sub;1276struct pbase_tree_cache *tree;1277const char*down = name+cmplen+1;1278int downlen =name_cmp_len(down);12791280 tree =pbase_tree_get(entry.oid);1281if(!tree)1282return;1283init_tree_desc(&sub, tree->tree_data, tree->tree_size);12841285add_pbase_object(&sub, down, downlen, fullname);1286pbase_tree_put(tree);1287}1288}1289}12901291static unsigned*done_pbase_paths;1292static int done_pbase_paths_num;1293static int done_pbase_paths_alloc;1294static intdone_pbase_path_pos(unsigned hash)1295{1296int lo =0;1297int hi = done_pbase_paths_num;1298while(lo < hi) {1299int mi = lo + (hi - lo) /2;1300if(done_pbase_paths[mi] == hash)1301return mi;1302if(done_pbase_paths[mi] < hash)1303 hi = mi;1304else1305 lo = mi +1;1306}1307return-lo-1;1308}13091310static intcheck_pbase_path(unsigned hash)1311{1312int pos =done_pbase_path_pos(hash);1313if(0<= pos)1314return1;1315 pos = -pos -1;1316ALLOC_GROW(done_pbase_paths,1317 done_pbase_paths_num +1,1318 done_pbase_paths_alloc);1319 done_pbase_paths_num++;1320if(pos < done_pbase_paths_num)1321MOVE_ARRAY(done_pbase_paths + pos +1, done_pbase_paths + pos,1322 done_pbase_paths_num - pos -1);1323 done_pbase_paths[pos] = hash;1324return0;1325}13261327static voidadd_preferred_base_object(const char*name)1328{1329struct pbase_tree *it;1330int cmplen;1331unsigned hash =pack_name_hash(name);13321333if(!num_preferred_base ||check_pbase_path(hash))1334return;13351336 cmplen =name_cmp_len(name);1337for(it = pbase_tree; it; it = it->next) {1338if(cmplen ==0) {1339add_object_entry(&it->pcache.oid, OBJ_TREE, NULL,1);1340}1341else{1342struct tree_desc tree;1343init_tree_desc(&tree, it->pcache.tree_data, it->pcache.tree_size);1344add_pbase_object(&tree, name, cmplen, name);1345}1346}1347}13481349static voidadd_preferred_base(struct object_id *oid)1350{1351struct pbase_tree *it;1352void*data;1353unsigned long size;1354struct object_id tree_oid;13551356if(window <= num_preferred_base++)1357return;13581359 data =read_object_with_reference(oid, tree_type, &size, &tree_oid);1360if(!data)1361return;13621363for(it = pbase_tree; it; it = it->next) {1364if(!oidcmp(&it->pcache.oid, &tree_oid)) {1365free(data);1366return;1367}1368}13691370 it =xcalloc(1,sizeof(*it));1371 it->next = pbase_tree;1372 pbase_tree = it;13731374oidcpy(&it->pcache.oid, &tree_oid);1375 it->pcache.tree_data = data;1376 it->pcache.tree_size = size;1377}13781379static voidcleanup_preferred_base(void)1380{1381struct pbase_tree *it;1382unsigned i;13831384 it = pbase_tree;1385 pbase_tree = NULL;1386while(it) {1387struct pbase_tree *tmp = it;1388 it = tmp->next;1389free(tmp->pcache.tree_data);1390free(tmp);1391}13921393for(i =0; i <ARRAY_SIZE(pbase_tree_cache); i++) {1394if(!pbase_tree_cache[i])1395continue;1396free(pbase_tree_cache[i]->tree_data);1397FREE_AND_NULL(pbase_tree_cache[i]);1398}13991400FREE_AND_NULL(done_pbase_paths);1401 done_pbase_paths_num = done_pbase_paths_alloc =0;1402}14031404static voidcheck_object(struct object_entry *entry)1405{1406if(entry->in_pack) {1407struct packed_git *p = entry->in_pack;1408struct pack_window *w_curs = NULL;1409const unsigned char*base_ref = NULL;1410struct object_entry *base_entry;1411unsigned long used, used_0;1412unsigned long avail;1413 off_t ofs;1414unsigned char*buf, c;14151416 buf =use_pack(p, &w_curs, entry->in_pack_offset, &avail);14171418/*1419 * We want in_pack_type even if we do not reuse delta1420 * since non-delta representations could still be reused.1421 */1422 used =unpack_object_header_buffer(buf, avail,1423&entry->in_pack_type,1424&entry->size);1425if(used ==0)1426goto give_up;14271428/*1429 * Determine if this is a delta and if so whether we can1430 * reuse it or not. Otherwise let's find out as cheaply as1431 * possible what the actual type and size for this object is.1432 */1433switch(entry->in_pack_type) {1434default:1435/* Not a delta hence we've already got all we need. */1436 entry->type = entry->in_pack_type;1437 entry->in_pack_header_size = used;1438if(entry->type < OBJ_COMMIT || entry->type > OBJ_BLOB)1439goto give_up;1440unuse_pack(&w_curs);1441return;1442case OBJ_REF_DELTA:1443if(reuse_delta && !entry->preferred_base)1444 base_ref =use_pack(p, &w_curs,1445 entry->in_pack_offset + used, NULL);1446 entry->in_pack_header_size = used +20;1447break;1448case OBJ_OFS_DELTA:1449 buf =use_pack(p, &w_curs,1450 entry->in_pack_offset + used, NULL);1451 used_0 =0;1452 c = buf[used_0++];1453 ofs = c &127;1454while(c &128) {1455 ofs +=1;1456if(!ofs ||MSB(ofs,7)) {1457error("delta base offset overflow in pack for%s",1458oid_to_hex(&entry->idx.oid));1459goto give_up;1460}1461 c = buf[used_0++];1462 ofs = (ofs <<7) + (c &127);1463}1464 ofs = entry->in_pack_offset - ofs;1465if(ofs <=0|| ofs >= entry->in_pack_offset) {1466error("delta base offset out of bound for%s",1467oid_to_hex(&entry->idx.oid));1468goto give_up;1469}1470if(reuse_delta && !entry->preferred_base) {1471struct revindex_entry *revidx;1472 revidx =find_pack_revindex(p, ofs);1473if(!revidx)1474goto give_up;1475 base_ref =nth_packed_object_sha1(p, revidx->nr);1476}1477 entry->in_pack_header_size = used + used_0;1478break;1479}14801481if(base_ref && (base_entry =packlist_find(&to_pack, base_ref, NULL))) {1482/*1483 * If base_ref was set above that means we wish to1484 * reuse delta data, and we even found that base1485 * in the list of objects we want to pack. Goodie!1486 *1487 * Depth value does not matter - find_deltas() will1488 * never consider reused delta as the base object to1489 * deltify other objects against, in order to avoid1490 * circular deltas.1491 */1492 entry->type = entry->in_pack_type;1493 entry->delta = base_entry;1494 entry->delta_size = entry->size;1495 entry->delta_sibling = base_entry->delta_child;1496 base_entry->delta_child = entry;1497unuse_pack(&w_curs);1498return;1499}15001501if(entry->type) {1502/*1503 * This must be a delta and we already know what the1504 * final object type is. Let's extract the actual1505 * object size from the delta header.1506 */1507 entry->size =get_size_from_delta(p, &w_curs,1508 entry->in_pack_offset + entry->in_pack_header_size);1509if(entry->size ==0)1510goto give_up;1511unuse_pack(&w_curs);1512return;1513}15141515/*1516 * No choice but to fall back to the recursive delta walk1517 * with sha1_object_info() to find about the object type1518 * at this point...1519 */1520 give_up:1521unuse_pack(&w_curs);1522}15231524 entry->type =oid_object_info(&entry->idx.oid, &entry->size);1525/*1526 * The error condition is checked in prepare_pack(). This is1527 * to permit a missing preferred base object to be ignored1528 * as a preferred base. Doing so can result in a larger1529 * pack file, but the transfer will still take place.1530 */1531}15321533static intpack_offset_sort(const void*_a,const void*_b)1534{1535const struct object_entry *a = *(struct object_entry **)_a;1536const struct object_entry *b = *(struct object_entry **)_b;15371538/* avoid filesystem trashing with loose objects */1539if(!a->in_pack && !b->in_pack)1540returnoidcmp(&a->idx.oid, &b->idx.oid);15411542if(a->in_pack < b->in_pack)1543return-1;1544if(a->in_pack > b->in_pack)1545return1;1546return a->in_pack_offset < b->in_pack_offset ? -1:1547(a->in_pack_offset > b->in_pack_offset);1548}15491550/*1551 * Drop an on-disk delta we were planning to reuse. Naively, this would1552 * just involve blanking out the "delta" field, but we have to deal1553 * with some extra book-keeping:1554 *1555 * 1. Removing ourselves from the delta_sibling linked list.1556 *1557 * 2. Updating our size/type to the non-delta representation. These were1558 * either not recorded initially (size) or overwritten with the delta type1559 * (type) when check_object() decided to reuse the delta.1560 *1561 * 3. Resetting our delta depth, as we are now a base object.1562 */1563static voiddrop_reused_delta(struct object_entry *entry)1564{1565struct object_entry **p = &entry->delta->delta_child;1566struct object_info oi = OBJECT_INFO_INIT;15671568while(*p) {1569if(*p == entry)1570*p = (*p)->delta_sibling;1571else1572 p = &(*p)->delta_sibling;1573}1574 entry->delta = NULL;1575 entry->depth =0;15761577 oi.sizep = &entry->size;1578 oi.typep = &entry->type;1579if(packed_object_info(entry->in_pack, entry->in_pack_offset, &oi) <0) {1580/*1581 * We failed to get the info from this pack for some reason;1582 * fall back to sha1_object_info, which may find another copy.1583 * And if that fails, the error will be recorded in entry->type1584 * and dealt with in prepare_pack().1585 */1586 entry->type =oid_object_info(&entry->idx.oid, &entry->size);1587}1588}15891590/*1591 * Follow the chain of deltas from this entry onward, throwing away any links1592 * that cause us to hit a cycle (as determined by the DFS state flags in1593 * the entries).1594 *1595 * We also detect too-long reused chains that would violate our --depth1596 * limit.1597 */1598static voidbreak_delta_chains(struct object_entry *entry)1599{1600/*1601 * The actual depth of each object we will write is stored as an int,1602 * as it cannot exceed our int "depth" limit. But before we break1603 * changes based no that limit, we may potentially go as deep as the1604 * number of objects, which is elsewhere bounded to a uint32_t.1605 */1606uint32_t total_depth;1607struct object_entry *cur, *next;16081609for(cur = entry, total_depth =0;1610 cur;1611 cur = cur->delta, total_depth++) {1612if(cur->dfs_state == DFS_DONE) {1613/*1614 * We've already seen this object and know it isn't1615 * part of a cycle. We do need to append its depth1616 * to our count.1617 */1618 total_depth += cur->depth;1619break;1620}16211622/*1623 * We break cycles before looping, so an ACTIVE state (or any1624 * other cruft which made its way into the state variable)1625 * is a bug.1626 */1627if(cur->dfs_state != DFS_NONE)1628die("BUG: confusing delta dfs state in first pass:%d",1629 cur->dfs_state);16301631/*1632 * Now we know this is the first time we've seen the object. If1633 * it's not a delta, we're done traversing, but we'll mark it1634 * done to save time on future traversals.1635 */1636if(!cur->delta) {1637 cur->dfs_state = DFS_DONE;1638break;1639}16401641/*1642 * Mark ourselves as active and see if the next step causes1643 * us to cycle to another active object. It's important to do1644 * this _before_ we loop, because it impacts where we make the1645 * cut, and thus how our total_depth counter works.1646 * E.g., We may see a partial loop like:1647 *1648 * A -> B -> C -> D -> B1649 *1650 * Cutting B->C breaks the cycle. But now the depth of A is1651 * only 1, and our total_depth counter is at 3. The size of the1652 * error is always one less than the size of the cycle we1653 * broke. Commits C and D were "lost" from A's chain.1654 *1655 * If we instead cut D->B, then the depth of A is correct at 3.1656 * We keep all commits in the chain that we examined.1657 */1658 cur->dfs_state = DFS_ACTIVE;1659if(cur->delta->dfs_state == DFS_ACTIVE) {1660drop_reused_delta(cur);1661 cur->dfs_state = DFS_DONE;1662break;1663}1664}16651666/*1667 * And now that we've gone all the way to the bottom of the chain, we1668 * need to clear the active flags and set the depth fields as1669 * appropriate. Unlike the loop above, which can quit when it drops a1670 * delta, we need to keep going to look for more depth cuts. So we need1671 * an extra "next" pointer to keep going after we reset cur->delta.1672 */1673for(cur = entry; cur; cur = next) {1674 next = cur->delta;16751676/*1677 * We should have a chain of zero or more ACTIVE states down to1678 * a final DONE. We can quit after the DONE, because either it1679 * has no bases, or we've already handled them in a previous1680 * call.1681 */1682if(cur->dfs_state == DFS_DONE)1683break;1684else if(cur->dfs_state != DFS_ACTIVE)1685die("BUG: confusing delta dfs state in second pass:%d",1686 cur->dfs_state);16871688/*1689 * If the total_depth is more than depth, then we need to snip1690 * the chain into two or more smaller chains that don't exceed1691 * the maximum depth. Most of the resulting chains will contain1692 * (depth + 1) entries (i.e., depth deltas plus one base), and1693 * the last chain (i.e., the one containing entry) will contain1694 * whatever entries are left over, namely1695 * (total_depth % (depth + 1)) of them.1696 *1697 * Since we are iterating towards decreasing depth, we need to1698 * decrement total_depth as we go, and we need to write to the1699 * entry what its final depth will be after all of the1700 * snipping. Since we're snipping into chains of length (depth1701 * + 1) entries, the final depth of an entry will be its1702 * original depth modulo (depth + 1). Any time we encounter an1703 * entry whose final depth is supposed to be zero, we snip it1704 * from its delta base, thereby making it so.1705 */1706 cur->depth = (total_depth--) % (depth +1);1707if(!cur->depth)1708drop_reused_delta(cur);17091710 cur->dfs_state = DFS_DONE;1711}1712}17131714static voidget_object_details(void)1715{1716uint32_t i;1717struct object_entry **sorted_by_offset;17181719 sorted_by_offset =xcalloc(to_pack.nr_objects,sizeof(struct object_entry *));1720for(i =0; i < to_pack.nr_objects; i++)1721 sorted_by_offset[i] = to_pack.objects + i;1722QSORT(sorted_by_offset, to_pack.nr_objects, pack_offset_sort);17231724for(i =0; i < to_pack.nr_objects; i++) {1725struct object_entry *entry = sorted_by_offset[i];1726check_object(entry);1727if(big_file_threshold < entry->size)1728 entry->no_try_delta =1;1729}17301731/*1732 * This must happen in a second pass, since we rely on the delta1733 * information for the whole list being completed.1734 */1735for(i =0; i < to_pack.nr_objects; i++)1736break_delta_chains(&to_pack.objects[i]);17371738free(sorted_by_offset);1739}17401741/*1742 * We search for deltas in a list sorted by type, by filename hash, and then1743 * by size, so that we see progressively smaller and smaller files.1744 * That's because we prefer deltas to be from the bigger file1745 * to the smaller -- deletes are potentially cheaper, but perhaps1746 * more importantly, the bigger file is likely the more recent1747 * one. The deepest deltas are therefore the oldest objects which are1748 * less susceptible to be accessed often.1749 */1750static inttype_size_sort(const void*_a,const void*_b)1751{1752const struct object_entry *a = *(struct object_entry **)_a;1753const struct object_entry *b = *(struct object_entry **)_b;17541755if(a->type > b->type)1756return-1;1757if(a->type < b->type)1758return1;1759if(a->hash > b->hash)1760return-1;1761if(a->hash < b->hash)1762return1;1763if(a->preferred_base > b->preferred_base)1764return-1;1765if(a->preferred_base < b->preferred_base)1766return1;1767if(a->size > b->size)1768return-1;1769if(a->size < b->size)1770return1;1771return a < b ? -1: (a > b);/* newest first */1772}17731774struct unpacked {1775struct object_entry *entry;1776void*data;1777struct delta_index *index;1778unsigned depth;1779};17801781static intdelta_cacheable(unsigned long src_size,unsigned long trg_size,1782unsigned long delta_size)1783{1784if(max_delta_cache_size && delta_cache_size + delta_size > max_delta_cache_size)1785return0;17861787if(delta_size < cache_max_small_delta_size)1788return1;17891790/* cache delta, if objects are large enough compared to delta size */1791if((src_size >>20) + (trg_size >>21) > (delta_size >>10))1792return1;17931794return0;1795}17961797#ifndef NO_PTHREADS17981799static pthread_mutex_t read_mutex;1800#define read_lock() pthread_mutex_lock(&read_mutex)1801#define read_unlock() pthread_mutex_unlock(&read_mutex)18021803static pthread_mutex_t cache_mutex;1804#define cache_lock() pthread_mutex_lock(&cache_mutex)1805#define cache_unlock() pthread_mutex_unlock(&cache_mutex)18061807static pthread_mutex_t progress_mutex;1808#define progress_lock() pthread_mutex_lock(&progress_mutex)1809#define progress_unlock() pthread_mutex_unlock(&progress_mutex)18101811#else18121813#define read_lock() (void)01814#define read_unlock() (void)01815#define cache_lock() (void)01816#define cache_unlock() (void)01817#define progress_lock() (void)01818#define progress_unlock() (void)018191820#endif18211822static inttry_delta(struct unpacked *trg,struct unpacked *src,1823unsigned max_depth,unsigned long*mem_usage)1824{1825struct object_entry *trg_entry = trg->entry;1826struct object_entry *src_entry = src->entry;1827unsigned long trg_size, src_size, delta_size, sizediff, max_size, sz;1828unsigned ref_depth;1829enum object_type type;1830void*delta_buf;18311832/* Don't bother doing diffs between different types */1833if(trg_entry->type != src_entry->type)1834return-1;18351836/*1837 * We do not bother to try a delta that we discarded on an1838 * earlier try, but only when reusing delta data. Note that1839 * src_entry that is marked as the preferred_base should always1840 * be considered, as even if we produce a suboptimal delta against1841 * it, we will still save the transfer cost, as we already know1842 * the other side has it and we won't send src_entry at all.1843 */1844if(reuse_delta && trg_entry->in_pack &&1845 trg_entry->in_pack == src_entry->in_pack &&1846!src_entry->preferred_base &&1847 trg_entry->in_pack_type != OBJ_REF_DELTA &&1848 trg_entry->in_pack_type != OBJ_OFS_DELTA)1849return0;18501851/* Let's not bust the allowed depth. */1852if(src->depth >= max_depth)1853return0;18541855/* Now some size filtering heuristics. */1856 trg_size = trg_entry->size;1857if(!trg_entry->delta) {1858 max_size = trg_size/2-20;1859 ref_depth =1;1860}else{1861 max_size = trg_entry->delta_size;1862 ref_depth = trg->depth;1863}1864 max_size = (uint64_t)max_size * (max_depth - src->depth) /1865(max_depth - ref_depth +1);1866if(max_size ==0)1867return0;1868 src_size = src_entry->size;1869 sizediff = src_size < trg_size ? trg_size - src_size :0;1870if(sizediff >= max_size)1871return0;1872if(trg_size < src_size /32)1873return0;18741875/* Load data if not already done */1876if(!trg->data) {1877read_lock();1878 trg->data =read_object_file(&trg_entry->idx.oid, &type, &sz);1879read_unlock();1880if(!trg->data)1881die("object%scannot be read",1882oid_to_hex(&trg_entry->idx.oid));1883if(sz != trg_size)1884die("object%sinconsistent object length (%lu vs%lu)",1885oid_to_hex(&trg_entry->idx.oid), sz,1886 trg_size);1887*mem_usage += sz;1888}1889if(!src->data) {1890read_lock();1891 src->data =read_object_file(&src_entry->idx.oid, &type, &sz);1892read_unlock();1893if(!src->data) {1894if(src_entry->preferred_base) {1895static int warned =0;1896if(!warned++)1897warning("object%scannot be read",1898oid_to_hex(&src_entry->idx.oid));1899/*1900 * Those objects are not included in the1901 * resulting pack. Be resilient and ignore1902 * them if they can't be read, in case the1903 * pack could be created nevertheless.1904 */1905return0;1906}1907die("object%scannot be read",1908oid_to_hex(&src_entry->idx.oid));1909}1910if(sz != src_size)1911die("object%sinconsistent object length (%lu vs%lu)",1912oid_to_hex(&src_entry->idx.oid), sz,1913 src_size);1914*mem_usage += sz;1915}1916if(!src->index) {1917 src->index =create_delta_index(src->data, src_size);1918if(!src->index) {1919static int warned =0;1920if(!warned++)1921warning("suboptimal pack - out of memory");1922return0;1923}1924*mem_usage +=sizeof_delta_index(src->index);1925}19261927 delta_buf =create_delta(src->index, trg->data, trg_size, &delta_size, max_size);1928if(!delta_buf)1929return0;19301931if(trg_entry->delta) {1932/* Prefer only shallower same-sized deltas. */1933if(delta_size == trg_entry->delta_size &&1934 src->depth +1>= trg->depth) {1935free(delta_buf);1936return0;1937}1938}19391940/*1941 * Handle memory allocation outside of the cache1942 * accounting lock. Compiler will optimize the strangeness1943 * away when NO_PTHREADS is defined.1944 */1945free(trg_entry->delta_data);1946cache_lock();1947if(trg_entry->delta_data) {1948 delta_cache_size -= trg_entry->delta_size;1949 trg_entry->delta_data = NULL;1950}1951if(delta_cacheable(src_size, trg_size, delta_size)) {1952 delta_cache_size += delta_size;1953cache_unlock();1954 trg_entry->delta_data =xrealloc(delta_buf, delta_size);1955}else{1956cache_unlock();1957free(delta_buf);1958}19591960 trg_entry->delta = src_entry;1961 trg_entry->delta_size = delta_size;1962 trg->depth = src->depth +1;19631964return1;1965}19661967static unsigned intcheck_delta_limit(struct object_entry *me,unsigned int n)1968{1969struct object_entry *child = me->delta_child;1970unsigned int m = n;1971while(child) {1972unsigned int c =check_delta_limit(child, n +1);1973if(m < c)1974 m = c;1975 child = child->delta_sibling;1976}1977return m;1978}19791980static unsigned longfree_unpacked(struct unpacked *n)1981{1982unsigned long freed_mem =sizeof_delta_index(n->index);1983free_delta_index(n->index);1984 n->index = NULL;1985if(n->data) {1986 freed_mem += n->entry->size;1987FREE_AND_NULL(n->data);1988}1989 n->entry = NULL;1990 n->depth =0;1991return freed_mem;1992}19931994static voidfind_deltas(struct object_entry **list,unsigned*list_size,1995int window,int depth,unsigned*processed)1996{1997uint32_t i, idx =0, count =0;1998struct unpacked *array;1999unsigned long mem_usage =0;20002001 array =xcalloc(window,sizeof(struct unpacked));20022003for(;;) {2004struct object_entry *entry;2005struct unpacked *n = array + idx;2006int j, max_depth, best_base = -1;20072008progress_lock();2009if(!*list_size) {2010progress_unlock();2011break;2012}2013 entry = *list++;2014(*list_size)--;2015if(!entry->preferred_base) {2016(*processed)++;2017display_progress(progress_state, *processed);2018}2019progress_unlock();20202021 mem_usage -=free_unpacked(n);2022 n->entry = entry;20232024while(window_memory_limit &&2025 mem_usage > window_memory_limit &&2026 count >1) {2027uint32_t tail = (idx + window - count) % window;2028 mem_usage -=free_unpacked(array + tail);2029 count--;2030}20312032/* We do not compute delta to *create* objects we are not2033 * going to pack.2034 */2035if(entry->preferred_base)2036goto next;20372038/*2039 * If the current object is at pack edge, take the depth the2040 * objects that depend on the current object into account2041 * otherwise they would become too deep.2042 */2043 max_depth = depth;2044if(entry->delta_child) {2045 max_depth -=check_delta_limit(entry,0);2046if(max_depth <=0)2047goto next;2048}20492050 j = window;2051while(--j >0) {2052int ret;2053uint32_t other_idx = idx + j;2054struct unpacked *m;2055if(other_idx >= window)2056 other_idx -= window;2057 m = array + other_idx;2058if(!m->entry)2059break;2060 ret =try_delta(n, m, max_depth, &mem_usage);2061if(ret <0)2062break;2063else if(ret >0)2064 best_base = other_idx;2065}20662067/*2068 * If we decided to cache the delta data, then it is best2069 * to compress it right away. First because we have to do2070 * it anyway, and doing it here while we're threaded will2071 * save a lot of time in the non threaded write phase,2072 * as well as allow for caching more deltas within2073 * the same cache size limit.2074 * ...2075 * But only if not writing to stdout, since in that case2076 * the network is most likely throttling writes anyway,2077 * and therefore it is best to go to the write phase ASAP2078 * instead, as we can afford spending more time compressing2079 * between writes at that moment.2080 */2081if(entry->delta_data && !pack_to_stdout) {2082 entry->z_delta_size =do_compress(&entry->delta_data,2083 entry->delta_size);2084cache_lock();2085 delta_cache_size -= entry->delta_size;2086 delta_cache_size += entry->z_delta_size;2087cache_unlock();2088}20892090/* if we made n a delta, and if n is already at max2091 * depth, leaving it in the window is pointless. we2092 * should evict it first.2093 */2094if(entry->delta && max_depth <= n->depth)2095continue;20962097/*2098 * Move the best delta base up in the window, after the2099 * currently deltified object, to keep it longer. It will2100 * be the first base object to be attempted next.2101 */2102if(entry->delta) {2103struct unpacked swap = array[best_base];2104int dist = (window + idx - best_base) % window;2105int dst = best_base;2106while(dist--) {2107int src = (dst +1) % window;2108 array[dst] = array[src];2109 dst = src;2110}2111 array[dst] = swap;2112}21132114 next:2115 idx++;2116if(count +1< window)2117 count++;2118if(idx >= window)2119 idx =0;2120}21212122for(i =0; i < window; ++i) {2123free_delta_index(array[i].index);2124free(array[i].data);2125}2126free(array);2127}21282129#ifndef NO_PTHREADS21302131static voidtry_to_free_from_threads(size_t size)2132{2133read_lock();2134release_pack_memory(size);2135read_unlock();2136}21372138static try_to_free_t old_try_to_free_routine;21392140/*2141 * The main thread waits on the condition that (at least) one of the workers2142 * has stopped working (which is indicated in the .working member of2143 * struct thread_params).2144 * When a work thread has completed its work, it sets .working to 0 and2145 * signals the main thread and waits on the condition that .data_ready2146 * becomes 1.2147 */21482149struct thread_params {2150 pthread_t thread;2151struct object_entry **list;2152unsigned list_size;2153unsigned remaining;2154int window;2155int depth;2156int working;2157int data_ready;2158 pthread_mutex_t mutex;2159 pthread_cond_t cond;2160unsigned*processed;2161};21622163static pthread_cond_t progress_cond;21642165/*2166 * Mutex and conditional variable can't be statically-initialized on Windows.2167 */2168static voidinit_threaded_search(void)2169{2170init_recursive_mutex(&read_mutex);2171pthread_mutex_init(&cache_mutex, NULL);2172pthread_mutex_init(&progress_mutex, NULL);2173pthread_cond_init(&progress_cond, NULL);2174 old_try_to_free_routine =set_try_to_free_routine(try_to_free_from_threads);2175}21762177static voidcleanup_threaded_search(void)2178{2179set_try_to_free_routine(old_try_to_free_routine);2180pthread_cond_destroy(&progress_cond);2181pthread_mutex_destroy(&read_mutex);2182pthread_mutex_destroy(&cache_mutex);2183pthread_mutex_destroy(&progress_mutex);2184}21852186static void*threaded_find_deltas(void*arg)2187{2188struct thread_params *me = arg;21892190progress_lock();2191while(me->remaining) {2192progress_unlock();21932194find_deltas(me->list, &me->remaining,2195 me->window, me->depth, me->processed);21962197progress_lock();2198 me->working =0;2199pthread_cond_signal(&progress_cond);2200progress_unlock();22012202/*2203 * We must not set ->data_ready before we wait on the2204 * condition because the main thread may have set it to 12205 * before we get here. In order to be sure that new2206 * work is available if we see 1 in ->data_ready, it2207 * was initialized to 0 before this thread was spawned2208 * and we reset it to 0 right away.2209 */2210pthread_mutex_lock(&me->mutex);2211while(!me->data_ready)2212pthread_cond_wait(&me->cond, &me->mutex);2213 me->data_ready =0;2214pthread_mutex_unlock(&me->mutex);22152216progress_lock();2217}2218progress_unlock();2219/* leave ->working 1 so that this doesn't get more work assigned */2220return NULL;2221}22222223static voidll_find_deltas(struct object_entry **list,unsigned list_size,2224int window,int depth,unsigned*processed)2225{2226struct thread_params *p;2227int i, ret, active_threads =0;22282229init_threaded_search();22302231if(delta_search_threads <=1) {2232find_deltas(list, &list_size, window, depth, processed);2233cleanup_threaded_search();2234return;2235}2236if(progress > pack_to_stdout)2237fprintf(stderr,"Delta compression using up to%dthreads.\n",2238 delta_search_threads);2239 p =xcalloc(delta_search_threads,sizeof(*p));22402241/* Partition the work amongst work threads. */2242for(i =0; i < delta_search_threads; i++) {2243unsigned sub_size = list_size / (delta_search_threads - i);22442245/* don't use too small segments or no deltas will be found */2246if(sub_size <2*window && i+1< delta_search_threads)2247 sub_size =0;22482249 p[i].window = window;2250 p[i].depth = depth;2251 p[i].processed = processed;2252 p[i].working =1;2253 p[i].data_ready =0;22542255/* try to split chunks on "path" boundaries */2256while(sub_size && sub_size < list_size &&2257 list[sub_size]->hash &&2258 list[sub_size]->hash == list[sub_size-1]->hash)2259 sub_size++;22602261 p[i].list = list;2262 p[i].list_size = sub_size;2263 p[i].remaining = sub_size;22642265 list += sub_size;2266 list_size -= sub_size;2267}22682269/* Start work threads. */2270for(i =0; i < delta_search_threads; i++) {2271if(!p[i].list_size)2272continue;2273pthread_mutex_init(&p[i].mutex, NULL);2274pthread_cond_init(&p[i].cond, NULL);2275 ret =pthread_create(&p[i].thread, NULL,2276 threaded_find_deltas, &p[i]);2277if(ret)2278die("unable to create thread:%s",strerror(ret));2279 active_threads++;2280}22812282/*2283 * Now let's wait for work completion. Each time a thread is done2284 * with its work, we steal half of the remaining work from the2285 * thread with the largest number of unprocessed objects and give2286 * it to that newly idle thread. This ensure good load balancing2287 * until the remaining object list segments are simply too short2288 * to be worth splitting anymore.2289 */2290while(active_threads) {2291struct thread_params *target = NULL;2292struct thread_params *victim = NULL;2293unsigned sub_size =0;22942295progress_lock();2296for(;;) {2297for(i =0; !target && i < delta_search_threads; i++)2298if(!p[i].working)2299 target = &p[i];2300if(target)2301break;2302pthread_cond_wait(&progress_cond, &progress_mutex);2303}23042305for(i =0; i < delta_search_threads; i++)2306if(p[i].remaining >2*window &&2307(!victim || victim->remaining < p[i].remaining))2308 victim = &p[i];2309if(victim) {2310 sub_size = victim->remaining /2;2311 list = victim->list + victim->list_size - sub_size;2312while(sub_size && list[0]->hash &&2313 list[0]->hash == list[-1]->hash) {2314 list++;2315 sub_size--;2316}2317if(!sub_size) {2318/*2319 * It is possible for some "paths" to have2320 * so many objects that no hash boundary2321 * might be found. Let's just steal the2322 * exact half in that case.2323 */2324 sub_size = victim->remaining /2;2325 list -= sub_size;2326}2327 target->list = list;2328 victim->list_size -= sub_size;2329 victim->remaining -= sub_size;2330}2331 target->list_size = sub_size;2332 target->remaining = sub_size;2333 target->working =1;2334progress_unlock();23352336pthread_mutex_lock(&target->mutex);2337 target->data_ready =1;2338pthread_cond_signal(&target->cond);2339pthread_mutex_unlock(&target->mutex);23402341if(!sub_size) {2342pthread_join(target->thread, NULL);2343pthread_cond_destroy(&target->cond);2344pthread_mutex_destroy(&target->mutex);2345 active_threads--;2346}2347}2348cleanup_threaded_search();2349free(p);2350}23512352#else2353#define ll_find_deltas(l, s, w, d, p) find_deltas(l, &s, w, d, p)2354#endif23552356static voidadd_tag_chain(const struct object_id *oid)2357{2358struct tag *tag;23592360/*2361 * We catch duplicates already in add_object_entry(), but we'd2362 * prefer to do this extra check to avoid having to parse the2363 * tag at all if we already know that it's being packed (e.g., if2364 * it was included via bitmaps, we would not have parsed it2365 * previously).2366 */2367if(packlist_find(&to_pack, oid->hash, NULL))2368return;23692370 tag =lookup_tag(oid);2371while(1) {2372if(!tag ||parse_tag(tag) || !tag->tagged)2373die("unable to pack objects reachable from tag%s",2374oid_to_hex(oid));23752376add_object_entry(&tag->object.oid, OBJ_TAG, NULL,0);23772378if(tag->tagged->type != OBJ_TAG)2379return;23802381 tag = (struct tag *)tag->tagged;2382}2383}23842385static intadd_ref_tag(const char*path,const struct object_id *oid,int flag,void*cb_data)2386{2387struct object_id peeled;23882389if(starts_with(path,"refs/tags/") &&/* is a tag? */2390!peel_ref(path, &peeled) &&/* peelable? */2391packlist_find(&to_pack, peeled.hash, NULL))/* object packed? */2392add_tag_chain(oid);2393return0;2394}23952396static voidprepare_pack(int window,int depth)2397{2398struct object_entry **delta_list;2399uint32_t i, nr_deltas;2400unsigned n;24012402get_object_details();24032404/*2405 * If we're locally repacking then we need to be doubly careful2406 * from now on in order to make sure no stealth corruption gets2407 * propagated to the new pack. Clients receiving streamed packs2408 * should validate everything they get anyway so no need to incur2409 * the additional cost here in that case.2410 */2411if(!pack_to_stdout)2412 do_check_packed_object_crc =1;24132414if(!to_pack.nr_objects || !window || !depth)2415return;24162417ALLOC_ARRAY(delta_list, to_pack.nr_objects);2418 nr_deltas = n =0;24192420for(i =0; i < to_pack.nr_objects; i++) {2421struct object_entry *entry = to_pack.objects + i;24222423if(entry->delta)2424/* This happens if we decided to reuse existing2425 * delta from a pack. "reuse_delta &&" is implied.2426 */2427continue;24282429if(entry->size <50)2430continue;24312432if(entry->no_try_delta)2433continue;24342435if(!entry->preferred_base) {2436 nr_deltas++;2437if(entry->type <0)2438die("unable to get type of object%s",2439oid_to_hex(&entry->idx.oid));2440}else{2441if(entry->type <0) {2442/*2443 * This object is not found, but we2444 * don't have to include it anyway.2445 */2446continue;2447}2448}24492450 delta_list[n++] = entry;2451}24522453if(nr_deltas && n >1) {2454unsigned nr_done =0;2455if(progress)2456 progress_state =start_progress(_("Compressing objects"),2457 nr_deltas);2458QSORT(delta_list, n, type_size_sort);2459ll_find_deltas(delta_list, n, window+1, depth, &nr_done);2460stop_progress(&progress_state);2461if(nr_done != nr_deltas)2462die("inconsistency with delta count");2463}2464free(delta_list);2465}24662467static intgit_pack_config(const char*k,const char*v,void*cb)2468{2469if(!strcmp(k,"pack.window")) {2470 window =git_config_int(k, v);2471return0;2472}2473if(!strcmp(k,"pack.windowmemory")) {2474 window_memory_limit =git_config_ulong(k, v);2475return0;2476}2477if(!strcmp(k,"pack.depth")) {2478 depth =git_config_int(k, v);2479return0;2480}2481if(!strcmp(k,"pack.deltacachesize")) {2482 max_delta_cache_size =git_config_int(k, v);2483return0;2484}2485if(!strcmp(k,"pack.deltacachelimit")) {2486 cache_max_small_delta_size =git_config_int(k, v);2487return0;2488}2489if(!strcmp(k,"pack.writebitmaphashcache")) {2490if(git_config_bool(k, v))2491 write_bitmap_options |= BITMAP_OPT_HASH_CACHE;2492else2493 write_bitmap_options &= ~BITMAP_OPT_HASH_CACHE;2494}2495if(!strcmp(k,"pack.usebitmaps")) {2496 use_bitmap_index_default =git_config_bool(k, v);2497return0;2498}2499if(!strcmp(k,"pack.threads")) {2500 delta_search_threads =git_config_int(k, v);2501if(delta_search_threads <0)2502die("invalid number of threads specified (%d)",2503 delta_search_threads);2504#ifdef NO_PTHREADS2505if(delta_search_threads !=1) {2506warning("no threads support, ignoring%s", k);2507 delta_search_threads =0;2508}2509#endif2510return0;2511}2512if(!strcmp(k,"pack.indexversion")) {2513 pack_idx_opts.version =git_config_int(k, v);2514if(pack_idx_opts.version >2)2515die("bad pack.indexversion=%"PRIu32,2516 pack_idx_opts.version);2517return0;2518}2519returngit_default_config(k, v, cb);2520}25212522static voidread_object_list_from_stdin(void)2523{2524char line[GIT_MAX_HEXSZ +1+ PATH_MAX +2];2525struct object_id oid;2526const char*p;25272528for(;;) {2529if(!fgets(line,sizeof(line), stdin)) {2530if(feof(stdin))2531break;2532if(!ferror(stdin))2533die("fgets returned NULL, not EOF, not error!");2534if(errno != EINTR)2535die_errno("fgets");2536clearerr(stdin);2537continue;2538}2539if(line[0] =='-') {2540if(get_oid_hex(line+1, &oid))2541die("expected edge object ID, got garbage:\n%s",2542 line);2543add_preferred_base(&oid);2544continue;2545}2546if(parse_oid_hex(line, &oid, &p))2547die("expected object ID, got garbage:\n%s", line);25482549add_preferred_base_object(p +1);2550add_object_entry(&oid,0, p +1,0);2551}2552}25532554/* Remember to update object flag allocation in object.h */2555#define OBJECT_ADDED (1u<<20)25562557static voidshow_commit(struct commit *commit,void*data)2558{2559add_object_entry(&commit->object.oid, OBJ_COMMIT, NULL,0);2560 commit->object.flags |= OBJECT_ADDED;25612562if(write_bitmap_index)2563index_commit_for_bitmap(commit);2564}25652566static voidshow_object(struct object *obj,const char*name,void*data)2567{2568add_preferred_base_object(name);2569add_object_entry(&obj->oid, obj->type, name,0);2570 obj->flags |= OBJECT_ADDED;2571}25722573static voidshow_object__ma_allow_any(struct object *obj,const char*name,void*data)2574{2575assert(arg_missing_action == MA_ALLOW_ANY);25762577/*2578 * Quietly ignore ALL missing objects. This avoids problems with2579 * staging them now and getting an odd error later.2580 */2581if(!has_object_file(&obj->oid))2582return;25832584show_object(obj, name, data);2585}25862587static voidshow_object__ma_allow_promisor(struct object *obj,const char*name,void*data)2588{2589assert(arg_missing_action == MA_ALLOW_PROMISOR);25902591/*2592 * Quietly ignore EXPECTED missing objects. This avoids problems with2593 * staging them now and getting an odd error later.2594 */2595if(!has_object_file(&obj->oid) &&is_promisor_object(&obj->oid))2596return;25972598show_object(obj, name, data);2599}26002601static intoption_parse_missing_action(const struct option *opt,2602const char*arg,int unset)2603{2604assert(arg);2605assert(!unset);26062607if(!strcmp(arg,"error")) {2608 arg_missing_action = MA_ERROR;2609 fn_show_object = show_object;2610return0;2611}26122613if(!strcmp(arg,"allow-any")) {2614 arg_missing_action = MA_ALLOW_ANY;2615 fetch_if_missing =0;2616 fn_show_object = show_object__ma_allow_any;2617return0;2618}26192620if(!strcmp(arg,"allow-promisor")) {2621 arg_missing_action = MA_ALLOW_PROMISOR;2622 fetch_if_missing =0;2623 fn_show_object = show_object__ma_allow_promisor;2624return0;2625}26262627die(_("invalid value for --missing"));2628return0;2629}26302631static voidshow_edge(struct commit *commit)2632{2633add_preferred_base(&commit->object.oid);2634}26352636struct in_pack_object {2637 off_t offset;2638struct object *object;2639};26402641struct in_pack {2642unsigned int alloc;2643unsigned int nr;2644struct in_pack_object *array;2645};26462647static voidmark_in_pack_object(struct object *object,struct packed_git *p,struct in_pack *in_pack)2648{2649 in_pack->array[in_pack->nr].offset =find_pack_entry_one(object->oid.hash, p);2650 in_pack->array[in_pack->nr].object = object;2651 in_pack->nr++;2652}26532654/*2655 * Compare the objects in the offset order, in order to emulate the2656 * "git rev-list --objects" output that produced the pack originally.2657 */2658static intofscmp(const void*a_,const void*b_)2659{2660struct in_pack_object *a = (struct in_pack_object *)a_;2661struct in_pack_object *b = (struct in_pack_object *)b_;26622663if(a->offset < b->offset)2664return-1;2665else if(a->offset > b->offset)2666return1;2667else2668returnoidcmp(&a->object->oid, &b->object->oid);2669}26702671static voidadd_objects_in_unpacked_packs(struct rev_info *revs)2672{2673struct packed_git *p;2674struct in_pack in_pack;2675uint32_t i;26762677memset(&in_pack,0,sizeof(in_pack));26782679for(p =get_packed_git(the_repository); p; p = p->next) {2680struct object_id oid;2681struct object *o;26822683if(!p->pack_local || p->pack_keep || p->pack_keep_in_core)2684continue;2685if(open_pack_index(p))2686die("cannot open pack index");26872688ALLOC_GROW(in_pack.array,2689 in_pack.nr + p->num_objects,2690 in_pack.alloc);26912692for(i =0; i < p->num_objects; i++) {2693nth_packed_object_oid(&oid, p, i);2694 o =lookup_unknown_object(oid.hash);2695if(!(o->flags & OBJECT_ADDED))2696mark_in_pack_object(o, p, &in_pack);2697 o->flags |= OBJECT_ADDED;2698}2699}27002701if(in_pack.nr) {2702QSORT(in_pack.array, in_pack.nr, ofscmp);2703for(i =0; i < in_pack.nr; i++) {2704struct object *o = in_pack.array[i].object;2705add_object_entry(&o->oid, o->type,"",0);2706}2707}2708free(in_pack.array);2709}27102711static intadd_loose_object(const struct object_id *oid,const char*path,2712void*data)2713{2714enum object_type type =oid_object_info(oid, NULL);27152716if(type <0) {2717warning("loose object at%scould not be examined", path);2718return0;2719}27202721add_object_entry(oid, type,"",0);2722return0;2723}27242725/*2726 * We actually don't even have to worry about reachability here.2727 * add_object_entry will weed out duplicates, so we just add every2728 * loose object we find.2729 */2730static voidadd_unreachable_loose_objects(void)2731{2732for_each_loose_file_in_objdir(get_object_directory(),2733 add_loose_object,2734 NULL, NULL, NULL);2735}27362737static inthas_sha1_pack_kept_or_nonlocal(const struct object_id *oid)2738{2739static struct packed_git *last_found = (void*)1;2740struct packed_git *p;27412742 p = (last_found != (void*)1) ? last_found :2743get_packed_git(the_repository);27442745while(p) {2746if((!p->pack_local || p->pack_keep ||2747 p->pack_keep_in_core) &&2748find_pack_entry_one(oid->hash, p)) {2749 last_found = p;2750return1;2751}2752if(p == last_found)2753 p =get_packed_git(the_repository);2754else2755 p = p->next;2756if(p == last_found)2757 p = p->next;2758}2759return0;2760}27612762/*2763 * Store a list of sha1s that are should not be discarded2764 * because they are either written too recently, or are2765 * reachable from another object that was.2766 *2767 * This is filled by get_object_list.2768 */2769static struct oid_array recent_objects;27702771static intloosened_object_can_be_discarded(const struct object_id *oid,2772 timestamp_t mtime)2773{2774if(!unpack_unreachable_expiration)2775return0;2776if(mtime > unpack_unreachable_expiration)2777return0;2778if(oid_array_lookup(&recent_objects, oid) >=0)2779return0;2780return1;2781}27822783static voidloosen_unused_packed_objects(struct rev_info *revs)2784{2785struct packed_git *p;2786uint32_t i;2787struct object_id oid;27882789for(p =get_packed_git(the_repository); p; p = p->next) {2790if(!p->pack_local || p->pack_keep || p->pack_keep_in_core)2791continue;27922793if(open_pack_index(p))2794die("cannot open pack index");27952796for(i =0; i < p->num_objects; i++) {2797nth_packed_object_oid(&oid, p, i);2798if(!packlist_find(&to_pack, oid.hash, NULL) &&2799!has_sha1_pack_kept_or_nonlocal(&oid) &&2800!loosened_object_can_be_discarded(&oid, p->mtime))2801if(force_object_loose(&oid, p->mtime))2802die("unable to force loose object");2803}2804}2805}28062807/*2808 * This tracks any options which pack-reuse code expects to be on, or which a2809 * reader of the pack might not understand, and which would therefore prevent2810 * blind reuse of what we have on disk.2811 */2812static intpack_options_allow_reuse(void)2813{2814return pack_to_stdout &&2815 allow_ofs_delta &&2816!ignore_packed_keep_on_disk &&2817!ignore_packed_keep_in_core &&2818(!local || !have_non_local_packs) &&2819!incremental;2820}28212822static intget_object_list_from_bitmap(struct rev_info *revs)2823{2824if(prepare_bitmap_walk(revs) <0)2825return-1;28262827if(pack_options_allow_reuse() &&2828!reuse_partial_packfile_from_bitmap(2829&reuse_packfile,2830&reuse_packfile_objects,2831&reuse_packfile_offset)) {2832assert(reuse_packfile_objects);2833 nr_result += reuse_packfile_objects;2834display_progress(progress_state, nr_result);2835}28362837traverse_bitmap_commit_list(&add_object_entry_from_bitmap);2838return0;2839}28402841static voidrecord_recent_object(struct object *obj,2842const char*name,2843void*data)2844{2845oid_array_append(&recent_objects, &obj->oid);2846}28472848static voidrecord_recent_commit(struct commit *commit,void*data)2849{2850oid_array_append(&recent_objects, &commit->object.oid);2851}28522853static voidget_object_list(int ac,const char**av)2854{2855struct rev_info revs;2856char line[1000];2857int flags =0;28582859init_revisions(&revs, NULL);2860 save_commit_buffer =0;2861setup_revisions(ac, av, &revs, NULL);28622863/* make sure shallows are read */2864is_repository_shallow();28652866while(fgets(line,sizeof(line), stdin) != NULL) {2867int len =strlen(line);2868if(len && line[len -1] =='\n')2869 line[--len] =0;2870if(!len)2871break;2872if(*line =='-') {2873if(!strcmp(line,"--not")) {2874 flags ^= UNINTERESTING;2875 write_bitmap_index =0;2876continue;2877}2878if(starts_with(line,"--shallow ")) {2879struct object_id oid;2880if(get_oid_hex(line +10, &oid))2881die("not an SHA-1 '%s'", line +10);2882register_shallow(&oid);2883 use_bitmap_index =0;2884continue;2885}2886die("not a rev '%s'", line);2887}2888if(handle_revision_arg(line, &revs, flags, REVARG_CANNOT_BE_FILENAME))2889die("bad revision '%s'", line);2890}28912892if(use_bitmap_index && !get_object_list_from_bitmap(&revs))2893return;28942895if(prepare_revision_walk(&revs))2896die("revision walk setup failed");2897mark_edges_uninteresting(&revs, show_edge);28982899if(!fn_show_object)2900 fn_show_object = show_object;2901traverse_commit_list_filtered(&filter_options, &revs,2902 show_commit, fn_show_object, NULL,2903 NULL);29042905if(unpack_unreachable_expiration) {2906 revs.ignore_missing_links =1;2907if(add_unseen_recent_objects_to_traversal(&revs,2908 unpack_unreachable_expiration))2909die("unable to add recent objects");2910if(prepare_revision_walk(&revs))2911die("revision walk setup failed");2912traverse_commit_list(&revs, record_recent_commit,2913 record_recent_object, NULL);2914}29152916if(keep_unreachable)2917add_objects_in_unpacked_packs(&revs);2918if(pack_loose_unreachable)2919add_unreachable_loose_objects();2920if(unpack_unreachable)2921loosen_unused_packed_objects(&revs);29222923oid_array_clear(&recent_objects);2924}29252926static voidadd_extra_kept_packs(const struct string_list *names)2927{2928struct packed_git *p;29292930if(!names->nr)2931return;29322933for(p =get_packed_git(the_repository); p; p = p->next) {2934const char*name =basename(p->pack_name);2935int i;29362937if(!p->pack_local)2938continue;29392940for(i =0; i < names->nr; i++)2941if(!fspathcmp(name, names->items[i].string))2942break;29432944if(i < names->nr) {2945 p->pack_keep_in_core =1;2946 ignore_packed_keep_in_core =1;2947continue;2948}2949}2950}29512952static intoption_parse_index_version(const struct option *opt,2953const char*arg,int unset)2954{2955char*c;2956const char*val = arg;2957 pack_idx_opts.version =strtoul(val, &c,10);2958if(pack_idx_opts.version >2)2959die(_("unsupported index version%s"), val);2960if(*c ==','&& c[1])2961 pack_idx_opts.off32_limit =strtoul(c+1, &c,0);2962if(*c || pack_idx_opts.off32_limit &0x80000000)2963die(_("bad index version '%s'"), val);2964return0;2965}29662967static intoption_parse_unpack_unreachable(const struct option *opt,2968const char*arg,int unset)2969{2970if(unset) {2971 unpack_unreachable =0;2972 unpack_unreachable_expiration =0;2973}2974else{2975 unpack_unreachable =1;2976if(arg)2977 unpack_unreachable_expiration =approxidate(arg);2978}2979return0;2980}29812982intcmd_pack_objects(int argc,const char**argv,const char*prefix)2983{2984int use_internal_rev_list =0;2985int thin =0;2986int shallow =0;2987int all_progress_implied =0;2988struct argv_array rp = ARGV_ARRAY_INIT;2989int rev_list_unpacked =0, rev_list_all =0, rev_list_reflog =0;2990int rev_list_index =0;2991struct string_list keep_pack_list = STRING_LIST_INIT_NODUP;2992struct option pack_objects_options[] = {2993OPT_SET_INT('q',"quiet", &progress,2994N_("do not show progress meter"),0),2995OPT_SET_INT(0,"progress", &progress,2996N_("show progress meter"),1),2997OPT_SET_INT(0,"all-progress", &progress,2998N_("show progress meter during object writing phase"),2),2999OPT_BOOL(0,"all-progress-implied",3000&all_progress_implied,3001N_("similar to --all-progress when progress meter is shown")),3002{ OPTION_CALLBACK,0,"index-version", NULL,N_("version[,offset]"),3003N_("write the pack index file in the specified idx format version"),30040, option_parse_index_version },3005OPT_MAGNITUDE(0,"max-pack-size", &pack_size_limit,3006N_("maximum size of each output pack file")),3007OPT_BOOL(0,"local", &local,3008N_("ignore borrowed objects from alternate object store")),3009OPT_BOOL(0,"incremental", &incremental,3010N_("ignore packed objects")),3011OPT_INTEGER(0,"window", &window,3012N_("limit pack window by objects")),3013OPT_MAGNITUDE(0,"window-memory", &window_memory_limit,3014N_("limit pack window by memory in addition to object limit")),3015OPT_INTEGER(0,"depth", &depth,3016N_("maximum length of delta chain allowed in the resulting pack")),3017OPT_BOOL(0,"reuse-delta", &reuse_delta,3018N_("reuse existing deltas")),3019OPT_BOOL(0,"reuse-object", &reuse_object,3020N_("reuse existing objects")),3021OPT_BOOL(0,"delta-base-offset", &allow_ofs_delta,3022N_("use OFS_DELTA objects")),3023OPT_INTEGER(0,"threads", &delta_search_threads,3024N_("use threads when searching for best delta matches")),3025OPT_BOOL(0,"non-empty", &non_empty,3026N_("do not create an empty pack output")),3027OPT_BOOL(0,"revs", &use_internal_rev_list,3028N_("read revision arguments from standard input")),3029{ OPTION_SET_INT,0,"unpacked", &rev_list_unpacked, NULL,3030N_("limit the objects to those that are not yet packed"),3031 PARSE_OPT_NOARG | PARSE_OPT_NONEG, NULL,1},3032{ OPTION_SET_INT,0,"all", &rev_list_all, NULL,3033N_("include objects reachable from any reference"),3034 PARSE_OPT_NOARG | PARSE_OPT_NONEG, NULL,1},3035{ OPTION_SET_INT,0,"reflog", &rev_list_reflog, NULL,3036N_("include objects referred by reflog entries"),3037 PARSE_OPT_NOARG | PARSE_OPT_NONEG, NULL,1},3038{ OPTION_SET_INT,0,"indexed-objects", &rev_list_index, NULL,3039N_("include objects referred to by the index"),3040 PARSE_OPT_NOARG | PARSE_OPT_NONEG, NULL,1},3041OPT_BOOL(0,"stdout", &pack_to_stdout,3042N_("output pack to stdout")),3043OPT_BOOL(0,"include-tag", &include_tag,3044N_("include tag objects that refer to objects to be packed")),3045OPT_BOOL(0,"keep-unreachable", &keep_unreachable,3046N_("keep unreachable objects")),3047OPT_BOOL(0,"pack-loose-unreachable", &pack_loose_unreachable,3048N_("pack loose unreachable objects")),3049{ OPTION_CALLBACK,0,"unpack-unreachable", NULL,N_("time"),3050N_("unpack unreachable objects newer than <time>"),3051 PARSE_OPT_OPTARG, option_parse_unpack_unreachable },3052OPT_BOOL(0,"thin", &thin,3053N_("create thin packs")),3054OPT_BOOL(0,"shallow", &shallow,3055N_("create packs suitable for shallow fetches")),3056OPT_BOOL(0,"honor-pack-keep", &ignore_packed_keep_on_disk,3057N_("ignore packs that have companion .keep file")),3058OPT_STRING_LIST(0,"keep-pack", &keep_pack_list,N_("name"),3059N_("ignore this pack")),3060OPT_INTEGER(0,"compression", &pack_compression_level,3061N_("pack compression level")),3062OPT_SET_INT(0,"keep-true-parents", &grafts_replace_parents,3063N_("do not hide commits by grafts"),0),3064OPT_BOOL(0,"use-bitmap-index", &use_bitmap_index,3065N_("use a bitmap index if available to speed up counting objects")),3066OPT_BOOL(0,"write-bitmap-index", &write_bitmap_index,3067N_("write a bitmap index together with the pack index")),3068OPT_PARSE_LIST_OBJECTS_FILTER(&filter_options),3069{ OPTION_CALLBACK,0,"missing", NULL,N_("action"),3070N_("handling for missing objects"), PARSE_OPT_NONEG,3071 option_parse_missing_action },3072OPT_BOOL(0,"exclude-promisor-objects", &exclude_promisor_objects,3073N_("do not pack objects in promisor packfiles")),3074OPT_END(),3075};30763077 check_replace_refs =0;30783079reset_pack_idx_option(&pack_idx_opts);3080git_config(git_pack_config, NULL);30813082 progress =isatty(2);3083 argc =parse_options(argc, argv, prefix, pack_objects_options,3084 pack_usage,0);30853086if(argc) {3087 base_name = argv[0];3088 argc--;3089}3090if(pack_to_stdout != !base_name || argc)3091usage_with_options(pack_usage, pack_objects_options);30923093argv_array_push(&rp,"pack-objects");3094if(thin) {3095 use_internal_rev_list =1;3096argv_array_push(&rp, shallow3097?"--objects-edge-aggressive"3098:"--objects-edge");3099}else3100argv_array_push(&rp,"--objects");31013102if(rev_list_all) {3103 use_internal_rev_list =1;3104argv_array_push(&rp,"--all");3105}3106if(rev_list_reflog) {3107 use_internal_rev_list =1;3108argv_array_push(&rp,"--reflog");3109}3110if(rev_list_index) {3111 use_internal_rev_list =1;3112argv_array_push(&rp,"--indexed-objects");3113}3114if(rev_list_unpacked) {3115 use_internal_rev_list =1;3116argv_array_push(&rp,"--unpacked");3117}31183119if(exclude_promisor_objects) {3120 use_internal_rev_list =1;3121 fetch_if_missing =0;3122argv_array_push(&rp,"--exclude-promisor-objects");3123}31243125if(!reuse_object)3126 reuse_delta =0;3127if(pack_compression_level == -1)3128 pack_compression_level = Z_DEFAULT_COMPRESSION;3129else if(pack_compression_level <0|| pack_compression_level > Z_BEST_COMPRESSION)3130die("bad pack compression level%d", pack_compression_level);31313132if(!delta_search_threads)/* --threads=0 means autodetect */3133 delta_search_threads =online_cpus();31343135#ifdef NO_PTHREADS3136if(delta_search_threads !=1)3137warning("no threads support, ignoring --threads");3138#endif3139if(!pack_to_stdout && !pack_size_limit)3140 pack_size_limit = pack_size_limit_cfg;3141if(pack_to_stdout && pack_size_limit)3142die("--max-pack-size cannot be used to build a pack for transfer.");3143if(pack_size_limit && pack_size_limit <1024*1024) {3144warning("minimum pack size limit is 1 MiB");3145 pack_size_limit =1024*1024;3146}31473148if(!pack_to_stdout && thin)3149die("--thin cannot be used to build an indexable pack.");31503151if(keep_unreachable && unpack_unreachable)3152die("--keep-unreachable and --unpack-unreachable are incompatible.");3153if(!rev_list_all || !rev_list_reflog || !rev_list_index)3154 unpack_unreachable_expiration =0;31553156if(filter_options.choice) {3157if(!pack_to_stdout)3158die("cannot use --filter without --stdout.");3159 use_bitmap_index =0;3160}31613162/*3163 * "soft" reasons not to use bitmaps - for on-disk repack by default we want3164 *3165 * - to produce good pack (with bitmap index not-yet-packed objects are3166 * packed in suboptimal order).3167 *3168 * - to use more robust pack-generation codepath (avoiding possible3169 * bugs in bitmap code and possible bitmap index corruption).3170 */3171if(!pack_to_stdout)3172 use_bitmap_index_default =0;31733174if(use_bitmap_index <0)3175 use_bitmap_index = use_bitmap_index_default;31763177/* "hard" reasons not to use bitmaps; these just won't work at all */3178if(!use_internal_rev_list || (!pack_to_stdout && write_bitmap_index) ||is_repository_shallow())3179 use_bitmap_index =0;31803181if(pack_to_stdout || !rev_list_all)3182 write_bitmap_index =0;31833184if(progress && all_progress_implied)3185 progress =2;31863187add_extra_kept_packs(&keep_pack_list);3188if(ignore_packed_keep_on_disk) {3189struct packed_git *p;3190for(p =get_packed_git(the_repository); p; p = p->next)3191if(p->pack_local && p->pack_keep)3192break;3193if(!p)/* no keep-able packs found */3194 ignore_packed_keep_on_disk =0;3195}3196if(local) {3197/*3198 * unlike ignore_packed_keep_on_disk above, we do not3199 * want to unset "local" based on looking at packs, as3200 * it also covers non-local objects3201 */3202struct packed_git *p;3203for(p =get_packed_git(the_repository); p; p = p->next) {3204if(!p->pack_local) {3205 have_non_local_packs =1;3206break;3207}3208}3209}32103211if(progress)3212 progress_state =start_progress(_("Counting objects"),0);3213if(!use_internal_rev_list)3214read_object_list_from_stdin();3215else{3216get_object_list(rp.argc, rp.argv);3217argv_array_clear(&rp);3218}3219cleanup_preferred_base();3220if(include_tag && nr_result)3221for_each_ref(add_ref_tag, NULL);3222stop_progress(&progress_state);32233224if(non_empty && !nr_result)3225return0;3226if(nr_result)3227prepare_pack(window, depth);3228write_pack_file();3229if(progress)3230fprintf(stderr,"Total %"PRIu32" (delta %"PRIu32"),"3231" reused %"PRIu32" (delta %"PRIu32")\n",3232 written, written_delta, reused, reused_delta);3233return0;3234}