#include "git-compat-util.h"

#include "config.h"

#include "lockfile.h"

#include "pack.h"

#include "packfile.h"

#include "commit.h"

#include "object.h"

#include "refs.h"

#include "revision.h"

#include "hash-lookup.h"

#include "commit-graph.h"

#include "object-store.h"

#include "alloc.h"

#include "hashmap.h"

#include "replace-object.h"

#include "progress.h"

#include "bloom.h"

#include "commit-slab.h"

#include "shallow.h"

#include "json-writer.h"

#include "trace2.h"

#include "chunk-format.h"

void git_test_write_commit_graph_or_die(void)

{

int flags = 0;

if (!git_env_bool(GIT_TEST_COMMIT_GRAPH, 0))

return;

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,

flags, NULL))

die("failed to write commit-graph under GIT_TEST_COMMIT_GRAPH");

}

#define GRAPH_SIGNATURE 0x43475048 /* "CGPH" */

#define GRAPH_CHUNKID_OIDFANOUT 0x4f494446 /* "OIDF" */

#define GRAPH_CHUNKID_OIDLOOKUP 0x4f49444c /* "OIDL" */

#define GRAPH_CHUNKID_DATA 0x43444154 /* "CDAT" */

#define GRAPH_CHUNKID_GENERATION_DATA 0x47444154 /* "GDAT" */

#define GRAPH_CHUNKID_GENERATION_DATA_OVERFLOW 0x47444f56 /* "GDOV" */

#define GRAPH_CHUNKID_EXTRAEDGES 0x45444745 /* "EDGE" */

#define GRAPH_CHUNKID_BLOOMINDEXES 0x42494458 /* "BIDX" */

#define GRAPH_CHUNKID_BLOOMDATA 0x42444154 /* "BDAT" */

#define GRAPH_CHUNKID_BASE 0x42415345 /* "BASE" */

#define GRAPH_DATA_WIDTH (the_hash_algo->rawsz + 16)

#define GRAPH_VERSION_1 0x1

#define GRAPH_VERSION GRAPH_VERSION_1

#define GRAPH_EXTRA_EDGES_NEEDED 0x80000000

#define GRAPH_EDGE_LAST_MASK 0x7fffffff

#define GRAPH_PARENT_NONE 0x70000000

#define GRAPH_LAST_EDGE 0x80000000

#define GRAPH_HEADER_SIZE 8

#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 REACHABLE (1u<<15)

define_commit_slab(topo_level_slab, uint32_t);

define_commit_slab(commit_pos, int);

static struct commit_pos commit_pos = COMMIT_SLAB_INIT(1, commit_pos);

static void set_commit_pos(struct repository *r, const struct object_id *oid)

{

static int32_t max_pos;

struct commit *commit = lookup_commit(r, oid);

if (!commit)

return; /* should never happen, but be lenient */

*commit_pos_at(&commit_pos, commit) = max_pos++;

}

static int commit_pos_cmp(const void *va, const void *vb)

{

const struct commit *a = *(const struct commit **)va;

const struct commit *b = *(const struct commit **)vb;

return commit_pos_at(&commit_pos, a) -

commit_pos_at(&commit_pos, b);

}

define_commit_slab(commit_graph_data_slab, struct commit_graph_data);

static struct commit_graph_data_slab commit_graph_data_slab =

COMMIT_SLAB_INIT(1, commit_graph_data_slab);

static int get_configured_generation_version(struct repository *r)

{

int version = 2;

repo_config_get_int(r, "commitgraph.generationversion", &version);

return version;

}

uint32_t commit_graph_position(const struct commit *c)

{

struct commit_graph_data *data =

commit_graph_data_slab_peek(&commit_graph_data_slab, c);

return data ? data->graph_pos : COMMIT_NOT_FROM_GRAPH;

}

timestamp_t commit_graph_generation(const struct commit *c)

{

struct commit_graph_data *data =

commit_graph_data_slab_peek(&commit_graph_data_slab, c);

if (!data)

return GENERATION_NUMBER_INFINITY;

else if (data->graph_pos == COMMIT_NOT_FROM_GRAPH)

return GENERATION_NUMBER_INFINITY;

return data->generation;

}

static struct commit_graph_data *commit_graph_data_at(const struct commit *c)

