struct repository *repo UNUSED)

{

struct commit_graph *graph = NULL;

char *graph_name;

char *chain_name;

enum { OPENED_NONE, OPENED_GRAPH, OPENED_CHAIN } opened = OPENED_NONE;

if (opts.progress)

flags |= COMMIT_GRAPH_WRITE_PROGRESS;

if (open_commit_graph(graph_name, &fd, &st))

opened = OPENED_GRAPH;

else if (errno != ENOENT)

if (opened == OPENED_NONE)

return 0;

else if (opened == OPENED_GRAPH)

else

graph = load_commit_graph_chain_fd_st(the_repository, fd, &st,

&incomplete_chain);

struct string_list pack_indexes = STRING_LIST_INIT_DUP;

struct strbuf buf = STRBUF_INIT;

struct oidset commits = OIDSET_INIT;

int result = 0;

enum commit_graph_write_flags flags = 0;

struct progress *progress = NULL;

git_env_bool(GIT_TEST_COMMIT_GRAPH_CHANGED_PATHS, 0))

flags |= COMMIT_GRAPH_WRITE_BLOOM_FILTERS;

if (opts.reachable) {

result = 1;

goto cleanup;

}

stop_progress(&progress);

}

opts.stdin_packs ? &pack_indexes : NULL,

opts.stdin_commits ? &commits : NULL,

flags,

return 0;

}

{

printf("alternate: ");

putchar('\n');

return 0;

}

commit_graph_flags |= COMMIT_GRAPH_WRITE_PROGRESS;

trace2_region_enter("fetch", "write-commit-graph", the_repository);

commit_graph_flags,

NULL);

trace2_region_leave("fetch", "write-commit-graph", the_repository);

struct repository *repo UNUSED)

{

int i;

/* fsck knows how to handle missing promisor objects */

fetch_if_missing = 0;

mark_packed_for_connectivity, NULL, 0);

} else {

prepare_alt_odb(the_repository);

if (check_full) {

struct packed_git *p;

struct child_process commit_graph_verify = CHILD_PROCESS_INIT;

prepare_alt_odb(the_repository);

child_process_init(&commit_graph_verify);

commit_graph_verify.git_cmd = 1;

strvec_pushl(&commit_graph_verify.args, "commit-graph",

if (show_progress)

strvec_push(&commit_graph_verify.args, "--progress");

else

struct child_process midx_verify = CHILD_PROCESS_INIT;

prepare_alt_odb(the_repository);

child_process_init(&midx_verify);

midx_verify.git_cmd = 1;

strvec_pushl(&midx_verify.args, "multi-pack-index",

if (show_progress)

strvec_push(&midx_verify.args, "--progress");

else

}

if (the_repository->settings.gc_write_commit_graph == 1)

!quiet && !daemonized ? COMMIT_GRAPH_WRITE_PROGRESS : 0,

NULL);

if (loose_object_auto_limit < 0)

return 1;

loose_object_count,

NULL, NULL, &count);

}

* Do not start pack-objects process

* if there are no loose objects.

*/

bail_on_loose,

NULL, NULL, NULL))

return 0;

strvec_push(&pack_proc.args, "--quiet");

else

strvec_push(&pack_proc.args, "--no-quiet");

pack_proc.in = -1;

else if (data.batch_size > 0)

data.batch_size--; /* Decrease for equality on limit. */

write_loose_object_to_stdin,

NULL,

NULL,

int result = 0;

struct lock_file lk;

struct repository *r = the_repository;

if (hold_lock_file_for_update(&lk, lock_path, LOCK_NO_DEREF) < 0) {

/*

unsigned int i;

int result = 0;

struct lock_file lk;

if (hold_lock_file_for_update(&lk, lock_path, LOCK_NO_DEREF) < 0) {

if (errno == EEXIST)

* lazily registered as alternates when needed (and except in an

* unexpected code interaction, it won't be needed).

*/

obj_read_unlock();

memcpy(&subopt, opt, sizeof(subopt));

if (the_repository &&

the_repository->objects &&

argc = parse_options(argc, argv, prefix, options,

builtin_multi_pack_index_usage, 0);

);

static int add_possible_reference_from_superproject(

{

struct submodule_alternate_setup *sas = sas_cb;

size_t len;

* If the alternate object store is another repository, try the

* standard layout with .git/(modules/<name>)+/objects

*/

struct repository alternate;

char *sm_alternate;

struct strbuf sb = STRBUF_INIT;

struct strbuf err = STRBUF_INIT;

if (repo_init(&alternate, sb.buf, NULL) < 0)

die(_("could not get a repository handle for gitdir '%s'"),

.quiet = 1,

};

return error(_("need a repository to verify a bundle"));

for (i = 0; i < p->nr; i++) {

if (git_env_bool(GIT_TEST_COMMIT_GRAPH_CHANGED_PATHS, 0))

flags = COMMIT_GRAPH_WRITE_BLOOM_FILTERS;

flags, NULL))

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

}

return 0;

}

