reachable.c 5.91 KB
Newer Older
1 2 3 4 5 6 7 8 9
#include "cache.h"
#include "refs.h"
#include "tag.h"
#include "commit.h"
#include "blob.h"
#include "diff.h"
#include "revision.h"
#include "reachable.h"
#include "cache-tree.h"
10
#include "progress.h"
11
#include "list-objects.h"
12
#include "packfile.h"
13
#include "worktree.h"
14
#include "object-store.h"
15
#include "pack-bitmap.h"
16

17 18 19 20 21 22 23 24 25 26 27 28
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);
}

29 30
static int add_one_ref(const char *path, const struct object_id *oid,
		       int flag, void *cb_data)
31 32
{
	struct rev_info *revs = (struct rev_info *)cb_data;
33
	struct object *object;
34

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

40
	object = parse_object_or_die(oid, path);
41 42 43 44 45
	add_pending_object(revs, object, "");

	return 0;
}

46 47 48 49
/*
 * The traversal will have already marked us as SEEN, so we
 * only need to handle any progress reporting here.
 */
50
static void mark_object(struct object *obj, const char *name, void *data)
51 52 53 54 55 56
{
	update_progress(data);
}

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

60 61
struct recent_data {
	struct rev_info *revs;
62
	timestamp_t timestamp;
63 64
};

65
static void add_recent_object(const struct object_id *oid,
66
			      timestamp_t mtime,
67 68 69 70 71 72 73 74 75 76 77 78 79 80 81
			      struct recent_data *data)
{
	struct object *obj;
	enum object_type type;

	if (mtime <= data->timestamp)
		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.
	 */
82
	type = oid_object_info(the_repository, oid, NULL);
83
	if (type < 0)
84
		die("unable to get object info for %s", oid_to_hex(oid));
85 86 87 88

	switch (type) {
	case OBJ_TAG:
	case OBJ_COMMIT:
89
		obj = parse_object_or_die(oid, NULL);
90 91
		break;
	case OBJ_TREE:
92
		obj = (struct object *)lookup_tree(the_repository, oid);
93 94
		break;
	case OBJ_BLOB:
95
		obj = (struct object *)lookup_blob(the_repository, oid);
96 97 98
		break;
	default:
		die("unknown object type for %s: %s",
99
		    oid_to_hex(oid), type_name(type));
100 101 102
	}

	if (!obj)
103
		die("unable to lookup %s", oid_to_hex(oid));
104 105 106 107

	add_pending_object(data->revs, obj, "");
}

108
static int add_recent_loose(const struct object_id *oid,
109 110 111
			    const char *path, void *data)
{
	struct stat st;
112
	struct object *obj = lookup_object(the_repository, oid->hash);
113 114 115 116 117 118 119 120 121 122 123 124 125

	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;
126
		return error_errno("unable to stat %s", oid_to_hex(oid));
127 128
	}

129
	add_recent_object(oid, st.st_mtime, data);
130 131 132
	return 0;
}

133
static int add_recent_packed(const struct object_id *oid,
134 135 136
			     struct packed_git *p, uint32_t pos,
			     void *data)
{
137
	struct object *obj = lookup_object(the_repository, oid->hash);
138 139 140

	if (obj && obj->flags & SEEN)
		return 0;
141
	add_recent_object(oid, p->mtime, data);
142 143 144
	return 0;
}

145
int add_unseen_recent_objects_to_traversal(struct rev_info *revs,
146
					   timestamp_t timestamp)
147 148 149 150 151 152 153
{
	struct recent_data data;
	int r;

	data.revs = revs;
	data.timestamp = timestamp;

154 155
	r = for_each_loose_object(add_recent_loose, &data,
				  FOR_EACH_OBJECT_LOCAL_ONLY);
156 157
	if (r)
		return r;
158 159
	return for_each_packed_object(add_recent_packed, &data,
				      FOR_EACH_OBJECT_LOCAL_ONLY);
160 161
}

162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194
static void *lookup_object_by_type(struct repository *r,
				   const struct object_id *oid,
				   enum object_type type)
{
	switch (type) {
	case OBJ_COMMIT:
		return lookup_commit(r, oid);
	case OBJ_TREE:
		return lookup_tree(r, oid);
	case OBJ_TAG:
		return lookup_tag(r, oid);
	case OBJ_BLOB:
		return lookup_blob(r, oid);
	default:
		die("BUG: unknown object type %d", type);
	}
}

static int mark_object_seen(const struct object_id *oid,
			     enum object_type type,
			     int exclude,
			     uint32_t name_hash,
			     struct packed_git *found_pack,
			     off_t found_offset)
{
	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;
}

195
void mark_reachable_objects(struct rev_info *revs, int mark_reflog,
196
			    timestamp_t mark_recent, struct progress *progress)
197
{
198
	struct connectivity_progress cp;
199
	struct bitmap_index *bitmap_git;
200

201 202 203 204 205 206 207 208 209
	/*
	 * 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 */
210
	add_index_objects_to_pending(revs, 0);
211 212

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

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

219
	/* Add all reflog info */
220
	if (mark_reflog)
221
		add_reflogs_to_pending(revs, 0);
222

223 224 225
	cp.progress = progress;
	cp.count = 0;

226 227 228 229 230 231 232
	bitmap_git = prepare_bitmap_walk(revs);
	if (bitmap_git) {
		traverse_bitmap_commit_list(bitmap_git, mark_object_seen);
		free_bitmap_index(bitmap_git);
		return;
	}

233 234 235 236
	/*
	 * Set up the revision walk - this will move all commits
	 * from the pending list to the commit walking list.
	 */
237 238
	if (prepare_revision_walk(revs))
		die("revision walk setup failed");
239
	traverse_commit_list(revs, mark_commit, mark_object, &cp);
240 241 242 243 244 245 246 247 248 249

	if (mark_recent) {
		revs->ignore_missing_links = 1;
		if (add_unseen_recent_objects_to_traversal(revs, mark_recent))
			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);
	}

250
	display_progress(cp.progress, cp.count);
251
}