midx: compute paths via their source

With the preceding commits we started to always have the object database
source available when we load, write or access multi-pack indices. With
this in place we can change how MIDX paths are computed so that we don't
have to pass in the combination of a hash algorithm and object directory
anymore, but only the object database source.

Refactor the code accordingly.

Signed-off-by: Patrick Steinhardt <ps@pks.im>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/midx-write.c b/midx-write.c
index 84f76856d67ee9de23ee1ee6bc21f823722c9fa3..1dcdf3dc0f151b32b05a89c6664c1524aa775450 100644 (file)
--- a/midx-write.c
+++ b/midx-write.c
@@ -26,9 +26,9 @@
 #define MIDX_CHUNK_LARGE_OFFSET_WIDTH (sizeof(uint64_t))
 
 extern int midx_checksum_valid(struct multi_pack_index *m);
-extern void clear_midx_files_ext(const char *object_dir, const char *ext,
+extern void clear_midx_files_ext(struct odb_source *source, const char *ext,
                                 const char *keep_hash);
-extern void clear_incremental_midx_files_ext(const char *object_dir,
+extern void clear_incremental_midx_files_ext(struct odb_source *source,
                                             const char *ext,
                                             const char **keep_hashes,
                                             uint32_t hashes_nr);
@@ -112,6 +112,7 @@ struct write_midx_context {
        struct string_list *to_include;
 
        struct repository *repo;
+       struct odb_source *source;
 };
 
 static int should_include_pack(const struct write_midx_context *ctx,
@@ -648,7 +649,6 @@ static uint32_t *midx_pack_order(struct write_midx_context *ctx)
 }
 
 static void write_midx_reverse_index(struct write_midx_context *ctx,
-                                    const char *object_dir,
                                     unsigned char *midx_hash)
 {
        struct strbuf buf = STRBUF_INIT;
@@ -657,11 +657,10 @@ static void write_midx_reverse_index(struct write_midx_context *ctx,
        trace2_region_enter("midx", "write_midx_reverse_index", ctx->repo);
 
        if (ctx->incremental)
-               get_split_midx_filename_ext(ctx->repo->hash_algo, &buf,
-                                           object_dir, midx_hash,
-                                           MIDX_EXT_REV);
+               get_split_midx_filename_ext(ctx->source, &buf,
+                                           midx_hash, MIDX_EXT_REV);
        else
-               get_midx_filename_ext(ctx->repo->hash_algo, &buf, object_dir,
+               get_midx_filename_ext(ctx->source, &buf,
                                      midx_hash, MIDX_EXT_REV);
 
        tmp_file = write_rev_file_order(ctx->repo, NULL, ctx->pack_order,
@@ -836,7 +835,6 @@ static struct commit **find_commits_for_midx_bitmap(uint32_t *indexed_commits_nr
 }
 
 static int write_midx_bitmap(struct write_midx_context *ctx,
-                            const char *object_dir,
                             const unsigned char *midx_hash,
                             struct packing_data *pdata,
                             struct commit **commits,
@@ -852,12 +850,11 @@ static int write_midx_bitmap(struct write_midx_context *ctx,
        trace2_region_enter("midx", "write_midx_bitmap", ctx->repo);
 
        if (ctx->incremental)
-               get_split_midx_filename_ext(ctx->repo->hash_algo, &bitmap_name,
-                                           object_dir, midx_hash,
-                                           MIDX_EXT_BITMAP);
+               get_split_midx_filename_ext(ctx->source, &bitmap_name,
+                                           midx_hash, MIDX_EXT_BITMAP);
        else
-               get_midx_filename_ext(ctx->repo->hash_algo, &bitmap_name,
-                                     object_dir, midx_hash, MIDX_EXT_BITMAP);
+               get_midx_filename_ext(ctx->source, &bitmap_name,
+                                     midx_hash, MIDX_EXT_BITMAP);
 
        if (flags & MIDX_WRITE_BITMAP_HASH_CACHE)
                options |= BITMAP_OPT_HASH_CACHE;
@@ -981,11 +978,9 @@ static int link_midx_to_chain(struct multi_pack_index *m)
        for (i = 0; i < ARRAY_SIZE(midx_exts); i++) {
                const unsigned char *hash = get_midx_checksum(m);
 
-               get_midx_filename_ext(m->source->odb->repo->hash_algo, &from,
-                                     m->source->path,
+               get_midx_filename_ext(m->source, &from,
                                      hash, midx_exts[i].non_split);
-               get_split_midx_filename_ext(m->source->odb->repo->hash_algo, &to,
-                                           m->source->path, hash,
+               get_split_midx_filename_ext(m->source, &to, hash,
                                            midx_exts[i].split);
 
                if (link(from.buf, to.buf) < 0 && errno != ENOENT) {
@@ -1023,16 +1018,16 @@ static void clear_midx_files(struct odb_source *source,
        uint32_t i, j;
 
        for (i = 0; i < ARRAY_SIZE(exts); i++) {
-               clear_incremental_midx_files_ext(source->path, exts[i],
+               clear_incremental_midx_files_ext(source, exts[i],
                                                 hashes, hashes_nr);
                for (j = 0; j < hashes_nr; j++)
-                       clear_midx_files_ext(source->path, exts[i], hashes[j]);
+                       clear_midx_files_ext(source, exts[i], hashes[j]);
        }
 
        if (incremental)
-               get_midx_filename(source->odb->repo->hash_algo, &buf, source->path);
+               get_midx_filename(source, &buf);
        else
-               get_midx_chain_filename(&buf, source->path);
+               get_midx_chain_filename(source, &buf);
 
        if (unlink(buf.buf) && errno != ENOENT)
                die_errno(_("failed to clear multi-pack-index at %s"), buf.buf);
@@ -1065,6 +1060,7 @@ static int write_midx_internal(struct odb_source *source,
        trace2_region_enter("midx", "write_midx_internal", r);
 
        ctx.repo = r;
+       ctx.source = source;
 
        ctx.incremental = !!(flags & MIDX_WRITE_INCREMENTAL);
 
@@ -1073,7 +1069,7 @@ static int write_midx_internal(struct odb_source *source,
                            "%s/pack/multi-pack-index.d/tmp_midx_XXXXXX",
                            source->path);
        else
-               get_midx_filename(r->hash_algo, &midx_name, source->path);
+               get_midx_filename(source, &midx_name);
        if (safe_create_leading_directories(r, midx_name.buf))
                die_errno(_("unable to create leading directories of %s"),
                          midx_name.buf);
@@ -1153,7 +1149,7 @@ static int write_midx_internal(struct odb_source *source,
                         * corresponding bitmap (or one wasn't requested).
                         */
                        if (!want_bitmap)
-                               clear_midx_files_ext(source->path, "bitmap", NULL);
+                               clear_midx_files_ext(source, "bitmap", NULL);
                        goto cleanup;
                }
        }
@@ -1321,7 +1317,7 @@ static int write_midx_internal(struct odb_source *source,
        if (ctx.incremental) {
                struct strbuf lock_name = STRBUF_INIT;
 
-               get_midx_chain_filename(&lock_name, source->path);
+               get_midx_chain_filename(source, &lock_name);
                hold_lock_file_for_update(&lk, lock_name.buf, LOCK_DIE_ON_ERROR);
                strbuf_release(&lock_name);
 
@@ -1384,7 +1380,7 @@ static int write_midx_internal(struct odb_source *source,
 
        if (flags & MIDX_WRITE_REV_INDEX &&
            git_env_bool("GIT_TEST_MIDX_WRITE_REV", 0))
-               write_midx_reverse_index(&ctx, source->path, midx_hash);
+               write_midx_reverse_index(&ctx, midx_hash);
 
        if (flags & MIDX_WRITE_BITMAP) {
                struct packing_data pdata;
@@ -1407,7 +1403,7 @@ static int write_midx_internal(struct odb_source *source,
                FREE_AND_NULL(ctx.entries);
                ctx.entries_nr = 0;
 
-               if (write_midx_bitmap(&ctx, source->path,
+               if (write_midx_bitmap(&ctx,
                                      midx_hash, &pdata, commits, commits_nr,
                                      flags) < 0) {
                        error(_("could not write multi-pack bitmap"));
@@ -1440,8 +1436,8 @@ static int write_midx_internal(struct odb_source *source,
                if (link_midx_to_chain(ctx.base_midx) < 0)
                        return -1;
 
-               get_split_midx_filename_ext(r->hash_algo, &final_midx_name,
-                                           source->path, midx_hash, MIDX_EXT_MIDX);
+               get_split_midx_filename_ext(source, &final_midx_name,
+                                           midx_hash, MIDX_EXT_MIDX);
 
                if (rename_tempfile(&incr, final_midx_name.buf) < 0) {
                        error_errno(_("unable to rename new multi-pack-index layer"));

diff --git a/midx.c b/midx.c
index 81bf3c4d5f351e5689cf7462761dea59652106ce..7726c13d7e7bc04b9805589b37dd4b3dfa942910 100644 (file)
--- a/midx.c
+++ b/midx.c
@@ -16,9 +16,9 @@
 #define MIDX_PACK_ERROR ((void *)(intptr_t)-1)
 
 int midx_checksum_valid(struct multi_pack_index *m);
-void clear_midx_files_ext(const char *object_dir, const char *ext,
+void clear_midx_files_ext(struct odb_source *source, const char *ext,
                          const char *keep_hash);
-void clear_incremental_midx_files_ext(const char *object_dir, const char *ext,
+void clear_incremental_midx_files_ext(struct odb_source *source, const char *ext,
                                      char **keep_hashes,
                                      uint32_t hashes_nr);
 int cmp_idx_or_pack_name(const char *idx_or_pack_name,
@@ -29,19 +29,17 @@ const unsigned char *get_midx_checksum(struct multi_pack_index *m)
        return m->data + m->data_len - m->source->odb->repo->hash_algo->rawsz;
 }
 
-void get_midx_filename(const struct git_hash_algo *hash_algo,
-                      struct strbuf *out, const char *object_dir)
+void get_midx_filename(struct odb_source *source, struct strbuf *out)
 {
-       get_midx_filename_ext(hash_algo, out, object_dir, NULL, NULL);
+       get_midx_filename_ext(source, out, NULL, NULL);
 }
 
-void get_midx_filename_ext(const struct git_hash_algo *hash_algo,
-                          struct strbuf *out, const char *object_dir,
+void get_midx_filename_ext(struct odb_source *source, struct strbuf *out,
                           const unsigned char *hash, const char *ext)
 {
-       strbuf_addf(out, "%s/pack/multi-pack-index", object_dir);
+       strbuf_addf(out, "%s/pack/multi-pack-index", source->path);
        if (ext)
-               strbuf_addf(out, "-%s.%s", hash_to_hex_algop(hash, hash_algo), ext);
+               strbuf_addf(out, "-%s.%s", hash_to_hex_algop(hash, source->odb->repo->hash_algo), ext);
 }
 
 static int midx_read_oid_fanout(const unsigned char *chunk_start,
@@ -222,24 +220,23 @@ cleanup_fail:
        return NULL;
 }
 
-void get_midx_chain_dirname(struct strbuf *buf, const char *object_dir)
+void get_midx_chain_dirname(struct odb_source *source, struct strbuf *buf)
 {
-       strbuf_addf(buf, "%s/pack/multi-pack-index.d", object_dir);
+       strbuf_addf(buf, "%s/pack/multi-pack-index.d", source->path);
 }
 
-void get_midx_chain_filename(struct strbuf *buf, const char *object_dir)
+void get_midx_chain_filename(struct odb_source *source, struct strbuf *buf)
 {
-       get_midx_chain_dirname(buf, object_dir);
+       get_midx_chain_dirname(source, buf);
        strbuf_addstr(buf, "/multi-pack-index-chain");
 }
 
-void get_split_midx_filename_ext(const struct git_hash_algo *hash_algo,
-                                struct strbuf *buf, const char *object_dir,
+void get_split_midx_filename_ext(struct odb_source *source, struct strbuf *buf,
                                 const unsigned char *hash, const char *ext)
 {
-       get_midx_chain_dirname(buf, object_dir);
+       get_midx_chain_dirname(source, buf);
        strbuf_addf(buf, "/multi-pack-index-%s.%s",
-                   hash_to_hex_algop(hash, hash_algo), ext);
+                   hash_to_hex_algop(hash, source->odb->repo->hash_algo), ext);
 }
 
 static int open_multi_pack_index_chain(const struct git_hash_algo *hash_algo,
@@ -326,7 +323,7 @@ static struct multi_pack_index *load_midx_chain_fd_st(struct odb_source *source,
                valid = 0;
 
                strbuf_reset(&buf);
-               get_split_midx_filename_ext(hash_algo, &buf, source->path,
+               get_split_midx_filename_ext(source, &buf,
                                            layer.hash, MIDX_EXT_MIDX);
                m = load_multi_pack_index_one(source, buf.buf);
 
@@ -358,7 +355,7 @@ static struct multi_pack_index *load_multi_pack_index_chain(struct odb_source *s
        int fd;
        struct multi_pack_index *m = NULL;
 
-       get_midx_chain_filename(&chain_file, source->path);
+       get_midx_chain_filename(source, &chain_file);
        if (open_multi_pack_index_chain(source->odb->repo->hash_algo, chain_file.buf, &fd, &st)) {
                int incomplete;
                /* ownership of fd is taken over by load function */
@@ -374,8 +371,7 @@ struct multi_pack_index *load_multi_pack_index(struct odb_source *source)
        struct strbuf midx_name = STRBUF_INIT;
        struct multi_pack_index *m;
 
-       get_midx_filename(source->odb->repo->hash_algo, &midx_name,
-                         source->path);
+       get_midx_filename(source, &midx_name);
 
        m = load_multi_pack_index_one(source, midx_name.buf);
        if (!m)
@@ -762,7 +758,7 @@ static void clear_midx_file_ext(const char *full_path, size_t full_path_len UNUS
                die_errno(_("failed to remove %s"), full_path);
 }
 
-void clear_midx_files_ext(const char *object_dir, const char *ext,
+void clear_midx_files_ext(struct odb_source *source, const char *ext,
                          const char *keep_hash)
 {
        struct clear_midx_data data;
@@ -776,7 +772,7 @@ void clear_midx_files_ext(const char *object_dir, const char *ext,
        }
        data.ext = ext;
 
-       for_each_file_in_pack_dir(object_dir,
+       for_each_file_in_pack_dir(source->path,
                                  clear_midx_file_ext,
                                  &data);
 
@@ -785,7 +781,7 @@ void clear_midx_files_ext(const char *object_dir, const char *ext,
        free(data.keep);
 }
 
-void clear_incremental_midx_files_ext(const char *object_dir, const char *ext,
+void clear_incremental_midx_files_ext(struct odb_source *source, const char *ext,
                                      char **keep_hashes,
                                      uint32_t hashes_nr)
 {
@@ -801,7 +797,7 @@ void clear_incremental_midx_files_ext(const char *object_dir, const char *ext,
        data.keep_nr = hashes_nr;
        data.ext = ext;
 
-       for_each_file_in_pack_subdir(object_dir, "multi-pack-index.d",
+       for_each_file_in_pack_subdir(source->path, "multi-pack-index.d",
                                     clear_midx_file_ext, &data);
 
        for (i = 0; i < hashes_nr; i++)
@@ -813,7 +809,7 @@ void clear_midx_file(struct repository *r)
 {
        struct strbuf midx = STRBUF_INIT;
 
-       get_midx_filename(r->hash_algo, &midx, r->objects->sources->path);
+       get_midx_filename(r->objects->sources, &midx);
 
        if (r->objects) {
                struct odb_source *source;
@@ -828,8 +824,8 @@ void clear_midx_file(struct repository *r)
        if (remove_path(midx.buf))
                die(_("failed to clear multi-pack-index at %s"), midx.buf);
 
-       clear_midx_files_ext(r->objects->sources->path, MIDX_EXT_BITMAP, NULL);
-       clear_midx_files_ext(r->objects->sources->path, MIDX_EXT_REV, NULL);
+       clear_midx_files_ext(r->objects->sources, MIDX_EXT_BITMAP, NULL);
+       clear_midx_files_ext(r->objects->sources, MIDX_EXT_REV, NULL);
 
        strbuf_release(&midx);
 }
@@ -888,7 +884,7 @@ int verify_midx_file(struct odb_source *source, unsigned flags)
                struct stat sb;
                struct strbuf filename = STRBUF_INIT;
 
-               get_midx_filename(r->hash_algo, &filename, source->path);
+               get_midx_filename(source, &filename);
 
                if (!stat(filename.buf, &sb)) {
                        error(_("multi-pack-index file exists, but failed to parse"));

diff --git a/midx.h b/midx.h
index 71dbdec66ef6188391fa86c5db74f375959434d7..e241d2d6900bc3a2946e973a3d37df74aa3cbc4f 100644 (file)
--- a/midx.h
+++ b/midx.h
@@ -86,15 +86,12 @@ struct multi_pack_index {
 #define MIDX_EXT_MIDX "midx"
 
 const unsigned char *get_midx_checksum(struct multi_pack_index *m);
-void get_midx_filename(const struct git_hash_algo *hash_algo,
-                      struct strbuf *out, const char *object_dir);
-void get_midx_filename_ext(const struct git_hash_algo *hash_algo,
-                          struct strbuf *out, const char *object_dir,
+void get_midx_filename(struct odb_source *source, struct strbuf *out);
+void get_midx_filename_ext(struct odb_source *source, struct strbuf *out,
                           const unsigned char *hash, const char *ext);
-void get_midx_chain_dirname(struct strbuf *buf, const char *object_dir);
-void get_midx_chain_filename(struct strbuf *buf, const char *object_dir);
-void get_split_midx_filename_ext(const struct git_hash_algo *hash_algo,
-                                struct strbuf *buf, const char *object_dir,
+void get_midx_chain_dirname(struct odb_source *source, struct strbuf *out);
+void get_midx_chain_filename(struct odb_source *source, struct strbuf *out);
+void get_split_midx_filename_ext(struct odb_source *source, struct strbuf *buf,
                                 const unsigned char *hash, const char *ext);
 
 struct multi_pack_index *load_multi_pack_index(struct odb_source *source);

diff --git a/pack-bitmap.c b/pack-bitmap.c
index 01e14c34bd0caccdd3eff74ae391eea9b1fe45fb..058bdb5d7ded0b46337015bd05f3b9ca7ebf2ab5 100644 (file)
--- a/pack-bitmap.c
+++ b/pack-bitmap.c
@@ -418,13 +418,12 @@ char *midx_bitmap_filename(struct multi_pack_index *midx)
 {
        struct strbuf buf = STRBUF_INIT;
        if (midx->has_chain)
-               get_split_midx_filename_ext(midx->source->odb->repo->hash_algo, &buf,
-                                           midx->source->path,
+               get_split_midx_filename_ext(midx->source, &buf,
                                            get_midx_checksum(midx),
                                            MIDX_EXT_BITMAP);
        else
-               get_midx_filename_ext(midx->source->odb->repo->hash_algo, &buf,
-                                     midx->source->path, get_midx_checksum(midx),
+               get_midx_filename_ext(midx->source, &buf,
+                                     get_midx_checksum(midx),
                                      MIDX_EXT_BITMAP);
 
        return strbuf_detach(&buf, NULL);
@@ -463,8 +462,7 @@ static int open_midx_bitmap_1(struct bitmap_index *bitmap_git,
 
        if (bitmap_git->pack || bitmap_git->midx) {
                struct strbuf buf = STRBUF_INIT;
-               get_midx_filename(midx->source->odb->repo->hash_algo, &buf,
-                                 midx->source->path);
+               get_midx_filename(midx->source, &buf);
                trace2_data_string("bitmap", bitmap_repo(bitmap_git),
                                   "ignoring extra midx bitmap file", buf.buf);
                close(fd);

diff --git a/pack-revindex.c b/pack-revindex.c
index b206518dcb51ddaa7c0f52e0d55c72bd6d2fbfea..d0791cc4938fa2c784a1a585210552ee2c6d06fa 100644 (file)
--- a/pack-revindex.c
+++ b/pack-revindex.c
@@ -389,12 +389,12 @@ int load_midx_revindex(struct multi_pack_index *m)
                           "source", "rev");
 
        if (m->has_chain)
-               get_split_midx_filename_ext(m->source->odb->repo->hash_algo, &revindex_name,
-                                           m->source->path, get_midx_checksum(m),
+               get_split_midx_filename_ext(m->source, &revindex_name,
+                                           get_midx_checksum(m),
                                            MIDX_EXT_REV);
        else
-               get_midx_filename_ext(m->source->odb->repo->hash_algo, &revindex_name,
-                                     m->source->path, get_midx_checksum(m),
+               get_midx_filename_ext(m->source, &revindex_name,
+                                     get_midx_checksum(m),
                                      MIDX_EXT_REV);
 
        ret = load_revindex_from_disk(m->source->odb->repo->hash_algo,