{

}

const char *oid_hex)

{

oid_hex);

}

{

}

static struct commit_graph *alloc_commit_graph(void)

struct commit_graph *load_commit_graph_one_fd_st(struct repository *r,

int fd, struct stat *st,

{

void *graph_map;

size_t graph_size;

ret = parse_commit_graph(&r->settings, graph_map, graph_size);

if (ret)

else

munmap(graph_map, graph_size);

static struct commit_graph *load_commit_graph_one(struct repository *r,

const char *graph_file,

{

struct stat st;

if (!open_ok)

return NULL;

if (g)

g->filename = xstrdup(graph_file);

}

static struct commit_graph *load_commit_graph_v1(struct repository *r,

{

free(graph_name);

return g;

prepare_alt_odb(r);

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

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

break;

}

valid = 0;

free(graph_name);

}

static struct commit_graph *load_commit_graph_chain(struct repository *r,

{

struct stat st;

int fd;

struct commit_graph *g = NULL;

}

struct commit_graph *read_commit_graph_one(struct repository *r,

{

if (!g)

return g;

}

static void prepare_commit_graph_one(struct repository *r,

{

if (r->objects->commit_graph)

return;

}

/*

*/

static int prepare_commit_graph(struct repository *r)

{

/*

* Early return if there is no git dir or if the commit graph is

return 0;

prepare_alt_odb(r);

return !!r->objects->commit_graph;

}

struct write_commit_graph_context {

struct repository *r;

char *graph_name;

struct oid_array oids;

struct packed_commit_list commits;

return 0;

}

enum commit_graph_write_flags flags,

const struct commit_graph_opts *opts)

{

stop_progress(&data.progress);

flags, opts);

oidset_clear(&commits);

int dirlen;

int ret = 0;

dirlen = packname.len;

if (ctx->report_progress) {

strbuf_addf(&progress_title,

strbuf_addf(&tmp_file,

"%s/info/commit-graphs/tmp_graph_XXXXXX",

ctx->graph_name = strbuf_detach(&tmp_file, NULL);

} else {

}

if (safe_create_leading_directories(the_repository, ctx->graph_name)) {

}

if (ctx->split) {

hold_lock_file_for_update_mode(&lk, lock_name,

LOCK_DIE_ON_ERROR, 0444);

if (ctx->split && ctx->base_graph_name && ctx->num_commit_graphs_after > 1) {

char *new_base_hash = xstrdup(oid_to_hex(&ctx->new_base_graph->oid));

free(ctx->commit_graph_filenames_after[ctx->num_commit_graphs_after - 2]);

free(ctx->commit_graph_hash_after[ctx->num_commit_graphs_after - 2]);

}

}

} else {

unlink(graph_name);

free(graph_name);

}

free(ctx->commit_graph_hash_after[ctx->num_commit_graphs_after - 1]);

ctx->commit_graph_hash_after[ctx->num_commit_graphs_after - 1] = xstrdup(hash_to_hex(file_hash));

ctx->commit_graph_hash_after[ctx->num_commit_graphs_after - 1]);

free(ctx->commit_graph_filenames_after[ctx->num_commit_graphs_after - 1]);

ctx->commit_graph_filenames_after[ctx->num_commit_graphs_after - 1] = final_graph_name;

flags != COMMIT_GRAPH_SPLIT_REPLACE) {

while (g && (g->num_commits <= st_mult(size_mult, num_commits) ||

(max_commits && num_commits > max_commits))) {

break;

if (unsigned_add_overflows(num_commits, g->num_commits))

"should be 1 with --split=replace");

if (ctx->num_commit_graphs_after == 2) {

if (!strcmp(g->filename, old_graph_name) &&

ctx->num_commit_graphs_after = 1;

ctx->new_base_graph = NULL;

}

if (ctx->opts && ctx->opts->expire_time)

expire_time = ctx->opts->expire_time;

if (!ctx->split) {

unlink(chain_file_name);

free(chain_file_name);

ctx->num_commit_graphs_after = 0;

}

strbuf_addstr(&path, "/info/commit-graphs");

dir = opendir(path.buf);

strbuf_release(&path);

}

const struct string_list *const pack_indexes,

struct oidset *commits,

enum commit_graph_write_flags flags,

struct repository *r = the_repository;

struct write_commit_graph_context ctx = {

.r = r,

.append = flags & COMMIT_GRAPH_WRITE_APPEND ? 1 : 0,

.report_progress = flags & COMMIT_GRAPH_WRITE_PROGRESS ? 1 : 0,

.split = flags & COMMIT_GRAPH_WRITE_SPLIT ? 1 : 0,

struct object_database;

struct string_list;

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

uint32_t num_commits;

struct object_id oid;

char *filename;

uint32_t num_commits_in_base;

unsigned int read_generation_data;

struct commit_graph *load_commit_graph_one_fd_st(struct repository *r,

int fd, struct stat *st,

struct commit_graph *load_commit_graph_chain_fd_st(struct repository *r,

int fd, struct stat *st,

int *incomplete_chain);

struct commit_graph *read_commit_graph_one(struct repository *r,

struct repo_settings;

* is not compatible with the commit-graph feature, then the

* methods will return 0 without writing a commit-graph.

*/

enum commit_graph_write_flags flags,

const struct commit_graph_opts *opts);

const struct string_list *pack_indexes,

struct oidset *commits,

enum commit_graph_write_flags flags,

(uintmax_t)st.st_size);

}

{

struct strbuf *buf = data;

data);

return 0;

strbuf_reset(&buf);

strbuf_addstr(&buf, "--add-virtual-file=packs-local.txt:");

foreach_alt_odb(dir_file_stats, &buf);

strvec_push(&archiver_args, buf.buf);

ret = error("File %s has bad hash", hex);

} else if (req->rename < 0) {

struct strbuf buf = STRBUF_INIT;

ret = error("unable to write sha1 filename %s", buf.buf);

strbuf_release(&buf);

}

oidcpy(&freq->oid, oid);

freq->localfile = -1;

strbuf_addf(&freq->tmpfile, "%s.temp", filename.buf);

strbuf_addf(&prevfile, "%s.prev", filename.buf);

unlink_or_warn(freq->tmpfile.buf);

return -1;

}

freq->rename = finalize_object_file(freq->tmpfile.buf, filename.buf);

strbuf_release(&filename);

return 1;

}

const struct object_id *oid,

const struct object_id *compat_oid)

