@@ -277,7 +277,7 @@ 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(buf.buf, buf.len, OBJ_BLOB, &origin->blob_oid);
+ pretend_object_file(the_repository, buf.buf, buf.len, OBJ_BLOB, &origin->blob_oid);
/*
* Read the current index, replace the path entry with
@@ -151,6 +151,8 @@ static inline int pack_map_entry_cmp(const void *cmp_data UNUSED,
return strcmp(pg1->pack_name, key ? key : pg2->pack_name);
}
+struct cached_object_entry;
+
struct raw_object_store {
/*
* Set of all object directories; the main directory is first (and
@@ -203,6 +205,15 @@ struct raw_object_store {
unsigned flags;
} kept_pack_cache;
+ /*
+ * 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
+ * to write them into the object store (e.g. a browse-only
+ * application).
+ */
+ struct cached_object_entry *cached_objects;
+ size_t cached_object_nr, cached_object_alloc;
+
/*
* A map of packfiles to packed_git structs for tracking which
* packs have been loaded already.
@@ -272,7 +283,8 @@ void hash_object_file(const struct git_hash_algo *algo, const void *buf,
* object in persistent storage before writing any other new objects
* that reference it.
*/
-int pretend_object_file(void *, unsigned long, enum object_type,
+int pretend_object_file(struct repository *repo,
+ void *buf, unsigned long len, enum object_type type,
struct object_id *oid);
struct object_info {
@@ -30,31 +30,31 @@
* to write them into the object store (e.g. a browse-only
* application).
*/
-static struct cached_object_entry {
+struct cached_object_entry {
struct object_id oid;
struct cached_object {
enum object_type type;
const void *buf;
unsigned long size;
} value;
-} *cached_objects;
-static int cached_object_nr, cached_object_alloc;
+};
-static const struct cached_object *find_cached_object(const struct object_id *oid)
+static const struct cached_object *find_cached_object(struct raw_object_store *object_store,
+ const struct object_id *oid)
{
static const struct cached_object empty_tree = {
.type = OBJ_TREE,
.buf = "",
};
- int i;
- const struct cached_object_entry *co = cached_objects;
+ const struct cached_object_entry *co = object_store->cached_objects;
- for (i = 0; i < cached_object_nr; i++, co++) {
+ for (size_t i = 0; i < object_store->cached_object_nr; i++, co++)
if (oideq(&co->oid, oid))
return &co->value;
- }
- if (oideq(oid, the_hash_algo->empty_tree))
+
+ if (oid->algo && oideq(oid, hash_algos[oid->algo].empty_tree))
return &empty_tree;
+
return NULL;
}
@@ -650,7 +650,7 @@ static int do_oid_object_info_extended(struct repository *r,
if (!oi)
oi = &blank_oi;
- co = find_cached_object(real);
+ co = find_cached_object(r->objects, real);
if (co) {
if (oi->typep)
*(oi->typep) = co->type;
@@ -853,18 +853,21 @@ int oid_object_info(struct repository *r,
return type;
}
-int pretend_object_file(void *buf, unsigned long len, enum object_type type,
+int pretend_object_file(struct repository *repo,
+ void *buf, unsigned long len, enum object_type type,
struct object_id *oid)
{
struct cached_object_entry *co;
char *co_buf;
- hash_object_file(the_hash_algo, buf, len, type, oid);
- if (repo_has_object_file_with_flags(the_repository, oid, OBJECT_INFO_QUICK | OBJECT_INFO_SKIP_FETCH_OBJECT) ||
- find_cached_object(oid))
+ hash_object_file(repo->hash_algo, buf, len, type, oid);
+ if (repo_has_object_file_with_flags(repo, oid, OBJECT_INFO_QUICK | OBJECT_INFO_SKIP_FETCH_OBJECT) ||
+ find_cached_object(repo->objects, oid))
return 0;
- ALLOC_GROW(cached_objects, cached_object_nr + 1, cached_object_alloc);
- co = &cached_objects[cached_object_nr++];
+
+ 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++];
co->value.size = len;
co->value.type = type;
co_buf = xmalloc(len);
@@ -1021,6 +1024,10 @@ void raw_object_store_clear(struct raw_object_store *o)
o->odb_tail = NULL;
o->loaded_alternates = 0;
+ for (size_t i = 0; i < o->cached_object_nr; i++)
+ free((char *) o->cached_objects[i].value.buf);
+ FREE_AND_NULL(o->cached_objects);
+
INIT_LIST_HEAD(&o->packed_git_mru);
close_object_store(o);
Cached objects are virtual objects that can be set up without writing anything into the object store directly, which is used by git-blame(1) to create fake commits for the working tree. These cached objects are stored in a global variable, which is another roadblock for libification of the object subsystem. Refactor the code so that we instead store the array as part of the raw object store. This refactoring raises the question whether virtual objects should really be specific to a single repository (or rather a single object store). Hypothetical usecases might for example span across submodules, and here it may or may not be the right thing to provide virtual objects across submodule boundaries. The only existing usecase is git-blame(1) though, which does not know to blame across submodule boundaries in the first place. As such, storing these objects both globally and per-repository would achieve the same result right now. But arguably, if we learned to blame across submodule boundaries, we would likely want to create separate fare working tree commits for each of the submodules so that the user can learn which worktree a specific uncommitted change belongs to. And even if we would want to create the same fake commit for each of the submodules we could do that when storing separate virtual objects per object store. While this is all rather hypothetical, the takeaway is that handling virtual objects per-object store gives us more flexibility compared to storing them globally. In a hypothetical future where we have achieved full libification one might be able to handle unrelated repositories in a single process, where the state of one repository should not have an impact on the state of another repository. As such, storing these cached objects per object store will enable more usecases and should lead to less surprising outcomes overall. Signed-off-by: Patrick Steinhardt <ps@pks.im> --- blame.c | 2 +- object-store-ll.h | 14 +++++++++++++- object-store.c | 39 +++++++++++++++++++++++---------------- 3 files changed, 37 insertions(+), 18 deletions(-)