admin/git
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'ps/commit-graph-wo-globals'

Browse Source 
Remove dependency on the_repository and other globals from the
commit-graph code, and other changes unrelated to de-globaling.

* ps/commit-graph-wo-globals:
  commit-graph: stop passing in redundant repository
  commit-graph: stop using `the_repository`
  commit-graph: stop using `the_hash_algo`
  commit-graph: refactor `parse_commit_graph()` to take a repository
  commit-graph: store the hash algorithm instead of its length
  commit-graph: stop using `the_hash_algo` via macros
This commit is contained in:
Junio C Hamano
2025-08-25 14:22:03 -07:00
parent 4f58f6d617 7be9e410b2
commit eed447dd95
7 changed files with 157 additions and 168 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
builtin/commit-graph.c
View File

@@ -109,7 +109,8 @@ static int graph_verify(int argc, const char **argv, const char *prefix,
opened = OPENED_GRAPH; opened = OPENED_GRAPH;
else if (errno != ENOENT) else if (errno != ENOENT)
die_errno(_("Could not open commit-graph '%s'"), graph_name); die_errno(_("Could not open commit-graph '%s'"), graph_name);
else if (open_commit_graph_chain(chain_name, &fd, &st)) else if (open_commit_graph_chain(chain_name, &fd, &st,
the_repository->hash_algo))
opened = OPENED_CHAIN; opened = OPENED_CHAIN;
else if (errno != ENOENT) else if (errno != ENOENT)
die_errno(_("could not open commit-graph chain '%s'"), chain_name); die_errno(_("could not open commit-graph chain '%s'"), chain_name);
@@ -121,15 +122,15 @@ static int graph_verify(int argc, const char **argv, const char *prefix,
if (opened == OPENED_NONE) if (opened == OPENED_NONE)
return 0; return 0;
else if (opened == OPENED_GRAPH) else if (opened == OPENED_GRAPH)
graph = load_commit_graph_one_fd_st(the_repository, fd, &st, source); graph = load_commit_graph_one_fd_st(source, fd, &st);
else else
graph = load_commit_graph_chain_fd_st(the_repository, fd, &st, graph = load_commit_graph_chain_fd_st(the_repository->objects, fd, &st,
&incomplete_chain); &incomplete_chain);
if (!graph) if (!graph)
return 1; return 1;
ret = verify_commit_graph(the_repository, graph, flags); ret = verify_commit_graph(graph, flags);
free_commit_graph(graph); free_commit_graph(graph);
if (incomplete_chain) { if (incomplete_chain) {

2
builtin/commit.c
View File

@@ -1947,7 +1947,7 @@ int cmd_commit(int argc,
"new index file. Check that disk is not full and quota is\n" "new index file. Check that disk is not full and quota is\n"
"not exceeded, and then \"git restore --staged :/\" to recover.")); "not exceeded, and then \"git restore --staged :/\" to recover."));
git_test_write_commit_graph_or_die(); git_test_write_commit_graph_or_die(the_repository->objects->sources);
repo_rerere(the_repository, 0); repo_rerere(the_repository, 0);
run_auto_maintenance(quiet); run_auto_maintenance(quiet);

2
builtin/merge.c
View File

@@ -1863,7 +1863,7 @@ int cmd_merge(int argc,
if (squash) { if (squash) {
finish(head_commit, remoteheads, NULL, NULL); finish(head_commit, remoteheads, NULL, NULL);
git_test_write_commit_graph_or_die(); git_test_write_commit_graph_or_die(the_repository->objects->sources);
} else } else
write_merge_state(remoteheads); write_merge_state(remoteheads);

283
commit-graph.c
View File

@@ -1,4 +1,3 @@
#define USE_THE_REPOSITORY_VARIABLE
#define DISABLE_SIGN_COMPARE_WARNINGS #define DISABLE_SIGN_COMPARE_WARNINGS
#include "git-compat-util.h" #include "git-compat-util.h"
@@ -29,7 +28,7 @@
#include "tree.h" #include "tree.h"
#include "chunk-format.h" #include "chunk-format.h"
void git_test_write_commit_graph_or_die(void) void git_test_write_commit_graph_or_die(struct odb_source *source)
{ {
int flags = 0; int flags = 0;
if (!git_env_bool(GIT_TEST_COMMIT_GRAPH, 0)) if (!git_env_bool(GIT_TEST_COMMIT_GRAPH, 0))
@@ -38,8 +37,7 @@ void git_test_write_commit_graph_or_die(void)
if (git_env_bool(GIT_TEST_COMMIT_GRAPH_CHANGED_PATHS, 0)) if (git_env_bool(GIT_TEST_COMMIT_GRAPH_CHANGED_PATHS, 0))
flags = COMMIT_GRAPH_WRITE_BLOOM_FILTERS; flags = COMMIT_GRAPH_WRITE_BLOOM_FILTERS;
if (write_commit_graph_reachable(the_repository->objects->sources, if (write_commit_graph_reachable(source, flags, NULL))
flags, NULL))
die("failed to write commit-graph under GIT_TEST_COMMIT_GRAPH"); die("failed to write commit-graph under GIT_TEST_COMMIT_GRAPH");
} }
@@ -54,8 +52,6 @@ void git_test_write_commit_graph_or_die(void)
#define GRAPH_CHUNKID_BLOOMDATA 0x42444154 /* "BDAT" */ #define GRAPH_CHUNKID_BLOOMDATA 0x42444154 /* "BDAT" */
#define GRAPH_CHUNKID_BASE 0x42415345 /* "BASE" */ #define GRAPH_CHUNKID_BASE 0x42415345 /* "BASE" */
#define GRAPH_DATA_WIDTH (the_hash_algo->rawsz + 16)
#define GRAPH_VERSION_1 0x1 #define GRAPH_VERSION_1 0x1
#define GRAPH_VERSION GRAPH_VERSION_1 #define GRAPH_VERSION GRAPH_VERSION_1
@@ -67,8 +63,6 @@ void git_test_write_commit_graph_or_die(void)
#define GRAPH_HEADER_SIZE 8 #define GRAPH_HEADER_SIZE 8
#define GRAPH_FANOUT_SIZE (4 * 256) #define GRAPH_FANOUT_SIZE (4 * 256)
#define GRAPH_MIN_SIZE (GRAPH_HEADER_SIZE + 4 * CHUNK_TOC_ENTRY_SIZE \
+ GRAPH_FANOUT_SIZE + the_hash_algo->rawsz)
#define CORRECTED_COMMIT_DATE_OFFSET_OVERFLOW (1ULL << 31) #define CORRECTED_COMMIT_DATE_OFFSET_OVERFLOW (1ULL << 31)
@@ -81,6 +75,16 @@ define_commit_slab(topo_level_slab, uint32_t);
define_commit_slab(commit_pos, int); define_commit_slab(commit_pos, int);
static struct commit_pos commit_pos = COMMIT_SLAB_INIT(1, commit_pos); static struct commit_pos commit_pos = COMMIT_SLAB_INIT(1, commit_pos);
static size_t graph_data_width(const struct git_hash_algo *algop)
{
return algop->rawsz + 16;
}
static size_t graph_min_size(const struct git_hash_algo *algop)
{
return GRAPH_HEADER_SIZE + 4 * CHUNK_TOC_ENTRY_SIZE + GRAPH_FANOUT_SIZE + algop->rawsz;
}
static void set_commit_pos(struct repository *r, const struct object_id *oid) static void set_commit_pos(struct repository *r, const struct object_id *oid)
{ {
static int32_t max_pos; static int32_t max_pos;
@@ -249,9 +253,8 @@ int open_commit_graph(const char *graph_file, int *fd, struct stat *st)
return 1; return 1;
} }
struct commit_graph *load_commit_graph_one_fd_st(struct repository *r, struct commit_graph *load_commit_graph_one_fd_st(struct odb_source *source,
int fd, struct stat *st, int fd, struct stat *st)
struct odb_source *source)
{ {
void *graph_map; void *graph_map;
size_t graph_size; size_t graph_size;
@@ -259,16 +262,15 @@ struct commit_graph *load_commit_graph_one_fd_st(struct repository *r,
graph_size = xsize_t(st->st_size); graph_size = xsize_t(st->st_size);
if (graph_size < GRAPH_MIN_SIZE) { if (graph_size < graph_min_size(source->odb->repo->hash_algo)) {
close(fd); close(fd);
error(_("commit-graph file is too small")); error(_("commit-graph file is too small"));
return NULL; return NULL;
} }
graph_map = xmmap(NULL, graph_size, PROT_READ, MAP_PRIVATE, fd, 0); graph_map = xmmap(NULL, graph_size, PROT_READ, MAP_PRIVATE, fd, 0);
close(fd); close(fd);
prepare_repo_settings(r);
ret = parse_commit_graph(&r->settings, graph_map, graph_size);
ret = parse_commit_graph(source->odb->repo, graph_map, graph_size);
if (ret) if (ret)
ret->odb_source = source; ret->odb_source = source;
else else
@@ -306,7 +308,7 @@ static int graph_read_oid_lookup(const unsigned char *chunk_start,
{ {
struct commit_graph *g = data; struct commit_graph *g = data;
g->chunk_oid_lookup = chunk_start; g->chunk_oid_lookup = chunk_start;
if (chunk_size / g->hash_len != g->num_commits) if (chunk_size / g->hash_algo->rawsz != g->num_commits)
return error(_("commit-graph OID lookup chunk is the wrong size")); return error(_("commit-graph OID lookup chunk is the wrong size"));
return 0; return 0;
} }
@@ -315,7 +317,7 @@ static int graph_read_commit_data(const unsigned char *chunk_start,
size_t chunk_size, void *data) size_t chunk_size, void *data)
{ {
struct commit_graph *g = data; struct commit_graph *g = data;
if (chunk_size / GRAPH_DATA_WIDTH != g->num_commits) if (chunk_size / graph_data_width(g->hash_algo) != g->num_commits)
return error(_("commit-graph commit data chunk is wrong size")); return error(_("commit-graph commit data chunk is wrong size"));
g->chunk_commit_data = chunk_start; g->chunk_commit_data = chunk_start;
return 0; return 0;
@@ -368,7 +370,7 @@ static int graph_read_bloom_data(const unsigned char *chunk_start,
return 0; return 0;
} }
struct commit_graph *parse_commit_graph(struct repo_settings *s, struct commit_graph *parse_commit_graph(struct repository *r,
void *graph_map, size_t graph_size) void *graph_map, size_t graph_size)
{ {
const unsigned char *data; const unsigned char *data;
@@ -380,7 +382,7 @@ struct commit_graph *parse_commit_graph(struct repo_settings *s,
if (!graph_map) if (!graph_map)
return NULL; return NULL;
if (graph_size < GRAPH_MIN_SIZE) if (graph_size < graph_min_size(r->hash_algo))
return NULL; return NULL;
data = (const unsigned char *)graph_map; data = (const unsigned char *)graph_map;
@@ -400,22 +402,22 @@ struct commit_graph *parse_commit_graph(struct repo_settings *s,
} }
hash_version = *(unsigned char*)(data + 5); hash_version = *(unsigned char*)(data + 5);
if (hash_version != oid_version(the_hash_algo)) { if (hash_version != oid_version(r->hash_algo)) {
error(_("commit-graph hash version %X does not match version %X"), error(_("commit-graph hash version %X does not match version %X"),
hash_version, oid_version(the_hash_algo)); hash_version, oid_version(r->hash_algo));
return NULL; return NULL;
} }
graph = alloc_commit_graph(); graph = alloc_commit_graph();
graph->hash_len = the_hash_algo->rawsz; graph->hash_algo = r->hash_algo;
graph->num_chunks = *(unsigned char*)(data + 6); graph->num_chunks = *(unsigned char*)(data + 6);
graph->data = graph_map; graph->data = graph_map;
graph->data_len = graph_size; graph->data_len = graph_size;
if (graph_size < GRAPH_HEADER_SIZE + if (graph_size < GRAPH_HEADER_SIZE +
(graph->num_chunks + 1) * CHUNK_TOC_ENTRY_SIZE + (graph->num_chunks + 1) * CHUNK_TOC_ENTRY_SIZE +
GRAPH_FANOUT_SIZE + the_hash_algo->rawsz) { GRAPH_FANOUT_SIZE + r->hash_algo->rawsz) {
error(_("commit-graph file is too small to hold %u chunks"), error(_("commit-graph file is too small to hold %u chunks"),
graph->num_chunks); graph->num_chunks);
free(graph); free(graph);
@@ -446,7 +448,9 @@ struct commit_graph *parse_commit_graph(struct repo_settings *s,
pair_chunk(cf, GRAPH_CHUNKID_BASE, &graph->chunk_base_graphs, pair_chunk(cf, GRAPH_CHUNKID_BASE, &graph->chunk_base_graphs,
&graph->chunk_base_graphs_size); &graph->chunk_base_graphs_size);
if (s->commit_graph_generation_version >= 2) { prepare_repo_settings(r);
if (r->settings.commit_graph_generation_version >= 2) {
read_chunk(cf, GRAPH_CHUNKID_GENERATION_DATA, read_chunk(cf, GRAPH_CHUNKID_GENERATION_DATA,
graph_read_generation_data, graph); graph_read_generation_data, graph);
pair_chunk(cf, GRAPH_CHUNKID_GENERATION_DATA_OVERFLOW, pair_chunk(cf, GRAPH_CHUNKID_GENERATION_DATA_OVERFLOW,
@@ -457,7 +461,7 @@ struct commit_graph *parse_commit_graph(struct repo_settings *s,
graph->read_generation_data = 1; graph->read_generation_data = 1;
} }
if (s->commit_graph_changed_paths_version) { if (r->settings.commit_graph_changed_paths_version) {
read_chunk(cf, GRAPH_CHUNKID_BLOOMINDEXES, read_chunk(cf, GRAPH_CHUNKID_BLOOMINDEXES,
graph_read_bloom_index, graph); graph_read_bloom_index, graph);
read_chunk(cf, GRAPH_CHUNKID_BLOOMDATA, read_chunk(cf, GRAPH_CHUNKID_BLOOMDATA,
@@ -473,8 +477,8 @@ struct commit_graph *parse_commit_graph(struct repo_settings *s,
FREE_AND_NULL(graph->bloom_filter_settings); FREE_AND_NULL(graph->bloom_filter_settings);
} }
oidread(&graph->oid, graph->data + graph->data_len - graph->hash_len, oidread(&graph->oid, graph->data + graph->data_len - graph->hash_algo->rawsz,
the_repository->hash_algo); r->hash_algo);
free_chunkfile(cf); free_chunkfile(cf);
return graph; return graph;
@@ -486,11 +490,9 @@ free_and_return:
return NULL; return NULL;
} }
static struct commit_graph *load_commit_graph_one(struct repository *r, static struct commit_graph *load_commit_graph_one(struct odb_source *source,
const char *graph_file, const char *graph_file)
struct odb_source *source)
{ {
struct stat st; struct stat st;
int fd; int fd;
struct commit_graph *g; struct commit_graph *g;
@@ -499,19 +501,17 @@ static struct commit_graph *load_commit_graph_one(struct repository *r,
if (!open_ok) if (!open_ok)
return NULL; return NULL;
g = load_commit_graph_one_fd_st(r, fd, &st, source); g = load_commit_graph_one_fd_st(source, fd, &st);
if (g) if (g)
g->filename = xstrdup(graph_file); g->filename = xstrdup(graph_file);
return g; return g;
} }
static struct commit_graph *load_commit_graph_v1(struct repository *r, static struct commit_graph *load_commit_graph_v1(struct odb_source *source)
struct odb_source *source)
{ {
char *graph_name = get_commit_graph_filename(source); char *graph_name = get_commit_graph_filename(source);
struct commit_graph *g = load_commit_graph_one(r, graph_name, source); struct commit_graph *g = load_commit_graph_one(source, graph_name);
free(graph_name); free(graph_name);
return g; return g;
@@ -579,7 +579,7 @@ static int add_graph_to_chain(struct commit_graph *g,
return 0; return 0;
} }
if (g->chunk_base_graphs_size / g->hash_len < n) { if (g->chunk_base_graphs_size / g->hash_algo->rawsz < n) {
warning(_("commit-graph base graphs chunk is too small")); warning(_("commit-graph base graphs chunk is too small"));
return 0; return 0;
} }
@@ -589,8 +589,8 @@ static int add_graph_to_chain(struct commit_graph *g,
if (!cur_g || if (!cur_g ||
!oideq(&oids[n], &cur_g->oid) || !oideq(&oids[n], &cur_g->oid) ||
!hasheq(oids[n].hash, g->chunk_base_graphs + st_mult(g->hash_len, n), !hasheq(oids[n].hash, g->chunk_base_graphs + st_mult(g->hash_algo->rawsz, n),
the_repository->hash_algo)) { g->hash_algo)) {
warning(_("commit-graph chain does not match")); warning(_("commit-graph chain does not match"));
return 0; return 0;
} }
@@ -614,7 +614,8 @@ static int add_graph_to_chain(struct commit_graph *g,
} }
int open_commit_graph_chain(const char *chain_file, int open_commit_graph_chain(const char *chain_file,
int *fd, struct stat *st) int *fd, struct stat *st,
const struct git_hash_algo *hash_algo)
{ {
*fd = git_open(chain_file); *fd = git_open(chain_file);
if (*fd < 0) if (*fd < 0)
@@ -623,7 +624,7 @@ int open_commit_graph_chain(const char *chain_file,
close(*fd); close(*fd);
return 0; return 0;
} }
if (st->st_size < the_hash_algo->hexsz) { if (st->st_size < hash_algo->hexsz) {
close(*fd); close(*fd);
if (!st->st_size) { if (!st->st_size) {
/* treat empty files the same as missing */ /* treat empty files the same as missing */
@@ -637,7 +638,7 @@ int open_commit_graph_chain(const char *chain_file,
return 1; return 1;
} }
struct commit_graph *load_commit_graph_chain_fd_st(struct repository *r, struct commit_graph *load_commit_graph_chain_fd_st(struct object_database *odb,
int fd, struct stat *st, int fd, struct stat *st,
int *incomplete_chain) int *incomplete_chain)
{ {
@@ -647,10 +648,10 @@ struct commit_graph *load_commit_graph_chain_fd_st(struct repository *r,
int i = 0, valid = 1, count; int i = 0, valid = 1, count;
FILE *fp = xfdopen(fd, "r"); FILE *fp = xfdopen(fd, "r");
count = st->st_size / (the_hash_algo->hexsz + 1); count = st->st_size / (odb->repo->hash_algo->hexsz + 1);
CALLOC_ARRAY(oids, count); CALLOC_ARRAY(oids, count);
odb_prepare_alternates(r->objects); odb_prepare_alternates(odb);
for (i = 0; i < count; i++) { for (i = 0; i < count; i++) {
struct odb_source *source; struct odb_source *source;
@@ -658,7 +659,7 @@ struct commit_graph *load_commit_graph_chain_fd_st(struct repository *r,
if (strbuf_getline_lf(&line, fp) == EOF) if (strbuf_getline_lf(&line, fp) == EOF)
break; break;
if (get_oid_hex(line.buf, &oids[i])) { if (get_oid_hex_algop(line.buf, &oids[i], odb->repo->hash_algo)) {
warning(_("invalid commit-graph chain: line '%s' not a hash"), warning(_("invalid commit-graph chain: line '%s' not a hash"),
line.buf); line.buf);
valid = 0; valid = 0;
@@ -666,9 +667,9 @@ struct commit_graph *load_commit_graph_chain_fd_st(struct repository *r,
} }
valid = 0; valid = 0;
for (source = r->objects->sources; source; source = source->next) { for (source = odb->sources; source; source = source->next) {
char *graph_name = get_split_graph_filename(source, line.buf); char *graph_name = get_split_graph_filename(source, line.buf);
struct commit_graph *g = load_commit_graph_one(r, graph_name, source); struct commit_graph *g = load_commit_graph_one(source, graph_name);
free(graph_name); free(graph_name);
@@ -701,50 +702,38 @@ struct commit_graph *load_commit_graph_chain_fd_st(struct repository *r,
return graph_chain; return graph_chain;
} }
static struct commit_graph *load_commit_graph_chain(struct repository *r, static struct commit_graph *load_commit_graph_chain(struct odb_source *source)
struct odb_source *source)
{ {
char *chain_file = get_commit_graph_chain_filename(source); char *chain_file = get_commit_graph_chain_filename(source);
struct stat st; struct stat st;
int fd; int fd;
struct commit_graph *g = NULL; struct commit_graph *g = NULL;
if (open_commit_graph_chain(chain_file, &fd, &st)) { if (open_commit_graph_chain(chain_file, &fd, &st, source->odb->repo->hash_algo)) {
int incomplete; int incomplete;
/* ownership of fd is taken over by load function */ /* ownership of fd is taken over by load function */
g = load_commit_graph_chain_fd_st(r, fd, &st, &incomplete); g = load_commit_graph_chain_fd_st(source->odb, fd, &st, &incomplete);
} }
free(chain_file); free(chain_file);
return g; return g;
} }
struct commit_graph *read_commit_graph_one(struct repository *r, struct commit_graph *read_commit_graph_one(struct odb_source *source)
struct odb_source *source)
{ {
struct commit_graph *g = load_commit_graph_v1(r, source); struct commit_graph *g = load_commit_graph_v1(source);
if (!g) if (!g)
g = load_commit_graph_chain(r, source); g = load_commit_graph_chain(source);
return g; return g;
} }
static void prepare_commit_graph_one(struct repository *r,
struct odb_source *source)
{
if (r->objects->commit_graph)
return;
r->objects->commit_graph = read_commit_graph_one(r, source);
}
/* /*
* Return 1 if commit_graph is non-NULL, and 0 otherwise. * Return 1 if commit_graph is non-NULL, and 0 otherwise.
* *
* On the first invocation, this function attempts to load the commit * On the first invocation, this function attempts to load the commit
* graph if the_repository is configured to have one. * graph if the repository is configured to have one.
*/ */
static int prepare_commit_graph(struct repository *r) static int prepare_commit_graph(struct repository *r)
{ {
@@ -780,10 +769,12 @@ static int prepare_commit_graph(struct repository *r)
return 0; return 0;
odb_prepare_alternates(r->objects); odb_prepare_alternates(r->objects);
for (source = r->objects->sources; for (source = r->objects->sources; source; source = source->next) {
!r->objects->commit_graph && source; r->objects->commit_graph = read_commit_graph_one(source);
source = source->next) if (r->objects->commit_graph)
prepare_commit_graph_one(r, source); break;
}
return !!r->objects->commit_graph; return !!r->objects->commit_graph;
} }
@@ -800,7 +791,7 @@ int generation_numbers_enabled(struct repository *r)
return 0; return 0;
first_generation = get_be32(g->chunk_commit_data + first_generation = get_be32(g->chunk_commit_data +
g->hash_len + 8) >> 2; g->hash_algo->rawsz + 8) >> 2;
return !!first_generation; return !!first_generation;
} }
@@ -844,7 +835,7 @@ void close_commit_graph(struct object_database *o)
static int bsearch_graph(struct commit_graph *g, const struct object_id *oid, uint32_t *pos) static int bsearch_graph(struct commit_graph *g, const struct object_id *oid, uint32_t *pos)
{ {
return bsearch_hash(oid->hash, g->chunk_oid_fanout, return bsearch_hash(oid->hash, g->chunk_oid_fanout,
g->chunk_oid_lookup, g->hash_len, pos); g->chunk_oid_lookup, g->hash_algo->rawsz, pos);
} }
static void load_oid_from_graph(struct commit_graph *g, static void load_oid_from_graph(struct commit_graph *g,
@@ -864,12 +855,11 @@ static void load_oid_from_graph(struct commit_graph *g,
lex_index = pos - g->num_commits_in_base; lex_index = pos - g->num_commits_in_base;
oidread(oid, g->chunk_oid_lookup + st_mult(g->hash_len, lex_index), oidread(oid, g->chunk_oid_lookup + st_mult(g->hash_algo->rawsz, lex_index),
the_repository->hash_algo); g->hash_algo);
} }
static struct commit_list **insert_parent_or_die(struct repository *r, static struct commit_list **insert_parent_or_die(struct commit_graph *g,
struct commit_graph *g,
uint32_t pos, uint32_t pos,
struct commit_list **pptr) struct commit_list **pptr)
{ {
@@ -880,7 +870,7 @@ static struct commit_list **insert_parent_or_die(struct repository *r,
die("invalid parent position %"PRIu32, pos); die("invalid parent position %"PRIu32, pos);
load_oid_from_graph(g, pos, &oid); load_oid_from_graph(g, pos, &oid);
c = lookup_commit(r, &oid); c = lookup_commit(g->odb_source->odb->repo, &oid);
if (!c) if (!c)
die(_("could not find commit %s"), oid_to_hex(&oid)); die(_("could not find commit %s"), oid_to_hex(&oid));
commit_graph_data_at(c)->graph_pos = pos; commit_graph_data_at(c)->graph_pos = pos;
@@ -901,13 +891,13 @@ static void fill_commit_graph_info(struct commit *item, struct commit_graph *g,
die(_("invalid commit position. commit-graph is likely corrupt")); die(_("invalid commit position. commit-graph is likely corrupt"));
lex_index = pos - g->num_commits_in_base; lex_index = pos - g->num_commits_in_base;
commit_data = g->chunk_commit_data + st_mult(GRAPH_DATA_WIDTH, lex_index); commit_data = g->chunk_commit_data + st_mult(graph_data_width(g->hash_algo), lex_index);
graph_data = commit_graph_data_at(item); graph_data = commit_graph_data_at(item);
graph_data->graph_pos = pos; graph_data->graph_pos = pos;
date_high = get_be32(commit_data + g->hash_len + 8) & 0x3; date_high = get_be32(commit_data + g->hash_algo->rawsz + 8) & 0x3;
date_low = get_be32(commit_data + g->hash_len + 12); date_low = get_be32(commit_data + g->hash_algo->rawsz + 12);
item->date = (timestamp_t)((date_high << 32) | date_low); item->date = (timestamp_t)((date_high << 32) | date_low);
if (g->read_generation_data) { if (g->read_generation_data) {
@@ -925,10 +915,10 @@ static void fill_commit_graph_info(struct commit *item, struct commit_graph *g,
} else } else
graph_data->generation = item->date + offset; graph_data->generation = item->date + offset;
} else } else
graph_data->generation = get_be32(commit_data + g->hash_len + 8) >> 2; graph_data->generation = get_be32(commit_data + g->hash_algo->rawsz + 8) >> 2;
if (g->topo_levels) if (g->topo_levels)
*topo_level_slab_at(g->topo_levels, item) = get_be32(commit_data + g->hash_len + 8) >> 2; *topo_level_slab_at(g->topo_levels, item) = get_be32(commit_data + g->hash_algo->rawsz + 8) >> 2;
} }
static inline void set_commit_tree(struct commit *c, struct tree *t) static inline void set_commit_tree(struct commit *c, struct tree *t)
@@ -936,8 +926,7 @@ static inline void set_commit_tree(struct commit *c, struct tree *t)
c->maybe_tree = t; c->maybe_tree = t;
} }
static int fill_commit_in_graph(struct repository *r, static int fill_commit_in_graph(struct commit *item,
struct commit *item,
struct commit_graph *g, uint32_t pos) struct commit_graph *g, uint32_t pos)
{ {
uint32_t edge_value; uint32_t edge_value;
@@ -952,7 +941,7 @@ static int fill_commit_in_graph(struct repository *r,
fill_commit_graph_info(item, g, pos); fill_commit_graph_info(item, g, pos);
lex_index = pos - g->num_commits_in_base; lex_index = pos - g->num_commits_in_base;
commit_data = g->chunk_commit_data + st_mult(g->hash_len + 16, lex_index); commit_data = g->chunk_commit_data + st_mult(g->hash_algo->rawsz + 16, lex_index);
item->object.parsed = 1; item->object.parsed = 1;
@@ -960,16 +949,16 @@ static int fill_commit_in_graph(struct repository *r,
pptr = &item->parents; pptr = &item->parents;
edge_value = get_be32(commit_data + g->hash_len); edge_value = get_be32(commit_data + g->hash_algo->rawsz);
if (edge_value == GRAPH_PARENT_NONE) if (edge_value == GRAPH_PARENT_NONE)
return 1; return 1;
pptr = insert_parent_or_die(r, g, edge_value, pptr); pptr = insert_parent_or_die(g, edge_value, pptr);
edge_value = get_be32(commit_data + g->hash_len + 4); edge_value = get_be32(commit_data + g->hash_algo->rawsz + 4);
if (edge_value == GRAPH_PARENT_NONE) if (edge_value == GRAPH_PARENT_NONE)
return 1; return 1;
if (!(edge_value & GRAPH_EXTRA_EDGES_NEEDED)) { if (!(edge_value & GRAPH_EXTRA_EDGES_NEEDED)) {
pptr = insert_parent_or_die(r, g, edge_value, pptr); pptr = insert_parent_or_die(g, edge_value, pptr);
return 1; return 1;
} }
@@ -984,7 +973,7 @@ static int fill_commit_in_graph(struct repository *r,
} }
edge_value = get_be32(g->chunk_extra_edges + edge_value = get_be32(g->chunk_extra_edges +
sizeof(uint32_t) * parent_data_pos); sizeof(uint32_t) * parent_data_pos);
pptr = insert_parent_or_die(r, g, pptr = insert_parent_or_die(g,
edge_value & GRAPH_EDGE_LAST_MASK, edge_value & GRAPH_EDGE_LAST_MASK,
pptr); pptr);
parent_data_pos++; parent_data_pos++;
@@ -1050,14 +1039,13 @@ struct commit *lookup_commit_in_graph(struct repository *repo, const struct obje
if (commit->object.parsed) if (commit->object.parsed)
return commit; return commit;
if (!fill_commit_in_graph(repo, commit, repo->objects->commit_graph, pos)) if (!fill_commit_in_graph(commit, repo->objects->commit_graph, pos))
return NULL; return NULL;
return commit; return commit;
} }
static int parse_commit_in_graph_one(struct repository *r, static int parse_commit_in_graph_one(struct commit_graph *g,
struct commit_graph *g,
struct commit *item) struct commit *item)
{ {
uint32_t pos; uint32_t pos;
@@ -1066,7 +1054,7 @@ static int parse_commit_in_graph_one(struct repository *r,
return 1; return 1;
if (find_commit_pos_in_graph(item, g, &pos)) if (find_commit_pos_in_graph(item, g, &pos))
return fill_commit_in_graph(r, item, g, pos); return fill_commit_in_graph(item, g, pos);
return 0; return 0;
} }
@@ -1083,7 +1071,7 @@ int parse_commit_in_graph(struct repository *r, struct commit *item)
if (!prepare_commit_graph(r)) if (!prepare_commit_graph(r))
return 0; return 0;
return parse_commit_in_graph_one(r, r->objects->commit_graph, item); return parse_commit_in_graph_one(r->objects->commit_graph, item);
} }
void load_commit_graph_info(struct repository *r, struct commit *item) void load_commit_graph_info(struct repository *r, struct commit *item)
@@ -1093,8 +1081,7 @@ void load_commit_graph_info(struct repository *r, struct commit *item)
fill_commit_graph_info(item, r->objects->commit_graph, pos); fill_commit_graph_info(item, r->objects->commit_graph, pos);
} }
static struct tree *load_tree_for_commit(struct repository *r, static struct tree *load_tree_for_commit(struct commit_graph *g,
struct commit_graph *g,
struct commit *c) struct commit *c)
{ {
struct object_id oid; struct object_id oid;
@@ -1105,16 +1092,16 @@ static struct tree *load_tree_for_commit(struct repository *r,
g = g->base_graph; g = g->base_graph;
commit_data = g->chunk_commit_data + commit_data = g->chunk_commit_data +
st_mult(GRAPH_DATA_WIDTH, graph_pos - g->num_commits_in_base); st_mult(graph_data_width(g->hash_algo),
graph_pos - g->num_commits_in_base);
oidread(&oid, commit_data, the_repository->hash_algo); oidread(&oid, commit_data, g->hash_algo);
set_commit_tree(c, lookup_tree(r, &oid)); set_commit_tree(c, lookup_tree(g->odb_source->odb->repo, &oid));
return c->maybe_tree; return c->maybe_tree;
} }
static struct tree *get_commit_tree_in_graph_one(struct repository *r, static struct tree *get_commit_tree_in_graph_one(struct commit_graph *g,
struct commit_graph *g,
const struct commit *c) const struct commit *c)
{ {
if (c->maybe_tree) if (c->maybe_tree)
@@ -1122,12 +1109,12 @@ static struct tree *get_commit_tree_in_graph_one(struct repository *r,
if (commit_graph_position(c) == COMMIT_NOT_FROM_GRAPH) if (commit_graph_position(c) == COMMIT_NOT_FROM_GRAPH)
BUG("get_commit_tree_in_graph_one called from non-commit-graph commit"); BUG("get_commit_tree_in_graph_one called from non-commit-graph commit");
return load_tree_for_commit(r, g, (struct commit *)c); return load_tree_for_commit(g, (struct commit *)c);
} }
struct tree *get_commit_tree_in_graph(struct repository *r, const struct commit *c) struct tree *get_commit_tree_in_graph(struct repository *r, const struct commit *c)
{ {
return get_commit_tree_in_graph_one(r, r->objects->commit_graph, c); return get_commit_tree_in_graph_one(r->objects->commit_graph, c);
} }
struct packed_commit_list { struct packed_commit_list {
@@ -1213,7 +1200,7 @@ static int write_graph_chunk_oids(struct hashfile *f,
int count; int count;
for (count = 0; count < ctx->commits.nr; count++, list++) { for (count = 0; count < ctx->commits.nr; count++, list++) {
display_progress(ctx->progress, ++ctx->progress_cnt); display_progress(ctx->progress, ++ctx->progress_cnt);
hashwrite(f, (*list)->object.oid.hash, the_hash_algo->rawsz); hashwrite(f, (*list)->object.oid.hash, f->algop->rawsz);
} }
return 0; return 0;
@@ -1244,7 +1231,7 @@ static int write_graph_chunk_data(struct hashfile *f,
die(_("unable to parse commit %s"), die(_("unable to parse commit %s"),
oid_to_hex(&(*list)->object.oid)); oid_to_hex(&(*list)->object.oid));
tree = get_commit_tree_oid(*list); tree = get_commit_tree_oid(*list);
hashwrite(f, tree->hash, the_hash_algo->rawsz); hashwrite(f, tree->hash, ctx->r->hash_algo->rawsz);
parent = (*list)->parents; parent = (*list)->parents;
@@ -1534,7 +1521,7 @@ static void close_reachable(struct write_commit_graph_context *ctx)
if (ctx->report_progress) if (ctx->report_progress)
ctx->progress = start_delayed_progress( ctx->progress = start_delayed_progress(
the_repository, ctx->r,
_("Loading known commits in commit graph"), _("Loading known commits in commit graph"),
ctx->oids.nr); ctx->oids.nr);
for (i = 0; i < ctx->oids.nr; i++) { for (i = 0; i < ctx->oids.nr; i++) {
@@ -1552,7 +1539,7 @@ static void close_reachable(struct write_commit_graph_context *ctx)
*/ */
if (ctx->report_progress) if (ctx->report_progress)
ctx->progress = start_delayed_progress( ctx->progress = start_delayed_progress(
the_repository, ctx->r,
_("Expanding reachable commits in commit graph"), _("Expanding reachable commits in commit graph"),
0); 0);
for (i = 0; i < ctx->oids.nr; i++) { for (i = 0; i < ctx->oids.nr; i++) {
@@ -1573,7 +1560,7 @@ static void close_reachable(struct write_commit_graph_context *ctx)
if (ctx->report_progress) if (ctx->report_progress)
ctx->progress = start_delayed_progress( ctx->progress = start_delayed_progress(
the_repository, ctx->r,
_("Clearing commit marks in commit graph"), _("Clearing commit marks in commit graph"),
ctx->oids.nr); ctx->oids.nr);
for (i = 0; i < ctx->oids.nr; i++) { for (i = 0; i < ctx->oids.nr; i++) {
@@ -1691,7 +1678,7 @@ static void compute_topological_levels(struct write_commit_graph_context *ctx)
if (ctx->report_progress) if (ctx->report_progress)
info.progress = ctx->progress info.progress = ctx->progress
= start_delayed_progress( = start_delayed_progress(
the_repository, ctx->r,
_("Computing commit graph topological levels"), _("Computing commit graph topological levels"),
ctx->commits.nr); ctx->commits.nr);
@@ -1726,7 +1713,7 @@ static void compute_generation_numbers(struct write_commit_graph_context *ctx)
if (ctx->report_progress) if (ctx->report_progress)
info.progress = ctx->progress info.progress = ctx->progress
= start_delayed_progress( = start_delayed_progress(
the_repository, ctx->r,
_("Computing commit graph generation numbers"), _("Computing commit graph generation numbers"),
ctx->commits.nr); ctx->commits.nr);
@@ -1803,7 +1790,7 @@ static void compute_bloom_filters(struct write_commit_graph_context *ctx)
if (ctx->report_progress) if (ctx->report_progress)
progress = start_delayed_progress( progress = start_delayed_progress(
the_repository, ctx->r,
_("Computing commit changed paths Bloom filters"), _("Computing commit changed paths Bloom filters"),
ctx->commits.nr); ctx->commits.nr);
@@ -1849,6 +1836,7 @@ static void compute_bloom_filters(struct write_commit_graph_context *ctx)
} }
struct refs_cb_data { struct refs_cb_data {
struct repository *repo;
struct oidset *commits; struct oidset *commits;
struct progress *progress; struct progress *progress;
}; };
@@ -1861,9 +1849,9 @@ static int add_ref_to_set(const char *refname UNUSED,
struct object_id peeled; struct object_id peeled;
struct refs_cb_data *data = (struct refs_cb_data *)cb_data; struct refs_cb_data *data = (struct refs_cb_data *)cb_data;
if (!peel_iterated_oid(the_repository, oid, &peeled)) if (!peel_iterated_oid(data->repo, oid, &peeled))
oid = &peeled; oid = &peeled;
if (odb_read_object_info(the_repository->objects, oid, NULL) == OBJ_COMMIT) if (odb_read_object_info(data->repo->objects, oid, NULL) == OBJ_COMMIT)
oidset_insert(data->commits, oid); oidset_insert(data->commits, oid);
display_progress(data->progress, oidset_size(data->commits)); display_progress(data->progress, oidset_size(data->commits));
@@ -1880,13 +1868,15 @@ int write_commit_graph_reachable(struct odb_source *source,
int result; int result;
memset(&data, 0, sizeof(data)); memset(&data, 0, sizeof(data));
data.repo = source->odb->repo;
data.commits = &commits; data.commits = &commits;
if (flags & COMMIT_GRAPH_WRITE_PROGRESS) if (flags & COMMIT_GRAPH_WRITE_PROGRESS)
data.progress = start_delayed_progress( data.progress = start_delayed_progress(
the_repository, source->odb->repo,
_("Collecting referenced commits"), 0); _("Collecting referenced commits"), 0);
refs_for_each_ref(get_main_ref_store(the_repository), add_ref_to_set, refs_for_each_ref(get_main_ref_store(source->odb->repo), add_ref_to_set,
&data); &data);
stop_progress(&data.progress); stop_progress(&data.progress);
@@ -1915,7 +1905,7 @@ static int fill_oids_from_packs(struct write_commit_graph_context *ctx,
"Finding commits for commit graph in %"PRIuMAX" packs", "Finding commits for commit graph in %"PRIuMAX" packs",
pack_indexes->nr), pack_indexes->nr),
(uintmax_t)pack_indexes->nr); (uintmax_t)pack_indexes->nr);
ctx->progress = start_delayed_progress(the_repository, ctx->progress = start_delayed_progress(ctx->r,
progress_title.buf, 0); progress_title.buf, 0);
ctx->progress_done = 0; ctx->progress_done = 0;
} }
@@ -1969,7 +1959,7 @@ static void fill_oids_from_all_packs(struct write_commit_graph_context *ctx)
{ {
if (ctx->report_progress) if (ctx->report_progress)
ctx->progress = start_delayed_progress( ctx->progress = start_delayed_progress(
the_repository, ctx->r,
_("Finding commits for commit graph among packed objects"), _("Finding commits for commit graph among packed objects"),
ctx->approx_nr_objects); ctx->approx_nr_objects);
for_each_packed_object(ctx->r, add_packed_commits, ctx, for_each_packed_object(ctx->r, add_packed_commits, ctx,
@@ -1988,7 +1978,7 @@ static void copy_oids_to_commits(struct write_commit_graph_context *ctx)
ctx->num_extra_edges = 0; ctx->num_extra_edges = 0;
if (ctx->report_progress) if (ctx->report_progress)
ctx->progress = start_delayed_progress( ctx->progress = start_delayed_progress(
the_repository, ctx->r,
_("Finding extra edges in commit graph"), _("Finding extra edges in commit graph"),
ctx->oids.nr); ctx->oids.nr);
oid_array_sort(&ctx->oids); oid_array_sort(&ctx->oids);
@@ -2027,7 +2017,7 @@ static int write_graph_chunk_base_1(struct hashfile *f,
return 0; return 0;
num = write_graph_chunk_base_1(f, g->base_graph); num = write_graph_chunk_base_1(f, g->base_graph);
hashwrite(f, g->oid.hash, the_hash_algo->rawsz); hashwrite(f, g->oid.hash, g->hash_algo->rawsz);
return num + 1; return num + 1;
} }
@@ -2051,7 +2041,7 @@ static int write_commit_graph_file(struct write_commit_graph_context *ctx)
struct hashfile *f; struct hashfile *f;
struct tempfile *graph_layer; /* when ctx->split is non-zero */ struct tempfile *graph_layer; /* when ctx->split is non-zero */
struct lock_file lk = LOCK_INIT; struct lock_file lk = LOCK_INIT;
const unsigned hashsz = the_hash_algo->rawsz; const unsigned hashsz = ctx->r->hash_algo->rawsz;
struct strbuf progress_title = STRBUF_INIT; struct strbuf progress_title = STRBUF_INIT;
struct chunkfile *cf; struct chunkfile *cf;
unsigned char file_hash[GIT_MAX_RAWSZ]; unsigned char file_hash[GIT_MAX_RAWSZ];
@@ -2067,7 +2057,7 @@ static int write_commit_graph_file(struct write_commit_graph_context *ctx)
ctx->graph_name = get_commit_graph_filename(ctx->odb_source); ctx->graph_name = get_commit_graph_filename(ctx->odb_source);
} }
if (safe_create_leading_directories(the_repository, ctx->graph_name)) { if (safe_create_leading_directories(ctx->r, ctx->graph_name)) {
error(_("unable to create leading directories of %s"), error(_("unable to create leading directories of %s"),
ctx->graph_name); ctx->graph_name);
return -1; return -1;
@@ -2086,18 +2076,18 @@ static int write_commit_graph_file(struct write_commit_graph_context *ctx)
return -1; return -1;
} }
if (adjust_shared_perm(the_repository, get_tempfile_path(graph_layer))) { if (adjust_shared_perm(ctx->r, get_tempfile_path(graph_layer))) {
error(_("unable to adjust shared permissions for '%s'"), error(_("unable to adjust shared permissions for '%s'"),
get_tempfile_path(graph_layer)); get_tempfile_path(graph_layer));
return -1; return -1;
} }
f = hashfd(the_repository->hash_algo, f = hashfd(ctx->r->hash_algo,
get_tempfile_fd(graph_layer), get_tempfile_path(graph_layer)); get_tempfile_fd(graph_layer), get_tempfile_path(graph_layer));
} else { } else {
hold_lock_file_for_update_mode(&lk, ctx->graph_name, hold_lock_file_for_update_mode(&lk, ctx->graph_name,
LOCK_DIE_ON_ERROR, 0444); LOCK_DIE_ON_ERROR, 0444);
f = hashfd(the_repository->hash_algo, f = hashfd(ctx->r->hash_algo,
get_lock_file_fd(&lk), get_lock_file_path(&lk)); get_lock_file_fd(&lk), get_lock_file_path(&lk));
} }
@@ -2139,7 +2129,7 @@ static int write_commit_graph_file(struct write_commit_graph_context *ctx)
hashwrite_be32(f, GRAPH_SIGNATURE); hashwrite_be32(f, GRAPH_SIGNATURE);
hashwrite_u8(f, GRAPH_VERSION); hashwrite_u8(f, GRAPH_VERSION);
hashwrite_u8(f, oid_version(the_hash_algo)); hashwrite_u8(f, oid_version(ctx->r->hash_algo));
hashwrite_u8(f, get_num_chunks(cf)); hashwrite_u8(f, get_num_chunks(cf));
hashwrite_u8(f, ctx->num_commit_graphs_after - 1); hashwrite_u8(f, ctx->num_commit_graphs_after - 1);
@@ -2150,7 +2140,7 @@ static int write_commit_graph_file(struct write_commit_graph_context *ctx)
get_num_chunks(cf)), get_num_chunks(cf)),
get_num_chunks(cf)); get_num_chunks(cf));
ctx->progress = start_delayed_progress( ctx->progress = start_delayed_progress(
the_repository, ctx->r,
progress_title.buf, progress_title.buf,
st_mult(get_num_chunks(cf), ctx->commits.nr)); st_mult(get_num_chunks(cf), ctx->commits.nr));
} }
@@ -2208,7 +2198,8 @@ static int write_commit_graph_file(struct write_commit_graph_context *ctx)
} }
free(ctx->commit_graph_hash_after[ctx->num_commit_graphs_after - 1]); 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)); ctx->commit_graph_hash_after[ctx->num_commit_graphs_after - 1] =
xstrdup(hash_to_hex_algop(file_hash, ctx->r->hash_algo));
final_graph_name = get_split_graph_filename(ctx->odb_source, final_graph_name = get_split_graph_filename(ctx->odb_source,
ctx->commit_graph_hash_after[ctx->num_commit_graphs_after - 1]); ctx->commit_graph_hash_after[ctx->num_commit_graphs_after - 1]);
free(ctx->commit_graph_filenames_after[ctx->num_commit_graphs_after - 1]); free(ctx->commit_graph_filenames_after[ctx->num_commit_graphs_after - 1]);
@@ -2363,7 +2354,7 @@ static void sort_and_scan_merged_commits(struct write_commit_graph_context *ctx)
if (ctx->report_progress) if (ctx->report_progress)
ctx->progress = start_delayed_progress( ctx->progress = start_delayed_progress(
the_repository, ctx->r,
_("Scanning merged commits"), _("Scanning merged commits"),
ctx->commits.nr); ctx->commits.nr);
@@ -2408,7 +2399,7 @@ static void merge_commit_graphs(struct write_commit_graph_context *ctx)
current_graph_number--; current_graph_number--;
if (ctx->report_progress) if (ctx->report_progress)
ctx->progress = start_delayed_progress(the_repository, ctx->progress = start_delayed_progress(ctx->r,
_("Merging commit-graph"), 0); _("Merging commit-graph"), 0);
merge_commit_graph(ctx, g); merge_commit_graph(ctx, g);
@@ -2511,7 +2502,7 @@ int write_commit_graph(struct odb_source *source,
enum commit_graph_write_flags flags, enum commit_graph_write_flags flags,
const struct commit_graph_opts *opts) const struct commit_graph_opts *opts)
{ {
struct repository *r = the_repository; struct repository *r = source->odb->repo;
struct write_commit_graph_context ctx = { struct write_commit_graph_context ctx = {
.r = r, .r = r,
.odb_source = source, .odb_source = source,
@@ -2611,14 +2602,14 @@ int write_commit_graph(struct odb_source *source,
replace = ctx.opts->split_flags & COMMIT_GRAPH_SPLIT_REPLACE; replace = ctx.opts->split_flags & COMMIT_GRAPH_SPLIT_REPLACE;
} }
ctx.approx_nr_objects = repo_approximate_object_count(the_repository); ctx.approx_nr_objects = repo_approximate_object_count(r);
if (ctx.append && ctx.r->objects->commit_graph) { if (ctx.append && ctx.r->objects->commit_graph) {
struct commit_graph *g = ctx.r->objects->commit_graph; struct commit_graph *g = ctx.r->objects->commit_graph;
for (i = 0; i < g->num_commits; i++) { for (i = 0; i < g->num_commits; i++) {
struct object_id oid; struct object_id oid;
oidread(&oid, g->chunk_oid_lookup + st_mult(g->hash_len, i), oidread(&oid, g->chunk_oid_lookup + st_mult(g->hash_algo->rawsz, i),
the_repository->hash_algo); r->hash_algo);
oid_array_append(&ctx.oids, &oid); oid_array_append(&ctx.oids, &oid);
} }
} }
@@ -2726,15 +2717,15 @@ static void graph_report(const char *fmt, ...)
static int commit_graph_checksum_valid(struct commit_graph *g) static int commit_graph_checksum_valid(struct commit_graph *g)
{ {
return hashfile_checksum_valid(the_repository->hash_algo, return hashfile_checksum_valid(g->hash_algo,
g->data, g->data_len); g->data, g->data_len);
} }
static int verify_one_commit_graph(struct repository *r, static int verify_one_commit_graph(struct commit_graph *g,
struct commit_graph *g,
struct progress *progress, struct progress *progress,
uint64_t *seen) uint64_t *seen)
{ {
struct repository *r = g->odb_source->odb->repo;
uint32_t i, cur_fanout_pos = 0; uint32_t i, cur_fanout_pos = 0;
struct object_id prev_oid, cur_oid; struct object_id prev_oid, cur_oid;
struct commit *seen_gen_zero = NULL; struct commit *seen_gen_zero = NULL;
@@ -2748,8 +2739,8 @@ static int verify_one_commit_graph(struct repository *r,
for (i = 0; i < g->num_commits; i++) { for (i = 0; i < g->num_commits; i++) {
struct commit *graph_commit; struct commit *graph_commit;
oidread(&cur_oid, g->chunk_oid_lookup + st_mult(g->hash_len, i), oidread(&cur_oid, g->chunk_oid_lookup + st_mult(g->hash_algo->rawsz, i),
the_repository->hash_algo); g->hash_algo);
if (i && oidcmp(&prev_oid, &cur_oid) >= 0) if (i && oidcmp(&prev_oid, &cur_oid) >= 0)
graph_report(_("commit-graph has incorrect OID order: %s then %s"), graph_report(_("commit-graph has incorrect OID order: %s then %s"),
@@ -2768,7 +2759,7 @@ static int verify_one_commit_graph(struct repository *r,
} }
graph_commit = lookup_commit(r, &cur_oid); graph_commit = lookup_commit(r, &cur_oid);
if (!parse_commit_in_graph_one(r, g, graph_commit)) if (!parse_commit_in_graph_one(g, graph_commit))
graph_report(_("failed to parse commit %s from commit-graph"), graph_report(_("failed to parse commit %s from commit-graph"),
oid_to_hex(&cur_oid)); oid_to_hex(&cur_oid));
} }
@@ -2793,8 +2784,8 @@ static int verify_one_commit_graph(struct repository *r,
timestamp_t generation; timestamp_t generation;
display_progress(progress, ++(*seen)); display_progress(progress, ++(*seen));
oidread(&cur_oid, g->chunk_oid_lookup + st_mult(g->hash_len, i), oidread(&cur_oid, g->chunk_oid_lookup + st_mult(g->hash_algo->rawsz, i),
the_repository->hash_algo); g->hash_algo);
graph_commit = lookup_commit(r, &cur_oid); graph_commit = lookup_commit(r, &cur_oid);
odb_commit = (struct commit *)create_object(r, &cur_oid, alloc_commit_node(r)); odb_commit = (struct commit *)create_object(r, &cur_oid, alloc_commit_node(r));
@@ -2804,7 +2795,7 @@ static int verify_one_commit_graph(struct repository *r,
continue; continue;
} }
if (!oideq(&get_commit_tree_in_graph_one(r, g, graph_commit)->object.oid, if (!oideq(&get_commit_tree_in_graph_one(g, graph_commit)->object.oid,
get_commit_tree_oid(odb_commit))) get_commit_tree_oid(odb_commit)))
graph_report(_("root tree OID for commit %s in commit-graph is %s != %s"), graph_report(_("root tree OID for commit %s in commit-graph is %s != %s"),
oid_to_hex(&cur_oid), oid_to_hex(&cur_oid),
@@ -2822,7 +2813,7 @@ static int verify_one_commit_graph(struct repository *r,
} }
/* parse parent in case it is in a base graph */ /* parse parent in case it is in a base graph */
parse_commit_in_graph_one(r, g, graph_parents->item); parse_commit_in_graph_one(g, graph_parents->item);
if (!oideq(&graph_parents->item->object.oid, &odb_parents->item->object.oid)) if (!oideq(&graph_parents->item->object.oid, &odb_parents->item->object.oid))
graph_report(_("commit-graph parent for %s is %s != %s"), graph_report(_("commit-graph parent for %s is %s != %s"),
@@ -2882,7 +2873,7 @@ static int verify_one_commit_graph(struct repository *r,
return verify_commit_graph_error; return verify_commit_graph_error;
} }
int verify_commit_graph(struct repository *r, struct commit_graph *g, int flags) int verify_commit_graph(struct commit_graph *g, int flags)
{ {
struct progress *progress = NULL; struct progress *progress = NULL;
int local_error = 0; int local_error = 0;
@@ -2898,13 +2889,13 @@ int verify_commit_graph(struct repository *r, struct commit_graph *g, int flags)
if (!(flags & COMMIT_GRAPH_VERIFY_SHALLOW)) if (!(flags & COMMIT_GRAPH_VERIFY_SHALLOW))
total += g->num_commits_in_base; total += g->num_commits_in_base;
progress = start_progress(the_repository, progress = start_progress(g->odb_source->odb->repo,
_("Verifying commits in commit graph"), _("Verifying commits in commit graph"),
total); total);
} }
for (; g; g = g->base_graph) { for (; g; g = g->base_graph) {
local_error |= verify_one_commit_graph(r, g, progress, &seen); local_error |= verify_one_commit_graph(g, progress, &seen);
if (flags & COMMIT_GRAPH_VERIFY_SHALLOW) if (flags & COMMIT_GRAPH_VERIFY_SHALLOW)
break; break;
} }

21
commit-graph.h
View File

@@ -21,7 +21,7 @@
* call this method oustide of a builtin, and only if you know what * call this method oustide of a builtin, and only if you know what
* you are doing! * you are doing!
*/ */
void git_test_write_commit_graph_or_die(void); void git_test_write_commit_graph_or_die(struct odb_source *source);
struct commit; struct commit;
struct bloom_filter_settings; struct bloom_filter_settings;
@@ -32,7 +32,8 @@ struct string_list;
char *get_commit_graph_filename(struct odb_source *source); char *get_commit_graph_filename(struct odb_source *source);
char *get_commit_graph_chain_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(const char *graph_file, int *fd, struct stat *st);
int open_commit_graph_chain(const char *chain_file, int *fd, struct stat *st); int open_commit_graph_chain(const char *chain_file, int *fd, struct stat *st,
const struct git_hash_algo *hash_algo);
/* /*
* Given a commit struct, try to fill the commit struct info, including: * Given a commit struct, try to fill the commit struct info, including:
@@ -84,7 +85,7 @@ struct commit_graph {
const unsigned char *data; const unsigned char *data;
size_t data_len; size_t data_len;
unsigned char hash_len; const struct git_hash_algo *hash_algo;
unsigned char num_chunks; unsigned char num_chunks;
uint32_t num_commits; uint32_t num_commits;
struct object_id oid; struct object_id oid;
@@ -113,14 +114,12 @@ struct commit_graph {
struct bloom_filter_settings *bloom_filter_settings; struct bloom_filter_settings *bloom_filter_settings;
}; };
struct commit_graph *load_commit_graph_one_fd_st(struct repository *r, struct commit_graph *load_commit_graph_one_fd_st(struct odb_source *source,
int fd, struct stat *st, int fd, struct stat *st);
struct odb_source *source); struct commit_graph *load_commit_graph_chain_fd_st(struct object_database *odb,
struct commit_graph *load_commit_graph_chain_fd_st(struct repository *r,
int fd, struct stat *st, int fd, struct stat *st,
int *incomplete_chain); int *incomplete_chain);
struct commit_graph *read_commit_graph_one(struct repository *r, struct commit_graph *read_commit_graph_one(struct odb_source *source);
struct odb_source *source);
struct repo_settings; struct repo_settings;
@@ -128,7 +127,7 @@ struct repo_settings;
* Callers should initialize the repo_settings with prepare_repo_settings() * Callers should initialize the repo_settings with prepare_repo_settings()
* prior to calling parse_commit_graph(). * prior to calling parse_commit_graph().
*/ */
struct commit_graph *parse_commit_graph(struct repo_settings *s, struct commit_graph *parse_commit_graph(struct repository *r,
void *graph_map, size_t graph_size); void *graph_map, size_t graph_size);
/* /*
@@ -184,7 +183,7 @@ int write_commit_graph(struct odb_source *source,
#define COMMIT_GRAPH_VERIFY_SHALLOW (1 << 0) #define COMMIT_GRAPH_VERIFY_SHALLOW (1 << 0)
int verify_commit_graph(struct repository *r, struct commit_graph *g, int flags); int verify_commit_graph(struct commit_graph *g, int flags);
void close_commit_graph(struct object_database *); void close_commit_graph(struct object_database *);
void free_commit_graph(struct commit_graph *); void free_commit_graph(struct commit_graph *);

6
oss-fuzz/fuzz-commit-graph.c
View File

@@ -4,9 +4,6 @@
#include "commit-graph.h" #include "commit-graph.h"
#include "repository.h" #include "repository.h"
struct commit_graph *parse_commit_graph(struct repo_settings *s,
void *graph_map, size_t graph_size);
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size); int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size);
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
@@ -22,9 +19,10 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
* possible. * possible.
*/ */
repo_set_hash_algo(the_repository, GIT_HASH_SHA1); repo_set_hash_algo(the_repository, GIT_HASH_SHA1);
the_repository->settings.initialized = 1;
the_repository->settings.commit_graph_generation_version = 2; the_repository->settings.commit_graph_generation_version = 2;
the_repository->settings.commit_graph_changed_paths_version = 1; the_repository->settings.commit_graph_changed_paths_version = 1;
g = parse_commit_graph(&the_repository->settings, (void *)data, size); g = parse_commit_graph(the_repository, (void *)data, size);
repo_clear(the_repository); repo_clear(the_repository);
free_commit_graph(g); free_commit_graph(g);

2
t/helper/test-read-graph.c
View File

@@ -81,7 +81,7 @@ int cmd__read_graph(int argc, const char **argv)
prepare_repo_settings(the_repository); prepare_repo_settings(the_repository);
graph = read_commit_graph_one(the_repository, source); graph = read_commit_graph_one(source);
if (!graph) { if (!graph) {
ret = 1; ret = 1;
goto done; goto done;