{

int inserted = 0;

inserted |= insert_oid_pair(map->to_compat, oid, compat_oid);

inserted |= insert_oid_pair(map->to_storage, compat_oid, oid);

if (inserted)

return inserted;

}

{

struct strbuf buf = STRBUF_INIT, path = STRBUF_INIT;

FILE *fp;

}

repo_common_path_replace(repo, &path, "objects/loose-object-idx");

fp = fopen(path.buf, "rb");

parse_oid_hex_algop(p, &compat_oid, &p, repo->compat_hash_algo) ||

p != buf.buf + buf.len)

goto err;

}

strbuf_release(&buf);

int repo_read_loose_object_map(struct repository *repo)

{

if (!should_use_loose_object_map(repo))

return 0;

prepare_alt_odb(repo);

return -1;

}

}

int repo_write_loose_object_map(struct repository *repo)

{

struct lock_file lock;

int fd;

khiter_t iter;

if (!should_use_loose_object_map(repo))

return 0;

if (inserted)

return write_one_object(repo, oid, compat_oid);

return 0;

const struct git_hash_algo *to,

struct object_id *dest)

{

kh_oid_map_t *map;

khiter_t pos;

if (!loose_map)

continue;

map = (to == repo->compat_hash_algo) ?

{

struct strbuf midx = STRBUF_INIT;

if (r->objects && r->objects->multi_pack_index) {

close_midx(r->objects->multi_pack_index);

if (remove_path(midx.buf))

die(_("failed to clear multi-pack-index at %s"), midx.buf);

strbuf_release(&midx);

}

}

}

struct strbuf *buf,

const struct object_id *oid)

{

strbuf_reset(buf);

strbuf_addch(buf, '/');

fill_loose_path(buf, oid);

return buf->buf;

return 1;

}

const struct object_id *oid,

int freshen)

{

static struct strbuf path = STRBUF_INIT;

return check_and_freshen_file(path.buf, freshen);

}

static int check_and_freshen_local(const struct object_id *oid, int freshen)

{

}

static int check_and_freshen_nonlocal(const struct object_id *oid, int freshen)

{

prepare_alt_odb(the_repository);

return 1;

}

return 0;

static int stat_loose_object(struct repository *r, const struct object_id *oid,

struct stat *st, const char **path)

