7 #include "object-store.h"
8 #include "hash-lookup.h"
12 #include "run-command.h"
13 #include "repository.h"
14 #include "chunk-format.h"
17 #define MIDX_SIGNATURE 0x4d494458 /* "MIDX" */
18 #define MIDX_VERSION 1
19 #define MIDX_BYTE_FILE_VERSION 4
20 #define MIDX_BYTE_HASH_VERSION 5
21 #define MIDX_BYTE_NUM_CHUNKS 6
22 #define MIDX_BYTE_NUM_PACKS 8
23 #define MIDX_HEADER_SIZE 12
24 #define MIDX_MIN_SIZE (MIDX_HEADER_SIZE + the_hash_algo->rawsz)
26 #define MIDX_CHUNK_ALIGNMENT 4
27 #define MIDX_CHUNKID_PACKNAMES 0x504e414d /* "PNAM" */
28 #define MIDX_CHUNKID_OIDFANOUT 0x4f494446 /* "OIDF" */
29 #define MIDX_CHUNKID_OIDLOOKUP 0x4f49444c /* "OIDL" */
30 #define MIDX_CHUNKID_OBJECTOFFSETS 0x4f4f4646 /* "OOFF" */
31 #define MIDX_CHUNKID_LARGEOFFSETS 0x4c4f4646 /* "LOFF" */
32 #define MIDX_CHUNK_FANOUT_SIZE (sizeof(uint32_t) * 256)
33 #define MIDX_CHUNK_OFFSET_WIDTH (2 * sizeof(uint32_t))
34 #define MIDX_CHUNK_LARGE_OFFSET_WIDTH (sizeof(uint64_t))
35 #define MIDX_LARGE_OFFSET_NEEDED 0x80000000
37 #define PACK_EXPIRED UINT_MAX
39 static uint8_t oid_version(void)
41 switch (hash_algo_by_ptr(the_hash_algo
)) {
47 die(_("invalid hash version"));
51 static const unsigned char *get_midx_checksum(struct multi_pack_index
*m
)
53 return m
->data
+ m
->data_len
- the_hash_algo
->rawsz
;
56 static char *get_midx_filename(const char *object_dir
)
58 return xstrfmt("%s/pack/multi-pack-index", object_dir
);
61 char *get_midx_rev_filename(struct multi_pack_index
*m
)
63 return xstrfmt("%s/pack/multi-pack-index-%s.rev",
64 m
->object_dir
, hash_to_hex(get_midx_checksum(m
)));
67 static int midx_read_oid_fanout(const unsigned char *chunk_start
,
68 size_t chunk_size
, void *data
)
70 struct multi_pack_index
*m
= data
;
71 m
->chunk_oid_fanout
= (uint32_t *)chunk_start
;
73 if (chunk_size
!= 4 * 256) {
74 error(_("multi-pack-index OID fanout is of the wrong size"));
80 struct multi_pack_index
*load_multi_pack_index(const char *object_dir
, int local
)
82 struct multi_pack_index
*m
= NULL
;
86 void *midx_map
= NULL
;
87 uint32_t hash_version
;
88 char *midx_name
= get_midx_filename(object_dir
);
90 const char *cur_pack_name
;
91 struct chunkfile
*cf
= NULL
;
93 fd
= git_open(midx_name
);
98 error_errno(_("failed to read %s"), midx_name
);
102 midx_size
= xsize_t(st
.st_size
);
104 if (midx_size
< MIDX_MIN_SIZE
) {
105 error(_("multi-pack-index file %s is too small"), midx_name
);
109 FREE_AND_NULL(midx_name
);
111 midx_map
= xmmap(NULL
, midx_size
, PROT_READ
, MAP_PRIVATE
, fd
, 0);
114 FLEX_ALLOC_STR(m
, object_dir
, object_dir
);
116 m
->data_len
= midx_size
;
119 m
->signature
= get_be32(m
->data
);
120 if (m
->signature
!= MIDX_SIGNATURE
)
121 die(_("multi-pack-index signature 0x%08x does not match signature 0x%08x"),
122 m
->signature
, MIDX_SIGNATURE
);
124 m
->version
= m
->data
[MIDX_BYTE_FILE_VERSION
];
125 if (m
->version
!= MIDX_VERSION
)
126 die(_("multi-pack-index version %d not recognized"),
129 hash_version
= m
->data
[MIDX_BYTE_HASH_VERSION
];
130 if (hash_version
!= oid_version()) {
131 error(_("multi-pack-index hash version %u does not match version %u"),
132 hash_version
, oid_version());
135 m
->hash_len
= the_hash_algo
->rawsz
;
137 m
->num_chunks
= m
->data
[MIDX_BYTE_NUM_CHUNKS
];
139 m
->num_packs
= get_be32(m
->data
+ MIDX_BYTE_NUM_PACKS
);
141 cf
= init_chunkfile(NULL
);
143 if (read_table_of_contents(cf
, m
->data
, midx_size
,
144 MIDX_HEADER_SIZE
, m
->num_chunks
))
147 if (pair_chunk(cf
, MIDX_CHUNKID_PACKNAMES
, &m
->chunk_pack_names
) == CHUNK_NOT_FOUND
)
148 die(_("multi-pack-index missing required pack-name chunk"));
149 if (read_chunk(cf
, MIDX_CHUNKID_OIDFANOUT
, midx_read_oid_fanout
, m
) == CHUNK_NOT_FOUND
)
150 die(_("multi-pack-index missing required OID fanout chunk"));
151 if (pair_chunk(cf
, MIDX_CHUNKID_OIDLOOKUP
, &m
->chunk_oid_lookup
) == CHUNK_NOT_FOUND
)
152 die(_("multi-pack-index missing required OID lookup chunk"));
153 if (pair_chunk(cf
, MIDX_CHUNKID_OBJECTOFFSETS
, &m
->chunk_object_offsets
) == CHUNK_NOT_FOUND
)
154 die(_("multi-pack-index missing required object offsets chunk"));
156 pair_chunk(cf
, MIDX_CHUNKID_LARGEOFFSETS
, &m
->chunk_large_offsets
);
158 m
->num_objects
= ntohl(m
->chunk_oid_fanout
[255]);
160 CALLOC_ARRAY(m
->pack_names
, m
->num_packs
);
161 CALLOC_ARRAY(m
->packs
, m
->num_packs
);
163 cur_pack_name
= (const char *)m
->chunk_pack_names
;
164 for (i
= 0; i
< m
->num_packs
; i
++) {
165 m
->pack_names
[i
] = cur_pack_name
;
167 cur_pack_name
+= strlen(cur_pack_name
) + 1;
169 if (i
&& strcmp(m
->pack_names
[i
], m
->pack_names
[i
- 1]) <= 0)
170 die(_("multi-pack-index pack names out of order: '%s' before '%s'"),
171 m
->pack_names
[i
- 1],
175 trace2_data_intmax("midx", the_repository
, "load/num_packs", m
->num_packs
);
176 trace2_data_intmax("midx", the_repository
, "load/num_objects", m
->num_objects
);
185 munmap(midx_map
, midx_size
);
191 void close_midx(struct multi_pack_index
*m
)
198 munmap((unsigned char *)m
->data
, m
->data_len
);
200 for (i
= 0; i
< m
->num_packs
; i
++) {
202 m
->packs
[i
]->multi_pack_index
= 0;
204 FREE_AND_NULL(m
->packs
);
205 FREE_AND_NULL(m
->pack_names
);
208 int prepare_midx_pack(struct repository
*r
, struct multi_pack_index
*m
, uint32_t pack_int_id
)
210 struct strbuf pack_name
= STRBUF_INIT
;
211 struct packed_git
*p
;
213 if (pack_int_id
>= m
->num_packs
)
214 die(_("bad pack-int-id: %u (%u total packs)"),
215 pack_int_id
, m
->num_packs
);
217 if (m
->packs
[pack_int_id
])
220 strbuf_addf(&pack_name
, "%s/pack/%s", m
->object_dir
,
221 m
->pack_names
[pack_int_id
]);
223 p
= add_packed_git(pack_name
.buf
, pack_name
.len
, m
->local
);
224 strbuf_release(&pack_name
);
229 p
->multi_pack_index
= 1;
230 m
->packs
[pack_int_id
] = p
;
231 install_packed_git(r
, p
);
232 list_add_tail(&p
->mru
, &r
->objects
->packed_git_mru
);
237 int bsearch_midx(const struct object_id
*oid
, struct multi_pack_index
*m
, uint32_t *result
)
239 return bsearch_hash(oid
->hash
, m
->chunk_oid_fanout
, m
->chunk_oid_lookup
,
240 the_hash_algo
->rawsz
, result
);
243 struct object_id
*nth_midxed_object_oid(struct object_id
*oid
,
244 struct multi_pack_index
*m
,
247 if (n
>= m
->num_objects
)
250 oidread(oid
, m
->chunk_oid_lookup
+ m
->hash_len
* n
);
254 off_t
nth_midxed_offset(struct multi_pack_index
*m
, uint32_t pos
)
256 const unsigned char *offset_data
;
259 offset_data
= m
->chunk_object_offsets
+ (off_t
)pos
* MIDX_CHUNK_OFFSET_WIDTH
;
260 offset32
= get_be32(offset_data
+ sizeof(uint32_t));
262 if (m
->chunk_large_offsets
&& offset32
& MIDX_LARGE_OFFSET_NEEDED
) {
263 if (sizeof(off_t
) < sizeof(uint64_t))
264 die(_("multi-pack-index stores a 64-bit offset, but off_t is too small"));
266 offset32
^= MIDX_LARGE_OFFSET_NEEDED
;
267 return get_be64(m
->chunk_large_offsets
+ sizeof(uint64_t) * offset32
);
273 uint32_t nth_midxed_pack_int_id(struct multi_pack_index
*m
, uint32_t pos
)
275 return get_be32(m
->chunk_object_offsets
+
276 (off_t
)pos
* MIDX_CHUNK_OFFSET_WIDTH
);
279 int fill_midx_entry(struct repository
* r
,
280 const struct object_id
*oid
,
281 struct pack_entry
*e
,
282 struct multi_pack_index
*m
)
285 uint32_t pack_int_id
;
286 struct packed_git
*p
;
288 if (!bsearch_midx(oid
, m
, &pos
))
291 if (pos
>= m
->num_objects
)
294 pack_int_id
= nth_midxed_pack_int_id(m
, pos
);
296 if (prepare_midx_pack(r
, m
, pack_int_id
))
298 p
= m
->packs
[pack_int_id
];
301 * We are about to tell the caller where they can locate the
302 * requested object. We better make sure the packfile is
303 * still here and can be accessed before supplying that
304 * answer, as it may have been deleted since the MIDX was
307 if (!is_pack_valid(p
))
310 if (p
->num_bad_objects
) {
312 for (i
= 0; i
< p
->num_bad_objects
; i
++)
313 if (hasheq(oid
->hash
,
314 p
->bad_object_sha1
+ the_hash_algo
->rawsz
* i
))
318 e
->offset
= nth_midxed_offset(m
, pos
);
324 /* Match "foo.idx" against either "foo.pack" _or_ "foo.idx". */
325 static int cmp_idx_or_pack_name(const char *idx_or_pack_name
,
326 const char *idx_name
)
328 /* Skip past any initial matching prefix. */
329 while (*idx_name
&& *idx_name
== *idx_or_pack_name
) {
335 * If we didn't match completely, we may have matched "pack-1234." and
336 * be left with "idx" and "pack" respectively, which is also OK. We do
337 * not have to check for "idx" and "idx", because that would have been
338 * a complete match (and in that case these strcmps will be false, but
339 * we'll correctly return 0 from the final strcmp() below.
341 * Technically this matches "fooidx" and "foopack", but we'd never have
342 * such names in the first place.
344 if (!strcmp(idx_name
, "idx") && !strcmp(idx_or_pack_name
, "pack"))
348 * This not only checks for a complete match, but also orders based on
349 * the first non-identical character, which means our ordering will
350 * match a raw strcmp(). That makes it OK to use this to binary search
351 * a naively-sorted list.
353 return strcmp(idx_or_pack_name
, idx_name
);
356 int midx_contains_pack(struct multi_pack_index
*m
, const char *idx_or_pack_name
)
358 uint32_t first
= 0, last
= m
->num_packs
;
360 while (first
< last
) {
361 uint32_t mid
= first
+ (last
- first
) / 2;
365 current
= m
->pack_names
[mid
];
366 cmp
= cmp_idx_or_pack_name(idx_or_pack_name
, current
);
379 int prepare_multi_pack_index_one(struct repository
*r
, const char *object_dir
, int local
)
381 struct multi_pack_index
*m
;
382 struct multi_pack_index
*m_search
;
384 prepare_repo_settings(r
);
385 if (!r
->settings
.core_multi_pack_index
)
388 for (m_search
= r
->objects
->multi_pack_index
; m_search
; m_search
= m_search
->next
)
389 if (!strcmp(object_dir
, m_search
->object_dir
))
392 m
= load_multi_pack_index(object_dir
, local
);
395 struct multi_pack_index
*mp
= r
->objects
->multi_pack_index
;
400 r
->objects
->multi_pack_index
= m
;
407 static size_t write_midx_header(struct hashfile
*f
,
408 unsigned char num_chunks
,
411 hashwrite_be32(f
, MIDX_SIGNATURE
);
412 hashwrite_u8(f
, MIDX_VERSION
);
413 hashwrite_u8(f
, oid_version());
414 hashwrite_u8(f
, num_chunks
);
415 hashwrite_u8(f
, 0); /* unused */
416 hashwrite_be32(f
, num_packs
);
418 return MIDX_HEADER_SIZE
;
422 uint32_t orig_pack_int_id
;
424 struct packed_git
*p
;
425 unsigned expired
: 1;
428 static int pack_info_compare(const void *_a
, const void *_b
)
430 struct pack_info
*a
= (struct pack_info
*)_a
;
431 struct pack_info
*b
= (struct pack_info
*)_b
;
432 return strcmp(a
->pack_name
, b
->pack_name
);
435 static int idx_or_pack_name_cmp(const void *_va
, const void *_vb
)
437 const char *pack_name
= _va
;
438 const struct pack_info
*compar
= _vb
;
440 return cmp_idx_or_pack_name(pack_name
, compar
->pack_name
);
443 struct write_midx_context
{
444 struct pack_info
*info
;
447 struct multi_pack_index
*m
;
448 struct progress
*progress
;
449 unsigned pack_paths_checked
;
451 struct pack_midx_entry
*entries
;
455 uint32_t *pack_order
;
456 unsigned large_offsets_needed
:1;
457 uint32_t num_large_offsets
;
459 int preferred_pack_idx
;
462 static void add_pack_to_midx(const char *full_path
, size_t full_path_len
,
463 const char *file_name
, void *data
)
465 struct write_midx_context
*ctx
= data
;
467 if (ends_with(file_name
, ".idx")) {
468 display_progress(ctx
->progress
, ++ctx
->pack_paths_checked
);
469 if (ctx
->m
&& midx_contains_pack(ctx
->m
, file_name
))
472 ALLOC_GROW(ctx
->info
, ctx
->nr
+ 1, ctx
->alloc
);
474 ctx
->info
[ctx
->nr
].p
= add_packed_git(full_path
,
478 if (!ctx
->info
[ctx
->nr
].p
) {
479 warning(_("failed to add packfile '%s'"),
484 if (open_pack_index(ctx
->info
[ctx
->nr
].p
)) {
485 warning(_("failed to open pack-index '%s'"),
487 close_pack(ctx
->info
[ctx
->nr
].p
);
488 FREE_AND_NULL(ctx
->info
[ctx
->nr
].p
);
492 ctx
->info
[ctx
->nr
].pack_name
= xstrdup(file_name
);
493 ctx
->info
[ctx
->nr
].orig_pack_int_id
= ctx
->nr
;
494 ctx
->info
[ctx
->nr
].expired
= 0;
499 struct pack_midx_entry
{
500 struct object_id oid
;
501 uint32_t pack_int_id
;
504 unsigned preferred
: 1;
507 static int midx_oid_compare(const void *_a
, const void *_b
)
509 const struct pack_midx_entry
*a
= (const struct pack_midx_entry
*)_a
;
510 const struct pack_midx_entry
*b
= (const struct pack_midx_entry
*)_b
;
511 int cmp
= oidcmp(&a
->oid
, &b
->oid
);
516 /* Sort objects in a preferred pack first when multiple copies exist. */
517 if (a
->preferred
> b
->preferred
)
519 if (a
->preferred
< b
->preferred
)
522 if (a
->pack_mtime
> b
->pack_mtime
)
524 else if (a
->pack_mtime
< b
->pack_mtime
)
527 return a
->pack_int_id
- b
->pack_int_id
;
530 static int nth_midxed_pack_midx_entry(struct multi_pack_index
*m
,
531 struct pack_midx_entry
*e
,
534 if (pos
>= m
->num_objects
)
537 nth_midxed_object_oid(&e
->oid
, m
, pos
);
538 e
->pack_int_id
= nth_midxed_pack_int_id(m
, pos
);
539 e
->offset
= nth_midxed_offset(m
, pos
);
541 /* consider objects in midx to be from "old" packs */
546 static void fill_pack_entry(uint32_t pack_int_id
,
547 struct packed_git
*p
,
549 struct pack_midx_entry
*entry
,
552 if (nth_packed_object_id(&entry
->oid
, p
, cur_object
) < 0)
553 die(_("failed to locate object %d in packfile"), cur_object
);
555 entry
->pack_int_id
= pack_int_id
;
556 entry
->pack_mtime
= p
->mtime
;
558 entry
->offset
= nth_packed_object_offset(p
, cur_object
);
559 entry
->preferred
= !!preferred
;
563 * It is possible to artificially get into a state where there are many
564 * duplicate copies of objects. That can create high memory pressure if
565 * we are to create a list of all objects before de-duplication. To reduce
566 * this memory pressure without a significant performance drop, automatically
567 * group objects by the first byte of their object id. Use the IDX fanout
568 * tables to group the data, copy to a local array, then sort.
570 * Copy only the de-duplicated entries (selected by most-recent modified time
571 * of a packfile containing the object).
573 static struct pack_midx_entry
*get_sorted_entries(struct multi_pack_index
*m
,
574 struct pack_info
*info
,
576 uint32_t *nr_objects
,
579 uint32_t cur_fanout
, cur_pack
, cur_object
;
580 uint32_t alloc_fanout
, alloc_objects
, total_objects
= 0;
581 struct pack_midx_entry
*entries_by_fanout
= NULL
;
582 struct pack_midx_entry
*deduplicated_entries
= NULL
;
583 uint32_t start_pack
= m
? m
->num_packs
: 0;
585 for (cur_pack
= start_pack
; cur_pack
< nr_packs
; cur_pack
++)
586 total_objects
+= info
[cur_pack
].p
->num_objects
;
589 * As we de-duplicate by fanout value, we expect the fanout
590 * slices to be evenly distributed, with some noise. Hence,
591 * allocate slightly more than one 256th.
593 alloc_objects
= alloc_fanout
= total_objects
> 3200 ? total_objects
/ 200 : 16;
595 ALLOC_ARRAY(entries_by_fanout
, alloc_fanout
);
596 ALLOC_ARRAY(deduplicated_entries
, alloc_objects
);
599 for (cur_fanout
= 0; cur_fanout
< 256; cur_fanout
++) {
600 uint32_t nr_fanout
= 0;
603 uint32_t start
= 0, end
;
606 start
= ntohl(m
->chunk_oid_fanout
[cur_fanout
- 1]);
607 end
= ntohl(m
->chunk_oid_fanout
[cur_fanout
]);
609 for (cur_object
= start
; cur_object
< end
; cur_object
++) {
610 ALLOC_GROW(entries_by_fanout
, nr_fanout
+ 1, alloc_fanout
);
611 nth_midxed_pack_midx_entry(m
,
612 &entries_by_fanout
[nr_fanout
],
614 if (nth_midxed_pack_int_id(m
, cur_object
) == preferred_pack
)
615 entries_by_fanout
[nr_fanout
].preferred
= 1;
617 entries_by_fanout
[nr_fanout
].preferred
= 0;
622 for (cur_pack
= start_pack
; cur_pack
< nr_packs
; cur_pack
++) {
623 uint32_t start
= 0, end
;
624 int preferred
= cur_pack
== preferred_pack
;
627 start
= get_pack_fanout(info
[cur_pack
].p
, cur_fanout
- 1);
628 end
= get_pack_fanout(info
[cur_pack
].p
, cur_fanout
);
630 for (cur_object
= start
; cur_object
< end
; cur_object
++) {
631 ALLOC_GROW(entries_by_fanout
, nr_fanout
+ 1, alloc_fanout
);
632 fill_pack_entry(cur_pack
,
635 &entries_by_fanout
[nr_fanout
],
641 QSORT(entries_by_fanout
, nr_fanout
, midx_oid_compare
);
644 * The batch is now sorted by OID and then mtime (descending).
645 * Take only the first duplicate.
647 for (cur_object
= 0; cur_object
< nr_fanout
; cur_object
++) {
648 if (cur_object
&& oideq(&entries_by_fanout
[cur_object
- 1].oid
,
649 &entries_by_fanout
[cur_object
].oid
))
652 ALLOC_GROW(deduplicated_entries
, *nr_objects
+ 1, alloc_objects
);
653 memcpy(&deduplicated_entries
[*nr_objects
],
654 &entries_by_fanout
[cur_object
],
655 sizeof(struct pack_midx_entry
));
660 free(entries_by_fanout
);
661 return deduplicated_entries
;
664 static int write_midx_pack_names(struct hashfile
*f
, void *data
)
666 struct write_midx_context
*ctx
= data
;
668 unsigned char padding
[MIDX_CHUNK_ALIGNMENT
];
671 for (i
= 0; i
< ctx
->nr
; i
++) {
674 if (ctx
->info
[i
].expired
)
677 if (i
&& strcmp(ctx
->info
[i
].pack_name
, ctx
->info
[i
- 1].pack_name
) <= 0)
678 BUG("incorrect pack-file order: %s before %s",
679 ctx
->info
[i
- 1].pack_name
,
680 ctx
->info
[i
].pack_name
);
682 writelen
= strlen(ctx
->info
[i
].pack_name
) + 1;
683 hashwrite(f
, ctx
->info
[i
].pack_name
, writelen
);
687 /* add padding to be aligned */
688 i
= MIDX_CHUNK_ALIGNMENT
- (written
% MIDX_CHUNK_ALIGNMENT
);
689 if (i
< MIDX_CHUNK_ALIGNMENT
) {
690 memset(padding
, 0, sizeof(padding
));
691 hashwrite(f
, padding
, i
);
697 static int write_midx_oid_fanout(struct hashfile
*f
,
700 struct write_midx_context
*ctx
= data
;
701 struct pack_midx_entry
*list
= ctx
->entries
;
702 struct pack_midx_entry
*last
= ctx
->entries
+ ctx
->entries_nr
;
707 * Write the first-level table (the list is sorted,
708 * but we use a 256-entry lookup to be able to avoid
709 * having to do eight extra binary search iterations).
711 for (i
= 0; i
< 256; i
++) {
712 struct pack_midx_entry
*next
= list
;
714 while (next
< last
&& next
->oid
.hash
[0] == i
) {
719 hashwrite_be32(f
, count
);
726 static int write_midx_oid_lookup(struct hashfile
*f
,
729 struct write_midx_context
*ctx
= data
;
730 unsigned char hash_len
= the_hash_algo
->rawsz
;
731 struct pack_midx_entry
*list
= ctx
->entries
;
734 for (i
= 0; i
< ctx
->entries_nr
; i
++) {
735 struct pack_midx_entry
*obj
= list
++;
737 if (i
< ctx
->entries_nr
- 1) {
738 struct pack_midx_entry
*next
= list
;
739 if (oidcmp(&obj
->oid
, &next
->oid
) >= 0)
740 BUG("OIDs not in order: %s >= %s",
741 oid_to_hex(&obj
->oid
),
742 oid_to_hex(&next
->oid
));
745 hashwrite(f
, obj
->oid
.hash
, (int)hash_len
);
751 static int write_midx_object_offsets(struct hashfile
*f
,
754 struct write_midx_context
*ctx
= data
;
755 struct pack_midx_entry
*list
= ctx
->entries
;
756 uint32_t i
, nr_large_offset
= 0;
758 for (i
= 0; i
< ctx
->entries_nr
; i
++) {
759 struct pack_midx_entry
*obj
= list
++;
761 if (ctx
->pack_perm
[obj
->pack_int_id
] == PACK_EXPIRED
)
762 BUG("object %s is in an expired pack with int-id %d",
763 oid_to_hex(&obj
->oid
),
766 hashwrite_be32(f
, ctx
->pack_perm
[obj
->pack_int_id
]);
768 if (ctx
->large_offsets_needed
&& obj
->offset
>> 31)
769 hashwrite_be32(f
, MIDX_LARGE_OFFSET_NEEDED
| nr_large_offset
++);
770 else if (!ctx
->large_offsets_needed
&& obj
->offset
>> 32)
771 BUG("object %s requires a large offset (%"PRIx64
") but the MIDX is not writing large offsets!",
772 oid_to_hex(&obj
->oid
),
775 hashwrite_be32(f
, (uint32_t)obj
->offset
);
781 static int write_midx_large_offsets(struct hashfile
*f
,
784 struct write_midx_context
*ctx
= data
;
785 struct pack_midx_entry
*list
= ctx
->entries
;
786 struct pack_midx_entry
*end
= ctx
->entries
+ ctx
->entries_nr
;
787 uint32_t nr_large_offset
= ctx
->num_large_offsets
;
789 while (nr_large_offset
) {
790 struct pack_midx_entry
*obj
;
794 BUG("too many large-offset objects");
797 offset
= obj
->offset
;
802 hashwrite_be64(f
, offset
);
810 struct midx_pack_order_data
{
816 static int midx_pack_order_cmp(const void *va
, const void *vb
)
818 const struct midx_pack_order_data
*a
= va
, *b
= vb
;
819 if (a
->pack
< b
->pack
)
821 else if (a
->pack
> b
->pack
)
823 else if (a
->offset
< b
->offset
)
825 else if (a
->offset
> b
->offset
)
831 static uint32_t *midx_pack_order(struct write_midx_context
*ctx
)
833 struct midx_pack_order_data
*data
;
834 uint32_t *pack_order
;
837 ALLOC_ARRAY(data
, ctx
->entries_nr
);
838 for (i
= 0; i
< ctx
->entries_nr
; i
++) {
839 struct pack_midx_entry
*e
= &ctx
->entries
[i
];
841 data
[i
].pack
= ctx
->pack_perm
[e
->pack_int_id
];
843 data
[i
].pack
|= (1U << 31);
844 data
[i
].offset
= e
->offset
;
847 QSORT(data
, ctx
->entries_nr
, midx_pack_order_cmp
);
849 ALLOC_ARRAY(pack_order
, ctx
->entries_nr
);
850 for (i
= 0; i
< ctx
->entries_nr
; i
++)
851 pack_order
[i
] = data
[i
].nr
;
857 static void write_midx_reverse_index(char *midx_name
, unsigned char *midx_hash
,
858 struct write_midx_context
*ctx
)
860 struct strbuf buf
= STRBUF_INIT
;
861 const char *tmp_file
;
863 strbuf_addf(&buf
, "%s-%s.rev", midx_name
, hash_to_hex(midx_hash
));
865 tmp_file
= write_rev_file_order(NULL
, ctx
->pack_order
, ctx
->entries_nr
,
866 midx_hash
, WRITE_REV
);
868 if (finalize_object_file(tmp_file
, buf
.buf
))
869 die(_("cannot store reverse index file"));
871 strbuf_release(&buf
);
874 static void clear_midx_files_ext(struct repository
*r
, const char *ext
,
875 unsigned char *keep_hash
);
877 static int midx_checksum_valid(struct multi_pack_index
*m
)
879 return hashfile_checksum_valid(m
->data
, m
->data_len
);
882 static int write_midx_internal(const char *object_dir
, struct multi_pack_index
*m
,
883 struct string_list
*packs_to_drop
,
884 const char *preferred_pack_name
,
888 unsigned char midx_hash
[GIT_MAX_RAWSZ
];
890 struct hashfile
*f
= NULL
;
892 struct write_midx_context ctx
= { 0 };
893 int pack_name_concat_len
= 0;
894 int dropped_packs
= 0;
896 struct chunkfile
*cf
;
898 midx_name
= get_midx_filename(object_dir
);
899 if (safe_create_leading_directories(midx_name
))
900 die_errno(_("unable to create leading directories of %s"),
906 ctx
.m
= load_multi_pack_index(object_dir
, 1);
908 if (ctx
.m
&& !midx_checksum_valid(ctx
.m
)) {
909 warning(_("ignoring existing multi-pack-index; checksum mismatch"));
914 ctx
.alloc
= ctx
.m
? ctx
.m
->num_packs
: 16;
916 ALLOC_ARRAY(ctx
.info
, ctx
.alloc
);
919 for (i
= 0; i
< ctx
.m
->num_packs
; i
++) {
920 ALLOC_GROW(ctx
.info
, ctx
.nr
+ 1, ctx
.alloc
);
922 ctx
.info
[ctx
.nr
].orig_pack_int_id
= i
;
923 ctx
.info
[ctx
.nr
].pack_name
= xstrdup(ctx
.m
->pack_names
[i
]);
924 ctx
.info
[ctx
.nr
].p
= NULL
;
925 ctx
.info
[ctx
.nr
].expired
= 0;
930 ctx
.pack_paths_checked
= 0;
931 if (flags
& MIDX_PROGRESS
)
932 ctx
.progress
= start_delayed_progress(_("Adding packfiles to multi-pack-index"), 0);
936 for_each_file_in_pack_dir(object_dir
, add_pack_to_midx
, &ctx
);
937 stop_progress(&ctx
.progress
);
939 if (ctx
.m
&& ctx
.nr
== ctx
.m
->num_packs
&& !packs_to_drop
)
942 ctx
.preferred_pack_idx
= -1;
943 if (preferred_pack_name
) {
944 for (i
= 0; i
< ctx
.nr
; i
++) {
945 if (!cmp_idx_or_pack_name(preferred_pack_name
,
946 ctx
.info
[i
].pack_name
)) {
947 ctx
.preferred_pack_idx
= i
;
953 ctx
.entries
= get_sorted_entries(ctx
.m
, ctx
.info
, ctx
.nr
, &ctx
.entries_nr
,
954 ctx
.preferred_pack_idx
);
956 ctx
.large_offsets_needed
= 0;
957 for (i
= 0; i
< ctx
.entries_nr
; i
++) {
958 if (ctx
.entries
[i
].offset
> 0x7fffffff)
959 ctx
.num_large_offsets
++;
960 if (ctx
.entries
[i
].offset
> 0xffffffff)
961 ctx
.large_offsets_needed
= 1;
964 QSORT(ctx
.info
, ctx
.nr
, pack_info_compare
);
966 if (packs_to_drop
&& packs_to_drop
->nr
) {
968 int missing_drops
= 0;
970 for (i
= 0; i
< ctx
.nr
&& drop_index
< packs_to_drop
->nr
; i
++) {
971 int cmp
= strcmp(ctx
.info
[i
].pack_name
,
972 packs_to_drop
->items
[drop_index
].string
);
976 ctx
.info
[i
].expired
= 1;
977 } else if (cmp
> 0) {
978 error(_("did not see pack-file %s to drop"),
979 packs_to_drop
->items
[drop_index
].string
);
984 ctx
.info
[i
].expired
= 0;
995 * pack_perm stores a permutation between pack-int-ids from the
996 * previous multi-pack-index to the new one we are writing:
998 * pack_perm[old_id] = new_id
1000 ALLOC_ARRAY(ctx
.pack_perm
, ctx
.nr
);
1001 for (i
= 0; i
< ctx
.nr
; i
++) {
1002 if (ctx
.info
[i
].expired
) {
1004 ctx
.pack_perm
[ctx
.info
[i
].orig_pack_int_id
] = PACK_EXPIRED
;
1006 ctx
.pack_perm
[ctx
.info
[i
].orig_pack_int_id
] = i
- dropped_packs
;
1010 for (i
= 0; i
< ctx
.nr
; i
++) {
1011 if (!ctx
.info
[i
].expired
)
1012 pack_name_concat_len
+= strlen(ctx
.info
[i
].pack_name
) + 1;
1015 /* Check that the preferred pack wasn't expired (if given). */
1016 if (preferred_pack_name
) {
1017 struct pack_info
*preferred
= bsearch(preferred_pack_name
,
1020 idx_or_pack_name_cmp
);
1023 warning(_("unknown preferred pack: '%s'"),
1024 preferred_pack_name
);
1026 uint32_t perm
= ctx
.pack_perm
[preferred
->orig_pack_int_id
];
1027 if (perm
== PACK_EXPIRED
)
1028 warning(_("preferred pack '%s' is expired"),
1029 preferred_pack_name
);
1033 if (pack_name_concat_len
% MIDX_CHUNK_ALIGNMENT
)
1034 pack_name_concat_len
+= MIDX_CHUNK_ALIGNMENT
-
1035 (pack_name_concat_len
% MIDX_CHUNK_ALIGNMENT
);
1037 hold_lock_file_for_update(&lk
, midx_name
, LOCK_DIE_ON_ERROR
);
1038 f
= hashfd(get_lock_file_fd(&lk
), get_lock_file_path(&lk
));
1043 if (ctx
.nr
- dropped_packs
== 0) {
1044 error(_("no pack files to index."));
1049 cf
= init_chunkfile(f
);
1051 add_chunk(cf
, MIDX_CHUNKID_PACKNAMES
, pack_name_concat_len
,
1052 write_midx_pack_names
);
1053 add_chunk(cf
, MIDX_CHUNKID_OIDFANOUT
, MIDX_CHUNK_FANOUT_SIZE
,
1054 write_midx_oid_fanout
);
1055 add_chunk(cf
, MIDX_CHUNKID_OIDLOOKUP
,
1056 (size_t)ctx
.entries_nr
* the_hash_algo
->rawsz
,
1057 write_midx_oid_lookup
);
1058 add_chunk(cf
, MIDX_CHUNKID_OBJECTOFFSETS
,
1059 (size_t)ctx
.entries_nr
* MIDX_CHUNK_OFFSET_WIDTH
,
1060 write_midx_object_offsets
);
1062 if (ctx
.large_offsets_needed
)
1063 add_chunk(cf
, MIDX_CHUNKID_LARGEOFFSETS
,
1064 (size_t)ctx
.num_large_offsets
* MIDX_CHUNK_LARGE_OFFSET_WIDTH
,
1065 write_midx_large_offsets
);
1067 write_midx_header(f
, get_num_chunks(cf
), ctx
.nr
- dropped_packs
);
1068 write_chunkfile(cf
, &ctx
);
1070 finalize_hashfile(f
, midx_hash
, CSUM_FSYNC
| CSUM_HASH_IN_STREAM
);
1073 if (flags
& MIDX_WRITE_REV_INDEX
)
1074 ctx
.pack_order
= midx_pack_order(&ctx
);
1076 if (flags
& MIDX_WRITE_REV_INDEX
)
1077 write_midx_reverse_index(midx_name
, midx_hash
, &ctx
);
1078 clear_midx_files_ext(the_repository
, ".rev", midx_hash
);
1080 commit_lock_file(&lk
);
1083 for (i
= 0; i
< ctx
.nr
; i
++) {
1084 if (ctx
.info
[i
].p
) {
1085 close_pack(ctx
.info
[i
].p
);
1086 free(ctx
.info
[i
].p
);
1088 free(ctx
.info
[i
].pack_name
);
1093 free(ctx
.pack_perm
);
1094 free(ctx
.pack_order
);
1099 int write_midx_file(const char *object_dir
,
1100 const char *preferred_pack_name
,
1103 return write_midx_internal(object_dir
, NULL
, NULL
, preferred_pack_name
,
1107 struct clear_midx_data
{
1112 static void clear_midx_file_ext(const char *full_path
, size_t full_path_len
,
1113 const char *file_name
, void *_data
)
1115 struct clear_midx_data
*data
= _data
;
1117 if (!(starts_with(file_name
, "multi-pack-index-") &&
1118 ends_with(file_name
, data
->ext
)))
1120 if (data
->keep
&& !strcmp(data
->keep
, file_name
))
1123 if (unlink(full_path
))
1124 die_errno(_("failed to remove %s"), full_path
);
1127 static void clear_midx_files_ext(struct repository
*r
, const char *ext
,
1128 unsigned char *keep_hash
)
1130 struct clear_midx_data data
;
1131 memset(&data
, 0, sizeof(struct clear_midx_data
));
1134 data
.keep
= xstrfmt("multi-pack-index-%s%s",
1135 hash_to_hex(keep_hash
), ext
);
1138 for_each_file_in_pack_dir(r
->objects
->odb
->path
,
1139 clear_midx_file_ext
,
1145 void clear_midx_file(struct repository
*r
)
1147 char *midx
= get_midx_filename(r
->objects
->odb
->path
);
1149 if (r
->objects
&& r
->objects
->multi_pack_index
) {
1150 close_midx(r
->objects
->multi_pack_index
);
1151 r
->objects
->multi_pack_index
= NULL
;
1154 if (remove_path(midx
))
1155 die(_("failed to clear multi-pack-index at %s"), midx
);
1157 clear_midx_files_ext(r
, ".rev", NULL
);
1162 static int verify_midx_error
;
1164 __attribute__((format (printf
, 1, 2)))
1165 static void midx_report(const char *fmt
, ...)
1168 verify_midx_error
= 1;
1170 vfprintf(stderr
, fmt
, ap
);
1171 fprintf(stderr
, "\n");
1175 struct pair_pos_vs_id
1178 uint32_t pack_int_id
;
1181 static int compare_pair_pos_vs_id(const void *_a
, const void *_b
)
1183 struct pair_pos_vs_id
*a
= (struct pair_pos_vs_id
*)_a
;
1184 struct pair_pos_vs_id
*b
= (struct pair_pos_vs_id
*)_b
;
1186 return b
->pack_int_id
- a
->pack_int_id
;
1190 * Limit calls to display_progress() for performance reasons.
1191 * The interval here was arbitrarily chosen.
1193 #define SPARSE_PROGRESS_INTERVAL (1 << 12)
1194 #define midx_display_sparse_progress(progress, n) \
1196 uint64_t _n = (n); \
1197 if ((_n & (SPARSE_PROGRESS_INTERVAL - 1)) == 0) \
1198 display_progress(progress, _n); \
1201 int verify_midx_file(struct repository
*r
, const char *object_dir
, unsigned flags
)
1203 struct pair_pos_vs_id
*pairs
= NULL
;
1205 struct progress
*progress
= NULL
;
1206 struct multi_pack_index
*m
= load_multi_pack_index(object_dir
, 1);
1207 verify_midx_error
= 0;
1212 char *filename
= get_midx_filename(object_dir
);
1213 if (!stat(filename
, &sb
)) {
1214 error(_("multi-pack-index file exists, but failed to parse"));
1221 if (!midx_checksum_valid(m
))
1222 midx_report(_("incorrect checksum"));
1224 if (flags
& MIDX_PROGRESS
)
1225 progress
= start_delayed_progress(_("Looking for referenced packfiles"),
1227 for (i
= 0; i
< m
->num_packs
; i
++) {
1228 if (prepare_midx_pack(r
, m
, i
))
1229 midx_report("failed to load pack in position %d", i
);
1231 display_progress(progress
, i
+ 1);
1233 stop_progress(&progress
);
1235 for (i
= 0; i
< 255; i
++) {
1236 uint32_t oid_fanout1
= ntohl(m
->chunk_oid_fanout
[i
]);
1237 uint32_t oid_fanout2
= ntohl(m
->chunk_oid_fanout
[i
+ 1]);
1239 if (oid_fanout1
> oid_fanout2
)
1240 midx_report(_("oid fanout out of order: fanout[%d] = %"PRIx32
" > %"PRIx32
" = fanout[%d]"),
1241 i
, oid_fanout1
, oid_fanout2
, i
+ 1);
1244 if (m
->num_objects
== 0) {
1245 midx_report(_("the midx contains no oid"));
1247 * Remaining tests assume that we have objects, so we can
1250 return verify_midx_error
;
1253 if (flags
& MIDX_PROGRESS
)
1254 progress
= start_sparse_progress(_("Verifying OID order in multi-pack-index"),
1255 m
->num_objects
- 1);
1256 for (i
= 0; i
< m
->num_objects
- 1; i
++) {
1257 struct object_id oid1
, oid2
;
1259 nth_midxed_object_oid(&oid1
, m
, i
);
1260 nth_midxed_object_oid(&oid2
, m
, i
+ 1);
1262 if (oidcmp(&oid1
, &oid2
) >= 0)
1263 midx_report(_("oid lookup out of order: oid[%d] = %s >= %s = oid[%d]"),
1264 i
, oid_to_hex(&oid1
), oid_to_hex(&oid2
), i
+ 1);
1266 midx_display_sparse_progress(progress
, i
+ 1);
1268 stop_progress(&progress
);
1271 * Create an array mapping each object to its packfile id. Sort it
1272 * to group the objects by packfile. Use this permutation to visit
1273 * each of the objects and only require 1 packfile to be open at a
1276 ALLOC_ARRAY(pairs
, m
->num_objects
);
1277 for (i
= 0; i
< m
->num_objects
; i
++) {
1279 pairs
[i
].pack_int_id
= nth_midxed_pack_int_id(m
, i
);
1282 if (flags
& MIDX_PROGRESS
)
1283 progress
= start_sparse_progress(_("Sorting objects by packfile"),
1285 display_progress(progress
, 0); /* TODO: Measure QSORT() progress */
1286 QSORT(pairs
, m
->num_objects
, compare_pair_pos_vs_id
);
1287 stop_progress(&progress
);
1289 if (flags
& MIDX_PROGRESS
)
1290 progress
= start_sparse_progress(_("Verifying object offsets"), m
->num_objects
);
1291 for (i
= 0; i
< m
->num_objects
; i
++) {
1292 struct object_id oid
;
1293 struct pack_entry e
;
1294 off_t m_offset
, p_offset
;
1296 if (i
> 0 && pairs
[i
-1].pack_int_id
!= pairs
[i
].pack_int_id
&&
1297 m
->packs
[pairs
[i
-1].pack_int_id
])
1299 close_pack_fd(m
->packs
[pairs
[i
-1].pack_int_id
]);
1300 close_pack_index(m
->packs
[pairs
[i
-1].pack_int_id
]);
1303 nth_midxed_object_oid(&oid
, m
, pairs
[i
].pos
);
1305 if (!fill_midx_entry(r
, &oid
, &e
, m
)) {
1306 midx_report(_("failed to load pack entry for oid[%d] = %s"),
1307 pairs
[i
].pos
, oid_to_hex(&oid
));
1311 if (open_pack_index(e
.p
)) {
1312 midx_report(_("failed to load pack-index for packfile %s"),
1317 m_offset
= e
.offset
;
1318 p_offset
= find_pack_entry_one(oid
.hash
, e
.p
);
1320 if (m_offset
!= p_offset
)
1321 midx_report(_("incorrect object offset for oid[%d] = %s: %"PRIx64
" != %"PRIx64
),
1322 pairs
[i
].pos
, oid_to_hex(&oid
), m_offset
, p_offset
);
1324 midx_display_sparse_progress(progress
, i
+ 1);
1326 stop_progress(&progress
);
1330 return verify_midx_error
;
1333 int expire_midx_packs(struct repository
*r
, const char *object_dir
, unsigned flags
)
1335 uint32_t i
, *count
, result
= 0;
1336 struct string_list packs_to_drop
= STRING_LIST_INIT_DUP
;
1337 struct multi_pack_index
*m
= load_multi_pack_index(object_dir
, 1);
1338 struct progress
*progress
= NULL
;
1343 CALLOC_ARRAY(count
, m
->num_packs
);
1345 if (flags
& MIDX_PROGRESS
)
1346 progress
= start_delayed_progress(_("Counting referenced objects"),
1348 for (i
= 0; i
< m
->num_objects
; i
++) {
1349 int pack_int_id
= nth_midxed_pack_int_id(m
, i
);
1350 count
[pack_int_id
]++;
1351 display_progress(progress
, i
+ 1);
1353 stop_progress(&progress
);
1355 if (flags
& MIDX_PROGRESS
)
1356 progress
= start_delayed_progress(_("Finding and deleting unreferenced packfiles"),
1358 for (i
= 0; i
< m
->num_packs
; i
++) {
1360 display_progress(progress
, i
+ 1);
1365 if (prepare_midx_pack(r
, m
, i
))
1368 if (m
->packs
[i
]->pack_keep
)
1371 pack_name
= xstrdup(m
->packs
[i
]->pack_name
);
1372 close_pack(m
->packs
[i
]);
1374 string_list_insert(&packs_to_drop
, m
->pack_names
[i
]);
1375 unlink_pack_path(pack_name
, 0);
1378 stop_progress(&progress
);
1382 if (packs_to_drop
.nr
)
1383 result
= write_midx_internal(object_dir
, m
, &packs_to_drop
, NULL
, flags
);
1385 string_list_clear(&packs_to_drop
, 0);
1389 struct repack_info
{
1391 uint32_t referenced_objects
;
1392 uint32_t pack_int_id
;
1395 static int compare_by_mtime(const void *a_
, const void *b_
)
1397 const struct repack_info
*a
, *b
;
1399 a
= (const struct repack_info
*)a_
;
1400 b
= (const struct repack_info
*)b_
;
1402 if (a
->mtime
< b
->mtime
)
1404 if (a
->mtime
> b
->mtime
)
1409 static int fill_included_packs_all(struct repository
*r
,
1410 struct multi_pack_index
*m
,
1411 unsigned char *include_pack
)
1413 uint32_t i
, count
= 0;
1414 int pack_kept_objects
= 0;
1416 repo_config_get_bool(r
, "repack.packkeptobjects", &pack_kept_objects
);
1418 for (i
= 0; i
< m
->num_packs
; i
++) {
1419 if (prepare_midx_pack(r
, m
, i
))
1421 if (!pack_kept_objects
&& m
->packs
[i
]->pack_keep
)
1424 include_pack
[i
] = 1;
1431 static int fill_included_packs_batch(struct repository
*r
,
1432 struct multi_pack_index
*m
,
1433 unsigned char *include_pack
,
1436 uint32_t i
, packs_to_repack
;
1438 struct repack_info
*pack_info
= xcalloc(m
->num_packs
, sizeof(struct repack_info
));
1439 int pack_kept_objects
= 0;
1441 repo_config_get_bool(r
, "repack.packkeptobjects", &pack_kept_objects
);
1443 for (i
= 0; i
< m
->num_packs
; i
++) {
1444 pack_info
[i
].pack_int_id
= i
;
1446 if (prepare_midx_pack(r
, m
, i
))
1449 pack_info
[i
].mtime
= m
->packs
[i
]->mtime
;
1452 for (i
= 0; batch_size
&& i
< m
->num_objects
; i
++) {
1453 uint32_t pack_int_id
= nth_midxed_pack_int_id(m
, i
);
1454 pack_info
[pack_int_id
].referenced_objects
++;
1457 QSORT(pack_info
, m
->num_packs
, compare_by_mtime
);
1460 packs_to_repack
= 0;
1461 for (i
= 0; total_size
< batch_size
&& i
< m
->num_packs
; i
++) {
1462 int pack_int_id
= pack_info
[i
].pack_int_id
;
1463 struct packed_git
*p
= m
->packs
[pack_int_id
];
1464 size_t expected_size
;
1468 if (!pack_kept_objects
&& p
->pack_keep
)
1470 if (open_pack_index(p
) || !p
->num_objects
)
1473 expected_size
= (size_t)(p
->pack_size
1474 * pack_info
[i
].referenced_objects
);
1475 expected_size
/= p
->num_objects
;
1477 if (expected_size
>= batch_size
)
1481 total_size
+= expected_size
;
1482 include_pack
[pack_int_id
] = 1;
1487 if (packs_to_repack
< 2)
1493 int midx_repack(struct repository
*r
, const char *object_dir
, size_t batch_size
, unsigned flags
)
1497 unsigned char *include_pack
;
1498 struct child_process cmd
= CHILD_PROCESS_INIT
;
1500 struct strbuf base_name
= STRBUF_INIT
;
1501 struct multi_pack_index
*m
= load_multi_pack_index(object_dir
, 1);
1504 * When updating the default for these configuration
1505 * variables in builtin/repack.c, these must be adjusted
1508 int delta_base_offset
= 1;
1509 int use_delta_islands
= 0;
1514 CALLOC_ARRAY(include_pack
, m
->num_packs
);
1517 if (fill_included_packs_batch(r
, m
, include_pack
, batch_size
))
1519 } else if (fill_included_packs_all(r
, m
, include_pack
))
1522 repo_config_get_bool(r
, "repack.usedeltabaseoffset", &delta_base_offset
);
1523 repo_config_get_bool(r
, "repack.usedeltaislands", &use_delta_islands
);
1525 strvec_push(&cmd
.args
, "pack-objects");
1527 strbuf_addstr(&base_name
, object_dir
);
1528 strbuf_addstr(&base_name
, "/pack/pack");
1529 strvec_push(&cmd
.args
, base_name
.buf
);
1531 if (delta_base_offset
)
1532 strvec_push(&cmd
.args
, "--delta-base-offset");
1533 if (use_delta_islands
)
1534 strvec_push(&cmd
.args
, "--delta-islands");
1536 if (flags
& MIDX_PROGRESS
)
1537 strvec_push(&cmd
.args
, "--progress");
1539 strvec_push(&cmd
.args
, "-q");
1541 strbuf_release(&base_name
);
1544 cmd
.in
= cmd
.out
= -1;
1546 if (start_command(&cmd
)) {
1547 error(_("could not start pack-objects"));
1552 cmd_in
= xfdopen(cmd
.in
, "w");
1554 for (i
= 0; i
< m
->num_objects
; i
++) {
1555 struct object_id oid
;
1556 uint32_t pack_int_id
= nth_midxed_pack_int_id(m
, i
);
1558 if (!include_pack
[pack_int_id
])
1561 nth_midxed_object_oid(&oid
, m
, i
);
1562 fprintf(cmd_in
, "%s\n", oid_to_hex(&oid
));
1566 if (finish_command(&cmd
)) {
1567 error(_("could not finish pack-objects"));
1572 result
= write_midx_internal(object_dir
, m
, NULL
, NULL
, flags
);