[thirdparty/git.git] / reachable.c

#include "git-compat-util.h"
#include "gettext.h"
#include "hex.h"
#include "refs.h"
#include "commit.h"
#include "blob.h"
#include "diff.h"
#include "revision.h"
#include "reachable.h"
#include "cache-tree.h"
#include "progress.h"
#include "list-objects.h"
#include "packfile.h"
#include "worktree.h"
#include "object-store-ll.h"
#include "pack-bitmap.h"
#include "pack-mtimes.h"
#include "config.h"
#include "run-command.h"
#include "sequencer.h"

struct connectivity_progress {
	struct progress *progress;
	unsigned long count;
};

static void update_progress(struct connectivity_progress *cp)
{
	cp->count++;
	if ((cp->count & 1023) == 0)
		display_progress(cp->progress, cp->count);
}

static void add_one_file(const char *path, struct rev_info *revs)
{
	struct strbuf buf = STRBUF_INIT;
	struct object_id oid;
	struct object *object;

	if (!read_oneliner(&buf, path, READ_ONELINER_SKIP_IF_EMPTY)) {
		strbuf_release(&buf);
		return;
	}
	strbuf_trim(&buf);
	if (!get_oid_hex(buf.buf, &oid)) {
		object = parse_object_or_die(&oid, buf.buf);
		add_pending_object(revs, object, "");
	}
	strbuf_release(&buf);
}

/* Mark objects recorded in rebase state files as reachable. */
static void add_rebase_files(struct rev_info *revs)
{
	struct strbuf buf = STRBUF_INIT;
	size_t len;
	const char *path[] = {
		"rebase-apply/autostash",
		"rebase-apply/orig-head",
		"rebase-merge/autostash",
		"rebase-merge/orig-head",
	};
	struct worktree **worktrees = get_worktrees();

	for (struct worktree **wt = worktrees; *wt; wt++) {
		strbuf_reset(&buf);
		strbuf_addstr(&buf, get_worktree_git_dir(*wt));
		strbuf_complete(&buf, '/');
		len = buf.len;
		for (size_t i = 0; i < ARRAY_SIZE(path); i++) {
			strbuf_setlen(&buf, len);
			strbuf_addstr(&buf, path[i]);
			add_one_file(buf.buf, revs);
		}
	}
	strbuf_release(&buf);
	free_worktrees(worktrees);
}

static int add_one_ref(const char *path, const struct object_id *oid,
		       int flag, void *cb_data)
{
	struct rev_info *revs = (struct rev_info *)cb_data;
	struct object *object;

	if ((flag & REF_ISSYMREF) && (flag & REF_ISBROKEN)) {
		warning("symbolic ref is dangling: %s", path);
		return 0;
	}

	object = parse_object_or_die(oid, path);
	add_pending_object(revs, object, "");

	return 0;
}

/*
 * The traversal will have already marked us as SEEN, so we
 * only need to handle any progress reporting here.
 */
static void mark_object(struct object *obj UNUSED,
			const char *name UNUSED,
			void *data)
{
	update_progress(data);
}

static void mark_commit(struct commit *c, void *data)
{
	mark_object(&c->object, NULL, data);
}

struct recent_data {
	struct rev_info *revs;
	timestamp_t timestamp;
	report_recent_object_fn *cb;
	int ignore_in_core_kept_packs;

	struct oidset extra_recent_oids;
	int extra_recent_oids_loaded;
};

static int run_one_gc_recent_objects_hook(struct oidset *set,
					    const char *args)
{
	struct child_process cmd = CHILD_PROCESS_INIT;
	struct strbuf buf = STRBUF_INIT;
	FILE *out;
	int ret = 0;

	cmd.use_shell = 1;
	cmd.out = -1;

	strvec_push(&cmd.args, args);

	if (start_command(&cmd))
		return -1;

	out = xfdopen(cmd.out, "r");
	while (strbuf_getline(&buf, out) != EOF) {
		struct object_id oid;
		const char *rest;

		if (parse_oid_hex(buf.buf, &oid, &rest) || *rest) {
			ret = error(_("invalid extra cruft tip: '%s'"), buf.buf);
			break;
		}

		oidset_insert(set, &oid);
	}

	fclose(out);
	ret |= finish_command(&cmd);

	strbuf_release(&buf);
	return ret;
}

