From 3367b6657c456788e37c335bdd3225e517d2c804 Mon Sep 17 00:00:00 2001 From: Taylor Blau Date: Tue, 1 Jul 2025 05:32:07 +0000 Subject: [PATCH 01/21] pack-bitmap: fix memory leak if load_bitmap() failed After going through the "failed" label, load_bitmap() will return -1, and its caller (either prepare_bitmap_walk() or prepare_bitmap_git()) will then call free_bitmap_index(). That function would have done: struct stored_bitmap *sb; kh_foreach_value(b->bitmaps, sb { ewah_pool_free(sb->root); free(sb); }); , but won't since load_bitmap() already called kh_destroy_oid_map() and NULL'd the "bitmaps" pointer from within its "failed" label. Thus if you got part of the way through loading bitmap entries and then failed, you would leak all of the previous entries that you were able to load successfully. The solution is to remove the error handling code in load_bitmap(), because its caller will always call free_bitmap_index() in case of an error. Signed-off-by: Taylor Blau Signed-off-by: Lidong Yan <502024330056@smail.nju.edu.cn> Signed-off-by: Junio C Hamano --- pack-bitmap.c | 21 ++++----------------- 1 file changed, 4 insertions(+), 17 deletions(-) diff --git a/pack-bitmap.c b/pack-bitmap.c index ac6d62b980c5a8..fd19c22551638d 100644 --- a/pack-bitmap.c +++ b/pack-bitmap.c @@ -630,41 +630,28 @@ static int load_bitmap(struct repository *r, struct bitmap_index *bitmap_git, bitmap_git->ext_index.positions = kh_init_oid_pos(); if (load_reverse_index(r, bitmap_git)) - goto failed; + return -1; if (!(bitmap_git->commits = read_bitmap_1(bitmap_git)) || !(bitmap_git->trees = read_bitmap_1(bitmap_git)) || !(bitmap_git->blobs = read_bitmap_1(bitmap_git)) || !(bitmap_git->tags = read_bitmap_1(bitmap_git))) - goto failed; + return -1; if (!bitmap_git->table_lookup && load_bitmap_entries_v1(bitmap_git) < 0) - goto failed; + return -1; if (bitmap_git->base) { if (!bitmap_is_midx(bitmap_git)) BUG("non-MIDX bitmap has non-NULL base bitmap index"); if (load_bitmap(r, bitmap_git->base, 1) < 0) - goto failed; + return -1; } if (!recursing) load_all_type_bitmaps(bitmap_git); return 0; - -failed: - munmap(bitmap_git->map, bitmap_git->map_size); - bitmap_git->map = NULL; - bitmap_git->map_size = 0; - - kh_destroy_oid_map(bitmap_git->bitmaps); - bitmap_git->bitmaps = NULL; - - kh_destroy_oid_pos(bitmap_git->ext_index.positions); - bitmap_git->ext_index.positions = NULL; - - return -1; } static int open_pack_bitmap(struct repository *r, From 73bf771b958b0d28fc5839cd94c4b7ad2029f631 Mon Sep 17 00:00:00 2001 From: Lidong Yan <502024330056@smail.nju.edu.cn> Date: Tue, 1 Jul 2025 05:32:08 +0000 Subject: [PATCH 02/21] pack-bitmap: reword comments in test_bitmap_commits() The comment in pack-bitmap.c:test_bitmap_commits(), suggests that we can avoid reading the commit table altogether. However, this comment is misleading. The reason we load bitmap entries here is because test_bitmap_commits() needs to print the commit IDs from the bitmap, and we must read the bitmap entries to obtain those commit IDs. So reword this comment. Signed-off-by: Lidong Yan <502024330056@smail.nju.edu.cn> Signed-off-by: Junio C Hamano --- pack-bitmap.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/pack-bitmap.c b/pack-bitmap.c index fd19c22551638d..d1d8814be7f3f3 100644 --- a/pack-bitmap.c +++ b/pack-bitmap.c @@ -2839,8 +2839,9 @@ int test_bitmap_commits(struct repository *r) die(_("failed to load bitmap indexes")); /* - * As this function is only used to print bitmap selected - * commits, we don't have to read the commit table. + * Since this function needs to print the bitmapped + * commits, bypass the commit lookup table (if one exists) + * by forcing the bitmap to eagerly load its entries. */ if (bitmap_git->table_lookup) { if (load_bitmap_entries_v1(bitmap_git) < 0) From bfd5522e98cead32d7bbdf54eca4ffeb3e01fa6b Mon Sep 17 00:00:00 2001 From: Lidong Yan <502024330056@smail.nju.edu.cn> Date: Tue, 1 Jul 2025 05:32:09 +0000 Subject: [PATCH 03/21] pack-bitmap: add load corrupt bitmap test t5310 lacks a test to ensure git works correctly when commit bitmap data is corrupted. So this patch add test helper in pack-bitmap.c to list each commit bitmap position in bitmap file and `load corrupt bitmap` test case in t/t5310 to corrupt a commit bitmap before loading it. Signed-off-by: Lidong Yan <502024330056@smail.nju.edu.cn> Signed-off-by: Junio C Hamano --- pack-bitmap.c | 62 +++++++++++++++++++++++++++++++++++++---- pack-bitmap.h | 1 + t/helper/test-bitmap.c | 8 ++++++ t/t5310-pack-bitmaps.sh | 30 ++++++++++++++++++++ 4 files changed, 96 insertions(+), 5 deletions(-) diff --git a/pack-bitmap.c b/pack-bitmap.c index d1d8814be7f3f3..d707bc52f7fda3 100644 --- a/pack-bitmap.c +++ b/pack-bitmap.c @@ -31,6 +31,7 @@ struct stored_bitmap { struct object_id oid; struct ewah_bitmap *root; struct stored_bitmap *xor; + size_t map_pos; int flags; }; @@ -314,13 +315,14 @@ static struct stored_bitmap *store_bitmap(struct bitmap_index *index, struct ewah_bitmap *root, const struct object_id *oid, struct stored_bitmap *xor_with, - int flags) + int flags, size_t map_pos) { struct stored_bitmap *stored; khiter_t hash_pos; int ret; stored = xmalloc(sizeof(struct stored_bitmap)); + stored->map_pos = map_pos; stored->root = root; stored->xor = xor_with; stored->flags = flags; @@ -376,10 +378,12 @@ static int load_bitmap_entries_v1(struct bitmap_index *index) struct stored_bitmap *xor_bitmap = NULL; uint32_t commit_idx_pos; struct object_id oid; + size_t entry_map_pos; if (index->map_size - index->map_pos < 6) return error(_("corrupt ewah bitmap: truncated header for entry %d"), i); + entry_map_pos = index->map_pos; commit_idx_pos = read_be32(index->map, &index->map_pos); xor_offset = read_u8(index->map, &index->map_pos); flags = read_u8(index->map, &index->map_pos); @@ -402,8 +406,9 @@ static int load_bitmap_entries_v1(struct bitmap_index *index) if (!bitmap) return -1; - recent_bitmaps[i % MAX_XOR_OFFSET] = store_bitmap( - index, bitmap, &oid, xor_bitmap, flags); + recent_bitmaps[i % MAX_XOR_OFFSET] = + store_bitmap(index, bitmap, &oid, xor_bitmap, flags, + entry_map_pos); } return 0; @@ -869,6 +874,7 @@ static struct stored_bitmap *lazy_bitmap_for_commit(struct bitmap_index *bitmap_ int xor_flags; khiter_t hash_pos; struct bitmap_lookup_table_xor_item *xor_item; + size_t entry_map_pos; if (is_corrupt) return NULL; @@ -928,6 +934,7 @@ static struct stored_bitmap *lazy_bitmap_for_commit(struct bitmap_index *bitmap_ goto corrupt; } + entry_map_pos = bitmap_git->map_pos; bitmap_git->map_pos += sizeof(uint32_t) + sizeof(uint8_t); xor_flags = read_u8(bitmap_git->map, &bitmap_git->map_pos); bitmap = read_bitmap_1(bitmap_git); @@ -935,7 +942,8 @@ static struct stored_bitmap *lazy_bitmap_for_commit(struct bitmap_index *bitmap_ if (!bitmap) goto corrupt; - xor_bitmap = store_bitmap(bitmap_git, bitmap, &xor_item->oid, xor_bitmap, xor_flags); + xor_bitmap = store_bitmap(bitmap_git, bitmap, &xor_item->oid, + xor_bitmap, xor_flags, entry_map_pos); xor_items_nr--; } @@ -969,6 +977,7 @@ static struct stored_bitmap *lazy_bitmap_for_commit(struct bitmap_index *bitmap_ * Instead, we can skip ahead and immediately read the flags and * ewah bitmap. */ + entry_map_pos = bitmap_git->map_pos; bitmap_git->map_pos += sizeof(uint32_t) + sizeof(uint8_t); flags = read_u8(bitmap_git->map, &bitmap_git->map_pos); bitmap = read_bitmap_1(bitmap_git); @@ -976,7 +985,8 @@ static struct stored_bitmap *lazy_bitmap_for_commit(struct bitmap_index *bitmap_ if (!bitmap) goto corrupt; - return store_bitmap(bitmap_git, bitmap, oid, xor_bitmap, flags); + return store_bitmap(bitmap_git, bitmap, oid, xor_bitmap, flags, + entry_map_pos); corrupt: free(xor_items); @@ -2857,6 +2867,48 @@ int test_bitmap_commits(struct repository *r) return 0; } +int test_bitmap_commits_with_offset(struct repository *r) +{ + struct object_id oid; + struct stored_bitmap *stored; + struct bitmap_index *bitmap_git; + size_t commit_idx_pos_map_pos, xor_offset_map_pos, flag_map_pos, + ewah_bitmap_map_pos; + + bitmap_git = prepare_bitmap_git(r); + if (!bitmap_git) + die(_("failed to load bitmap indexes")); + + /* + * Since this function needs to know the position of each individual + * bitmap, bypass the commit lookup table (if one exists) by forcing + * the bitmap to eagerly load its entries. + */ + if (bitmap_git->table_lookup) { + if (load_bitmap_entries_v1(bitmap_git) < 0) + die(_("failed to load bitmap indexes")); + } + + kh_foreach (bitmap_git->bitmaps, oid, stored, { + commit_idx_pos_map_pos = stored->map_pos; + xor_offset_map_pos = stored->map_pos + sizeof(uint32_t); + flag_map_pos = xor_offset_map_pos + sizeof(uint8_t); + ewah_bitmap_map_pos = flag_map_pos + sizeof(uint8_t); + + printf_ln("%s %"PRIuMAX" %"PRIuMAX" %"PRIuMAX" %"PRIuMAX, + oid_to_hex(&oid), + (uintmax_t)commit_idx_pos_map_pos, + (uintmax_t)xor_offset_map_pos, + (uintmax_t)flag_map_pos, + (uintmax_t)ewah_bitmap_map_pos); + }) + ; + + free_bitmap_index(bitmap_git); + + return 0; +} + int test_bitmap_hashes(struct repository *r) { struct bitmap_index *bitmap_git = prepare_bitmap_git(r); diff --git a/pack-bitmap.h b/pack-bitmap.h index 382d39499af23c..1bd7a791e2a0d0 100644 --- a/pack-bitmap.h +++ b/pack-bitmap.h @@ -81,6 +81,7 @@ void traverse_bitmap_commit_list(struct bitmap_index *, show_reachable_fn show_reachable); void test_bitmap_walk(struct rev_info *revs); int test_bitmap_commits(struct repository *r); +int test_bitmap_commits_with_offset(struct repository *r); int test_bitmap_hashes(struct repository *r); int test_bitmap_pseudo_merges(struct repository *r); int test_bitmap_pseudo_merge_commits(struct repository *r, uint32_t n); diff --git a/t/helper/test-bitmap.c b/t/helper/test-bitmap.c index 3f23f21072681c..16a01669e4149a 100644 --- a/t/helper/test-bitmap.c +++ b/t/helper/test-bitmap.c @@ -10,6 +10,11 @@ static int bitmap_list_commits(void) return test_bitmap_commits(the_repository); } +static int bitmap_list_commits_with_offset(void) +{ + return test_bitmap_commits_with_offset(the_repository); +} + static int bitmap_dump_hashes(void) { return test_bitmap_hashes(the_repository); @@ -36,6 +41,8 @@ int cmd__bitmap(int argc, const char **argv) if (argc == 2 && !strcmp(argv[1], "list-commits")) return bitmap_list_commits(); + if (argc == 2 && !strcmp(argv[1], "list-commits-with-offset")) + return bitmap_list_commits_with_offset(); if (argc == 2 && !strcmp(argv[1], "dump-hashes")) return bitmap_dump_hashes(); if (argc == 2 && !strcmp(argv[1], "dump-pseudo-merges")) @@ -46,6 +53,7 @@ int cmd__bitmap(int argc, const char **argv) return bitmap_dump_pseudo_merge_objects(atoi(argv[2])); usage("\ttest-tool bitmap list-commits\n" + "\ttest-tool bitmap list-commits-with-offset\n" "\ttest-tool bitmap dump-hashes\n" "\ttest-tool bitmap dump-pseudo-merges\n" "\ttest-tool bitmap dump-pseudo-merge-commits \n" diff --git a/t/t5310-pack-bitmaps.sh b/t/t5310-pack-bitmaps.sh index a62b463eaf0932..df05d7419185a6 100755 --- a/t/t5310-pack-bitmaps.sh +++ b/t/t5310-pack-bitmaps.sh @@ -486,6 +486,36 @@ test_bitmap_cases () { grep "ignoring extra bitmap" trace2.txt ) ' + + test_expect_success 'load corrupt bitmap' ' + rm -fr repo && + git init repo && + test_when_finished "rm -fr repo" && + ( + cd repo && + git config pack.writeBitmapLookupTable '"$writeLookupTable"' && + + test_commit base && + + git repack -adb && + bitmap="$(ls .git/objects/pack/pack-*.bitmap)" && + chmod +w $bitmap && + + test-tool bitmap list-commits-with-offset >offsets && + xor_off=$(head -n1 offsets | awk "{print \$3}") && + printf '\161' | + dd of=$bitmap count=1 bs=1 conv=notrunc seek=$xor_off && + + git rev-list --objects --no-object-names HEAD >expect.raw && + git rev-list --objects --use-bitmap-index --no-object-names HEAD \ + >actual.raw && + + sort expect.raw >expect && + sort actual.raw >actual && + + test_cmp expect actual + ) + ' } test_bitmap_cases From 1ace06644926bcf1f05e291e8a9476c977c25eeb Mon Sep 17 00:00:00 2001 From: Patrick Steinhardt Date: Tue, 1 Jul 2025 14:22:13 +0200 Subject: [PATCH 04/21] object-store: rename `raw_object_store` to `object_database` The `raw_object_store` structure is the central entry point for reading and writing objects in a repository. The main purpose of this structure is to manage object directories and provide an interface to access and write objects in those object directories. Right now, many of the functions associated with the raw object store implicitly rely on `the_repository` to get access to its `objects` pointer, which is the `raw_object_store`. As we want to generally get rid of using `the_repository` across our codebase we will have to convert this implicit dependency on this global variable into an explicit parameter. This conversion can be done by simply passing in an explicit pointer to a repository and then using its `->objects` pointer. But there is a second effort underway, which is to make the object subsystem more selfcontained so that we can eventually have pluggable object backends. As such, passing in a repository wouldn't make a ton of sense, and the goal is to convert the object store interfaces such that we always pass in a reference to the `raw_object_store` instead. This will expose the `raw_object_store` type to a lot more callers though, which surfaces that this type is named somewhat awkwardly. The "raw_" prefix makes readers wonder whether there is a non-raw variant of the object store, but there isn't. Furthermore, we nowadays want to name functions in a way that they can be clearly attributed to a specific subsystem, but calling them e.g. `raw_object_store_has_object()` is just too unwieldy, even when dropping the "raw_" prefix. Instead, rename the structure to `object_database`. This term is already used a lot throughout our codebase, and it cannot easily be mistaken for "object directories", either. Furthermore, its acronym ODB is already well-known and works well as part of a function's name, like for example `odb_has_object()`. Signed-off-by: Patrick Steinhardt Signed-off-by: Junio C Hamano --- commit-graph.c | 2 +- commit-graph.h | 4 ++-- object-store.c | 12 ++++++------ object-store.h | 11 ++++++++--- packfile.c | 2 +- packfile.h | 4 ++-- repository.c | 4 ++-- repository.h | 4 ++-- 8 files changed, 24 insertions(+), 19 deletions(-) diff --git a/commit-graph.c b/commit-graph.c index ad3943b6906520..905fcbdf0e8e9f 100644 --- a/commit-graph.c +++ b/commit-graph.c @@ -829,7 +829,7 @@ struct bloom_filter_settings *get_bloom_filter_settings(struct repository *r) return NULL; } -void close_commit_graph(struct raw_object_store *o) +void close_commit_graph(struct object_database *o) { if (!o->commit_graph) return; diff --git a/commit-graph.h b/commit-graph.h index 13f662827d49a9..20d38c100ce7c9 100644 --- a/commit-graph.h +++ b/commit-graph.h @@ -26,7 +26,7 @@ void git_test_write_commit_graph_or_die(void); struct commit; struct bloom_filter_settings; struct repository; -struct raw_object_store; +struct object_database; struct string_list; char *get_commit_graph_filename(struct object_directory *odb); @@ -186,7 +186,7 @@ int write_commit_graph(struct object_directory *odb, int verify_commit_graph(struct repository *r, struct commit_graph *g, int flags); -void close_commit_graph(struct raw_object_store *); +void close_commit_graph(struct object_database *); void free_commit_graph(struct commit_graph *); /* diff --git a/object-store.c b/object-store.c index 58cde0313a5533..f4e8f99d90f1b2 100644 --- a/object-store.c +++ b/object-store.c @@ -44,7 +44,7 @@ struct cached_object_entry { } value; }; -static const struct cached_object *find_cached_object(struct raw_object_store *object_store, +static const struct cached_object *find_cached_object(struct object_database *object_store, const struct object_id *oid) { static const struct cached_object empty_tree = { @@ -86,7 +86,7 @@ int odb_mkstemp(struct strbuf *temp_filename, const char *pattern) /* * Return non-zero iff the path is usable as an alternate object database. */ -static int alt_odb_usable(struct raw_object_store *o, +static int alt_odb_usable(struct object_database *o, struct strbuf *path, const char *normalized_objdir, khiter_t *pos) { @@ -950,9 +950,9 @@ void assert_oid_type(const struct object_id *oid, enum object_type expect) type_name(expect)); } -struct raw_object_store *raw_object_store_new(void) +struct object_database *odb_new(void) { - struct raw_object_store *o = xmalloc(sizeof(*o)); + struct object_database *o = xmalloc(sizeof(*o)); memset(o, 0, sizeof(*o)); INIT_LIST_HEAD(&o->packed_git_mru); @@ -961,7 +961,7 @@ struct raw_object_store *raw_object_store_new(void) return o; } -static void free_object_directories(struct raw_object_store *o) +static void free_object_directories(struct object_database *o) { while (o->odb) { struct object_directory *next; @@ -974,7 +974,7 @@ static void free_object_directories(struct raw_object_store *o) o->odb_by_path = NULL; } -void raw_object_store_clear(struct raw_object_store *o) +void odb_clear(struct object_database *o) { FREE_AND_NULL(o->alternate_db); diff --git a/object-store.h b/object-store.h index c5890085352329..a3be27d1171842 100644 --- a/object-store.h +++ b/object-store.h @@ -87,7 +87,12 @@ struct packed_git; struct multi_pack_index; struct cached_object_entry; -struct raw_object_store { +/* + * The object database encapsulates access to objects in a repository. It + * manages one or more backends that store the actual objects which are + * configured via alternates. + */ +struct object_database { /* * Set of all object directories; the main directory is first (and * cannot be NULL after initialization). Subsequent directories are @@ -169,8 +174,8 @@ struct raw_object_store { unsigned packed_git_initialized : 1; }; -struct raw_object_store *raw_object_store_new(void); -void raw_object_store_clear(struct raw_object_store *o); +struct object_database *odb_new(void); +void odb_clear(struct object_database *o); /* * Create a temporary file rooted in the object database directory, or diff --git a/packfile.c b/packfile.c index 70c7208f027b52..c735b4d013547d 100644 --- a/packfile.c +++ b/packfile.c @@ -359,7 +359,7 @@ void close_pack(struct packed_git *p) oidset_clear(&p->bad_objects); } -void close_object_store(struct raw_object_store *o) +void close_object_store(struct object_database *o) { struct packed_git *p; diff --git a/packfile.h b/packfile.h index 3a3c77cf05a63d..826eb7f475fc31 100644 --- a/packfile.h +++ b/packfile.h @@ -183,12 +183,12 @@ int close_pack_fd(struct packed_git *p); uint32_t get_pack_fanout(struct packed_git *p, uint32_t value); -struct raw_object_store; +struct object_database; unsigned char *use_pack(struct packed_git *, struct pack_window **, off_t, unsigned long *); void close_pack_windows(struct packed_git *); void close_pack(struct packed_git *); -void close_object_store(struct raw_object_store *o); +void close_object_store(struct object_database *o); void unuse_pack(struct pack_window **); void clear_delta_base_cache(void); struct packed_git *add_packed_git(struct repository *r, const char *path, diff --git a/repository.c b/repository.c index 9b3d6665fc6d4f..07757e6e0c90d7 100644 --- a/repository.c +++ b/repository.c @@ -52,7 +52,7 @@ static void set_default_hash_algo(struct repository *repo) void initialize_repository(struct repository *repo) { - repo->objects = raw_object_store_new(); + repo->objects = odb_new(); repo->remote_state = remote_state_new(); repo->parsed_objects = parsed_object_pool_new(repo); ALLOC_ARRAY(repo->index, 1); @@ -374,7 +374,7 @@ void repo_clear(struct repository *repo) FREE_AND_NULL(repo->worktree); FREE_AND_NULL(repo->submodule_prefix); - raw_object_store_clear(repo->objects); + odb_clear(repo->objects); FREE_AND_NULL(repo->objects); parsed_object_pool_clear(repo->parsed_objects); diff --git a/repository.h b/repository.h index c4c92b2ab9c9e3..3a5ef9c781e1ec 100644 --- a/repository.h +++ b/repository.h @@ -9,7 +9,7 @@ struct git_hash_algo; struct index_state; struct lock_file; struct pathspec; -struct raw_object_store; +struct object_database; struct submodule_cache; struct promisor_remote_config; struct remote_state; @@ -47,7 +47,7 @@ struct repository { /* * Holds any information related to accessing the raw object content. */ - struct raw_object_store *objects; + struct object_database *objects; /* * All objects in this repository that have been parsed. This structure From a1e2581a1e9ca2a85ae0a018ba5fb8fe5db3c322 Mon Sep 17 00:00:00 2001 From: Patrick Steinhardt Date: Tue, 1 Jul 2025 14:22:14 +0200 Subject: [PATCH 05/21] object-store: rename `object_directory` to `odb_source` The `object_directory` structure is used as an access point for a single object directory like ".git/objects". While the structure isn't yet fully self-contained, the intent is for it to eventually contain all information required to access objects in one specific location. While the name "object directory" is a good fit for now, this will change over time as we continue with the agenda to make pluggable object databases a thing. Eventually, objects may not be accessed via any kind of directory at all anymore, but they could instead be backed by any kind of durable storage mechanism. While it seems quite far-fetched for now, it is thinkable that eventually this might even be some form of a database, for example. As such, the current name of this structure will become worse over time as we evolve into the direction of pluggable ODBs. Immediate next steps will start to carve out proper self-contained object directories, which requires us to pass in these object directories as parameters. Based on our modern naming schema this means that those functions should then be named after their subsystem, which means that we would start to bake the current name into the codebase more and more. Let's preempt this by renaming the structure. There have been a couple alternatives that were discussed: - `odb_backend` was discarded because it led to the association that one object database has a single backend, but the model is that one alternate has one backend. Furthermore, "backend" is more about the actual backing implementation and less about the high-level concept. - `odb_alternate` was discarded because it is a bit of a stretch to also call the main object directory an "alternate". Instead, pick `odb_source` as the new name. It makes it sufficiently clear that there can be multiple sources and does not cause confusion when mixed with the already-existing "alternate" terminology. In the future, this change allows us to easily introduce for example a `odb_files_source` and other format-specific implementations. Signed-off-by: Patrick Steinhardt Signed-off-by: Junio C Hamano --- builtin/commit-graph.c | 18 +++--- builtin/count-objects.c | 4 +- builtin/fetch.c | 2 +- builtin/fsck.c | 14 ++--- builtin/gc.c | 14 ++--- builtin/grep.c | 2 +- builtin/multi-pack-index.c | 4 +- builtin/submodule--helper.c | 6 +- bundle.c | 2 +- commit-graph.c | 94 +++++++++++++-------------- commit-graph.h | 14 ++--- diagnose.c | 8 +-- http-walker.c | 2 +- http.c | 4 +- loose.c | 42 ++++++------- midx.c | 6 +- object-file.c | 80 +++++++++++------------ object-file.h | 8 +-- object-name.c | 6 +- object-store.c | 122 ++++++++++++++++++------------------ object-store.h | 38 +++++++---- packfile.c | 16 ++--- path.c | 2 +- refs.c | 2 +- repository.c | 14 ++--- submodule-config.c | 2 +- t/helper/test-read-graph.c | 6 +- tmp-objdir.c | 24 +++---- 28 files changed, 284 insertions(+), 272 deletions(-) diff --git a/builtin/commit-graph.c b/builtin/commit-graph.c index a783a86e797726..98a84315342994 100644 --- a/builtin/commit-graph.c +++ b/builtin/commit-graph.c @@ -66,7 +66,7 @@ static int graph_verify(int argc, const char **argv, const char *prefix, struct repository *repo UNUSED) { struct commit_graph *graph = NULL; - struct object_directory *odb = NULL; + struct odb_source *source = NULL; char *graph_name; char *chain_name; enum { OPENED_NONE, OPENED_GRAPH, OPENED_CHAIN } opened = OPENED_NONE; @@ -101,9 +101,9 @@ static int graph_verify(int argc, const char **argv, const char *prefix, if (opts.progress) flags |= COMMIT_GRAPH_WRITE_PROGRESS; - odb = find_odb(the_repository, opts.obj_dir); - graph_name = get_commit_graph_filename(odb); - chain_name = get_commit_graph_chain_filename(odb); + source = find_odb(the_repository, opts.obj_dir); + graph_name = get_commit_graph_filename(source); + chain_name = get_commit_graph_chain_filename(source); if (open_commit_graph(graph_name, &fd, &st)) opened = OPENED_GRAPH; else if (errno != ENOENT) @@ -120,7 +120,7 @@ static int graph_verify(int argc, const char **argv, const char *prefix, if (opened == OPENED_NONE) return 0; else if (opened == OPENED_GRAPH) - graph = load_commit_graph_one_fd_st(the_repository, fd, &st, odb); + graph = load_commit_graph_one_fd_st(the_repository, fd, &st, source); else graph = load_commit_graph_chain_fd_st(the_repository, fd, &st, &incomplete_chain); @@ -221,7 +221,7 @@ static int graph_write(int argc, const char **argv, const char *prefix, struct string_list pack_indexes = STRING_LIST_INIT_DUP; struct strbuf buf = STRBUF_INIT; struct oidset commits = OIDSET_INIT; - struct object_directory *odb = NULL; + struct odb_source *source = NULL; int result = 0; enum commit_graph_write_flags flags = 0; struct progress *progress = NULL; @@ -289,10 +289,10 @@ static int graph_write(int argc, const char **argv, const char *prefix, git_env_bool(GIT_TEST_COMMIT_GRAPH_CHANGED_PATHS, 0)) flags |= COMMIT_GRAPH_WRITE_BLOOM_FILTERS; - odb = find_odb(the_repository, opts.obj_dir); + source = find_odb(the_repository, opts.obj_dir); if (opts.reachable) { - if (write_commit_graph_reachable(odb, flags, &write_opts)) + if (write_commit_graph_reachable(source, flags, &write_opts)) result = 1; goto cleanup; } @@ -318,7 +318,7 @@ static int graph_write(int argc, const char **argv, const char *prefix, stop_progress(&progress); } - if (write_commit_graph(odb, + if (write_commit_graph(source, opts.stdin_packs ? &pack_indexes : NULL, opts.stdin_commits ? &commits : NULL, flags, diff --git a/builtin/count-objects.c b/builtin/count-objects.c index a88c0c9c09af64..58e0af433d1658 100644 --- a/builtin/count-objects.c +++ b/builtin/count-objects.c @@ -80,10 +80,10 @@ static int count_cruft(const char *basename UNUSED, const char *path, return 0; } -static int print_alternate(struct object_directory *odb, void *data UNUSED) +static int print_alternate(struct odb_source *alternate, void *data UNUSED) { printf("alternate: "); - quote_c_style(odb->path, NULL, stdout, 0); + quote_c_style(alternate->path, NULL, stdout, 0); putchar('\n'); return 0; } diff --git a/builtin/fetch.c b/builtin/fetch.c index 40a0e8d24434f2..a890e2864d13d9 100644 --- a/builtin/fetch.c +++ b/builtin/fetch.c @@ -2653,7 +2653,7 @@ int cmd_fetch(int argc, commit_graph_flags |= COMMIT_GRAPH_WRITE_PROGRESS; trace2_region_enter("fetch", "write-commit-graph", the_repository); - write_commit_graph_reachable(the_repository->objects->odb, + write_commit_graph_reachable(the_repository->objects->sources, commit_graph_flags, NULL); trace2_region_leave("fetch", "write-commit-graph", the_repository); diff --git a/builtin/fsck.c b/builtin/fsck.c index e7d96a9c8ea586..6e1474f63d59fd 100644 --- a/builtin/fsck.c +++ b/builtin/fsck.c @@ -956,7 +956,7 @@ int cmd_fsck(int argc, struct repository *repo UNUSED) { int i; - struct object_directory *odb; + struct odb_source *source; /* fsck knows how to handle missing promisor objects */ fetch_if_missing = 0; @@ -998,8 +998,8 @@ int cmd_fsck(int argc, mark_packed_for_connectivity, NULL, 0); } else { prepare_alt_odb(the_repository); - for (odb = the_repository->objects->odb; odb; odb = odb->next) - fsck_object_dir(odb->path); + for (source = the_repository->objects->sources; source; source = source->next) + fsck_object_dir(source->path); if (check_full) { struct packed_git *p; @@ -1109,11 +1109,11 @@ int cmd_fsck(int argc, struct child_process commit_graph_verify = CHILD_PROCESS_INIT; prepare_alt_odb(the_repository); - for (odb = the_repository->objects->odb; odb; odb = odb->next) { + for (source = the_repository->objects->sources; source; source = source->next) { child_process_init(&commit_graph_verify); commit_graph_verify.git_cmd = 1; strvec_pushl(&commit_graph_verify.args, "commit-graph", - "verify", "--object-dir", odb->path, NULL); + "verify", "--object-dir", source->path, NULL); if (show_progress) strvec_push(&commit_graph_verify.args, "--progress"); else @@ -1127,11 +1127,11 @@ int cmd_fsck(int argc, struct child_process midx_verify = CHILD_PROCESS_INIT; prepare_alt_odb(the_repository); - for (odb = the_repository->objects->odb; odb; odb = odb->next) { + for (source = the_repository->objects->sources; source; source = source->next) { child_process_init(&midx_verify); midx_verify.git_cmd = 1; strvec_pushl(&midx_verify.args, "multi-pack-index", - "verify", "--object-dir", odb->path, NULL); + "verify", "--object-dir", source->path, NULL); if (show_progress) strvec_push(&midx_verify.args, "--progress"); else diff --git a/builtin/gc.c b/builtin/gc.c index e33ba946e43602..50a09eb07e3f55 100644 --- a/builtin/gc.c +++ b/builtin/gc.c @@ -1018,7 +1018,7 @@ int cmd_gc(int argc, } if (the_repository->settings.gc_write_commit_graph == 1) - write_commit_graph_reachable(the_repository->objects->odb, + write_commit_graph_reachable(the_repository->objects->sources, !quiet && !daemonized ? COMMIT_GRAPH_WRITE_PROGRESS : 0, NULL); @@ -1271,7 +1271,7 @@ static int loose_object_auto_condition(struct gc_config *cfg UNUSED) if (loose_object_auto_limit < 0) return 1; - return for_each_loose_file_in_objdir(the_repository->objects->odb->path, + return for_each_loose_file_in_objdir(the_repository->objects->sources->path, loose_object_count, NULL, NULL, &count); } @@ -1306,7 +1306,7 @@ static int pack_loose(struct maintenance_run_opts *opts) * Do not start pack-objects process * if there are no loose objects. */ - if (!for_each_loose_file_in_objdir(r->objects->odb->path, + if (!for_each_loose_file_in_objdir(r->objects->sources->path, bail_on_loose, NULL, NULL, NULL)) return 0; @@ -1318,7 +1318,7 @@ static int pack_loose(struct maintenance_run_opts *opts) strvec_push(&pack_proc.args, "--quiet"); else strvec_push(&pack_proc.args, "--no-quiet"); - strvec_pushf(&pack_proc.args, "%s/pack/loose", r->objects->odb->path); + strvec_pushf(&pack_proc.args, "%s/pack/loose", r->objects->sources->path); pack_proc.in = -1; @@ -1346,7 +1346,7 @@ static int pack_loose(struct maintenance_run_opts *opts) else if (data.batch_size > 0) data.batch_size--; /* Decrease for equality on limit. */ - for_each_loose_file_in_objdir(r->objects->odb->path, + for_each_loose_file_in_objdir(r->objects->sources->path, write_loose_object_to_stdin, NULL, NULL, @@ -1611,7 +1611,7 @@ static int maintenance_run_tasks(struct maintenance_run_opts *opts, int result = 0; struct lock_file lk; struct repository *r = the_repository; - char *lock_path = xstrfmt("%s/maintenance", r->objects->odb->path); + char *lock_path = xstrfmt("%s/maintenance", r->objects->sources->path); if (hold_lock_file_for_update(&lk, lock_path, LOCK_NO_DEREF) < 0) { /* @@ -3083,7 +3083,7 @@ static int update_background_schedule(const struct maintenance_start_opts *opts, unsigned int i; int result = 0; struct lock_file lk; - char *lock_path = xstrfmt("%s/schedule", the_repository->objects->odb->path); + char *lock_path = xstrfmt("%s/schedule", the_repository->objects->sources->path); if (hold_lock_file_for_update(&lk, lock_path, LOCK_NO_DEREF) < 0) { if (errno == EEXIST) diff --git a/builtin/grep.c b/builtin/grep.c index 3ce574a605b72d..76b1938bba5152 100644 --- a/builtin/grep.c +++ b/builtin/grep.c @@ -505,7 +505,7 @@ static int grep_submodule(struct grep_opt *opt, * lazily registered as alternates when needed (and except in an * unexpected code interaction, it won't be needed). */ - add_submodule_odb_by_path(subrepo->objects->odb->path); + add_submodule_odb_by_path(subrepo->objects->sources->path); obj_read_unlock(); memcpy(&subopt, opt, sizeof(subopt)); diff --git a/builtin/multi-pack-index.c b/builtin/multi-pack-index.c index 69a97507324940..f55bf53da838a5 100644 --- a/builtin/multi-pack-index.c +++ b/builtin/multi-pack-index.c @@ -294,8 +294,8 @@ int cmd_multi_pack_index(int argc, if (the_repository && the_repository->objects && - the_repository->objects->odb) - opts.object_dir = xstrdup(the_repository->objects->odb->path); + the_repository->objects->sources) + opts.object_dir = xstrdup(the_repository->objects->sources->path); argc = parse_options(argc, argv, prefix, options, builtin_multi_pack_index_usage, 0); diff --git a/builtin/submodule--helper.c b/builtin/submodule--helper.c index 53da2116ddf576..758bc6d0f24089 100644 --- a/builtin/submodule--helper.c +++ b/builtin/submodule--helper.c @@ -1582,7 +1582,7 @@ static const char alternate_error_advice[] = N_( ); static int add_possible_reference_from_superproject( - struct object_directory *odb, void *sas_cb) + struct odb_source *alt_odb, void *sas_cb) { struct submodule_alternate_setup *sas = sas_cb; size_t len; @@ -1591,12 +1591,12 @@ static int add_possible_reference_from_superproject( * If the alternate object store is another repository, try the * standard layout with .git/(modules/)+/objects */ - if (strip_suffix(odb->path, "/objects", &len)) { + if (strip_suffix(alt_odb->path, "/objects", &len)) { struct repository alternate; char *sm_alternate; struct strbuf sb = STRBUF_INIT; struct strbuf err = STRBUF_INIT; - strbuf_add(&sb, odb->path, len); + strbuf_add(&sb, alt_odb->path, len); if (repo_init(&alternate, sb.buf, NULL) < 0) die(_("could not get a repository handle for gitdir '%s'"), diff --git a/bundle.c b/bundle.c index b0a3fee2efa7b3..2ce7525f90d564 100644 --- a/bundle.c +++ b/bundle.c @@ -233,7 +233,7 @@ int verify_bundle(struct repository *r, .quiet = 1, }; - if (!r || !r->objects || !r->objects->odb) + if (!r || !r->objects || !r->objects->sources) return error(_("need a repository to verify a bundle")); for (i = 0; i < p->nr; i++) { diff --git a/commit-graph.c b/commit-graph.c index 905fcbdf0e8e9f..12d32cdad1dc87 100644 --- a/commit-graph.c +++ b/commit-graph.c @@ -37,7 +37,7 @@ void git_test_write_commit_graph_or_die(void) if (git_env_bool(GIT_TEST_COMMIT_GRAPH_CHANGED_PATHS, 0)) flags = COMMIT_GRAPH_WRITE_BLOOM_FILTERS; - if (write_commit_graph_reachable(the_repository->objects->odb, + if (write_commit_graph_reachable(the_repository->objects->sources, flags, NULL)) die("failed to write commit-graph under GIT_TEST_COMMIT_GRAPH"); } @@ -191,21 +191,21 @@ static int commit_gen_cmp(const void *va, const void *vb) return 0; } -char *get_commit_graph_filename(struct object_directory *obj_dir) +char *get_commit_graph_filename(struct odb_source *source) { - return xstrfmt("%s/info/commit-graph", obj_dir->path); + return xstrfmt("%s/info/commit-graph", source->path); } -static char *get_split_graph_filename(struct object_directory *odb, +static char *get_split_graph_filename(struct odb_source *source, const char *oid_hex) { - return xstrfmt("%s/info/commit-graphs/graph-%s.graph", odb->path, + return xstrfmt("%s/info/commit-graphs/graph-%s.graph", source->path, oid_hex); } -char *get_commit_graph_chain_filename(struct object_directory *odb) +char *get_commit_graph_chain_filename(struct odb_source *source) { - return xstrfmt("%s/info/commit-graphs/commit-graph-chain", odb->path); + return xstrfmt("%s/info/commit-graphs/commit-graph-chain", source->path); } static struct commit_graph *alloc_commit_graph(void) @@ -250,7 +250,7 @@ int open_commit_graph(const char *graph_file, int *fd, struct stat *st) struct commit_graph *load_commit_graph_one_fd_st(struct repository *r, int fd, struct stat *st, - struct object_directory *odb) + struct odb_source *source) { void *graph_map; size_t graph_size; @@ -269,7 +269,7 @@ struct commit_graph *load_commit_graph_one_fd_st(struct repository *r, ret = parse_commit_graph(&r->settings, graph_map, graph_size); if (ret) - ret->odb = odb; + ret->odb_source = source; else munmap(graph_map, graph_size); @@ -487,7 +487,7 @@ struct commit_graph *parse_commit_graph(struct repo_settings *s, static struct commit_graph *load_commit_graph_one(struct repository *r, const char *graph_file, - struct object_directory *odb) + struct odb_source *source) { struct stat st; @@ -498,7 +498,7 @@ static struct commit_graph *load_commit_graph_one(struct repository *r, if (!open_ok) return NULL; - g = load_commit_graph_one_fd_st(r, fd, &st, odb); + g = load_commit_graph_one_fd_st(r, fd, &st, source); if (g) g->filename = xstrdup(graph_file); @@ -507,10 +507,10 @@ static struct commit_graph *load_commit_graph_one(struct repository *r, } static struct commit_graph *load_commit_graph_v1(struct repository *r, - struct object_directory *odb) + struct odb_source *source) { - char *graph_name = get_commit_graph_filename(odb); - struct commit_graph *g = load_commit_graph_one(r, graph_name, odb); + char *graph_name = get_commit_graph_filename(source); + struct commit_graph *g = load_commit_graph_one(r, graph_name, source); free(graph_name); return g; @@ -652,7 +652,7 @@ struct commit_graph *load_commit_graph_chain_fd_st(struct repository *r, prepare_alt_odb(r); for (i = 0; i < count; i++) { - struct object_directory *odb; + struct odb_source *source; if (strbuf_getline_lf(&line, fp) == EOF) break; @@ -665,9 +665,9 @@ struct commit_graph *load_commit_graph_chain_fd_st(struct repository *r, } valid = 0; - for (odb = r->objects->odb; odb; odb = odb->next) { - char *graph_name = get_split_graph_filename(odb, line.buf); - struct commit_graph *g = load_commit_graph_one(r, graph_name, odb); + for (source = r->objects->sources; source; source = source->next) { + char *graph_name = get_split_graph_filename(source, line.buf); + struct commit_graph *g = load_commit_graph_one(r, graph_name, source); free(graph_name); @@ -701,9 +701,9 @@ struct commit_graph *load_commit_graph_chain_fd_st(struct repository *r, } static struct commit_graph *load_commit_graph_chain(struct repository *r, - struct object_directory *odb) + struct odb_source *source) { - char *chain_file = get_commit_graph_chain_filename(odb); + char *chain_file = get_commit_graph_chain_filename(source); struct stat st; int fd; struct commit_graph *g = NULL; @@ -719,24 +719,24 @@ static struct commit_graph *load_commit_graph_chain(struct repository *r, } struct commit_graph *read_commit_graph_one(struct repository *r, - struct object_directory *odb) + struct odb_source *source) { - struct commit_graph *g = load_commit_graph_v1(r, odb); + struct commit_graph *g = load_commit_graph_v1(r, source); if (!g) - g = load_commit_graph_chain(r, odb); + g = load_commit_graph_chain(r, source); return g; } static void prepare_commit_graph_one(struct repository *r, - struct object_directory *odb) + struct odb_source *source) { if (r->objects->commit_graph) return; - r->objects->commit_graph = read_commit_graph_one(r, odb); + r->objects->commit_graph = read_commit_graph_one(r, source); } /* @@ -747,7 +747,7 @@ static void prepare_commit_graph_one(struct repository *r, */ static int prepare_commit_graph(struct repository *r) { - struct object_directory *odb; + struct odb_source *source; /* * Early return if there is no git dir or if the commit graph is @@ -779,10 +779,10 @@ static int prepare_commit_graph(struct repository *r) return 0; prepare_alt_odb(r); - for (odb = r->objects->odb; - !r->objects->commit_graph && odb; - odb = odb->next) - prepare_commit_graph_one(r, odb); + for (source = r->objects->sources; + !r->objects->commit_graph && source; + source = source->next) + prepare_commit_graph_one(r, source); return !!r->objects->commit_graph; } @@ -1137,7 +1137,7 @@ struct packed_commit_list { struct write_commit_graph_context { struct repository *r; - struct object_directory *odb; + struct odb_source *odb_source; char *graph_name; struct oid_array oids; struct packed_commit_list commits; @@ -1870,7 +1870,7 @@ static int add_ref_to_set(const char *refname UNUSED, return 0; } -int write_commit_graph_reachable(struct object_directory *odb, +int write_commit_graph_reachable(struct odb_source *source, enum commit_graph_write_flags flags, const struct commit_graph_opts *opts) { @@ -1890,7 +1890,7 @@ int write_commit_graph_reachable(struct object_directory *odb, stop_progress(&data.progress); - result = write_commit_graph(odb, NULL, &commits, + result = write_commit_graph(source, NULL, &commits, flags, opts); oidset_clear(&commits); @@ -1906,7 +1906,7 @@ static int fill_oids_from_packs(struct write_commit_graph_context *ctx, int dirlen; int ret = 0; - strbuf_addf(&packname, "%s/pack/", ctx->odb->path); + strbuf_addf(&packname, "%s/pack/", ctx->odb_source->path); dirlen = packname.len; if (ctx->report_progress) { strbuf_addf(&progress_title, @@ -2060,10 +2060,10 @@ static int write_commit_graph_file(struct write_commit_graph_context *ctx) strbuf_addf(&tmp_file, "%s/info/commit-graphs/tmp_graph_XXXXXX", - ctx->odb->path); + ctx->odb_source->path); ctx->graph_name = strbuf_detach(&tmp_file, NULL); } else { - ctx->graph_name = get_commit_graph_filename(ctx->odb); + ctx->graph_name = get_commit_graph_filename(ctx->odb_source); } if (safe_create_leading_directories(the_repository, ctx->graph_name)) { @@ -2073,7 +2073,7 @@ static int write_commit_graph_file(struct write_commit_graph_context *ctx) } if (ctx->split) { - char *lock_name = get_commit_graph_chain_filename(ctx->odb); + char *lock_name = get_commit_graph_chain_filename(ctx->odb_source); hold_lock_file_for_update_mode(&lk, lock_name, LOCK_DIE_ON_ERROR, 0444); @@ -2161,7 +2161,7 @@ static int write_commit_graph_file(struct write_commit_graph_context *ctx) if (ctx->split && ctx->base_graph_name && ctx->num_commit_graphs_after > 1) { char *new_base_hash = xstrdup(oid_to_hex(&ctx->new_base_graph->oid)); - char *new_base_name = get_split_graph_filename(ctx->new_base_graph->odb, new_base_hash); + char *new_base_name = get_split_graph_filename(ctx->new_base_graph->odb_source, new_base_hash); free(ctx->commit_graph_filenames_after[ctx->num_commit_graphs_after - 2]); free(ctx->commit_graph_hash_after[ctx->num_commit_graphs_after - 2]); @@ -2201,14 +2201,14 @@ static int write_commit_graph_file(struct write_commit_graph_context *ctx) } } } else { - char *graph_name = get_commit_graph_filename(ctx->odb); + char *graph_name = get_commit_graph_filename(ctx->odb_source); unlink(graph_name); free(graph_name); } free(ctx->commit_graph_hash_after[ctx->num_commit_graphs_after - 1]); ctx->commit_graph_hash_after[ctx->num_commit_graphs_after - 1] = xstrdup(hash_to_hex(file_hash)); - final_graph_name = get_split_graph_filename(ctx->odb, + final_graph_name = get_split_graph_filename(ctx->odb_source, ctx->commit_graph_hash_after[ctx->num_commit_graphs_after - 1]); free(ctx->commit_graph_filenames_after[ctx->num_commit_graphs_after - 1]); ctx->commit_graph_filenames_after[ctx->num_commit_graphs_after - 1] = final_graph_name; @@ -2259,7 +2259,7 @@ static void split_graph_merge_strategy(struct write_commit_graph_context *ctx) flags != COMMIT_GRAPH_SPLIT_REPLACE) { while (g && (g->num_commits <= st_mult(size_mult, num_commits) || (max_commits && num_commits > max_commits))) { - if (g->odb != ctx->odb) + if (g->odb_source != ctx->odb_source) break; if (unsigned_add_overflows(num_commits, g->num_commits)) @@ -2281,10 +2281,10 @@ static void split_graph_merge_strategy(struct write_commit_graph_context *ctx) "should be 1 with --split=replace"); if (ctx->num_commit_graphs_after == 2) { - char *old_graph_name = get_commit_graph_filename(g->odb); + char *old_graph_name = get_commit_graph_filename(g->odb_source); if (!strcmp(g->filename, old_graph_name) && - g->odb != ctx->odb) { + g->odb_source != ctx->odb_source) { ctx->num_commit_graphs_after = 1; ctx->new_base_graph = NULL; } @@ -2456,13 +2456,13 @@ static void expire_commit_graphs(struct write_commit_graph_context *ctx) if (ctx->opts && ctx->opts->expire_time) expire_time = ctx->opts->expire_time; if (!ctx->split) { - char *chain_file_name = get_commit_graph_chain_filename(ctx->odb); + char *chain_file_name = get_commit_graph_chain_filename(ctx->odb_source); unlink(chain_file_name); free(chain_file_name); ctx->num_commit_graphs_after = 0; } - strbuf_addstr(&path, ctx->odb->path); + strbuf_addstr(&path, ctx->odb_source->path); strbuf_addstr(&path, "/info/commit-graphs"); dir = opendir(path.buf); @@ -2504,7 +2504,7 @@ static void expire_commit_graphs(struct write_commit_graph_context *ctx) strbuf_release(&path); } -int write_commit_graph(struct object_directory *odb, +int write_commit_graph(struct odb_source *source, const struct string_list *const pack_indexes, struct oidset *commits, enum commit_graph_write_flags flags, @@ -2513,7 +2513,7 @@ int write_commit_graph(struct object_directory *odb, struct repository *r = the_repository; struct write_commit_graph_context ctx = { .r = r, - .odb = odb, + .odb_source = source, .append = flags & COMMIT_GRAPH_WRITE_APPEND ? 1 : 0, .report_progress = flags & COMMIT_GRAPH_WRITE_PROGRESS ? 1 : 0, .split = flags & COMMIT_GRAPH_WRITE_SPLIT ? 1 : 0, diff --git a/commit-graph.h b/commit-graph.h index 20d38c100ce7c9..0e661db1b54dd9 100644 --- a/commit-graph.h +++ b/commit-graph.h @@ -29,8 +29,8 @@ struct repository; struct object_database; struct string_list; -char *get_commit_graph_filename(struct object_directory *odb); -char *get_commit_graph_chain_filename(struct object_directory *odb); +char *get_commit_graph_filename(struct odb_source *source); +char *get_commit_graph_chain_filename(struct odb_source *source); int open_commit_graph(const char *graph_file, int *fd, struct stat *st); int open_commit_graph_chain(const char *chain_file, int *fd, struct stat *st); @@ -89,7 +89,7 @@ struct commit_graph { uint32_t num_commits; struct object_id oid; char *filename; - struct object_directory *odb; + struct odb_source *odb_source; uint32_t num_commits_in_base; unsigned int read_generation_data; @@ -115,12 +115,12 @@ struct commit_graph { struct commit_graph *load_commit_graph_one_fd_st(struct repository *r, int fd, struct stat *st, - struct object_directory *odb); + struct odb_source *source); struct commit_graph *load_commit_graph_chain_fd_st(struct repository *r, int fd, struct stat *st, int *incomplete_chain); struct commit_graph *read_commit_graph_one(struct repository *r, - struct object_directory *odb); + struct odb_source *source); struct repo_settings; @@ -173,10 +173,10 @@ struct commit_graph_opts { * is not compatible with the commit-graph feature, then the * methods will return 0 without writing a commit-graph. */ -int write_commit_graph_reachable(struct object_directory *odb, +int write_commit_graph_reachable(struct odb_source *source, enum commit_graph_write_flags flags, const struct commit_graph_opts *opts); -int write_commit_graph(struct object_directory *odb, +int write_commit_graph(struct odb_source *source, const struct string_list *pack_indexes, struct oidset *commits, enum commit_graph_write_flags flags, diff --git a/diagnose.c b/diagnose.c index b1be74be9831f8..d08d5643aac4f8 100644 --- a/diagnose.c +++ b/diagnose.c @@ -59,13 +59,13 @@ static void dir_file_stats_objects(const char *full_path, (uintmax_t)st.st_size); } -static int dir_file_stats(struct object_directory *object_dir, void *data) +static int dir_file_stats(struct odb_source *source, void *data) { struct strbuf *buf = data; - strbuf_addf(buf, "Contents of %s:\n", object_dir->path); + strbuf_addf(buf, "Contents of %s:\n", source->path); - for_each_file_in_pack_dir(object_dir->path, dir_file_stats_objects, + for_each_file_in_pack_dir(source->path, dir_file_stats_objects, data); return 0; @@ -228,7 +228,7 @@ int create_diagnostics_archive(struct repository *r, strbuf_reset(&buf); strbuf_addstr(&buf, "--add-virtual-file=packs-local.txt:"); - dir_file_stats(r->objects->odb, &buf); + dir_file_stats(r->objects->sources, &buf); foreach_alt_odb(dir_file_stats, &buf); strvec_push(&archiver_args, buf.buf); diff --git a/http-walker.c b/http-walker.c index 463f7b119ad4ca..c374e6b2056a01 100644 --- a/http-walker.c +++ b/http-walker.c @@ -543,7 +543,7 @@ static int fetch_object(struct walker *walker, const struct object_id *oid) ret = error("File %s has bad hash", hex); } else if (req->rename < 0) { struct strbuf buf = STRBUF_INIT; - odb_loose_path(the_repository->objects->odb, &buf, &req->oid); + odb_loose_path(the_repository->objects->sources, &buf, &req->oid); ret = error("unable to write sha1 filename %s", buf.buf); strbuf_release(&buf); } diff --git a/http.c b/http.c index 3c029cf8947df7..5e15bbab3f1dd5 100644 --- a/http.c +++ b/http.c @@ -2662,7 +2662,7 @@ struct http_object_request *new_http_object_request(const char *base_url, oidcpy(&freq->oid, oid); freq->localfile = -1; - odb_loose_path(the_repository->objects->odb, &filename, oid); + odb_loose_path(the_repository->objects->sources, &filename, oid); strbuf_addf(&freq->tmpfile, "%s.temp", filename.buf); strbuf_addf(&prevfile, "%s.prev", filename.buf); @@ -2814,7 +2814,7 @@ int finish_http_object_request(struct http_object_request *freq) unlink_or_warn(freq->tmpfile.buf); return -1; } - odb_loose_path(the_repository->objects->odb, &filename, &freq->oid); + odb_loose_path(the_repository->objects->sources, &filename, &freq->oid); freq->rename = finalize_object_file(freq->tmpfile.buf, filename.buf); strbuf_release(&filename); diff --git a/loose.c b/loose.c index bb602aaa366bf7..fe65d5b9b0f5c7 100644 --- a/loose.c +++ b/loose.c @@ -44,36 +44,36 @@ static int insert_oid_pair(kh_oid_map_t *map, const struct object_id *key, const return 1; } -static int insert_loose_map(struct object_directory *odb, +static int insert_loose_map(struct odb_source *source, const struct object_id *oid, const struct object_id *compat_oid) { - struct loose_object_map *map = odb->loose_map; + struct loose_object_map *map = source->loose_map; int inserted = 0; inserted |= insert_oid_pair(map->to_compat, oid, compat_oid); inserted |= insert_oid_pair(map->to_storage, compat_oid, oid); if (inserted) - oidtree_insert(odb->loose_objects_cache, compat_oid); + oidtree_insert(source->loose_objects_cache, compat_oid); return inserted; } -static int load_one_loose_object_map(struct repository *repo, struct object_directory *dir) +static int load_one_loose_object_map(struct repository *repo, struct odb_source *source) { struct strbuf buf = STRBUF_INIT, path = STRBUF_INIT; FILE *fp; - if (!dir->loose_map) - loose_object_map_init(&dir->loose_map); - if (!dir->loose_objects_cache) { - ALLOC_ARRAY(dir->loose_objects_cache, 1); - oidtree_init(dir->loose_objects_cache); + if (!source->loose_map) + loose_object_map_init(&source->loose_map); + if (!source->loose_objects_cache) { + ALLOC_ARRAY(source->loose_objects_cache, 1); + oidtree_init(source->loose_objects_cache); } - insert_loose_map(dir, repo->hash_algo->empty_tree, repo->compat_hash_algo->empty_tree); - insert_loose_map(dir, repo->hash_algo->empty_blob, repo->compat_hash_algo->empty_blob); - insert_loose_map(dir, repo->hash_algo->null_oid, repo->compat_hash_algo->null_oid); + insert_loose_map(source, repo->hash_algo->empty_tree, repo->compat_hash_algo->empty_tree); + insert_loose_map(source, repo->hash_algo->empty_blob, repo->compat_hash_algo->empty_blob); + insert_loose_map(source, repo->hash_algo->null_oid, repo->compat_hash_algo->null_oid); repo_common_path_replace(repo, &path, "objects/loose-object-idx"); fp = fopen(path.buf, "rb"); @@ -93,7 +93,7 @@ static int load_one_loose_object_map(struct repository *repo, struct object_dire parse_oid_hex_algop(p, &compat_oid, &p, repo->compat_hash_algo) || p != buf.buf + buf.len) goto err; - insert_loose_map(dir, &oid, &compat_oid); + insert_loose_map(source, &oid, &compat_oid); } strbuf_release(&buf); @@ -107,15 +107,15 @@ static int load_one_loose_object_map(struct repository *repo, struct object_dire int repo_read_loose_object_map(struct repository *repo) { - struct object_directory *dir; + struct odb_source *source; if (!should_use_loose_object_map(repo)) return 0; prepare_alt_odb(repo); - for (dir = repo->objects->odb; dir; dir = dir->next) { - if (load_one_loose_object_map(repo, dir) < 0) { + for (source = repo->objects->sources; source; source = source->next) { + if (load_one_loose_object_map(repo, source) < 0) { return -1; } } @@ -124,7 +124,7 @@ int repo_read_loose_object_map(struct repository *repo) int repo_write_loose_object_map(struct repository *repo) { - kh_oid_map_t *map = repo->objects->odb->loose_map->to_compat; + kh_oid_map_t *map = repo->objects->sources->loose_map->to_compat; struct lock_file lock; int fd; khiter_t iter; @@ -212,7 +212,7 @@ int repo_add_loose_object_map(struct repository *repo, const struct object_id *o if (!should_use_loose_object_map(repo)) return 0; - inserted = insert_loose_map(repo->objects->odb, oid, compat_oid); + inserted = insert_loose_map(repo->objects->sources, oid, compat_oid); if (inserted) return write_one_object(repo, oid, compat_oid); return 0; @@ -223,12 +223,12 @@ int repo_loose_object_map_oid(struct repository *repo, const struct git_hash_algo *to, struct object_id *dest) { - struct object_directory *dir; + struct odb_source *source; kh_oid_map_t *map; khiter_t pos; - for (dir = repo->objects->odb; dir; dir = dir->next) { - struct loose_object_map *loose_map = dir->loose_map; + for (source = repo->objects->sources; source; source = source->next) { + struct loose_object_map *loose_map = source->loose_map; if (!loose_map) continue; map = (to == repo->compat_hash_algo) ? diff --git a/midx.c b/midx.c index cd6e766ce2b158..3c5bc8217300ca 100644 --- a/midx.c +++ b/midx.c @@ -832,7 +832,7 @@ void clear_midx_file(struct repository *r) { struct strbuf midx = STRBUF_INIT; - get_midx_filename(r->hash_algo, &midx, r->objects->odb->path); + get_midx_filename(r->hash_algo, &midx, r->objects->sources->path); if (r->objects && r->objects->multi_pack_index) { close_midx(r->objects->multi_pack_index); @@ -842,8 +842,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->odb->path, MIDX_EXT_BITMAP, NULL); - clear_midx_files_ext(r->objects->odb->path, MIDX_EXT_REV, NULL); + clear_midx_files_ext(r->objects->sources->path, MIDX_EXT_BITMAP, NULL); + clear_midx_files_ext(r->objects->sources->path, MIDX_EXT_REV, NULL); strbuf_release(&midx); } diff --git a/object-file.c b/object-file.c index 1ac04c2891634a..6bad1d3dd1cf13 100644 --- a/object-file.c +++ b/object-file.c @@ -55,12 +55,12 @@ static void fill_loose_path(struct strbuf *buf, const struct object_id *oid) } } -const char *odb_loose_path(struct object_directory *odb, +const char *odb_loose_path(struct odb_source *source, struct strbuf *buf, const struct object_id *oid) { strbuf_reset(buf); - strbuf_addstr(buf, odb->path); + strbuf_addstr(buf, source->path); strbuf_addch(buf, '/'); fill_loose_path(buf, oid); return buf->buf; @@ -88,27 +88,27 @@ int check_and_freshen_file(const char *fn, int freshen) return 1; } -static int check_and_freshen_odb(struct object_directory *odb, +static int check_and_freshen_odb(struct odb_source *source, const struct object_id *oid, int freshen) { static struct strbuf path = STRBUF_INIT; - odb_loose_path(odb, &path, oid); + odb_loose_path(source, &path, oid); return check_and_freshen_file(path.buf, freshen); } static int check_and_freshen_local(const struct object_id *oid, int freshen) { - return check_and_freshen_odb(the_repository->objects->odb, oid, freshen); + return check_and_freshen_odb(the_repository->objects->sources, oid, freshen); } static int check_and_freshen_nonlocal(const struct object_id *oid, int freshen) { - struct object_directory *odb; + struct odb_source *source; prepare_alt_odb(the_repository); - for (odb = the_repository->objects->odb->next; odb; odb = odb->next) { - if (check_and_freshen_odb(odb, oid, freshen)) + for (source = the_repository->objects->sources->next; source; source = source->next) { + if (check_and_freshen_odb(source, oid, freshen)) return 1; } return 0; @@ -202,12 +202,12 @@ int stream_object_signature(struct repository *r, const struct object_id *oid) static int stat_loose_object(struct repository *r, const struct object_id *oid, struct stat *st, const char **path) { - struct object_directory *odb; + struct odb_source *source; static struct strbuf buf = STRBUF_INIT; prepare_alt_odb(r); - for (odb = r->objects->odb; odb; odb = odb->next) { - *path = odb_loose_path(odb, &buf, oid); + for (source = r->objects->sources; source; source = source->next) { + *path = odb_loose_path(source, &buf, oid); if (!lstat(*path, st)) return 0; } @@ -223,13 +223,13 @@ static int open_loose_object(struct repository *r, const struct object_id *oid, const char **path) { int fd; - struct object_directory *odb; + struct odb_source *source; int most_interesting_errno = ENOENT; static struct strbuf buf = STRBUF_INIT; prepare_alt_odb(r); - for (odb = r->objects->odb; odb; odb = odb->next) { - *path = odb_loose_path(odb, &buf, oid); + for (source = r->objects->sources; source; source = source->next) { + *path = odb_loose_path(source, &buf, oid); fd = git_open(*path); if (fd >= 0) return fd; @@ -244,11 +244,11 @@ static int open_loose_object(struct repository *r, static int quick_has_loose(struct repository *r, const struct object_id *oid) { - struct object_directory *odb; + struct odb_source *source; prepare_alt_odb(r); - for (odb = r->objects->odb; odb; odb = odb->next) { - if (oidtree_contains(odb_loose_cache(odb, oid), oid)) + for (source = r->objects->sources; source; source = source->next) { + if (oidtree_contains(odb_loose_cache(source, oid), oid)) return 1; } return 0; @@ -694,7 +694,7 @@ void hash_object_file(const struct git_hash_algo *algo, const void *buf, /* Finalize a file on disk, and close it. */ static void close_loose_object(int fd, const char *filename) { - if (the_repository->objects->odb->will_destroy) + if (the_repository->objects->sources->will_destroy) goto out; if (batch_fsync_enabled(FSYNC_COMPONENT_LOOSE_OBJECT)) @@ -876,7 +876,7 @@ static int write_loose_object(const struct object_id *oid, char *hdr, if (batch_fsync_enabled(FSYNC_COMPONENT_LOOSE_OBJECT)) prepare_loose_object_bulk_checkin(); - odb_loose_path(the_repository->objects->odb, &filename, oid); + odb_loose_path(the_repository->objects->sources, &filename, oid); fd = start_loose_object_common(&tmp_file, filename.buf, flags, &stream, compressed, sizeof(compressed), @@ -1023,7 +1023,7 @@ int stream_loose_object(struct input_stream *in_stream, size_t len, goto cleanup; } - odb_loose_path(the_repository->objects->odb, &filename, oid); + odb_loose_path(the_repository->objects->sources, &filename, oid); /* We finally know the object path, and create the missing dir. */ dirlen = directory_size(filename.buf); @@ -1437,11 +1437,11 @@ int for_each_loose_file_in_objdir(const char *path, int for_each_loose_object(each_loose_object_fn cb, void *data, enum for_each_object_flags flags) { - struct object_directory *odb; + struct odb_source *source; prepare_alt_odb(the_repository); - for (odb = the_repository->objects->odb; odb; odb = odb->next) { - int r = for_each_loose_file_in_objdir(odb->path, cb, NULL, + for (source = the_repository->objects->sources; source; source = source->next) { + int r = for_each_loose_file_in_objdir(source->path, cb, NULL, NULL, data); if (r) return r; @@ -1461,43 +1461,43 @@ static int append_loose_object(const struct object_id *oid, return 0; } -struct oidtree *odb_loose_cache(struct object_directory *odb, - const struct object_id *oid) +struct oidtree *odb_loose_cache(struct odb_source *source, + const struct object_id *oid) { int subdir_nr = oid->hash[0]; struct strbuf buf = STRBUF_INIT; - size_t word_bits = bitsizeof(odb->loose_objects_subdir_seen[0]); + size_t word_bits = bitsizeof(source->loose_objects_subdir_seen[0]); size_t word_index = subdir_nr / word_bits; size_t mask = (size_t)1u << (subdir_nr % word_bits); uint32_t *bitmap; if (subdir_nr < 0 || - subdir_nr >= bitsizeof(odb->loose_objects_subdir_seen)) + subdir_nr >= bitsizeof(source->loose_objects_subdir_seen)) BUG("subdir_nr out of range"); - bitmap = &odb->loose_objects_subdir_seen[word_index]; + bitmap = &source->loose_objects_subdir_seen[word_index]; if (*bitmap & mask) - return odb->loose_objects_cache; - if (!odb->loose_objects_cache) { - ALLOC_ARRAY(odb->loose_objects_cache, 1); - oidtree_init(odb->loose_objects_cache); + return source->loose_objects_cache; + if (!source->loose_objects_cache) { + ALLOC_ARRAY(source->loose_objects_cache, 1); + oidtree_init(source->loose_objects_cache); } - strbuf_addstr(&buf, odb->path); + strbuf_addstr(&buf, source->path); for_each_file_in_obj_subdir(subdir_nr, &buf, append_loose_object, NULL, NULL, - odb->loose_objects_cache); + source->loose_objects_cache); *bitmap |= mask; strbuf_release(&buf); - return odb->loose_objects_cache; + return source->loose_objects_cache; } -void odb_clear_loose_cache(struct object_directory *odb) +void odb_clear_loose_cache(struct odb_source *source) { - oidtree_clear(odb->loose_objects_cache); - FREE_AND_NULL(odb->loose_objects_cache); - memset(&odb->loose_objects_subdir_seen, 0, - sizeof(odb->loose_objects_subdir_seen)); + oidtree_clear(source->loose_objects_cache); + FREE_AND_NULL(source->loose_objects_cache); + memset(&source->loose_objects_subdir_seen, 0, + sizeof(source->loose_objects_subdir_seen)); } static int check_stream_oid(git_zstream *stream, diff --git a/object-file.h b/object-file.h index 6f411424523932..9a18859b2e0c9d 100644 --- a/object-file.h +++ b/object-file.h @@ -24,23 +24,23 @@ enum { int index_fd(struct index_state *istate, struct object_id *oid, int fd, struct stat *st, enum object_type type, const char *path, unsigned flags); int index_path(struct index_state *istate, struct object_id *oid, const char *path, struct stat *st, unsigned flags); -struct object_directory; +struct odb_source; /* * Populate and return the loose object cache array corresponding to the * given object ID. */ -struct oidtree *odb_loose_cache(struct object_directory *odb, +struct oidtree *odb_loose_cache(struct odb_source *source, const struct object_id *oid); /* Empty the loose object cache for the specified object directory. */ -void odb_clear_loose_cache(struct object_directory *odb); +void odb_clear_loose_cache(struct odb_source *source); /* * Put in `buf` the name of the file in the local object database that * would be used to store a loose object with the specified oid. */ -const char *odb_loose_path(struct object_directory *odb, +const char *odb_loose_path(struct odb_source *source, struct strbuf *buf, const struct object_id *oid); diff --git a/object-name.c b/object-name.c index 9288b2dd2453a0..544634d0f409f4 100644 --- a/object-name.c +++ b/object-name.c @@ -112,10 +112,10 @@ static enum cb_next match_prefix(const struct object_id *oid, void *arg) static void find_short_object_filename(struct disambiguate_state *ds) { - struct object_directory *odb; + struct odb_source *source; - for (odb = ds->repo->objects->odb; odb && !ds->ambiguous; odb = odb->next) - oidtree_each(odb_loose_cache(odb, &ds->bin_pfx), + for (source = ds->repo->objects->sources; source && !ds->ambiguous; source = source->next) + oidtree_each(odb_loose_cache(source, &ds->bin_pfx), &ds->bin_pfx, ds->len, match_prefix, ds); } diff --git a/object-store.c b/object-store.c index f4e8f99d90f1b2..5c04a1018f7c7a 100644 --- a/object-store.c +++ b/object-store.c @@ -27,7 +27,7 @@ #include "write-or-die.h" KHASH_INIT(odb_path_map, const char * /* key: odb_path */, - struct object_directory *, 1, fspathhash, fspatheq) + struct odb_source *, 1, fspathhash, fspatheq) /* * This is meant to hold a *small* number of objects that you would @@ -104,18 +104,18 @@ static int alt_odb_usable(struct object_database *o, * Prevent the common mistake of listing the same * thing twice, or object directory itself. */ - if (!o->odb_by_path) { + if (!o->source_by_path) { khiter_t p; - o->odb_by_path = kh_init_odb_path_map(); - assert(!o->odb->next); - p = kh_put_odb_path_map(o->odb_by_path, o->odb->path, &r); + o->source_by_path = kh_init_odb_path_map(); + assert(!o->sources->next); + p = kh_put_odb_path_map(o->source_by_path, o->sources->path, &r); assert(r == 1); /* never used */ - kh_value(o->odb_by_path, p) = o->odb; + kh_value(o->source_by_path, p) = o->sources; } if (fspatheq(path->buf, normalized_objdir)) return 0; - *pos = kh_put_odb_path_map(o->odb_by_path, path->buf, &r); + *pos = kh_put_odb_path_map(o->source_by_path, path->buf, &r); /* r: 0 = exists, 1 = never used, 2 = deleted */ return r == 0 ? 0 : 1; } @@ -124,7 +124,7 @@ static int alt_odb_usable(struct object_database *o, * Prepare alternate object database registry. * * The variable alt_odb_list points at the list of struct - * object_directory. The elements on this list come from + * odb_source. The elements on this list come from * non-empty elements from colon separated ALTERNATE_DB_ENVIRONMENT * environment variable, and $GIT_OBJECT_DIRECTORY/info/alternates, * whose contents is similar to that environment variable but can be @@ -141,7 +141,7 @@ static void read_info_alternates(struct repository *r, static int link_alt_odb_entry(struct repository *r, const struct strbuf *entry, const char *relative_base, int depth, const char *normalized_objdir) { - struct object_directory *ent; + struct odb_source *alternate; struct strbuf pathbuf = STRBUF_INIT; struct strbuf tmp = STRBUF_INIT; khiter_t pos; @@ -170,19 +170,19 @@ static int link_alt_odb_entry(struct repository *r, const struct strbuf *entry, if (!alt_odb_usable(r->objects, &pathbuf, normalized_objdir, &pos)) goto error; - CALLOC_ARRAY(ent, 1); - /* pathbuf.buf is already in r->objects->odb_by_path */ - ent->path = strbuf_detach(&pathbuf, NULL); + CALLOC_ARRAY(alternate, 1); + /* pathbuf.buf is already in r->objects->source_by_path */ + alternate->path = strbuf_detach(&pathbuf, NULL); /* add the alternate entry */ - *r->objects->odb_tail = ent; - r->objects->odb_tail = &(ent->next); - ent->next = NULL; - assert(r->objects->odb_by_path); - kh_value(r->objects->odb_by_path, pos) = ent; + *r->objects->sources_tail = alternate; + r->objects->sources_tail = &(alternate->next); + alternate->next = NULL; + assert(r->objects->source_by_path); + kh_value(r->objects->source_by_path, pos) = alternate; /* recursively add alternates */ - read_info_alternates(r, ent->path, depth + 1); + read_info_alternates(r, alternate->path, depth + 1); ret = 0; error: strbuf_release(&tmp); @@ -234,7 +234,7 @@ static void link_alt_odb_entries(struct repository *r, const char *alt, return; } - strbuf_realpath(&objdirbuf, r->objects->odb->path, 1); + strbuf_realpath(&objdirbuf, r->objects->sources->path, 1); while (*alt) { alt = parse_alt_odb_entry(alt, sep, &entry); @@ -321,9 +321,9 @@ void add_to_alternates_memory(const char *reference) '\n', NULL, 0); } -struct object_directory *set_temporary_primary_odb(const char *dir, int will_destroy) +struct odb_source *set_temporary_primary_odb(const char *dir, int will_destroy) { - struct object_directory *new_odb; + struct odb_source *source; /* * Make sure alternates are initialized, or else our entry may be @@ -335,41 +335,41 @@ struct object_directory *set_temporary_primary_odb(const char *dir, int will_des * Make a new primary odb and link the old primary ODB in as an * alternate */ - new_odb = xcalloc(1, sizeof(*new_odb)); - new_odb->path = xstrdup(dir); + source = xcalloc(1, sizeof(*source)); + source->path = xstrdup(dir); /* * Disable ref updates while a temporary odb is active, since * the objects in the database may roll back. */ - new_odb->disable_ref_updates = 1; - new_odb->will_destroy = will_destroy; - new_odb->next = the_repository->objects->odb; - the_repository->objects->odb = new_odb; - return new_odb->next; + source->disable_ref_updates = 1; + source->will_destroy = will_destroy; + source->next = the_repository->objects->sources; + the_repository->objects->sources = source; + return source->next; } -static void free_object_directory(struct object_directory *odb) +static void free_object_directory(struct odb_source *source) { - free(odb->path); - odb_clear_loose_cache(odb); - loose_object_map_clear(&odb->loose_map); - free(odb); + free(source->path); + odb_clear_loose_cache(source); + loose_object_map_clear(&source->loose_map); + free(source); } -void restore_primary_odb(struct object_directory *restore_odb, const char *old_path) +void restore_primary_odb(struct odb_source *restore_alt, const char *old_path) { - struct object_directory *cur_odb = the_repository->objects->odb; + struct odb_source *cur_alt = the_repository->objects->sources; - if (strcmp(old_path, cur_odb->path)) + if (strcmp(old_path, cur_alt->path)) BUG("expected %s as primary object store; found %s", - old_path, cur_odb->path); + old_path, cur_alt->path); - if (cur_odb->next != restore_odb) + if (cur_alt->next != restore_alt) BUG("we expect the old primary object store to be the first alternate"); - the_repository->objects->odb = restore_odb; - free_object_directory(cur_odb); + the_repository->objects->sources = restore_alt; + free_object_directory(cur_alt); } /* @@ -442,15 +442,15 @@ char *compute_alternate_path(const char *path, struct strbuf *err) return ref_git; } -struct object_directory *find_odb(struct repository *r, const char *obj_dir) +struct odb_source *find_odb(struct repository *r, const char *obj_dir) { - struct object_directory *odb; + struct odb_source *source; char *obj_dir_real = real_pathdup(obj_dir, 1); struct strbuf odb_path_real = STRBUF_INIT; prepare_alt_odb(r); - for (odb = r->objects->odb; odb; odb = odb->next) { - strbuf_realpath(&odb_path_real, odb->path, 1); + for (source = r->objects->sources; source; source = source->next) { + strbuf_realpath(&odb_path_real, source->path, 1); if (!strcmp(obj_dir_real, odb_path_real.buf)) break; } @@ -458,9 +458,9 @@ struct object_directory *find_odb(struct repository *r, const char *obj_dir) free(obj_dir_real); strbuf_release(&odb_path_real); - if (!odb) + if (!source) die(_("could not find object directory matching %s"), obj_dir); - return odb; + return source; } static void fill_alternate_refs_command(struct child_process *cmd, @@ -527,14 +527,14 @@ struct alternate_refs_data { void *data; }; -static int refs_from_alternate_cb(struct object_directory *e, +static int refs_from_alternate_cb(struct odb_source *alternate, void *data) { struct strbuf path = STRBUF_INIT; size_t base_len; struct alternate_refs_data *cb = data; - if (!strbuf_realpath(&path, e->path, 0)) + if (!strbuf_realpath(&path, alternate->path, 0)) goto out; if (!strbuf_strip_suffix(&path, "/objects")) goto out; @@ -563,12 +563,12 @@ void for_each_alternate_ref(alternate_ref_fn fn, void *data) int foreach_alt_odb(alt_odb_fn fn, void *cb) { - struct object_directory *ent; + struct odb_source *alternate; int r = 0; prepare_alt_odb(the_repository); - for (ent = the_repository->objects->odb->next; ent; ent = ent->next) { - r = fn(ent, cb); + for (alternate = the_repository->objects->sources->next; alternate; alternate = alternate->next) { + r = fn(alternate, cb); if (r) break; } @@ -582,14 +582,14 @@ void prepare_alt_odb(struct repository *r) link_alt_odb_entries(r, r->objects->alternate_db, PATH_SEP, NULL, 0); - read_info_alternates(r, r->objects->odb->path, 0); + read_info_alternates(r, r->objects->sources->path, 0); r->objects->loaded_alternates = 1; } int has_alt_odb(struct repository *r) { prepare_alt_odb(r); - return !!r->objects->odb->next; + return !!r->objects->sources->next; } int obj_read_use_lock = 0; @@ -963,15 +963,15 @@ struct object_database *odb_new(void) static void free_object_directories(struct object_database *o) { - while (o->odb) { - struct object_directory *next; + while (o->sources) { + struct odb_source *next; - next = o->odb->next; - free_object_directory(o->odb); - o->odb = next; + next = o->sources->next; + free_object_directory(o->sources); + o->sources = next; } - kh_destroy_odb_path_map(o->odb_by_path); - o->odb_by_path = NULL; + kh_destroy_odb_path_map(o->source_by_path); + o->source_by_path = NULL; } void odb_clear(struct object_database *o) @@ -986,7 +986,7 @@ void odb_clear(struct object_database *o) o->commit_graph_attempted = 0; free_object_directories(o); - o->odb_tail = NULL; + o->sources_tail = NULL; o->loaded_alternates = 0; for (size_t i = 0; i < o->cached_object_nr; i++) diff --git a/object-store.h b/object-store.h index a3be27d1171842..d199d757d7620c 100644 --- a/object-store.h +++ b/object-store.h @@ -13,8 +13,20 @@ struct oidtree; struct strbuf; struct repository; -struct object_directory { - struct object_directory *next; +/* + * The source is the part of the object database that stores the actual + * objects. It thus encapsulates the logic to read and write the specific + * on-disk format. An object database can have multiple sources: + * + * - The primary source, which is typically located in "$GIT_DIR/objects". + * This is where new objects are usually written to. + * + * - Alternate sources, which are configured via "objects/info/alternates" or + * via the GIT_ALTERNATE_OBJECT_DIRECTORIES environment variable. These + * alternate sources are only used to read objects. + */ +struct odb_source { + struct odb_source *next; /* * Used to store the results of readdir(3) calls when we are OK @@ -44,8 +56,8 @@ struct object_directory { int will_destroy; /* - * Path to the alternative object store. If this is a relative path, - * it is relative to the current working directory. + * Path to the source. If this is a relative path, it is relative to + * the current working directory. */ char *path; }; @@ -53,8 +65,8 @@ struct object_directory { void prepare_alt_odb(struct repository *r); int has_alt_odb(struct repository *r); char *compute_alternate_path(const char *path, struct strbuf *err); -struct object_directory *find_odb(struct repository *r, const char *obj_dir); -typedef int alt_odb_fn(struct object_directory *, void *); +struct odb_source *find_odb(struct repository *r, const char *obj_dir); +typedef int alt_odb_fn(struct odb_source *, void *); int foreach_alt_odb(alt_odb_fn, void*); typedef void alternate_ref_fn(const struct object_id *oid, void *); void for_each_alternate_ref(alternate_ref_fn, void *); @@ -76,12 +88,12 @@ void add_to_alternates_memory(const char *dir); * Replace the current writable object directory with the specified temporary * object directory; returns the former primary object directory. */ -struct object_directory *set_temporary_primary_odb(const char *dir, int will_destroy); +struct odb_source *set_temporary_primary_odb(const char *dir, int will_destroy); /* * Restore a previous ODB replaced by set_temporary_main_odb. */ -void restore_primary_odb(struct object_directory *restore_odb, const char *old_path); +void restore_primary_odb(struct odb_source *restore_alternate, const char *old_path); struct packed_git; struct multi_pack_index; @@ -89,7 +101,7 @@ struct cached_object_entry; /* * The object database encapsulates access to objects in a repository. It - * manages one or more backends that store the actual objects which are + * manages one or more sources that store the actual objects which are * configured via alternates. */ struct object_database { @@ -98,16 +110,16 @@ struct object_database { * cannot be NULL after initialization). Subsequent directories are * alternates. */ - struct object_directory *odb; - struct object_directory **odb_tail; - struct kh_odb_path_map *odb_by_path; + struct odb_source *sources; + struct odb_source **sources_tail; + struct kh_odb_path_map *source_by_path; int loaded_alternates; /* * A list of alternate object directories loaded from the environment; * this should not generally need to be accessed directly, but will - * populate the "odb" list when prepare_alt_odb() is run. + * populate the "sources" list when prepare_alt_odb() is run. */ char *alternate_db; diff --git a/packfile.c b/packfile.c index c735b4d013547d..60661ad00951f4 100644 --- a/packfile.c +++ b/packfile.c @@ -1029,16 +1029,16 @@ static void prepare_packed_git_mru(struct repository *r) static void prepare_packed_git(struct repository *r) { - struct object_directory *odb; + struct odb_source *source; if (r->objects->packed_git_initialized) return; prepare_alt_odb(r); - for (odb = r->objects->odb; odb; odb = odb->next) { - int local = (odb == r->objects->odb); - prepare_multi_pack_index_one(r, odb->path, local); - prepare_packed_git_one(r, odb->path, local); + for (source = r->objects->sources; source; source = source->next) { + int local = (source == r->objects->sources); + prepare_multi_pack_index_one(r, source->path, local); + prepare_packed_git_one(r, source->path, local); } rearrange_packed_git(r); @@ -1048,7 +1048,7 @@ static void prepare_packed_git(struct repository *r) void reprepare_packed_git(struct repository *r) { - struct object_directory *odb; + struct odb_source *source; obj_read_lock(); @@ -1061,8 +1061,8 @@ void reprepare_packed_git(struct repository *r) r->objects->loaded_alternates = 0; prepare_alt_odb(r); - for (odb = r->objects->odb; odb; odb = odb->next) - odb_clear_loose_cache(odb); + for (source = r->objects->sources; source; source = source->next) + odb_clear_loose_cache(source); r->objects->approximate_object_count_valid = 0; r->objects->packed_git_initialized = 0; diff --git a/path.c b/path.c index 3b598b2847ff03..c347829aa667cc 100644 --- a/path.c +++ b/path.c @@ -397,7 +397,7 @@ static void adjust_git_path(struct repository *repo, strbuf_splice(buf, 0, buf->len, repo->index_file, strlen(repo->index_file)); else if (dir_prefix(base, "objects")) - replace_dir(buf, git_dir_len + 7, repo->objects->odb->path); + replace_dir(buf, git_dir_len + 7, repo->objects->sources->path); else if (repo_settings_get_hooks_path(repo) && dir_prefix(base, "hooks")) replace_dir(buf, git_dir_len + 5, repo_settings_get_hooks_path(repo)); else if (repo->different_commondir) diff --git a/refs.c b/refs.c index dce5c49ca2ba65..5f6a386cc93bf9 100644 --- a/refs.c +++ b/refs.c @@ -2477,7 +2477,7 @@ int ref_transaction_prepare(struct ref_transaction *transaction, break; } - if (refs->repo->objects->odb->disable_ref_updates) { + if (refs->repo->objects->sources->disable_ref_updates) { strbuf_addstr(err, _("ref updates forbidden inside quarantine environment")); return -1; diff --git a/repository.c b/repository.c index 07757e6e0c90d7..7528beccddf136 100644 --- a/repository.c +++ b/repository.c @@ -107,9 +107,9 @@ const char *repo_get_common_dir(struct repository *repo) const char *repo_get_object_directory(struct repository *repo) { - if (!repo->objects->odb) + if (!repo->objects->sources) BUG("repository hasn't been set up"); - return repo->objects->odb->path; + return repo->objects->sources->path; } const char *repo_get_index_file(struct repository *repo) @@ -165,14 +165,14 @@ void repo_set_gitdir(struct repository *repo, repo_set_commondir(repo, o->commondir); - if (!repo->objects->odb) { - CALLOC_ARRAY(repo->objects->odb, 1); - repo->objects->odb_tail = &repo->objects->odb->next; + if (!repo->objects->sources) { + CALLOC_ARRAY(repo->objects->sources, 1); + repo->objects->sources_tail = &repo->objects->sources->next; } - expand_base_dir(&repo->objects->odb->path, o->object_dir, + expand_base_dir(&repo->objects->sources->path, o->object_dir, repo->commondir, "objects"); - repo->objects->odb->disable_ref_updates = o->disable_ref_updates; + repo->objects->sources->disable_ref_updates = o->disable_ref_updates; free(repo->objects->alternate_db); repo->objects->alternate_db = xstrdup_or_null(o->alternate_db); diff --git a/submodule-config.c b/submodule-config.c index 8630e27947d394..b30d9365fbdb9b 100644 --- a/submodule-config.c +++ b/submodule-config.c @@ -810,7 +810,7 @@ static void config_from_gitmodules(config_fn_t fn, struct repository *repo, void repo_get_oid(repo, GITMODULES_HEAD, &oid) >= 0) { config_source.blob = oidstr = xstrdup(oid_to_hex(&oid)); if (repo != the_repository) - add_submodule_odb_by_path(repo->objects->odb->path); + add_submodule_odb_by_path(repo->objects->sources->path); } else { goto out; } diff --git a/t/helper/test-read-graph.c b/t/helper/test-read-graph.c index 8b413b644be677..53b633e2ba6690 100644 --- a/t/helper/test-read-graph.c +++ b/t/helper/test-read-graph.c @@ -73,15 +73,15 @@ static void dump_graph_bloom_filters(struct commit_graph *graph) int cmd__read_graph(int argc, const char **argv) { struct commit_graph *graph = NULL; - struct object_directory *odb; + struct odb_source *source; int ret = 0; setup_git_directory(); - odb = the_repository->objects->odb; + source = the_repository->objects->sources; prepare_repo_settings(the_repository); - graph = read_commit_graph_one(the_repository, odb); + graph = read_commit_graph_one(the_repository, source); if (!graph) { ret = 1; goto done; diff --git a/tmp-objdir.c b/tmp-objdir.c index c38fbeb5e8aa3a..056484404be0bf 100644 --- a/tmp-objdir.c +++ b/tmp-objdir.c @@ -17,7 +17,7 @@ struct tmp_objdir { struct repository *repo; struct strbuf path; struct strvec env; - struct object_directory *prev_odb; + struct odb_source *prev_source; int will_destroy; }; @@ -46,8 +46,8 @@ int tmp_objdir_destroy(struct tmp_objdir *t) if (t == the_tmp_objdir) the_tmp_objdir = NULL; - if (t->prev_odb) - restore_primary_odb(t->prev_odb, t->path.buf); + if (t->prev_source) + restore_primary_odb(t->prev_source, t->path.buf); err = remove_dir_recursively(&t->path, 0); @@ -276,11 +276,11 @@ int tmp_objdir_migrate(struct tmp_objdir *t) if (!t) return 0; - if (t->prev_odb) { - if (t->repo->objects->odb->will_destroy) + if (t->prev_source) { + if (t->repo->objects->sources->will_destroy) BUG("migrating an ODB that was marked for destruction"); - restore_primary_odb(t->prev_odb, t->path.buf); - t->prev_odb = NULL; + restore_primary_odb(t->prev_source, t->path.buf); + t->prev_source = NULL; } strbuf_addbuf(&src, &t->path); @@ -309,19 +309,19 @@ void tmp_objdir_add_as_alternate(const struct tmp_objdir *t) void tmp_objdir_replace_primary_odb(struct tmp_objdir *t, int will_destroy) { - if (t->prev_odb) + if (t->prev_source) BUG("the primary object database is already replaced"); - t->prev_odb = set_temporary_primary_odb(t->path.buf, will_destroy); + t->prev_source = set_temporary_primary_odb(t->path.buf, will_destroy); t->will_destroy = will_destroy; } struct tmp_objdir *tmp_objdir_unapply_primary_odb(void) { - if (!the_tmp_objdir || !the_tmp_objdir->prev_odb) + if (!the_tmp_objdir || !the_tmp_objdir->prev_source) return NULL; - restore_primary_odb(the_tmp_objdir->prev_odb, the_tmp_objdir->path.buf); - the_tmp_objdir->prev_odb = NULL; + restore_primary_odb(the_tmp_objdir->prev_source, the_tmp_objdir->path.buf); + the_tmp_objdir->prev_source = NULL; return the_tmp_objdir; } From 8f49151763cb81adf4bcec53c1ae67057081b02d Mon Sep 17 00:00:00 2001 From: Patrick Steinhardt Date: Tue, 1 Jul 2025 14:22:15 +0200 Subject: [PATCH 06/21] object-store: rename files to "odb.{c,h}" In the preceding commits we have renamed the structures contained in "object-store.h" to `struct object_database` and `struct odb_backend`. As such, the code files "object-store.{c,h}" are confusingly named now. Rename them to "odb.{c,h}" accordingly. Signed-off-by: Patrick Steinhardt Signed-off-by: Junio C Hamano --- Makefile | 2 +- apply.c | 2 +- archive-tar.c | 2 +- archive-zip.c | 2 +- archive.c | 2 +- attr.c | 2 +- bisect.c | 2 +- blame.c | 2 +- builtin/backfill.c | 2 +- builtin/blame.c | 2 +- builtin/cat-file.c | 2 +- builtin/checkout.c | 2 +- builtin/clone.c | 2 +- builtin/commit-graph.c | 2 +- builtin/commit-tree.c | 2 +- builtin/describe.c | 2 +- builtin/difftool.c | 2 +- builtin/fast-export.c | 2 +- builtin/fast-import.c | 2 +- builtin/fetch.c | 2 +- builtin/fsck.c | 2 +- builtin/grep.c | 2 +- builtin/hash-object.c | 2 +- builtin/index-pack.c | 2 +- builtin/log.c | 2 +- builtin/ls-files.c | 2 +- builtin/ls-tree.c | 2 +- builtin/merge-file.c | 2 +- builtin/merge-tree.c | 2 +- builtin/mktag.c | 2 +- builtin/mktree.c | 2 +- builtin/multi-pack-index.c | 2 +- builtin/notes.c | 2 +- builtin/pack-objects.c | 2 +- builtin/pack-redundant.c | 2 +- builtin/prune.c | 2 +- builtin/receive-pack.c | 2 +- builtin/remote.c | 2 +- builtin/repack.c | 2 +- builtin/replace.c | 2 +- builtin/rev-list.c | 2 +- builtin/show-ref.c | 2 +- builtin/submodule--helper.c | 2 +- builtin/tag.c | 2 +- builtin/unpack-file.c | 2 +- builtin/unpack-objects.c | 2 +- bulk-checkin.c | 2 +- bundle-uri.c | 2 +- bundle.c | 2 +- cache-tree.c | 2 +- combine-diff.c | 2 +- commit-graph.c | 2 +- commit-graph.h | 2 +- commit.c | 2 +- config.c | 2 +- connected.c | 2 +- contrib/coccinelle/the_repository.cocci | 2 +- diagnose.c | 2 +- diff.c | 2 +- entry.c | 2 +- fetch-pack.c | 2 +- fmt-merge-msg.c | 2 +- fsck.c | 2 +- grep.c | 2 +- http-backend.c | 2 +- http-push.c | 2 +- http-walker.c | 2 +- http.c | 2 +- list-objects-filter.c | 2 +- list-objects.c | 2 +- loose.c | 2 +- mailmap.c | 2 +- match-trees.c | 2 +- merge-blobs.c | 2 +- merge-ort.c | 2 +- meson.build | 2 +- notes-cache.c | 2 +- notes-merge.c | 2 +- notes.c | 2 +- object-file.c | 2 +- object-file.h | 2 +- object-store.c => odb.c | 2 +- object-store.h => odb.h | 6 +++--- oss-fuzz/fuzz-pack-idx.c | 2 +- pack-bitmap-write.c | 2 +- pack-bitmap.c | 2 +- pack-check.c | 2 +- pack-mtimes.c | 2 +- pack-objects.h | 2 +- pack-revindex.c | 2 +- packfile.c | 2 +- packfile.h | 4 ++-- path.c | 2 +- promisor-remote.c | 2 +- protocol-caps.c | 2 +- read-cache.c | 2 +- ref-filter.c | 2 +- reflog.c | 2 +- refs.c | 2 +- remote.c | 2 +- replace-object.c | 2 +- replace-object.h | 2 +- repository.c | 2 +- rerere.c | 2 +- revision.c | 2 +- send-pack.c | 2 +- sequencer.c | 2 +- server-info.c | 2 +- shallow.c | 2 +- streaming.c | 2 +- submodule-config.c | 2 +- submodule.c | 2 +- t/helper/test-find-pack.c | 2 +- t/helper/test-pack-mtimes.c | 2 +- t/helper/test-partial-clone.c | 2 +- t/helper/test-read-graph.c | 2 +- t/helper/test-read-midx.c | 2 +- t/helper/test-ref-store.c | 2 +- tag.c | 2 +- tmp-objdir.c | 2 +- tree-walk.c | 2 +- tree.c | 2 +- unpack-trees.c | 2 +- upload-pack.c | 2 +- walker.c | 2 +- xdiff-interface.c | 2 +- 126 files changed, 129 insertions(+), 129 deletions(-) rename object-store.c => odb.c (99%) rename object-store.h => odb.h (99%) diff --git a/Makefile b/Makefile index 70d1543b6b8688..4b1bf8977913f4 100644 --- a/Makefile +++ b/Makefile @@ -1085,8 +1085,8 @@ LIB_OBJS += notes.o LIB_OBJS += object-file-convert.o LIB_OBJS += object-file.o LIB_OBJS += object-name.o -LIB_OBJS += object-store.o LIB_OBJS += object.o +LIB_OBJS += odb.o LIB_OBJS += oid-array.o LIB_OBJS += oidmap.o LIB_OBJS += oidset.o diff --git a/apply.c b/apply.c index 8bbe6ed224032e..e778b4e911de98 100644 --- a/apply.c +++ b/apply.c @@ -14,7 +14,7 @@ #include "abspath.h" #include "base85.h" #include "config.h" -#include "object-store.h" +#include "odb.h" #include "delta.h" #include "diff.h" #include "dir.h" diff --git a/archive-tar.c b/archive-tar.c index 282b48196f9810..249164ea77dc04 100644 --- a/archive-tar.c +++ b/archive-tar.c @@ -11,7 +11,7 @@ #include "hex.h" #include "tar.h" #include "archive.h" -#include "object-store.h" +#include "odb.h" #include "strbuf.h" #include "streaming.h" #include "run-command.h" diff --git a/archive-zip.c b/archive-zip.c index 405da6f3d83004..df8866d5bae28a 100644 --- a/archive-zip.c +++ b/archive-zip.c @@ -12,7 +12,7 @@ #include "hex.h" #include "streaming.h" #include "utf8.h" -#include "object-store.h" +#include "odb.h" #include "strbuf.h" #include "userdiff.h" #include "write-or-die.h" diff --git a/archive.c b/archive.c index 8309ea213e6ea0..7fa2cc2596a50e 100644 --- a/archive.c +++ b/archive.c @@ -14,7 +14,7 @@ #include "pretty.h" #include "setup.h" #include "refs.h" -#include "object-store.h" +#include "odb.h" #include "commit.h" #include "tree.h" #include "tree-walk.h" diff --git a/attr.c b/attr.c index 86b6109fc4e328..e5680db7f65080 100644 --- a/attr.c +++ b/attr.c @@ -22,7 +22,7 @@ #include "read-cache-ll.h" #include "refs.h" #include "revision.h" -#include "object-store.h" +#include "odb.h" #include "setup.h" #include "thread-utils.h" #include "tree-walk.h" diff --git a/bisect.c b/bisect.c index a327468c75bbcd..a7939216d00eaf 100644 --- a/bisect.c +++ b/bisect.c @@ -20,7 +20,7 @@ #include "commit-slab.h" #include "commit-reach.h" #include "object-name.h" -#include "object-store.h" +#include "odb.h" #include "path.h" #include "dir.h" diff --git a/blame.c b/blame.c index 57daa45e8996e8..0ceea080a80cb2 100644 --- a/blame.c +++ b/blame.c @@ -3,7 +3,7 @@ #include "git-compat-util.h" #include "refs.h" -#include "object-store.h" +#include "odb.h" #include "cache-tree.h" #include "mergesort.h" #include "commit.h" diff --git a/builtin/backfill.c b/builtin/backfill.c index fa82ad2f6ff0b1..0b49baa39fa5c8 100644 --- a/builtin/backfill.c +++ b/builtin/backfill.c @@ -13,7 +13,7 @@ #include "tree.h" #include "tree-walk.h" #include "object.h" -#include "object-store.h" +#include "odb.h" #include "oid-array.h" #include "oidset.h" #include "promisor-remote.h" diff --git a/builtin/blame.c b/builtin/blame.c index 944952e30ebaac..15eda60af904e0 100644 --- a/builtin/blame.c +++ b/builtin/blame.c @@ -28,7 +28,7 @@ #include "line-log.h" #include "progress.h" #include "object-name.h" -#include "object-store.h" +#include "odb.h" #include "pager.h" #include "blame.h" #include "refs.h" diff --git a/builtin/cat-file.c b/builtin/cat-file.c index 67a5ff2b9ebd29..f3a925a8183c28 100644 --- a/builtin/cat-file.c +++ b/builtin/cat-file.c @@ -24,7 +24,7 @@ #include "pack-bitmap.h" #include "object-file.h" #include "object-name.h" -#include "object-store.h" +#include "odb.h" #include "replace-object.h" #include "promisor-remote.h" #include "mailmap.h" diff --git a/builtin/checkout.c b/builtin/checkout.c index d185982f3a6372..e7dd66173dd0bb 100644 --- a/builtin/checkout.c +++ b/builtin/checkout.c @@ -20,7 +20,7 @@ #include "merge-ort-wrappers.h" #include "object-file.h" #include "object-name.h" -#include "object-store.h" +#include "odb.h" #include "parse-options.h" #include "path.h" #include "preload-index.h" diff --git a/builtin/clone.c b/builtin/clone.c index 91b9cd0d164198..1eafeefb48d1fc 100644 --- a/builtin/clone.c +++ b/builtin/clone.c @@ -25,7 +25,7 @@ #include "refs.h" #include "refspec.h" #include "object-file.h" -#include "object-store.h" +#include "odb.h" #include "tree.h" #include "tree-walk.h" #include "unpack-trees.h" diff --git a/builtin/commit-graph.c b/builtin/commit-graph.c index 98a84315342994..f04eaba5259343 100644 --- a/builtin/commit-graph.c +++ b/builtin/commit-graph.c @@ -6,7 +6,7 @@ #include "hex.h" #include "parse-options.h" #include "commit-graph.h" -#include "object-store.h" +#include "odb.h" #include "progress.h" #include "replace-object.h" #include "strbuf.h" diff --git a/builtin/commit-tree.c b/builtin/commit-tree.c index ad6b2c9320931d..546069f8682027 100644 --- a/builtin/commit-tree.c +++ b/builtin/commit-tree.c @@ -9,7 +9,7 @@ #include "gettext.h" #include "hex.h" #include "object-name.h" -#include "object-store.h" +#include "odb.h" #include "commit.h" #include "parse-options.h" diff --git a/builtin/describe.c b/builtin/describe.c index 2d50883b729671..96cb68e5e5d0e7 100644 --- a/builtin/describe.c +++ b/builtin/describe.c @@ -19,7 +19,7 @@ #include "setup.h" #include "strvec.h" #include "run-command.h" -#include "object-store.h" +#include "odb.h" #include "list-objects.h" #include "commit-slab.h" #include "wildmatch.h" diff --git a/builtin/difftool.c b/builtin/difftool.c index a3b64ce69426bf..fac613e3bc385a 100644 --- a/builtin/difftool.c +++ b/builtin/difftool.c @@ -30,7 +30,7 @@ #include "strbuf.h" #include "lockfile.h" #include "object-file.h" -#include "object-store.h" +#include "odb.h" #include "dir.h" #include "entry.h" #include "setup.h" diff --git a/builtin/fast-export.c b/builtin/fast-export.c index 37c01d6c6fe6cb..0505f289a94e16 100644 --- a/builtin/fast-export.c +++ b/builtin/fast-export.c @@ -14,7 +14,7 @@ #include "refs.h" #include "refspec.h" #include "object-file.h" -#include "object-store.h" +#include "odb.h" #include "commit.h" #include "object.h" #include "tag.h" diff --git a/builtin/fast-import.c b/builtin/fast-import.c index b2839c5f439b7b..52c792488e1379 100644 --- a/builtin/fast-import.c +++ b/builtin/fast-import.c @@ -24,7 +24,7 @@ #include "packfile.h" #include "object-file.h" #include "object-name.h" -#include "object-store.h" +#include "odb.h" #include "mem-pool.h" #include "commit-reach.h" #include "khash.h" diff --git a/builtin/fetch.c b/builtin/fetch.c index a890e2864d13d9..b842bc9c51bb1c 100644 --- a/builtin/fetch.c +++ b/builtin/fetch.c @@ -14,7 +14,7 @@ #include "refs.h" #include "refspec.h" #include "object-name.h" -#include "object-store.h" +#include "odb.h" #include "oidset.h" #include "oid-array.h" #include "commit.h" diff --git a/builtin/fsck.c b/builtin/fsck.c index 6e1474f63d59fd..9abd7b255808a0 100644 --- a/builtin/fsck.c +++ b/builtin/fsck.c @@ -17,7 +17,7 @@ #include "packfile.h" #include "object-file.h" #include "object-name.h" -#include "object-store.h" +#include "odb.h" #include "path.h" #include "read-cache-ll.h" #include "replace-object.h" diff --git a/builtin/grep.c b/builtin/grep.c index 76b1938bba5152..a1d7ee7af39687 100644 --- a/builtin/grep.c +++ b/builtin/grep.c @@ -26,7 +26,7 @@ #include "submodule-config.h" #include "object-file.h" #include "object-name.h" -#include "object-store.h" +#include "odb.h" #include "packfile.h" #include "pager.h" #include "path.h" diff --git a/builtin/hash-object.c b/builtin/hash-object.c index 6a99ec250d028f..e28f000221f618 100644 --- a/builtin/hash-object.c +++ b/builtin/hash-object.c @@ -11,7 +11,7 @@ #include "gettext.h" #include "hex.h" #include "object-file.h" -#include "object-store.h" +#include "odb.h" #include "blob.h" #include "quote.h" #include "parse-options.h" diff --git a/builtin/index-pack.c b/builtin/index-pack.c index bb7925bd29f0aa..1aabe6b8ee213f 100644 --- a/builtin/index-pack.c +++ b/builtin/index-pack.c @@ -21,7 +21,7 @@ #include "packfile.h" #include "pack-revindex.h" #include "object-file.h" -#include "object-store.h" +#include "odb.h" #include "oid-array.h" #include "oidset.h" #include "path.h" diff --git a/builtin/log.c b/builtin/log.c index b450cd3bde821b..fe9cc5ebecb231 100644 --- a/builtin/log.c +++ b/builtin/log.c @@ -15,7 +15,7 @@ #include "hex.h" #include "refs.h" #include "object-name.h" -#include "object-store.h" +#include "odb.h" #include "pager.h" #include "color.h" #include "commit.h" diff --git a/builtin/ls-files.c b/builtin/ls-files.c index be74f0a03b20f3..821339b07d4f3d 100644 --- a/builtin/ls-files.c +++ b/builtin/ls-files.c @@ -25,7 +25,7 @@ #include "setup.h" #include "sparse-index.h" #include "submodule.h" -#include "object-store.h" +#include "odb.h" #include "hex.h" diff --git a/builtin/ls-tree.c b/builtin/ls-tree.c index 8aafc30ca48f7a..62b6fd58c1655d 100644 --- a/builtin/ls-tree.c +++ b/builtin/ls-tree.c @@ -10,7 +10,7 @@ #include "gettext.h" #include "hex.h" #include "object-name.h" -#include "object-store.h" +#include "odb.h" #include "tree.h" #include "path.h" #include "quote.h" diff --git a/builtin/merge-file.c b/builtin/merge-file.c index 2b16b10d2cad1f..9464f2756299ec 100644 --- a/builtin/merge-file.c +++ b/builtin/merge-file.c @@ -7,7 +7,7 @@ #include "hex.h" #include "object-file.h" #include "object-name.h" -#include "object-store.h" +#include "odb.h" #include "config.h" #include "gettext.h" #include "setup.h" diff --git a/builtin/merge-tree.c b/builtin/merge-tree.c index 7f41665dfd7e67..b1a17787bcf913 100644 --- a/builtin/merge-tree.c +++ b/builtin/merge-tree.c @@ -10,7 +10,7 @@ #include "commit-reach.h" #include "merge-ort.h" #include "object-name.h" -#include "object-store.h" +#include "odb.h" #include "parse-options.h" #include "blob.h" #include "merge-blobs.h" diff --git a/builtin/mktag.c b/builtin/mktag.c index 7ac11c46d53f03..1809b38f937f3b 100644 --- a/builtin/mktag.c +++ b/builtin/mktag.c @@ -6,7 +6,7 @@ #include "strbuf.h" #include "replace-object.h" #include "object-file.h" -#include "object-store.h" +#include "odb.h" #include "fsck.h" #include "config.h" diff --git a/builtin/mktree.c b/builtin/mktree.c index 4b4780346751cb..016b0e5b224792 100644 --- a/builtin/mktree.c +++ b/builtin/mktree.c @@ -12,7 +12,7 @@ #include "tree.h" #include "parse-options.h" #include "object-file.h" -#include "object-store.h" +#include "odb.h" static struct treeent { unsigned mode; diff --git a/builtin/multi-pack-index.c b/builtin/multi-pack-index.c index f55bf53da838a5..aa25b06f9d0f89 100644 --- a/builtin/multi-pack-index.c +++ b/builtin/multi-pack-index.c @@ -7,7 +7,7 @@ #include "midx.h" #include "strbuf.h" #include "trace2.h" -#include "object-store.h" +#include "odb.h" #include "replace-object.h" #include "repository.h" diff --git a/builtin/notes.c b/builtin/notes.c index a3f433ca4c06fa..783d4932ca6efe 100644 --- a/builtin/notes.c +++ b/builtin/notes.c @@ -16,7 +16,7 @@ #include "notes.h" #include "object-file.h" #include "object-name.h" -#include "object-store.h" +#include "odb.h" #include "path.h" #include "pretty.h" diff --git a/builtin/pack-objects.c b/builtin/pack-objects.c index 8b33edc2ff525a..99b63cb0980218 100644 --- a/builtin/pack-objects.c +++ b/builtin/pack-objects.c @@ -32,7 +32,7 @@ #include "list.h" #include "packfile.h" #include "object-file.h" -#include "object-store.h" +#include "odb.h" #include "replace-object.h" #include "dir.h" #include "midx.h" diff --git a/builtin/pack-redundant.c b/builtin/pack-redundant.c index 5d1fc781761c79..3134cb8c689d01 100644 --- a/builtin/pack-redundant.c +++ b/builtin/pack-redundant.c @@ -13,7 +13,7 @@ #include "hex.h" #include "packfile.h" -#include "object-store.h" +#include "odb.h" #include "strbuf.h" #define BLKSIZE 512 diff --git a/builtin/prune.c b/builtin/prune.c index e930caa0c0af0e..7bbfb14c2bedf4 100644 --- a/builtin/prune.c +++ b/builtin/prune.c @@ -17,7 +17,7 @@ #include "replace-object.h" #include "object-file.h" #include "object-name.h" -#include "object-store.h" +#include "odb.h" #include "shallow.h" static const char * const prune_usage[] = { diff --git a/builtin/receive-pack.c b/builtin/receive-pack.c index a317d6c278de21..0f5958c4a6601e 100644 --- a/builtin/receive-pack.c +++ b/builtin/receive-pack.c @@ -33,7 +33,7 @@ #include "packfile.h" #include "object-file.h" #include "object-name.h" -#include "object-store.h" +#include "odb.h" #include "path.h" #include "protocol.h" #include "commit-reach.h" diff --git a/builtin/remote.c b/builtin/remote.c index 0d6755bcb71e3d..ac5b8d2a1a6506 100644 --- a/builtin/remote.c +++ b/builtin/remote.c @@ -14,7 +14,7 @@ #include "rebase.h" #include "refs.h" #include "refspec.h" -#include "object-store.h" +#include "odb.h" #include "strvec.h" #include "commit-reach.h" #include "progress.h" diff --git a/builtin/repack.c b/builtin/repack.c index 59214dbdfdfcd5..167823200586fb 100644 --- a/builtin/repack.c +++ b/builtin/repack.c @@ -17,7 +17,7 @@ #include "midx.h" #include "packfile.h" #include "prune-packed.h" -#include "object-store.h" +#include "odb.h" #include "promisor-remote.h" #include "shallow.h" #include "pack.h" diff --git a/builtin/replace.c b/builtin/replace.c index 48c7c6a2d56d92..11c7e2d4c0cbcc 100644 --- a/builtin/replace.c +++ b/builtin/replace.c @@ -19,7 +19,7 @@ #include "run-command.h" #include "object-file.h" #include "object-name.h" -#include "object-store.h" +#include "odb.h" #include "replace-object.h" #include "tag.h" #include "wildmatch.h" diff --git a/builtin/rev-list.c b/builtin/rev-list.c index 0984b607bf052d..0ee37a32cb211c 100644 --- a/builtin/rev-list.c +++ b/builtin/rev-list.c @@ -14,7 +14,7 @@ #include "object.h" #include "object-name.h" #include "object-file.h" -#include "object-store.h" +#include "odb.h" #include "pack-bitmap.h" #include "parse-options.h" #include "log-tree.h" diff --git a/builtin/show-ref.c b/builtin/show-ref.c index 623a52a45f85cf..90ec1de78f9002 100644 --- a/builtin/show-ref.c +++ b/builtin/show-ref.c @@ -5,7 +5,7 @@ #include "hex.h" #include "refs/refs-internal.h" #include "object-name.h" -#include "object-store.h" +#include "odb.h" #include "object.h" #include "string-list.h" #include "parse-options.h" diff --git a/builtin/submodule--helper.c b/builtin/submodule--helper.c index 758bc6d0f24089..84f7fa53424ceb 100644 --- a/builtin/submodule--helper.c +++ b/builtin/submodule--helper.c @@ -28,7 +28,7 @@ #include "diff.h" #include "object-file.h" #include "object-name.h" -#include "object-store.h" +#include "odb.h" #include "advice.h" #include "branch.h" #include "list-objects-filter-options.h" diff --git a/builtin/tag.c b/builtin/tag.c index 4742b27d16e5cf..cf2ea4b4993daf 100644 --- a/builtin/tag.c +++ b/builtin/tag.c @@ -19,7 +19,7 @@ #include "refs.h" #include "object-file.h" #include "object-name.h" -#include "object-store.h" +#include "odb.h" #include "path.h" #include "tag.h" #include "parse-options.h" diff --git a/builtin/unpack-file.c b/builtin/unpack-file.c index e33acfc4ee4764..b92fd4710a99db 100644 --- a/builtin/unpack-file.c +++ b/builtin/unpack-file.c @@ -4,7 +4,7 @@ #include "hex.h" #include "object-file.h" #include "object-name.h" -#include "object-store.h" +#include "odb.h" static char *create_temp_file(struct object_id *oid) { diff --git a/builtin/unpack-objects.c b/builtin/unpack-objects.c index e905d5f4e1964b..7bf395eec8461d 100644 --- a/builtin/unpack-objects.c +++ b/builtin/unpack-objects.c @@ -9,7 +9,7 @@ #include "git-zlib.h" #include "hex.h" #include "object-file.h" -#include "object-store.h" +#include "odb.h" #include "object.h" #include "delta.h" #include "pack.h" diff --git a/bulk-checkin.c b/bulk-checkin.c index 678e2ecc2c29da..55406a539e7d4a 100644 --- a/bulk-checkin.c +++ b/bulk-checkin.c @@ -17,7 +17,7 @@ #include "tmp-objdir.h" #include "packfile.h" #include "object-file.h" -#include "object-store.h" +#include "odb.h" static int odb_transaction_nesting; diff --git a/bundle-uri.c b/bundle-uri.c index 9accf157b44a7a..2e623f8627abea 100644 --- a/bundle-uri.c +++ b/bundle-uri.c @@ -14,7 +14,7 @@ #include "fetch-pack.h" #include "remote.h" #include "trace2.h" -#include "object-store.h" +#include "odb.h" static struct { enum bundle_list_heuristic heuristic; diff --git a/bundle.c b/bundle.c index 2ce7525f90d564..e09e3c2f58c3e9 100644 --- a/bundle.c +++ b/bundle.c @@ -7,7 +7,7 @@ #include "environment.h" #include "gettext.h" #include "hex.h" -#include "object-store.h" +#include "odb.h" #include "repository.h" #include "object.h" #include "commit.h" diff --git a/cache-tree.c b/cache-tree.c index fa3858e2829aa8..9786b32b3a1caa 100644 --- a/cache-tree.c +++ b/cache-tree.c @@ -10,7 +10,7 @@ #include "cache-tree.h" #include "bulk-checkin.h" #include "object-file.h" -#include "object-store.h" +#include "odb.h" #include "read-cache-ll.h" #include "replace-object.h" #include "repository.h" diff --git a/combine-diff.c b/combine-diff.c index dfae9f7995da51..cf23a753407561 100644 --- a/combine-diff.c +++ b/combine-diff.c @@ -2,7 +2,7 @@ #define DISABLE_SIGN_COMPARE_WARNINGS #include "git-compat-util.h" -#include "object-store.h" +#include "odb.h" #include "commit.h" #include "convert.h" #include "diff.h" diff --git a/commit-graph.c b/commit-graph.c index 12d32cdad1dc87..6ced5b366e7101 100644 --- a/commit-graph.c +++ b/commit-graph.c @@ -13,7 +13,7 @@ #include "refs.h" #include "hash-lookup.h" #include "commit-graph.h" -#include "object-store.h" +#include "odb.h" #include "oid-array.h" #include "path.h" #include "alloc.h" diff --git a/commit-graph.h b/commit-graph.h index 0e661db1b54dd9..78ab7b875b2751 100644 --- a/commit-graph.h +++ b/commit-graph.h @@ -1,7 +1,7 @@ #ifndef COMMIT_GRAPH_H #define COMMIT_GRAPH_H -#include "object-store.h" +#include "odb.h" #include "oidset.h" #define GIT_TEST_COMMIT_GRAPH "GIT_TEST_COMMIT_GRAPH" diff --git a/commit.c b/commit.c index e915b2b9a1295c..1d30f8ce15ad8c 100644 --- a/commit.c +++ b/commit.c @@ -9,7 +9,7 @@ #include "hex.h" #include "repository.h" #include "object-name.h" -#include "object-store.h" +#include "odb.h" #include "utf8.h" #include "diff.h" #include "revision.h" diff --git a/config.c b/config.c index b18b5617fcd05d..883dd0668271c6 100644 --- a/config.c +++ b/config.c @@ -31,7 +31,7 @@ #include "hashmap.h" #include "string-list.h" #include "object-name.h" -#include "object-store.h" +#include "odb.h" #include "pager.h" #include "path.h" #include "utf8.h" diff --git a/connected.c b/connected.c index 4415388bebacdf..18c13245d8e40c 100644 --- a/connected.c +++ b/connected.c @@ -3,7 +3,7 @@ #include "git-compat-util.h" #include "gettext.h" #include "hex.h" -#include "object-store.h" +#include "odb.h" #include "run-command.h" #include "sigchain.h" #include "connected.h" diff --git a/contrib/coccinelle/the_repository.cocci b/contrib/coccinelle/the_repository.cocci index 765ad689678f22..ea7fe1c8db78f3 100644 --- a/contrib/coccinelle/the_repository.cocci +++ b/contrib/coccinelle/the_repository.cocci @@ -77,7 +77,7 @@ | - diff_setup + repo_diff_setup -// object-store.h +// odb.h | - read_object_file + repo_read_object_file diff --git a/diagnose.c b/diagnose.c index d08d5643aac4f8..ad0d5c1246558d 100644 --- a/diagnose.c +++ b/diagnose.c @@ -7,7 +7,7 @@ #include "gettext.h" #include "hex.h" #include "strvec.h" -#include "object-store.h" +#include "odb.h" #include "packfile.h" #include "parse-options.h" #include "repository.h" diff --git a/diff.c b/diff.c index 90e8003dd11e4d..3af108115b351b 100644 --- a/diff.c +++ b/diff.c @@ -23,7 +23,7 @@ #include "color.h" #include "run-command.h" #include "utf8.h" -#include "object-store.h" +#include "odb.h" #include "userdiff.h" #include "submodule.h" #include "hashmap.h" diff --git a/entry.c b/entry.c index f36ec5ad24205a..75d55038d7ceb8 100644 --- a/entry.c +++ b/entry.c @@ -1,7 +1,7 @@ #define USE_THE_REPOSITORY_VARIABLE #include "git-compat-util.h" -#include "object-store.h" +#include "odb.h" #include "dir.h" #include "environment.h" #include "gettext.h" diff --git a/fetch-pack.c b/fetch-pack.c index fa4231fee74c9f..cf157f5d7e583e 100644 --- a/fetch-pack.c +++ b/fetch-pack.c @@ -24,7 +24,7 @@ #include "oid-array.h" #include "oidset.h" #include "packfile.h" -#include "object-store.h" +#include "odb.h" #include "path.h" #include "connected.h" #include "fetch-negotiator.h" diff --git a/fmt-merge-msg.c b/fmt-merge-msg.c index 501b5acdd44c22..1a8c972adf3ad7 100644 --- a/fmt-merge-msg.c +++ b/fmt-merge-msg.c @@ -6,7 +6,7 @@ #include "environment.h" #include "refs.h" #include "object-name.h" -#include "object-store.h" +#include "odb.h" #include "diff.h" #include "diff-merges.h" #include "hex.h" diff --git a/fsck.c b/fsck.c index 8dc8472ceb3781..e69baab3af7ede 100644 --- a/fsck.c +++ b/fsck.c @@ -4,7 +4,7 @@ #include "date.h" #include "dir.h" #include "hex.h" -#include "object-store.h" +#include "odb.h" #include "path.h" #include "repository.h" #include "object.h" diff --git a/grep.c b/grep.c index f8d535182c36d3..dc77e6c4631915 100644 --- a/grep.c +++ b/grep.c @@ -5,7 +5,7 @@ #include "gettext.h" #include "grep.h" #include "hex.h" -#include "object-store.h" +#include "odb.h" #include "pretty.h" #include "userdiff.h" #include "xdiff-interface.h" diff --git a/http-backend.c b/http-backend.c index 0c575aa88aaf32..ad8c4037493057 100644 --- a/http-backend.c +++ b/http-backend.c @@ -18,7 +18,7 @@ #include "url.h" #include "strvec.h" #include "packfile.h" -#include "object-store.h" +#include "odb.h" #include "protocol.h" #include "date.h" #include "write-or-die.h" diff --git a/http-push.c b/http-push.c index f9e67cabd4bee8..d1b1bb23711653 100644 --- a/http-push.c +++ b/http-push.c @@ -20,7 +20,7 @@ #include "url.h" #include "packfile.h" #include "object-file.h" -#include "object-store.h" +#include "odb.h" #include "commit-reach.h" #ifdef EXPAT_NEEDS_XMLPARSE_H diff --git a/http-walker.c b/http-walker.c index c374e6b2056a01..05fb9ce714a4c9 100644 --- a/http-walker.c +++ b/http-walker.c @@ -10,7 +10,7 @@ #include "transport.h" #include "packfile.h" #include "object-file.h" -#include "object-store.h" +#include "odb.h" struct alt_base { char *base; diff --git a/http.c b/http.c index 5e15bbab3f1dd5..8f4f701a818ac2 100644 --- a/http.c +++ b/http.c @@ -19,7 +19,7 @@ #include "packfile.h" #include "string-list.h" #include "object-file.h" -#include "object-store.h" +#include "odb.h" #include "tempfile.h" static struct trace_key trace_curl = TRACE_KEY_INIT(CURL); diff --git a/list-objects-filter.c b/list-objects-filter.c index 78b397bc194849..80fe48a52c8a7c 100644 --- a/list-objects-filter.c +++ b/list-objects-filter.c @@ -12,7 +12,7 @@ #include "oidmap.h" #include "oidset.h" #include "object-name.h" -#include "object-store.h" +#include "odb.h" /* Remember to update object flag allocation in object.h */ /* diff --git a/list-objects.c b/list-objects.c index 597114281f6596..c50b9578584d20 100644 --- a/list-objects.c +++ b/list-objects.c @@ -14,7 +14,7 @@ #include "list-objects-filter.h" #include "list-objects-filter-options.h" #include "packfile.h" -#include "object-store.h" +#include "odb.h" #include "trace.h" #include "environment.h" diff --git a/loose.c b/loose.c index fe65d5b9b0f5c7..fab4041c03d50b 100644 --- a/loose.c +++ b/loose.c @@ -1,7 +1,7 @@ #include "git-compat-util.h" #include "hash.h" #include "path.h" -#include "object-store.h" +#include "odb.h" #include "hex.h" #include "repository.h" #include "wrapper.h" diff --git a/mailmap.c b/mailmap.c index 9e2642a043b1fb..b18e74c2110e78 100644 --- a/mailmap.c +++ b/mailmap.c @@ -6,7 +6,7 @@ #include "string-list.h" #include "mailmap.h" #include "object-name.h" -#include "object-store.h" +#include "odb.h" #include "setup.h" char *git_mailmap_file; diff --git a/match-trees.c b/match-trees.c index 72922d5d64e777..4704f95c3402e6 100644 --- a/match-trees.c +++ b/match-trees.c @@ -7,7 +7,7 @@ #include "tree.h" #include "tree-walk.h" #include "object-file.h" -#include "object-store.h" +#include "odb.h" #include "repository.h" static int score_missing(unsigned mode) diff --git a/merge-blobs.c b/merge-blobs.c index 53f36dbc1750e7..ba8a3fdfd82b74 100644 --- a/merge-blobs.c +++ b/merge-blobs.c @@ -4,7 +4,7 @@ #include "merge-ll.h" #include "blob.h" #include "merge-blobs.h" -#include "object-store.h" +#include "odb.h" static int fill_mmfile_blob(mmfile_t *f, struct blob *obj) { diff --git a/merge-ort.c b/merge-ort.c index 47b3d1730ece36..9f693ab1d36c9a 100644 --- a/merge-ort.c +++ b/merge-ort.c @@ -39,7 +39,7 @@ #include "mem-pool.h" #include "object-file.h" #include "object-name.h" -#include "object-store.h" +#include "odb.h" #include "oid-array.h" #include "path.h" #include "promisor-remote.h" diff --git a/meson.build b/meson.build index 596f5ac7110ebf..3fad0e39987d7d 100644 --- a/meson.build +++ b/meson.build @@ -396,8 +396,8 @@ libgit_sources = [ 'object-file-convert.c', 'object-file.c', 'object-name.c', - 'object-store.c', 'object.c', + 'odb.c', 'oid-array.c', 'oidmap.c', 'oidset.c', diff --git a/notes-cache.c b/notes-cache.c index 150241b15e0905..344f67762b8c18 100644 --- a/notes-cache.c +++ b/notes-cache.c @@ -3,7 +3,7 @@ #include "git-compat-util.h" #include "notes-cache.h" #include "object-file.h" -#include "object-store.h" +#include "odb.h" #include "pretty.h" #include "repository.h" #include "commit.h" diff --git a/notes-merge.c b/notes-merge.c index dae8e6a281aab0..de6a52e2e7ff3f 100644 --- a/notes-merge.c +++ b/notes-merge.c @@ -8,7 +8,7 @@ #include "refs.h" #include "object-file.h" #include "object-name.h" -#include "object-store.h" +#include "odb.h" #include "path.h" #include "repository.h" #include "diff.h" diff --git a/notes.c b/notes.c index 0a128f1de98050..fc000e501d2a63 100644 --- a/notes.c +++ b/notes.c @@ -8,7 +8,7 @@ #include "notes.h" #include "object-file.h" #include "object-name.h" -#include "object-store.h" +#include "odb.h" #include "utf8.h" #include "strbuf.h" #include "tree-walk.h" diff --git a/object-file.c b/object-file.c index 6bad1d3dd1cf13..2d3af8a77c0f5b 100644 --- a/object-file.c +++ b/object-file.c @@ -21,7 +21,7 @@ #include "loose.h" #include "object-file-convert.h" #include "object-file.h" -#include "object-store.h" +#include "odb.h" #include "oidtree.h" #include "pack.h" #include "packfile.h" diff --git a/object-file.h b/object-file.h index 9a18859b2e0c9d..5066638f8eccd0 100644 --- a/object-file.h +++ b/object-file.h @@ -3,7 +3,7 @@ #include "git-zlib.h" #include "object.h" -#include "object-store.h" +#include "odb.h" struct index_state; diff --git a/object-store.c b/odb.c similarity index 99% rename from object-store.c rename to odb.c index 5c04a1018f7c7a..d1025ac182d151 100644 --- a/object-store.c +++ b/odb.c @@ -13,7 +13,7 @@ #include "loose.h" #include "object-file-convert.h" #include "object-file.h" -#include "object-store.h" +#include "odb.h" #include "packfile.h" #include "path.h" #include "promisor-remote.h" diff --git a/object-store.h b/odb.h similarity index 99% rename from object-store.h rename to odb.h index d199d757d7620c..6f56b168e4665e 100644 --- a/object-store.h +++ b/odb.h @@ -1,5 +1,5 @@ -#ifndef OBJECT_STORE_H -#define OBJECT_STORE_H +#ifndef ODB_H +#define ODB_H #include "hashmap.h" #include "object.h" @@ -352,4 +352,4 @@ void *read_object_with_reference(struct repository *r, unsigned long *size, struct object_id *oid_ret); -#endif /* OBJECT_STORE_H */ +#endif /* ODB_H */ diff --git a/oss-fuzz/fuzz-pack-idx.c b/oss-fuzz/fuzz-pack-idx.c index 609a343ee3ea41..d2a92f34d98ae9 100644 --- a/oss-fuzz/fuzz-pack-idx.c +++ b/oss-fuzz/fuzz-pack-idx.c @@ -1,5 +1,5 @@ #include "git-compat-util.h" -#include "object-store.h" +#include "odb.h" #include "packfile.h" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size); diff --git a/pack-bitmap-write.c b/pack-bitmap-write.c index 7f400ee01213da..37648b57125567 100644 --- a/pack-bitmap-write.c +++ b/pack-bitmap-write.c @@ -4,7 +4,7 @@ #include "environment.h" #include "gettext.h" #include "hex.h" -#include "object-store.h" +#include "odb.h" #include "commit.h" #include "diff.h" #include "revision.h" diff --git a/pack-bitmap.c b/pack-bitmap.c index ac6d62b980c5a8..a695a794e9b703 100644 --- a/pack-bitmap.c +++ b/pack-bitmap.c @@ -17,7 +17,7 @@ #include "packfile.h" #include "repository.h" #include "trace2.h" -#include "object-store.h" +#include "odb.h" #include "list-objects-filter-options.h" #include "midx.h" #include "config.h" diff --git a/pack-check.c b/pack-check.c index 874897d6cbab12..67cb2cf72f2b93 100644 --- a/pack-check.c +++ b/pack-check.c @@ -8,7 +8,7 @@ #include "progress.h" #include "packfile.h" #include "object-file.h" -#include "object-store.h" +#include "odb.h" struct idx_entry { off_t offset; diff --git a/pack-mtimes.c b/pack-mtimes.c index 20900ca88d377a..8e1f2dec0ef62f 100644 --- a/pack-mtimes.c +++ b/pack-mtimes.c @@ -1,7 +1,7 @@ #include "git-compat-util.h" #include "gettext.h" #include "pack-mtimes.h" -#include "object-store.h" +#include "odb.h" #include "packfile.h" #include "strbuf.h" diff --git a/pack-objects.h b/pack-objects.h index 475a2d67ce30eb..1ac8644201b58d 100644 --- a/pack-objects.h +++ b/pack-objects.h @@ -1,7 +1,7 @@ #ifndef PACK_OBJECTS_H #define PACK_OBJECTS_H -#include "object-store.h" +#include "odb.h" #include "thread-utils.h" #include "pack.h" #include "packfile.h" diff --git a/pack-revindex.c b/pack-revindex.c index ffcde48870d8f7..0cc422a1e67bc8 100644 --- a/pack-revindex.c +++ b/pack-revindex.c @@ -1,7 +1,7 @@ #include "git-compat-util.h" #include "gettext.h" #include "pack-revindex.h" -#include "object-store.h" +#include "odb.h" #include "packfile.h" #include "strbuf.h" #include "trace2.h" diff --git a/packfile.c b/packfile.c index 60661ad00951f4..346c2f9ce90574 100644 --- a/packfile.c +++ b/packfile.c @@ -19,7 +19,7 @@ #include "tree-walk.h" #include "tree.h" #include "object-file.h" -#include "object-store.h" +#include "odb.h" #include "midx.h" #include "commit-graph.h" #include "pack-revindex.h" diff --git a/packfile.h b/packfile.h index 826eb7f475fc31..53c3b7d3b43cba 100644 --- a/packfile.h +++ b/packfile.h @@ -3,10 +3,10 @@ #include "list.h" #include "object.h" -#include "object-store.h" +#include "odb.h" #include "oidset.h" -/* in object-store.h */ +/* in odb.h */ struct object_info; struct packed_git { diff --git a/path.c b/path.c index c347829aa667cc..7f56eaf9930374 100644 --- a/path.c +++ b/path.c @@ -15,7 +15,7 @@ #include "submodule-config.h" #include "path.h" #include "packfile.h" -#include "object-store.h" +#include "odb.h" #include "lockfile.h" #include "exec-cmd.h" diff --git a/promisor-remote.c b/promisor-remote.c index 9d058586dfa8a4..2baa286bfd04ba 100644 --- a/promisor-remote.c +++ b/promisor-remote.c @@ -3,7 +3,7 @@ #include "git-compat-util.h" #include "gettext.h" #include "hex.h" -#include "object-store.h" +#include "odb.h" #include "promisor-remote.h" #include "config.h" #include "trace2.h" diff --git a/protocol-caps.c b/protocol-caps.c index 9b8db37a2105fc..3022f69a1bd55f 100644 --- a/protocol-caps.c +++ b/protocol-caps.c @@ -6,7 +6,7 @@ #include "hash.h" #include "hex.h" #include "object.h" -#include "object-store.h" +#include "odb.h" #include "repository.h" #include "string-list.h" #include "strbuf.h" diff --git a/read-cache.c b/read-cache.c index c0bb760ad473ef..c3fa9686766375 100644 --- a/read-cache.c +++ b/read-cache.c @@ -20,7 +20,7 @@ #include "refs.h" #include "dir.h" #include "object-file.h" -#include "object-store.h" +#include "odb.h" #include "oid-array.h" #include "tree.h" #include "commit.h" diff --git a/ref-filter.c b/ref-filter.c index 7a274633cfc7e7..4ce45440ad12cb 100644 --- a/ref-filter.c +++ b/ref-filter.c @@ -12,7 +12,7 @@ #include "refs.h" #include "wildmatch.h" #include "object-name.h" -#include "object-store.h" +#include "odb.h" #include "oid-array.h" #include "repo-settings.h" #include "repository.h" diff --git a/reflog.c b/reflog.c index 15d81ebea978d3..4f8a3b717cdb74 100644 --- a/reflog.c +++ b/reflog.c @@ -5,7 +5,7 @@ #include "config.h" #include "gettext.h" #include "parse-options.h" -#include "object-store.h" +#include "odb.h" #include "reflog.h" #include "refs.h" #include "revision.h" diff --git a/refs.c b/refs.c index 5f6a386cc93bf9..0ff0e582a6b019 100644 --- a/refs.c +++ b/refs.c @@ -19,7 +19,7 @@ #include "run-command.h" #include "hook.h" #include "object-name.h" -#include "object-store.h" +#include "odb.h" #include "object.h" #include "path.h" #include "submodule.h" diff --git a/remote.c b/remote.c index 4099183cacdc8a..17a842f5684746 100644 --- a/remote.c +++ b/remote.c @@ -12,7 +12,7 @@ #include "refs.h" #include "refspec.h" #include "object-name.h" -#include "object-store.h" +#include "odb.h" #include "path.h" #include "commit.h" #include "diff.h" diff --git a/replace-object.c b/replace-object.c index f8c5f68837f12e..3eae0510745eae 100644 --- a/replace-object.c +++ b/replace-object.c @@ -2,7 +2,7 @@ #include "gettext.h" #include "hex.h" #include "oidmap.h" -#include "object-store.h" +#include "odb.h" #include "replace-object.h" #include "refs.h" #include "repository.h" diff --git a/replace-object.h b/replace-object.h index 3052e96a6203fd..4c9f2a2383d577 100644 --- a/replace-object.h +++ b/replace-object.h @@ -3,7 +3,7 @@ #include "oidmap.h" #include "repository.h" -#include "object-store.h" +#include "odb.h" struct replace_object { struct oidmap_entry original; diff --git a/repository.c b/repository.c index 7528beccddf136..13426db0f2be26 100644 --- a/repository.c +++ b/repository.c @@ -1,7 +1,7 @@ #include "git-compat-util.h" #include "abspath.h" #include "repository.h" -#include "object-store.h" +#include "odb.h" #include "config.h" #include "object.h" #include "lockfile.h" diff --git a/rerere.c b/rerere.c index 3cd37c5f0ae70c..951e4bf8b41c95 100644 --- a/rerere.c +++ b/rerere.c @@ -18,7 +18,7 @@ #include "path.h" #include "pathspec.h" #include "object-file.h" -#include "object-store.h" +#include "odb.h" #include "strmap.h" #define RESOLVED 0 diff --git a/revision.c b/revision.c index 2c36a9c179efb5..cdefe7d6e482cb 100644 --- a/revision.c +++ b/revision.c @@ -8,7 +8,7 @@ #include "hex.h" #include "object-name.h" #include "object-file.h" -#include "object-store.h" +#include "odb.h" #include "oidset.h" #include "tag.h" #include "blob.h" diff --git a/send-pack.c b/send-pack.c index 86592ce526db95..abca2dd38a78ba 100644 --- a/send-pack.c +++ b/send-pack.c @@ -4,7 +4,7 @@ #include "date.h" #include "gettext.h" #include "hex.h" -#include "object-store.h" +#include "odb.h" #include "pkt-line.h" #include "sideband.h" #include "run-command.h" diff --git a/sequencer.c b/sequencer.c index 1ee0abbd4514f2..2432d0a39ec669 100644 --- a/sequencer.c +++ b/sequencer.c @@ -13,7 +13,7 @@ #include "dir.h" #include "object-file.h" #include "object-name.h" -#include "object-store.h" +#include "odb.h" #include "object.h" #include "pager.h" #include "commit.h" diff --git a/server-info.c b/server-info.c index d6cd20a39d74fc..9bb30d9ab71d22 100644 --- a/server-info.c +++ b/server-info.c @@ -11,7 +11,7 @@ #include "packfile.h" #include "path.h" #include "object-file.h" -#include "object-store.h" +#include "odb.h" #include "server-info.h" #include "strbuf.h" #include "tempfile.h" diff --git a/shallow.c b/shallow.c index faeeeb45f986e1..d379756e39a67a 100644 --- a/shallow.c +++ b/shallow.c @@ -5,7 +5,7 @@ #include "repository.h" #include "tempfile.h" #include "lockfile.h" -#include "object-store.h" +#include "odb.h" #include "commit.h" #include "tag.h" #include "pkt-line.h" diff --git a/streaming.c b/streaming.c index 6d6512e2e0d6d9..81c42673a235fa 100644 --- a/streaming.c +++ b/streaming.c @@ -10,7 +10,7 @@ #include "streaming.h" #include "repository.h" #include "object-file.h" -#include "object-store.h" +#include "odb.h" #include "replace-object.h" #include "packfile.h" diff --git a/submodule-config.c b/submodule-config.c index b30d9365fbdb9b..9c80f9f7b66608 100644 --- a/submodule-config.c +++ b/submodule-config.c @@ -13,7 +13,7 @@ #include "submodule.h" #include "strbuf.h" #include "object-name.h" -#include "object-store.h" +#include "odb.h" #include "parse-options.h" #include "thread-utils.h" #include "tree-walk.h" diff --git a/submodule.c b/submodule.c index ead3fb5dadca3a..9b1018877df8b7 100644 --- a/submodule.c +++ b/submodule.c @@ -27,7 +27,7 @@ #include "parse-options.h" #include "object-file.h" #include "object-name.h" -#include "object-store.h" +#include "odb.h" #include "commit-reach.h" #include "read-cache-ll.h" #include "setup.h" diff --git a/t/helper/test-find-pack.c b/t/helper/test-find-pack.c index 76c2f4eba85f2c..611a13a32610d2 100644 --- a/t/helper/test-find-pack.c +++ b/t/helper/test-find-pack.c @@ -2,7 +2,7 @@ #include "test-tool.h" #include "object-name.h" -#include "object-store.h" +#include "odb.h" #include "packfile.h" #include "parse-options.h" #include "setup.h" diff --git a/t/helper/test-pack-mtimes.c b/t/helper/test-pack-mtimes.c index fdf1b13437bd79..d51aaa3dc40d12 100644 --- a/t/helper/test-pack-mtimes.c +++ b/t/helper/test-pack-mtimes.c @@ -3,7 +3,7 @@ #include "test-tool.h" #include "hex.h" #include "strbuf.h" -#include "object-store.h" +#include "odb.h" #include "packfile.h" #include "pack-mtimes.h" #include "setup.h" diff --git a/t/helper/test-partial-clone.c b/t/helper/test-partial-clone.c index 34f1aee5581762..dba227259a2629 100644 --- a/t/helper/test-partial-clone.c +++ b/t/helper/test-partial-clone.c @@ -1,7 +1,7 @@ #include "test-tool.h" #include "hex.h" #include "repository.h" -#include "object-store.h" +#include "odb.h" #include "setup.h" /* diff --git a/t/helper/test-read-graph.c b/t/helper/test-read-graph.c index 53b633e2ba6690..ef5339bbee9553 100644 --- a/t/helper/test-read-graph.c +++ b/t/helper/test-read-graph.c @@ -3,7 +3,7 @@ #include "test-tool.h" #include "commit-graph.h" #include "repository.h" -#include "object-store.h" +#include "odb.h" #include "bloom.h" #include "setup.h" diff --git a/t/helper/test-read-midx.c b/t/helper/test-read-midx.c index ac81390899aef0..da2aa036b57ef6 100644 --- a/t/helper/test-read-midx.c +++ b/t/helper/test-read-midx.c @@ -4,7 +4,7 @@ #include "hex.h" #include "midx.h" #include "repository.h" -#include "object-store.h" +#include "odb.h" #include "pack-bitmap.h" #include "packfile.h" #include "setup.h" diff --git a/t/helper/test-ref-store.c b/t/helper/test-ref-store.c index 4cfc7c90b59bea..2920ca59d72f53 100644 --- a/t/helper/test-ref-store.c +++ b/t/helper/test-ref-store.c @@ -5,7 +5,7 @@ #include "refs.h" #include "setup.h" #include "worktree.h" -#include "object-store.h" +#include "odb.h" #include "path.h" #include "repository.h" #include "strbuf.h" diff --git a/tag.c b/tag.c index 05be39067cfe4e..5f6868bf7b12a4 100644 --- a/tag.c +++ b/tag.c @@ -5,7 +5,7 @@ #include "environment.h" #include "tag.h" #include "object-name.h" -#include "object-store.h" +#include "odb.h" #include "commit.h" #include "tree.h" #include "blob.h" diff --git a/tmp-objdir.c b/tmp-objdir.c index 056484404be0bf..bef2f917cd2f2a 100644 --- a/tmp-objdir.c +++ b/tmp-objdir.c @@ -10,7 +10,7 @@ #include "strbuf.h" #include "strvec.h" #include "quote.h" -#include "object-store.h" +#include "odb.h" #include "repository.h" struct tmp_objdir { diff --git a/tree-walk.c b/tree-walk.c index 90655d52378319..34b0fff4873dbd 100644 --- a/tree-walk.c +++ b/tree-walk.c @@ -6,7 +6,7 @@ #include "gettext.h" #include "hex.h" #include "object-file.h" -#include "object-store.h" +#include "odb.h" #include "trace2.h" #include "tree.h" #include "pathspec.h" diff --git a/tree.c b/tree.c index b85f56267fb3bb..341b7c2ff3fb9f 100644 --- a/tree.c +++ b/tree.c @@ -4,7 +4,7 @@ #include "hex.h" #include "tree.h" #include "object-name.h" -#include "object-store.h" +#include "odb.h" #include "commit.h" #include "alloc.h" #include "tree-walk.h" diff --git a/unpack-trees.c b/unpack-trees.c index 471837f0329d63..f38c761ab987a6 100644 --- a/unpack-trees.c +++ b/unpack-trees.c @@ -26,7 +26,7 @@ #include "symlinks.h" #include "trace2.h" #include "fsmonitor.h" -#include "object-store.h" +#include "odb.h" #include "promisor-remote.h" #include "entry.h" #include "parallel-checkout.h" diff --git a/upload-pack.c b/upload-pack.c index 26f29b85b551c1..e994d6a901b667 100644 --- a/upload-pack.c +++ b/upload-pack.c @@ -10,7 +10,7 @@ #include "pkt-line.h" #include "sideband.h" #include "repository.h" -#include "object-store.h" +#include "odb.h" #include "oid-array.h" #include "object.h" #include "commit.h" diff --git a/walker.c b/walker.c index b470d43e54d486..a8abe8a2e78ee5 100644 --- a/walker.c +++ b/walker.c @@ -5,7 +5,7 @@ #include "hex.h" #include "walker.h" #include "repository.h" -#include "object-store.h" +#include "odb.h" #include "commit.h" #include "strbuf.h" #include "tree.h" diff --git a/xdiff-interface.c b/xdiff-interface.c index 1edcd319e6ef2c..01e6e378ea6071 100644 --- a/xdiff-interface.c +++ b/xdiff-interface.c @@ -5,7 +5,7 @@ #include "gettext.h" #include "config.h" #include "hex.h" -#include "object-store.h" +#include "odb.h" #include "strbuf.h" #include "xdiff-interface.h" #include "xdiff/xtypes.h" From 2f5181fce6c6353f9c743d9d396fbf06527688c7 Mon Sep 17 00:00:00 2001 From: Patrick Steinhardt Date: Tue, 1 Jul 2025 14:22:16 +0200 Subject: [PATCH 07/21] odb: introduce parent pointers In subsequent commits we'll get rid of our use of `the_repository` in "odb.c" in favor of explicitly passing in a `struct object_database` or a `struct odb_source`. In some cases though we'll need access to the repository, for example to read a config value from it, but we don't have a way to access the repository owning a specific object database. Introduce parent pointers for `struct object_database` to its owning repository as well as for `struct odb_source` to its owning object database, which will allow us to adapt those use cases. Note that this change requires us to pass through the object database to `link_alt_odb_entry()` so that we can set up the parent pointers for any source there. The callchain is adapted to pass through the object database accordingly. Signed-off-by: Patrick Steinhardt Signed-off-by: Junio C Hamano --- odb.c | 45 ++++++++++++++++++++++++++------------------- odb.h | 8 +++++++- repository.c | 3 ++- 3 files changed, 35 insertions(+), 21 deletions(-) diff --git a/odb.c b/odb.c index d1025ac182d151..0464d7f54a2176 100644 --- a/odb.c +++ b/odb.c @@ -135,11 +135,15 @@ static int alt_odb_usable(struct object_database *o, * of the object ID, an extra slash for the first level indirection, and * the terminating NUL. */ -static void read_info_alternates(struct repository *r, +static void read_info_alternates(struct object_database *odb, const char *relative_base, int depth); -static int link_alt_odb_entry(struct repository *r, const struct strbuf *entry, - const char *relative_base, int depth, const char *normalized_objdir) + +static int link_alt_odb_entry(struct object_database *odb, + const struct strbuf *entry, + const char *relative_base, + int depth, + const char *normalized_objdir) { struct odb_source *alternate; struct strbuf pathbuf = STRBUF_INIT; @@ -167,22 +171,23 @@ static int link_alt_odb_entry(struct repository *r, const struct strbuf *entry, while (pathbuf.len && pathbuf.buf[pathbuf.len - 1] == '/') strbuf_setlen(&pathbuf, pathbuf.len - 1); - if (!alt_odb_usable(r->objects, &pathbuf, normalized_objdir, &pos)) + if (!alt_odb_usable(odb, &pathbuf, normalized_objdir, &pos)) goto error; CALLOC_ARRAY(alternate, 1); + alternate->odb = odb; /* pathbuf.buf is already in r->objects->source_by_path */ alternate->path = strbuf_detach(&pathbuf, NULL); /* add the alternate entry */ - *r->objects->sources_tail = alternate; - r->objects->sources_tail = &(alternate->next); + *odb->sources_tail = alternate; + odb->sources_tail = &(alternate->next); alternate->next = NULL; - assert(r->objects->source_by_path); - kh_value(r->objects->source_by_path, pos) = alternate; + assert(odb->source_by_path); + kh_value(odb->source_by_path, pos) = alternate; /* recursively add alternates */ - read_info_alternates(r, alternate->path, depth + 1); + read_info_alternates(odb, alternate->path, depth + 1); ret = 0; error: strbuf_release(&tmp); @@ -219,7 +224,7 @@ static const char *parse_alt_odb_entry(const char *string, return end; } -static void link_alt_odb_entries(struct repository *r, const char *alt, +static void link_alt_odb_entries(struct object_database *odb, const char *alt, int sep, const char *relative_base, int depth) { struct strbuf objdirbuf = STRBUF_INIT; @@ -234,20 +239,20 @@ static void link_alt_odb_entries(struct repository *r, const char *alt, return; } - strbuf_realpath(&objdirbuf, r->objects->sources->path, 1); + strbuf_realpath(&objdirbuf, odb->sources->path, 1); while (*alt) { alt = parse_alt_odb_entry(alt, sep, &entry); if (!entry.len) continue; - link_alt_odb_entry(r, &entry, + link_alt_odb_entry(odb, &entry, relative_base, depth, objdirbuf.buf); } strbuf_release(&entry); strbuf_release(&objdirbuf); } -static void read_info_alternates(struct repository *r, +static void read_info_alternates(struct object_database *odb, const char *relative_base, int depth) { @@ -261,7 +266,7 @@ static void read_info_alternates(struct repository *r, return; } - link_alt_odb_entries(r, buf.buf, '\n', relative_base, depth); + link_alt_odb_entries(odb, buf.buf, '\n', relative_base, depth); strbuf_release(&buf); free(path); } @@ -303,7 +308,7 @@ void add_to_alternates_file(const char *reference) if (commit_lock_file(&lock)) die_errno(_("unable to move new alternates file into place")); if (the_repository->objects->loaded_alternates) - link_alt_odb_entries(the_repository, reference, + link_alt_odb_entries(the_repository->objects, reference, '\n', NULL, 0); } free(alts); @@ -317,7 +322,7 @@ void add_to_alternates_memory(const char *reference) */ prepare_alt_odb(the_repository); - link_alt_odb_entries(the_repository, reference, + link_alt_odb_entries(the_repository->objects, reference, '\n', NULL, 0); } @@ -336,6 +341,7 @@ struct odb_source *set_temporary_primary_odb(const char *dir, int will_destroy) * alternate */ source = xcalloc(1, sizeof(*source)); + source->odb = the_repository->objects; source->path = xstrdup(dir); /* @@ -580,9 +586,9 @@ void prepare_alt_odb(struct repository *r) if (r->objects->loaded_alternates) return; - link_alt_odb_entries(r, r->objects->alternate_db, PATH_SEP, NULL, 0); + link_alt_odb_entries(r->objects, r->objects->alternate_db, PATH_SEP, NULL, 0); - read_info_alternates(r, r->objects->sources->path, 0); + read_info_alternates(r->objects, r->objects->sources->path, 0); r->objects->loaded_alternates = 1; } @@ -950,11 +956,12 @@ void assert_oid_type(const struct object_id *oid, enum object_type expect) type_name(expect)); } -struct object_database *odb_new(void) +struct object_database *odb_new(struct repository *repo) { struct object_database *o = xmalloc(sizeof(*o)); memset(o, 0, sizeof(*o)); + o->repo = repo; INIT_LIST_HEAD(&o->packed_git_mru); hashmap_init(&o->pack_map, pack_map_entry_cmp, NULL, 0); pthread_mutex_init(&o->replace_mutex, NULL); diff --git a/odb.h b/odb.h index 6f56b168e4665e..c3851e296685cb 100644 --- a/odb.h +++ b/odb.h @@ -28,6 +28,9 @@ struct repository; struct odb_source { struct odb_source *next; + /* Object database that owns this object source. */ + struct object_database *odb; + /* * Used to store the results of readdir(3) calls when we are OK * sacrificing accuracy due to races for speed. That includes @@ -105,6 +108,9 @@ struct cached_object_entry; * configured via alternates. */ struct object_database { + /* Repository that owns this database. */ + struct repository *repo; + /* * Set of all object directories; the main directory is first (and * cannot be NULL after initialization). Subsequent directories are @@ -186,7 +192,7 @@ struct object_database { unsigned packed_git_initialized : 1; }; -struct object_database *odb_new(void); +struct object_database *odb_new(struct repository *repo); void odb_clear(struct object_database *o); /* diff --git a/repository.c b/repository.c index 13426db0f2be26..c606e1153c8b46 100644 --- a/repository.c +++ b/repository.c @@ -52,7 +52,7 @@ static void set_default_hash_algo(struct repository *repo) void initialize_repository(struct repository *repo) { - repo->objects = odb_new(); + repo->objects = odb_new(repo); repo->remote_state = remote_state_new(); repo->parsed_objects = parsed_object_pool_new(repo); ALLOC_ARRAY(repo->index, 1); @@ -167,6 +167,7 @@ void repo_set_gitdir(struct repository *repo, if (!repo->objects->sources) { CALLOC_ARRAY(repo->objects->sources, 1); + repo->objects->sources->odb = repo->objects; repo->objects->sources_tail = &repo->objects->sources->next; } expand_base_dir(&repo->objects->sources->path, o->object_dir, From bd52ea343d2af91574fedcf765250f44f3d624d4 Mon Sep 17 00:00:00 2001 From: Patrick Steinhardt Date: Tue, 1 Jul 2025 14:22:17 +0200 Subject: [PATCH 08/21] odb: get rid of `the_repository` in `find_odb()` Get rid of our dependency on `the_repository` in `find_odb()` by passing in the object database in which we want to search for the source and adjusting all callers. Rename the function to `odb_find_source()`. Signed-off-by: Patrick Steinhardt Signed-off-by: Junio C Hamano --- builtin/commit-graph.c | 4 ++-- midx-write.c | 2 +- odb.c | 6 +++--- odb.h | 7 ++++++- 4 files changed, 12 insertions(+), 7 deletions(-) diff --git a/builtin/commit-graph.c b/builtin/commit-graph.c index f04eaba5259343..77d7e88a98c43e 100644 --- a/builtin/commit-graph.c +++ b/builtin/commit-graph.c @@ -101,7 +101,7 @@ static int graph_verify(int argc, const char **argv, const char *prefix, if (opts.progress) flags |= COMMIT_GRAPH_WRITE_PROGRESS; - source = find_odb(the_repository, opts.obj_dir); + source = odb_find_source(the_repository->objects, opts.obj_dir); graph_name = get_commit_graph_filename(source); chain_name = get_commit_graph_chain_filename(source); if (open_commit_graph(graph_name, &fd, &st)) @@ -289,7 +289,7 @@ static int graph_write(int argc, const char **argv, const char *prefix, git_env_bool(GIT_TEST_COMMIT_GRAPH_CHANGED_PATHS, 0)) flags |= COMMIT_GRAPH_WRITE_BLOOM_FILTERS; - source = find_odb(the_repository, opts.obj_dir); + source = odb_find_source(the_repository->objects, opts.obj_dir); if (opts.reachable) { if (write_commit_graph_reachable(source, flags, &write_opts)) diff --git a/midx-write.c b/midx-write.c index ba4a94950a8314..f2cfb85476ed78 100644 --- a/midx-write.c +++ b/midx-write.c @@ -922,7 +922,7 @@ static struct multi_pack_index *lookup_multi_pack_index(struct repository *r, struct strbuf cur_path_real = STRBUF_INIT; /* Ensure the given object_dir is local, or a known alternate. */ - find_odb(r, obj_dir_real); + 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); diff --git a/odb.c b/odb.c index 0464d7f54a2176..240fc62ca2b18f 100644 --- a/odb.c +++ b/odb.c @@ -448,14 +448,14 @@ char *compute_alternate_path(const char *path, struct strbuf *err) return ref_git; } -struct odb_source *find_odb(struct repository *r, const char *obj_dir) +struct odb_source *odb_find_source(struct object_database *odb, const char *obj_dir) { struct odb_source *source; char *obj_dir_real = real_pathdup(obj_dir, 1); struct strbuf odb_path_real = STRBUF_INIT; - prepare_alt_odb(r); - for (source = r->objects->sources; source; source = source->next) { + prepare_alt_odb(odb->repo); + for (source = odb->sources; source; source = source->next) { strbuf_realpath(&odb_path_real, source->path, 1); if (!strcmp(obj_dir_real, odb_path_real.buf)) break; diff --git a/odb.h b/odb.h index c3851e296685cb..941329c6943153 100644 --- a/odb.h +++ b/odb.h @@ -68,7 +68,6 @@ struct odb_source { void prepare_alt_odb(struct repository *r); int has_alt_odb(struct repository *r); char *compute_alternate_path(const char *path, struct strbuf *err); -struct odb_source *find_odb(struct repository *r, const char *obj_dir); typedef int alt_odb_fn(struct odb_source *, void *); int foreach_alt_odb(alt_odb_fn, void*); typedef void alternate_ref_fn(const struct object_id *oid, void *); @@ -195,6 +194,12 @@ struct object_database { struct object_database *odb_new(struct repository *repo); void odb_clear(struct object_database *o); +/* + * Find source by its object directory path. Dies in case the source couldn't + * be found. + */ +struct odb_source *odb_find_source(struct object_database *odb, const char *obj_dir); + /* * Create a temporary file rooted in the object database directory, or * die on failure. The filename is taken from "pattern", which should have the From 961038856bcd319289a226e29503358123c0a1ba Mon Sep 17 00:00:00 2001 From: Patrick Steinhardt Date: Tue, 1 Jul 2025 14:22:18 +0200 Subject: [PATCH 09/21] odb: get rid of `the_repository` in `assert_oid_type()` Get rid of our dependency on `the_repository` in `assert_oid_type()` by passing in the object database as a parameter and adjusting all callers. Rename the function to `odb_assert_oid_type()`. Signed-off-by: Patrick Steinhardt Signed-off-by: Junio C Hamano --- builtin/commit-tree.c | 2 +- commit.c | 2 +- odb.c | 5 +++-- odb.h | 3 ++- 4 files changed, 7 insertions(+), 5 deletions(-) diff --git a/builtin/commit-tree.c b/builtin/commit-tree.c index 546069f8682027..31cfd9bd15d615 100644 --- a/builtin/commit-tree.c +++ b/builtin/commit-tree.c @@ -48,7 +48,7 @@ static int parse_parent_arg_callback(const struct option *opt, if (repo_get_oid_commit(the_repository, arg, &oid)) die(_("not a valid object name %s"), arg); - assert_oid_type(&oid, OBJ_COMMIT); + odb_assert_oid_type(the_repository->objects, &oid, OBJ_COMMIT); new_parent(lookup_commit(the_repository, &oid), parents); return 0; } diff --git a/commit.c b/commit.c index 1d30f8ce15ad8c..aa65183d8b6dd8 100644 --- a/commit.c +++ b/commit.c @@ -1706,7 +1706,7 @@ int commit_tree_extended(const char *msg, size_t msg_len, /* Not having i18n.commitencoding is the same as having utf-8 */ encoding_is_utf8 = is_encoding_utf8(git_commit_encoding); - assert_oid_type(tree, OBJ_TREE); + odb_assert_oid_type(the_repository->objects, tree, OBJ_TREE); if (memchr(msg, '\0', msg_len)) return error("a NUL byte in commit log message not allowed."); diff --git a/odb.c b/odb.c index 240fc62ca2b18f..d0ca29907741c7 100644 --- a/odb.c +++ b/odb.c @@ -946,9 +946,10 @@ int has_object(struct repository *r, const struct object_id *oid, return oid_object_info_extended(r, oid, NULL, object_info_flags) >= 0; } -void assert_oid_type(const struct object_id *oid, enum object_type expect) +void odb_assert_oid_type(struct object_database *odb, + const struct object_id *oid, enum object_type expect) { - enum object_type type = oid_object_info(the_repository, oid, NULL); + enum object_type type = oid_object_info(odb->repo, oid, NULL); if (type < 0) die(_("%s is not a valid object"), oid_to_hex(oid)); if (type != expect) diff --git a/odb.h b/odb.h index 941329c6943153..13f5da45f54949 100644 --- a/odb.h +++ b/odb.h @@ -302,7 +302,8 @@ enum { int has_object(struct repository *r, const struct object_id *oid, unsigned flags); -void assert_oid_type(const struct object_id *oid, enum object_type expect); +void odb_assert_oid_type(struct object_database *odb, + const struct object_id *oid, enum object_type expect); /* * Enabling the object read lock allows multiple threads to safely call the From 1b1679c6883f948b19599f11229ff61124b51733 Mon Sep 17 00:00:00 2001 From: Patrick Steinhardt Date: Tue, 1 Jul 2025 14:22:19 +0200 Subject: [PATCH 10/21] odb: get rid of `the_repository` in `odb_mkstemp()` Get rid of our dependency on `the_repository` in `odb_mkstemp()` by passing in the object database as a parameter and adjusting all callers. Signed-off-by: Patrick Steinhardt Signed-off-by: Junio C Hamano --- builtin/fast-import.c | 3 ++- builtin/index-pack.c | 2 +- bundle-uri.c | 3 ++- odb.c | 9 +++++---- odb.h | 7 ++++--- pack-bitmap-write.c | 3 ++- pack-write.c | 10 ++++++---- 7 files changed, 22 insertions(+), 15 deletions(-) diff --git a/builtin/fast-import.c b/builtin/fast-import.c index 52c792488e1379..413304db9b591b 100644 --- a/builtin/fast-import.c +++ b/builtin/fast-import.c @@ -763,7 +763,8 @@ static void start_packfile(void) struct packed_git *p; int pack_fd; - pack_fd = odb_mkstemp(&tmp_file, "pack/tmp_pack_XXXXXX"); + pack_fd = odb_mkstemp(the_repository->objects, &tmp_file, + "pack/tmp_pack_XXXXXX"); FLEX_ALLOC_STR(p, pack_name, tmp_file.buf); strbuf_release(&tmp_file); diff --git a/builtin/index-pack.c b/builtin/index-pack.c index 1aabe6b8ee213f..4d4d989eb1a29f 100644 --- a/builtin/index-pack.c +++ b/builtin/index-pack.c @@ -362,7 +362,7 @@ static const char *open_pack_file(const char *pack_name) input_fd = 0; if (!pack_name) { struct strbuf tmp_file = STRBUF_INIT; - output_fd = odb_mkstemp(&tmp_file, + output_fd = odb_mkstemp(the_repository->objects, &tmp_file, "pack/tmp_pack_XXXXXX"); pack_name = strbuf_detach(&tmp_file, NULL); } else { diff --git a/bundle-uri.c b/bundle-uri.c index 2e623f8627abea..f94e780e967e1a 100644 --- a/bundle-uri.c +++ b/bundle-uri.c @@ -278,7 +278,8 @@ static char *find_temp_filename(void) * Find a temporary filename that is available. This is briefly * racy, but unlikely to collide. */ - fd = odb_mkstemp(&name, "bundles/tmp_uri_XXXXXX"); + fd = odb_mkstemp(the_repository->objects, &name, + "bundles/tmp_uri_XXXXXX"); if (fd < 0) { warning(_("failed to create temporary file")); return NULL; diff --git a/odb.c b/odb.c index d0ca29907741c7..8967e9fd548bd5 100644 --- a/odb.c +++ b/odb.c @@ -63,7 +63,8 @@ static const struct cached_object *find_cached_object(struct object_database *ob return NULL; } -int odb_mkstemp(struct strbuf *temp_filename, const char *pattern) +int odb_mkstemp(struct object_database *odb, + struct strbuf *temp_filename, const char *pattern) { int fd; /* @@ -71,15 +72,15 @@ int odb_mkstemp(struct strbuf *temp_filename, const char *pattern) * restrictive except to remove write permission. */ int mode = 0444; - repo_git_path_replace(the_repository, temp_filename, "objects/%s", pattern); + repo_git_path_replace(odb->repo, temp_filename, "objects/%s", pattern); fd = git_mkstemp_mode(temp_filename->buf, mode); if (0 <= fd) return fd; /* slow path */ /* some mkstemp implementations erase temp_filename on failure */ - repo_git_path_replace(the_repository, temp_filename, "objects/%s", pattern); - safe_create_leading_directories(the_repository, temp_filename->buf); + repo_git_path_replace(odb->repo, temp_filename, "objects/%s", pattern); + safe_create_leading_directories(odb->repo, temp_filename->buf); return xmkstemp_mode(temp_filename->buf, mode); } diff --git a/odb.h b/odb.h index 13f5da45f54949..5de952608f3a3c 100644 --- a/odb.h +++ b/odb.h @@ -201,12 +201,13 @@ void odb_clear(struct object_database *o); struct odb_source *odb_find_source(struct object_database *odb, const char *obj_dir); /* - * Create a temporary file rooted in the object database directory, or - * die on failure. The filename is taken from "pattern", which should have the + * Create a temporary file rooted in the primary alternate's directory, or die + * on failure. The filename is taken from "pattern", which should have the * usual "XXXXXX" trailer, and the resulting filename is written into the * "template" buffer. Returns the open descriptor. */ -int odb_mkstemp(struct strbuf *temp_filename, const char *pattern); +int odb_mkstemp(struct object_database *odb, + struct strbuf *temp_filename, const char *pattern); void *repo_read_object_file(struct repository *r, const struct object_id *oid, diff --git a/pack-bitmap-write.c b/pack-bitmap-write.c index 37648b57125567..c847369eaaad14 100644 --- a/pack-bitmap-write.c +++ b/pack-bitmap-write.c @@ -1052,7 +1052,8 @@ void bitmap_writer_finish(struct bitmap_writer *writer, struct bitmap_disk_header header; - int fd = odb_mkstemp(&tmp_file, "pack/tmp_bitmap_XXXXXX"); + int fd = odb_mkstemp(writer->repo->objects, &tmp_file, + "pack/tmp_bitmap_XXXXXX"); if (writer->pseudo_merges_nr) options |= BITMAP_OPT_PSEUDO_MERGES; diff --git a/pack-write.c b/pack-write.c index 6b06315f80ab48..eccdc798e368c3 100644 --- a/pack-write.c +++ b/pack-write.c @@ -84,7 +84,8 @@ const char *write_idx_file(struct repository *repo, } else { if (!index_name) { struct strbuf tmp_file = STRBUF_INIT; - fd = odb_mkstemp(&tmp_file, "pack/tmp_idx_XXXXXX"); + fd = odb_mkstemp(repo->objects, &tmp_file, + "pack/tmp_idx_XXXXXX"); index_name = strbuf_detach(&tmp_file, NULL); } else { unlink(index_name); @@ -259,7 +260,8 @@ char *write_rev_file_order(struct repository *repo, if (flags & WRITE_REV) { if (!rev_name) { struct strbuf tmp_file = STRBUF_INIT; - fd = odb_mkstemp(&tmp_file, "pack/tmp_rev_XXXXXX"); + fd = odb_mkstemp(repo->objects, &tmp_file, + "pack/tmp_rev_XXXXXX"); path = strbuf_detach(&tmp_file, NULL); } else { unlink(rev_name); @@ -342,7 +344,7 @@ static char *write_mtimes_file(struct repository *repo, if (!to_pack) BUG("cannot call write_mtimes_file with NULL packing_data"); - fd = odb_mkstemp(&tmp_file, "pack/tmp_mtimes_XXXXXX"); + fd = odb_mkstemp(repo->objects, &tmp_file, "pack/tmp_mtimes_XXXXXX"); mtimes_name = strbuf_detach(&tmp_file, NULL); f = hashfd(repo->hash_algo, fd, mtimes_name); @@ -531,7 +533,7 @@ struct hashfile *create_tmp_packfile(struct repository *repo, struct strbuf tmpname = STRBUF_INIT; int fd; - fd = odb_mkstemp(&tmpname, "pack/tmp_pack_XXXXXX"); + fd = odb_mkstemp(repo->objects, &tmpname, "pack/tmp_pack_XXXXXX"); *pack_tmp_name = strbuf_detach(&tmpname, NULL); return hashfd(repo->hash_algo, fd, *pack_tmp_name); } From c44185f6c10fb2d306efe505112982a7c3b93789 Mon Sep 17 00:00:00 2001 From: Patrick Steinhardt Date: Tue, 1 Jul 2025 14:22:20 +0200 Subject: [PATCH 11/21] odb: get rid of `the_repository` when handling alternates The functions to manage alternates all depend on `the_repository`. Refactor them to accept an object database as a parameter and adjust all callers. The functions are renamed accordingly. Note that right now the situation is still somewhat weird because we end up using the object store path provided by the object store's repository anyway. Consequently, we could have instead passed in a pointer to the repository instead of passing in the pointer to the object store. This will be addressed in subsequent commits though, where we will start to use the path owned by the object store itself. Signed-off-by: Patrick Steinhardt Signed-off-by: Junio C Hamano --- builtin/clone.c | 10 +++++--- builtin/fsck.c | 6 ++--- builtin/grep.c | 2 +- builtin/repack.c | 3 ++- commit-graph.c | 4 +-- loose.c | 2 +- object-file.c | 10 ++++---- object-name.c | 2 +- odb.c | 44 +++++++++++++++----------------- odb.h | 53 ++++++++++++++++++++++++++------------- packfile.c | 4 +-- submodule.c | 3 ++- t/helper/test-ref-store.c | 2 +- tmp-objdir.c | 2 +- 14 files changed, 83 insertions(+), 64 deletions(-) diff --git a/builtin/clone.c b/builtin/clone.c index 1eafeefb48d1fc..3aabdf6570b71b 100644 --- a/builtin/clone.c +++ b/builtin/clone.c @@ -171,7 +171,7 @@ static int add_one_reference(struct string_list_item *item, void *cb_data) } else { struct strbuf sb = STRBUF_INIT; strbuf_addf(&sb, "%s/objects", ref_git); - add_to_alternates_file(sb.buf); + odb_add_to_alternates_file(the_repository->objects, sb.buf); strbuf_release(&sb); } @@ -212,12 +212,14 @@ static void copy_alternates(struct strbuf *src, const char *src_repo) if (!line.len || line.buf[0] == '#') continue; if (is_absolute_path(line.buf)) { - add_to_alternates_file(line.buf); + odb_add_to_alternates_file(the_repository->objects, + line.buf); continue; } abs_path = mkpathdup("%s/objects/%s", src_repo, line.buf); if (!normalize_path_copy(abs_path, abs_path)) - add_to_alternates_file(abs_path); + odb_add_to_alternates_file(the_repository->objects, + abs_path); else warning("skipping invalid relative alternate: %s/%s", src_repo, line.buf); @@ -352,7 +354,7 @@ static void clone_local(const char *src_repo, const char *dest_repo) struct strbuf alt = STRBUF_INIT; get_common_dir(&alt, src_repo); strbuf_addstr(&alt, "/objects"); - add_to_alternates_file(alt.buf); + odb_add_to_alternates_file(the_repository->objects, alt.buf); strbuf_release(&alt); } else { struct strbuf src = STRBUF_INIT; diff --git a/builtin/fsck.c b/builtin/fsck.c index 9abd7b255808a0..014aa1344e26b4 100644 --- a/builtin/fsck.c +++ b/builtin/fsck.c @@ -997,7 +997,7 @@ int cmd_fsck(int argc, for_each_packed_object(the_repository, mark_packed_for_connectivity, NULL, 0); } else { - prepare_alt_odb(the_repository); + odb_prepare_alternates(the_repository->objects); for (source = the_repository->objects->sources; source; source = source->next) fsck_object_dir(source->path); @@ -1108,7 +1108,7 @@ int cmd_fsck(int argc, if (the_repository->settings.core_commit_graph) { struct child_process commit_graph_verify = CHILD_PROCESS_INIT; - prepare_alt_odb(the_repository); + odb_prepare_alternates(the_repository->objects); for (source = the_repository->objects->sources; source; source = source->next) { child_process_init(&commit_graph_verify); commit_graph_verify.git_cmd = 1; @@ -1126,7 +1126,7 @@ int cmd_fsck(int argc, if (the_repository->settings.core_multi_pack_index) { struct child_process midx_verify = CHILD_PROCESS_INIT; - prepare_alt_odb(the_repository); + odb_prepare_alternates(the_repository->objects); for (source = the_repository->objects->sources; source; source = source->next) { child_process_init(&midx_verify); midx_verify.git_cmd = 1; diff --git a/builtin/grep.c b/builtin/grep.c index a1d7ee7af39687..336cfcab6fbce8 100644 --- a/builtin/grep.c +++ b/builtin/grep.c @@ -462,7 +462,7 @@ static int grep_submodule(struct grep_opt *opt, /* * NEEDSWORK: repo_read_gitmodules() might call - * add_to_alternates_memory() via config_from_gitmodules(). This + * odb_add_to_alternates_memory() via config_from_gitmodules(). This * operation causes a race condition with concurrent object readings * performed by the worker threads. That's why we need obj_read_lock() * here. It should be removed once it's no longer necessary to add the diff --git a/builtin/repack.c b/builtin/repack.c index 167823200586fb..8145474cf8d98b 100644 --- a/builtin/repack.c +++ b/builtin/repack.c @@ -1256,7 +1256,8 @@ int cmd_repack(int argc, if (write_bitmaps && !(pack_everything & ALL_INTO_ONE) && !write_midx) die(_(incremental_bitmap_conflict_error)); - if (write_bitmaps && po_args.local && has_alt_odb(the_repository)) { + if (write_bitmaps && po_args.local && + odb_has_alternates(the_repository->objects)) { /* * When asked to do a local repack, but we have * packfiles that are inherited from an alternate, then diff --git a/commit-graph.c b/commit-graph.c index 6ced5b366e7101..59265f89385a39 100644 --- a/commit-graph.c +++ b/commit-graph.c @@ -649,7 +649,7 @@ struct commit_graph *load_commit_graph_chain_fd_st(struct repository *r, count = st->st_size / (the_hash_algo->hexsz + 1); CALLOC_ARRAY(oids, count); - prepare_alt_odb(r); + odb_prepare_alternates(r->objects); for (i = 0; i < count; i++) { struct odb_source *source; @@ -778,7 +778,7 @@ static int prepare_commit_graph(struct repository *r) if (!commit_graph_compatible(r)) return 0; - prepare_alt_odb(r); + odb_prepare_alternates(r->objects); for (source = r->objects->sources; !r->objects->commit_graph && source; source = source->next) diff --git a/loose.c b/loose.c index fab4041c03d50b..519f5db79352a1 100644 --- a/loose.c +++ b/loose.c @@ -112,7 +112,7 @@ int repo_read_loose_object_map(struct repository *repo) if (!should_use_loose_object_map(repo)) return 0; - prepare_alt_odb(repo); + odb_prepare_alternates(repo->objects); for (source = repo->objects->sources; source; source = source->next) { if (load_one_loose_object_map(repo, source) < 0) { diff --git a/object-file.c b/object-file.c index 2d3af8a77c0f5b..04da19a1a3bd77 100644 --- a/object-file.c +++ b/object-file.c @@ -106,7 +106,7 @@ static int check_and_freshen_nonlocal(const struct object_id *oid, int freshen) { struct odb_source *source; - prepare_alt_odb(the_repository); + odb_prepare_alternates(the_repository->objects); for (source = the_repository->objects->sources->next; source; source = source->next) { if (check_and_freshen_odb(source, oid, freshen)) return 1; @@ -205,7 +205,7 @@ static int stat_loose_object(struct repository *r, const struct object_id *oid, struct odb_source *source; static struct strbuf buf = STRBUF_INIT; - prepare_alt_odb(r); + odb_prepare_alternates(r->objects); for (source = r->objects->sources; source; source = source->next) { *path = odb_loose_path(source, &buf, oid); if (!lstat(*path, st)) @@ -227,7 +227,7 @@ static int open_loose_object(struct repository *r, int most_interesting_errno = ENOENT; static struct strbuf buf = STRBUF_INIT; - prepare_alt_odb(r); + odb_prepare_alternates(r->objects); for (source = r->objects->sources; source; source = source->next) { *path = odb_loose_path(source, &buf, oid); fd = git_open(*path); @@ -246,7 +246,7 @@ static int quick_has_loose(struct repository *r, { struct odb_source *source; - prepare_alt_odb(r); + odb_prepare_alternates(r->objects); for (source = r->objects->sources; source; source = source->next) { if (oidtree_contains(odb_loose_cache(source, oid), oid)) return 1; @@ -1439,7 +1439,7 @@ int for_each_loose_object(each_loose_object_fn cb, void *data, { struct odb_source *source; - prepare_alt_odb(the_repository); + odb_prepare_alternates(the_repository->objects); for (source = the_repository->objects->sources; source; source = source->next) { int r = for_each_loose_file_in_objdir(source->path, cb, NULL, NULL, data); diff --git a/object-name.c b/object-name.c index 544634d0f409f4..381536e900e365 100644 --- a/object-name.c +++ b/object-name.c @@ -376,7 +376,7 @@ static int init_object_disambiguation(struct repository *r, ds->hex_pfx[len] = '\0'; ds->repo = r; ds->bin_pfx.algo = algo ? hash_algo_by_ptr(algo) : GIT_HASH_UNKNOWN; - prepare_alt_odb(r); + odb_prepare_alternates(r->objects); return 0; } diff --git a/odb.c b/odb.c index 8967e9fd548bd5..691a8c7c68157f 100644 --- a/odb.c +++ b/odb.c @@ -272,10 +272,11 @@ static void read_info_alternates(struct object_database *odb, free(path); } -void add_to_alternates_file(const char *reference) +void odb_add_to_alternates_file(struct object_database *odb, + const char *reference) { struct lock_file lock = LOCK_INIT; - char *alts = repo_git_path(the_repository, "objects/info/alternates"); + char *alts = repo_git_path(odb->repo, "objects/info/alternates"); FILE *in, *out; int found = 0; @@ -308,22 +309,23 @@ void add_to_alternates_file(const char *reference) fprintf_or_die(out, "%s\n", reference); if (commit_lock_file(&lock)) die_errno(_("unable to move new alternates file into place")); - if (the_repository->objects->loaded_alternates) - link_alt_odb_entries(the_repository->objects, reference, + if (odb->loaded_alternates) + link_alt_odb_entries(odb, reference, '\n', NULL, 0); } free(alts); } -void add_to_alternates_memory(const char *reference) +void odb_add_to_alternates_memory(struct object_database *odb, + const char *reference) { /* * Make sure alternates are initialized, or else our entry may be * overwritten when they are. */ - prepare_alt_odb(the_repository); + odb_prepare_alternates(odb); - link_alt_odb_entries(the_repository->objects, reference, + link_alt_odb_entries(odb, reference, '\n', NULL, 0); } @@ -335,7 +337,7 @@ struct odb_source *set_temporary_primary_odb(const char *dir, int will_destroy) * Make sure alternates are initialized, or else our entry may be * overwritten when they are. */ - prepare_alt_odb(the_repository); + odb_prepare_alternates(the_repository->objects); /* * Make a new primary odb and link the old primary ODB in as an @@ -379,12 +381,6 @@ void restore_primary_odb(struct odb_source *restore_alt, const char *old_path) free_object_directory(cur_alt); } -/* - * Compute the exact path an alternate is at and returns it. In case of - * error NULL is returned and the human readable error is added to `err` - * `path` may be relative and should point to $GIT_DIR. - * `err` must not be null. - */ char *compute_alternate_path(const char *path, struct strbuf *err) { char *ref_git = NULL; @@ -455,7 +451,7 @@ struct odb_source *odb_find_source(struct object_database *odb, const char *obj_ char *obj_dir_real = real_pathdup(obj_dir, 1); struct strbuf odb_path_real = STRBUF_INIT; - prepare_alt_odb(odb->repo); + odb_prepare_alternates(odb); for (source = odb->sources; source; source = source->next) { strbuf_realpath(&odb_path_real, source->path, 1); if (!strcmp(obj_dir_real, odb_path_real.buf)) @@ -573,7 +569,7 @@ int foreach_alt_odb(alt_odb_fn fn, void *cb) struct odb_source *alternate; int r = 0; - prepare_alt_odb(the_repository); + odb_prepare_alternates(the_repository->objects); for (alternate = the_repository->objects->sources->next; alternate; alternate = alternate->next) { r = fn(alternate, cb); if (r) @@ -582,21 +578,21 @@ int foreach_alt_odb(alt_odb_fn fn, void *cb) return r; } -void prepare_alt_odb(struct repository *r) +void odb_prepare_alternates(struct object_database *odb) { - if (r->objects->loaded_alternates) + if (odb->loaded_alternates) return; - link_alt_odb_entries(r->objects, r->objects->alternate_db, PATH_SEP, NULL, 0); + link_alt_odb_entries(odb, odb->alternate_db, PATH_SEP, NULL, 0); - read_info_alternates(r->objects, r->objects->sources->path, 0); - r->objects->loaded_alternates = 1; + read_info_alternates(odb, odb->sources->path, 0); + odb->loaded_alternates = 1; } -int has_alt_odb(struct repository *r) +int odb_has_alternates(struct object_database *odb) { - prepare_alt_odb(r); - return !!r->objects->sources->next; + odb_prepare_alternates(odb); + return !!odb->sources->next; } int obj_read_use_lock = 0; diff --git a/odb.h b/odb.h index 5de952608f3a3c..eba16929a81f29 100644 --- a/odb.h +++ b/odb.h @@ -13,6 +13,14 @@ struct oidtree; struct strbuf; struct repository; +/* + * Compute the exact path an alternate is at and returns it. In case of + * error NULL is returned and the human readable error is added to `err` + * `path` may be relative and should point to $GIT_DIR. + * `err` must not be null. + */ +char *compute_alternate_path(const char *path, struct strbuf *err); + /* * The source is the part of the object database that stores the actual * objects. It thus encapsulates the logic to read and write the specific @@ -65,27 +73,11 @@ struct odb_source { char *path; }; -void prepare_alt_odb(struct repository *r); -int has_alt_odb(struct repository *r); -char *compute_alternate_path(const char *path, struct strbuf *err); typedef int alt_odb_fn(struct odb_source *, void *); int foreach_alt_odb(alt_odb_fn, void*); typedef void alternate_ref_fn(const struct object_id *oid, void *); void for_each_alternate_ref(alternate_ref_fn, void *); -/* - * Add the directory to the on-disk alternates file; the new entry will also - * take effect in the current process. - */ -void add_to_alternates_file(const char *dir); - -/* - * Add the directory to the in-memory list of alternates (along with any - * recursive alternates it points to), but do not modify the on-disk alternates - * file. - */ -void add_to_alternates_memory(const char *dir); - /* * Replace the current writable object directory with the specified temporary * object directory; returns the former primary object directory. @@ -124,7 +116,7 @@ struct object_database { /* * A list of alternate object directories loaded from the environment; * this should not generally need to be accessed directly, but will - * populate the "sources" list when prepare_alt_odb() is run. + * populate the "sources" list when odb_prepare_alternates() is run. */ char *alternate_db; @@ -209,6 +201,33 @@ struct odb_source *odb_find_source(struct object_database *odb, const char *obj_ int odb_mkstemp(struct object_database *odb, struct strbuf *temp_filename, const char *pattern); +/* + * Prepare alternate object sources for the given database by reading + * "objects/info/alternates" and opening the respective sources. + */ +void odb_prepare_alternates(struct object_database *odb); + +/* + * Check whether the object database has any alternates. The primary object + * source does not count as alternate. + */ +int odb_has_alternates(struct object_database *odb); + +/* + * Add the directory to the on-disk alternates file; the new entry will also + * take effect in the current process. + */ +void odb_add_to_alternates_file(struct object_database *odb, + const char *dir); + +/* + * Add the directory to the in-memory list of alternate sources (along with any + * recursive alternates it points to), but do not modify the on-disk alternates + * file. + */ +void odb_add_to_alternates_memory(struct object_database *odb, + const char *dir); + void *repo_read_object_file(struct repository *r, const struct object_id *oid, enum object_type *type, diff --git a/packfile.c b/packfile.c index 346c2f9ce90574..ac0e29e99b9165 100644 --- a/packfile.c +++ b/packfile.c @@ -1034,7 +1034,7 @@ static void prepare_packed_git(struct repository *r) if (r->objects->packed_git_initialized) return; - prepare_alt_odb(r); + odb_prepare_alternates(r->objects); for (source = r->objects->sources; source; source = source->next) { int local = (source == r->objects->sources); prepare_multi_pack_index_one(r, source->path, local); @@ -1059,7 +1059,7 @@ void reprepare_packed_git(struct repository *r) * the lifetime of the process. */ r->objects->loaded_alternates = 0; - prepare_alt_odb(r); + odb_prepare_alternates(r->objects); for (source = r->objects->sources; source; source = source->next) odb_clear_loose_cache(source); diff --git a/submodule.c b/submodule.c index 9b1018877df8b7..386be2342307be 100644 --- a/submodule.c +++ b/submodule.c @@ -189,7 +189,8 @@ int register_all_submodule_odb_as_alternates(void) int ret = added_submodule_odb_paths.nr; for (i = 0; i < added_submodule_odb_paths.nr; i++) - add_to_alternates_memory(added_submodule_odb_paths.items[i].string); + odb_add_to_alternates_memory(the_repository->objects, + added_submodule_odb_paths.items[i].string); if (ret) { string_list_clear(&added_submodule_odb_paths, 0); trace2_data_intmax("submodule", the_repository, diff --git a/t/helper/test-ref-store.c b/t/helper/test-ref-store.c index 2920ca59d72f53..8d9a271845c4b6 100644 --- a/t/helper/test-ref-store.c +++ b/t/helper/test-ref-store.c @@ -79,7 +79,7 @@ static const char **get_store(const char **argv, struct ref_store **refs) if (!repo_submodule_path_append(the_repository, &sb, gitdir, "objects/")) die("computing submodule path failed"); - add_to_alternates_memory(sb.buf); + odb_add_to_alternates_memory(the_repository->objects, sb.buf); strbuf_release(&sb); *refs = repo_get_submodule_ref_store(the_repository, gitdir); diff --git a/tmp-objdir.c b/tmp-objdir.c index bef2f917cd2f2a..4120badf5ceb93 100644 --- a/tmp-objdir.c +++ b/tmp-objdir.c @@ -304,7 +304,7 @@ const char **tmp_objdir_env(const struct tmp_objdir *t) void tmp_objdir_add_as_alternate(const struct tmp_objdir *t) { - add_to_alternates_memory(t->path.buf); + odb_add_to_alternates_memory(t->repo->objects, t->path.buf); } void tmp_objdir_replace_primary_odb(struct tmp_objdir *t, int will_destroy) From 798c661ce39f7d5297fa7ea8928ae464b6d5dd95 Mon Sep 17 00:00:00 2001 From: Patrick Steinhardt Date: Tue, 1 Jul 2025 14:22:21 +0200 Subject: [PATCH 12/21] odb: get rid of `the_repository` in `for_each()` functions There are a couple of iterator-style functions that execute a callback for each instance of a given set, all of which currently depend on `the_repository`. Refactor them to instead take an object database as parameter so that we can get rid of this dependency. Rename the functions accordingly. Signed-off-by: Patrick Steinhardt Signed-off-by: Junio C Hamano --- builtin/count-objects.c | 2 +- builtin/receive-pack.c | 3 ++- builtin/submodule--helper.c | 3 ++- diagnose.c | 2 +- fetch-pack.c | 3 ++- odb.c | 36 +++++++++++++++++++----------------- odb.h | 23 ++++++++++++++++++----- revision.c | 3 ++- 8 files changed, 47 insertions(+), 28 deletions(-) diff --git a/builtin/count-objects.c b/builtin/count-objects.c index 58e0af433d1658..f687647931e0e2 100644 --- a/builtin/count-objects.c +++ b/builtin/count-objects.c @@ -159,7 +159,7 @@ int cmd_count_objects(int argc, printf("prune-packable: %lu\n", packed_loose); printf("garbage: %lu\n", garbage); printf("size-garbage: %s\n", garbage_buf.buf); - foreach_alt_odb(print_alternate, NULL); + odb_for_each_alternate(the_repository->objects, print_alternate, NULL); strbuf_release(&loose_buf); strbuf_release(&pack_buf); strbuf_release(&garbage_buf); diff --git a/builtin/receive-pack.c b/builtin/receive-pack.c index 0f5958c4a6601e..7ea273d93e40ae 100644 --- a/builtin/receive-pack.c +++ b/builtin/receive-pack.c @@ -359,7 +359,8 @@ static void write_head_info(void) refs_for_each_fullref_in(get_main_ref_store(the_repository), "", exclude_patterns, show_ref_cb, &seen); - for_each_alternate_ref(show_one_alternate_ref, &seen); + odb_for_each_alternate_ref(the_repository->objects, + show_one_alternate_ref, &seen); oidset_clear(&seen); strvec_clear(&excludes_vector); diff --git a/builtin/submodule--helper.c b/builtin/submodule--helper.c index 84f7fa53424ceb..7ca483cab52bac 100644 --- a/builtin/submodule--helper.c +++ b/builtin/submodule--helper.c @@ -1668,7 +1668,8 @@ static void prepare_possible_alternates(const char *sm_name, die(_("Value '%s' for submodule.alternateErrorStrategy is not recognized"), error_strategy); if (!strcmp(sm_alternate, "superproject")) - foreach_alt_odb(add_possible_reference_from_superproject, &sas); + odb_for_each_alternate(the_repository->objects, + add_possible_reference_from_superproject, &sas); else if (!strcmp(sm_alternate, "no")) ; /* do nothing */ else diff --git a/diagnose.c b/diagnose.c index ad0d5c1246558d..5092bf80d35fdd 100644 --- a/diagnose.c +++ b/diagnose.c @@ -229,7 +229,7 @@ int create_diagnostics_archive(struct repository *r, strbuf_reset(&buf); strbuf_addstr(&buf, "--add-virtual-file=packs-local.txt:"); dir_file_stats(r->objects->sources, &buf); - foreach_alt_odb(dir_file_stats, &buf); + odb_for_each_alternate(r->objects, dir_file_stats, &buf); strvec_push(&archiver_args, buf.buf); strbuf_reset(&buf); diff --git a/fetch-pack.c b/fetch-pack.c index cf157f5d7e583e..47fa7fa4c492cb 100644 --- a/fetch-pack.c +++ b/fetch-pack.c @@ -115,7 +115,8 @@ static void for_each_cached_alternate(struct fetch_negotiator *negotiator, size_t i; if (!initialized) { - for_each_alternate_ref(cache_one_alternate, &cache); + odb_for_each_alternate_ref(the_repository->objects, + cache_one_alternate, &cache); initialized = 1; } diff --git a/odb.c b/odb.c index 691a8c7c68157f..03fb68605c1f11 100644 --- a/odb.c +++ b/odb.c @@ -494,8 +494,8 @@ static void fill_alternate_refs_command(struct child_process *cmd, } static void read_alternate_refs(const char *path, - alternate_ref_fn *cb, - void *data) + odb_for_each_alternate_ref_fn *cb, + void *payload) { struct child_process cmd = CHILD_PROCESS_INIT; struct strbuf line = STRBUF_INIT; @@ -517,7 +517,7 @@ static void read_alternate_refs(const char *path, break; } - cb(&oid, data); + cb(&oid, payload); } fclose(fh); @@ -526,16 +526,16 @@ static void read_alternate_refs(const char *path, } struct alternate_refs_data { - alternate_ref_fn *fn; - void *data; + odb_for_each_alternate_ref_fn *fn; + void *payload; }; static int refs_from_alternate_cb(struct odb_source *alternate, - void *data) + void *payload) { struct strbuf path = STRBUF_INIT; size_t base_len; - struct alternate_refs_data *cb = data; + struct alternate_refs_data *cb = payload; if (!strbuf_realpath(&path, alternate->path, 0)) goto out; @@ -549,29 +549,31 @@ static int refs_from_alternate_cb(struct odb_source *alternate, goto out; strbuf_setlen(&path, base_len); - read_alternate_refs(path.buf, cb->fn, cb->data); + read_alternate_refs(path.buf, cb->fn, cb->payload); out: strbuf_release(&path); return 0; } -void for_each_alternate_ref(alternate_ref_fn fn, void *data) +void odb_for_each_alternate_ref(struct object_database *odb, + odb_for_each_alternate_ref_fn cb, void *payload) { - struct alternate_refs_data cb; - cb.fn = fn; - cb.data = data; - foreach_alt_odb(refs_from_alternate_cb, &cb); + struct alternate_refs_data data; + data.fn = cb; + data.payload = payload; + odb_for_each_alternate(odb, refs_from_alternate_cb, &data); } -int foreach_alt_odb(alt_odb_fn fn, void *cb) +int odb_for_each_alternate(struct object_database *odb, + odb_for_each_alternate_fn cb, void *payload) { struct odb_source *alternate; int r = 0; - odb_prepare_alternates(the_repository->objects); - for (alternate = the_repository->objects->sources->next; alternate; alternate = alternate->next) { - r = fn(alternate, cb); + odb_prepare_alternates(odb); + for (alternate = odb->sources->next; alternate; alternate = alternate->next) { + r = cb(alternate, payload); if (r) break; } diff --git a/odb.h b/odb.h index eba16929a81f29..7e65e9707c1af7 100644 --- a/odb.h +++ b/odb.h @@ -73,11 +73,6 @@ struct odb_source { char *path; }; -typedef int alt_odb_fn(struct odb_source *, void *); -int foreach_alt_odb(alt_odb_fn, void*); -typedef void alternate_ref_fn(const struct object_id *oid, void *); -void for_each_alternate_ref(alternate_ref_fn, void *); - /* * Replace the current writable object directory with the specified temporary * object directory; returns the former primary object directory. @@ -192,6 +187,24 @@ void odb_clear(struct object_database *o); */ struct odb_source *odb_find_source(struct object_database *odb, const char *obj_dir); +/* + * Iterate through all alternates of the database and execute the provided + * callback function for each of them. Stop iterating once the callback + * function returns a non-zero value, in which case the value is bubbled up + * from the callback. + */ +typedef int odb_for_each_alternate_fn(struct odb_source *, void *); +int odb_for_each_alternate(struct object_database *odb, + odb_for_each_alternate_fn cb, void *payload); + +/* + * Iterate through all alternates of the database and yield their respective + * references. + */ +typedef void odb_for_each_alternate_ref_fn(const struct object_id *oid, void *); +void odb_for_each_alternate_ref(struct object_database *odb, + odb_for_each_alternate_ref_fn cb, void *payload); + /* * Create a temporary file rooted in the primary alternate's directory, or die * on failure. The filename is taken from "pattern", which should have the diff --git a/revision.c b/revision.c index cdefe7d6e482cb..b0364f556ee220 100644 --- a/revision.c +++ b/revision.c @@ -1907,7 +1907,8 @@ static void add_alternate_refs_to_pending(struct rev_info *revs, struct add_alternate_refs_data data; data.revs = revs; data.flags = flags; - for_each_alternate_ref(add_one_alternate_ref, &data); + odb_for_each_alternate_ref(the_repository->objects, + add_one_alternate_ref, &data); } static int add_parents_only(struct rev_info *revs, const char *arg_, int flags, From 7eafd4472d7c273e10a408da6662ca9d4b9800fd Mon Sep 17 00:00:00 2001 From: Patrick Steinhardt Date: Tue, 1 Jul 2025 14:22:22 +0200 Subject: [PATCH 13/21] odb: get rid of `the_repository` when handling the primary source The functions `set_temporary_primary_odb()` and `restore_primary_odb()` are responsible for managing a temporary primary source for the database. Both of these functions implicitly rely on `the_repository`. Refactor them to instead take an explicit object database parameter as argument and adjust callers. Rename the functions accordingly. Signed-off-by: Patrick Steinhardt Signed-off-by: Junio C Hamano --- odb.c | 27 +++++++++++++++------------ odb.h | 26 +++++++++++++++----------- tmp-objdir.c | 10 ++++++---- 3 files changed, 36 insertions(+), 27 deletions(-) diff --git a/odb.c b/odb.c index 03fb68605c1f11..4f03be7f770081 100644 --- a/odb.c +++ b/odb.c @@ -329,7 +329,8 @@ void odb_add_to_alternates_memory(struct object_database *odb, '\n', NULL, 0); } -struct odb_source *set_temporary_primary_odb(const char *dir, int will_destroy) +struct odb_source *odb_set_temporary_primary_source(struct object_database *odb, + const char *dir, int will_destroy) { struct odb_source *source; @@ -337,14 +338,14 @@ struct odb_source *set_temporary_primary_odb(const char *dir, int will_destroy) * Make sure alternates are initialized, or else our entry may be * overwritten when they are. */ - odb_prepare_alternates(the_repository->objects); + odb_prepare_alternates(odb); /* * Make a new primary odb and link the old primary ODB in as an * alternate */ source = xcalloc(1, sizeof(*source)); - source->odb = the_repository->objects; + source->odb = odb; source->path = xstrdup(dir); /* @@ -353,8 +354,8 @@ struct odb_source *set_temporary_primary_odb(const char *dir, int will_destroy) */ source->disable_ref_updates = 1; source->will_destroy = will_destroy; - source->next = the_repository->objects->sources; - the_repository->objects->sources = source; + source->next = odb->sources; + odb->sources = source; return source->next; } @@ -366,19 +367,21 @@ static void free_object_directory(struct odb_source *source) free(source); } -void restore_primary_odb(struct odb_source *restore_alt, const char *old_path) +void odb_restore_primary_source(struct object_database *odb, + struct odb_source *restore_source, + const char *old_path) { - struct odb_source *cur_alt = the_repository->objects->sources; + struct odb_source *cur_source = odb->sources; - if (strcmp(old_path, cur_alt->path)) + if (strcmp(old_path, cur_source->path)) BUG("expected %s as primary object store; found %s", - old_path, cur_alt->path); + old_path, cur_source->path); - if (cur_alt->next != restore_alt) + if (cur_source->next != restore_source) BUG("we expect the old primary object store to be the first alternate"); - the_repository->objects->sources = restore_alt; - free_object_directory(cur_alt); + odb->sources = restore_source; + free_object_directory(cur_source); } char *compute_alternate_path(const char *path, struct strbuf *err) diff --git a/odb.h b/odb.h index 7e65e9707c1af7..4e2d1004f8a5a1 100644 --- a/odb.h +++ b/odb.h @@ -73,17 +73,6 @@ struct odb_source { char *path; }; -/* - * Replace the current writable object directory with the specified temporary - * object directory; returns the former primary object directory. - */ -struct odb_source *set_temporary_primary_odb(const char *dir, int will_destroy); - -/* - * Restore a previous ODB replaced by set_temporary_main_odb. - */ -void restore_primary_odb(struct odb_source *restore_alternate, const char *old_path); - struct packed_git; struct multi_pack_index; struct cached_object_entry; @@ -187,6 +176,21 @@ void odb_clear(struct object_database *o); */ struct odb_source *odb_find_source(struct object_database *odb, const char *obj_dir); +/* + * Replace the current writable object directory with the specified temporary + * object directory; returns the former primary source. + */ +struct odb_source *odb_set_temporary_primary_source(struct object_database *odb, + const char *dir, int will_destroy); + +/* + * Restore the primary source that was previously replaced by + * `odb_set_temporary_primary_source()`. + */ +void odb_restore_primary_source(struct object_database *odb, + struct odb_source *restore_source, + const char *old_path); + /* * Iterate through all alternates of the database and execute the provided * callback function for each of them. Stop iterating once the callback diff --git a/tmp-objdir.c b/tmp-objdir.c index 4120badf5ceb93..ae01eae9c415d3 100644 --- a/tmp-objdir.c +++ b/tmp-objdir.c @@ -47,7 +47,7 @@ int tmp_objdir_destroy(struct tmp_objdir *t) the_tmp_objdir = NULL; if (t->prev_source) - restore_primary_odb(t->prev_source, t->path.buf); + odb_restore_primary_source(t->repo->objects, t->prev_source, t->path.buf); err = remove_dir_recursively(&t->path, 0); @@ -279,7 +279,7 @@ int tmp_objdir_migrate(struct tmp_objdir *t) if (t->prev_source) { if (t->repo->objects->sources->will_destroy) BUG("migrating an ODB that was marked for destruction"); - restore_primary_odb(t->prev_source, t->path.buf); + odb_restore_primary_source(t->repo->objects, t->prev_source, t->path.buf); t->prev_source = NULL; } @@ -311,7 +311,8 @@ void tmp_objdir_replace_primary_odb(struct tmp_objdir *t, int will_destroy) { if (t->prev_source) BUG("the primary object database is already replaced"); - t->prev_source = set_temporary_primary_odb(t->path.buf, will_destroy); + t->prev_source = odb_set_temporary_primary_source(t->repo->objects, + t->path.buf, will_destroy); t->will_destroy = will_destroy; } @@ -320,7 +321,8 @@ struct tmp_objdir *tmp_objdir_unapply_primary_odb(void) if (!the_tmp_objdir || !the_tmp_objdir->prev_source) return NULL; - restore_primary_odb(the_tmp_objdir->prev_source, the_tmp_objdir->path.buf); + odb_restore_primary_source(the_tmp_objdir->repo->objects, + the_tmp_objdir->prev_source, the_tmp_objdir->path.buf); the_tmp_objdir->prev_source = NULL; return the_tmp_objdir; } From fc28a8a856a1e7978794e7dee61c42d7d5740a6b Mon Sep 17 00:00:00 2001 From: Patrick Steinhardt Date: Tue, 1 Jul 2025 14:22:23 +0200 Subject: [PATCH 14/21] odb: get rid of `the_repository` when handling submodule sources The "--recursive" flag for git-grep(1) allows users to grep for a string across submodule boundaries. To make this work we add each submodule's object sources to our own object database so that the objects can be accessed directly. The infrastructure for this depends on a global string list of submodule paths. The caller is expected to call `add_submodule_odb_by_path()` for each source and the object database will then eventually register all submodule sources via `do_oid_object_info_extended()` in case it isn't able to look up a specific object. This reliance on global state is of course suboptimal with regards to our libification efforts. Refactor the logic so that the list of submodule sources is instead tracked in the object database itself. This allows us to lose the condition of `r == the_repository` before registering submodule sources as we only ever add submodule sources to `the_repository` anyway. As such, behaviour before and after this refactoring should always be the same. Rename the functions accordingly. Signed-off-by: Patrick Steinhardt Signed-off-by: Junio C Hamano --- builtin/grep.c | 3 ++- odb.c | 37 +++++++++++++++++++++++++++++++------ odb.h | 15 +++++++++++++++ submodule-config.c | 3 ++- submodule.c | 26 -------------------------- submodule.h | 9 --------- 6 files changed, 50 insertions(+), 43 deletions(-) diff --git a/builtin/grep.c b/builtin/grep.c index 336cfcab6fbce8..cfcf916bce1e3e 100644 --- a/builtin/grep.c +++ b/builtin/grep.c @@ -505,7 +505,8 @@ static int grep_submodule(struct grep_opt *opt, * lazily registered as alternates when needed (and except in an * unexpected code interaction, it won't be needed). */ - add_submodule_odb_by_path(subrepo->objects->sources->path); + odb_add_submodule_source_by_path(the_repository->objects, + subrepo->objects->sources->path); obj_read_unlock(); memcpy(&subopt, opt, sizeof(subopt)); diff --git a/odb.c b/odb.c index 4f03be7f770081..f0b27bd936b8d8 100644 --- a/odb.c +++ b/odb.c @@ -24,6 +24,7 @@ #include "strbuf.h" #include "strvec.h" #include "submodule.h" +#include "trace2.h" #include "write-or-die.h" KHASH_INIT(odb_path_map, const char * /* key: odb_path */, @@ -469,6 +470,12 @@ struct odb_source *odb_find_source(struct object_database *odb, const char *obj_ return source; } +void odb_add_submodule_source_by_path(struct object_database *odb, + const char *path) +{ + string_list_insert(&odb->submodule_source_paths, path); +} + static void fill_alternate_refs_command(struct child_process *cmd, const char *repo_path) { @@ -623,6 +630,23 @@ void disable_obj_read_lock(void) int fetch_if_missing = 1; +static int register_all_submodule_sources(struct object_database *odb) +{ + int ret = odb->submodule_source_paths.nr; + + for (size_t i = 0; i < odb->submodule_source_paths.nr; i++) + odb_add_to_alternates_memory(odb, + odb->submodule_source_paths.items[i].string); + if (ret) { + string_list_clear(&odb->submodule_source_paths, 0); + trace2_data_intmax("submodule", odb->repo, + "register_all_submodule_sources/registered", ret); + if (git_env_bool("GIT_TEST_FATAL_REGISTER_SUBMODULE_ODB", 0)) + BUG("register_all_submodule_sources() called"); + } + return ret; +} + static int do_oid_object_info_extended(struct repository *r, const struct object_id *oid, struct object_info *oi, unsigned flags) @@ -676,13 +700,12 @@ static int do_oid_object_info_extended(struct repository *r, } /* - * If r is the_repository, this might be an attempt at - * accessing a submodule object as if it were in the_repository - * (having called add_submodule_odb() on that submodule's ODB). - * If any such ODBs exist, register them and try again. + * This might be an attempt at accessing a submodule object as + * if it were in main object store (having called + * `odb_add_submodule_source_by_path()` on that submodule's + * ODB). If any such ODBs exist, register them and try again. */ - if (r == the_repository && - register_all_submodule_odb_as_alternates()) + if (register_all_submodule_sources(r->objects)) /* We added some alternates; retry */ continue; @@ -968,6 +991,7 @@ struct object_database *odb_new(struct repository *repo) INIT_LIST_HEAD(&o->packed_git_mru); hashmap_init(&o->pack_map, pack_map_entry_cmp, NULL, 0); pthread_mutex_init(&o->replace_mutex, NULL); + string_list_init_dup(&o->submodule_source_paths); return o; } @@ -1017,4 +1041,5 @@ void odb_clear(struct object_database *o) o->packed_git = NULL; hashmap_clear(&o->pack_map); + string_list_clear(&o->submodule_source_paths, 0); } diff --git a/odb.h b/odb.h index 4e2d1004f8a5a1..0ea9d4faa70225 100644 --- a/odb.h +++ b/odb.h @@ -6,6 +6,7 @@ #include "list.h" #include "oidset.h" #include "oidmap.h" +#include "string-list.h" #include "thread-utils.h" struct oidmap; @@ -165,6 +166,12 @@ struct object_database { * packs. */ unsigned packed_git_initialized : 1; + + /* + * Submodule source paths that will be added as additional sources to + * allow lookup of submodule objects via the main object database. + */ + struct string_list submodule_source_paths; }; struct object_database *odb_new(struct repository *repo); @@ -191,6 +198,14 @@ void odb_restore_primary_source(struct object_database *odb, struct odb_source *restore_source, const char *old_path); +/* + * Call odb_add_submodule_source_by_path() to add the submodule at the given + * path to a list. The object stores of all submodules in that list will be + * added as additional sources in the object store when looking up objects. + */ +void odb_add_submodule_source_by_path(struct object_database *odb, + const char *path); + /* * Iterate through all alternates of the database and execute the provided * callback function for each of them. Stop iterating once the callback diff --git a/submodule-config.c b/submodule-config.c index 9c80f9f7b66608..a9f721078889eb 100644 --- a/submodule-config.c +++ b/submodule-config.c @@ -810,7 +810,8 @@ static void config_from_gitmodules(config_fn_t fn, struct repository *repo, void repo_get_oid(repo, GITMODULES_HEAD, &oid) >= 0) { config_source.blob = oidstr = xstrdup(oid_to_hex(&oid)); if (repo != the_repository) - add_submodule_odb_by_path(repo->objects->sources->path); + odb_add_submodule_source_by_path(the_repository->objects, + repo->objects->sources->path); } else { goto out; } diff --git a/submodule.c b/submodule.c index 386be2342307be..788c9e55ed3606 100644 --- a/submodule.c +++ b/submodule.c @@ -31,7 +31,6 @@ #include "commit-reach.h" #include "read-cache-ll.h" #include "setup.h" -#include "trace2.h" static int config_update_recurse_submodules = RECURSE_SUBMODULES_OFF; static int initialized_fetch_ref_tips; @@ -176,31 +175,6 @@ void stage_updated_gitmodules(struct index_state *istate) die(_("staging updated .gitmodules failed")); } -static struct string_list added_submodule_odb_paths = STRING_LIST_INIT_DUP; - -void add_submodule_odb_by_path(const char *path) -{ - string_list_insert(&added_submodule_odb_paths, path); -} - -int register_all_submodule_odb_as_alternates(void) -{ - int i; - int ret = added_submodule_odb_paths.nr; - - for (i = 0; i < added_submodule_odb_paths.nr; i++) - odb_add_to_alternates_memory(the_repository->objects, - added_submodule_odb_paths.items[i].string); - if (ret) { - string_list_clear(&added_submodule_odb_paths, 0); - trace2_data_intmax("submodule", the_repository, - "register_all_submodule_odb_as_alternates/registered", ret); - if (git_env_bool("GIT_TEST_FATAL_REGISTER_SUBMODULE_ODB", 0)) - BUG("register_all_submodule_odb_as_alternates() called"); - } - return ret; -} - void set_diffopt_flags_from_submodule_config(struct diff_options *diffopt, const char *path) { diff --git a/submodule.h b/submodule.h index db980c1d083bc0..b10e16e6c063d2 100644 --- a/submodule.h +++ b/submodule.h @@ -104,15 +104,6 @@ int submodule_uses_gitfile(const char *path); #define SUBMODULE_REMOVAL_IGNORE_IGNORED_UNTRACKED (1<<2) int bad_to_remove_submodule(const char *path, unsigned flags); -/* - * Call add_submodule_odb_by_path() to add the submodule at the given - * path to a list. When register_all_submodule_odb_as_alternates() is - * called, the object stores of all submodules in that list will be - * added as alternates in the_repository. - */ -void add_submodule_odb_by_path(const char *path); -int register_all_submodule_odb_as_alternates(void); - /* * Checks if there are submodule changes in a..b. If a is the null OID, * checks b and all its ancestors instead. From 16cf7494962f20d09dcd8ef20af8962600fafca9 Mon Sep 17 00:00:00 2001 From: Patrick Steinhardt Date: Tue, 1 Jul 2025 14:22:24 +0200 Subject: [PATCH 15/21] odb: trivial refactorings to get rid of `the_repository` All of the external functions provided by the object database subsystem don't depend on `the_repository` anymore, but some internal functions still do. Refactor those cases by plumbing through the repository that owns the object database. This change allows us to get rid of the `USE_THE_REPOSITORY_VARIABLE` preprocessor define. Signed-off-by: Patrick Steinhardt Signed-off-by: Junio C Hamano --- odb.c | 32 ++++++++++++++++---------------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/odb.c b/odb.c index f0b27bd936b8d8..5a88701550eacf 100644 --- a/odb.c +++ b/odb.c @@ -1,5 +1,3 @@ -#define USE_THE_REPOSITORY_VARIABLE - #include "git-compat-util.h" #include "abspath.h" #include "commit-graph.h" @@ -476,12 +474,13 @@ void odb_add_submodule_source_by_path(struct object_database *odb, string_list_insert(&odb->submodule_source_paths, path); } -static void fill_alternate_refs_command(struct child_process *cmd, +static void fill_alternate_refs_command(struct repository *repo, + struct child_process *cmd, const char *repo_path) { const char *value; - if (!git_config_get_value("core.alternateRefsCommand", &value)) { + if (!repo_config_get_value(repo, "core.alternateRefsCommand", &value)) { cmd->use_shell = 1; strvec_push(&cmd->args, value); @@ -493,7 +492,7 @@ static void fill_alternate_refs_command(struct child_process *cmd, strvec_push(&cmd->args, "for-each-ref"); strvec_push(&cmd->args, "--format=%(objectname)"); - if (!git_config_get_value("core.alternateRefsPrefixes", &value)) { + if (!repo_config_get_value(repo, "core.alternateRefsPrefixes", &value)) { strvec_push(&cmd->args, "--"); strvec_split(&cmd->args, value); } @@ -503,7 +502,8 @@ static void fill_alternate_refs_command(struct child_process *cmd, cmd->out = -1; } -static void read_alternate_refs(const char *path, +static void read_alternate_refs(struct repository *repo, + const char *path, odb_for_each_alternate_ref_fn *cb, void *payload) { @@ -511,7 +511,7 @@ static void read_alternate_refs(const char *path, struct strbuf line = STRBUF_INIT; FILE *fh; - fill_alternate_refs_command(&cmd, path); + fill_alternate_refs_command(repo, &cmd, path); if (start_command(&cmd)) return; @@ -521,7 +521,7 @@ static void read_alternate_refs(const char *path, struct object_id oid; const char *p; - if (parse_oid_hex(line.buf, &oid, &p) || *p) { + if (parse_oid_hex_algop(line.buf, &oid, &p, repo->hash_algo) || *p) { warning(_("invalid line while parsing alternate refs: %s"), line.buf); break; @@ -559,7 +559,7 @@ static int refs_from_alternate_cb(struct odb_source *alternate, goto out; strbuf_setlen(&path, base_len); - read_alternate_refs(path.buf, cb->fn, cb->payload); + read_alternate_refs(alternate->odb->repo, path.buf, cb->fn, cb->payload); out: strbuf_release(&path); @@ -677,7 +677,7 @@ static int do_oid_object_info_extended(struct repository *r, if (oi->disk_sizep) *(oi->disk_sizep) = 0; if (oi->delta_base_oid) - oidclr(oi->delta_base_oid, the_repository->hash_algo); + oidclr(oi->delta_base_oid, r->hash_algo); if (oi->contentp) *oi->contentp = xmemdupz(co->buf, co->size); oi->whence = OI_CACHED; @@ -763,10 +763,10 @@ static int oid_object_info_convert(struct repository *r, void *content; int ret; - if (repo_oid_to_algop(r, input_oid, the_hash_algo, &oid)) { + if (repo_oid_to_algop(r, input_oid, r->hash_algo, &oid)) { if (do_die) die(_("missing mapping of %s to %s"), - oid_to_hex(input_oid), the_hash_algo->name); + oid_to_hex(input_oid), r->hash_algo->name); return -1; } @@ -797,8 +797,8 @@ static int oid_object_info_convert(struct repository *r, struct strbuf outbuf = STRBUF_INIT; if (type != OBJ_BLOB) { - ret = convert_object_file(the_repository, &outbuf, - the_hash_algo, input_algo, + ret = convert_object_file(r, &outbuf, + r->hash_algo, input_algo, content, size, type, !do_die); free(content); if (ret == -1) @@ -944,9 +944,9 @@ void *read_object_with_reference(struct repository *r, } ref_length = strlen(ref_type); - if (ref_length + the_hash_algo->hexsz > isize || + if (ref_length + r->hash_algo->hexsz > isize || memcmp(buffer, ref_type, ref_length) || - get_oid_hex((char *) buffer + ref_length, &actual_oid)) { + get_oid_hex_algop((char *) buffer + ref_length, &actual_oid, r->hash_algo)) { free(buffer); return NULL; } From e989dd96b8aa9b20b0e23d3fa845d0baba1b454a Mon Sep 17 00:00:00 2001 From: Patrick Steinhardt Date: Tue, 1 Jul 2025 14:22:25 +0200 Subject: [PATCH 16/21] odb: rename `oid_object_info()` Rename `oid_object_info()` to `odb_read_object_info()` as well as their `_extended()` variant to match other functions related to the object database and our modern coding guidelines. Introduce compatibility wrappers so that any in-flight topics will continue to compile. Signed-off-by: Patrick Steinhardt Signed-off-by: Junio C Hamano --- archive.c | 2 +- blame.c | 4 +-- builtin/blame.c | 4 +-- builtin/cat-file.c | 26 ++++++++------- builtin/describe.c | 3 +- builtin/fast-export.c | 2 +- builtin/fast-import.c | 17 +++++----- builtin/fsck.c | 7 ++-- builtin/gc.c | 2 +- builtin/grep.c | 2 +- builtin/index-pack.c | 13 ++++---- builtin/ls-files.c | 2 +- builtin/ls-tree.c | 4 +-- builtin/mktree.c | 8 ++--- builtin/pack-objects.c | 30 ++++++++++-------- builtin/prune.c | 4 +-- builtin/repack.c | 2 +- builtin/replace.c | 10 +++--- builtin/rev-list.c | 6 ++-- builtin/tag.c | 4 +-- builtin/unpack-objects.c | 2 +- commit-graph.c | 2 +- commit.c | 3 +- diff.c | 18 +++++------ fetch-pack.c | 4 +-- list-objects-filter.c | 2 +- log-tree.c | 2 +- merge-ort.c | 4 +-- object-file.c | 2 +- object-file.h | 2 +- object-name.c | 16 +++++----- object.c | 6 ++-- odb.c | 60 ++++++++++++++++++----------------- odb.h | 46 ++++++++++++++++++++++----- pack-bitmap-write.c | 4 +-- pack-bitmap.c | 8 ++--- packfile.c | 5 +-- promisor-remote.c | 4 +-- protocol-caps.c | 2 +- reachable.c | 2 +- read-cache.c | 6 ++-- ref-filter.c | 4 +-- remote.c | 5 +-- sequencer.c | 5 ++- streaming.c | 8 ++--- submodule.c | 5 ++- t/helper/test-partial-clone.c | 2 +- tag.c | 2 +- 48 files changed, 213 insertions(+), 170 deletions(-) diff --git a/archive.c b/archive.c index 7fa2cc2596a50e..f2511d530d585b 100644 --- a/archive.c +++ b/archive.c @@ -215,7 +215,7 @@ static int write_archive_entry(const struct object_id *oid, const char *base, /* Stream it? */ if (S_ISREG(mode) && !args->convert && - oid_object_info(args->repo, oid, &size) == OBJ_BLOB && + odb_read_object_info(args->repo->objects, oid, &size) == OBJ_BLOB && size > repo_settings_get_big_file_threshold(the_repository)) return write_entry(args, oid, path.buf, path.len, mode, NULL, size); diff --git a/blame.c b/blame.c index 0ceea080a80cb2..97db3355af4594 100644 --- a/blame.c +++ b/blame.c @@ -116,7 +116,7 @@ static void verify_working_tree_path(struct repository *r, unsigned short mode; if (!get_tree_entry(r, commit_oid, path, &blob_oid, &mode) && - oid_object_info(r, &blob_oid, NULL) == OBJ_BLOB) + odb_read_object_info(r->objects, &blob_oid, NULL) == OBJ_BLOB) return; } @@ -1245,7 +1245,7 @@ static int fill_blob_sha1_and_mode(struct repository *r, return 0; if (get_tree_entry(r, &origin->commit->object.oid, origin->path, &origin->blob_oid, &origin->mode)) goto error_out; - if (oid_object_info(r, &origin->blob_oid, NULL) != OBJ_BLOB) + if (odb_read_object_info(r->objects, &origin->blob_oid, NULL) != OBJ_BLOB) goto error_out; return 0; error_out: diff --git a/builtin/blame.c b/builtin/blame.c index 15eda60af904e0..91586e6852b09e 100644 --- a/builtin/blame.c +++ b/builtin/blame.c @@ -837,7 +837,7 @@ static int is_a_rev(const char *name) if (repo_get_oid(the_repository, name, &oid)) return 0; - return OBJ_NONE < oid_object_info(the_repository, &oid, NULL); + return OBJ_NONE < odb_read_object_info(the_repository->objects, &oid, NULL); } static int peel_to_commit_oid(struct object_id *oid_ret, void *cbdata) @@ -848,7 +848,7 @@ static int peel_to_commit_oid(struct object_id *oid_ret, void *cbdata) oidcpy(&oid, oid_ret); while (1) { struct object *obj; - int kind = oid_object_info(r, &oid, NULL); + int kind = odb_read_object_info(r->objects, &oid, NULL); if (kind == OBJ_COMMIT) { oidcpy(oid_ret, &oid); return 0; diff --git a/builtin/cat-file.c b/builtin/cat-file.c index f3a925a8183c28..f7595fdb04e901 100644 --- a/builtin/cat-file.c +++ b/builtin/cat-file.c @@ -132,7 +132,7 @@ static int cat_one_file(int opt, const char *exp_type, const char *obj_name) switch (opt) { case 't': oi.typep = &type; - if (oid_object_info_extended(the_repository, &oid, &oi, flags) < 0) + if (odb_read_object_info_extended(the_repository->objects, &oid, &oi, flags) < 0) die("git cat-file: could not get object info"); printf("%s\n", type_name(type)); ret = 0; @@ -146,7 +146,7 @@ static int cat_one_file(int opt, const char *exp_type, const char *obj_name) oi.contentp = (void**)&buf; } - if (oid_object_info_extended(the_repository, &oid, &oi, flags) < 0) + if (odb_read_object_info_extended(the_repository->objects, &oid, &oi, flags) < 0) die("git cat-file: could not get object info"); if (use_mailmap && (type == OBJ_COMMIT || type == OBJ_TAG)) { @@ -180,7 +180,7 @@ static int cat_one_file(int opt, const char *exp_type, const char *obj_name) /* else fallthrough */ case 'p': - type = oid_object_info(the_repository, &oid, NULL); + type = odb_read_object_info(the_repository->objects, &oid, NULL); if (type < 0) die("Not a valid object name %s", obj_name); @@ -217,7 +217,8 @@ static int cat_one_file(int opt, const char *exp_type, const char *obj_name) if (exp_type_id == OBJ_BLOB) { struct object_id blob_oid; - if (oid_object_info(the_repository, &oid, NULL) == OBJ_TAG) { + if (odb_read_object_info(the_repository->objects, + &oid, NULL) == OBJ_TAG) { char *buffer = repo_read_object_file(the_repository, &oid, &type, @@ -235,7 +236,8 @@ static int cat_one_file(int opt, const char *exp_type, const char *obj_name) } else oidcpy(&blob_oid, &oid); - if (oid_object_info(the_repository, &blob_oid, NULL) == OBJ_BLOB) { + if (odb_read_object_info(the_repository->objects, + &blob_oid, NULL) == OBJ_BLOB) { ret = stream_blob(&blob_oid); goto cleanup; } @@ -294,7 +296,7 @@ struct expand_data { /* * After a mark_query run, this object_info is set up to be - * passed to oid_object_info_extended. It will point to the data + * passed to odb_read_object_info_extended. It will point to the data * elements above, so you can retrieve the response from there. */ struct object_info info; @@ -484,12 +486,12 @@ static void batch_object_write(const char *obj_name, data->info.sizep = &data->size; if (pack) - ret = packed_object_info(the_repository, pack, offset, - &data->info); + ret = packed_object_info(the_repository, pack, + offset, &data->info); else - ret = oid_object_info_extended(the_repository, - &data->oid, &data->info, - OBJECT_INFO_LOOKUP_REPLACE); + ret = odb_read_object_info_extended(the_repository->objects, + &data->oid, &data->info, + OBJECT_INFO_LOOKUP_REPLACE); if (ret < 0) { report_object_status(opt, obj_name, &data->oid, "missing"); return; @@ -872,7 +874,7 @@ static int batch_objects(struct batch_options *opt) /* * Expand once with our special mark_query flag, which will prime the - * object_info to be handed to oid_object_info_extended for each + * object_info to be handed to odb_read_object_info_extended for each * object. */ memset(&data, 0, sizeof(data)); diff --git a/builtin/describe.c b/builtin/describe.c index 96cb68e5e5d0e7..fbf305d7624487 100644 --- a/builtin/describe.c +++ b/builtin/describe.c @@ -552,7 +552,8 @@ static void describe(const char *arg, int last_one) if (cmit) describe_commit(&oid, &sb); - else if (oid_object_info(the_repository, &oid, NULL) == OBJ_BLOB) + else if (odb_read_object_info(the_repository->objects, + &oid, NULL) == OBJ_BLOB) describe_blob(oid, &sb); else die(_("%s is neither a commit nor blob"), arg); diff --git a/builtin/fast-export.c b/builtin/fast-export.c index 0505f289a94e16..6c93cf0a8aa1f5 100644 --- a/builtin/fast-export.c +++ b/builtin/fast-export.c @@ -1200,7 +1200,7 @@ static void import_marks(char *input_file, int check_exists) if (last_idnum < mark) last_idnum = mark; - type = oid_object_info(the_repository, &oid, NULL); + type = odb_read_object_info(the_repository->objects, &oid, NULL); if (type < 0) die("object not found: %s", oid_to_hex(&oid)); diff --git a/builtin/fast-import.c b/builtin/fast-import.c index 413304db9b591b..2718376f2c96de 100644 --- a/builtin/fast-import.c +++ b/builtin/fast-import.c @@ -1756,8 +1756,8 @@ static void insert_object_entry(struct mark_set **s, struct object_id *oid, uint struct object_entry *e; e = find_object(oid); if (!e) { - enum object_type type = oid_object_info(the_repository, - oid, NULL); + enum object_type type = odb_read_object_info(the_repository->objects, + oid, NULL); if (type < 0) die("object not found: %s", oid_to_hex(oid)); e = insert_object(oid); @@ -2416,8 +2416,8 @@ static void file_change_m(const char *p, struct branch *b) enum object_type expected = S_ISDIR(mode) ? OBJ_TREE: OBJ_BLOB; enum object_type type = oe ? oe->type : - oid_object_info(the_repository, &oid, - NULL); + odb_read_object_info(the_repository->objects, + &oid, NULL); if (type < 0) die("%s not found: %s", S_ISDIR(mode) ? "Tree" : "Blob", @@ -2553,7 +2553,7 @@ static void note_change_n(const char *p, struct branch *b, unsigned char *old_fa die("Not a blob (actually a %s): %s", type_name(oe->type), command_buf.buf); } else if (!is_null_oid(&oid)) { - enum object_type type = oid_object_info(the_repository, &oid, + enum object_type type = odb_read_object_info(the_repository->objects, &oid, NULL); if (type < 0) die("Blob not found: %s", command_buf.buf); @@ -2895,7 +2895,8 @@ static void parse_new_tag(const char *arg) } else if (!repo_get_oid(the_repository, from, &oid)) { struct object_entry *oe = find_object(&oid); if (!oe) { - type = oid_object_info(the_repository, &oid, NULL); + type = odb_read_object_info(the_repository->objects, + &oid, NULL); if (type < 0) die("Not a valid object: %s", from); } else @@ -3085,8 +3086,8 @@ static struct object_entry *dereference(struct object_entry *oe, const unsigned hexsz = the_hash_algo->hexsz; if (!oe) { - enum object_type type = oid_object_info(the_repository, oid, - NULL); + enum object_type type = odb_read_object_info(the_repository->objects, + oid, NULL); if (type < 0) die("object not found: %s", oid_to_hex(oid)); /* cache it! */ diff --git a/builtin/fsck.c b/builtin/fsck.c index 014aa1344e26b4..6e3465b026696a 100644 --- a/builtin/fsck.c +++ b/builtin/fsck.c @@ -71,7 +71,8 @@ static const char *printable_type(const struct object_id *oid, const char *ret; if (type == OBJ_NONE) - type = oid_object_info(the_repository, oid, NULL); + type = odb_read_object_info(the_repository->objects, + oid, NULL); ret = type_name(type); if (!ret) @@ -232,8 +233,8 @@ static void mark_unreachable_referents(const struct object_id *oid) * (and we want to avoid parsing blobs). */ if (obj->type == OBJ_NONE) { - enum object_type type = oid_object_info(the_repository, - &obj->oid, NULL); + enum object_type type = odb_read_object_info(the_repository->objects, + &obj->oid, NULL); if (type > 0) object_as_type(obj, type, 0); } diff --git a/builtin/gc.c b/builtin/gc.c index 50a09eb07e3f55..ff551fab439a4f 100644 --- a/builtin/gc.c +++ b/builtin/gc.c @@ -1080,7 +1080,7 @@ static int dfs_on_ref(const char *refname UNUSED, if (!peel_iterated_oid(the_repository, oid, &peeled)) oid = &peeled; - if (oid_object_info(the_repository, oid, NULL) != OBJ_COMMIT) + if (odb_read_object_info(the_repository->objects, oid, NULL) != OBJ_COMMIT) return 0; commit = lookup_commit(the_repository, oid); diff --git a/builtin/grep.c b/builtin/grep.c index cfcf916bce1e3e..1435d462cd1883 100644 --- a/builtin/grep.c +++ b/builtin/grep.c @@ -520,7 +520,7 @@ static int grep_submodule(struct grep_opt *opt, struct strbuf base = STRBUF_INIT; obj_read_lock(); - object_type = oid_object_info(subrepo, oid, NULL); + object_type = odb_read_object_info(subrepo->objects, oid, NULL); obj_read_unlock(); data = read_object_with_reference(subrepo, oid, OBJ_TREE, diff --git a/builtin/index-pack.c b/builtin/index-pack.c index 4d4d989eb1a29f..d0b16908122bf0 100644 --- a/builtin/index-pack.c +++ b/builtin/index-pack.c @@ -260,7 +260,8 @@ static unsigned check_object(struct object *obj) if (!(obj->flags & FLAG_CHECKED)) { unsigned long size; - int type = oid_object_info(the_repository, &obj->oid, &size); + int type = odb_read_object_info(the_repository->objects, + &obj->oid, &size); if (type <= 0) die(_("did not receive expected object %s"), oid_to_hex(&obj->oid)); @@ -908,7 +909,7 @@ static void sha1_object(const void *data, struct object_entry *obj_entry, enum object_type has_type; unsigned long has_size; read_lock(); - has_type = oid_object_info(the_repository, oid, &has_size); + has_type = odb_read_object_info(the_repository->objects, oid, &has_size); if (has_type < 0) die(_("cannot read existing object info %s"), oid_to_hex(oid)); if (has_type != type || has_size != size) @@ -1501,9 +1502,9 @@ static void fix_unresolved_deltas(struct hashfile *f) struct oid_array to_fetch = OID_ARRAY_INIT; for (i = 0; i < nr_ref_deltas; i++) { struct ref_delta_entry *d = sorted_by_pos[i]; - if (!oid_object_info_extended(the_repository, &d->oid, - NULL, - OBJECT_INFO_FOR_PREFETCH)) + if (!odb_read_object_info_extended(the_repository->objects, + &d->oid, NULL, + OBJECT_INFO_FOR_PREFETCH)) continue; oid_array_append(&to_fetch, &d->oid); } @@ -1829,7 +1830,7 @@ static void repack_local_links(void) oidset_iter_init(&outgoing_links, &iter); while ((oid = oidset_iter_next(&iter))) { struct object_info info = OBJECT_INFO_INIT; - if (oid_object_info_extended(the_repository, oid, &info, 0)) + if (odb_read_object_info_extended(the_repository->objects, oid, &info, 0)) /* Missing; assume it is a promisor object */ continue; if (info.whence == OI_PACKED && info.u.packed.pack->pack_promisor) diff --git a/builtin/ls-files.c b/builtin/ls-files.c index 821339b07d4f3d..ff975e7be06045 100644 --- a/builtin/ls-files.c +++ b/builtin/ls-files.c @@ -251,7 +251,7 @@ static void expand_objectsize(struct repository *repo, struct strbuf *line, { if (type == OBJ_BLOB) { unsigned long size; - if (oid_object_info(repo, oid, &size) < 0) + if (odb_read_object_info(repo->objects, oid, &size) < 0) die(_("could not get object info about '%s'"), oid_to_hex(oid)); if (padded) diff --git a/builtin/ls-tree.c b/builtin/ls-tree.c index 62b6fd58c1655d..4d616dd52827d9 100644 --- a/builtin/ls-tree.c +++ b/builtin/ls-tree.c @@ -27,7 +27,7 @@ static void expand_objectsize(struct strbuf *line, const struct object_id *oid, { if (type == OBJ_BLOB) { unsigned long size; - if (oid_object_info(the_repository, oid, &size) < 0) + if (odb_read_object_info(the_repository->objects, oid, &size) < 0) die(_("could not get object info about '%s'"), oid_to_hex(oid)); if (padded) @@ -217,7 +217,7 @@ static int show_tree_long(const struct object_id *oid, struct strbuf *base, if (type == OBJ_BLOB) { unsigned long size; - if (oid_object_info(the_repository, oid, &size) == OBJ_BAD) + if (odb_read_object_info(the_repository->objects, oid, &size) == OBJ_BAD) xsnprintf(size_text, sizeof(size_text), "BAD"); else xsnprintf(size_text, sizeof(size_text), diff --git a/builtin/mktree.c b/builtin/mktree.c index 016b0e5b224792..81df7f6099fa4e 100644 --- a/builtin/mktree.c +++ b/builtin/mktree.c @@ -124,10 +124,10 @@ static void mktree_line(char *buf, int nul_term_line, int allow_missing) /* Check the type of object identified by oid without fetching objects */ oi.typep = &obj_type; - if (oid_object_info_extended(the_repository, &oid, &oi, - OBJECT_INFO_LOOKUP_REPLACE | - OBJECT_INFO_QUICK | - OBJECT_INFO_SKIP_FETCH_OBJECT) < 0) + if (odb_read_object_info_extended(the_repository->objects, &oid, &oi, + OBJECT_INFO_LOOKUP_REPLACE | + OBJECT_INFO_QUICK | + OBJECT_INFO_SKIP_FETCH_OBJECT) < 0) obj_type = -1; if (obj_type < 0) { diff --git a/builtin/pack-objects.c b/builtin/pack-objects.c index 99b63cb0980218..da35d684081aea 100644 --- a/builtin/pack-objects.c +++ b/builtin/pack-objects.c @@ -2154,10 +2154,10 @@ static void prefetch_to_pack(uint32_t object_index_start) { for (i = object_index_start; i < to_pack.nr_objects; i++) { struct object_entry *entry = to_pack.objects + i; - if (!oid_object_info_extended(the_repository, - &entry->idx.oid, - NULL, - OBJECT_INFO_FOR_PREFETCH)) + if (!odb_read_object_info_extended(the_repository->objects, + &entry->idx.oid, + NULL, + OBJECT_INFO_FOR_PREFETCH)) continue; oid_array_append(&to_fetch, &entry->idx.oid); } @@ -2298,19 +2298,19 @@ static void check_object(struct object_entry *entry, uint32_t object_index) /* * No choice but to fall back to the recursive delta walk - * with oid_object_info() to find about the object type + * with odb_read_object_info() to find about the object type * at this point... */ give_up: unuse_pack(&w_curs); } - if (oid_object_info_extended(the_repository, &entry->idx.oid, &oi, - OBJECT_INFO_SKIP_FETCH_OBJECT | OBJECT_INFO_LOOKUP_REPLACE) < 0) { + if (odb_read_object_info_extended(the_repository->objects, &entry->idx.oid, &oi, + OBJECT_INFO_SKIP_FETCH_OBJECT | OBJECT_INFO_LOOKUP_REPLACE) < 0) { if (repo_has_promisor_remote(the_repository)) { prefetch_to_pack(object_index); - if (oid_object_info_extended(the_repository, &entry->idx.oid, &oi, - OBJECT_INFO_SKIP_FETCH_OBJECT | OBJECT_INFO_LOOKUP_REPLACE) < 0) + if (odb_read_object_info_extended(the_repository->objects, &entry->idx.oid, &oi, + OBJECT_INFO_SKIP_FETCH_OBJECT | OBJECT_INFO_LOOKUP_REPLACE) < 0) type = -1; } else { type = -1; @@ -2384,12 +2384,13 @@ static void drop_reused_delta(struct object_entry *entry) if (packed_object_info(the_repository, IN_PACK(entry), entry->in_pack_offset, &oi) < 0) { /* * We failed to get the info from this pack for some reason; - * fall back to oid_object_info, which may find another copy. + * fall back to odb_read_object_info, which may find another copy. * And if that fails, the error will be recorded in oe_type(entry) * and dealt with in prepare_pack(). */ oe_set_type(entry, - oid_object_info(the_repository, &entry->idx.oid, &size)); + odb_read_object_info(the_repository->objects, + &entry->idx.oid, &size)); } else { oe_set_type(entry, type); } @@ -2677,7 +2678,8 @@ unsigned long oe_get_size_slow(struct packing_data *pack, if (e->type_ != OBJ_OFS_DELTA && e->type_ != OBJ_REF_DELTA) { packing_data_lock(&to_pack); - if (oid_object_info(the_repository, &e->idx.oid, &size) < 0) + if (odb_read_object_info(the_repository->objects, + &e->idx.oid, &size) < 0) die(_("unable to get size of %s"), oid_to_hex(&e->idx.oid)); packing_data_unlock(&to_pack); @@ -4063,7 +4065,7 @@ static void add_objects_in_unpacked_packs(void) static int add_loose_object(const struct object_id *oid, const char *path, void *data UNUSED) { - enum object_type type = oid_object_info(the_repository, oid, NULL); + enum object_type type = odb_read_object_info(the_repository->objects, oid, NULL); if (type < 0) { warning(_("loose object at %s could not be examined"), path); @@ -4449,7 +4451,7 @@ static int option_parse_cruft_expiration(const struct option *opt UNUSED, static int is_not_in_promisor_pack_obj(struct object *obj, void *data UNUSED) { struct object_info info = OBJECT_INFO_INIT; - if (oid_object_info_extended(the_repository, &obj->oid, &info, 0)) + if (odb_read_object_info_extended(the_repository->objects, &obj->oid, &info, 0)) BUG("should_include_obj should only be called on existing objects"); return info.whence != OI_PACKED || !info.u.packed.pack->pack_promisor; } diff --git a/builtin/prune.c b/builtin/prune.c index 7bbfb14c2bedf4..339017c7ccf37c 100644 --- a/builtin/prune.c +++ b/builtin/prune.c @@ -99,8 +99,8 @@ static int prune_object(const struct object_id *oid, const char *fullpath, if (st.st_mtime > expire) return 0; if (show_only || verbose) { - enum object_type type = oid_object_info(the_repository, oid, - NULL); + enum object_type type = odb_read_object_info(the_repository->objects, + oid, NULL); printf("%s %s\n", oid_to_hex(oid), (type > 0) ? type_name(type) : "unknown"); } diff --git a/builtin/repack.c b/builtin/repack.c index 8145474cf8d98b..a89c2b704fb455 100644 --- a/builtin/repack.c +++ b/builtin/repack.c @@ -707,7 +707,7 @@ static int midx_snapshot_ref_one(const char *refname UNUSED, if (oidset_insert(&data->seen, oid)) return 0; /* already seen */ - if (oid_object_info(the_repository, oid, NULL) != OBJ_COMMIT) + if (odb_read_object_info(the_repository->objects, oid, NULL) != OBJ_COMMIT) return 0; fprintf(data->f->fp, "%s%s\n", data->preferred ? "+" : "", diff --git a/builtin/replace.c b/builtin/replace.c index 11c7e2d4c0cbcc..5ff2ab723cbd58 100644 --- a/builtin/replace.c +++ b/builtin/replace.c @@ -65,8 +65,8 @@ static int show_reference(const char *refname, if (repo_get_oid(data->repo, refname, &object)) return error(_("failed to resolve '%s' as a valid ref"), refname); - obj_type = oid_object_info(data->repo, &object, NULL); - repl_type = oid_object_info(data->repo, oid, NULL); + obj_type = odb_read_object_info(data->repo->objects, &object, NULL); + repl_type = odb_read_object_info(data->repo->objects, oid, NULL); printf("%s (%s) -> %s (%s)\n", refname, type_name(obj_type), oid_to_hex(oid), type_name(repl_type)); @@ -185,8 +185,8 @@ static int replace_object_oid(const char *object_ref, struct strbuf err = STRBUF_INIT; int res = 0; - obj_type = oid_object_info(the_repository, object, NULL); - repl_type = oid_object_info(the_repository, repl, NULL); + obj_type = odb_read_object_info(the_repository->objects, object, NULL); + repl_type = odb_read_object_info(the_repository->objects, repl, NULL); if (!force && obj_type != repl_type) return error(_("Objects must be of the same type.\n" "'%s' points to a replaced object of type '%s'\n" @@ -334,7 +334,7 @@ static int edit_and_replace(const char *object_ref, int force, int raw) if (repo_get_oid(the_repository, object_ref, &old_oid) < 0) return error(_("not a valid object name: '%s'"), object_ref); - type = oid_object_info(the_repository, &old_oid, NULL); + type = odb_read_object_info(the_repository->objects, &old_oid, NULL); if (type < 0) return error(_("unable to get object type for %s"), oid_to_hex(&old_oid)); diff --git a/builtin/rev-list.c b/builtin/rev-list.c index 0ee37a32cb211c..4d0c460f1862db 100644 --- a/builtin/rev-list.c +++ b/builtin/rev-list.c @@ -110,7 +110,8 @@ static off_t get_object_disk_usage(struct object *obj) off_t size; struct object_info oi = OBJECT_INFO_INIT; oi.disk_sizep = &size; - if (oid_object_info_extended(the_repository, &obj->oid, &oi, 0) < 0) + if (odb_read_object_info_extended(the_repository->objects, + &obj->oid, &oi, 0) < 0) die(_("unable to get disk usage of %s"), oid_to_hex(&obj->oid)); return size; } @@ -346,7 +347,8 @@ static void show_commit(struct commit *commit, void *data) static int finish_object(struct object *obj, const char *name, void *cb_data) { struct rev_list_info *info = cb_data; - if (oid_object_info_extended(the_repository, &obj->oid, NULL, 0) < 0) { + if (odb_read_object_info_extended(the_repository->objects, + &obj->oid, NULL, 0) < 0) { finish_object__ma(obj, name); return 1; } diff --git a/builtin/tag.c b/builtin/tag.c index cf2ea4b4993daf..e0b27396c6b905 100644 --- a/builtin/tag.c +++ b/builtin/tag.c @@ -304,7 +304,7 @@ static void create_tag(const struct object_id *object, const char *object_ref, struct strbuf header = STRBUF_INIT; int should_edit; - type = oid_object_info(the_repository, object, NULL); + type = odb_read_object_info(the_repository->objects, object, NULL); if (type <= OBJ_NONE) die(_("bad object type.")); @@ -401,7 +401,7 @@ static void create_reflog_msg(const struct object_id *oid, struct strbuf *sb) } strbuf_addstr(sb, " ("); - type = oid_object_info(the_repository, oid, NULL); + type = odb_read_object_info(the_repository->objects, oid, NULL); switch (type) { default: strbuf_addstr(sb, "object of unknown type"); diff --git a/builtin/unpack-objects.c b/builtin/unpack-objects.c index 7bf395eec8461d..405e78bc592387 100644 --- a/builtin/unpack-objects.c +++ b/builtin/unpack-objects.c @@ -232,7 +232,7 @@ static int check_object(struct object *obj, enum object_type type, if (!(obj->flags & FLAG_OPEN)) { unsigned long size; - int type = oid_object_info(the_repository, &obj->oid, &size); + int type = odb_read_object_info(the_repository->objects, &obj->oid, &size); if (type != obj->type || type <= 0) die("object of unexpected type"); obj->flags |= FLAG_WRITTEN; diff --git a/commit-graph.c b/commit-graph.c index 59265f89385a39..5f482d3377ff1b 100644 --- a/commit-graph.c +++ b/commit-graph.c @@ -1862,7 +1862,7 @@ static int add_ref_to_set(const char *refname UNUSED, if (!peel_iterated_oid(the_repository, oid, &peeled)) oid = &peeled; - if (oid_object_info(the_repository, oid, NULL) == OBJ_COMMIT) + if (odb_read_object_info(the_repository->objects, oid, NULL) == OBJ_COMMIT) oidset_insert(data->commits, oid); display_progress(data->progress, oidset_size(data->commits)); diff --git a/commit.c b/commit.c index aa65183d8b6dd8..d4aa9c7a5f81a8 100644 --- a/commit.c +++ b/commit.c @@ -585,7 +585,8 @@ int repo_parse_commit_internal(struct repository *r, return 0; } - if (oid_object_info_extended(r, &item->object.oid, &oi, flags) < 0) + if (odb_read_object_info_extended(r->objects, &item->object.oid, + &oi, flags) < 0) return quiet_on_missing ? -1 : error("Could not read %s", oid_to_hex(&item->object.oid)); diff --git a/diff.c b/diff.c index 3af108115b351b..dca87e164fb615 100644 --- a/diff.c +++ b/diff.c @@ -4230,14 +4230,14 @@ int diff_populate_filespec(struct repository *r, info.contentp = &s->data; if (options && options->missing_object_cb) { - if (!oid_object_info_extended(r, &s->oid, &info, - OBJECT_INFO_LOOKUP_REPLACE | - OBJECT_INFO_SKIP_FETCH_OBJECT)) + if (!odb_read_object_info_extended(r->objects, &s->oid, &info, + OBJECT_INFO_LOOKUP_REPLACE | + OBJECT_INFO_SKIP_FETCH_OBJECT)) goto object_read; options->missing_object_cb(options->missing_object_data); } - if (oid_object_info_extended(r, &s->oid, &info, - OBJECT_INFO_LOOKUP_REPLACE)) + if (odb_read_object_info_extended(r->objects, &s->oid, &info, + OBJECT_INFO_LOOKUP_REPLACE)) die("unable to read %s", oid_to_hex(&s->oid)); object_read: @@ -4252,8 +4252,8 @@ int diff_populate_filespec(struct repository *r, } if (!info.contentp) { info.contentp = &s->data; - if (oid_object_info_extended(r, &s->oid, &info, - OBJECT_INFO_LOOKUP_REPLACE)) + if (odb_read_object_info_extended(r->objects, &s->oid, &info, + OBJECT_INFO_LOOKUP_REPLACE)) die("unable to read %s", oid_to_hex(&s->oid)); } s->should_free = 1; @@ -7019,8 +7019,8 @@ void diff_add_if_missing(struct repository *r, { if (filespec && filespec->oid_valid && !S_ISGITLINK(filespec->mode) && - oid_object_info_extended(r, &filespec->oid, NULL, - OBJECT_INFO_FOR_PREFETCH)) + odb_read_object_info_extended(r->objects, &filespec->oid, NULL, + OBJECT_INFO_FOR_PREFETCH)) oid_array_append(to_fetch, &filespec->oid); } diff --git a/fetch-pack.c b/fetch-pack.c index 47fa7fa4c492cb..0f5de1c94d1478 100644 --- a/fetch-pack.c +++ b/fetch-pack.c @@ -149,8 +149,8 @@ static struct commit *deref_without_lazy_fetch(const struct object_id *oid, } while (1) { - if (oid_object_info_extended(the_repository, oid, &info, - OBJECT_INFO_SKIP_FETCH_OBJECT | OBJECT_INFO_QUICK)) + if (odb_read_object_info_extended(the_repository->objects, oid, &info, + OBJECT_INFO_SKIP_FETCH_OBJECT | OBJECT_INFO_QUICK)) return NULL; if (type == OBJ_TAG) { struct tag *tag = (struct tag *) diff --git a/list-objects-filter.c b/list-objects-filter.c index 80fe48a52c8a7c..7ecd4d9ef50a8e 100644 --- a/list-objects-filter.c +++ b/list-objects-filter.c @@ -310,7 +310,7 @@ static enum list_objects_filter_result filter_blobs_limit( assert(obj->type == OBJ_BLOB); assert((obj->flags & SEEN) == 0); - t = oid_object_info(r, &obj->oid, &object_length); + t = odb_read_object_info(r->objects, &obj->oid, &object_length); if (t != OBJ_BLOB) { /* probably OBJ_NONE */ /* * We DO NOT have the blob locally, so we cannot diff --git a/log-tree.c b/log-tree.c index 1d05dc1c7010d5..233bf9f227c61b 100644 --- a/log-tree.c +++ b/log-tree.c @@ -176,7 +176,7 @@ static int add_ref_decoration(const char *refname, const char *referent UNUSED, return 0; } - objtype = oid_object_info(the_repository, oid, NULL); + objtype = odb_read_object_info(the_repository->objects, oid, NULL); if (objtype < 0) return 0; obj = lookup_object_by_type(the_repository, oid, objtype); diff --git a/merge-ort.c b/merge-ort.c index 9f693ab1d36c9a..f29417040c1cd9 100644 --- a/merge-ort.c +++ b/merge-ort.c @@ -4385,8 +4385,8 @@ static void prefetch_for_content_merges(struct merge_options *opt, if ((ci->filemask & side_mask) && S_ISREG(vi->mode) && - oid_object_info_extended(opt->repo, &vi->oid, NULL, - OBJECT_INFO_FOR_PREFETCH)) + odb_read_object_info_extended(opt->repo->objects, &vi->oid, NULL, + OBJECT_INFO_FOR_PREFETCH)) oid_array_append(&to_fetch, &vi->oid); } } diff --git a/object-file.c b/object-file.c index 04da19a1a3bd77..3d674d1093e449 100644 --- a/object-file.c +++ b/object-file.c @@ -1108,7 +1108,7 @@ int force_object_loose(const struct object_id *oid, time_t mtime) oi.typep = &type; oi.sizep = &len; oi.contentp = &buf; - if (oid_object_info_extended(the_repository, oid, &oi, 0)) + if (odb_read_object_info_extended(the_repository->objects, oid, &oi, 0)) return error(_("cannot read object for %s"), oid_to_hex(oid)); if (compat) { if (repo_oid_to_algop(repo, oid, compat, &compat_oid)) diff --git a/object-file.h b/object-file.h index 5066638f8eccd0..67b4ffc480833b 100644 --- a/object-file.h +++ b/object-file.h @@ -8,7 +8,7 @@ struct index_state; /* - * Set this to 0 to prevent oid_object_info_extended() from fetching missing + * Set this to 0 to prevent odb_read_object_info_extended() from fetching missing * blobs. This has a difference only if extensions.partialClone is set. * * Its default value is 1. diff --git a/object-name.c b/object-name.c index 381536e900e365..e225eb602cfa60 100644 --- a/object-name.c +++ b/object-name.c @@ -251,7 +251,7 @@ static int disambiguate_commit_only(struct repository *r, const struct object_id *oid, void *cb_data UNUSED) { - int kind = oid_object_info(r, oid, NULL); + int kind = odb_read_object_info(r->objects, oid, NULL); return kind == OBJ_COMMIT; } @@ -262,7 +262,7 @@ static int disambiguate_committish_only(struct repository *r, struct object *obj; int kind; - kind = oid_object_info(r, oid, NULL); + kind = odb_read_object_info(r->objects, oid, NULL); if (kind == OBJ_COMMIT) return 1; if (kind != OBJ_TAG) @@ -279,7 +279,7 @@ static int disambiguate_tree_only(struct repository *r, const struct object_id *oid, void *cb_data UNUSED) { - int kind = oid_object_info(r, oid, NULL); + int kind = odb_read_object_info(r->objects, oid, NULL); return kind == OBJ_TREE; } @@ -290,7 +290,7 @@ static int disambiguate_treeish_only(struct repository *r, struct object *obj; int kind; - kind = oid_object_info(r, oid, NULL); + kind = odb_read_object_info(r->objects, oid, NULL); if (kind == OBJ_TREE || kind == OBJ_COMMIT) return 1; if (kind != OBJ_TAG) @@ -307,7 +307,7 @@ static int disambiguate_blob_only(struct repository *r, const struct object_id *oid, void *cb_data UNUSED) { - int kind = oid_object_info(r, oid, NULL); + int kind = odb_read_object_info(r->objects, oid, NULL); return kind == OBJ_BLOB; } @@ -399,7 +399,7 @@ static int show_ambiguous_object(const struct object_id *oid, void *data) return 0; hash = repo_find_unique_abbrev(ds->repo, oid, DEFAULT_ABBREV); - type = oid_object_info(ds->repo, oid, NULL); + type = odb_read_object_info(ds->repo->objects, oid, NULL); if (type < 0) { /* @@ -514,8 +514,8 @@ static int sort_ambiguous(const void *va, const void *vb, void *ctx) { struct repository *sort_ambiguous_repo = ctx; const struct object_id *a = va, *b = vb; - int a_type = oid_object_info(sort_ambiguous_repo, a, NULL); - int b_type = oid_object_info(sort_ambiguous_repo, b, NULL); + int a_type = odb_read_object_info(sort_ambiguous_repo->objects, a, NULL); + int b_type = odb_read_object_info(sort_ambiguous_repo->objects, b, NULL); int a_type_sort; int b_type_sort; diff --git a/object.c b/object.c index 3b15469139d2ef..868d89eed42da1 100644 --- a/object.c +++ b/object.c @@ -214,7 +214,7 @@ enum peel_status peel_object(struct repository *r, struct object *o = lookup_unknown_object(r, name); if (o->type == OBJ_NONE) { - int type = oid_object_info(r, name, NULL); + int type = odb_read_object_info(r->objects, name, NULL); if (type < 0 || !object_as_type(o, type, 0)) return PEEL_INVALID; } @@ -315,7 +315,7 @@ struct object *parse_object_with_flags(struct repository *r, } if ((!obj || obj->type == OBJ_BLOB) && - oid_object_info(r, oid, NULL) == OBJ_BLOB) { + odb_read_object_info(r->objects, oid, NULL) == OBJ_BLOB) { if (!skip_hash && stream_object_signature(r, repl) < 0) { error(_("hash mismatch %s"), oid_to_hex(oid)); return NULL; @@ -331,7 +331,7 @@ struct object *parse_object_with_flags(struct repository *r, */ if (skip_hash && discard_tree && (!obj || obj->type == OBJ_TREE) && - oid_object_info(r, oid, NULL) == OBJ_TREE) { + odb_read_object_info(r->objects, oid, NULL) == OBJ_TREE) { return &lookup_tree(r, oid)->object; } diff --git a/odb.c b/odb.c index 5a88701550eacf..40eacdfe2da27f 100644 --- a/odb.c +++ b/odb.c @@ -647,7 +647,7 @@ static int register_all_submodule_sources(struct object_database *odb) return ret; } -static int do_oid_object_info_extended(struct repository *r, +static int do_oid_object_info_extended(struct object_database *odb, const struct object_id *oid, struct object_info *oi, unsigned flags) { @@ -660,7 +660,7 @@ static int do_oid_object_info_extended(struct repository *r, if (flags & OBJECT_INFO_LOOKUP_REPLACE) - real = lookup_replace_object(r, oid); + real = lookup_replace_object(odb->repo, oid); if (is_null_oid(real)) return -1; @@ -668,7 +668,7 @@ static int do_oid_object_info_extended(struct repository *r, if (!oi) oi = &blank_oi; - co = find_cached_object(r->objects, real); + co = find_cached_object(odb, real); if (co) { if (oi->typep) *(oi->typep) = co->type; @@ -677,7 +677,7 @@ static int do_oid_object_info_extended(struct repository *r, if (oi->disk_sizep) *(oi->disk_sizep) = 0; if (oi->delta_base_oid) - oidclr(oi->delta_base_oid, r->hash_algo); + oidclr(oi->delta_base_oid, odb->repo->hash_algo); if (oi->contentp) *oi->contentp = xmemdupz(co->buf, co->size); oi->whence = OI_CACHED; @@ -685,17 +685,17 @@ static int do_oid_object_info_extended(struct repository *r, } while (1) { - if (find_pack_entry(r, real, &e)) + if (find_pack_entry(odb->repo, real, &e)) break; /* Most likely it's a loose object. */ - if (!loose_object_info(r, real, oi, flags)) + if (!loose_object_info(odb->repo, real, oi, flags)) return 0; /* Not a loose object; someone else may have just packed it. */ if (!(flags & OBJECT_INFO_QUICK)) { - reprepare_packed_git(r); - if (find_pack_entry(r, real, &e)) + reprepare_packed_git(odb->repo); + if (find_pack_entry(odb->repo, real, &e)) break; } @@ -705,15 +705,15 @@ static int do_oid_object_info_extended(struct repository *r, * `odb_add_submodule_source_by_path()` on that submodule's * ODB). If any such ODBs exist, register them and try again. */ - if (register_all_submodule_sources(r->objects)) + if (register_all_submodule_sources(odb)) /* We added some alternates; retry */ continue; /* Check if it is a missing object */ - if (fetch_if_missing && repo_has_promisor_remote(r) && + if (fetch_if_missing && repo_has_promisor_remote(odb->repo) && !already_retried && !(flags & OBJECT_INFO_SKIP_FETCH_OBJECT)) { - promisor_remote_get_direct(r, real, 1); + promisor_remote_get_direct(odb->repo, real, 1); already_retried = 1; continue; } @@ -723,7 +723,7 @@ static int do_oid_object_info_extended(struct repository *r, if ((flags & OBJECT_INFO_LOOKUP_REPLACE) && !oideq(real, oid)) die(_("replacement %s not found for %s"), oid_to_hex(real), oid_to_hex(oid)); - if ((p = has_packed_and_bad(r, real))) + if ((p = has_packed_and_bad(odb->repo, real))) die(_("packed object %s (stored in %s) is corrupt"), oid_to_hex(real), p->pack_name); } @@ -736,10 +736,10 @@ static int do_oid_object_info_extended(struct repository *r, * information below, so return early. */ return 0; - rtype = packed_object_info(r, e.p, e.offset, oi); + rtype = packed_object_info(odb->repo, e.p, e.offset, oi); if (rtype < 0) { mark_bad_packed_object(e.p, real); - return do_oid_object_info_extended(r, real, oi, 0); + return do_oid_object_info_extended(odb, real, oi, 0); } else if (oi->whence == OI_PACKED) { oi->u.packed.offset = e.offset; oi->u.packed.pack = e.p; @@ -787,7 +787,7 @@ static int oid_object_info_convert(struct repository *r, oi = &new_oi; } - ret = oid_object_info_extended(r, &oid, oi, flags); + ret = odb_read_object_info_extended(r->objects, &oid, oi, flags); if (ret) return -1; if (oi == input_oi) @@ -830,33 +830,35 @@ static int oid_object_info_convert(struct repository *r, return ret; } -int oid_object_info_extended(struct repository *r, const struct object_id *oid, - struct object_info *oi, unsigned flags) +int odb_read_object_info_extended(struct object_database *odb, + const struct object_id *oid, + struct object_info *oi, + unsigned flags) { int ret; - if (oid->algo && (hash_algo_by_ptr(r->hash_algo) != oid->algo)) - return oid_object_info_convert(r, oid, oi, flags); + if (oid->algo && (hash_algo_by_ptr(odb->repo->hash_algo) != oid->algo)) + return oid_object_info_convert(odb->repo, oid, oi, flags); obj_read_lock(); - ret = do_oid_object_info_extended(r, oid, oi, flags); + ret = do_oid_object_info_extended(odb, oid, oi, flags); obj_read_unlock(); return ret; } /* returns enum object_type or negative */ -int oid_object_info(struct repository *r, - const struct object_id *oid, - unsigned long *sizep) +int odb_read_object_info(struct object_database *odb, + const struct object_id *oid, + unsigned long *sizep) { enum object_type type; struct object_info oi = OBJECT_INFO_INIT; oi.typep = &type; oi.sizep = sizep; - if (oid_object_info_extended(r, oid, &oi, - OBJECT_INFO_LOOKUP_REPLACE) < 0) + if (odb_read_object_info_extended(odb, oid, &oi, + OBJECT_INFO_LOOKUP_REPLACE) < 0) return -1; return type; } @@ -887,7 +889,7 @@ int pretend_object_file(struct repository *repo, /* * This function dies on corrupt objects; the callers who want to - * deal with them should arrange to call oid_object_info_extended() and give + * deal with them should arrange to call odb_read_object_info_extended() and give * error messages themselves. */ void *repo_read_object_file(struct repository *r, @@ -902,7 +904,7 @@ void *repo_read_object_file(struct repository *r, oi.typep = type; oi.sizep = size; oi.contentp = &data; - if (oid_object_info_extended(r, oid, &oi, flags)) + if (odb_read_object_info_extended(r->objects, oid, &oi, flags)) return NULL; return data; @@ -968,13 +970,13 @@ int has_object(struct repository *r, const struct object_id *oid, if (!(flags & HAS_OBJECT_FETCH_PROMISOR)) object_info_flags |= OBJECT_INFO_SKIP_FETCH_OBJECT; - return oid_object_info_extended(r, oid, NULL, object_info_flags) >= 0; + return odb_read_object_info_extended(r->objects, oid, NULL, object_info_flags) >= 0; } void odb_assert_oid_type(struct object_database *odb, const struct object_id *oid, enum object_type expect) { - enum object_type type = oid_object_info(odb->repo, oid, NULL); + enum object_type type = odb_read_object_info(odb, oid, NULL); if (type < 0) die(_("%s is not a valid object"), oid_to_hex(oid)); if (type != expect) diff --git a/odb.h b/odb.h index 0ea9d4faa70225..b37a9c5d20ffa3 100644 --- a/odb.h +++ b/odb.h @@ -265,9 +265,6 @@ void *repo_read_object_file(struct repository *r, enum object_type *type, unsigned long *size); -/* Read and unpack an object file into memory, write memory to an object file */ -int oid_object_info(struct repository *r, const struct object_id *, unsigned long *); - /* * Add an object file to the in-memory object store, without writing it * to disk. @@ -336,9 +333,24 @@ struct object_info { /* Die if object corruption (not just an object being missing) was detected. */ #define OBJECT_INFO_DIE_IF_CORRUPT 32 -int oid_object_info_extended(struct repository *r, - const struct object_id *, - struct object_info *, unsigned flags); +/* + * Read object info from the object database and populate the `object_info` + * structure. Returns 0 on success, a negative error code otherwise. + */ +int odb_read_object_info_extended(struct object_database *odb, + const struct object_id *oid, + struct object_info *oi, + unsigned flags); + +/* + * Read a subset of object info for the given object ID. Returns an `enum + * object_type` on success, a negative error code otherwise. If successful and + * `sizep` is non-NULL, then the size of the object will be written to the + * pointer. + */ +int odb_read_object_info(struct object_database *odb, + const struct object_id *oid, + unsigned long *sizep); enum { /* Retry packed storage after checking packed and loose storage */ @@ -360,7 +372,7 @@ void odb_assert_oid_type(struct object_database *odb, /* * Enabling the object read lock allows multiple threads to safely call the * following functions in parallel: repo_read_object_file(), - * read_object_with_reference(), oid_object_info() and oid_object_info_extended(). + * read_object_with_reference(), odb_read_object_info() and odb(). * * obj_read_lock() and obj_read_unlock() may also be used to protect other * section which cannot execute in parallel with object reading. Since the used @@ -368,7 +380,7 @@ void odb_assert_oid_type(struct object_database *odb, * reading functions. However, beware that in these cases zlib inflation won't * be performed in parallel, losing performance. * - * TODO: oid_object_info_extended()'s call stack has a recursive behavior. If + * TODO: odb_read_object_info_extended()'s call stack has a recursive behavior. If * any of its callees end up calling it, this recursive call won't benefit from * parallel inflation. */ @@ -416,4 +428,22 @@ void *read_object_with_reference(struct repository *r, unsigned long *size, struct object_id *oid_ret); +/* Compatibility wrappers, to be removed once Git 2.51 has been released. */ +#include "repository.h" + +static inline int oid_object_info_extended(struct repository *r, + const struct object_id *oid, + struct object_info *oi, + unsigned flags) +{ + return odb_read_object_info_extended(r->objects, oid, oi, flags); +} + +static inline int oid_object_info(struct repository *r, + const struct object_id *oid, + unsigned long *sizep) +{ + return odb_read_object_info(r->objects, oid, sizep); +} + #endif /* ODB_H */ diff --git a/pack-bitmap-write.c b/pack-bitmap-write.c index c847369eaaad14..c5183b619c1206 100644 --- a/pack-bitmap-write.c +++ b/pack-bitmap-write.c @@ -144,8 +144,8 @@ void bitmap_writer_build_type_index(struct bitmap_writer *writer, break; default: - real_type = oid_object_info(writer->to_pack->repo, - &entry->idx.oid, NULL); + real_type = odb_read_object_info(writer->to_pack->repo->objects, + &entry->idx.oid, NULL); break; } diff --git a/pack-bitmap.c b/pack-bitmap.c index a695a794e9b703..bcbb71f7502b7c 100644 --- a/pack-bitmap.c +++ b/pack-bitmap.c @@ -1868,8 +1868,8 @@ static unsigned long get_size_by_pos(struct bitmap_index *bitmap_git, size_t eindex_pos = pos - bitmap_num_objects_total(bitmap_git); struct eindex *eindex = &bitmap_git->ext_index; struct object *obj = eindex->objects[eindex_pos]; - if (oid_object_info_extended(bitmap_repo(bitmap_git), &obj->oid, - &oi, 0) < 0) + if (odb_read_object_info_extended(bitmap_repo(bitmap_git)->objects, &obj->oid, + &oi, 0) < 0) die(_("unable to get size of %s"), oid_to_hex(&obj->oid)); } @@ -3220,8 +3220,8 @@ static off_t get_disk_usage_for_extended(struct bitmap_index *bitmap_git) i))) continue; - if (oid_object_info_extended(bitmap_repo(bitmap_git), &obj->oid, - &oi, 0) < 0) + if (odb_read_object_info_extended(bitmap_repo(bitmap_git)->objects, + &obj->oid, &oi, 0) < 0) die(_("unable to get disk usage of '%s'"), oid_to_hex(&obj->oid)); diff --git a/packfile.c b/packfile.c index ac0e29e99b9165..af9ccfdba624ab 100644 --- a/packfile.c +++ b/packfile.c @@ -1321,7 +1321,7 @@ static int retry_bad_packed_offset(struct repository *r, return OBJ_BAD; nth_packed_object_id(&oid, p, pack_pos_to_index(p, pos)); mark_bad_packed_object(p, &oid); - type = oid_object_info(r, &oid, NULL); + type = odb_read_object_info(r->objects, &oid, NULL); if (type <= OBJ_NONE) return OBJ_BAD; return type; @@ -1849,7 +1849,8 @@ void *unpack_entry(struct repository *r, struct packed_git *p, off_t obj_offset, oi.typep = &type; oi.sizep = &base_size; oi.contentp = &base; - if (oid_object_info_extended(r, &base_oid, &oi, 0) < 0) + if (odb_read_object_info_extended(r->objects, &base_oid, + &oi, 0) < 0) base = NULL; external_base = base; diff --git a/promisor-remote.c b/promisor-remote.c index 2baa286bfd04ba..be6f82d12f847a 100644 --- a/promisor-remote.c +++ b/promisor-remote.c @@ -245,8 +245,8 @@ static int remove_fetched_oids(struct repository *repo, struct object_id *new_oids; for (i = 0; i < oid_nr; i++) - if (oid_object_info_extended(repo, &old_oids[i], NULL, - OBJECT_INFO_SKIP_FETCH_OBJECT)) { + if (odb_read_object_info_extended(repo->objects, &old_oids[i], NULL, + OBJECT_INFO_SKIP_FETCH_OBJECT)) { remaining[i] = 1; remaining_nr++; } diff --git a/protocol-caps.c b/protocol-caps.c index 3022f69a1bd55f..ecdd0dc58d5aab 100644 --- a/protocol-caps.c +++ b/protocol-caps.c @@ -64,7 +64,7 @@ static void send_info(struct repository *r, struct packet_writer *writer, strbuf_addstr(&send_buffer, oid_str); if (info->size) { - if (oid_object_info(r, &oid, &object_size) < 0) { + if (odb_read_object_info(r->objects, &oid, &object_size) < 0) { strbuf_addstr(&send_buffer, " "); } else { strbuf_addf(&send_buffer, " %lu", object_size); diff --git a/reachable.c b/reachable.c index 9dc748f0b9a0f7..e984b68a0c41e1 100644 --- a/reachable.c +++ b/reachable.c @@ -211,7 +211,7 @@ static void add_recent_object(const struct object_id *oid, * later processing, and the revision machinery expects * commits and tags to have been parsed. */ - type = oid_object_info(the_repository, oid, NULL); + type = odb_read_object_info(the_repository->objects, oid, NULL); if (type < 0) die("unable to get object info for %s", oid_to_hex(oid)); diff --git a/read-cache.c b/read-cache.c index c3fa9686766375..7d5bccf95dcfc3 100644 --- a/read-cache.c +++ b/read-cache.c @@ -3729,9 +3729,9 @@ void prefetch_cache_entries(const struct index_state *istate, if (S_ISGITLINK(ce->ce_mode) || !must_prefetch(ce)) continue; - if (!oid_object_info_extended(the_repository, &ce->oid, - NULL, - OBJECT_INFO_FOR_PREFETCH)) + if (!odb_read_object_info_extended(the_repository->objects, + &ce->oid, NULL, + OBJECT_INFO_FOR_PREFETCH)) continue; oid_array_append(&to_fetch, &ce->oid); } diff --git a/ref-filter.c b/ref-filter.c index 4ce45440ad12cb..f9f2c512a8c6e0 100644 --- a/ref-filter.c +++ b/ref-filter.c @@ -2302,8 +2302,8 @@ static int get_object(struct ref_array_item *ref, int deref, struct object **obj oi->info.sizep = &oi->size; oi->info.typep = &oi->type; } - if (oid_object_info_extended(the_repository, &oi->oid, &oi->info, - OBJECT_INFO_LOOKUP_REPLACE)) + if (odb_read_object_info_extended(the_repository->objects, &oi->oid, &oi->info, + OBJECT_INFO_LOOKUP_REPLACE)) return strbuf_addf_ret(err, -1, _("missing object %s for %s"), oid_to_hex(&oi->oid), ref->refname); if (oi->info.disk_sizep && oi->disk_size < 0) diff --git a/remote.c b/remote.c index 17a842f5684746..72c36239d31e34 100644 --- a/remote.c +++ b/remote.c @@ -1182,7 +1182,7 @@ static void show_push_unqualified_ref_name_error(const char *dst_value, BUG("'%s' is not a valid object, " "match_explicit_lhs() should catch this!", matched_src_name); - type = oid_object_info(the_repository, &oid, NULL); + type = odb_read_object_info(the_repository->objects, &oid, NULL); if (type == OBJ_COMMIT) { advise(_("The part of the refspec is a commit object.\n" "Did you mean to create a new branch by pushing to\n" @@ -1412,7 +1412,8 @@ static void add_missing_tags(struct ref *src, struct ref **dst, struct ref ***ds continue; /* not a tag */ if (string_list_has_string(&dst_tag, ref->name)) continue; /* they already have it */ - if (oid_object_info(the_repository, &ref->new_oid, NULL) != OBJ_TAG) + if (odb_read_object_info(the_repository->objects, + &ref->new_oid, NULL) != OBJ_TAG) continue; /* be conservative */ item = string_list_append(&src_tag, ref->name); item->util = ref; diff --git a/sequencer.c b/sequencer.c index 2432d0a39ec669..193459405f8737 100644 --- a/sequencer.c +++ b/sequencer.c @@ -5503,9 +5503,8 @@ int sequencer_pick_revisions(struct repository *r, if (!repo_get_oid(r, name, &oid)) { if (!lookup_commit_reference_gently(r, &oid, 1)) { - enum object_type type = oid_object_info(r, - &oid, - NULL); + enum object_type type = odb_read_object_info(r->objects, + &oid, NULL); res = error(_("%s: can't cherry-pick a %s"), name, type_name(type)); goto out; diff --git a/streaming.c b/streaming.c index 81c42673a235fa..4b13827668e67a 100644 --- a/streaming.c +++ b/streaming.c @@ -44,7 +44,7 @@ struct git_istream { union { struct { - char *buf; /* from oid_object_info_extended() */ + char *buf; /* from odb_read_object_info_extended() */ unsigned long read_ptr; } incore; @@ -403,8 +403,8 @@ static int open_istream_incore(struct git_istream *st, struct repository *r, oi.typep = type; oi.sizep = &st->size; oi.contentp = (void **)&st->u.incore.buf; - return oid_object_info_extended(r, oid, &oi, - OBJECT_INFO_DIE_IF_CORRUPT); + return odb_read_object_info_extended(r->objects, oid, &oi, + OBJECT_INFO_DIE_IF_CORRUPT); } /***************************************************************************** @@ -422,7 +422,7 @@ static int istream_source(struct git_istream *st, oi.typep = type; oi.sizep = &size; - status = oid_object_info_extended(r, oid, &oi, 0); + status = odb_read_object_info_extended(r->objects, oid, &oi, 0); if (status < 0) return status; diff --git a/submodule.c b/submodule.c index 788c9e55ed3606..f8373a9ea7decf 100644 --- a/submodule.c +++ b/submodule.c @@ -968,7 +968,7 @@ static int check_has_commit(const struct object_id *oid, void *data) return 0; } - type = oid_object_info(&subrepo, oid, NULL); + type = odb_read_object_info(subrepo.objects, oid, NULL); switch (type) { case OBJ_COMMIT: @@ -1752,8 +1752,7 @@ static int fetch_start_failure(struct strbuf *err UNUSED, static int commit_missing_in_sub(const struct object_id *oid, void *data) { struct repository *subrepo = data; - - enum object_type type = oid_object_info(subrepo, oid, NULL); + enum object_type type = odb_read_object_info(subrepo->objects, oid, NULL); return type != OBJ_COMMIT; } diff --git a/t/helper/test-partial-clone.c b/t/helper/test-partial-clone.c index dba227259a2629..d84880074930b2 100644 --- a/t/helper/test-partial-clone.c +++ b/t/helper/test-partial-clone.c @@ -23,7 +23,7 @@ static void object_info(const char *gitdir, const char *oid_hex) die("could not init repo"); if (parse_oid_hex_algop(oid_hex, &oid, &p, r.hash_algo)) die("could not parse oid"); - if (oid_object_info_extended(&r, &oid, &oi, 0)) + if (odb_read_object_info_extended(r.objects, &oid, &oi, 0)) die("could not obtain object info"); printf("%d\n", (int) size); diff --git a/tag.c b/tag.c index 5f6868bf7b12a4..144048fd5e0c25 100644 --- a/tag.c +++ b/tag.c @@ -52,7 +52,7 @@ int gpg_verify_tag(const struct object_id *oid, const char *name_to_report, unsigned long size; int ret; - type = oid_object_info(the_repository, oid, NULL); + type = odb_read_object_info(the_repository->objects, oid, NULL); if (type != OBJ_TAG) return error("%s: cannot verify a non-tag object of type %s.", name_to_report ? From d4ff88aee3967e5d1ef1237cd9b8792b7cdb304c Mon Sep 17 00:00:00 2001 From: Patrick Steinhardt Date: Tue, 1 Jul 2025 14:22:26 +0200 Subject: [PATCH 17/21] odb: rename `repo_read_object_file()` Rename `repo_read_object_file()` to `odb_read_object()` to match other functions related to the object database and our modern coding guidelines. Introduce a compatibility wrapper so that any in-flight topics will continue to compile. Signed-off-by: Patrick Steinhardt Signed-off-by: Junio C Hamano --- apply.c | 10 +++++----- archive.c | 2 +- attr.c | 2 +- bisect.c | 6 +++--- blame.c | 13 ++++++------- builtin/cat-file.c | 26 +++++++++++--------------- builtin/difftool.c | 2 +- builtin/fast-export.c | 6 +++--- builtin/fast-import.c | 8 ++++---- builtin/grep.c | 8 ++++---- builtin/index-pack.c | 8 ++++---- builtin/log.c | 2 +- builtin/merge-tree.c | 12 ++++++------ builtin/mktag.c | 4 ++-- builtin/notes.c | 6 +++--- builtin/pack-objects.c | 30 +++++++++++++++--------------- builtin/tag.c | 4 ++-- builtin/unpack-file.c | 2 +- builtin/unpack-objects.c | 4 ++-- bundle.c | 2 +- combine-diff.c | 2 +- commit.c | 6 +++--- config.c | 2 +- dir.c | 2 +- entry.c | 4 ++-- fmt-merge-msg.c | 4 ++-- fsck.c | 2 +- grep.c | 4 ++-- http-push.c | 4 ++-- mailmap.c | 2 +- match-trees.c | 4 ++-- merge-blobs.c | 8 ++++---- merge-ort.c | 2 +- notes-cache.c | 2 +- notes-merge.c | 2 +- notes.c | 13 +++++++------ object.c | 2 +- odb.c | 19 +++++++------------ odb.h | 29 +++++++++++++++++++++++------ read-cache.c | 6 +++--- reflog.c | 4 ++-- rerere.c | 5 ++--- submodule-config.c | 4 ++-- tag.c | 6 +++--- tree-walk.c | 6 +++--- tree.c | 4 ++-- xdiff-interface.c | 2 +- 47 files changed, 157 insertions(+), 150 deletions(-) diff --git a/apply.c b/apply.c index e778b4e911de98..a34ced04625e18 100644 --- a/apply.c +++ b/apply.c @@ -3210,8 +3210,8 @@ static int apply_binary(struct apply_state *state, unsigned long size; char *result; - result = repo_read_object_file(the_repository, &oid, &type, - &size); + result = odb_read_object(the_repository->objects, &oid, + &type, &size); if (!result) return error(_("the necessary postimage %s for " "'%s' cannot be read"), @@ -3273,8 +3273,8 @@ static int read_blob_object(struct strbuf *buf, const struct object_id *oid, uns unsigned long sz; char *result; - result = repo_read_object_file(the_repository, oid, &type, - &sz); + result = odb_read_object(the_repository->objects, oid, + &type, &sz); if (!result) return -1; /* XXX read_sha1_file NUL-terminates */ @@ -3503,7 +3503,7 @@ static int resolve_to(struct image *image, const struct object_id *result_id) image_clear(image); - data = repo_read_object_file(the_repository, result_id, &type, &size); + data = odb_read_object(the_repository->objects, result_id, &type, &size); if (!data || type != OBJ_BLOB) die("unable to read blob object %s", oid_to_hex(result_id)); strbuf_attach(&image->buf, data, size, size + 1); diff --git a/archive.c b/archive.c index f2511d530d585b..f5a9d45c8d3e24 100644 --- a/archive.c +++ b/archive.c @@ -98,7 +98,7 @@ static void *object_file_to_archive(const struct archiver_args *args, (args->tree ? &args->tree->object.oid : NULL), oid); path += args->baselen; - buffer = repo_read_object_file(the_repository, oid, type, sizep); + buffer = odb_read_object(the_repository->objects, oid, type, sizep); if (buffer && S_ISREG(mode)) { struct strbuf buf = STRBUF_INIT; size_t size = 0; diff --git a/attr.c b/attr.c index e5680db7f65080..d1daeb0b4d90a6 100644 --- a/attr.c +++ b/attr.c @@ -779,7 +779,7 @@ static struct attr_stack *read_attr_from_blob(struct index_state *istate, if (get_tree_entry(istate->repo, tree_oid, path, &oid, &mode)) return NULL; - buf = repo_read_object_file(istate->repo, &oid, &type, &sz); + buf = odb_read_object(istate->repo->objects, &oid, &type, &sz); if (!buf || type != OBJ_BLOB) { free(buf); return NULL; diff --git a/bisect.c b/bisect.c index a7939216d00eaf..f24474542ec3b1 100644 --- a/bisect.c +++ b/bisect.c @@ -155,9 +155,9 @@ static void show_list(const char *debug, int counted, int nr, unsigned commit_flags = commit->object.flags; enum object_type type; unsigned long size; - char *buf = repo_read_object_file(the_repository, - &commit->object.oid, &type, - &size); + char *buf = odb_read_object(the_repository->objects, + &commit->object.oid, &type, + &size); const char *subject_start; int subject_len; diff --git a/blame.c b/blame.c index 97db3355af4594..858d2d74df98fb 100644 --- a/blame.c +++ b/blame.c @@ -1041,9 +1041,9 @@ static void fill_origin_blob(struct diff_options *opt, &o->blob_oid, 1, &file->ptr, &file_size)) ; else - file->ptr = repo_read_object_file(the_repository, - &o->blob_oid, &type, - &file_size); + file->ptr = odb_read_object(the_repository->objects, + &o->blob_oid, &type, + &file_size); file->size = file_size; if (!file->ptr) @@ -2869,10 +2869,9 @@ void setup_scoreboard(struct blame_scoreboard *sb, &sb->final_buf_size)) ; else - sb->final_buf = repo_read_object_file(the_repository, - &o->blob_oid, - &type, - &sb->final_buf_size); + sb->final_buf = odb_read_object(the_repository->objects, + &o->blob_oid, &type, + &sb->final_buf_size); if (!sb->final_buf) die(_("cannot read blob %s for path %s"), diff --git a/builtin/cat-file.c b/builtin/cat-file.c index f7595fdb04e901..90a3e159d119cd 100644 --- a/builtin/cat-file.c +++ b/builtin/cat-file.c @@ -74,7 +74,7 @@ static int filter_object(const char *path, unsigned mode, { enum object_type type; - *buf = repo_read_object_file(the_repository, oid, &type, size); + *buf = odb_read_object(the_repository->objects, oid, &type, size); if (!*buf) return error(_("cannot read object %s '%s'"), oid_to_hex(oid), path); @@ -197,8 +197,8 @@ static int cat_one_file(int opt, const char *exp_type, const char *obj_name) ret = stream_blob(&oid); goto cleanup; } - buf = repo_read_object_file(the_repository, &oid, &type, - &size); + buf = odb_read_object(the_repository->objects, &oid, + &type, &size); if (!buf) die("Cannot read object %s", obj_name); @@ -219,10 +219,8 @@ static int cat_one_file(int opt, const char *exp_type, const char *obj_name) struct object_id blob_oid; if (odb_read_object_info(the_repository->objects, &oid, NULL) == OBJ_TAG) { - char *buffer = repo_read_object_file(the_repository, - &oid, - &type, - &size); + char *buffer = odb_read_object(the_repository->objects, + &oid, &type, &size); const char *target; if (!buffer) @@ -403,10 +401,8 @@ static void print_object_or_die(struct batch_options *opt, struct expand_data *d if (!textconv_object(the_repository, data->rest, 0100644, oid, 1, &contents, &size)) - contents = repo_read_object_file(the_repository, - oid, - &type, - &size); + contents = odb_read_object(the_repository->objects, + oid, &type, &size); if (!contents) die("could not convert '%s' %s", oid_to_hex(oid), data->rest); @@ -423,8 +419,8 @@ static void print_object_or_die(struct batch_options *opt, struct expand_data *d unsigned long size; void *contents; - contents = repo_read_object_file(the_repository, oid, &type, - &size); + contents = odb_read_object(the_repository->objects, oid, + &type, &size); if (!contents) die("object %s disappeared", oid_to_hex(oid)); @@ -533,8 +529,8 @@ static void batch_object_write(const char *obj_name, size_t s = data->size; char *buf = NULL; - buf = repo_read_object_file(the_repository, &data->oid, &data->type, - &data->size); + buf = odb_read_object(the_repository->objects, &data->oid, + &data->type, &data->size); if (!buf) die(_("unable to read %s"), oid_to_hex(&data->oid)); buf = replace_idents_using_mailmap(buf, &s); diff --git a/builtin/difftool.c b/builtin/difftool.c index fac613e3bc385a..e4bc1f831696a8 100644 --- a/builtin/difftool.c +++ b/builtin/difftool.c @@ -320,7 +320,7 @@ static char *get_symlink(struct repository *repo, } else { enum object_type type; unsigned long size; - data = repo_read_object_file(repo, oid, &type, &size); + data = odb_read_object(repo->objects, oid, &type, &size); if (!data) die(_("could not read object %s for symlink %s"), oid_to_hex(oid), path); diff --git a/builtin/fast-export.c b/builtin/fast-export.c index 6c93cf0a8aa1f5..33f304dd0ad243 100644 --- a/builtin/fast-export.c +++ b/builtin/fast-export.c @@ -323,7 +323,7 @@ static void export_blob(const struct object_id *oid) object = (struct object *)lookup_blob(the_repository, oid); eaten = 0; } else { - buf = repo_read_object_file(the_repository, oid, &type, &size); + buf = odb_read_object(the_repository->objects, oid, &type, &size); if (!buf) die("could not read blob %s", oid_to_hex(oid)); if (check_object_signature(the_repository, oid, buf, size, @@ -869,8 +869,8 @@ static void handle_tag(const char *name, struct tag *tag) return; } - buf = repo_read_object_file(the_repository, &tag->object.oid, &type, - &size); + buf = odb_read_object(the_repository->objects, &tag->object.oid, + &type, &size); if (!buf) die("could not read tag %s", oid_to_hex(&tag->object.oid)); message = memmem(buf, size, "\n\n", 2); diff --git a/builtin/fast-import.c b/builtin/fast-import.c index 2718376f2c96de..1973c504e25754 100644 --- a/builtin/fast-import.c +++ b/builtin/fast-import.c @@ -1265,7 +1265,7 @@ static void load_tree(struct tree_entry *root) die("Can't load tree %s", oid_to_hex(oid)); } else { enum object_type type; - buf = repo_read_object_file(the_repository, oid, &type, &size); + buf = odb_read_object(the_repository->objects, oid, &type, &size); if (!buf || type != OBJ_TREE) die("Can't load tree %s", oid_to_hex(oid)); } @@ -3002,7 +3002,7 @@ static void cat_blob(struct object_entry *oe, struct object_id *oid) char *buf; if (!oe || oe->pack_id == MAX_PACK_ID) { - buf = repo_read_object_file(the_repository, oid, &type, &size); + buf = odb_read_object(the_repository->objects, oid, &type, &size); } else { type = oe->type; buf = gfi_unpack_entry(oe, &size); @@ -3110,8 +3110,8 @@ static struct object_entry *dereference(struct object_entry *oe, buf = gfi_unpack_entry(oe, &size); } else { enum object_type unused; - buf = repo_read_object_file(the_repository, oid, &unused, - &size); + buf = odb_read_object(the_repository->objects, oid, + &unused, &size); } if (!buf) die("Can't load object %s", oid_to_hex(oid)); diff --git a/builtin/grep.c b/builtin/grep.c index 1435d462cd1883..5de61dfffe893b 100644 --- a/builtin/grep.c +++ b/builtin/grep.c @@ -573,8 +573,8 @@ static int grep_cache(struct grep_opt *opt, void *data; unsigned long size; - data = repo_read_object_file(the_repository, &ce->oid, - &type, &size); + data = odb_read_object(the_repository->objects, &ce->oid, + &type, &size); if (!data) die(_("unable to read tree %s"), oid_to_hex(&ce->oid)); init_tree_desc(&tree, &ce->oid, data, size); @@ -666,8 +666,8 @@ static int grep_tree(struct grep_opt *opt, const struct pathspec *pathspec, void *data; unsigned long size; - data = repo_read_object_file(the_repository, - &entry.oid, &type, &size); + data = odb_read_object(the_repository->objects, + &entry.oid, &type, &size); if (!data) die(_("unable to read tree (%s)"), oid_to_hex(&entry.oid)); diff --git a/builtin/index-pack.c b/builtin/index-pack.c index d0b16908122bf0..180d261f6ce288 100644 --- a/builtin/index-pack.c +++ b/builtin/index-pack.c @@ -914,8 +914,8 @@ static void sha1_object(const void *data, struct object_entry *obj_entry, die(_("cannot read existing object info %s"), oid_to_hex(oid)); if (has_type != type || has_size != size) die(_("SHA1 COLLISION FOUND WITH %s !"), oid_to_hex(oid)); - has_data = repo_read_object_file(the_repository, oid, - &has_type, &has_size); + has_data = odb_read_object(the_repository->objects, oid, + &has_type, &has_size); read_unlock(); if (!data) data = new_data = get_data_from_pack(obj_entry); @@ -1521,8 +1521,8 @@ static void fix_unresolved_deltas(struct hashfile *f) if (objects[d->obj_no].real_type != OBJ_REF_DELTA) continue; - data = repo_read_object_file(the_repository, &d->oid, &type, - &size); + data = odb_read_object(the_repository->objects, &d->oid, + &type, &size); if (!data) continue; diff --git a/builtin/log.c b/builtin/log.c index fe9cc5ebecb231..f2040b1815970b 100644 --- a/builtin/log.c +++ b/builtin/log.c @@ -714,7 +714,7 @@ static int show_tag_object(const struct object_id *oid, struct rev_info *rev) { unsigned long size; enum object_type type; - char *buf = repo_read_object_file(the_repository, oid, &type, &size); + char *buf = odb_read_object(the_repository->objects, oid, &type, &size); unsigned long offset = 0; if (!buf) diff --git a/builtin/merge-tree.c b/builtin/merge-tree.c index b1a17787bcf913..cf8b06cadc7d50 100644 --- a/builtin/merge-tree.c +++ b/builtin/merge-tree.c @@ -75,9 +75,9 @@ static void *result(struct merge_list *entry, unsigned long *size) const char *path = entry->path; if (!entry->stage) - return repo_read_object_file(the_repository, - &entry->blob->object.oid, &type, - size); + return odb_read_object(the_repository->objects, + &entry->blob->object.oid, &type, + size); base = NULL; if (entry->stage == 1) { base = entry->blob; @@ -100,9 +100,9 @@ static void *origin(struct merge_list *entry, unsigned long *size) enum object_type type; while (entry) { if (entry->stage == 2) - return repo_read_object_file(the_repository, - &entry->blob->object.oid, - &type, size); + return odb_read_object(the_repository->objects, + &entry->blob->object.oid, + &type, size); entry = entry->link; } return NULL; diff --git a/builtin/mktag.c b/builtin/mktag.c index 1809b38f937f3b..1b391119de85e5 100644 --- a/builtin/mktag.c +++ b/builtin/mktag.c @@ -54,8 +54,8 @@ static int verify_object_in_tag(struct object_id *tagged_oid, int *tagged_type) void *buffer; const struct object_id *repl; - buffer = repo_read_object_file(the_repository, tagged_oid, &type, - &size); + buffer = odb_read_object(the_repository->objects, tagged_oid, + &type, &size); if (!buffer) die(_("could not read tagged object '%s'"), oid_to_hex(tagged_oid)); diff --git a/builtin/notes.c b/builtin/notes.c index 783d4932ca6efe..a9529b1696ae14 100644 --- a/builtin/notes.c +++ b/builtin/notes.c @@ -152,7 +152,7 @@ static void copy_obj_to_fd(int fd, const struct object_id *oid) { unsigned long size; enum object_type type; - char *buf = repo_read_object_file(the_repository, oid, &type, &size); + char *buf = odb_read_object(the_repository->objects, oid, &type, &size); if (buf) { if (size) write_or_die(fd, buf, size); @@ -319,7 +319,7 @@ static int parse_reuse_arg(const struct option *opt, const char *arg, int unset) strbuf_init(&msg->buf, 0); if (repo_get_oid(the_repository, arg, &object)) die(_("failed to resolve '%s' as a valid ref."), arg); - if (!(value = repo_read_object_file(the_repository, &object, &type, &len))) + if (!(value = odb_read_object(the_repository->objects, &object, &type, &len))) die(_("failed to read object '%s'."), arg); if (type != OBJ_BLOB) { strbuf_release(&msg->buf); @@ -722,7 +722,7 @@ static int append_edit(int argc, const char **argv, const char *prefix, unsigned long size; enum object_type type; struct strbuf buf = STRBUF_INIT; - char *prev_buf = repo_read_object_file(the_repository, note, &type, &size); + char *prev_buf = odb_read_object(the_repository->objects, note, &type, &size); if (!prev_buf) die(_("unable to read %s"), oid_to_hex(note)); diff --git a/builtin/pack-objects.c b/builtin/pack-objects.c index da35d684081aea..580a5c1996b406 100644 --- a/builtin/pack-objects.c +++ b/builtin/pack-objects.c @@ -337,13 +337,13 @@ static void *get_delta(struct object_entry *entry) void *buf, *base_buf, *delta_buf; enum object_type type; - buf = repo_read_object_file(the_repository, &entry->idx.oid, &type, - &size); + buf = odb_read_object(the_repository->objects, &entry->idx.oid, + &type, &size); if (!buf) die(_("unable to read %s"), oid_to_hex(&entry->idx.oid)); - base_buf = repo_read_object_file(the_repository, - &DELTA(entry)->idx.oid, &type, - &base_size); + base_buf = odb_read_object(the_repository->objects, + &DELTA(entry)->idx.oid, &type, + &base_size); if (!base_buf) die("unable to read %s", oid_to_hex(&DELTA(entry)->idx.oid)); @@ -506,9 +506,9 @@ static unsigned long write_no_reuse_object(struct hashfile *f, struct object_ent &size, NULL)) != NULL) buf = NULL; else { - buf = repo_read_object_file(the_repository, - &entry->idx.oid, &type, - &size); + buf = odb_read_object(the_repository->objects, + &entry->idx.oid, &type, + &size); if (!buf) die(_("unable to read %s"), oid_to_hex(&entry->idx.oid)); @@ -1895,7 +1895,7 @@ static struct pbase_tree_cache *pbase_tree_get(const struct object_id *oid) /* Did not find one. Either we got a bogus request or * we need to read and perhaps cache. */ - data = repo_read_object_file(the_repository, oid, &type, &size); + data = odb_read_object(the_repository->objects, oid, &type, &size); if (!data) return NULL; if (type != OBJ_TREE) { @@ -2762,9 +2762,9 @@ static int try_delta(struct unpacked *trg, struct unpacked *src, /* Load data if not already done */ if (!trg->data) { packing_data_lock(&to_pack); - trg->data = repo_read_object_file(the_repository, - &trg_entry->idx.oid, &type, - &sz); + trg->data = odb_read_object(the_repository->objects, + &trg_entry->idx.oid, &type, + &sz); packing_data_unlock(&to_pack); if (!trg->data) die(_("object %s cannot be read"), @@ -2777,9 +2777,9 @@ static int try_delta(struct unpacked *trg, struct unpacked *src, } if (!src->data) { packing_data_lock(&to_pack); - src->data = repo_read_object_file(the_repository, - &src_entry->idx.oid, &type, - &sz); + src->data = odb_read_object(the_repository->objects, + &src_entry->idx.oid, &type, + &sz); packing_data_unlock(&to_pack); if (!src->data) { if (src_entry->preferred_base) { diff --git a/builtin/tag.c b/builtin/tag.c index e0b27396c6b905..46cbf892e34224 100644 --- a/builtin/tag.c +++ b/builtin/tag.c @@ -244,7 +244,7 @@ static void write_tag_body(int fd, const struct object_id *oid) struct strbuf payload = STRBUF_INIT; struct strbuf signature = STRBUF_INIT; - orig = buf = repo_read_object_file(the_repository, oid, &type, &size); + orig = buf = odb_read_object(the_repository->objects, oid, &type, &size); if (!buf) return; if (parse_signature(buf, size, &payload, &signature)) { @@ -407,7 +407,7 @@ static void create_reflog_msg(const struct object_id *oid, struct strbuf *sb) strbuf_addstr(sb, "object of unknown type"); break; case OBJ_COMMIT: - if ((buf = repo_read_object_file(the_repository, oid, &type, &size))) { + if ((buf = odb_read_object(the_repository->objects, oid, &type, &size))) { subject_len = find_commit_subject(buf, &subject_start); strbuf_insert(sb, sb->len, subject_start, subject_len); } else { diff --git a/builtin/unpack-file.c b/builtin/unpack-file.c index b92fd4710a99db..4360872ae07026 100644 --- a/builtin/unpack-file.c +++ b/builtin/unpack-file.c @@ -14,7 +14,7 @@ static char *create_temp_file(struct object_id *oid) unsigned long size; int fd; - buf = repo_read_object_file(the_repository, oid, &type, &size); + buf = odb_read_object(the_repository->objects, oid, &type, &size); if (!buf || type != OBJ_BLOB) die("unable to read blob object %s", oid_to_hex(oid)); diff --git a/builtin/unpack-objects.c b/builtin/unpack-objects.c index 405e78bc592387..4bc6575a5743e1 100644 --- a/builtin/unpack-objects.c +++ b/builtin/unpack-objects.c @@ -516,8 +516,8 @@ static void unpack_delta_entry(enum object_type type, unsigned long delta_size, if (resolve_against_held(nr, &base_oid, delta_data, delta_size)) return; - base = repo_read_object_file(the_repository, &base_oid, &type, - &base_size); + base = odb_read_object(the_repository->objects, &base_oid, + &type, &base_size); if (!base) { error("failed to read delta-pack base object %s", oid_to_hex(&base_oid)); diff --git a/bundle.c b/bundle.c index e09e3c2f58c3e9..717f056a45435f 100644 --- a/bundle.c +++ b/bundle.c @@ -305,7 +305,7 @@ static int is_tag_in_date_range(struct object *tag, struct rev_info *revs) if (revs->max_age == -1 && revs->min_age == -1) goto out; - buf = repo_read_object_file(the_repository, &tag->oid, &type, &size); + buf = odb_read_object(the_repository->objects, &tag->oid, &type, &size); if (!buf) goto out; line = memmem(buf, size, "\ntagger ", 8); diff --git a/combine-diff.c b/combine-diff.c index cf23a753407561..4ea2dc93c4f807 100644 --- a/combine-diff.c +++ b/combine-diff.c @@ -325,7 +325,7 @@ static char *grab_blob(struct repository *r, *size = fill_textconv(r, textconv, df, &blob); free_filespec(df); } else { - blob = repo_read_object_file(r, oid, &type, size); + blob = odb_read_object(r->objects, oid, &type, size); if (!blob) die(_("unable to read %s"), oid_to_hex(oid)); if (type != OBJ_BLOB) diff --git a/commit.c b/commit.c index d4aa9c7a5f81a8..28ee6b73ae6be0 100644 --- a/commit.c +++ b/commit.c @@ -374,7 +374,7 @@ const void *repo_get_commit_buffer(struct repository *r, if (!ret) { enum object_type type; unsigned long size; - ret = repo_read_object_file(r, &commit->object.oid, &type, &size); + ret = odb_read_object(r->objects, &commit->object.oid, &type, &size); if (!ret) die("cannot read commit object %s", oid_to_hex(&commit->object.oid)); @@ -1275,8 +1275,8 @@ static void handle_signed_tag(const struct commit *parent, struct commit_extra_h desc = merge_remote_util(parent); if (!desc || !desc->obj) return; - buf = repo_read_object_file(the_repository, &desc->obj->oid, &type, - &size); + buf = odb_read_object(the_repository->objects, &desc->obj->oid, + &type, &size); if (!buf || type != OBJ_TAG) goto free_return; if (!parse_signature(buf, size, &payload, &signature)) diff --git a/config.c b/config.c index 883dd0668271c6..142c37215a8c91 100644 --- a/config.c +++ b/config.c @@ -1942,7 +1942,7 @@ int git_config_from_blob_oid(config_fn_t fn, unsigned long size; int ret; - buf = repo_read_object_file(repo, oid, &type, &size); + buf = odb_read_object(repo->objects, oid, &type, &size); if (!buf) return error(_("unable to load config blob object '%s'"), name); if (type != OBJ_BLOB) { diff --git a/dir.c b/dir.c index a374972b6243b6..cb7bd873b171a1 100644 --- a/dir.c +++ b/dir.c @@ -302,7 +302,7 @@ static int do_read_blob(const struct object_id *oid, struct oid_stat *oid_stat, *size_out = 0; *data_out = NULL; - data = repo_read_object_file(the_repository, oid, &type, &sz); + data = odb_read_object(the_repository->objects, oid, &type, &sz); if (!data || type != OBJ_BLOB) { free(data); return -1; diff --git a/entry.c b/entry.c index 75d55038d7ceb8..cae02eb50398d7 100644 --- a/entry.c +++ b/entry.c @@ -93,8 +93,8 @@ void *read_blob_entry(const struct cache_entry *ce, size_t *size) { enum object_type type; unsigned long ul; - void *blob_data = repo_read_object_file(the_repository, &ce->oid, - &type, &ul); + void *blob_data = odb_read_object(the_repository->objects, &ce->oid, + &type, &ul); *size = ul; if (blob_data) { diff --git a/fmt-merge-msg.c b/fmt-merge-msg.c index 1a8c972adf3ad7..40174efa3de2b9 100644 --- a/fmt-merge-msg.c +++ b/fmt-merge-msg.c @@ -526,8 +526,8 @@ static void fmt_merge_msg_sigs(struct strbuf *out) struct object_id *oid = origins.items[i].util; enum object_type type; unsigned long size; - char *buf = repo_read_object_file(the_repository, oid, &type, - &size); + char *buf = odb_read_object(the_repository->objects, oid, + &type, &size); char *origbuf = buf; unsigned long len = size; struct signature_check sigc = { NULL }; diff --git a/fsck.c b/fsck.c index e69baab3af7ede..23965e1880fede 100644 --- a/fsck.c +++ b/fsck.c @@ -1293,7 +1293,7 @@ static int fsck_blobs(struct oidset *blobs_found, struct oidset *blobs_done, if (oidset_contains(blobs_done, oid)) continue; - buf = repo_read_object_file(the_repository, oid, &type, &size); + buf = odb_read_object(the_repository->objects, oid, &type, &size); if (!buf) { if (is_promisor_object(the_repository, oid)) continue; diff --git a/grep.c b/grep.c index dc77e6c4631915..932647e4a6580b 100644 --- a/grep.c +++ b/grep.c @@ -1931,8 +1931,8 @@ static int grep_source_load_oid(struct grep_source *gs) { enum object_type type; - gs->buf = repo_read_object_file(gs->repo, gs->identifier, &type, - &gs->size); + gs->buf = odb_read_object(gs->repo->objects, gs->identifier, + &type, &gs->size); if (!gs->buf) return error(_("'%s': unable to read %s"), gs->name, diff --git a/http-push.c b/http-push.c index d1b1bb23711653..9481825abfb8ad 100644 --- a/http-push.c +++ b/http-push.c @@ -369,8 +369,8 @@ static void start_put(struct transfer_request *request) ssize_t size; git_zstream stream; - unpacked = repo_read_object_file(the_repository, &request->obj->oid, - &type, &len); + unpacked = odb_read_object(the_repository->objects, &request->obj->oid, + &type, &len); hdrlen = format_object_header(hdr, sizeof(hdr), type, len); /* Set it up */ diff --git a/mailmap.c b/mailmap.c index b18e74c2110e78..56c72102d9e394 100644 --- a/mailmap.c +++ b/mailmap.c @@ -196,7 +196,7 @@ int read_mailmap_blob(struct string_list *map, const char *name) if (repo_get_oid(the_repository, name, &oid) < 0) return 0; - buf = repo_read_object_file(the_repository, &oid, &type, &size); + buf = odb_read_object(the_repository->objects, &oid, &type, &size); if (!buf) return error("unable to read mailmap object at %s", name); if (type != OBJ_BLOB) { diff --git a/match-trees.c b/match-trees.c index 4704f95c3402e6..5a8a5c39b04ab9 100644 --- a/match-trees.c +++ b/match-trees.c @@ -63,7 +63,7 @@ static void *fill_tree_desc_strict(struct repository *r, enum object_type type; unsigned long size; - buffer = repo_read_object_file(r, hash, &type, &size); + buffer = odb_read_object(r->objects, hash, &type, &size); if (!buffer) die("unable to read tree (%s)", oid_to_hex(hash)); if (type != OBJ_TREE) @@ -199,7 +199,7 @@ static int splice_tree(struct repository *r, if (*subpath) subpath++; - buf = repo_read_object_file(r, oid1, &type, &sz); + buf = odb_read_object(r->objects, oid1, &type, &sz); if (!buf) die("cannot read tree %s", oid_to_hex(oid1)); init_tree_desc(&desc, oid1, buf, sz); diff --git a/merge-blobs.c b/merge-blobs.c index ba8a3fdfd82b74..6fc279941714f6 100644 --- a/merge-blobs.c +++ b/merge-blobs.c @@ -12,8 +12,8 @@ static int fill_mmfile_blob(mmfile_t *f, struct blob *obj) unsigned long size; enum object_type type; - buf = repo_read_object_file(the_repository, &obj->object.oid, &type, - &size); + buf = odb_read_object(the_repository->objects, &obj->object.oid, + &type, &size); if (!buf) return -1; if (type != OBJ_BLOB) { @@ -79,8 +79,8 @@ void *merge_blobs(struct index_state *istate, const char *path, return NULL; if (!our) our = their; - return repo_read_object_file(the_repository, &our->object.oid, - &type, size); + return odb_read_object(the_repository->objects, &our->object.oid, + &type, size); } if (fill_mmfile_blob(&f1, our) < 0) diff --git a/merge-ort.c b/merge-ort.c index f29417040c1cd9..473ff61e36e9f7 100644 --- a/merge-ort.c +++ b/merge-ort.c @@ -3629,7 +3629,7 @@ static int read_oid_strbuf(struct merge_options *opt, void *buf; enum object_type type; unsigned long size; - buf = repo_read_object_file(the_repository, oid, &type, &size); + buf = odb_read_object(the_repository->objects, oid, &type, &size); if (!buf) { path_msg(opt, ERROR_OBJECT_READ_FAILED, 0, path, NULL, NULL, NULL, diff --git a/notes-cache.c b/notes-cache.c index 344f67762b8c18..dd56feed6e8cfe 100644 --- a/notes-cache.c +++ b/notes-cache.c @@ -87,7 +87,7 @@ char *notes_cache_get(struct notes_cache *c, struct object_id *key_oid, value_oid = get_note(&c->tree, key_oid); if (!value_oid) return NULL; - value = repo_read_object_file(the_repository, value_oid, &type, &size); + value = odb_read_object(the_repository->objects, value_oid, &type, &size); *outsize = size; return value; diff --git a/notes-merge.c b/notes-merge.c index de6a52e2e7ff3f..586939939f2451 100644 --- a/notes-merge.c +++ b/notes-merge.c @@ -340,7 +340,7 @@ static void write_note_to_worktree(const struct object_id *obj, { enum object_type type; unsigned long size; - void *buf = repo_read_object_file(the_repository, note, &type, &size); + void *buf = odb_read_object(the_repository->objects, note, &type, &size); if (!buf) die("cannot read note %s for object %s", diff --git a/notes.c b/notes.c index fc000e501d2a63..73eb5f00cf5174 100644 --- a/notes.c +++ b/notes.c @@ -816,15 +816,15 @@ int combine_notes_concatenate(struct object_id *cur_oid, /* read in both note blob objects */ if (!is_null_oid(new_oid)) - new_msg = repo_read_object_file(the_repository, new_oid, - &new_type, &new_len); + new_msg = odb_read_object(the_repository->objects, new_oid, + &new_type, &new_len); if (!new_msg || !new_len || new_type != OBJ_BLOB) { free(new_msg); return 0; } if (!is_null_oid(cur_oid)) - cur_msg = repo_read_object_file(the_repository, cur_oid, - &cur_type, &cur_len); + cur_msg = odb_read_object(the_repository->objects, cur_oid, + &cur_type, &cur_len); if (!cur_msg || !cur_len || cur_type != OBJ_BLOB) { free(cur_msg); free(new_msg); @@ -880,7 +880,7 @@ static int string_list_add_note_lines(struct string_list *list, return 0; /* read_sha1_file NUL-terminates */ - data = repo_read_object_file(the_repository, oid, &t, &len); + data = odb_read_object(the_repository->objects, oid, &t, &len); if (t != OBJ_BLOB || !data || !len) { free(data); return t != OBJ_BLOB || !data; @@ -1290,7 +1290,8 @@ static void format_note(struct notes_tree *t, const struct object_id *object_oid if (!oid) return; - if (!(msg = repo_read_object_file(the_repository, oid, &type, &msglen)) || type != OBJ_BLOB) { + if (!(msg = odb_read_object(the_repository->objects, oid, &type, &msglen)) || + type != OBJ_BLOB) { free(msg); return; } diff --git a/object.c b/object.c index 868d89eed42da1..c1553ee4330c89 100644 --- a/object.c +++ b/object.c @@ -335,7 +335,7 @@ struct object *parse_object_with_flags(struct repository *r, return &lookup_tree(r, oid)->object; } - buffer = repo_read_object_file(r, oid, &type, &size); + buffer = odb_read_object(r->objects, oid, &type, &size); if (buffer) { if (!skip_hash && check_object_signature(r, repl, buffer, size, type) < 0) { diff --git a/odb.c b/odb.c index 40eacdfe2da27f..5419d5dff6d2b7 100644 --- a/odb.c +++ b/odb.c @@ -30,7 +30,7 @@ KHASH_INIT(odb_path_map, const char * /* key: odb_path */, /* * This is meant to hold a *small* number of objects that you would - * want repo_read_object_file() to be able to return, but yet you do not want + * want odb_read_object() to be able to return, but yet you do not want * to write them into the object store (e.g. a browse-only * application). */ @@ -887,15 +887,10 @@ int pretend_object_file(struct repository *repo, return 0; } -/* - * This function dies on corrupt objects; the callers who want to - * deal with them should arrange to call odb_read_object_info_extended() and give - * error messages themselves. - */ -void *repo_read_object_file(struct repository *r, - const struct object_id *oid, - enum object_type *type, - unsigned long *size) +void *odb_read_object(struct object_database *odb, + const struct object_id *oid, + enum object_type *type, + unsigned long *size) { struct object_info oi = OBJECT_INFO_INIT; unsigned flags = OBJECT_INFO_DIE_IF_CORRUPT | OBJECT_INFO_LOOKUP_REPLACE; @@ -904,7 +899,7 @@ void *repo_read_object_file(struct repository *r, oi.typep = type; oi.sizep = size; oi.contentp = &data; - if (odb_read_object_info_extended(r->objects, oid, &oi, flags)) + if (odb_read_object_info_extended(odb, oid, &oi, flags)) return NULL; return data; @@ -926,7 +921,7 @@ void *read_object_with_reference(struct repository *r, int ref_length = -1; const char *ref_type = NULL; - buffer = repo_read_object_file(r, &actual_oid, &type, &isize); + buffer = odb_read_object(r->objects, &actual_oid, &type, &isize); if (!buffer) return NULL; if (type == required_type) { diff --git a/odb.h b/odb.h index b37a9c5d20ffa3..a4a5154fd0ff1d 100644 --- a/odb.h +++ b/odb.h @@ -140,7 +140,7 @@ struct object_database { /* * This is meant to hold a *small* number of objects that you would - * want repo_read_object_file() to be able to return, but yet you do not want + * want odb_read_object() to be able to return, but yet you do not want * to write them into the object store (e.g. a browse-only * application). */ @@ -260,10 +260,19 @@ void odb_add_to_alternates_file(struct object_database *odb, void odb_add_to_alternates_memory(struct object_database *odb, const char *dir); -void *repo_read_object_file(struct repository *r, - const struct object_id *oid, - enum object_type *type, - unsigned long *size); +/* + * Read an object from the database. Returns the object data and assigns object + * type and size to the `type` and `size` pointers, if these pointers are + * non-NULL. Returns a `NULL` pointer in case the object does not exist. + * + * This function dies on corrupt objects; the callers who want to deal with + * them should arrange to call odb_read_object_info_extended() and give error + * messages themselves. + */ +void *odb_read_object(struct object_database *odb, + const struct object_id *oid, + enum object_type *type, + unsigned long *size); /* * Add an object file to the in-memory object store, without writing it @@ -371,7 +380,7 @@ void odb_assert_oid_type(struct object_database *odb, /* * Enabling the object read lock allows multiple threads to safely call the - * following functions in parallel: repo_read_object_file(), + * following functions in parallel: odb_read_object(), * read_object_with_reference(), odb_read_object_info() and odb(). * * obj_read_lock() and obj_read_unlock() may also be used to protect other @@ -446,4 +455,12 @@ static inline int oid_object_info(struct repository *r, return odb_read_object_info(r->objects, oid, sizep); } +static inline void *repo_read_object_file(struct repository *r, + const struct object_id *oid, + enum object_type *type, + unsigned long *size) +{ + return odb_read_object(r->objects, oid, type, size); +} + #endif /* ODB_H */ diff --git a/read-cache.c b/read-cache.c index 7d5bccf95dcfc3..531d87e790529f 100644 --- a/read-cache.c +++ b/read-cache.c @@ -254,7 +254,7 @@ static int ce_compare_link(const struct cache_entry *ce, size_t expected_size) if (strbuf_readlink(&sb, ce->name, expected_size)) return -1; - buffer = repo_read_object_file(the_repository, &ce->oid, &type, &size); + buffer = odb_read_object(the_repository->objects, &ce->oid, &type, &size); if (buffer) { if (size == sb.len) match = memcmp(buffer, sb.buf, size); @@ -3485,8 +3485,8 @@ void *read_blob_data_from_index(struct index_state *istate, } if (pos < 0) return NULL; - data = repo_read_object_file(the_repository, &istate->cache[pos]->oid, - &type, &sz); + data = odb_read_object(the_repository->objects, &istate->cache[pos]->oid, + &type, &sz); if (!data || type != OBJ_BLOB) { free(data); return NULL; diff --git a/reflog.c b/reflog.c index 4f8a3b717cdb74..747b82eada83f4 100644 --- a/reflog.c +++ b/reflog.c @@ -140,8 +140,8 @@ static int tree_is_complete(const struct object_id *oid) if (!tree->buffer) { enum object_type type; unsigned long size; - void *data = repo_read_object_file(the_repository, oid, &type, - &size); + void *data = odb_read_object(the_repository->objects, oid, + &type, &size); if (!data) { tree->object.flags |= INCOMPLETE; return 0; diff --git a/rerere.c b/rerere.c index 951e4bf8b41c95..8bb97c98229bdd 100644 --- a/rerere.c +++ b/rerere.c @@ -1000,9 +1000,8 @@ static int handle_cache(struct index_state *istate, break; i = ce_stage(ce) - 1; if (!mmfile[i].ptr) { - mmfile[i].ptr = repo_read_object_file(the_repository, - &ce->oid, &type, - &size); + mmfile[i].ptr = odb_read_object(the_repository->objects, + &ce->oid, &type, &size); if (!mmfile[i].ptr) die(_("unable to read %s"), oid_to_hex(&ce->oid)); diff --git a/submodule-config.c b/submodule-config.c index a9f721078889eb..ea3a087a8bb91f 100644 --- a/submodule-config.c +++ b/submodule-config.c @@ -743,8 +743,8 @@ static const struct submodule *config_from(struct submodule_cache *cache, if (submodule) goto out; - config = repo_read_object_file(the_repository, &oid, &type, - &config_size); + config = odb_read_object(the_repository->objects, &oid, + &type, &config_size); if (!config || type != OBJ_BLOB) goto out; diff --git a/tag.c b/tag.c index 144048fd5e0c25..1d52686ee105f2 100644 --- a/tag.c +++ b/tag.c @@ -60,7 +60,7 @@ int gpg_verify_tag(const struct object_id *oid, const char *name_to_report, repo_find_unique_abbrev(the_repository, oid, DEFAULT_ABBREV), type_name(type)); - buf = repo_read_object_file(the_repository, oid, &type, &size); + buf = odb_read_object(the_repository->objects, oid, &type, &size); if (!buf) return error("%s: unable to read file.", name_to_report ? @@ -222,8 +222,8 @@ int parse_tag(struct tag *item) if (item->object.parsed) return 0; - data = repo_read_object_file(the_repository, &item->object.oid, &type, - &size); + data = odb_read_object(the_repository->objects, &item->object.oid, + &type, &size); if (!data) return error("Could not read %s", oid_to_hex(&item->object.oid)); diff --git a/tree-walk.c b/tree-walk.c index 34b0fff4873dbd..766af99f4668e4 100644 --- a/tree-walk.c +++ b/tree-walk.c @@ -795,9 +795,9 @@ enum get_oid_result get_tree_entry_follow_symlinks(struct repository *r, */ retval = DANGLING_SYMLINK; - contents = repo_read_object_file(r, - ¤t_tree_oid, &type, - &link_len); + contents = odb_read_object(r->objects, + ¤t_tree_oid, &type, + &link_len); if (!contents) goto done; diff --git a/tree.c b/tree.c index 341b7c2ff3fb9f..1ef743d90f4bad 100644 --- a/tree.c +++ b/tree.c @@ -193,8 +193,8 @@ int parse_tree_gently(struct tree *item, int quiet_on_missing) if (item->object.parsed) return 0; - buffer = repo_read_object_file(the_repository, &item->object.oid, - &type, &size); + buffer = odb_read_object(the_repository->objects, &item->object.oid, + &type, &size); if (!buffer) return quiet_on_missing ? -1 : error("Could not read %s", diff --git a/xdiff-interface.c b/xdiff-interface.c index 01e6e378ea6071..0e5d38c96003d3 100644 --- a/xdiff-interface.c +++ b/xdiff-interface.c @@ -187,7 +187,7 @@ void read_mmblob(mmfile_t *ptr, const struct object_id *oid) return; } - ptr->ptr = repo_read_object_file(the_repository, oid, &type, &size); + ptr->ptr = odb_read_object(the_repository->objects, oid, &type, &size); if (!ptr->ptr || type != OBJ_BLOB) die("unable to read blob object %s", oid_to_hex(oid)); ptr->size = size; From fcf8e3e111ec46705f91151baee40f2c0a3637da Mon Sep 17 00:00:00 2001 From: Patrick Steinhardt Date: Tue, 1 Jul 2025 14:22:27 +0200 Subject: [PATCH 18/21] odb: rename `has_object()` Rename `has_object()` to `odb_has_object()` to match other functions related to the object database and our modern coding guidelines. Introduce a compatibility wrapper so that any in-flight topics will continue to compile. Signed-off-by: Patrick Steinhardt Signed-off-by: Junio C Hamano --- apply.c | 2 +- builtin/backfill.c | 4 ++-- builtin/cat-file.c | 4 ++-- builtin/clone.c | 2 +- builtin/fetch.c | 17 +++++++++-------- builtin/fsck.c | 2 +- builtin/index-pack.c | 4 ++-- builtin/pack-objects.c | 4 ++-- builtin/receive-pack.c | 4 ++-- builtin/remote.c | 4 ++-- builtin/show-ref.c | 4 ++-- builtin/unpack-objects.c | 4 ++-- bulk-checkin.c | 4 ++-- cache-tree.c | 15 ++++++++------- commit-graph.c | 2 +- commit.c | 2 +- fetch-pack.c | 8 ++++---- http-push.c | 14 ++++++++------ http-walker.c | 8 ++++---- list-objects.c | 4 ++-- notes.c | 4 ++-- odb.c | 6 +++--- odb.h | 12 ++++++++++-- reflog.c | 2 +- refs.c | 3 ++- remote.c | 2 +- send-pack.c | 2 +- shallow.c | 12 ++++++------ upload-pack.c | 2 +- walker.c | 4 ++-- 30 files changed, 87 insertions(+), 74 deletions(-) diff --git a/apply.c b/apply.c index a34ced04625e18..a6836692d0ce08 100644 --- a/apply.c +++ b/apply.c @@ -3204,7 +3204,7 @@ static int apply_binary(struct apply_state *state, return 0; /* deletion patch */ } - if (has_object(the_repository, &oid, 0)) { + if (odb_has_object(the_repository->objects, &oid, 0)) { /* We already have the postimage */ enum object_type type; unsigned long size; diff --git a/builtin/backfill.c b/builtin/backfill.c index 0b49baa39fa5c8..80056abe4730ae 100644 --- a/builtin/backfill.c +++ b/builtin/backfill.c @@ -67,8 +67,8 @@ static int fill_missing_blobs(const char *path UNUSED, return 0; for (size_t i = 0; i < list->nr; i++) { - if (!has_object(ctx->repo, &list->oid[i], - OBJECT_INFO_FOR_PREFETCH)) + if (!odb_has_object(ctx->repo->objects, &list->oid[i], + OBJECT_INFO_FOR_PREFETCH)) oid_array_append(&ctx->current_batch, &list->oid[i]); } diff --git a/builtin/cat-file.c b/builtin/cat-file.c index 90a3e159d119cd..01672ec74bd2b8 100644 --- a/builtin/cat-file.c +++ b/builtin/cat-file.c @@ -160,8 +160,8 @@ static int cat_one_file(int opt, const char *exp_type, const char *obj_name) goto cleanup; case 'e': - ret = !has_object(the_repository, &oid, - HAS_OBJECT_RECHECK_PACKED | HAS_OBJECT_FETCH_PROMISOR); + ret = !odb_has_object(the_repository->objects, &oid, + HAS_OBJECT_RECHECK_PACKED | HAS_OBJECT_FETCH_PROMISOR); goto cleanup; case 'w': diff --git a/builtin/clone.c b/builtin/clone.c index 3aabdf6570b71b..6d08abed37c4ce 100644 --- a/builtin/clone.c +++ b/builtin/clone.c @@ -506,7 +506,7 @@ static void write_followtags(const struct ref *refs, const char *msg) continue; if (ends_with(ref->name, "^{}")) continue; - if (!has_object(the_repository, &ref->old_oid, 0)) + if (!odb_has_object(the_repository->objects, &ref->old_oid, 0)) continue; refs_update_ref(get_main_ref_store(the_repository), msg, ref->name, &ref->old_oid, NULL, 0, diff --git a/builtin/fetch.c b/builtin/fetch.c index b842bc9c51bb1c..65ea6c84368ecf 100644 --- a/builtin/fetch.c +++ b/builtin/fetch.c @@ -366,9 +366,9 @@ static void find_non_local_tags(const struct ref *refs, */ if (ends_with(ref->name, "^{}")) { if (item && - !has_object(the_repository, &ref->old_oid, 0) && + !odb_has_object(the_repository->objects, &ref->old_oid, 0) && !oidset_contains(&fetch_oids, &ref->old_oid) && - !has_object(the_repository, &item->oid, 0) && + !odb_has_object(the_repository->objects, &item->oid, 0) && !oidset_contains(&fetch_oids, &item->oid)) clear_item(item); item = NULL; @@ -382,7 +382,7 @@ static void find_non_local_tags(const struct ref *refs, * fetch. */ if (item && - !has_object(the_repository, &item->oid, 0) && + !odb_has_object(the_repository->objects, &item->oid, 0) && !oidset_contains(&fetch_oids, &item->oid)) clear_item(item); @@ -403,7 +403,7 @@ static void find_non_local_tags(const struct ref *refs, * checked to see if it needs fetching. */ if (item && - !has_object(the_repository, &item->oid, 0) && + !odb_has_object(the_repository->objects, &item->oid, 0) && !oidset_contains(&fetch_oids, &item->oid)) clear_item(item); @@ -910,8 +910,8 @@ static int update_local_ref(struct ref *ref, struct commit *current = NULL, *updated; int fast_forward = 0; - if (!has_object(the_repository, &ref->new_oid, - HAS_OBJECT_RECHECK_PACKED | HAS_OBJECT_FETCH_PROMISOR)) + if (!odb_has_object(the_repository->objects, &ref->new_oid, + HAS_OBJECT_RECHECK_PACKED | HAS_OBJECT_FETCH_PROMISOR)) die(_("object %s not found"), oid_to_hex(&ref->new_oid)); if (oideq(&ref->old_oid, &ref->new_oid)) { @@ -1330,7 +1330,8 @@ static int check_exist_and_connected(struct ref *ref_map) * we need all direct targets to exist. */ for (r = rm; r; r = r->next) { - if (!has_object(the_repository, &r->old_oid, HAS_OBJECT_RECHECK_PACKED)) + if (!odb_has_object(the_repository->objects, &r->old_oid, + HAS_OBJECT_RECHECK_PACKED)) return -1; } @@ -1485,7 +1486,7 @@ static void add_negotiation_tips(struct git_transport_options *smart_options) struct object_id oid; if (repo_get_oid(the_repository, s, &oid)) die(_("%s is not a valid object"), s); - if (!has_object(the_repository, &oid, 0)) + if (!odb_has_object(the_repository->objects, &oid, 0)) die(_("the object %s does not exist"), s); oid_array_append(oids, &oid); continue; diff --git a/builtin/fsck.c b/builtin/fsck.c index 6e3465b026696a..0084cf7400bd46 100644 --- a/builtin/fsck.c +++ b/builtin/fsck.c @@ -161,7 +161,7 @@ static int mark_object(struct object *obj, enum object_type type, return 0; if (!(obj->flags & HAS_OBJ)) { - if (parent && !has_object(the_repository, &obj->oid, 1)) { + if (parent && !odb_has_object(the_repository->objects, &obj->oid, 1)) { printf_ln(_("broken link from %7s %s\n" " to %7s %s"), printable_type(&parent->oid, parent->type), diff --git a/builtin/index-pack.c b/builtin/index-pack.c index 180d261f6ce288..19c67a8534414a 100644 --- a/builtin/index-pack.c +++ b/builtin/index-pack.c @@ -893,8 +893,8 @@ static void sha1_object(const void *data, struct object_entry *obj_entry, if (startup_info->have_repository) { read_lock(); - collision_test_needed = has_object(the_repository, oid, - HAS_OBJECT_FETCH_PROMISOR); + collision_test_needed = odb_has_object(the_repository->objects, oid, + HAS_OBJECT_FETCH_PROMISOR); read_unlock(); } diff --git a/builtin/pack-objects.c b/builtin/pack-objects.c index 580a5c1996b406..06bdeb4223b6d7 100644 --- a/builtin/pack-objects.c +++ b/builtin/pack-objects.c @@ -3968,7 +3968,7 @@ static void show_object__ma_allow_any(struct object *obj, const char *name, void * Quietly ignore ALL missing objects. This avoids problems with * staging them now and getting an odd error later. */ - if (!has_object(the_repository, &obj->oid, 0)) + if (!odb_has_object(the_repository->objects, &obj->oid, 0)) return; show_object(obj, name, data); @@ -3982,7 +3982,7 @@ static void show_object__ma_allow_promisor(struct object *obj, const char *name, * Quietly ignore EXPECTED missing objects. This avoids problems with * staging them now and getting an odd error later. */ - if (!has_object(the_repository, &obj->oid, 0) && + if (!odb_has_object(the_repository->objects, &obj->oid, 0) && is_promisor_object(to_pack.repo, &obj->oid)) return; diff --git a/builtin/receive-pack.c b/builtin/receive-pack.c index 7ea273d93e40ae..26e77d70726aae 100644 --- a/builtin/receive-pack.c +++ b/builtin/receive-pack.c @@ -1509,8 +1509,8 @@ static const char *update(struct command *cmd, struct shallow_info *si) } if (!is_null_oid(new_oid) && - !has_object(the_repository, new_oid, - HAS_OBJECT_RECHECK_PACKED | HAS_OBJECT_FETCH_PROMISOR)) { + !odb_has_object(the_repository->objects, new_oid, + HAS_OBJECT_RECHECK_PACKED | HAS_OBJECT_FETCH_PROMISOR)) { error("unpack should have generated %s, " "but I can't find it!", oid_to_hex(new_oid)); ret = "bad pack"; diff --git a/builtin/remote.c b/builtin/remote.c index ac5b8d2a1a6506..7cbda285ebed33 100644 --- a/builtin/remote.c +++ b/builtin/remote.c @@ -454,8 +454,8 @@ static int get_push_ref_states(const struct ref *remote_refs, info->status = PUSH_STATUS_UPTODATE; else if (is_null_oid(&ref->old_oid)) info->status = PUSH_STATUS_CREATE; - else if (has_object(the_repository, &ref->old_oid, - HAS_OBJECT_RECHECK_PACKED | HAS_OBJECT_FETCH_PROMISOR) && + else if (odb_has_object(the_repository->objects, &ref->old_oid, + HAS_OBJECT_RECHECK_PACKED | HAS_OBJECT_FETCH_PROMISOR) && ref_newer(&ref->new_oid, &ref->old_oid)) info->status = PUSH_STATUS_FASTFORWARD; else diff --git a/builtin/show-ref.c b/builtin/show-ref.c index 90ec1de78f9002..117709cb076ab3 100644 --- a/builtin/show-ref.c +++ b/builtin/show-ref.c @@ -35,8 +35,8 @@ static void show_one(const struct show_one_options *opts, const char *hex; struct object_id peeled; - if (!has_object(the_repository, oid, - HAS_OBJECT_RECHECK_PACKED | HAS_OBJECT_FETCH_PROMISOR)) + if (!odb_has_object(the_repository->objects, oid, + HAS_OBJECT_RECHECK_PACKED | HAS_OBJECT_FETCH_PROMISOR)) die("git show-ref: bad ref %s (%s)", refname, oid_to_hex(oid)); diff --git a/builtin/unpack-objects.c b/builtin/unpack-objects.c index 4bc6575a5743e1..a69d59eb50c902 100644 --- a/builtin/unpack-objects.c +++ b/builtin/unpack-objects.c @@ -449,8 +449,8 @@ static void unpack_delta_entry(enum object_type type, unsigned long delta_size, delta_data = get_data(delta_size); if (!delta_data) return; - if (has_object(the_repository, &base_oid, - HAS_OBJECT_RECHECK_PACKED | HAS_OBJECT_FETCH_PROMISOR)) + if (odb_has_object(the_repository->objects, &base_oid, + HAS_OBJECT_RECHECK_PACKED | HAS_OBJECT_FETCH_PROMISOR)) ; /* Ok we have this one */ else if (resolve_against_held(nr, &base_oid, delta_data, delta_size)) diff --git a/bulk-checkin.c b/bulk-checkin.c index 55406a539e7d4a..16df86c0ba89db 100644 --- a/bulk-checkin.c +++ b/bulk-checkin.c @@ -130,8 +130,8 @@ static void flush_batch_fsync(void) static int already_written(struct bulk_checkin_packfile *state, struct object_id *oid) { /* The object may already exist in the repository */ - if (has_object(the_repository, oid, - HAS_OBJECT_RECHECK_PACKED | HAS_OBJECT_FETCH_PROMISOR)) + if (odb_has_object(the_repository->objects, oid, + HAS_OBJECT_RECHECK_PACKED | HAS_OBJECT_FETCH_PROMISOR)) return 1; /* Might want to keep the list sorted */ diff --git a/cache-tree.c b/cache-tree.c index 9786b32b3a1caa..a4bc14ad15c8a0 100644 --- a/cache-tree.c +++ b/cache-tree.c @@ -239,8 +239,8 @@ int cache_tree_fully_valid(struct cache_tree *it) if (!it) return 0; if (it->entry_count < 0 || - has_object(the_repository, &it->oid, - HAS_OBJECT_RECHECK_PACKED | HAS_OBJECT_FETCH_PROMISOR)) + odb_has_object(the_repository->objects, &it->oid, + HAS_OBJECT_RECHECK_PACKED | HAS_OBJECT_FETCH_PROMISOR)) return 0; for (i = 0; i < it->subtree_nr; i++) { if (!cache_tree_fully_valid(it->down[i]->cache_tree)) @@ -292,8 +292,8 @@ static int update_one(struct cache_tree *it, } if (0 <= it->entry_count && - has_object(the_repository, &it->oid, - HAS_OBJECT_RECHECK_PACKED | HAS_OBJECT_FETCH_PROMISOR)) + odb_has_object(the_repository->objects, &it->oid, + HAS_OBJECT_RECHECK_PACKED | HAS_OBJECT_FETCH_PROMISOR)) return it->entry_count; /* @@ -399,8 +399,9 @@ static int update_one(struct cache_tree *it, ce_missing_ok = mode == S_IFGITLINK || missing_ok || !must_check_existence(ce); if (is_null_oid(oid) || - (!ce_missing_ok && !has_object(the_repository, oid, - HAS_OBJECT_RECHECK_PACKED | HAS_OBJECT_FETCH_PROMISOR))) { + (!ce_missing_ok && + !odb_has_object(the_repository->objects, oid, + HAS_OBJECT_RECHECK_PACKED | HAS_OBJECT_FETCH_PROMISOR))) { strbuf_release(&buffer); if (expected_missing) return -1; @@ -448,7 +449,7 @@ static int update_one(struct cache_tree *it, struct object_id oid; hash_object_file(the_hash_algo, buffer.buf, buffer.len, OBJ_TREE, &oid); - if (has_object(the_repository, &oid, HAS_OBJECT_RECHECK_PACKED)) + if (odb_has_object(the_repository->objects, &oid, HAS_OBJECT_RECHECK_PACKED)) oidcpy(&it->oid, &oid); else to_invalidate = 1; diff --git a/commit-graph.c b/commit-graph.c index 5f482d3377ff1b..bd7b6f5338bd9d 100644 --- a/commit-graph.c +++ b/commit-graph.c @@ -1040,7 +1040,7 @@ struct commit *lookup_commit_in_graph(struct repository *repo, const struct obje return NULL; if (!search_commit_pos_in_graph(id, repo->objects->commit_graph, &pos)) return NULL; - if (commit_graph_paranoia && !has_object(repo, id, 0)) + if (commit_graph_paranoia && !odb_has_object(repo->objects, id, 0)) return NULL; commit = lookup_commit(repo, id); diff --git a/commit.c b/commit.c index 28ee6b73ae6be0..15115125c3612c 100644 --- a/commit.c +++ b/commit.c @@ -575,7 +575,7 @@ int repo_parse_commit_internal(struct repository *r, if (commit_graph_paranoia == -1) commit_graph_paranoia = git_env_bool(GIT_COMMIT_GRAPH_PARANOIA, 0); - if (commit_graph_paranoia && !has_object(r, &item->object.oid, 0)) { + if (commit_graph_paranoia && !odb_has_object(r->objects, &item->object.oid, 0)) { unparse_commit(r, &item->object.oid); return quiet_on_missing ? -1 : error(_("commit %s exists in commit-graph but not in the object database"), diff --git a/fetch-pack.c b/fetch-pack.c index 0f5de1c94d1478..5e74235fc06f09 100644 --- a/fetch-pack.c +++ b/fetch-pack.c @@ -142,7 +142,7 @@ static struct commit *deref_without_lazy_fetch(const struct object_id *oid, commit = lookup_commit_in_graph(the_repository, oid); if (commit) { if (mark_tags_complete_and_check_obj_db) { - if (!has_object(the_repository, oid, 0)) + if (!odb_has_object(the_repository->objects, oid, 0)) die_in_commit_graph_only(oid); } return commit; @@ -770,7 +770,7 @@ static void mark_complete_and_common_ref(struct fetch_negotiator *negotiator, if (!commit) { struct object *o; - if (!has_object(the_repository, &ref->old_oid, 0)) + if (!odb_has_object(the_repository->objects, &ref->old_oid, 0)) continue; o = parse_object(the_repository, &ref->old_oid); if (!o || o->type != OBJ_COMMIT) @@ -1984,8 +1984,8 @@ static void update_shallow(struct fetch_pack_args *args, struct oid_array extra = OID_ARRAY_INIT; struct object_id *oid = si->shallow->oid; for (i = 0; i < si->shallow->nr; i++) - if (has_object(the_repository, &oid[i], - HAS_OBJECT_RECHECK_PACKED | HAS_OBJECT_FETCH_PROMISOR)) + if (odb_has_object(the_repository->objects, &oid[i], + HAS_OBJECT_RECHECK_PACKED | HAS_OBJECT_FETCH_PROMISOR)) oid_array_append(&extra, &oid[i]); if (extra.nr) { setup_alternate_shallow(&shallow_lock, diff --git a/http-push.c b/http-push.c index 9481825abfb8ad..beb41732fb6bfa 100644 --- a/http-push.c +++ b/http-push.c @@ -1447,8 +1447,8 @@ static void one_remote_ref(const char *refname) * may be required for updating server info later. */ if (repo->can_update_info_refs && - !has_object(the_repository, &ref->old_oid, - HAS_OBJECT_RECHECK_PACKED | HAS_OBJECT_FETCH_PROMISOR)) { + !odb_has_object(the_repository->objects, &ref->old_oid, + HAS_OBJECT_RECHECK_PACKED | HAS_OBJECT_FETCH_PROMISOR)) { obj = lookup_unknown_object(the_repository, &ref->old_oid); fprintf(stderr, " fetch %s for %s\n", oid_to_hex(&ref->old_oid), refname); @@ -1653,14 +1653,16 @@ static int delete_remote_branch(const char *pattern, int force) return error("Remote HEAD symrefs too deep"); if (is_null_oid(&head_oid)) return error("Unable to resolve remote HEAD"); - if (!has_object(the_repository, &head_oid, HAS_OBJECT_RECHECK_PACKED | HAS_OBJECT_FETCH_PROMISOR)) + if (!odb_has_object(the_repository->objects, &head_oid, + HAS_OBJECT_RECHECK_PACKED | HAS_OBJECT_FETCH_PROMISOR)) return error("Remote HEAD resolves to object %s\nwhich does not exist locally, perhaps you need to fetch?", oid_to_hex(&head_oid)); /* Remote branch must resolve to a known object */ if (is_null_oid(&remote_ref->old_oid)) return error("Unable to resolve remote branch %s", remote_ref->name); - if (!has_object(the_repository, &remote_ref->old_oid, HAS_OBJECT_RECHECK_PACKED | HAS_OBJECT_FETCH_PROMISOR)) + if (!odb_has_object(the_repository->objects, &remote_ref->old_oid, + HAS_OBJECT_RECHECK_PACKED | HAS_OBJECT_FETCH_PROMISOR)) return error("Remote branch %s resolves to object %s\nwhich does not exist locally, perhaps you need to fetch?", remote_ref->name, oid_to_hex(&remote_ref->old_oid)); /* Remote branch must be an ancestor of remote HEAD */ @@ -1881,8 +1883,8 @@ int cmd_main(int argc, const char **argv) if (!force_all && !is_null_oid(&ref->old_oid) && !ref->force) { - if (!has_object(the_repository, &ref->old_oid, - HAS_OBJECT_RECHECK_PACKED | HAS_OBJECT_FETCH_PROMISOR) || + if (!odb_has_object(the_repository->objects, &ref->old_oid, + HAS_OBJECT_RECHECK_PACKED | HAS_OBJECT_FETCH_PROMISOR) || !ref_newer(&ref->peer_ref->new_oid, &ref->old_oid)) { /* diff --git a/http-walker.c b/http-walker.c index 05fb9ce714a4c9..0f7ae46d7f12c0 100644 --- a/http-walker.c +++ b/http-walker.c @@ -138,8 +138,8 @@ static int fill_active_slot(void *data UNUSED) list_for_each_safe(pos, tmp, head) { obj_req = list_entry(pos, struct object_request, node); if (obj_req->state == WAITING) { - if (has_object(the_repository, &obj_req->oid, - HAS_OBJECT_RECHECK_PACKED | HAS_OBJECT_FETCH_PROMISOR)) + if (odb_has_object(the_repository->objects, &obj_req->oid, + HAS_OBJECT_RECHECK_PACKED | HAS_OBJECT_FETCH_PROMISOR)) obj_req->state = COMPLETE; else { start_object_request(obj_req); @@ -497,8 +497,8 @@ static int fetch_object(struct walker *walker, const struct object_id *oid) if (!obj_req) return error("Couldn't find request for %s in the queue", hex); - if (has_object(the_repository, &obj_req->oid, - HAS_OBJECT_RECHECK_PACKED | HAS_OBJECT_FETCH_PROMISOR)) { + if (odb_has_object(the_repository->objects, &obj_req->oid, + HAS_OBJECT_RECHECK_PACKED | HAS_OBJECT_FETCH_PROMISOR)) { if (obj_req->req) abort_http_object_request(&obj_req->req); abort_object_request(obj_req); diff --git a/list-objects.c b/list-objects.c index c50b9578584d20..42c17d9573910b 100644 --- a/list-objects.c +++ b/list-objects.c @@ -74,8 +74,8 @@ static void process_blob(struct traversal_context *ctx, * of missing objects. */ if (ctx->revs->exclude_promisor_objects && - !has_object(the_repository, &obj->oid, - HAS_OBJECT_RECHECK_PACKED | HAS_OBJECT_FETCH_PROMISOR) && + !odb_has_object(the_repository->objects, &obj->oid, + HAS_OBJECT_RECHECK_PACKED | HAS_OBJECT_FETCH_PROMISOR) && is_promisor_object(ctx->revs->repo, &obj->oid)) return; diff --git a/notes.c b/notes.c index 73eb5f00cf5174..97b995f3f2da6f 100644 --- a/notes.c +++ b/notes.c @@ -794,8 +794,8 @@ static int prune_notes_helper(const struct object_id *object_oid, struct note_delete_list **l = (struct note_delete_list **) cb_data; struct note_delete_list *n; - if (has_object(the_repository, object_oid, - HAS_OBJECT_RECHECK_PACKED | HAS_OBJECT_FETCH_PROMISOR)) + if (odb_has_object(the_repository->objects, object_oid, + HAS_OBJECT_RECHECK_PACKED | HAS_OBJECT_FETCH_PROMISOR)) return 0; /* nothing to do for this note */ /* failed to find object => prune this note */ diff --git a/odb.c b/odb.c index 5419d5dff6d2b7..ecb6711a27bd8b 100644 --- a/odb.c +++ b/odb.c @@ -871,7 +871,7 @@ int pretend_object_file(struct repository *repo, char *co_buf; hash_object_file(repo->hash_algo, buf, len, type, oid); - if (has_object(repo, oid, 0) || + if (odb_has_object(repo->objects, oid, 0) || find_cached_object(repo->objects, oid)) return 0; @@ -953,7 +953,7 @@ void *read_object_with_reference(struct repository *r, } } -int has_object(struct repository *r, const struct object_id *oid, +int odb_has_object(struct object_database *odb, const struct object_id *oid, unsigned flags) { unsigned object_info_flags = 0; @@ -965,7 +965,7 @@ int has_object(struct repository *r, const struct object_id *oid, if (!(flags & HAS_OBJECT_FETCH_PROMISOR)) object_info_flags |= OBJECT_INFO_SKIP_FETCH_OBJECT; - return odb_read_object_info_extended(r->objects, oid, NULL, object_info_flags) >= 0; + return odb_read_object_info_extended(odb, oid, NULL, object_info_flags) >= 0; } void odb_assert_oid_type(struct object_database *odb, diff --git a/odb.h b/odb.h index a4a5154fd0ff1d..2532c4904619da 100644 --- a/odb.h +++ b/odb.h @@ -372,8 +372,9 @@ enum { * Returns 1 if the object exists. This function will not lazily fetch objects * in a partial clone by default. */ -int has_object(struct repository *r, const struct object_id *oid, - unsigned flags); +int odb_has_object(struct object_database *odb, + const struct object_id *oid, + unsigned flags); void odb_assert_oid_type(struct object_database *odb, const struct object_id *oid, enum object_type expect); @@ -463,4 +464,11 @@ static inline void *repo_read_object_file(struct repository *r, return odb_read_object(r->objects, oid, type, size); } +static inline int has_object(struct repository *r, + const struct object_id *oid, + unsigned flags) +{ + return odb_has_object(r->objects, oid, flags); +} + #endif /* ODB_H */ diff --git a/reflog.c b/reflog.c index 747b82eada83f4..39c205fd26e77b 100644 --- a/reflog.c +++ b/reflog.c @@ -152,7 +152,7 @@ static int tree_is_complete(const struct object_id *oid) init_tree_desc(&desc, &tree->object.oid, tree->buffer, tree->size); complete = 1; while (tree_entry(&desc, &entry)) { - if (!has_object(the_repository, &entry.oid, + if (!odb_has_object(the_repository->objects, &entry.oid, HAS_OBJECT_RECHECK_PACKED | HAS_OBJECT_FETCH_PROMISOR) || (S_ISDIR(entry.mode) && !tree_is_complete(&entry.oid))) { tree->object.flags |= INCOMPLETE; diff --git a/refs.c b/refs.c index 0ff0e582a6b019..26e5c2a7d9cf18 100644 --- a/refs.c +++ b/refs.c @@ -376,7 +376,8 @@ int ref_resolves_to_object(const char *refname, { if (flags & REF_ISBROKEN) return 0; - if (!has_object(repo, oid, HAS_OBJECT_RECHECK_PACKED | HAS_OBJECT_FETCH_PROMISOR)) { + if (!odb_has_object(repo->objects, oid, + HAS_OBJECT_RECHECK_PACKED | HAS_OBJECT_FETCH_PROMISOR)) { error(_("%s does not point to a valid object!"), refname); return 0; } diff --git a/remote.c b/remote.c index 72c36239d31e34..5edf2a9f4b2d0e 100644 --- a/remote.c +++ b/remote.c @@ -1703,7 +1703,7 @@ void set_ref_status_for_push(struct ref *remote_refs, int send_mirror, if (!reject_reason && !ref->deletion && !is_null_oid(&ref->old_oid)) { if (starts_with(ref->name, "refs/tags/")) reject_reason = REF_STATUS_REJECT_ALREADY_EXISTS; - else if (!has_object(the_repository, &ref->old_oid, HAS_OBJECT_RECHECK_PACKED)) + else if (!odb_has_object(the_repository->objects, &ref->old_oid, HAS_OBJECT_RECHECK_PACKED)) reject_reason = REF_STATUS_REJECT_FETCH_FIRST; else if (!lookup_commit_reference_gently(the_repository, &ref->old_oid, 1) || !lookup_commit_reference_gently(the_repository, &ref->new_oid, 1)) diff --git a/send-pack.c b/send-pack.c index abca2dd38a78ba..d029f748232a42 100644 --- a/send-pack.c +++ b/send-pack.c @@ -45,7 +45,7 @@ int option_parse_push_signed(const struct option *opt, static void feed_object(struct repository *r, const struct object_id *oid, FILE *fh, int negative) { - if (negative && !has_object(r, oid, 0)) + if (negative && !odb_has_object(r->objects, oid, 0)) return; if (negative) diff --git a/shallow.c b/shallow.c index d379756e39a67a..ef3adb635fdb9c 100644 --- a/shallow.c +++ b/shallow.c @@ -310,8 +310,8 @@ static int write_one_shallow(const struct commit_graft *graft, void *cb_data) if (graft->nr_parent != -1) return 0; if (data->flags & QUICK) { - if (!has_object(the_repository, &graft->oid, - HAS_OBJECT_RECHECK_PACKED | HAS_OBJECT_FETCH_PROMISOR)) + if (!odb_has_object(the_repository->objects, &graft->oid, + HAS_OBJECT_RECHECK_PACKED | HAS_OBJECT_FETCH_PROMISOR)) return 0; } else if (data->flags & SEEN_ONLY) { struct commit *c = lookup_commit(the_repository, &graft->oid); @@ -477,8 +477,8 @@ void prepare_shallow_info(struct shallow_info *info, struct oid_array *sa) ALLOC_ARRAY(info->ours, sa->nr); ALLOC_ARRAY(info->theirs, sa->nr); for (size_t i = 0; i < sa->nr; i++) { - if (has_object(the_repository, sa->oid + i, - HAS_OBJECT_RECHECK_PACKED | HAS_OBJECT_FETCH_PROMISOR)) { + if (odb_has_object(the_repository->objects, sa->oid + i, + HAS_OBJECT_RECHECK_PACKED | HAS_OBJECT_FETCH_PROMISOR)) { struct commit_graft *graft; graft = lookup_commit_graft(the_repository, &sa->oid[i]); @@ -515,8 +515,8 @@ void remove_nonexistent_theirs_shallow(struct shallow_info *info) for (i = dst = 0; i < info->nr_theirs; i++) { if (i != dst) info->theirs[dst] = info->theirs[i]; - if (has_object(the_repository, oid + info->theirs[i], - HAS_OBJECT_RECHECK_PACKED | HAS_OBJECT_FETCH_PROMISOR)) + if (odb_has_object(the_repository->objects, oid + info->theirs[i], + HAS_OBJECT_RECHECK_PACKED | HAS_OBJECT_FETCH_PROMISOR)) dst++; } info->nr_theirs = dst; diff --git a/upload-pack.c b/upload-pack.c index e994d6a901b667..4f26f6afc77106 100644 --- a/upload-pack.c +++ b/upload-pack.c @@ -509,7 +509,7 @@ static int got_oid(struct upload_pack_data *data, { if (get_oid_hex(hex, oid)) die("git upload-pack: expected SHA1 object, got '%s'", hex); - if (!has_object(the_repository, oid, 0)) + if (!odb_has_object(the_repository->objects, oid, 0)) return -1; return do_got_oid(data, oid); } diff --git a/walker.c b/walker.c index a8abe8a2e78ee5..d131af04c7bf04 100644 --- a/walker.c +++ b/walker.c @@ -150,8 +150,8 @@ static int process(struct walker *walker, struct object *obj) return 0; obj->flags |= SEEN; - if (has_object(the_repository, &obj->oid, - HAS_OBJECT_RECHECK_PACKED | HAS_OBJECT_FETCH_PROMISOR)) { + if (odb_has_object(the_repository->objects, &obj->oid, + HAS_OBJECT_RECHECK_PACKED | HAS_OBJECT_FETCH_PROMISOR)) { /* We already have it, so we should scan it now. */ obj->flags |= TO_SCAN; } From 08218b8cd4b54468bbb7cd09454a630ca4209d1a Mon Sep 17 00:00:00 2001 From: Patrick Steinhardt Date: Tue, 1 Jul 2025 14:22:28 +0200 Subject: [PATCH 19/21] odb: rename `pretend_object_file()` Rename `pretend_object_file()` to `odb_pretend_object()` to match other functions related to the object database and our modern coding guidelines. No compatibility wrapper is introduced as the function is not used a lot throughout our codebase. Signed-off-by: Patrick Steinhardt Signed-off-by: Junio C Hamano --- blame.c | 3 ++- odb.c | 18 +++++++++--------- odb.h | 6 +++--- 3 files changed, 14 insertions(+), 13 deletions(-) diff --git a/blame.c b/blame.c index 858d2d74df98fb..dce5c8d855c438 100644 --- a/blame.c +++ b/blame.c @@ -277,7 +277,8 @@ static struct commit *fake_working_tree_commit(struct repository *r, convert_to_git(r->index, path, buf.buf, buf.len, &buf, 0); origin->file.ptr = buf.buf; origin->file.size = buf.len; - pretend_object_file(the_repository, buf.buf, buf.len, OBJ_BLOB, &origin->blob_oid); + odb_pretend_object(the_repository->objects, buf.buf, buf.len, + OBJ_BLOB, &origin->blob_oid); /* * Read the current index, replace the path entry with diff --git a/odb.c b/odb.c index ecb6711a27bd8b..217903d7b1423a 100644 --- a/odb.c +++ b/odb.c @@ -863,21 +863,21 @@ int odb_read_object_info(struct object_database *odb, return type; } -int pretend_object_file(struct repository *repo, - void *buf, unsigned long len, enum object_type type, - struct object_id *oid) +int odb_pretend_object(struct object_database *odb, + void *buf, unsigned long len, enum object_type type, + struct object_id *oid) { struct cached_object_entry *co; char *co_buf; - hash_object_file(repo->hash_algo, buf, len, type, oid); - if (odb_has_object(repo->objects, oid, 0) || - find_cached_object(repo->objects, oid)) + hash_object_file(odb->repo->hash_algo, buf, len, type, oid); + if (odb_has_object(odb, oid, 0) || + find_cached_object(odb, oid)) return 0; - ALLOC_GROW(repo->objects->cached_objects, - repo->objects->cached_object_nr + 1, repo->objects->cached_object_alloc); - co = &repo->objects->cached_objects[repo->objects->cached_object_nr++]; + ALLOC_GROW(odb->cached_objects, + odb->cached_object_nr + 1, odb->cached_object_alloc); + co = &odb->cached_objects[odb->cached_object_nr++]; co->value.size = len; co->value.type = type; co_buf = xmalloc(len); diff --git a/odb.h b/odb.h index 2532c4904619da..e4c51f8c38e9e6 100644 --- a/odb.h +++ b/odb.h @@ -282,9 +282,9 @@ void *odb_read_object(struct object_database *odb, * object in persistent storage before writing any other new objects * that reference it. */ -int pretend_object_file(struct repository *repo, - void *buf, unsigned long len, enum object_type type, - struct object_id *oid); +int odb_pretend_object(struct object_database *odb, + void *buf, unsigned long len, enum object_type type, + struct object_id *oid); struct object_info { /* Request */ From 841a03b4046ab81276743b4d7e727b1658f805da Mon Sep 17 00:00:00 2001 From: Patrick Steinhardt Date: Tue, 1 Jul 2025 14:22:29 +0200 Subject: [PATCH 20/21] odb: rename `read_object_with_reference()` Rename `read_object_with_reference()` to `odb_read_object_peeled()` to match other functions related to the object database and our modern coding guidelines. Furthermore though, the old name didn't really describe very well what this function actually does, which is to walk down any commit and tag objects until an object of the required type has been found. This is generally referred to as "peeling", so the new name should be way more descriptive. No compatibility wrapper is introduced as the function is not used a lot throughout our codebase. Signed-off-by: Patrick Steinhardt Signed-off-by: Junio C Hamano --- Documentation/user-manual.adoc | 4 ++-- builtin/cat-file.c | 4 ++-- builtin/fast-import.c | 19 ++++++++----------- builtin/grep.c | 9 +++------ builtin/pack-objects.c | 4 ++-- odb.c | 17 +++++++++-------- odb.h | 15 +++++++-------- tree-walk.c | 10 ++++------ 8 files changed, 37 insertions(+), 45 deletions(-) diff --git a/Documentation/user-manual.adoc b/Documentation/user-manual.adoc index d2b478ad23221a..e86b2ad9f8ab75 100644 --- a/Documentation/user-manual.adoc +++ b/Documentation/user-manual.adoc @@ -4301,11 +4301,11 @@ Now, for the meat: ----------------------------------------------------------------------------- case 0: - buf = read_object_with_reference(sha1, argv[1], &size, NULL); + buf = odb_read_object_peeled(r->objects, sha1, argv[1], &size, NULL); ----------------------------------------------------------------------------- This is how you read a blob (actually, not only a blob, but any type of -object). To know how the function `read_object_with_reference()` actually +object). To know how the function `odb_read_object_peeled()` actually works, find the source code for it (something like `git grep read_object_with | grep ":[a-z]"` in the Git repository), and read the source. diff --git a/builtin/cat-file.c b/builtin/cat-file.c index 01672ec74bd2b8..08afecbf57cb4b 100644 --- a/builtin/cat-file.c +++ b/builtin/cat-file.c @@ -246,8 +246,8 @@ static int cat_one_file(int opt, const char *exp_type, const char *obj_name) * fall-back to the usual case. */ } - buf = read_object_with_reference(the_repository, &oid, - exp_type_id, &size, NULL); + buf = odb_read_object_peeled(the_repository->objects, &oid, + exp_type_id, &size, NULL); if (use_mailmap) { size_t s = size; diff --git a/builtin/fast-import.c b/builtin/fast-import.c index 1973c504e25754..b1389c59211a48 100644 --- a/builtin/fast-import.c +++ b/builtin/fast-import.c @@ -2535,10 +2535,9 @@ static void note_change_n(const char *p, struct branch *b, unsigned char *old_fa oidcpy(&commit_oid, &commit_oe->idx.oid); } else if (!repo_get_oid(the_repository, p, &commit_oid)) { unsigned long size; - char *buf = read_object_with_reference(the_repository, - &commit_oid, - OBJ_COMMIT, &size, - &commit_oid); + char *buf = odb_read_object_peeled(the_repository->objects, + &commit_oid, OBJ_COMMIT, &size, + &commit_oid); if (!buf || size < the_hash_algo->hexsz + 6) die("Not a valid commit: %s", p); free(buf); @@ -2604,9 +2603,8 @@ static void parse_from_existing(struct branch *b) unsigned long size; char *buf; - buf = read_object_with_reference(the_repository, - &b->oid, OBJ_COMMIT, &size, - &b->oid); + buf = odb_read_object_peeled(the_repository->objects, &b->oid, + OBJ_COMMIT, &size, &b->oid); parse_from_commit(b, buf, size); free(buf); } @@ -2699,10 +2697,9 @@ static struct hash_list *parse_merge(unsigned int *count) oidcpy(&n->oid, &oe->idx.oid); } else if (!repo_get_oid(the_repository, from, &n->oid)) { unsigned long size; - char *buf = read_object_with_reference(the_repository, - &n->oid, - OBJ_COMMIT, - &size, &n->oid); + char *buf = odb_read_object_peeled(the_repository->objects, + &n->oid, OBJ_COMMIT, + &size, &n->oid); if (!buf || size < the_hash_algo->hexsz + 6) die("Not a valid commit: %s", from); free(buf); diff --git a/builtin/grep.c b/builtin/grep.c index 5de61dfffe893b..39273d9c0fd47d 100644 --- a/builtin/grep.c +++ b/builtin/grep.c @@ -522,9 +522,7 @@ static int grep_submodule(struct grep_opt *opt, obj_read_lock(); object_type = odb_read_object_info(subrepo->objects, oid, NULL); obj_read_unlock(); - data = read_object_with_reference(subrepo, - oid, OBJ_TREE, - &size, NULL); + data = odb_read_object_peeled(subrepo->objects, oid, OBJ_TREE, &size, NULL); if (!data) die(_("unable to read tree (%s)"), oid_to_hex(oid)); @@ -705,9 +703,8 @@ static int grep_object(struct grep_opt *opt, const struct pathspec *pathspec, struct strbuf base; int hit, len; - data = read_object_with_reference(opt->repo, - &obj->oid, OBJ_TREE, - &size, NULL); + data = odb_read_object_peeled(opt->repo->objects, &obj->oid, + OBJ_TREE, &size, NULL); if (!data) die(_("unable to read tree (%s)"), oid_to_hex(&obj->oid)); diff --git a/builtin/pack-objects.c b/builtin/pack-objects.c index 06bdeb4223b6d7..e88a13dbb9f47e 100644 --- a/builtin/pack-objects.c +++ b/builtin/pack-objects.c @@ -2055,8 +2055,8 @@ static void add_preferred_base(struct object_id *oid) if (window <= num_preferred_base++) return; - data = read_object_with_reference(the_repository, oid, - OBJ_TREE, &size, &tree_oid); + data = odb_read_object_peeled(the_repository->objects, oid, + OBJ_TREE, &size, &tree_oid); if (!data) return; diff --git a/odb.c b/odb.c index 217903d7b1423a..1f48a0448e398a 100644 --- a/odb.c +++ b/odb.c @@ -905,11 +905,11 @@ void *odb_read_object(struct object_database *odb, return data; } -void *read_object_with_reference(struct repository *r, - const struct object_id *oid, - enum object_type required_type, - unsigned long *size, - struct object_id *actual_oid_return) +void *odb_read_object_peeled(struct object_database *odb, + const struct object_id *oid, + enum object_type required_type, + unsigned long *size, + struct object_id *actual_oid_return) { enum object_type type; void *buffer; @@ -921,7 +921,7 @@ void *read_object_with_reference(struct repository *r, int ref_length = -1; const char *ref_type = NULL; - buffer = odb_read_object(r->objects, &actual_oid, &type, &isize); + buffer = odb_read_object(odb, &actual_oid, &type, &isize); if (!buffer) return NULL; if (type == required_type) { @@ -941,9 +941,10 @@ void *read_object_with_reference(struct repository *r, } ref_length = strlen(ref_type); - if (ref_length + r->hash_algo->hexsz > isize || + if (ref_length + odb->repo->hash_algo->hexsz > isize || memcmp(buffer, ref_type, ref_length) || - get_oid_hex_algop((char *) buffer + ref_length, &actual_oid, r->hash_algo)) { + get_oid_hex_algop((char *) buffer + ref_length, &actual_oid, + odb->repo->hash_algo)) { free(buffer); return NULL; } diff --git a/odb.h b/odb.h index e4c51f8c38e9e6..e922f256802a0c 100644 --- a/odb.h +++ b/odb.h @@ -274,6 +274,12 @@ void *odb_read_object(struct object_database *odb, enum object_type *type, unsigned long *size); +void *odb_read_object_peeled(struct object_database *odb, + const struct object_id *oid, + enum object_type required_type, + unsigned long *size, + struct object_id *oid_ret); + /* * Add an object file to the in-memory object store, without writing it * to disk. @@ -382,7 +388,7 @@ void odb_assert_oid_type(struct object_database *odb, /* * Enabling the object read lock allows multiple threads to safely call the * following functions in parallel: odb_read_object(), - * read_object_with_reference(), odb_read_object_info() and odb(). + * odb_read_object_peeled(), odb_read_object_info() and odb(). * * obj_read_lock() and obj_read_unlock() may also be used to protect other * section which cannot execute in parallel with object reading. Since the used @@ -431,13 +437,6 @@ enum for_each_object_flags { FOR_EACH_OBJECT_SKIP_ON_DISK_KEPT_PACKS = (1<<4), }; - -void *read_object_with_reference(struct repository *r, - const struct object_id *oid, - enum object_type required_type, - unsigned long *size, - struct object_id *oid_ret); - /* Compatibility wrappers, to be removed once Git 2.51 has been released. */ #include "repository.h" diff --git a/tree-walk.c b/tree-walk.c index 766af99f4668e4..e449a1320e55a6 100644 --- a/tree-walk.c +++ b/tree-walk.c @@ -90,7 +90,7 @@ void *fill_tree_descriptor(struct repository *r, void *buf = NULL; if (oid) { - buf = read_object_with_reference(r, oid, OBJ_TREE, &size, NULL); + buf = odb_read_object_peeled(r->objects, oid, OBJ_TREE, &size, NULL); if (!buf) die(_("unable to read tree (%s)"), oid_to_hex(oid)); } @@ -611,7 +611,7 @@ int get_tree_entry(struct repository *r, unsigned long size; struct object_id root; - tree = read_object_with_reference(r, tree_oid, OBJ_TREE, &size, &root); + tree = odb_read_object_peeled(r->objects, tree_oid, OBJ_TREE, &size, &root); if (!tree) return -1; @@ -681,10 +681,8 @@ enum get_oid_result get_tree_entry_follow_symlinks(struct repository *r, void *tree; struct object_id root; unsigned long size; - tree = read_object_with_reference(r, - ¤t_tree_oid, - OBJ_TREE, &size, - &root); + tree = odb_read_object_peeled(r->objects, ¤t_tree_oid, + OBJ_TREE, &size, &root); if (!tree) goto done; From 32571a0222eb85ef265e136f27e44c302302b45c Mon Sep 17 00:00:00 2001 From: Junio C Hamano Date: Tue, 15 Jul 2025 15:17:58 -0700 Subject: [PATCH 21/21] The tenth batch Signed-off-by: Junio C Hamano --- Documentation/RelNotes/2.51.0.adoc | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/Documentation/RelNotes/2.51.0.adoc b/Documentation/RelNotes/2.51.0.adoc index 4eb30d26a11201..ca0e39e1e82964 100644 --- a/Documentation/RelNotes/2.51.0.adoc +++ b/Documentation/RelNotes/2.51.0.adoc @@ -82,6 +82,8 @@ Performance, Internal Implementation, Development Support etc. * "make coccicheck" succeeds even when spatch made suggestions, which has been updated to fail in such a case. + * Code clean-up around object access API. + Fixes since v2.50 ----------------- @@ -161,6 +163,9 @@ including security updates, are included in this release. has been corrected. (merge 2b49d97fcb rp/apply-intent-to-add-fix later to maint). + * Leakfix with a new and a bit invasive test on pack-bitmap files. + (merge bfd5522e98 ly/load-bitmap-leakfix later to maint). + * Other code cleanup, docfix, build fix, etc. (merge b257adb571 lo/my-first-ow-doc-update later to maint). (merge 8b34b6a220 ly/sequencer-update-squash-is-fixup-only later to maint).