{

unsigned int i, nth_slab;

struct commit_graph_data *data =

commit_graph_data_slab_peek(&commit_graph_data_slab, c);

if (data)

return data;

nth_slab = c->index / commit_graph_data_slab.slab_size;

data = commit_graph_data_slab_at(&commit_graph_data_slab, c);

/*

for (i = 0; i < commit_graph_data_slab.slab_size; i++) {

commit_graph_data_slab.slab[nth_slab][i].graph_pos =

COMMIT_NOT_FROM_GRAPH;

}

return data;

}

static int commit_gen_cmp(const void *va, const void *vb)

{

const struct commit *a = *(const struct commit **)va;

const struct commit *b = *(const struct commit **)vb;

const timestamp_t generation_a = commit_graph_data_at(a)->generation;

const timestamp_t generation_b = commit_graph_data_at(b)->generation;

/* lower generation commits first */

if (generation_a < generation_b)

return -1;

else if (generation_a > generation_b)

return 1;

/* use date as a heuristic when generations are equal */

if (a->date < b->date)

return -1;

else if (a->date > b->date)

return 1;

return 0;

}

char *get_commit_graph_filename(struct object_directory *obj_dir)

{

return xstrfmt("%s/info/commit-graph", obj_dir->path);

}

static char *get_split_graph_filename(struct object_directory *odb,

const char *oid_hex)

{

return xstrfmt("%s/info/commit-graphs/graph-%s.graph", odb->path,

oid_hex);

}

char *get_commit_graph_chain_filename(struct object_directory *odb)

{

return xstrfmt("%s/info/commit-graphs/commit-graph-chain", odb->path);

}

static uint8_t oid_version(void)

{

switch (hash_algo_by_ptr(the_hash_algo)) {

case GIT_HASH_SHA1:

return 1;

case GIT_HASH_SHA256:

return 2;

default:

die(_("invalid hash version"));

}

}

static struct commit_graph *alloc_commit_graph(void)

{

struct commit_graph *g = xcalloc(1, sizeof(*g));

return g;

}

extern int read_replace_refs;

static int commit_graph_compatible(struct repository *r)

{

if (!r->gitdir)

return 0;

if (read_replace_refs) {

prepare_replace_object(r);

if (hashmap_get_size(&r->objects->replace_map->map))

return 0;

}

prepare_commit_graft(r);

if (r->parsed_objects &&

(r->parsed_objects->grafts_nr || r->parsed_objects->substituted_parent))

return 0;

if (is_repository_shallow(r))

return 0;

return 1;

}

int open_commit_graph(const char *graph_file, int *fd, struct stat *st)

{

*fd = git_open(graph_file);

if (*fd < 0)

return 0;

if (fstat(*fd, st)) {

close(*fd);

return 0;

}

return 1;

}

struct commit_graph *load_commit_graph_one_fd_st(struct repository *r,

int fd, struct stat *st,

struct object_directory *odb)

{

void *graph_map;

size_t graph_size;

struct commit_graph *ret;

graph_size = xsize_t(st->st_size);

if (graph_size < GRAPH_MIN_SIZE) {

close(fd);

error(_("commit-graph file is too small"));

return NULL;

}

graph_map = xmmap(NULL, graph_size, PROT_READ, MAP_PRIVATE, fd, 0);

close(fd);

ret = parse_commit_graph(r, graph_map, graph_size);

if (ret)

ret->odb = odb;

else

munmap(graph_map, graph_size);

return ret;

}

static int verify_commit_graph_lite(struct commit_graph *g)