static void load_gc_recent_objects(struct recent_data *data)
{
	const struct string_list *programs;
	int ret = 0;
	size_t i;

	data->extra_recent_oids_loaded = 1;

	if (git_config_get_string_multi("gc.recentobjectshook", &programs))
		return;

	for (i = 0; i < programs->nr; i++) {
		ret = run_one_gc_recent_objects_hook(&data->extra_recent_oids,
						       programs->items[i].string);
		if (ret)
			die(_("unable to enumerate additional recent objects"));
	}
}

static int obj_is_recent(const struct object_id *oid, timestamp_t mtime,
			 struct recent_data *data)
{
	if (mtime > data->timestamp)
		return 1;

	if (!data->extra_recent_oids_loaded)
		load_gc_recent_objects(data);
	return oidset_contains(&data->extra_recent_oids, oid);
}

static void add_recent_object(const struct object_id *oid,
			      struct packed_git *pack,
			      off_t offset,
			      timestamp_t mtime,
			      struct recent_data *data)
{
	struct object *obj;
	enum object_type type;

	if (!obj_is_recent(oid, mtime, data))
		return;

	/*
	 * We do not want to call parse_object here, because
	 * inflating blobs and trees could be very expensive.
	 * However, we do need to know the correct type for
	 * later processing, and the revision machinery expects
	 * commits and tags to have been parsed.
	 */
	type = oid_object_info(the_repository, oid, NULL);
	if (type < 0)
		die("unable to get object info for %s", oid_to_hex(oid));

	switch (type) {
	case OBJ_TAG:
	case OBJ_COMMIT:
		obj = parse_object_or_die(oid, NULL);
		break;
	case OBJ_TREE:
		obj = (struct object *)lookup_tree(the_repository, oid);
		break;
	case OBJ_BLOB:
		obj = (struct object *)lookup_blob(the_repository, oid);
		break;
	default:
		die("unknown object type for %s: %s",
		    oid_to_hex(oid), type_name(type));
	}

	if (!obj)
		die("unable to lookup %s", oid_to_hex(oid));

	add_pending_object(data->revs, obj, "");
	if (data->cb)
		data->cb(obj, pack, offset, mtime);
}

static int want_recent_object(struct recent_data *data,
			      const struct object_id *oid)
{
	if (data->ignore_in_core_kept_packs &&
	    has_object_kept_pack(oid, IN_CORE_KEEP_PACKS))
		return 0;
	return 1;
}

static int add_recent_loose(const struct object_id *oid,
			    const char *path, void *data)
{
	struct stat st;
	struct object *obj;

	if (!want_recent_object(data, oid))
		return 0;

	obj = lookup_object(the_repository, oid);

	if (obj && obj->flags & SEEN)
		return 0;

	if (stat(path, &st) < 0) {
		/*
		 * It's OK if an object went away during our iteration; this
		 * could be due to a simultaneous repack. But anything else
		 * we should abort, since we might then fail to mark objects
		 * which should not be pruned.
		 */
		if (errno == ENOENT)
			return 0;
		return error_errno("unable to stat %s", oid_to_hex(oid));
	}

	add_recent_object(oid, NULL, 0, st.st_mtime, data);
	return 0;
}

static int add_recent_packed(const struct object_id *oid,
			     struct packed_git *p,
			     uint32_t pos,
			     void *data)
{
	struct object *obj;
	timestamp_t mtime = p->mtime;

	if (!want_recent_object(data, oid))
		return 0;

	obj = lookup_object(the_repository, oid);

	if (obj && obj->flags & SEEN)
		return 0;
	if (p->is_cruft) {
		if (load_pack_mtimes(p) < 0)
			die(_("could not load cruft pack .mtimes"));
		mtime = nth_packed_mtime(p, pos);
	}
	add_recent_object(oid, p, nth_packed_object_offset(p, pos), mtime, data);
	return 0;
}

