pack-bitmap.c: check preferred pack validity when opening MIDX bitmap

When pack-objects adds an entry to its packing list, it marks the
packfile and offset containing the object, which we may later use during
verbatim reuse (c.f., `write_reused_pack_verbatim()`).

If the packfile in question is deleted in the background (e.g., due to a
concurrent `git repack`), we'll die() as a result of calling use_pack(),
unless we have an open file descriptor on the pack itself. 4c08018204
(pack-objects: protect against disappearing packs, 2011-10-14) worked
around this by opening the pack ahead of time before recording it as a
valid source for reuse.

4c08018204's treatment meant that we could tolerate disappearing packs,
since it ensures we always have an open file descriptor on any pack that
we mark as a valid source for reuse. This tightens the race to only
happen when we need to close an open pack's file descriptor (c.f., the
caller of `packfile.c::get_max_fd_limit()`) _and_ that pack was deleted,
in which case we'll complain that a pack could not be accessed and
die().

The pack bitmap code does this, too, since prior to dc1daacdcc
(pack-bitmap: check pack validity when opening bitmap, 2021-07-23) it
was vulnerable to the same race.

The MIDX bitmap code does not do this, and is vulnerable to the same
race. Apply the same treatment as dc1daacdcc to the routine responsible
for opening the multi-pack bitmap's preferred pack to close this race.

This patch handles the "preferred" pack (c.f., the section
"multi-pack-index reverse indexes" in
Documentation/technical/pack-format.txt) specially, since pack-objects
depends on reusing exact chunks of that pack verbatim in
reuse_partial_packfile_from_bitmap(). So if that pack cannot be loaded,
the utility of a bitmap is significantly diminished.

Similar to dc1daacdcc, we could technically just add this check in
reuse_partial_packfile_from_bitmap(), since it's possible to use a MIDX
.bitmap without needing to open any of its packs. But it's simpler to do
the check as early as possible, covering all direct uses of the
preferred pack. Note that doing this check early requires us to call
prepare_midx_pack() early, too, so move the relevant part of that loop
from load_reverse_index() into open_midx_bitmap_1().

Subsequent patches handle the non-preferred packs in a slightly
different fashion.

Signed-off-by: Taylor Blau <me@ttaylorr.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/pack-bitmap.c b/pack-bitmap.c
index f772d3cb7f7c181a9b703a9535f9ec55dfd60513..f18a01ed4246144124dbdd40e7fae7ae2dec4472 100644 (file)
--- a/pack-bitmap.c
+++ b/pack-bitmap.c
@@ -315,6 +315,8 @@ static int open_midx_bitmap_1(struct bitmap_index *bitmap_git,
        struct stat st;
        char *idx_name = midx_bitmap_filename(midx);
        int fd = git_open(idx_name);
+       uint32_t i;
+       struct packed_git *preferred;
 
        free(idx_name);
 
@@ -353,6 +355,20 @@ static int open_midx_bitmap_1(struct bitmap_index *bitmap_git,
                warning(_("multi-pack bitmap is missing required reverse index"));
                goto cleanup;
        }
+
+       for (i = 0; i < bitmap_git->midx->num_packs; i++) {
+               if (prepare_midx_pack(the_repository, bitmap_git->midx, i))
+                       die(_("could not open pack %s"),
+                           bitmap_git->midx->pack_names[i]);
+       }
+
+       preferred = bitmap_git->midx->packs[midx_preferred_pack(bitmap_git)];
+       if (!is_pack_valid(preferred)) {
+               warning(_("preferred pack (%s) is invalid"),
+                       preferred->pack_name);
+               goto cleanup;
+       }
+
        return 0;
 
 cleanup:
@@ -425,8 +441,6 @@ static int load_reverse_index(struct bitmap_index *bitmap_git)
                 * since we will need to make use of them in pack-objects.
                 */
                for (i = 0; i < bitmap_git->midx->num_packs; i++) {
-                       if (prepare_midx_pack(the_repository, bitmap_git->midx, i))
-                               die(_("load_reverse_index: could not open pack"));
                        ret = load_pack_revindex(bitmap_git->midx->packs[i]);
                        if (ret)
                                return ret;