commit-graph: Create `git_commit_graph` as an abstraction for the file

This change does a medium-size refactor of the git_commit_graph_file and
the interaction with the ODB. Now instead of the ODB owning a direct
reference to the git_commit_graph_file, there will be an intermediate
git_commit_graph. The main advantage of that is that now end users can
explicitly set a git_commit_graph that is eagerly checked for errors,
while still being able to lazily use the commit-graph in a regular ODB,
if the file is present.

5 files changed, 249 insertions, 161 deletions

diff --git a/src/commit_graph.c b/src/commit_graph.c
index b301d3d49..6715d05dc 100644
--- a/src/commit_graph.c
+++ b/src/commit_graph.c
@@ -43,7 +43,7 @@ static int commit_graph_error(const char *message)
 }
 
 static int commit_graph_parse_oid_fanout(
-		git_commit_graph_file *cgraph,
+		git_commit_graph_file *file,
 		const unsigned char *data,
 		struct git_commit_graph_chunk *chunk_oid_fanout)
 {
@@ -55,20 +55,20 @@ static int commit_graph_parse_oid_fanout(
 	if (chunk_oid_fanout->length != 256 * 4)
 		return commit_graph_error("OID Fanout chunk has wrong length");
 
-	cgraph->oid_fanout = (const uint32_t *)(data + chunk_oid_fanout->offset);
+	file->oid_fanout = (const uint32_t *)(data + chunk_oid_fanout->offset);
 	nr = 0;
 	for (i = 0; i < 256; ++i) {
-		uint32_t n = ntohl(cgraph->oid_fanout[i]);
+		uint32_t n = ntohl(file->oid_fanout[i]);
 		if (n < nr)
 			return commit_graph_error("index is non-monotonic");
 		nr = n;
 	}
-	cgraph->num_commits = nr;
+	file->num_commits = nr;
 	return 0;
 }
 
 static int commit_graph_parse_oid_lookup(
-		git_commit_graph_file *cgraph,
+		git_commit_graph_file *file,
 		const unsigned char *data,
 		struct git_commit_graph_chunk *chunk_oid_lookup)
 {
@@ -79,12 +79,12 @@ static int commit_graph_parse_oid_lookup(
 		return commit_graph_error("missing OID Lookup chunk");
 	if (chunk_oid_lookup->length == 0)
 		return commit_graph_error("empty OID Lookup chunk");
-	if (chunk_oid_lookup->length != cgraph->num_commits * GIT_OID_RAWSZ)
+	if (chunk_oid_lookup->length != file->num_commits * GIT_OID_RAWSZ)
 		return commit_graph_error("OID Lookup chunk has wrong length");
 
-	cgraph->oid_lookup = oid = (git_oid *)(data + chunk_oid_lookup->offset);
+	file->oid_lookup = oid = (git_oid *)(data + chunk_oid_lookup->offset);
 	prev_oid = &zero_oid;
-	for (i = 0; i < cgraph->num_commits; ++i, ++oid) {
+	for (i = 0; i < file->num_commits; ++i, ++oid) {
 		if (git_oid_cmp(prev_oid, oid) >= 0)
 			return commit_graph_error("OID Lookup index is non-monotonic");
 		prev_oid = oid;
@@ -94,7 +94,7 @@ static int commit_graph_parse_oid_lookup(
 }
 
 static int commit_graph_parse_commit_data(
-		git_commit_graph_file *cgraph,
+		git_commit_graph_file *file,
 		const unsigned char *data,
 		struct git_commit_graph_chunk *chunk_commit_data)
 {
@@ -102,16 +102,16 @@ static int commit_graph_parse_commit_data(
 		return commit_graph_error("missing Commit Data chunk");
 	if (chunk_commit_data->length == 0)
 		return commit_graph_error("empty Commit Data chunk");
-	if (chunk_commit_data->length != cgraph->num_commits * (GIT_OID_RAWSZ + 16))
+	if (chunk_commit_data->length != file->num_commits * (GIT_OID_RAWSZ + 16))
 		return commit_graph_error("Commit Data chunk has wrong length");
 
-	cgraph->commit_data = data + chunk_commit_data->offset;
+	file->commit_data = data + chunk_commit_data->offset;
 
 	return 0;
 }
 
 static int commit_graph_parse_extra_edge_list(
-		git_commit_graph_file *cgraph,
+		git_commit_graph_file *file,
 		const unsigned char *data,
 		struct git_commit_graph_chunk *chunk_extra_edge_list)
 {
@@ -120,13 +120,16 @@ static int commit_graph_parse_extra_edge_list(
 	if (chunk_extra_edge_list->length % 4 != 0)
 		return commit_graph_error("malformed Extra Edge List chunk");
 
-	cgraph->extra_edge_list = data + chunk_extra_edge_list->offset;
-	cgraph->num_extra_edge_list = chunk_extra_edge_list->length / 4;
+	file->extra_edge_list = data + chunk_extra_edge_list->offset;
+	file->num_extra_edge_list = chunk_extra_edge_list->length / 4;
 
 	return 0;
 }
 
-int git_commit_graph_parse(git_commit_graph_file *cgraph, const unsigned char *data, size_t size)
+int git_commit_graph_file_parse(
+		git_commit_graph_file *file,
+		const unsigned char *data,
+		size_t size)
 {
 	struct git_commit_graph_header *hdr;
 	const unsigned char *chunk_hdr;
@@ -139,7 +142,7 @@ int git_commit_graph_parse(git_commit_graph_file *cgraph, const unsigned char *d
 				      chunk_commit_data = {0}, chunk_extra_edge_list = {0},
 				      chunk_unsupported = {0};
 
-	GIT_ASSERT_ARG(cgraph);
+	GIT_ASSERT_ARG(file);
 
 	if (size < sizeof(struct git_commit_graph_header) + GIT_OID_RAWSZ)
 		return commit_graph_error("commit-graph is too short");
@@ -161,11 +164,11 @@ int git_commit_graph_parse(git_commit_graph_file *cgraph, const unsigned char *d
 	trailer_offset = size - GIT_OID_RAWSZ;
 	if (trailer_offset < last_chunk_offset)
 		return commit_graph_error("wrong commit-graph size");
-	git_oid_cpy(&cgraph->checksum, (git_oid *)(data + trailer_offset));
+	git_oid_cpy(&file->checksum, (git_oid *)(data + trailer_offset));
 
 	if (git_hash_buf(&cgraph_checksum, data, (size_t)trailer_offset) < 0)
 		return commit_graph_error("could not calculate signature");
-	if (!git_oid_equal(&cgraph_checksum, &cgraph->checksum))
+	if (!git_oid_equal(&cgraph_checksum, &file->checksum))
 		return commit_graph_error("index signature mismatch");
 
 	chunk_hdr = data + sizeof(struct git_commit_graph_header);
@@ -214,25 +217,60 @@ int git_commit_graph_parse(git_commit_graph_file *cgraph, const unsigned char *d
 	}
 	last_chunk->length = (size_t)(trailer_offset - last_chunk_offset);
 
-	error = commit_graph_parse_oid_fanout(cgraph, data, &chunk_oid_fanout);
+	error = commit_graph_parse_oid_fanout(file, data, &chunk_oid_fanout);
 	if (error < 0)
 		return error;
-	error = commit_graph_parse_oid_lookup(cgraph, data, &chunk_oid_lookup);
+	error = commit_graph_parse_oid_lookup(file, data, &chunk_oid_lookup);
 	if (error < 0)
 		return error;
-	error = commit_graph_parse_commit_data(cgraph, data, &chunk_commit_data);
+	error = commit_graph_parse_commit_data(file, data, &chunk_commit_data);
 	if (error < 0)
 		return error;
-	error = commit_graph_parse_extra_edge_list(cgraph, data, &chunk_extra_edge_list);
+	error = commit_graph_parse_extra_edge_list(file, data, &chunk_extra_edge_list);
 	if (error < 0)
 		return error;
 
 	return 0;
 }
 
-int git_commit_graph_open(git_commit_graph_file **cgraph_out, const char *path)
+int git_commit_graph_new(git_commit_graph **cgraph_out, const char *objects_dir, bool open_file)
 {
-	git_commit_graph_file *cgraph;
+	git_commit_graph *cgraph = NULL;
+	int error = 0;
+
+	GIT_ASSERT_ARG(cgraph_out);
+	GIT_ASSERT_ARG(objects_dir);
+
+	cgraph = git__calloc(1, sizeof(git_commit_graph));
+	GIT_ERROR_CHECK_ALLOC(cgraph);
+
+	error = git_buf_joinpath(&cgraph->filename, objects_dir, "info/commit-graph");
+	if (error < 0)
+		goto error;
+
+	if (open_file) {
+		error = git_commit_graph_file_open(&cgraph->file, git_buf_cstr(&cgraph->filename));
+		if (error < 0)
+			goto error;
+		cgraph->checked = 1;
+	}
+
+	*cgraph_out = cgraph;
+	return 0;
+
+error:
+	git_commit_graph_free(cgraph);
+	return error;
+}
+
+int git_commit_graph_open(git_commit_graph **cgraph_out, const char *objects_dir)
+{
+	return git_commit_graph_new(cgraph_out, objects_dir, true);
+}
+
+int git_commit_graph_file_open(git_commit_graph_file **file_out, const char *path)
+{
+	git_commit_graph_file *file;
 	git_file fd = -1;
 	size_t cgraph_size;
 	struct stat st;
@@ -245,56 +283,92 @@ int git_commit_graph_open(git_commit_graph_file **cgraph_out, const char *path)
 
 	if (p_fstat(fd, &st) < 0) {
 		p_close(fd);
-		git_error_set(GIT_ERROR_ODB, "multi-pack-index file not found - '%s'", path);
-		return -1;
+		git_error_set(GIT_ERROR_ODB, "commit-graph file not found - '%s'", path);
+		return GIT_ENOTFOUND;
 	}
 
 	if (!S_ISREG(st.st_mode) || !git__is_sizet(st.st_size)) {
 		p_close(fd);
 		git_error_set(GIT_ERROR_ODB, "invalid pack index '%s'", path);
-		return -1;
+		return GIT_ENOTFOUND;
 	}
 	cgraph_size = (size_t)st.st_size;
 
-	cgraph = git__calloc(1, sizeof(git_commit_graph_file));
-	GIT_ERROR_CHECK_ALLOC(cgraph);
-
-	error = git_buf_sets(&cgraph->filename, path);
-	if (error < 0)
-		return error;
+	file = git__calloc(1, sizeof(git_commit_graph_file));
+	GIT_ERROR_CHECK_ALLOC(file);
 
-	error = git_futils_mmap_ro(&cgraph->graph_map, fd, 0, cgraph_size);
+	error = git_futils_mmap_ro(&file->graph_map, fd, 0, cgraph_size);
 	p_close(fd);
 	if (error < 0) {
-		git_commit_graph_free(cgraph);
+		git_commit_graph_file_free(file);
 		return error;
 	}
 
-	if ((error = git_commit_graph_parse(cgraph, cgraph->graph_map.data, cgraph_size)) < 0) {
-		git_commit_graph_free(cgraph);
+	if ((error = git_commit_graph_file_parse(file, file->graph_map.data, cgraph_size)) < 0) {
+		git_commit_graph_file_free(file);
 		return error;
 	}
 
-	*cgraph_out = cgraph;
+	*file_out = file;
 	return 0;
 }
 
+int git_commit_graph_get_file(git_commit_graph_file **file_out, git_commit_graph *cgraph)
+{
+	if (!cgraph->checked) {
+		int error = 0;
+		git_commit_graph_file *result = NULL;
+
+		/* We only check once, no matter the result. */
+		cgraph->checked = 1;
+
+		/* Best effort */
+		error = git_commit_graph_file_open(&result, git_buf_cstr(&cgraph->filename));
+
+		if (error < 0)
+			return error;
+
+		cgraph->file = result;
+	}
+	if (!cgraph->file)
+		return GIT_ENOTFOUND;
+
+	*file_out = cgraph->file;
+	return 0;
+}
+
+void git_commit_graph_refresh(git_commit_graph *cgraph)
+{
+	if (!cgraph->checked)
+		return;
+
+	if (cgraph->file
+	    && git_commit_graph_file_needs_refresh(cgraph->file, git_buf_cstr(&cgraph->filename))) {
+		/* We just free the commit graph. The next time it is requested, it will be
+		 * re-loaded. */
+		git_commit_graph_file_free(cgraph->file);
+		cgraph->file = NULL;
+	}
+	/* Force a lazy re-check next time it is needed. */
+	cgraph->checked = 0;
+}
+
 static int git_commit_graph_entry_get_byindex(
 		git_commit_graph_entry *e,
-		const git_commit_graph_file *cgraph,
+		const git_commit_graph_file *file,
 		size_t pos)
 {
 	const unsigned char *commit_data;
 
 	GIT_ASSERT_ARG(e);
-	GIT_ASSERT_ARG(cgraph);
+	GIT_ASSERT_ARG(file);
 
-	if (pos >= cgraph->num_commits) {
+	if (pos >= file->num_commits) {
 		git_error_set(GIT_ERROR_INVALID, "commit index %zu does not exist", pos);
 		return GIT_ENOTFOUND;
 	}
 
-	commit_data = cgraph->commit_data + pos * (GIT_OID_RAWSZ + 4 * sizeof(uint32_t));
+	commit_data = file->commit_data + pos * (GIT_OID_RAWSZ + 4 * sizeof(uint32_t));
 	git_oid_cpy(&e->tree_oid, (const git_oid *)commit_data);
 	e->parent_indices[0] = ntohl(*((uint32_t *)(commit_data + GIT_OID_RAWSZ)));
 	e->parent_indices[1]
@@ -310,7 +384,7 @@ static int git_commit_graph_entry_get_byindex(
 		uint32_t extra_edge_list_pos = e->parent_indices[1] & 0x7fffffff;
 
 		/* Make sure we're not being sent out of bounds */
-		if (extra_edge_list_pos >= cgraph->num_extra_edge_list) {
+		if (extra_edge_list_pos >= file->num_extra_edge_list) {
 			git_error_set(GIT_ERROR_INVALID,
 				      "commit %u does not exist",
 				      extra_edge_list_pos);
@@ -318,9 +392,9 @@ static int git_commit_graph_entry_get_byindex(
 		}
 
 		e->extra_parents_index = extra_edge_list_pos;
-		while (extra_edge_list_pos < cgraph->num_extra_edge_list
+		while (extra_edge_list_pos < file->num_extra_edge_list
 		       && (ntohl(*(
-					   (uint32_t *)(cgraph->extra_edge_list
+					   (uint32_t *)(file->extra_edge_list
 							+ extra_edge_list_pos * sizeof(uint32_t))))
 			   & 0x80000000u)
 				       == 0) {
@@ -329,20 +403,17 @@ static int git_commit_graph_entry_get_byindex(
 		}
 
 	}
-	git_oid_cpy(&e->sha1, &cgraph->oid_lookup[pos]);
+	git_oid_cpy(&e->sha1, &file->oid_lookup[pos]);
 	return 0;
 }
 
-bool git_commit_graph_needs_refresh(const git_commit_graph_file *cgraph, const char *path)
+bool git_commit_graph_file_needs_refresh(const git_commit_graph_file *file, const char *path)
 {
 	git_file fd = -1;
 	struct stat st;
 	ssize_t bytes_read;
 	git_oid cgraph_checksum = {{0}};
 
-	if (path == NULL)
-		path = git_buf_cstr(&cgraph->filename);
-
 	/* TODO: properly open the file without access time using O_NOATIME */
 	fd = git_futils_open_ro(path);
 	if (fd < 0)
@@ -354,7 +425,7 @@ bool git_commit_graph_needs_refresh(const git_commit_graph_file *cgraph, const c
 	}
 
 	if (!S_ISREG(st.st_mode) || !git__is_sizet(st.st_size)
-	    || (size_t)st.st_size != cgraph->graph_map.len) {
+	    || (size_t)st.st_size != file->graph_map.len) {
 		p_close(fd);
 		return true;
 	}
@@ -364,12 +435,12 @@ bool git_commit_graph_needs_refresh(const git_commit_graph_file *cgraph, const c
 	if (bytes_read != GIT_OID_RAWSZ)
 		return true;
 
-	return !git_oid_equal(&cgraph_checksum, &cgraph->checksum);
+	return !git_oid_equal(&cgraph_checksum, &file->checksum);
 }
 
 int git_commit_graph_entry_find(
 		git_commit_graph_entry *e,
-		const git_commit_graph_file *cgraph,
+		const git_commit_graph_file *file,
 		const git_oid *short_oid,
 		size_t len)
 {
@@ -378,31 +449,31 @@ int git_commit_graph_entry_find(
 	const git_oid *current = NULL;
 
 	GIT_ASSERT_ARG(e);
-	GIT_ASSERT_ARG(cgraph);
+	GIT_ASSERT_ARG(file);
 	GIT_ASSERT_ARG(short_oid);
 
-	hi = ntohl(cgraph->oid_fanout[(int)short_oid->id[0]]);
-	lo = ((short_oid->id[0] == 0x0) ? 0 : ntohl(cgraph->oid_fanout[(int)short_oid->id[0] - 1]));
+	hi = ntohl(file->oid_fanout[(int)short_oid->id[0]]);
+	lo = ((short_oid->id[0] == 0x0) ? 0 : ntohl(file->oid_fanout[(int)short_oid->id[0] - 1]));
 
-	pos = git_pack__lookup_sha1(cgraph->oid_lookup, GIT_OID_RAWSZ, lo, hi, short_oid->id);
+	pos = git_pack__lookup_sha1(file->oid_lookup, GIT_OID_RAWSZ, lo, hi, short_oid->id);
 
 	if (pos >= 0) {
 		/* An object matching exactly the oid was found */
 		found = 1;
-		current = cgraph->oid_lookup + pos;
+		current = file->oid_lookup + pos;
 	} else {
 		/* No object was found */
 		/* pos refers to the object with the "closest" oid to short_oid */
 		pos = -1 - pos;
-		if (pos < (int)cgraph->num_commits) {
-			current = cgraph->oid_lookup + pos;
+		if (pos < (int)file->num_commits) {
+			current = file->oid_lookup + pos;
 
 			if (!git_oid_ncmp(short_oid, current, len))
 				found = 1;
 		}
 	}
 
-	if (found && len != GIT_OID_HEXSZ && pos + 1 < (int)cgraph->num_commits) {
+	if (found && len != GIT_OID_HEXSZ && pos + 1 < (int)file->num_commits) {
 		/* Check for ambiguousity */
 		const git_oid *next = current + 1;
 
@@ -413,22 +484,22 @@ int git_commit_graph_entry_find(
 
 	if (!found)
 		return git_odb__error_notfound(
-				"failed to find offset for multi-pack index entry", short_oid, len);
+				"failed to find offset for commit-graph index entry", short_oid, len);
 	if (found > 1)
 		return git_odb__error_ambiguous(
-				"found multiple offsets for multi-pack index entry");
+				"found multiple offsets for commit-graph index entry");
 
-	return git_commit_graph_entry_get_byindex(e, cgraph, pos);
+	return git_commit_graph_entry_get_byindex(e, file, pos);
 }
 
 int git_commit_graph_entry_parent(
 		git_commit_graph_entry *parent,
-		const git_commit_graph_file *cgraph,
+		const git_commit_graph_file *file,
 		const git_commit_graph_entry *entry,
 		size_t n)
 {
 	GIT_ASSERT_ARG(parent);
-	GIT_ASSERT_ARG(cgraph);
+	GIT_ASSERT_ARG(file);
 
 	if (n >= entry->parent_count) {
 		git_error_set(GIT_ERROR_INVALID, "parent index %zu does not exist", n);
@@ -436,35 +507,43 @@ int git_commit_graph_entry_parent(
 	}
 
 	if (n == 0 || (n == 1 && entry->parent_count == 2))
-		return git_commit_graph_entry_get_byindex(parent, cgraph, entry->parent_indices[n]);
+		return git_commit_graph_entry_get_byindex(parent, file, entry->parent_indices[n]);
 
 	return git_commit_graph_entry_get_byindex(
 			parent,
-			cgraph,
+			file,
 			ntohl(
-					*(uint32_t *)(cgraph->extra_edge_list
+					*(uint32_t *)(file->extra_edge_list
 						      + (entry->extra_parents_index + n - 1)
 								      * sizeof(uint32_t)))
 					& 0x7fffffff);
 }
 
-
-int git_commit_graph_close(git_commit_graph_file *cgraph)
+int git_commit_graph_file_close(git_commit_graph_file *file)
 {
-	GIT_ASSERT_ARG(cgraph);
+	GIT_ASSERT_ARG(file);
 
-	if (cgraph->graph_map.data)
-		git_futils_mmap_free(&cgraph->graph_map);
+	if (file->graph_map.data)
+		git_futils_mmap_free(&file->graph_map);
 
 	return 0;
 }
 
-void git_commit_graph_free(git_commit_graph_file *cgraph)
+void git_commit_graph_free(git_commit_graph *cgraph)
 {
 	if (!cgraph)
 		return;
 
 	git_buf_dispose(&cgraph->filename);
-	git_commit_graph_close(cgraph);
+	git_commit_graph_file_free(cgraph->file);
 	git__free(cgraph);
 }
+
+void git_commit_graph_file_free(git_commit_graph_file *file)
+{
+	if (!file)
+		return;
+
+	git_commit_graph_file_close(file);
+	git__free(file);
+}
diff --git a/src/commit_graph.h b/src/commit_graph.h
index f21a03769..e5e3ea1fd 100644
--- a/src/commit_graph.h
+++ b/src/commit_graph.h
@@ -10,6 +10,9 @@
 
 #include "common.h"
 
+#include "git2/types.h"
+#include "git2/sys/commit_graph.h"
+
 #include "map.h"
 
 /**
@@ -52,9 +55,6 @@ typedef struct git_commit_graph_file {
 
 	/* The trailer of the file. Contains the SHA1-checksum of the whole file. */
 	git_oid checksum;
-
-	/* something like ".git/objects/info/commit-graph". */
-	git_buf filename;
 } git_commit_graph_file;
 
 /**
@@ -88,29 +88,60 @@ typedef struct git_commit_graph_entry {
 	git_oid sha1;
 } git_commit_graph_entry;
 
-int git_commit_graph_open(git_commit_graph_file **cgraph_out, const char *path);
+/* A wrapper for git_commit_graph_file to enable lazy loading in the ODB. */
+struct git_commit_graph {
+	/* The path to the commit-graph file. Something like ".git/objects/info/commit-graph". */
+	git_buf filename;
+
+	/* The underlying commit-graph file. */
+	git_commit_graph_file *file;
+
+	/* Whether the commit-graph file was already checked for validity. */
+	bool checked;
+};
+
+/** Create a new commit-graph, optionally opening the underlying file. */
+int git_commit_graph_new(git_commit_graph **cgraph_out, const char *objects_dir, bool open_file);
+
+/** Open and validate a commit-graph file. */
+int git_commit_graph_file_open(git_commit_graph_file **file_out, const char *path);
+
+/*
+ * Attempt to get the git_commit_graph's commit-graph file. This object is
+ * still owned by the git_commit_graph. If the repository does not contain a commit graph,
+ * it will return GIT_ENOTFOUND.
+ *
+ * This function is not thread-safe.
+ */
+int git_commit_graph_get_file(git_commit_graph_file **file_out, git_commit_graph *cgraph);
+
+/* Marks the commit-graph file as needing a refresh. */
+void git_commit_graph_refresh(git_commit_graph *cgraph);
 
 /*
- * Returns whether the commit_graph_file needs to be reloaded since the
- * contents of the commit-graph file have changed on disk. If `path` is NULL,
- * the filename stored in `cgraph` will be used.
+ * Returns whether the git_commit_graph_file needs to be reloaded since the
+ * contents of the commit-graph file have changed on disk.
  */
-bool git_commit_graph_needs_refresh(const git_commit_graph_file *cgraph, const char *path);
+bool git_commit_graph_file_needs_refresh(
+		const git_commit_graph_file *file, const char *path);
 
 int git_commit_graph_entry_find(
 		git_commit_graph_entry *e,
-		const git_commit_graph_file *cgraph,
+		const git_commit_graph_file *file,
 		const git_oid *short_oid,
 		size_t len);
 int git_commit_graph_entry_parent(
 		git_commit_graph_entry *parent,
-		const git_commit_graph_file *cgraph,
+		const git_commit_graph_file *file,
 		const git_commit_graph_entry *entry,
 		size_t n);
-int git_commit_graph_close(git_commit_graph_file *cgraph);
-void git_commit_graph_free(git_commit_graph_file *cgraph);
+int git_commit_graph_file_close(git_commit_graph_file *cgraph);
+void git_commit_graph_file_free(git_commit_graph_file *cgraph);
 
 /* This is exposed for use in the fuzzers. */
-int git_commit_graph_parse(git_commit_graph_file *cgraph, const unsigned char *data, size_t size);
+int git_commit_graph_file_parse(
+		git_commit_graph_file *file,
+		const unsigned char *data,
+		size_t size);
 
 #endif
diff --git a/src/commit_list.c b/src/commit_list.c
index dfdd5daab..11cc2e7d2 100644
--- a/src/commit_list.c
+++ b/src/commit_list.c
@@ -144,18 +144,18 @@ static int commit_quick_parse(
 int git_commit_list_parse(git_revwalk *walk, git_commit_list_node *commit)
 {
 	git_odb_object *obj;
-	git_commit_graph_file *cgraph = NULL;
+	git_commit_graph_file *cgraph_file = NULL;
 	int error;
 
 	if (commit->parsed)
 		return 0;
 
 	/* Let's try to use the commit graph first. */
-	git_odb__get_commit_graph(&cgraph, walk->odb);
-	if (cgraph) {
+	git_odb__get_commit_graph_file(&cgraph_file, walk->odb);
+	if (cgraph_file) {
 		git_commit_graph_entry e;
 
-		error = git_commit_graph_entry_find(&e, cgraph, &commit->oid, GIT_OID_RAWSZ);
+		error = git_commit_graph_entry_find(&e, cgraph_file, &commit->oid, GIT_OID_RAWSZ);
 		if (error == 0 && git__is_uint16(e.parent_count)) {
 			size_t i;
 			commit->generation = (uint32_t)e.generation;
@@ -166,7 +166,7 @@ int git_commit_list_parse(git_revwalk *walk, git_commit_list_node *commit)
 
 			for (i = 0; i < commit->out_degree; ++i) {
 				git_commit_graph_entry parent;
-				error = git_commit_graph_entry_parent(&parent, cgraph, &e, i);
+				error = git_commit_graph_entry_parent(&parent, cgraph_file, &e, i);
 				if (error < 0)
 					return error;
 				commit->parents[i] = git_revwalk__commit_lookup(walk, &parent.sha1);
diff --git a/src/odb.c b/src/odb.c
index 02f97915d..40504ca15 100644
--- a/src/odb.c
+++ b/src/odb.c
@@ -465,13 +465,6 @@ int git_odb_new(git_odb **out)
 		git__free(db);
 		return -1;
 	}
-	if (git_buf_init(&db->objects_dir, 0) < 0) {
-		git_vector_free(&db->backends);
-		git_cache_dispose(&db->own_cache);
-		git_mutex_free(&db->lock);
-		git__free(db);
-		return -1;
-	}
 
 	*out = db;
 	GIT_REFCOUNT_INC(db);
@@ -619,17 +612,6 @@ int git_odb__add_default_backends(
 	git_mutex_unlock(&db->lock);
 #endif
 
-	if (git_mutex_lock(&db->lock) < 0) {
-		git_error_set(GIT_ERROR_ODB, "failed to acquire the odb lock");
-		return -1;
-	}
-	if (git_buf_len(&db->objects_dir) == 0 && git_buf_sets(&db->objects_dir, objects_dir) < 0) {
-		git_mutex_unlock(&db->lock);
-		git_odb_free(db);
-		return -1;
-	}
-	git_mutex_unlock(&db->lock);
-
 	/* add the loose object backend */
 	if (git_odb_backend_loose(&loose, objects_dir, -1, db->do_fsync, 0, 0) < 0 ||
 		add_backend_internal(db, loose, GIT_LOOSE_PRIORITY, as_alternates, inode) < 0)
@@ -640,6 +622,16 @@ int git_odb__add_default_backends(
 		add_backend_internal(db, packed, GIT_PACKED_PRIORITY, as_alternates, inode) < 0)
 		return -1;
 
+	if (git_mutex_lock(&db->lock) < 0) {
+		git_error_set(GIT_ERROR_ODB, "failed to acquire the odb lock");
+		return -1;
+	}
+	if (!db->cgraph && git_commit_graph_new(&db->cgraph, objects_dir, false) < 0) {
+		git_mutex_unlock(&db->lock);
+		return -1;
+	}
+	git_mutex_unlock(&db->lock);
+
 	return load_alternates(db, objects_dir, alternate_depth);
 }
 
@@ -701,6 +693,23 @@ int git_odb_add_disk_alternate(git_odb *odb, const char *path)
 	return git_odb__add_default_backends(odb, path, true, 0);
 }
 
+int git_odb_set_commit_graph(git_odb *odb, git_commit_graph *cgraph)
+{
+	int error = 0;
+
+	GIT_ASSERT_ARG(odb);
+
+	if ((error = git_mutex_lock(&odb->lock)) < 0) {
+		git_error_set(GIT_ERROR_ODB, "failed to acquire the db lock");
+		return error;
+	}
+	git_commit_graph_free(odb->cgraph);
+	odb->cgraph = cgraph;
+	git_mutex_unlock(&odb->lock);
+
+	return error;
+}
+
 int git_odb_open(git_odb **out, const char *objects_dir)
 {
 	git_odb *db;
@@ -760,7 +769,6 @@ static void odb_free(git_odb *db)
 	if (locked)
 		git_mutex_unlock(&db->lock);
 
-	git_buf_dispose(&db->objects_dir);
 	git_commit_graph_free(db->cgraph);
 	git_vector_free(&db->backends);
 	git_cache_dispose(&db->own_cache);
@@ -806,51 +814,27 @@ static int odb_exists_1(
 	return (int)found;
 }
 
-int git_odb__get_commit_graph(git_commit_graph_file **out, git_odb *db)
+int git_odb__get_commit_graph_file(git_commit_graph_file **out, git_odb *db)
 {
 	int error = 0;
+	git_commit_graph_file *result = NULL;
 
 	if ((error = git_mutex_lock(&db->lock)) < 0) {
 		git_error_set(GIT_ERROR_ODB, "failed to acquire the db lock");
 		return error;
 	}
-	if (!db->cgraph_checked) {
-		git_buf commit_graph_path = GIT_BUF_INIT;
-		git_commit_graph_file *cgraph = NULL;
-
-		/* We only check once, no matter the result. */
-		db->cgraph_checked = 1;
-
-		if (git_buf_len(&db->objects_dir) == 0) {
-			/*
-			 * This odb was not opened with an objects directory
-			 * associated. Skip opening the commit graph.
-			 */
-			goto done;
-		}
-
-		if ((error = git_buf_joinpath(
-				     &commit_graph_path,
-				     git_buf_cstr(&db->objects_dir),
-				     "info/commit-graph"))
-		    < 0) {
-			git_buf_dispose(&commit_graph_path);
-			goto done;
-		}
-		/* Best effort */
-		error = git_commit_graph_open(&cgraph, git_buf_cstr(&commit_graph_path));
-		git_buf_dispose(&commit_graph_path);
-
-		if (error < 0)
-			goto done;
-
-		db->cgraph = cgraph;
+	if (!db->cgraph) {
+		error = GIT_ENOTFOUND;
+		goto done;
 	}
+	error = git_commit_graph_get_file(&result, db->cgraph);
+	if (error)
+		goto done;
+	*out = result;
 
 done:
-	*out = db->cgraph;
 	git_mutex_unlock(&db->lock);
-	return 0;
+	return error;
 }
 
 static int odb_freshen_1(
@@ -1762,13 +1746,8 @@ int git_odb_refresh(struct git_odb *db)
 			}
 		}
 	}
-	if (db->cgraph && git_commit_graph_needs_refresh(db->cgraph, NULL)) {
-		/* We just free the commit graph. The next time it is requested, it will be re-loaded. */
-		git_commit_graph_free(db->cgraph);
-		db->cgraph = NULL;
-	}
-	/* Force a lazy re-check next time it is needed. */
-	db->cgraph_checked = 0;
+	if (db->cgraph)
+		git_commit_graph_refresh(db->cgraph);
 	git_mutex_unlock(&db->lock);
 
 	return 0;
diff --git a/src/odb.h b/src/odb.h
index dcf29c2e2..5bebb6edc 100644
--- a/src/odb.h
+++ b/src/odb.h
@@ -12,6 +12,7 @@
 #include "git2/odb.h"
 #include "git2/oid.h"
 #include "git2/types.h"
+#include "git2/sys/commit_graph.h"
 
 #include "cache.h"
 #include "commit_graph.h"
@@ -44,10 +45,8 @@ struct git_odb {
 	git_mutex lock;  /* protects backends */
 	git_vector backends;
 	git_cache own_cache;
-	git_buf objects_dir;
-	git_commit_graph_file *cgraph;
+	git_commit_graph *cgraph;
 	unsigned int do_fsync :1;
-	unsigned int cgraph_checked :1;
 };
 
 typedef enum {
@@ -132,11 +131,11 @@ int git_odb__read_header_or_object(
 	git_odb *db, const git_oid *id);
 
 /*
- * Attempt to get the ODB's commit graph. This object is still owned by the
- * ODB. If the repository does not contain a commit graph, it will return zero
- * and `*out` will be set to NULL.
+ * Attempt to get the ODB's commit-graph file. This object is still owned by
+ * the ODB. If the repository does not contain a commit-graph, it will return
+ * GIT_ENOTFOUND.
  */
-int git_odb__get_commit_graph(git_commit_graph_file **out, git_odb *odb);
+int git_odb__get_commit_graph_file(git_commit_graph_file **out, git_odb *odb);
 
 /* freshen an entry in the object database */
 int git_odb__freshen(git_odb *db, const git_oid *id);