int add_unseen_recent_objects_to_traversal(struct rev_info *revs,
					   timestamp_t timestamp,
					   report_recent_object_fn *cb,
					   int ignore_in_core_kept_packs)
{
	struct recent_data data;
	enum for_each_object_flags flags;
	int r;

	data.revs = revs;
	data.timestamp = timestamp;
	data.cb = cb;
	data.ignore_in_core_kept_packs = ignore_in_core_kept_packs;

	oidset_init(&data.extra_recent_oids, 0);
	data.extra_recent_oids_loaded = 0;

	r = for_each_loose_object(add_recent_loose, &data,
				  FOR_EACH_OBJECT_LOCAL_ONLY);
	if (r)
		goto done;

	flags = FOR_EACH_OBJECT_LOCAL_ONLY | FOR_EACH_OBJECT_PACK_ORDER;
	if (ignore_in_core_kept_packs)
		flags |= FOR_EACH_OBJECT_SKIP_IN_CORE_KEPT_PACKS;

	r = for_each_packed_object(add_recent_packed, &data, flags);

done:
	oidset_clear(&data.extra_recent_oids);

	return r;
}

static int mark_object_seen(const struct object_id *oid,
			     enum object_type type,
			     int exclude UNUSED,
			     uint32_t name_hash UNUSED,
			     struct packed_git *found_pack UNUSED,
			     off_t found_offset UNUSED)
{
	struct object *obj = lookup_object_by_type(the_repository, oid, type);
	if (!obj)
		die("unable to create object '%s'", oid_to_hex(oid));

	obj->flags |= SEEN;
	return 0;
}

void mark_reachable_objects(struct rev_info *revs, int mark_reflog,
			    timestamp_t mark_recent, struct progress *progress)
{
	struct connectivity_progress cp;
	struct bitmap_index *bitmap_git;

	/*
	 * Set up revision parsing, and mark us as being interested
	 * in all object types, not just commits.
	 */
	revs->tag_objects = 1;
	revs->blob_objects = 1;
	revs->tree_objects = 1;

	/* Add all refs from the index file */
	add_index_objects_to_pending(revs, 0);

	/* Add all external refs */
	for_each_ref(add_one_ref, revs);

	/* detached HEAD is not included in the list above */
	head_ref(add_one_ref, revs);
	other_head_refs(add_one_ref, revs);

	/* rebase autostash and orig-head */
	add_rebase_files(revs);

	/* Add all reflog info */
	if (mark_reflog)
		add_reflogs_to_pending(revs, 0);

	cp.progress = progress;
	cp.count = 0;

	bitmap_git = prepare_bitmap_walk(revs, 0);
	if (bitmap_git) {
		traverse_bitmap_commit_list(bitmap_git, revs, mark_object_seen);
		free_bitmap_index(bitmap_git);
	} else {
		if (prepare_revision_walk(revs))
			die("revision walk setup failed");
		traverse_commit_list(revs, mark_commit, mark_object, &cp);
	}

	if (mark_recent) {
		revs->ignore_missing_links = 1;
		if (add_unseen_recent_objects_to_traversal(revs, mark_recent,
							   NULL, 0))
			die("unable to mark recent objects");
		if (prepare_revision_walk(revs))
			die("revision walk setup failed");
		traverse_commit_list(revs, mark_commit, mark_object, &cp);
	}

	display_progress(cp.progress, cp.count);
}
Commit	Line	Data
98750588	1	#include "git-compat-util.h"
f394e093	2	#include "gettext.h"
41771fa4	3	#include "hex.h"
94421474	4	#include "refs.h"
94421474 JH	5	#include "commit.h"
	6	#include "blob.h"
	7	#include "diff.h"
	8	#include "revision.h"
	9	#include "reachable.h"
	10	#include "cache-tree.h"
