reachable.c

#define USE_THE_REPOSITORY_VARIABLE

#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 char *referent UNUSED, 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(data->revs->repo, 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(revs->repo, 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 */
	refs_for_each_ref(get_main_ref_store(the_repository), add_one_ref,
			  revs);

	/* detached HEAD is not included in the list above */
	refs_head_ref(get_main_ref_store(the_repository), 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);
}