From: Junio C Hamano <gitster@pobox.com>
Date: Tue, 9 Jul 2019 22:25:36 +0000 (-0700)
Subject: Merge branch 'ds/commit-graph-write-refactor'
X-Git-Tag: v2.23.0-rc0~86
X-Git-Url: https://git.lorimer.id.au/gitweb.git/diff_plain/e1168940ce11878261ece4602a7d8b8ee9a8c77e?hp=-c

Merge branch 'ds/commit-graph-write-refactor'

Renamed from commit-graph-format-v2 and changed scope.

* ds/commit-graph-write-refactor:
commit-graph: extract write_commit_graph_file()
commit-graph: extract copy_oids_to_commits()
commit-graph: extract count_distinct_commits()
commit-graph: extract fill_oids_from_all_packs()
commit-graph: extract fill_oids_from_commit_hex()
commit-graph: extract fill_oids_from_packs()
commit-graph: create write_commit_graph_context
commit-graph: remove Future Work section
commit-graph: collapse parameters into flags
commit-graph: return with errors during write
commit-graph: fix the_repository reference
---

e1168940ce11878261ece4602a7d8b8ee9a8c77e
diff --combined builtin/commit.c
index 1c9e8e2228,b001ef565d..1921401117
--- a/builtin/commit.c
+++ b/builtin/commit.c
@@@ -235,7 -235,7 +235,7 @@@ static int commit_index_files(void
   * and return the paths that match the given pattern in list.
   */
  static int list_paths(struct string_list *list, const char *with_tree,
 -		      const char *prefix, const struct pathspec *pattern)
 +		      const struct pathspec *pattern)
  {
  	int i, ret;
  	char *m;
@@@ -264,7 -264,7 +264,7 @@@
  			item->util = item; /* better a valid pointer than a fake one */
  	}
  
 -	ret = report_path_error(m, pattern, prefix);
 +	ret = report_path_error(m, pattern);
  	free(m);
  	return ret;
  }
@@@ -454,7 -454,7 +454,7 @@@ static const char *prepare_index(int ar
  			die(_("cannot do a partial commit during a cherry-pick."));
  	}
  
 -	if (list_paths(&partial, !current_head ? NULL : "HEAD", prefix, &pathspec))
 +	if (list_paths(&partial, !current_head ? NULL : "HEAD", &pathspec))
  		exit(1);
  
  	discard_cache();
@@@ -609,8 -609,7 +609,8 @@@ static void determine_author_info(struc
  		set_ident_var(&date, strbuf_detach(&date_buf, NULL));
  	}
  
 -	strbuf_addstr(author_ident, fmt_ident(name, email, date, IDENT_STRICT));
 +	strbuf_addstr(author_ident, fmt_ident(name, email, WANT_AUTHOR_IDENT, date,
 +				IDENT_STRICT));
  	assert_split_ident(&author, author_ident);
  	export_one("GIT_AUTHOR_NAME", author.name_begin, author.name_end, 0);
  	export_one("GIT_AUTHOR_EMAIL", author.mail_begin, author.mail_end, 0);