dc347195	11	#include "progress.h"
5f78a431	12	#include "list-objects.h"
7709f468	13	#include "packfile.h"
d0c39a49	14	#include "worktree.h"
a034e910	15	#include "object-store-ll.h"
fde67d68	16	#include "pack-bitmap.h"
fb546d6e	17	#include "pack-mtimes.h"
4dc16e2c TB	18	#include "config.h"
4dc16e2c TB	19	#include "run-command.h"
bc7f5db8	20	#include "sequencer.h"
94421474	21
0b26abc0 JK	22	struct connectivity_progress {
	23	struct progress *progress;
	24	unsigned long count;
	25	};
	26
	27	static void update_progress(struct connectivity_progress *cp)
	28	{
	29	cp->count++;
	30	if ((cp->count & 1023) == 0)
	31	display_progress(cp->progress, cp->count);
	32	}
	33
bc7f5db8 PW	34	static void add_one_file(const char path, struct rev_info revs)
	35	{
	36	struct strbuf buf = STRBUF_INIT;
	37	struct object_id oid;
	38	struct object *object;
	39
	40	if (!read_oneliner(&buf, path, READ_ONELINER_SKIP_IF_EMPTY)) {
	41	strbuf_release(&buf);
	42	return;
	43	}
	44	strbuf_trim(&buf);
	45	if (!get_oid_hex(buf.buf, &oid)) {
	46	object = parse_object_or_die(&oid, buf.buf);
	47	add_pending_object(revs, object, "");
	48	}
	49	strbuf_release(&buf);
	50	}
	51
	52	/* Mark objects recorded in rebase state files as reachable. */
	53	static void add_rebase_files(struct rev_info *revs)
	54	{
	55	struct strbuf buf = STRBUF_INIT;
	56	size_t len;
	57	const char *path[] = {
	58	"rebase-apply/autostash",
	59	"rebase-apply/orig-head",
	60	"rebase-merge/autostash",
	61	"rebase-merge/orig-head",
	62	};
	63	struct worktree **worktrees = get_worktrees();
	64
	65	for (struct worktree *wt = worktrees; wt; wt++) {
	66	strbuf_reset(&buf);
	67	strbuf_addstr(&buf, get_worktree_git_dir(*wt));
	68	strbuf_complete(&buf, '/');
	69	len = buf.len;
	70	for (size_t i = 0; i < ARRAY_SIZE(path); i++) {
	71	strbuf_setlen(&buf, len);
	72	strbuf_addstr(&buf, path[i]);
	73	add_one_file(buf.buf, revs);
	74	}
	75	}
	76	strbuf_release(&buf);
	77	free_worktrees(worktrees);
	78	}
	79
635170f2 MH	80	static int add_one_ref(const char path, const struct object_id oid,
635170f2 MH	81	int flag, void *cb_data)
94421474	82	{
94421474	83	struct rev_info revs = (struct rev_info )cb_data;
14886b40	84	struct object *object;
94421474	85
14886b40 JS	86	if ((flag & REF_ISSYMREF) && (flag & REF_ISBROKEN)) {
	87	warning("symbolic ref is dangling: %s", path);
	88	return 0;
	89	}
	90
c251c83d	91	object = parse_object_or_die(oid, path);
94421474 JH	92	add_pending_object(revs, object, "");
	93
	94	return 0;
	95	}
	96
5f78a431 JK	97	/*
	98	* The traversal will have already marked us as SEEN, so we
	99	* only need to handle any progress reporting here.
	100	*/
c50dca2a JK	101	static void mark_object(struct object *obj UNUSED,
	102	const char *name UNUSED,
	103	void *data)
