]> git.ipfire.org Git - thirdparty/git.git/commitdiff
packfile: refactor `get_multi_pack_index()` to work on sources
authorPatrick Steinhardt <ps@pks.im>
Tue, 15 Jul 2025 11:29:21 +0000 (13:29 +0200)
committerJunio C Hamano <gitster@pobox.com>
Tue, 15 Jul 2025 19:07:29 +0000 (12:07 -0700)
The function `get_multi_pack_index()` loads multi-pack indices via
`prepare_packed_git()` and then returns the linked list of multi-pack
indices that is stored in `struct object_database`. That list is in the
process of being removed though in favor of storing the MIDX as part of
the object database source it belongs to.

Refactor `get_multi_pack_index()` so that it returns the multi-pack
index for a single object source. Callers are now expected to call this
function for each source they are interested in. This requires them to
iterate through alternates, so we have to prepare alternate object
sources before doing so.

Signed-off-by: Patrick Steinhardt <ps@pks.im>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
builtin/pack-objects.c
builtin/repack.c
midx-write.c
object-name.c
pack-bitmap.c
packfile.c
packfile.h

index 067b9e322a9db490f4e4946c000f46a67e87671d..3dd84495b869e0c676f110d9e915e1d282cacf0a 100644 (file)
@@ -1706,8 +1706,8 @@ static int want_object_in_pack_mtime(const struct object_id *oid,
                                     uint32_t found_mtime)
 {
        int want;
+       struct odb_source *source;
        struct list_head *pos;
-       struct multi_pack_index *m;
 
        if (!exclude && local && has_loose_object_nonlocal(oid))
                return 0;
@@ -1727,9 +1727,13 @@ static int want_object_in_pack_mtime(const struct object_id *oid,
                *found_offset = 0;
        }
 
-       for (m = get_multi_pack_index(the_repository); m; m = m->next) {
+       odb_prepare_alternates(the_repository->objects);
+
+       for (source = the_repository->objects->sources; source; source = source->next) {
+               struct multi_pack_index *m = get_multi_pack_index(source);
                struct pack_entry e;
-               if (fill_midx_entry(the_repository, oid, &e, m)) {
+
+               if (m && fill_midx_entry(the_repository, oid, &e, m)) {
                        want = want_object_in_pack_one(e.p, oid, exclude, found_pack, found_offset, found_mtime);
                        if (want != -1)
                                return want;
index 5e89d96df1373d5b0cdccb2f925b3d6af5ff2f81..d63e1a9fec2fd61549195c2a57148a2baad5568f 100644 (file)
@@ -223,9 +223,9 @@ static void mark_packs_for_deletion(struct existing_packs *existing,
 static void remove_redundant_pack(const char *dir_name, const char *base_name)
 {
        struct strbuf buf = STRBUF_INIT;
-       struct multi_pack_index *m = get_local_multi_pack_index(the_repository);
+       struct multi_pack_index *m = get_multi_pack_index(the_repository->objects->sources);
        strbuf_addf(&buf, "%s.pack", base_name);
-       if (m && midx_contains_pack(m, buf.buf))
+       if (m && m->local && midx_contains_pack(m, buf.buf))
                clear_midx_file(the_repository);
        strbuf_insertf(&buf, 0, "%s/", dir_name);
        unlink_pack_path(buf.buf, 1);
@@ -1531,7 +1531,7 @@ int cmd_repack(int argc,
                 * midx_has_unknown_packs() will make the decision for
                 * us.
                 */
-               if (!get_local_multi_pack_index(the_repository))
+               if (!get_multi_pack_index(the_repository->objects->sources))
                        midx_must_contain_cruft = 1;
        }
 
@@ -1614,9 +1614,9 @@ int cmd_repack(int argc,
 
        string_list_sort(&names);
 
-       if (get_local_multi_pack_index(the_repository)) {
+       if (get_multi_pack_index(the_repository->objects->sources)) {
                struct multi_pack_index *m =
-                       get_local_multi_pack_index(the_repository);
+                       get_multi_pack_index(the_repository->objects->sources);
 
                ALLOC_ARRAY(midx_pack_names,
                            m->num_packs + m->num_packs_in_base);
index f2cfb85476ed78b340693c86ab4099ab3fa8186c..c1ae62d3549425585077447da73803bf50e6e5a6 100644 (file)
@@ -916,26 +916,8 @@ cleanup:
 static struct multi_pack_index *lookup_multi_pack_index(struct repository *r,
                                                        const char *object_dir)
 {
-       struct multi_pack_index *result = NULL;
-       struct multi_pack_index *cur;
-       char *obj_dir_real = real_pathdup(object_dir, 1);
-       struct strbuf cur_path_real = STRBUF_INIT;
-
-       /* Ensure the given object_dir is local, or a known alternate. */
-       odb_find_source(r->objects, obj_dir_real);
-
-       for (cur = get_multi_pack_index(r); cur; cur = cur->next) {
-               strbuf_realpath(&cur_path_real, cur->object_dir, 1);
-               if (!strcmp(obj_dir_real, cur_path_real.buf)) {
-                       result = cur;
-                       goto cleanup;
-               }
-       }
-
-cleanup:
-       free(obj_dir_real);
-       strbuf_release(&cur_path_real);
-       return result;
+       struct odb_source *source = odb_find_source(r->objects, object_dir);
+       return get_multi_pack_index(source);
 }
 
 static int fill_packs_from_midx(struct write_midx_context *ctx,
index ddafe7f9b13a9642e30eece89578b37ac15b5872..27138b55b47556e0a62f110281dc3fecd91098f6 100644 (file)
@@ -198,16 +198,20 @@ static void unique_in_pack(struct packed_git *p,
 
 static void find_short_packed_object(struct disambiguate_state *ds)
 {
-       struct multi_pack_index *m;
+       struct odb_source *source;
        struct packed_git *p;
 
        /* Skip, unless oids from the storage hash algorithm are wanted */
        if (ds->bin_pfx.algo && (&hash_algos[ds->bin_pfx.algo] != ds->repo->hash_algo))
                return;
 
-       for (m = get_multi_pack_index(ds->repo); m && !ds->ambiguous;
-            m = m->next)
-               unique_in_midx(m, ds);
+       odb_prepare_alternates(ds->repo->objects);
+       for (source = ds->repo->objects->sources; source && !ds->ambiguous; source = source->next) {
+               struct multi_pack_index *m = get_multi_pack_index(source);
+               if (m)
+                       unique_in_midx(m, ds);
+       }
+
        for (p = get_packed_git(ds->repo); p && !ds->ambiguous;
             p = p->next)
                unique_in_pack(p, ds);
@@ -792,11 +796,15 @@ static void find_abbrev_len_for_pack(struct packed_git *p,
 
 static void find_abbrev_len_packed(struct min_abbrev_data *mad)
 {
-       struct multi_pack_index *m;
        struct packed_git *p;
 
-       for (m = get_multi_pack_index(mad->repo); m; m = m->next)
-               find_abbrev_len_for_midx(m, mad);
+       odb_prepare_alternates(mad->repo->objects);
+       for (struct odb_source *source = mad->repo->objects->sources; source; source = source->next) {
+               struct multi_pack_index *m = get_multi_pack_index(source);
+               if (m)
+                       find_abbrev_len_for_midx(m, mad);
+       }
+
        for (p = get_packed_git(mad->repo); p; p = p->next)
                find_abbrev_len_for_pack(p, mad);
 }
index 0a4af199c05776b613848bc02ffc8bd32e3a4fc0..64278e2acf760493bc13bdf33e36205a51a7db2a 100644 (file)
@@ -691,13 +691,15 @@ static int open_pack_bitmap(struct repository *r,
 static int open_midx_bitmap(struct repository *r,
                            struct bitmap_index *bitmap_git)
 {
+       struct odb_source *source;
        int ret = -1;
-       struct multi_pack_index *midx;
 
        assert(!bitmap_git->map);
 
-       for (midx = get_multi_pack_index(r); midx; midx = midx->next) {
-               if (!open_midx_bitmap_1(bitmap_git, midx))
+       odb_prepare_alternates(r->objects);
+       for (source = r->objects->sources; source; source = source->next) {
+               struct multi_pack_index *midx = get_multi_pack_index(source);
+               if (midx && !open_midx_bitmap_1(bitmap_git, midx))
                        ret = 0;
        }
        return ret;
@@ -3305,11 +3307,18 @@ static int verify_bitmap_file(const struct git_hash_algo *algop,
 
 int verify_bitmap_files(struct repository *r)
 {
+       struct odb_source *source;
        int res = 0;
 
-       for (struct multi_pack_index *m = get_multi_pack_index(r);
-            m; m = m->next) {
-               char *midx_bitmap_name = midx_bitmap_filename(m);
+       odb_prepare_alternates(r->objects);
+       for (source = r->objects->sources; source; source = source->next) {
+               struct multi_pack_index *m = get_multi_pack_index(source);
+               char *midx_bitmap_name;
+
+               if (!m)
+                       continue;
+
+               midx_bitmap_name = midx_bitmap_filename(m);
                res |= verify_bitmap_file(r->hash_algo, midx_bitmap_name);
                free(midx_bitmap_name);
        }
index 7b350f018ca78c3c1d22766d43940b3c59b35681..d0f38a020354abbf210252cfa93cd6305afd031e 100644 (file)
@@ -963,14 +963,18 @@ static void prepare_packed_git(struct repository *r);
 unsigned long repo_approximate_object_count(struct repository *r)
 {
        if (!r->objects->approximate_object_count_valid) {
-               unsigned long count;
-               struct multi_pack_index *m;
+               struct odb_source *source;
+               unsigned long count = 0;
                struct packed_git *p;
 
                prepare_packed_git(r);
-               count = 0;
-               for (m = get_multi_pack_index(r); m; m = m->next)
-                       count += m->num_objects;
+
+               for (source = r->objects->sources; source; source = source->next) {
+                       struct multi_pack_index *m = get_multi_pack_index(source);
+                       if (m)
+                               count += m->num_objects;
+               }
+
                for (p = r->objects->packed_git; p; p = p->next) {
                        if (open_pack_index(p))
                                continue;
@@ -1074,21 +1078,10 @@ struct packed_git *get_packed_git(struct repository *r)
        return r->objects->packed_git;
 }
 
-struct multi_pack_index *get_multi_pack_index(struct repository *r)
-{
-       prepare_packed_git(r);
-       return r->objects->multi_pack_index;
-}
-
-struct multi_pack_index *get_local_multi_pack_index(struct repository *r)
+struct multi_pack_index *get_multi_pack_index(struct odb_source *source)
 {
-       struct multi_pack_index *m = get_multi_pack_index(r);
-
-       /* no need to iterate; we always put the local one first (if any) */
-       if (m && m->local)
-               return m;
-
-       return NULL;
+       prepare_packed_git(source->odb->repo);
+       return source->midx;
 }
 
 struct packed_git *get_all_packs(struct repository *r)
index 53c3b7d3b43cba18663ef74c70f15aba79b7f805..f16753f2a9bb4c18e832041a9145a3a5c79f492c 100644 (file)
@@ -147,8 +147,7 @@ void install_packed_git(struct repository *r, struct packed_git *pack);
 
 struct packed_git *get_packed_git(struct repository *r);
 struct list_head *get_packed_git_mru(struct repository *r);
-struct multi_pack_index *get_multi_pack_index(struct repository *r);
-struct multi_pack_index *get_local_multi_pack_index(struct repository *r);
+struct multi_pack_index *get_multi_pack_index(struct odb_source *source);
 struct packed_git *get_all_packs(struct repository *r);
 
 /*