@@@ -668,7 -667,6 +668,7 @@@ static int prepare_to_commit(const cha
  	const char *hook_arg2 = NULL;
  	int clean_message_contents = (cleanup_mode != COMMIT_MSG_CLEANUP_NONE);
  	int old_display_comment_prefix;
 +	int merge_contains_scissors = 0;
  
  	/* This checks and barfs if author is badly specified */
  	determine_author_info(author_ident);
@@@ -729,8 -727,6 +729,8 @@@
  			strbuf_addbuf(&sb, &message);
  		hook_arg1 = "message";
  	} else if (!stat(git_path_merge_msg(the_repository), &statbuf)) {
 +		size_t merge_msg_start;
 +
  		/*
  		 * prepend SQUASH_MSG here if it exists and a
  		 * "merge --squash" was originally performed
@@@ -741,16 -737,8 +741,16 @@@
  			hook_arg1 = "squash";
  		} else
  			hook_arg1 = "merge";
 +
 +		merge_msg_start = sb.len;
  		if (strbuf_read_file(&sb, git_path_merge_msg(the_repository), 0) < 0)
  			die_errno(_("could not read MERGE_MSG"));
 +
 +		if (cleanup_mode == COMMIT_MSG_CLEANUP_SCISSORS &&
 +		    wt_status_locate_end(sb.buf + merge_msg_start,
 +					 sb.len - merge_msg_start) <
 +				sb.len - merge_msg_start)
 +			merge_contains_scissors = 1;
  	} else if (!stat(git_path_squash_msg(the_repository), &statbuf)) {
  		if (strbuf_read_file(&sb, git_path_squash_msg(the_repository), 0) < 0)
  			die_errno(_("could not read SQUASH_MSG"));
@@@ -818,8 -806,7 +818,8 @@@
  		struct ident_split ci, ai;
  
  		if (whence != FROM_COMMIT) {
 -			if (cleanup_mode == COMMIT_MSG_CLEANUP_SCISSORS)
 +			if (cleanup_mode == COMMIT_MSG_CLEANUP_SCISSORS &&
 +				!merge_contains_scissors)
  				wt_status_add_cut_line(s->fp);
  			status_printf_ln(s, GIT_COLOR_NORMAL,
  			    whence == FROM_MERGE
@@@ -844,10 -831,10 +844,10 @@@
  				_("Please enter the commit message for your changes."
  				  " Lines starting\nwith '%c' will be ignored, and an empty"
  				  " message aborts the commit.\n"), comment_line_char);
 -		else if (cleanup_mode == COMMIT_MSG_CLEANUP_SCISSORS &&
 -			 whence == FROM_COMMIT)
 -			wt_status_add_cut_line(s->fp);
 -		else /* COMMIT_MSG_CLEANUP_SPACE, that is. */
 +		else if (cleanup_mode == COMMIT_MSG_CLEANUP_SCISSORS) {
 +			if (whence == FROM_COMMIT && !merge_contains_scissors)
 +				wt_status_add_cut_line(s->fp);
 +		} else /* COMMIT_MSG_CLEANUP_SPACE, that is. */
  			status_printf(s, GIT_COLOR_NORMAL,
  				_("Please enter the commit message for your changes."
  				  " Lines starting\n"
@@@ -1051,10 -1038,6 +1051,10 @@@ static void handle_untracked_files_arg(
  		s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
  	else if (!strcmp(untracked_files_arg, "all"))
  		s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
 +	/*
 +	 * Please update $__git_untracked_file_modes in
 +	 * git-completion.bash when you add new options
 +	 */
  	else
  		die(_("Invalid untracked files mode '%s'"), untracked_files_arg);
  }
@@@ -1184,13 -1167,25 +1184,13 @@@ static int parse_and_validate_options(i
  		die(_("Only one of --include/--only/--all/--interactive/--patch can be used."));
  	if (argc == 0 && (also || (only && !amend && !allow_empty)))
  		die(_("No paths with --include/--only does not make sense."));
 -	if (!cleanup_arg || !strcmp(cleanup_arg, "default"))
 -		cleanup_mode = use_editor ? COMMIT_MSG_CLEANUP_ALL :
 -					    COMMIT_MSG_CLEANUP_SPACE;
 -	else if (!strcmp(cleanup_arg, "verbatim"))
 -		cleanup_mode = COMMIT_MSG_CLEANUP_NONE;
 -	else if (!strcmp(cleanup_arg, "whitespace"))
 -		cleanup_mode = COMMIT_MSG_CLEANUP_SPACE;
 -	else if (!strcmp(cleanup_arg, "strip"))
 -		cleanup_mode = COMMIT_MSG_CLEANUP_ALL;
 -	else if (!strcmp(cleanup_arg, "scissors"))
 -		cleanup_mode = use_editor ? COMMIT_MSG_CLEANUP_SCISSORS :
 -					    COMMIT_MSG_CLEANUP_SPACE;
 -	else
 -		die(_("Invalid cleanup mode %s"), cleanup_arg);
 +	cleanup_mode = get_cleanup_mode(cleanup_arg, use_editor);
  
  	handle_untracked_files_arg(s);
  
  	if (all && argc > 0)
 -		die(_("Paths with -a does not make sense."));
 +		die(_("paths '%s ...' with -a does not make sense"),
 +		    argv[0]);
  
  	if (status_format != STATUS_FORMAT_NONE)
  		dry_run = 1;
@@@ -1486,7 -1481,7 +1486,7 @@@ int cmd_commit(int argc, const char **a
  		OPT_BOOL('s', "signoff", &signoff, N_("add Signed-off-by:")),
  		OPT_FILENAME('t', "template", &template_file, N_("use specified template file")),
  		OPT_BOOL('e', "edit", &edit_flag, N_("force edit of commit")),
 -		OPT_STRING(0, "cleanup", &cleanup_arg, N_("default"), N_("how to strip spaces and #comments from message")),
 +		OPT_CLEANUP(&cleanup_arg),
  		OPT_BOOL(0, "status", &include_status, N_("include status in commit message template")),
  		{ OPTION_STRING, 'S', "gpg-sign", &sign_commit, N_("key-id"),
  		  N_("GPG sign commit"), PARSE_OPT_OPTARG, NULL, (intptr_t) "" },
@@@ -1622,7 -1617,11 +1622,7 @@@
  		die(_("could not read commit message: %s"), strerror(saved_errno));
  	}
  
 -	if (verbose || /* Truncate the message just before the diff, if any. */
 -	    cleanup_mode == COMMIT_MSG_CLEANUP_SCISSORS)
 -		strbuf_setlen(&sb, wt_status_locate_end(sb.buf, sb.len));
 -	if (cleanup_mode != COMMIT_MSG_CLEANUP_NONE)
 -		strbuf_stripspace(&sb, cleanup_mode == COMMIT_MSG_CLEANUP_ALL);
 +	cleanup_message(&sb, cleanup_mode, verbose);
  
  	if (message_is_empty(&sb, cleanup_mode) && !allow_empty_message) {
  		rollback_index_files();
@@@ -1658,7 -1657,8 +1658,7 @@@
  		die("%s", err.buf);
  	}
  
 -	unlink(git_path_cherry_pick_head(the_repository));
 -	unlink(git_path_revert_head(the_repository));
 +	sequencer_post_commit_cleanup(the_repository);
  	unlink(git_path_merge_head(the_repository));
  	unlink(git_path_merge_msg(the_repository));
  	unlink(git_path_merge_mode(the_repository));
@@@ -1669,8 -1669,9 +1669,9 @@@
  		      "new_index file. Check that disk is not full and quota is\n"
  		      "not exceeded, and then \"git reset HEAD\" to recover."));
  
- 	if (git_env_bool(GIT_TEST_COMMIT_GRAPH, 0))
- 		write_commit_graph_reachable(get_object_directory(), 0, 0);
+ 	if (git_env_bool(GIT_TEST_COMMIT_GRAPH, 0) &&
+ 	    write_commit_graph_reachable(get_object_directory(), 0))
+ 		return 1;
  
  	repo_rerere(the_repository, 0);
  	run_command_v_opt(argv_gc_auto, RUN_GIT_CMD);
diff --combined builtin/gc.c
index 8943bcc300,df2573f124..8ba9bd2472
--- a/builtin/gc.c
+++ b/builtin/gc.c
@@@ -116,19 -116,6 +116,19 @@@ static void process_log_file_on_signal(
  	raise(signo);
  }
  
 +static int gc_config_is_timestamp_never(const char *var)
 +{
 +	const char *value;
 +	timestamp_t expire;
 +
 +	if (!git_config_get_value(var, &value) && value) {
 +		if (parse_expiry_date(value, &expire))
 +			die(_("failed to parse '%s' value '%s'"), var, value);
 +		return expire == 0;
 +	}
 +	return 0;
 +}
 +
  static void gc_config(void)
  {
  	const char *value;
@@@ -140,10 -127,6 +140,10 @@@
  			pack_refs = git_config_bool("gc.packrefs", value);
  	}
  
 +	if (gc_config_is_timestamp_never("gc.reflogexpire") &&
 +	    gc_config_is_timestamp_never("gc.reflogexpireunreachable"))
 +		prune_reflogs = 0;
 +
  	git_config_get_int("gc.aggressivewindow", &aggressive_window);
  	git_config_get_int("gc.aggressivedepth", &aggressive_depth);
  	git_config_get_int("gc.auto", &gc_auto_threshold);
@@@ -173,7 -156,9 +173,7 @@@ static int too_many_loose_objects(void
  	int auto_threshold;
  	int num_loose = 0;
  	int needed = 0;
 -
 -	if (gc_auto_threshold <= 0)
 -		return 0;
 +	const unsigned hexsz_loose = the_hash_algo->hexsz - 2;
  
  	dir = opendir(git_path("objects/17"));
  	if (!dir)
@@@ -181,8 -166,8 +181,8 @@@
  
  	auto_threshold = DIV_ROUND_UP(gc_auto_threshold, 256);
  	while ((ent = readdir(dir)) != NULL) {
 -		if (strspn(ent->d_name, "0123456789abcdef") != 38 ||
 -		    ent->d_name[38] != '\0')
 +		if (strspn(ent->d_name, "0123456789abcdef") != hexsz_loose ||
 +		    ent->d_name[hexsz_loose] != '\0')
  			continue;
  		if (++num_loose > auto_threshold) {
  			needed = 1;
@@@ -506,20 -491,14 +506,20 @@@ done
  
  static void gc_before_repack(void)
  {
 +	/*
 +	 * We may be called twice, as both the pre- and
 +	 * post-daemonized phases will call us, but running these
 +	 * commands more than once is pointless and wasteful.
 +	 */
 +	static int done = 0;
 +	if (done++)
 +		return;
 +
  	if (pack_refs && run_command_v_opt(pack_refs_cmd.argv, RUN_GIT_CMD))
  		die(FAILED_RUN, pack_refs_cmd.argv[0]);
  
  	if (prune_reflogs && run_command_v_opt(reflog.argv, RUN_GIT_CMD))
  		die(FAILED_RUN, reflog.argv[0]);
 -
 -	pack_refs = 0;
 -	prune_reflogs = 0;
  }
  
  int cmd_gc(int argc, const char **argv, const char *prefix)
@@@ -685,9 -664,10 +685,10 @@@
  		clean_pack_garbage();
  	}
  
- 	if (gc_write_commit_graph)
- 		write_commit_graph_reachable(get_object_directory(), 0,
- 					     !quiet && !daemonized);
+ 	if (gc_write_commit_graph &&
+ 	    write_commit_graph_reachable(get_object_directory(),
+ 					 !quiet && !daemonized ? COMMIT_GRAPH_PROGRESS : 0))
+ 		return 1;
  
  	if (auto_gc && too_many_loose_objects())
  		warning(_("There are too many unreachable loose objects; "
diff --combined commit-graph.c
index 7c5e54875f,9d2c72f5b4..89c4b982dd
--- a/commit-graph.c
+++ b/commit-graph.c
@@@ -267,10 -267,8 +267,10 @@@ struct commit_graph *parse_commit_graph
  		last_chunk_offset = chunk_offset;
  	}
  
 -	if (verify_commit_graph_lite(graph))
 +	if (verify_commit_graph_lite(graph)) {
 +		free(graph);
  		return NULL;
 +	}
  
  	return graph;
  }
@@@ -399,11 -397,6 +399,11 @@@ static void fill_commit_graph_info(stru
  	item->generation = 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)
@@@ -417,7 -410,7 +417,7 @@@
  	item->object.parsed = 1;
  	item->graph_pos = pos;
  
 -	item->maybe_tree = NULL;
 +	set_commit_tree(item, NULL);
  
  	date_high = get_be32(commit_data + g->hash_len + 8) & 0x3;
  	date_low = get_be32(commit_data + g->hash_len + 12);
@@@ -503,7 -496,7 +503,7 @@@ static struct tree *load_tree_for_commi
  					   GRAPH_DATA_WIDTH * (c->graph_pos);
  
  	hashcpy(oid.hash, commit_data);
 -	c->maybe_tree = lookup_tree(r, &oid);
 +	set_commit_tree(c, lookup_tree(r, &oid));
  
  	return c->maybe_tree;
  }
@@@ -525,14 -518,38 +525,38 @@@ struct tree *get_commit_tree_in_graph(s
  	return get_commit_tree_in_graph_one(r, r->objects->commit_graph, c);
  }
  
+ struct packed_commit_list {
+ 	struct commit **list;
+ 	int nr;
+ 	int alloc;
+ };
+ 
+ struct packed_oid_list {
+ 	struct object_id *list;
+ 	int nr;
+ 	int alloc;
+ };
+ 
+ struct write_commit_graph_context {
+ 	struct repository *r;
+ 	const char *obj_dir;
+ 	char *graph_name;
+ 	struct packed_oid_list oids;
+ 	struct packed_commit_list commits;
+ 	int num_extra_edges;
+ 	unsigned long approx_nr_objects;
+ 	struct progress *progress;
+ 	int progress_done;
+ 	uint64_t progress_cnt;
+ 	unsigned append:1,
+ 		 report_progress:1;
+ };
+ 
  static void write_graph_chunk_fanout(struct hashfile *f,
- 				     struct commit **commits,
- 				     int nr_commits,
- 				     struct progress *progress,
- 				     uint64_t *progress_cnt)
+ 				     struct write_commit_graph_context *ctx)
  {
  	int i, count = 0;
- 	struct commit **list = commits;
+ 	struct commit **list = ctx->commits.list;
  
  	/*
  	 * Write the first-level table (the list is sorted,
@@@ -540,10 -557,10 +564,10 @@@
  	 * having to do eight extra binary search iterations).
  	 */
  	for (i = 0; i < 256; i++) {
- 		while (count < nr_commits) {
+ 		while (count < ctx->commits.nr) {
  			if ((*list)->object.oid.hash[0] != i)
  				break;
- 			display_progress(progress, ++*progress_cnt);
+ 			display_progress(ctx->progress, ++ctx->progress_cnt);
  			count++;
  			list++;
  		}
@@@ -553,14 -570,12 +577,12 @@@
  }
  
  static void write_graph_chunk_oids(struct hashfile *f, int hash_len,
- 				   struct commit **commits, int nr_commits,
- 				   struct progress *progress,
- 				   uint64_t *progress_cnt)
+ 				   struct write_commit_graph_context *ctx)
  {
- 	struct commit **list = commits;
+ 	struct commit **list = ctx->commits.list;
  	int count;
- 	for (count = 0; count < nr_commits; count++, list++) {
- 		display_progress(progress, ++*progress_cnt);
+ 	for (count = 0; count < ctx->commits.nr; count++, list++) {
+ 		display_progress(ctx->progress, ++ctx->progress_cnt);
  		hashwrite(f, (*list)->object.oid.hash, (int)hash_len);
  	}
  }
@@@ -572,19 -587,17 +594,17 @@@ static const unsigned char *commit_to_s
  }
  
  static void write_graph_chunk_data(struct hashfile *f, int hash_len,
- 				   struct commit **commits, int nr_commits,
- 				   struct progress *progress,
- 				   uint64_t *progress_cnt)
+ 				   struct write_commit_graph_context *ctx)
  {
- 	struct commit **list = commits;
- 	struct commit **last = commits + nr_commits;
+ 	struct commit **list = ctx->commits.list;
+ 	struct commit **last = ctx->commits.list + ctx->commits.nr;
  	uint32_t num_extra_edges = 0;
  
  	while (list < last) {
  		struct commit_list *parent;
  		int edge_value;
  		uint32_t packedDate[2];
- 		display_progress(progress, ++*progress_cnt);
+ 		display_progress(ctx->progress, ++ctx->progress_cnt);
  
  		parse_commit_no_graph(*list);
  		hashwrite(f, get_commit_tree_oid(*list)->hash, hash_len);
@@@ -595,8 -608,8 +615,8 @@@
  			edge_value = GRAPH_PARENT_NONE;
  		else {
  			edge_value = sha1_pos(parent->item->object.oid.hash,
- 					      commits,
- 					      nr_commits,
+ 					      ctx->commits.list,
+ 					      ctx->commits.nr,
  					      commit_to_sha1);
  
  			if (edge_value < 0)
@@@ -616,8 -629,8 +636,8 @@@
  			edge_value = GRAPH_EXTRA_EDGES_NEEDED | num_extra_edges;
  		else {
  			edge_value = sha1_pos(parent->item->object.oid.hash,
- 					      commits,
- 					      nr_commits,
+ 					      ctx->commits.list,
+ 					      ctx->commits.nr,
  					      commit_to_sha1);
  			if (edge_value < 0)
  				BUG("missing parent %s for commit %s",
@@@ -649,19 -662,16 +669,16 @@@
  }
  
  static void write_graph_chunk_extra_edges(struct hashfile *f,
- 					  struct commit **commits,
- 					  int nr_commits,
- 					  struct progress *progress,
- 					  uint64_t *progress_cnt)
+ 					  struct write_commit_graph_context *ctx)
  {
- 	struct commit **list = commits;
- 	struct commit **last = commits + nr_commits;
+ 	struct commit **list = ctx->commits.list;
+ 	struct commit **last = ctx->commits.list + ctx->commits.nr;
  	struct commit_list *parent;
  
  	while (list < last) {
  		int num_parents = 0;
  
- 		display_progress(progress, ++*progress_cnt);
+ 		display_progress(ctx->progress, ++ctx->progress_cnt);
  
  		for (parent = (*list)->parents; num_parents < 3 && parent;
  		     parent = parent->next)
@@@ -675,8 -685,8 +692,8 @@@
  		/* Since num_parents > 2, this initializer is safe. */
  		for (parent = (*list)->parents->next; parent; parent = parent->next) {
  			int edge_value = sha1_pos(parent->item->object.oid.hash,
- 						  commits,
- 						  nr_commits,
+ 						  ctx->commits.list,
+ 						  ctx->commits.nr,
  						  commit_to_sha1);
  
  			if (edge_value < 0)
@@@ -700,125 -710,111 +717,111 @@@ static int commit_compare(const void *_
  	return oidcmp(a, b);
  }
  
- struct packed_commit_list {
- 	struct commit **list;
- 	int nr;
- 	int alloc;
- };
- 
- struct packed_oid_list {
- 	struct object_id *list;
- 	int nr;
- 	int alloc;
- 	struct progress *progress;
- 	int progress_done;
- };
- 
  static int add_packed_commits(const struct object_id *oid,
  			      struct packed_git *pack,
  			      uint32_t pos,
  			      void *data)
  {
- 	struct packed_oid_list *list = (struct packed_oid_list*)data;
+ 	struct write_commit_graph_context *ctx = (struct write_commit_graph_context*)data;
  	enum object_type type;
  	off_t offset = nth_packed_object_offset(pack, pos);
  	struct object_info oi = OBJECT_INFO_INIT;
  
- 	if (list->progress)
- 		display_progress(list->progress, ++list->progress_done);
+ 	if (ctx->progress)
+ 		display_progress(ctx->progress, ++ctx->progress_done);
  
  	oi.typep = &type;
- 	if (packed_object_info(the_repository, pack, offset, &oi) < 0)
+ 	if (packed_object_info(ctx->r, pack, offset, &oi) < 0)
  		die(_("unable to get type of object %s"), oid_to_hex(oid));
  
  	if (type != OBJ_COMMIT)
  		return 0;
  
- 	ALLOC_GROW(list->list, list->nr + 1, list->alloc);
- 	oidcpy(&(list->list[list->nr]), oid);
- 	list->nr++;
+ 	ALLOC_GROW(ctx->oids.list, ctx->oids.nr + 1, ctx->oids.alloc);
+ 	oidcpy(&(ctx->oids.list[ctx->oids.nr]), oid);
+ 	ctx->oids.nr++;
  
  	return 0;
  }
  
- static void add_missing_parents(struct packed_oid_list *oids, struct commit *commit)
+ static void add_missing_parents(struct write_commit_graph_context *ctx, struct commit *commit)
  {
  	struct commit_list *parent;
  	for (parent = commit->parents; parent; parent = parent->next) {
  		if (!(parent->item->object.flags & UNINTERESTING)) {
- 			ALLOC_GROW(oids->list, oids->nr + 1, oids->alloc);
- 			oidcpy(&oids->list[oids->nr], &(parent->item->object.oid));
- 			oids->nr++;
+ 			ALLOC_GROW(ctx->oids.list, ctx->oids.nr + 1, ctx->oids.alloc);
+ 			oidcpy(&ctx->oids.list[ctx->oids.nr], &(parent->item->object.oid));
+ 			ctx->oids.nr++;
  			parent->item->object.flags |= UNINTERESTING;
  		}
  	}
  }
  
- static void close_reachable(struct packed_oid_list *oids, int report_progress)
+ static void close_reachable(struct write_commit_graph_context *ctx)
  {
  	int i;
  	struct commit *commit;
- 	struct progress *progress = NULL;
  
- 	if (report_progress)
- 		progress = start_delayed_progress(
- 			_("Loading known commits in commit graph"), oids->nr);
- 	for (i = 0; i < oids->nr; i++) {
- 		display_progress(progress, i + 1);
- 		commit = lookup_commit(the_repository, &oids->list[i]);
+ 	if (ctx->report_progress)
+ 		ctx->progress = start_delayed_progress(
+ 					_("Loading known commits in commit graph"),
+ 					ctx->oids.nr);
+ 	for (i = 0; i < ctx->oids.nr; i++) {
+ 		display_progress(ctx->progress, i + 1);
+ 		commit = lookup_commit(ctx->r, &ctx->oids.list[i]);
  		if (commit)
  			commit->object.flags |= UNINTERESTING;
  	}
- 	stop_progress(&progress);
+ 	stop_progress(&ctx->progress);
  
  	/*
- 	 * As this loop runs, oids->nr may grow, but not more
+ 	 * As this loop runs, ctx->oids.nr may grow, but not more
  	 * than the number of missing commits in the reachable
  	 * closure.
  	 */
- 	if (report_progress)
- 		progress = start_delayed_progress(
- 			_("Expanding reachable commits in commit graph"), oids->nr);
- 	for (i = 0; i < oids->nr; i++) {
- 		display_progress(progress, i + 1);
- 		commit = lookup_commit(the_repository, &oids->list[i]);
+ 	if (ctx->report_progress)
+ 		ctx->progress = start_delayed_progress(
+ 					_("Expanding reachable commits in commit graph"),
+ 					ctx->oids.nr);
+ 	for (i = 0; i < ctx->oids.nr; i++) {
+ 		display_progress(ctx->progress, i + 1);
+ 		commit = lookup_commit(ctx->r, &ctx->oids.list[i]);
  
  		if (commit && !parse_commit_no_graph(commit))
- 			add_missing_parents(oids, commit);
+ 			add_missing_parents(ctx, commit);
  	}
- 	stop_progress(&progress);
+ 	stop_progress(&ctx->progress);
  
- 	if (report_progress)
- 		progress = start_delayed_progress(
- 			_("Clearing commit marks in commit graph"), oids->nr);
- 	for (i = 0; i < oids->nr; i++) {
- 		display_progress(progress, i + 1);
- 		commit = lookup_commit(the_repository, &oids->list[i]);
+ 	if (ctx->report_progress)
+ 		ctx->progress = start_delayed_progress(
+ 					_("Clearing commit marks in commit graph"),
+ 					ctx->oids.nr);
+ 	for (i = 0; i < ctx->oids.nr; i++) {
+ 		display_progress(ctx->progress, i + 1);
+ 		commit = lookup_commit(ctx->r, &ctx->oids.list[i]);
  
  		if (commit)
  			commit->object.flags &= ~UNINTERESTING;
  	}
- 	stop_progress(&progress);
+ 	stop_progress(&ctx->progress);
  }
  
- static void compute_generation_numbers(struct packed_commit_list* commits,
- 				       int report_progress)
+ static void compute_generation_numbers(struct write_commit_graph_context *ctx)
  {
  	int i;
  	struct commit_list *list = NULL;
- 	struct progress *progress = NULL;
  
- 	if (report_progress)
- 		progress = start_progress(
- 			_("Computing commit graph generation numbers"),
- 			commits->nr);
- 	for (i = 0; i < commits->nr; i++) {
- 		display_progress(progress, i + 1);
- 		if (commits->list[i]->generation != GENERATION_NUMBER_INFINITY &&
- 		    commits->list[i]->generation != GENERATION_NUMBER_ZERO)
+ 	if (ctx->report_progress)
+ 		ctx->progress = start_progress(
+ 					_("Computing commit graph generation numbers"),
+ 					ctx->commits.nr);
+ 	for (i = 0; i < ctx->commits.nr; i++) {
+ 		display_progress(ctx->progress, i + 1);
+ 		if (ctx->commits.list[i]->generation != GENERATION_NUMBER_INFINITY &&
+ 		    ctx->commits.list[i]->generation != GENERATION_NUMBER_ZERO)
  			continue;
  
- 		commit_list_insert(commits->list[i], &list);
+ 		commit_list_insert(ctx->commits.list[i], &list);
  		while (list) {
  			struct commit *current = list->item;
  			struct commit_list *parent;
@@@ -845,7 -841,7 +848,7 @@@
  			}
  		}
  	}
- 	stop_progress(&progress);
+ 	stop_progress(&ctx->progress);
  }
  
  static int add_ref_to_list(const char *refname,
@@@ -858,207 -854,187 +861,187 @@@
  	return 0;
  }
  
- void write_commit_graph_reachable(const char *obj_dir, int append,
- 				  int report_progress)
+ int write_commit_graph_reachable(const char *obj_dir, unsigned int flags)
  {
  	struct string_list list = STRING_LIST_INIT_DUP;
+ 	int result;
  
  	for_each_ref(add_ref_to_list, &list);
- 	write_commit_graph(obj_dir, NULL, &list, append, report_progress);
+ 	result = write_commit_graph(obj_dir, NULL, &list,
+ 				    flags);
  
  	string_list_clear(&list, 0);
+ 	return result;
  }
  
- void write_commit_graph(const char *obj_dir,
- 			struct string_list *pack_indexes,
- 			struct string_list *commit_hex,
- 			int append, int report_progress)
+ static int fill_oids_from_packs(struct write_commit_graph_context *ctx,
+ 				struct string_list *pack_indexes)
  {
- 	struct packed_oid_list oids;
- 	struct packed_commit_list commits;
- 	struct hashfile *f;
- 	uint32_t i, count_distinct = 0;
- 	char *graph_name;
- 	struct lock_file lk = LOCK_INIT;
- 	uint32_t chunk_ids[5];
- 	uint64_t chunk_offsets[5];
- 	int num_chunks;
- 	int num_extra_edges;
- 	struct commit_list *parent;
- 	struct progress *progress = NULL;
- 	const unsigned hashsz = the_hash_algo->rawsz;
- 	uint64_t progress_cnt = 0;
+ 	uint32_t i;
  	struct strbuf progress_title = STRBUF_INIT;
- 	unsigned long approx_nr_objects;
- 
- 	if (!commit_graph_compatible(the_repository))
- 		return;
- 
- 	oids.nr = 0;
- 	approx_nr_objects = approximate_object_count();
- 	oids.alloc = approx_nr_objects / 32;
- 	oids.progress = NULL;
- 	oids.progress_done = 0;
+ 	struct strbuf packname = STRBUF_INIT;
+ 	int dirlen;
  
- 	if (append) {
- 		prepare_commit_graph_one(the_repository, obj_dir);
- 		if (the_repository->objects->commit_graph)
- 			oids.alloc += the_repository->objects->commit_graph->num_commits;
+ 	strbuf_addf(&packname, "%s/pack/", ctx->obj_dir);
+ 	dirlen = packname.len;
+ 	if (ctx->report_progress) {
+ 		strbuf_addf(&progress_title,
+ 			    Q_("Finding commits for commit graph in %d pack",
+ 			       "Finding commits for commit graph in %d packs",
+ 			       pack_indexes->nr),
+ 			    pack_indexes->nr);
+ 		ctx->progress = start_delayed_progress(progress_title.buf, 0);
+ 		ctx->progress_done = 0;
  	}
- 
- 	if (oids.alloc < 1024)
- 		oids.alloc = 1024;
- 	ALLOC_ARRAY(oids.list, oids.alloc);
- 
- 	if (append && the_repository->objects->commit_graph) {
- 		struct commit_graph *commit_graph =
- 			the_repository->objects->commit_graph;
- 		for (i = 0; i < commit_graph->num_commits; i++) {
- 			const unsigned char *hash = commit_graph->chunk_oid_lookup +
- 				commit_graph->hash_len * i;
- 			hashcpy(oids.list[oids.nr++].hash, hash);
+ 	for (i = 0; i < pack_indexes->nr; i++) {
+ 		struct packed_git *p;
+ 		strbuf_setlen(&packname, dirlen);
+ 		strbuf_addstr(&packname, pack_indexes->items[i].string);
+ 		p = add_packed_git(packname.buf, packname.len, 1);
+ 		if (!p) {
+ 			error(_("error adding pack %s"), packname.buf);
+ 			return -1;
  		}
+ 		if (open_pack_index(p)) {
+ 			error(_("error opening index for %s"), packname.buf);
+ 			return -1;
+ 		}
+ 		for_each_object_in_pack(p, add_packed_commits, ctx,
+ 					FOR_EACH_OBJECT_PACK_ORDER);
+ 		close_pack(p);
+ 		free(p);
  	}
  
- 	if (pack_indexes) {
- 		struct strbuf packname = STRBUF_INIT;
- 		int dirlen;
- 		strbuf_addf(&packname, "%s/pack/", obj_dir);
- 		dirlen = packname.len;
- 		if (report_progress) {
- 			strbuf_addf(&progress_title,
- 				    Q_("Finding commits for commit graph in %d pack",
- 				       "Finding commits for commit graph in %d packs",
- 				       pack_indexes->nr),
- 				    pack_indexes->nr);
- 			oids.progress = start_delayed_progress(progress_title.buf, 0);
- 			oids.progress_done = 0;
- 		}
- 		for (i = 0; i < pack_indexes->nr; i++) {
- 			struct packed_git *p;
- 			strbuf_setlen(&packname, dirlen);
- 			strbuf_addstr(&packname, pack_indexes->items[i].string);
- 			p = add_packed_git(packname.buf, packname.len, 1);
- 			if (!p)
- 				die(_("error adding pack %s"), packname.buf);
- 			if (open_pack_index(p))
- 				die(_("error opening index for %s"), packname.buf);
- 			for_each_object_in_pack(p, add_packed_commits, &oids,
- 						FOR_EACH_OBJECT_PACK_ORDER);
- 			close_pack(p);
- 			free(p);
- 		}
- 		stop_progress(&oids.progress);
- 		strbuf_reset(&progress_title);
- 		strbuf_release(&packname);
+ 	stop_progress(&ctx->progress);
+ 	strbuf_reset(&progress_title);
+ 	strbuf_release(&packname);
+ 
+ 	return 0;
+ }
+ 
+ static void fill_oids_from_commit_hex(struct write_commit_graph_context *ctx,
+ 				      struct string_list *commit_hex)
+ {
+ 	uint32_t i;
+ 	struct strbuf progress_title = STRBUF_INIT;
+ 
+ 	if (ctx->report_progress) {
+ 		strbuf_addf(&progress_title,
+ 			    Q_("Finding commits for commit graph from %d ref",
+ 			       "Finding commits for commit graph from %d refs",
+ 			       commit_hex->nr),
+ 			    commit_hex->nr);
+ 		ctx->progress = start_delayed_progress(
+ 					progress_title.buf,
+ 					commit_hex->nr);
  	}
+ 	for (i = 0; i < commit_hex->nr; i++) {
+ 		const char *end;
+ 		struct object_id oid;
+ 		struct commit *result;
+ 
+ 		display_progress(ctx->progress, i + 1);
+ 		if (commit_hex->items[i].string &&
+ 		    parse_oid_hex(commit_hex->items[i].string, &oid, &end))
+ 			continue;
  
- 	if (commit_hex) {
- 		if (report_progress) {
- 			strbuf_addf(&progress_title,
- 				    Q_("Finding commits for commit graph from %d ref",
- 				       "Finding commits for commit graph from %d refs",
- 				       commit_hex->nr),
- 				    commit_hex->nr);
- 			progress = start_delayed_progress(progress_title.buf,
- 							  commit_hex->nr);
- 		}
- 		for (i = 0; i < commit_hex->nr; i++) {
- 			const char *end;
- 			struct object_id oid;
- 			struct commit *result;
- 
- 			display_progress(progress, i + 1);
- 			if (commit_hex->items[i].string &&
- 			    parse_oid_hex(commit_hex->items[i].string, &oid, &end))
- 				continue;
- 
- 			result = lookup_commit_reference_gently(the_repository, &oid, 1);
- 
- 			if (result) {
- 				ALLOC_GROW(oids.list, oids.nr + 1, oids.alloc);
- 				oidcpy(&oids.list[oids.nr], &(result->object.oid));
- 				oids.nr++;
- 			}
+ 		result = lookup_commit_reference_gently(ctx->r, &oid, 1);
+ 
+ 		if (result) {
+ 			ALLOC_GROW(ctx->oids.list, ctx->oids.nr + 1, ctx->oids.alloc);
+ 			oidcpy(&ctx->oids.list[ctx->oids.nr], &(result->object.oid));
+ 			ctx->oids.nr++;
  		}
- 		stop_progress(&progress);
- 		strbuf_reset(&progress_title);
  	}
+ 	stop_progress(&ctx->progress);
+ 	strbuf_release(&progress_title);
+ }
  
- 	if (!pack_indexes && !commit_hex) {
- 		if (report_progress)
- 			oids.progress = start_delayed_progress(
- 				_("Finding commits for commit graph among packed objects"),
- 				approx_nr_objects);
- 		for_each_packed_object(add_packed_commits, &oids,
- 				       FOR_EACH_OBJECT_PACK_ORDER);
- 		if (oids.progress_done < approx_nr_objects)
- 			display_progress(oids.progress, approx_nr_objects);
- 		stop_progress(&oids.progress);
- 	}
+ static void fill_oids_from_all_packs(struct write_commit_graph_context *ctx)
+ {
+ 	if (ctx->report_progress)
+ 		ctx->progress = start_delayed_progress(
+ 			_("Finding commits for commit graph among packed objects"),
+ 			ctx->approx_nr_objects);
+ 	for_each_packed_object(add_packed_commits, ctx,
+ 			       FOR_EACH_OBJECT_PACK_ORDER);
+ 	if (ctx->progress_done < ctx->approx_nr_objects)
+ 		display_progress(ctx->progress, ctx->approx_nr_objects);
+ 	stop_progress(&ctx->progress);
+ }
  
- 	close_reachable(&oids, report_progress);
+ static uint32_t count_distinct_commits(struct write_commit_graph_context *ctx)
+ {
+ 	uint32_t i, count_distinct = 1;
  
- 	if (report_progress)
- 		progress = start_delayed_progress(
+ 	if (ctx->report_progress)
+ 		ctx->progress = start_delayed_progress(
  			_("Counting distinct commits in commit graph"),
- 			oids.nr);
- 	display_progress(progress, 0); /* TODO: Measure QSORT() progress */
- 	QSORT(oids.list, oids.nr, commit_compare);
- 	count_distinct = 1;
- 	for (i = 1; i < oids.nr; i++) {
- 		display_progress(progress, i + 1);
- 		if (!oideq(&oids.list[i - 1], &oids.list[i]))
+ 			ctx->oids.nr);
+ 	display_progress(ctx->progress, 0); /* TODO: Measure QSORT() progress */
+ 	QSORT(ctx->oids.list, ctx->oids.nr, commit_compare);
+ 
+ 	for (i = 1; i < ctx->oids.nr; i++) {
+ 		display_progress(ctx->progress, i + 1);
+ 		if (!oideq(&ctx->oids.list[i - 1], &ctx->oids.list[i]))
  			count_distinct++;
  	}
- 	stop_progress(&progress);
+ 	stop_progress(&ctx->progress);
  
- 	if (count_distinct >= GRAPH_EDGE_LAST_MASK)
- 		die(_("the commit graph format cannot write %d commits"), count_distinct);
+ 	return count_distinct;
+ }
  
- 	commits.nr = 0;
- 	commits.alloc = count_distinct;
- 	ALLOC_ARRAY(commits.list, commits.alloc);
+ static void copy_oids_to_commits(struct write_commit_graph_context *ctx)
+ {
+ 	uint32_t i;
+ 	struct commit_list *parent;
  
- 	num_extra_edges = 0;
- 	if (report_progress)
- 		progress = start_delayed_progress(
+ 	ctx->num_extra_edges = 0;
+ 	if (ctx->report_progress)
+ 		ctx->progress = start_delayed_progress(
  			_("Finding extra edges in commit graph"),
- 			oids.nr);
- 	for (i = 0; i < oids.nr; i++) {
+ 			ctx->oids.nr);
+ 	for (i = 0; i < ctx->oids.nr; i++) {
  		int num_parents = 0;
- 		display_progress(progress, i + 1);
- 		if (i > 0 && oideq(&oids.list[i - 1], &oids.list[i]))
+ 		display_progress(ctx->progress, i + 1);
+ 		if (i > 0 && oideq(&ctx->oids.list[i - 1], &ctx->oids.list[i]))
  			continue;
  
- 		commits.list[commits.nr] = lookup_commit(the_repository, &oids.list[i]);
- 		parse_commit_no_graph(commits.list[commits.nr]);
+ 		ctx->commits.list[ctx->commits.nr] = lookup_commit(ctx->r, &ctx->oids.list[i]);
+ 		parse_commit_no_graph(ctx->commits.list[ctx->commits.nr]);
  
- 		for (parent = commits.list[commits.nr]->parents;
+ 		for (parent = ctx->commits.list[ctx->commits.nr]->parents;
  		     parent; parent = parent->next)
  			num_parents++;
  
  		if (num_parents > 2)
- 			num_extra_edges += num_parents - 1;
+ 			ctx->num_extra_edges += num_parents - 1;
  
- 		commits.nr++;
+ 		ctx->commits.nr++;
  	}
- 	num_chunks = num_extra_edges ? 4 : 3;
- 	stop_progress(&progress);
- 
- 	if (commits.nr >= GRAPH_EDGE_LAST_MASK)
- 		die(_("too many commits to write graph"));
- 
- 	compute_generation_numbers(&commits, report_progress);
+ 	stop_progress(&ctx->progress);
+ }
  
- 	graph_name = get_commit_graph_filename(obj_dir);
- 	if (safe_create_leading_directories(graph_name)) {
- 		UNLEAK(graph_name);
- 		die_errno(_("unable to create leading directories of %s"),
- 			  graph_name);
+ static int write_commit_graph_file(struct write_commit_graph_context *ctx)
+ {
+ 	uint32_t i;
+ 	struct hashfile *f;
+ 	struct lock_file lk = LOCK_INIT;
+ 	uint32_t chunk_ids[5];
+ 	uint64_t chunk_offsets[5];
+ 	const unsigned hashsz = the_hash_algo->rawsz;
+ 	struct strbuf progress_title = STRBUF_INIT;
+ 	int num_chunks = ctx->num_extra_edges ? 4 : 3;
+ 
+ 	ctx->graph_name = get_commit_graph_filename(ctx->obj_dir);
+ 	if (safe_create_leading_directories(ctx->graph_name)) {
+ 		UNLEAK(ctx->graph_name);
+ 		error(_("unable to create leading directories of %s"),
+ 			ctx->graph_name);
+ 		return -1;
  	}
  
- 	hold_lock_file_for_update(&lk, graph_name, LOCK_DIE_ON_ERROR);
+ 	hold_lock_file_for_update(&lk, ctx->graph_name, LOCK_DIE_ON_ERROR);
  	f = hashfd(lk.tempfile->fd, lk.tempfile->filename.buf);
  
  	hashwrite_be32(f, GRAPH_SIGNATURE);
@@@ -1071,7 -1047,7 +1054,7 @@@
  	chunk_ids[0] = GRAPH_CHUNKID_OIDFANOUT;
  	chunk_ids[1] = GRAPH_CHUNKID_OIDLOOKUP;
  	chunk_ids[2] = GRAPH_CHUNKID_DATA;
- 	if (num_extra_edges)
+ 	if (ctx->num_extra_edges)
  		chunk_ids[3] = GRAPH_CHUNKID_EXTRAEDGES;
  	else
  		chunk_ids[3] = 0;
@@@ -1079,9 -1055,9 +1062,9 @@@
  
  	chunk_offsets[0] = 8 + (num_chunks + 1) * GRAPH_CHUNKLOOKUP_WIDTH;
  	chunk_offsets[1] = chunk_offsets[0] + GRAPH_FANOUT_SIZE;
- 	chunk_offsets[2] = chunk_offsets[1] + hashsz * commits.nr;
- 	chunk_offsets[3] = chunk_offsets[2] + (hashsz + 16) * commits.nr;
- 	chunk_offsets[4] = chunk_offsets[3] + 4 * num_extra_edges;
+ 	chunk_offsets[2] = chunk_offsets[1] + hashsz * ctx->commits.nr;
+ 	chunk_offsets[3] = chunk_offsets[2] + (hashsz + 16) * ctx->commits.nr;
+ 	chunk_offsets[4] = chunk_offsets[3] + 4 * ctx->num_extra_edges;
  
  	for (i = 0; i <= num_chunks; i++) {
  		uint32_t chunk_write[3];
@@@ -1092,31 -1068,113 +1075,113 @@@
  		hashwrite(f, chunk_write, 12);
  	}
  
- 	if (report_progress) {
+ 	if (ctx->report_progress) {
  		strbuf_addf(&progress_title,
  			    Q_("Writing out commit graph in %d pass",
  			       "Writing out commit graph in %d passes",
  			       num_chunks),
  			    num_chunks);
- 		progress = start_delayed_progress(
+ 		ctx->progress = start_delayed_progress(
  			progress_title.buf,
- 			num_chunks * commits.nr);
+ 			num_chunks * ctx->commits.nr);
  	}
- 	write_graph_chunk_fanout(f, commits.list, commits.nr, progress, &progress_cnt);
- 	write_graph_chunk_oids(f, hashsz, commits.list, commits.nr, progress, &progress_cnt);
- 	write_graph_chunk_data(f, hashsz, commits.list, commits.nr, progress, &progress_cnt);
- 	if (num_extra_edges)
- 		write_graph_chunk_extra_edges(f, commits.list, commits.nr, progress, &progress_cnt);
- 	stop_progress(&progress);
+ 	write_graph_chunk_fanout(f, ctx);
+ 	write_graph_chunk_oids(f, hashsz, ctx);
+ 	write_graph_chunk_data(f, hashsz, ctx);
+ 	if (ctx->num_extra_edges)
+ 		write_graph_chunk_extra_edges(f, ctx);
+ 	stop_progress(&ctx->progress);
  	strbuf_release(&progress_title);
  
- 	close_commit_graph(the_repository);
+ 	close_commit_graph(ctx->r);
  	finalize_hashfile(f, NULL, CSUM_HASH_IN_STREAM | CSUM_FSYNC);
  	commit_lock_file(&lk);
  
- 	free(graph_name);
- 	free(commits.list);
- 	free(oids.list);
+ 	return 0;
+ }
+ 
+ int write_commit_graph(const char *obj_dir,
+ 		       struct string_list *pack_indexes,
+ 		       struct string_list *commit_hex,
+ 		       unsigned int flags)
+ {
+ 	struct write_commit_graph_context *ctx;
+ 	uint32_t i, count_distinct = 0;
+ 	int res = 0;
+ 
+ 	if (!commit_graph_compatible(the_repository))
+ 		return 0;
+ 
+ 	ctx = xcalloc(1, sizeof(struct write_commit_graph_context));
+ 	ctx->r = the_repository;
+ 	ctx->obj_dir = obj_dir;
+ 	ctx->append = flags & COMMIT_GRAPH_APPEND ? 1 : 0;
+ 	ctx->report_progress = flags & COMMIT_GRAPH_PROGRESS ? 1 : 0;
+ 
+ 	ctx->approx_nr_objects = approximate_object_count();
+ 	ctx->oids.alloc = ctx->approx_nr_objects / 32;
+ 
+ 	if (ctx->append) {
+ 		prepare_commit_graph_one(ctx->r, ctx->obj_dir);
+ 		if (ctx->r->objects->commit_graph)
+ 			ctx->oids.alloc += ctx->r->objects->commit_graph->num_commits;
+ 	}
+ 
+ 	if (ctx->oids.alloc < 1024)
+ 		ctx->oids.alloc = 1024;
+ 	ALLOC_ARRAY(ctx->oids.list, ctx->oids.alloc);
+ 
+ 	if (ctx->append && ctx->r->objects->commit_graph) {
+ 		struct commit_graph *g = ctx->r->objects->commit_graph;
+ 		for (i = 0; i < g->num_commits; i++) {
+ 			const unsigned char *hash = g->chunk_oid_lookup + g->hash_len * i;
+ 			hashcpy(ctx->oids.list[ctx->oids.nr++].hash, hash);
+ 		}
+ 	}
+ 
+ 	if (pack_indexes) {
+ 		if ((res = fill_oids_from_packs(ctx, pack_indexes)))
+ 			goto cleanup;
+ 	}
+ 
+ 	if (commit_hex)
+ 		fill_oids_from_commit_hex(ctx, commit_hex);
+ 
+ 	if (!pack_indexes && !commit_hex)
+ 		fill_oids_from_all_packs(ctx);
+ 
+ 	close_reachable(ctx);
+ 
+ 	count_distinct = count_distinct_commits(ctx);
+ 
+ 	if (count_distinct >= GRAPH_EDGE_LAST_MASK) {
+ 		error(_("the commit graph format cannot write %d commits"), count_distinct);
+ 		res = -1;
+ 		goto cleanup;
+ 	}
+ 
+ 	ctx->commits.alloc = count_distinct;
+ 	ALLOC_ARRAY(ctx->commits.list, ctx->commits.alloc);
+ 
+ 	copy_oids_to_commits(ctx);
+ 
+ 	if (ctx->commits.nr >= GRAPH_EDGE_LAST_MASK) {
+ 		error(_("too many commits to write graph"));
+ 		res = -1;
+ 		goto cleanup;
+ 	}
+ 
+ 	compute_generation_numbers(ctx);
+ 
+ 	res = write_commit_graph_file(ctx);
+ 
+ cleanup:
+ 	free(ctx->graph_name);
+ 	free(ctx->commits.list);
+ 	free(ctx->oids.list);
+ 	free(ctx);
+ 
+ 	return res;
  }
  
  #define VERIFY_COMMIT_GRAPH_ERROR_HASH 2
diff --combined commit.c
index 8fa1883c61,e4d1233226..26ce0770f6
--- a/commit.c
+++ b/commit.c
@@@ -340,21 -340,15 +340,21 @@@ void free_commit_buffer(struct parsed_o
  	}
  }
  
 -struct tree *get_commit_tree(const struct commit *commit)
 +static inline void set_commit_tree(struct commit *c, struct tree *t)
 +{
 +	c->maybe_tree = t;
 +}
 +
 +struct tree *repo_get_commit_tree(struct repository *r,
 +				  const struct commit *commit)
  {
  	if (commit->maybe_tree || !commit->object.parsed)
  		return commit->maybe_tree;
  
 -	if (commit->graph_pos == COMMIT_NOT_FROM_GRAPH)
 -		BUG("commit has NULL tree, but was not loaded from commit-graph");
 +	if (commit->graph_pos != COMMIT_NOT_FROM_GRAPH)
 +		return get_commit_tree_in_graph(r, commit);
  
 -	return get_commit_tree_in_graph(the_repository, commit);
 +	return NULL;
  }
  
  struct object_id *get_commit_tree_oid(const struct commit *commit)
@@@ -364,7 -358,7 +364,7 @@@
  
  void release_commit_memory(struct parsed_object_pool *pool, struct commit *c)
  {
 -	c->maybe_tree = NULL;
 +	set_commit_tree(c, NULL);
  	c->index = 0;
  	free_commit_buffer(pool, c);
  	free_commit_list(c->parents);
@@@ -412,7 -406,7 +412,7 @@@ int parse_commit_buffer(struct reposito
  	if (get_oid_hex(bufptr + 5, &parent) < 0)
  		return error("bad tree pointer in commit %s",
  			     oid_to_hex(&item->object.oid));
 -	item->maybe_tree = lookup_tree(r, &parent);
 +	set_commit_tree(item, lookup_tree(r, &parent));
  	bufptr += tree_entry_len + 1; /* "tree " + "hex sha1" + "\n" */
  	pptr = &item->parents;
  
@@@ -449,7 -443,7 +449,7 @@@
  	item->date = parse_commit_date(bufptr, tail);
  
  	if (check_graph)
- 		load_commit_graph_info(the_repository, item);
+ 		load_commit_graph_info(r, item);
  
  	return 0;
  }
diff --combined t/t5318-commit-graph.sh
index 840ad4d8ac,3b6fd0d728..5267c4be20
--- a/t/t5318-commit-graph.sh
+++ b/t/t5318-commit-graph.sh
@@@ -23,6 -23,14 +23,14 @@@ test_expect_success 'write graph with n
  	test_path_is_file info/commit-graph
  '
  
+ test_expect_success 'close with correct error on bad input' '
+ 	cd "$TRASH_DIRECTORY/full" &&
+ 	echo doesnotexist >in &&
+ 	{ git commit-graph write --stdin-packs <in 2>stderr; ret=$?; } &&
+ 	test "$ret" = 1 &&
+ 	test_i18ngrep "error adding pack" stderr
+ '
+ 
  test_expect_success 'create commits and repack' '
  	cd "$TRASH_DIRECTORY/full" &&
  	for i in $(test_seq 3)
@@@ -75,7 -83,7 +83,7 @@@ graph_read_expect() 
  
  test_expect_success 'write graph' '
  	cd "$TRASH_DIRECTORY/full" &&
 -	graph1=$(git commit-graph write) &&
 +	git commit-graph write &&
  	test_path_is_file $objdir/info/commit-graph &&
  	graph_read_expect "3"
  '
@@@ -400,7 -408,7 +408,7 @@@ corrupt_graph_and_verify() 
  	orig_size=$(wc -c < $objdir/info/commit-graph) &&
  	zero_pos=${4:-${orig_size}} &&
  	printf "$data" | dd of="$objdir/info/commit-graph" bs=1 seek="$pos" conv=notrunc &&
 -	dd of="$objdir/info/commit-graph" bs=1 seek="$zero_pos" count=0 &&
 +	dd of="$objdir/info/commit-graph" bs=1 seek="$zero_pos" if=/dev/null &&
  	generate_zero_bytes $(($orig_size - $zero_pos)) >>"$objdir/info/commit-graph" &&
  	corrupt_graph_verify "$grepstr"