5f78a431 JK	104	{
	105	update_progress(data);
	106	}
	107
	108	static void mark_commit(struct commit c, void data)
	109	{
de1e67d0	110	mark_object(&c->object, NULL, data);
5f78a431 JK	111	}
5f78a431 JK	112
d3038d22 JK	113	struct recent_data {
d3038d22 JK	114	struct rev_info *revs;
dddbad72	115	timestamp_t timestamp;
2fb90409 TB	116	report_recent_object_fn *cb;
2fb90409 TB	117	int ignore_in_core_kept_packs;
4dc16e2c TB	118
	119	struct oidset extra_recent_oids;
	120	int extra_recent_oids_loaded;
d3038d22 JK	121	};
d3038d22 JK	122
4dc16e2c TB	123	static int run_one_gc_recent_objects_hook(struct oidset *set,
	124	const char *args)
	125	{
	126	struct child_process cmd = CHILD_PROCESS_INIT;
	127	struct strbuf buf = STRBUF_INIT;
	128	FILE *out;
	129	int ret = 0;
	130
	131	cmd.use_shell = 1;
	132	cmd.out = -1;
	133
	134	strvec_push(&cmd.args, args);
	135
	136	if (start_command(&cmd))
	137	return -1;
	138
	139	out = xfdopen(cmd.out, "r");
	140	while (strbuf_getline(&buf, out) != EOF) {
	141	struct object_id oid;
	142	const char *rest;
	143
	144	if (parse_oid_hex(buf.buf, &oid, &rest) \|\| *rest) {
	145	ret = error(_("invalid extra cruft tip: '%s'"), buf.buf);
	146	break;
	147	}
	148
	149	oidset_insert(set, &oid);
	150	}
	151
	152	fclose(out);
	153	ret \|= finish_command(&cmd);
	154
	155	strbuf_release(&buf);
	156	return ret;
	157	}
	158
	159	static void load_gc_recent_objects(struct recent_data *data)
	160	{
	161	const struct string_list *programs;
	162	int ret = 0;
	163	size_t i;
	164
	165	data->extra_recent_oids_loaded = 1;
	166
	167	if (git_config_get_string_multi("gc.recentobjectshook", &programs))
	168	return;
	169
	170	for (i = 0; i < programs->nr; i++) {
	171	ret = run_one_gc_recent_objects_hook(&data->extra_recent_oids,
	172	programs->items[i].string);
	173	if (ret)
	174	die(_("unable to enumerate additional recent objects"));
	175	}
	176	}
	177