{

/*

if (!g->chunk_oid_fanout) {

error("commit-graph is missing the OID Fanout chunk");

return 1;

}

if (!g->chunk_oid_lookup) {

error("commit-graph is missing the OID Lookup chunk");

return 1;

}

if (!g->chunk_commit_data) {

error("commit-graph is missing the Commit Data chunk");

return 1;

}

return 0;

}

static int graph_read_oid_lookup(const unsigned char *chunk_start,

size_t chunk_size, void *data)

{

struct commit_graph *g = data;

g->chunk_oid_lookup = chunk_start;

g->num_commits = chunk_size / g->hash_len;

return 0;

}

static int graph_read_bloom_data(const unsigned char *chunk_start,

size_t chunk_size, void *data)

{

struct commit_graph *g = data;

uint32_t hash_version;

g->chunk_bloom_data = chunk_start;

hash_version = get_be32(chunk_start);

if (hash_version != 1)

return 0;

g->bloom_filter_settings = xmalloc(sizeof(struct bloom_filter_settings));

g->bloom_filter_settings->hash_version = hash_version;

g->bloom_filter_settings->num_hashes = get_be32(chunk_start + 4);

g->bloom_filter_settings->bits_per_entry = get_be32(chunk_start + 8);

g->bloom_filter_settings->max_changed_paths = DEFAULT_BLOOM_MAX_CHANGES;

return 0;

}

struct commit_graph *parse_commit_graph(struct repository *r,

void *graph_map, size_t graph_size)

{

const unsigned char *data;

struct commit_graph *graph;

uint32_t graph_signature;

unsigned char graph_version, hash_version;

struct chunkfile *cf = NULL;

if (!graph_map)

return NULL;

if (graph_size < GRAPH_MIN_SIZE)

return NULL;

data = (const unsigned char *)graph_map;

graph_signature = get_be32(data);

if (graph_signature != GRAPH_SIGNATURE) {

error(_("commit-graph signature %X does not match signature %X"),

graph_signature, GRAPH_SIGNATURE);

return NULL;

}

graph_version = *(unsigned char*)(data + 4);

if (graph_version != GRAPH_VERSION) {

error(_("commit-graph version %X does not match version %X"),

graph_version, GRAPH_VERSION);

return NULL;

}

hash_version = *(unsigned char*)(data + 5);

if (hash_version != oid_version()) {

error(_("commit-graph hash version %X does not match version %X"),

hash_version, oid_version());

return NULL;

}

prepare_repo_settings(r);

graph = alloc_commit_graph();

graph->hash_len = the_hash_algo->rawsz;

graph->num_chunks = *(unsigned char*)(data + 6);

graph->data = graph_map;

graph->data_len = graph_size;

if (graph_size < GRAPH_HEADER_SIZE +

(graph->num_chunks + 1) * CHUNK_TOC_ENTRY_SIZE +

GRAPH_FANOUT_SIZE + the_hash_algo->rawsz) {

error(_("commit-graph file is too small to hold %u chunks"),

graph->num_chunks);

free(graph);

return NULL;

}

cf = init_chunkfile(NULL);

if (read_table_of_contents(cf, graph->data, graph_size,

GRAPH_HEADER_SIZE, graph->num_chunks))

goto free_and_return;

pair_chunk(cf, GRAPH_CHUNKID_OIDFANOUT,

(const unsigned char **)&graph->chunk_oid_fanout);

read_chunk(cf, GRAPH_CHUNKID_OIDLOOKUP, graph_read_oid_lookup, graph);

pair_chunk(cf, GRAPH_CHUNKID_DATA, &graph->chunk_commit_data);

pair_chunk(cf, GRAPH_CHUNKID_EXTRAEDGES, &graph->chunk_extra_edges);

pair_chunk(cf, GRAPH_CHUNKID_BASE, &graph->chunk_base_graphs);

if (get_configured_generation_version(r) >= 2) {

pair_chunk(cf, GRAPH_CHUNKID_GENERATION_DATA,

&graph->chunk_generation_data);

pair_chunk(cf, GRAPH_CHUNKID_GENERATION_DATA_OVERFLOW,

&graph->chunk_generation_data_overflow);

}

if (r->settings.commit_graph_read_changed_paths) {

pair_chunk(cf, GRAPH_CHUNKID_BLOOMINDEXES,

&graph->chunk_bloom_indexes);

read_chunk(cf, GRAPH_CHUNKID_BLOOMDATA,

graph_read_bloom_data, graph);

}

if (graph->chunk_bloom_indexes && graph->chunk_bloom_data) {

init_bloom_filters();

} else {

/* We need both the bloom chunks to exist together. Else ignore the data */

graph->chunk_bloom_indexes = NULL;

graph->chunk_bloom_data = NULL;

FREE_AND_NULL(graph->bloom_filter_settings);

}

oidread(&graph->oid, graph->data + graph->data_len - graph->hash_len);

if (verify_commit_graph_lite(graph))

goto free_and_return;

free_chunkfile(cf);

return graph;

free_and_return:

free_chunkfile(cf);

free(graph->bloom_filter_settings);

free(graph);

return NULL;

}

static struct commit_graph *load_commit_graph_one(struct repository *r,

const char *graph_file,

struct object_directory *odb)

{

struct stat st;

int fd;

struct commit_graph *g;

int open_ok = open_commit_graph(graph_file, &fd, &st);

if (!open_ok)

return NULL;

g = load_commit_graph_one_fd_st(r, fd, &st, odb);

if (g)

g->filename = xstrdup(graph_file);

return g;

}