{

static struct strbuf buf = STRBUF_INIT;

prepare_alt_odb(r);

if (!lstat(*path, st))

return 0;

}

const struct object_id *oid, const char **path)

{

int fd;

int most_interesting_errno = ENOENT;

static struct strbuf buf = STRBUF_INIT;

prepare_alt_odb(r);

fd = git_open(*path);

if (fd >= 0)

return fd;

static int quick_has_loose(struct repository *r,

const struct object_id *oid)

{

prepare_alt_odb(r);

return 1;

}

return 0;

/* Finalize a file on disk, and close it. */

static void close_loose_object(int fd, const char *filename)

{

goto out;

if (batch_fsync_enabled(FSYNC_COMPONENT_LOOSE_OBJECT))

if (batch_fsync_enabled(FSYNC_COMPONENT_LOOSE_OBJECT))

prepare_loose_object_bulk_checkin();

fd = start_loose_object_common(&tmp_file, filename.buf, flags,

&stream, compressed, sizeof(compressed),

goto cleanup;

}

/* We finally know the object path, and create the missing dir. */

dirlen = directory_size(filename.buf);

int for_each_loose_object(each_loose_object_fn cb, void *data,

enum for_each_object_flags flags)

{

prepare_alt_odb(the_repository);

NULL, data);

if (r)

return r;

return 0;

}

{

int subdir_nr = oid->hash[0];

struct strbuf buf = STRBUF_INIT;

size_t word_index = subdir_nr / word_bits;

size_t mask = (size_t)1u << (subdir_nr % word_bits);

uint32_t *bitmap;

if (subdir_nr < 0 ||

BUG("subdir_nr out of range");

if (*bitmap & mask)

}

for_each_file_in_obj_subdir(subdir_nr, &buf,

append_loose_object,

NULL, NULL,

*bitmap |= mask;

strbuf_release(&buf);

}

{

}

static int check_stream_oid(git_zstream *stream,

int index_fd(struct index_state *istate, struct object_id *oid, int fd, struct stat *st, enum object_type type, const char *path, unsigned flags);

int index_path(struct index_state *istate, struct object_id *oid, const char *path, struct stat *st, unsigned flags);

/*

* Populate and return the loose object cache array corresponding to the

* given object ID.

*/

const struct object_id *oid);

/* Empty the loose object cache for the specified object directory. */

/*

* Put in `buf` the name of the file in the local object database that

* would be used to store a loose object with the specified oid.

*/

struct strbuf *buf,

const struct object_id *oid);

static void find_short_object_filename(struct disambiguate_state *ds)

{

&ds->bin_pfx, ds->len, match_prefix, ds);

}

#include "write-or-die.h"

KHASH_INIT(odb_path_map, const char * /* key: odb_path */,

/*

* This is meant to hold a *small* number of objects that you would

* Prevent the common mistake of listing the same

* thing twice, or object directory itself.

*/

khiter_t p;

assert(r == 1); /* never used */

}

if (fspatheq(path->buf, normalized_objdir))

return 0;

/* r: 0 = exists, 1 = never used, 2 = deleted */

return r == 0 ? 0 : 1;

}

* Prepare alternate object database registry.

*

* The variable alt_odb_list points at the list of struct

* non-empty elements from colon separated ALTERNATE_DB_ENVIRONMENT

* environment variable, and $GIT_OBJECT_DIRECTORY/info/alternates,

* whose contents is similar to that environment variable but can be

static int link_alt_odb_entry(struct repository *r, const struct strbuf *entry,

const char *relative_base, int depth, const char *normalized_objdir)

{

struct strbuf pathbuf = STRBUF_INIT;

struct strbuf tmp = STRBUF_INIT;

khiter_t pos;

if (!alt_odb_usable(r->objects, &pathbuf, normalized_objdir, &pos))

goto error;

/* add the alternate entry */

/* recursively add alternates */

ret = 0;

error:

strbuf_release(&tmp);

return;

}

while (*alt) {

alt = parse_alt_odb_entry(alt, sep, &entry);

'\n', NULL, 0);

}

{

/*

* Make sure alternates are initialized, or else our entry may be

* Make a new primary odb and link the old primary ODB in as an

* alternate

*/

/*

* Disable ref updates while a temporary odb is active, since

* the objects in the database may roll back.

*/

}

{

}