01e9ca4a TB	178	static int obj_is_recent(const struct object_id *oid, timestamp_t mtime,
	179	struct recent_data *data)
	180	{
4dc16e2c TB	181	if (mtime > data->timestamp)
	182	return 1;
	183
	184	if (!data->extra_recent_oids_loaded)
	185	load_gc_recent_objects(data);
	186	return oidset_contains(&data->extra_recent_oids, oid);
01e9ca4a TB	187	}
01e9ca4a TB	188
76c1d9a0	189	static void add_recent_object(const struct object_id *oid,
2fb90409 TB	190	struct packed_git *pack,
2fb90409 TB	191	off_t offset,
dddbad72	192	timestamp_t mtime,
d3038d22 JK	193	struct recent_data *data)
	194	{
	195	struct object *obj;
	196	enum object_type type;
	197
01e9ca4a	198	if (!obj_is_recent(oid, mtime, data))
d3038d22 JK	199	return;
	200
	201	/*
	202	* We do not want to call parse_object here, because
	203	* inflating blobs and trees could be very expensive.
	204	* However, we do need to know the correct type for
	205	* later processing, and the revision machinery expects
	206	* commits and tags to have been parsed.
	207	*/
0df8e965	208	type = oid_object_info(the_repository, oid, NULL);
d3038d22	209	if (type < 0)
76c1d9a0	210	die("unable to get object info for %s", oid_to_hex(oid));
d3038d22 JK	211
	212	switch (type) {
	213	case OBJ_TAG:
	214	case OBJ_COMMIT:
c251c83d	215	obj = parse_object_or_die(oid, NULL);
d3038d22 JK	216	break;
d3038d22 JK	217	case OBJ_TREE:
f86bcc7b	218	obj = (struct object *)lookup_tree(the_repository, oid);
d3038d22 JK	219	break;
d3038d22 JK	220	case OBJ_BLOB:
da14a7ff	221	obj = (struct object *)lookup_blob(the_repository, oid);
d3038d22 JK	222	break;
	223	default:
	224	die("unknown object type for %s: %s",
debca9d2	225	oid_to_hex(oid), type_name(type));
d3038d22 JK	226	}
	227
	228	if (!obj)
76c1d9a0	229	die("unable to lookup %s", oid_to_hex(oid));
d3038d22 JK	230
d3038d22 JK	231	add_pending_object(data->revs, obj, "");
2fb90409 TB	232	if (data->cb)
	233	data->cb(obj, pack, offset, mtime);
	234	}
	235
	236	static int want_recent_object(struct recent_data *data,
	237	const struct object_id *oid)
	238	{
	239	if (data->ignore_in_core_kept_packs &&
	240	has_object_kept_pack(oid, IN_CORE_KEEP_PACKS))
	241	return 0;
	242	return 1;
d3038d22 JK	243	}
d3038d22 JK	244
76c1d9a0	245	static int add_recent_loose(const struct object_id *oid,
d3038d22 JK	246	const char path, void data)
	247	{
	248	struct stat st;
2fb90409 TB	249	struct object *obj;
	250
	251	if (!want_recent_object(data, oid))
	252	return 0;
	253
	254	obj = lookup_object(the_repository, oid);
d3038d22 JK	255
	256	if (obj && obj->flags & SEEN)
	257	return 0;
	258
	259	if (stat(path, &st) < 0) {
	260	/*
	261	* It's OK if an object went away during our iteration; this
	262	* could be due to a simultaneous repack. But anything else
	263	* we should abort, since we might then fail to mark objects
	264	* which should not be pruned.
	265	*/
	266	if (errno == ENOENT)
	267	return 0;
76c1d9a0	268	return error_errno("unable to stat %s", oid_to_hex(oid));
d3038d22 JK	269	}
d3038d22 JK	270
2fb90409	271	add_recent_object(oid, NULL, 0, st.st_mtime, data);
d3038d22 JK	272	return 0;
	273	}
	274
76c1d9a0	275	static int add_recent_packed(const struct object_id *oid,
be252d33 JK	276	struct packed_git *p,
be252d33 JK	277	uint32_t pos,
d3038d22 JK	278	void *data)
d3038d22 JK	279	{
2fb90409	280	struct object *obj;
fb546d6e	281	timestamp_t mtime = p->mtime;
2fb90409 TB	282
	283	if (!want_recent_object(data, oid))
	284	return 0;
	285
	286	obj = lookup_object(the_repository, oid);
d3038d22 JK	287
	288	if (obj && obj->flags & SEEN)
	289	return 0;
fb546d6e TB	290	if (p->is_cruft) {
	291	if (load_pack_mtimes(p) < 0)
	292	die(_("could not load cruft pack .mtimes"));
	293	mtime = nth_packed_mtime(p, pos);
	294	}
	295	add_recent_object(oid, p, nth_packed_object_offset(p, pos), mtime, data);
d3038d22 JK	296	return 0;
	297	}
	298
abcb8655	299	int add_unseen_recent_objects_to_traversal(struct rev_info *revs,
2fb90409 TB	300	timestamp_t timestamp,
	301	report_recent_object_fn *cb,
	302	int ignore_in_core_kept_packs)