static struct commit_graph *load_commit_graph_v1(struct repository *r,

struct object_directory *odb)

{

char *graph_name = get_commit_graph_filename(odb);

struct commit_graph *g = load_commit_graph_one(r, graph_name, odb);

free(graph_name);

return g;

}

static int add_graph_to_chain(struct commit_graph *g,

struct commit_graph *chain,

struct object_id *oids,

int n)

{

struct commit_graph *cur_g = chain;

if (n && !g->chunk_base_graphs) {

warning(_("commit-graph has no base graphs chunk"));

return 0;

}

while (n) {

n--;

if (!cur_g ||

!oideq(&oids[n], &cur_g->oid) ||

!hasheq(oids[n].hash, g->chunk_base_graphs + g->hash_len * n)) {

warning(_("commit-graph chain does not match"));

return 0;

}

cur_g = cur_g->base_graph;

}

g->base_graph = chain;

if (chain)

g->num_commits_in_base = chain->num_commits + chain->num_commits_in_base;

return 1;

}

static struct commit_graph *load_commit_graph_chain(struct repository *r,

struct object_directory *odb)

{

struct commit_graph *graph_chain = NULL;

struct strbuf line = STRBUF_INIT;

struct stat st;

struct object_id *oids;

int i = 0, valid = 1, count;

char *chain_name = get_commit_graph_chain_filename(odb);

FILE *fp;

int stat_res;

fp = fopen(chain_name, "r");

stat_res = stat(chain_name, &st);

free(chain_name);

if (!fp ||

stat_res ||

st.st_size <= the_hash_algo->hexsz)

return NULL;

count = st.st_size / (the_hash_algo->hexsz + 1);

CALLOC_ARRAY(oids, count);

prepare_alt_odb(r);

for (i = 0; i < count; i++) {

struct object_directory *odb;

if (strbuf_getline_lf(&line, fp) == EOF)

break;

if (get_oid_hex(line.buf, &oids[i])) {

warning(_("invalid commit-graph chain: line '%s' not a hash"),

line.buf);

valid = 0;

break;

}

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);

free(graph_name);

if (g) {

if (add_graph_to_chain(g, graph_chain, oids, i)) {

graph_chain = g;

valid = 1;

}

break;

}

}

if (!valid) {

warning(_("unable to find all commit-graph files"));

break;

}

}

free(oids);

fclose(fp);

strbuf_release(&line);

return graph_chain;

}

static int validate_mixed_generation_chain(struct commit_graph *g)

{

int read_generation_data = 1;

struct commit_graph *p = g;

while (read_generation_data && p) {

read_generation_data = p->read_generation_data;

p = p->base_graph;

}

if (read_generation_data)

return 1;

while (g) {

g->read_generation_data = 0;

g = g->base_graph;

}

return 0;

}

struct commit_graph *read_commit_graph_one(struct repository *r,

struct object_directory *odb)

{

struct commit_graph *g = load_commit_graph_v1(r, odb);

if (!g)

g = load_commit_graph_chain(r, odb);

validate_mixed_generation_chain(g);

return g;

}

static void prepare_commit_graph_one(struct repository *r,

struct object_directory *odb)

{

if (r->objects->commit_graph)

return;

r->objects->commit_graph = read_commit_graph_one(r, odb);

}

static int prepare_commit_graph(struct repository *r)