{

BUG("expected %s as primary object store; found %s",

BUG("we expect the old primary object store to be the first alternate");

}

/*

return ref_git;

}

{

char *obj_dir_real = real_pathdup(obj_dir, 1);

struct strbuf odb_path_real = STRBUF_INIT;

prepare_alt_odb(r);

if (!strcmp(obj_dir_real, odb_path_real.buf))

break;

}

free(obj_dir_real);

strbuf_release(&odb_path_real);

die(_("could not find object directory matching %s"), obj_dir);

}

static void fill_alternate_refs_command(struct child_process *cmd,

void *data;

};

void *data)

{

struct strbuf path = STRBUF_INIT;

size_t base_len;

struct alternate_refs_data *cb = data;

goto out;

if (!strbuf_strip_suffix(&path, "/objects"))

goto out;

int foreach_alt_odb(alt_odb_fn fn, void *cb)

{

int r = 0;

prepare_alt_odb(the_repository);

if (r)

break;

}

link_alt_odb_entries(r, r->objects->alternate_db, PATH_SEP, NULL, 0);

r->objects->loaded_alternates = 1;

}

int has_alt_odb(struct repository *r)

{

prepare_alt_odb(r);

}

int obj_read_use_lock = 0;

static void free_object_directories(struct object_database *o)

{

}

}

void odb_clear(struct object_database *o)

o->commit_graph_attempted = 0;

free_object_directories(o);

o->loaded_alternates = 0;

for (size_t i = 0; i < o->cached_object_nr; i++)

struct strbuf;

struct repository;

/*

* Used to store the results of readdir(3) calls when we are OK

int will_destroy;

/*

*/

char *path;

};

void prepare_alt_odb(struct repository *r);

int has_alt_odb(struct repository *r);

char *compute_alternate_path(const char *path, struct strbuf *err);

int foreach_alt_odb(alt_odb_fn, void*);

typedef void alternate_ref_fn(const struct object_id *oid, void *);

void for_each_alternate_ref(alternate_ref_fn, void *);

* Replace the current writable object directory with the specified temporary

* object directory; returns the former primary object directory.

*/

/*

* Restore a previous ODB replaced by set_temporary_main_odb.

*/

struct packed_git;

struct multi_pack_index;

/*

* The object database encapsulates access to objects in a repository. It

* configured via alternates.

*/

struct object_database {

* cannot be NULL after initialization). Subsequent directories are

* alternates.

*/

int loaded_alternates;

/*

* A list of alternate object directories loaded from the environment;

* this should not generally need to be accessed directly, but will

*/

char *alternate_db;

static void prepare_packed_git(struct repository *r)

{

if (r->objects->packed_git_initialized)

return;

prepare_alt_odb(r);

}

rearrange_packed_git(r);

void reprepare_packed_git(struct repository *r)

{

obj_read_lock();

r->objects->loaded_alternates = 0;

prepare_alt_odb(r);

r->objects->approximate_object_count_valid = 0;

r->objects->packed_git_initialized = 0;

strbuf_splice(buf, 0, buf->len,

repo->index_file, strlen(repo->index_file));

else if (dir_prefix(base, "objects"))

else if (repo_settings_get_hooks_path(repo) && dir_prefix(base, "hooks"))

replace_dir(buf, git_dir_len + 5, repo_settings_get_hooks_path(repo));

else if (repo->different_commondir)

break;

}

strbuf_addstr(err,

_("ref updates forbidden inside quarantine environment"));

return -1;

const char *repo_get_object_directory(struct repository *repo)

{

BUG("repository hasn't been set up");

}

const char *repo_get_index_file(struct repository *repo)

repo_set_commondir(repo, o->commondir);

}

repo->commondir, "objects");

free(repo->objects->alternate_db);

repo->objects->alternate_db = xstrdup_or_null(o->alternate_db);

repo_get_oid(repo, GITMODULES_HEAD, &oid) >= 0) {

config_source.blob = oidstr = xstrdup(oid_to_hex(&oid));

if (repo != the_repository)

} else {

goto out;

}

int cmd__read_graph(int argc, const char **argv)

{

struct commit_graph *graph = NULL;

int ret = 0;

setup_git_directory();

prepare_repo_settings(the_repository);

if (!graph) {

ret = 1;

goto done;

struct repository *repo;

struct strbuf path;

struct strvec env;

int will_destroy;

};

if (t == the_tmp_objdir)

the_tmp_objdir = NULL;

err = remove_dir_recursively(&t->path, 0);

if (!t)

return 0;

BUG("migrating an ODB that was marked for destruction");

}

strbuf_addbuf(&src, &t->path);

void tmp_objdir_replace_primary_odb(struct tmp_objdir *t, int will_destroy)

{

BUG("the primary object database is already replaced");

t->will_destroy = will_destroy;

}

struct tmp_objdir *tmp_objdir_unapply_primary_odb(void)

{

return NULL;

return the_tmp_objdir;

}