d3038d22 JK	303	{
d3038d22 JK	304	struct recent_data data;
2fb90409	305	enum for_each_object_flags flags;
d3038d22 JK	306	int r;
	307
	308	data.revs = revs;
	309	data.timestamp = timestamp;
2fb90409 TB	310	data.cb = cb;
2fb90409 TB	311	data.ignore_in_core_kept_packs = ignore_in_core_kept_packs;
d3038d22	312
4dc16e2c TB	313	oidset_init(&data.extra_recent_oids, 0);
	314	data.extra_recent_oids_loaded = 0;
	315
1385bb7b JK	316	r = for_each_loose_object(add_recent_loose, &data,
1385bb7b JK	317	FOR_EACH_OBJECT_LOCAL_ONLY);
d3038d22	318	if (r)
4dc16e2c	319	goto done;
2fb90409 TB	320
	321	flags = FOR_EACH_OBJECT_LOCAL_ONLY \| FOR_EACH_OBJECT_PACK_ORDER;
	322	if (ignore_in_core_kept_packs)
	323	flags \|= FOR_EACH_OBJECT_SKIP_IN_CORE_KEPT_PACKS;
	324
4dc16e2c TB	325	r = for_each_packed_object(add_recent_packed, &data, flags);
	326
	327	done:
	328	oidset_clear(&data.extra_recent_oids);
	329
	330	return r;
d3038d22 JK	331	}
d3038d22 JK	332
fde67d68 JK	333	static int mark_object_seen(const struct object_id *oid,
fde67d68 JK	334	enum object_type type,
c50dca2a JK	335	int exclude UNUSED,
	336	uint32_t name_hash UNUSED,
	337	struct packed_git *found_pack UNUSED,
	338	off_t found_offset UNUSED)
fde67d68 JK	339	{
	340	struct object *obj = lookup_object_by_type(the_repository, oid, type);
	341	if (!obj)
	342	die("unable to create object '%s'", oid_to_hex(oid));
	343
	344	obj->flags \|= SEEN;
	345	return 0;
	346	}
	347
dc347195	348	void mark_reachable_objects(struct rev_info *revs, int mark_reflog,
dddbad72	349	timestamp_t mark_recent, struct progress *progress)
94421474	350	{
0b26abc0	351	struct connectivity_progress cp;
fde67d68	352	struct bitmap_index *bitmap_git;
0b26abc0	353
94421474 JH	354	/*
	355	* Set up revision parsing, and mark us as being interested
	356	* in all object types, not just commits.
	357	*/
	358	revs->tag_objects = 1;
	359	revs->blob_objects = 1;
	360	revs->tree_objects = 1;
	361
	362	/* Add all refs from the index file */
1be111d8	363	add_index_objects_to_pending(revs, 0);
94421474 JH	364
94421474 JH	365	/* Add all external refs */
635170f2	366	for_each_ref(add_one_ref, revs);
94421474	367
c40fdd01	368	/* detached HEAD is not included in the list above */
635170f2	369	head_ref(add_one_ref, revs);
d0c39a49	370	other_head_refs(add_one_ref, revs);
c40fdd01	371
bc7f5db8 PW	372	/* rebase autostash and orig-head */
	373	add_rebase_files(revs);
	374
eb8381c8	375	/* Add all reflog info */
94421474	376	if (mark_reflog)
718ccc97	377	add_reflogs_to_pending(revs, 0);
94421474	378
0b26abc0 JK	379	cp.progress = progress;
	380	cp.count = 0;
	381
09d4a79e	382	bitmap_git = prepare_bitmap_walk(revs, 0);
fde67d68	383	if (bitmap_git) {
4eb707eb	384	traverse_bitmap_commit_list(bitmap_git, revs, mark_object_seen);
fde67d68	385	free_bitmap_index(bitmap_git);
2ba582ba JK	386	} else {
	387	if (prepare_revision_walk(revs))
	388	die("revision walk setup failed");
	389	traverse_commit_list(revs, mark_commit, mark_object, &cp);
fde67d68 JK	390	}
fde67d68 JK	391
d3038d22 JK	392	if (mark_recent) {
d3038d22 JK	393	revs->ignore_missing_links = 1;
2fb90409 TB	394	if (add_unseen_recent_objects_to_traversal(revs, mark_recent,
2fb90409 TB	395	NULL, 0))
d3038d22 JK	396	die("unable to mark recent objects");
	397	if (prepare_revision_walk(revs))
	398	die("revision walk setup failed");
	399	traverse_commit_list(revs, mark_commit, mark_object, &cp);
	400	}
	401
0b26abc0	402	display_progress(cp.progress, cp.count);
94421474	403	}