{

struct object_directory *odb;

/*

if (r->commit_graph_disabled)

return 0;

if (r->objects->commit_graph_attempted)

return !!r->objects->commit_graph;

r->objects->commit_graph_attempted = 1;

prepare_repo_settings(r);

if (!git_env_bool(GIT_TEST_COMMIT_GRAPH, 0) &&

r->settings.core_commit_graph != 1)

/*

return 0;

if (!commit_graph_compatible(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);

return !!r->objects->commit_graph;

}

int generation_numbers_enabled(struct repository *r)

{

uint32_t first_generation;

struct commit_graph *g;

if (!prepare_commit_graph(r))

return 0;

g = r->objects->commit_graph;

if (!g->num_commits)

return 0;

first_generation = get_be32(g->chunk_commit_data +

g->hash_len + 8) >> 2;

return !!first_generation;

}

int corrected_commit_dates_enabled(struct repository *r)

{

struct commit_graph *g;

if (!prepare_commit_graph(r))

return 0;

g = r->objects->commit_graph;

if (!g->num_commits)

return 0;

return g->read_generation_data;

}

struct bloom_filter_settings *get_bloom_filter_settings(struct repository *r)

{

struct commit_graph *g = r->objects->commit_graph;

while (g) {

if (g->bloom_filter_settings)

return g->bloom_filter_settings;

g = g->base_graph;

}

return NULL;

}

static void close_commit_graph_one(struct commit_graph *g)

{

if (!g)

return;

clear_commit_graph_data_slab(&commit_graph_data_slab);

close_commit_graph_one(g->base_graph);

free_commit_graph(g);

}

void close_commit_graph(struct raw_object_store *o)

{

close_commit_graph_one(o->commit_graph);

o->commit_graph = NULL;

}

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,

g->chunk_oid_lookup, g->hash_len, pos);

}

static void load_oid_from_graph(struct commit_graph *g,

uint32_t pos,

struct object_id *oid)

{

uint32_t lex_index;

while (g && pos < g->num_commits_in_base)

g = g->base_graph;

if (!g)

BUG("NULL commit-graph");

if (pos >= g->num_commits + g->num_commits_in_base)

die(_("invalid commit position. commit-graph is likely corrupt"));

lex_index = pos - g->num_commits_in_base;

oidread(oid, g->chunk_oid_lookup + g->hash_len * lex_index);

}

static struct commit_list **insert_parent_or_die(struct repository *r,

struct commit_graph *g,

uint32_t pos,

struct commit_list **pptr)

{

struct commit *c;

struct object_id oid;

if (pos >= g->num_commits + g->num_commits_in_base)

die("invalid parent position %"PRIu32, pos);

load_oid_from_graph(g, pos, &oid);

c = lookup_commit(r, &oid);

if (!c)

die(_("could not find commit %s"), oid_to_hex(&oid));

commit_graph_data_at(c)->graph_pos = pos;

return &commit_list_insert(c, pptr)->next;

}

static void fill_commit_graph_info(struct commit *item, struct commit_graph *g, uint32_t pos)

{

const unsigned char *commit_data;

struct commit_graph_data *graph_data;

uint32_t lex_index, offset_pos;

uint64_t date_high, date_low, offset;

while (pos < g->num_commits_in_base)

g = g->base_graph;

if (pos >= g->num_commits + g->num_commits_in_base)

die(_("invalid commit position. commit-graph is likely corrupt"));

lex_index = pos - g->num_commits_in_base;

commit_data = g->chunk_commit_data + GRAPH_DATA_WIDTH * lex_index;

graph_data = commit_graph_data_at(item);

graph_data->graph_pos = pos;

date_high = get_be32(commit_data + g->hash_len + 8) & 0x3;

date_low = get_be32(commit_data + g->hash_len + 12);

item->date = (timestamp_t)((date_high << 32) | date_low);

if (g->read_generation_data) {

offset = (timestamp_t)get_be32(g->chunk_generation_data + sizeof(uint32_t) * lex_index);

if (offset & CORRECTED_COMMIT_DATE_OFFSET_OVERFLOW) {

if (!g->chunk_generation_data_overflow)

die(_("commit-graph requires overflow generation data but has none"));

offset_pos = offset ^ CORRECTED_COMMIT_DATE_OFFSET_OVERFLOW;

graph_data->generation = get_be64(g->chunk_generation_data_overflow + 8 * offset_pos);

} else

graph_data->generation = item->date + offset;

} else

graph_data->generation = get_be32(commit_data + g->hash_len + 8) >> 2;

if (g->topo_levels)

*topo_level_slab_at(g->topo_levels, item) = get_be32(commit_data + g->hash_len + 8) >> 2;

}

static inline void set_commit_tree(struct commit *c, struct tree *t)

{

c->maybe_tree = t;

}

static int fill_commit_in_graph(struct repository *r,

struct commit *item,

struct commit_graph *g, uint32_t pos)

{

uint32_t edge_value;

uint32_t *parent_data_ptr;

struct commit_list **pptr;

const unsigned char *commit_data;

uint32_t lex_index;

while (pos < g->num_commits_in_base)

g = g->base_graph;

fill_commit_graph_info(item, g, pos);

lex_index = pos - g->num_commits_in_base;

commit_data = g->chunk_commit_data + (g->hash_len + 16) * lex_index;

item->object.parsed = 1;

set_commit_tree(item, NULL);

pptr = &item->parents;

edge_value = get_be32(commit_data + g->hash_len);

if (edge_value == GRAPH_PARENT_NONE)

return 1;

pptr = insert_parent_or_die(r, g, edge_value, pptr);

edge_value = get_be32(commit_data + g->hash_len + 4);

if (edge_value == GRAPH_PARENT_NONE)

return 1;

if (!(edge_value & GRAPH_EXTRA_EDGES_NEEDED)) {

pptr = insert_parent_or_die(r, g, edge_value, pptr);

return 1;

}

parent_data_ptr = (uint32_t*)(g->chunk_extra_edges +

4 * (uint64_t)(edge_value & GRAPH_EDGE_LAST_MASK));

do {

edge_value = get_be32(parent_data_ptr);

pptr = insert_parent_or_die(r, g,

edge_value & GRAPH_EDGE_LAST_MASK,

pptr);

parent_data_ptr++;

} while (!(edge_value & GRAPH_LAST_EDGE));

return 1;

}

static int search_commit_pos_in_graph(const struct object_id *id, struct commit_graph *g, uint32_t *pos)

{

struct commit_graph *cur_g = g;

uint32_t lex_index;

while (cur_g && !bsearch_graph(cur_g, id, &lex_index))

cur_g = cur_g->base_graph;

if (cur_g) {

*pos = lex_index + cur_g->num_commits_in_base;

return 1;

}

return 0;

}

static int find_commit_pos_in_graph(struct commit *item, struct commit_graph *g, uint32_t *pos)

{

uint32_t graph_pos = commit_graph_position(item);

if (graph_pos != COMMIT_NOT_FROM_GRAPH) {

*pos = graph_pos;

return 1;

} else {

return search_commit_pos_in_graph(&item->object.oid, g, pos);

}

}

struct commit *lookup_commit_in_graph(struct repository *repo, const struct object_id *id)

{

struct commit *commit;

uint32_t pos;

if (!repo->objects->commit_graph)

return NULL;

if (!search_commit_pos_in_graph(id, repo->objects->commit_graph, &pos))

return NULL;

if (!repo_has_object_file(repo, id))

return NULL;

commit = lookup_commit(repo, id);

if (!commit)

return NULL;

if (commit->object.parsed)

return commit;

if (!fill_commit_in_graph(repo, commit, repo->objects->commit_graph, pos))

return NULL;

return commit;

}

static int parse_commit_in_graph_one(struct repository *r,

struct commit_graph *g,

struct commit *item)

{

uint32_t pos;

if (item->object.parsed)

return 1;

if (find_commit_pos_in_graph(item, g, &pos))

return fill_commit_in_graph(r, item, g, pos);

return 0;

}

int parse_commit_in_graph(struct repository *r, struct commit *item)

{

static int checked_env = 0;

if (!checked_env &&

git_env_bool(GIT_TEST_COMMIT_GRAPH_DIE_ON_PARSE, 0))

die("dying as requested by the '%s' variable on commit-graph parse!",

GIT_TEST_COMMIT_GRAPH_DIE_ON_PARSE);

checked_env = 1;

if (!prepare_commit_graph(r))

return 0;

return parse_commit_in_graph_one(r, r->objects->commit_graph, item);

}

void load_commit_graph_info(struct repository *r, struct commit *item)

{

uint32_t pos;

if (!prepare_commit_graph(r))

return;

if (find_commit_pos_in_graph(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,

struct commit_graph *g,

struct commit *c)

{

struct object_id oid;

const unsigned char *commit_data;

uint32_t graph_pos = commit_graph_position(c);

while (graph_pos < g->num_commits_in_base)

g = g->base_graph;

commit_data = g->chunk_commit_data +

GRAPH_DATA_WIDTH * (graph_pos - g->num_commits_in_base);

oidread(&oid, commit_data);

set_commit_tree(c, lookup_tree(r, &oid));

return c->maybe_tree;

}

static struct tree *get_commit_tree_in_graph_one(struct repository *r,

struct commit_graph *g,

const struct commit *c)

{

if (c->maybe_tree)

return c->maybe_tree;

if (commit_graph_position(c) == COMMIT_NOT_FROM_GRAPH)

BUG("get_commit_tree_in_graph_one called from non-commit-graph commit");

return load_tree_for_commit(r, g, (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);

}

struct packed_commit_list {

};