git

1
#define USE_THE_REPOSITORY_VARIABLE
2

3
#include "git-compat-util.h"
4
#include "gettext.h"
5
#include "object-store-ll.h"
6
#include "reflog.h"
7
#include "refs.h"
8
#include "revision.h"
9
#include "tree.h"
10
#include "tree-walk.h"
11

12
/* Remember to update object flag allocation in object.h */
13
#define INCOMPLETE	(1u<<10)
14
#define STUDYING	(1u<<11)
15
#define REACHABLE	(1u<<12)
16

17
static int tree_is_complete(const struct object_id *oid)
18
{
19
	struct tree_desc desc;
20
	struct name_entry entry;
21
	int complete;
22
	struct tree *tree;
23

24
	tree = lookup_tree(the_repository, oid);
25
	if (!tree)
26
		return 0;
27
	if (tree->object.flags & SEEN)
28
		return 1;
29
	if (tree->object.flags & INCOMPLETE)
30
		return 0;
31

32
	if (!tree->buffer) {
33
		enum object_type type;
34
		unsigned long size;
35
		void *data = repo_read_object_file(the_repository, oid, &type,
36
						   &size);
37
		if (!data) {
38
			tree->object.flags |= INCOMPLETE;
39
			return 0;
40
		}
41
		tree->buffer = data;
42
		tree->size = size;
43
	}
44
	init_tree_desc(&desc, &tree->object.oid, tree->buffer, tree->size);
45
	complete = 1;
46
	while (tree_entry(&desc, &entry)) {
47
		if (!repo_has_object_file(the_repository, &entry.oid) ||
48
		    (S_ISDIR(entry.mode) && !tree_is_complete(&entry.oid))) {
49
			tree->object.flags |= INCOMPLETE;
50
			complete = 0;
51
		}
52
	}
53
	free_tree_buffer(tree);
54

55
	if (complete)
56
		tree->object.flags |= SEEN;
57
	return complete;
58
}
59

60
static int commit_is_complete(struct commit *commit)
61
{
62
	struct object_array study;
63
	struct object_array found;
64
	int is_incomplete = 0;
65
	int i;
66

67
	/* early return */
68
	if (commit->object.flags & SEEN)
69
		return 1;
70
	if (commit->object.flags & INCOMPLETE)
71
		return 0;
72
	/*
73
	 * Find all commits that are reachable and are not marked as
74
	 * SEEN.  Then make sure the trees and blobs contained are
75
	 * complete.  After that, mark these commits also as SEEN.
76
	 * If some of the objects that are needed to complete this
77
	 * commit are missing, mark this commit as INCOMPLETE.
78
	 */
79
	memset(&study, 0, sizeof(study));
80
	memset(&found, 0, sizeof(found));
81
	add_object_array(&commit->object, NULL, &study);
82
	add_object_array(&commit->object, NULL, &found);
83
	commit->object.flags |= STUDYING;
84
	while (study.nr) {
85
		struct commit *c;
86
		struct commit_list *parent;
87

88
		c = (struct commit *)object_array_pop(&study);
89
		if (!c->object.parsed && !parse_object(the_repository, &c->object.oid))
90
			c->object.flags |= INCOMPLETE;
91

92
		if (c->object.flags & INCOMPLETE) {
93
			is_incomplete = 1;
94
			break;
95
		}
96
		else if (c->object.flags & SEEN)
97
			continue;
98
		for (parent = c->parents; parent; parent = parent->next) {
99
			struct commit *p = parent->item;
100
			if (p->object.flags & STUDYING)
101
				continue;
102
			p->object.flags |= STUDYING;
103
			add_object_array(&p->object, NULL, &study);
104
			add_object_array(&p->object, NULL, &found);
105
		}
106
	}
107
	if (!is_incomplete) {
108
		/*
109
		 * make sure all commits in "found" array have all the
110
		 * necessary objects.
111
		 */
112
		for (i = 0; i < found.nr; i++) {
113
			struct commit *c =
114
				(struct commit *)found.objects[i].item;
115
			if (!tree_is_complete(get_commit_tree_oid(c))) {
116
				is_incomplete = 1;
117
				c->object.flags |= INCOMPLETE;
118
			}
119
		}
120
		if (!is_incomplete) {
121
			/* mark all found commits as complete, iow SEEN */
122
			for (i = 0; i < found.nr; i++)
123
				found.objects[i].item->flags |= SEEN;
124
		}
125
	}
126
	/* clear flags from the objects we traversed */
127
	for (i = 0; i < found.nr; i++)
128
		found.objects[i].item->flags &= ~STUDYING;
129
	if (is_incomplete)
130
		commit->object.flags |= INCOMPLETE;
131
	else {
132
		/*
133
		 * If we come here, we have (1) traversed the ancestry chain
134
		 * from the "commit" until we reach SEEN commits (which are
135
		 * known to be complete), and (2) made sure that the commits
136
		 * encountered during the above traversal refer to trees that
137
		 * are complete.  Which means that we know *all* the commits
138
		 * we have seen during this process are complete.
139
		 */
140
		for (i = 0; i < found.nr; i++)
141
			found.objects[i].item->flags |= SEEN;
142
	}
143
	/* free object arrays */
144
	object_array_clear(&study);
145
	object_array_clear(&found);
146
	return !is_incomplete;
147
}
148

149
static int keep_entry(struct commit **it, struct object_id *oid)
150
{
151
	struct commit *commit;
152

153
	if (is_null_oid(oid))
154
		return 1;
155
	commit = lookup_commit_reference_gently(the_repository, oid, 1);
156
	if (!commit)
157
		return 0;
158

159
	/*
160
	 * Make sure everything in this commit exists.
161
	 *
162
	 * We have walked all the objects reachable from the refs
163
	 * and cache earlier.  The commits reachable by this commit
164
	 * must meet SEEN commits -- and then we should mark them as
165
	 * SEEN as well.
166
	 */
167
	if (!commit_is_complete(commit))
168
		return 0;
169
	*it = commit;
170
	return 1;
171
}
172

173
/*
174
 * Starting from commits in the cb->mark_list, mark commits that are
175
 * reachable from them.  Stop the traversal at commits older than
176
 * the expire_limit and queue them back, so that the caller can call
177
 * us again to restart the traversal with longer expire_limit.
178
 */
179
static void mark_reachable(struct expire_reflog_policy_cb *cb)
180
{
181
	struct commit_list *pending;
182
	timestamp_t expire_limit = cb->mark_limit;
183
	struct commit_list *leftover = NULL;
184

185
	for (pending = cb->mark_list; pending; pending = pending->next)
186
		pending->item->object.flags &= ~REACHABLE;
187

188
	pending = cb->mark_list;
189
	while (pending) {
190
		struct commit_list *parent;
191
		struct commit *commit = pop_commit(&pending);
192
		if (commit->object.flags & REACHABLE)
193
			continue;
194
		if (repo_parse_commit(the_repository, commit))
195
			continue;
196
		commit->object.flags |= REACHABLE;
197
		if (commit->date < expire_limit) {
198
			commit_list_insert(commit, &leftover);
199
			continue;
200
		}
201
		parent = commit->parents;
202
		while (parent) {
203
			commit = parent->item;
204
			parent = parent->next;
205
			if (commit->object.flags & REACHABLE)
206
				continue;
207
			commit_list_insert(commit, &pending);
208
		}
209
	}
210
	cb->mark_list = leftover;
211
}
212

213
static int unreachable(struct expire_reflog_policy_cb *cb, struct commit *commit, struct object_id *oid)
214
{
215
	/*
216
	 * We may or may not have the commit yet - if not, look it
217
	 * up using the supplied sha1.
218
	 */
219
	if (!commit) {
220
		if (is_null_oid(oid))
221
			return 0;
222

223
		commit = lookup_commit_reference_gently(the_repository, oid,
224
							1);
225

226
		/* Not a commit -- keep it */
227
		if (!commit)
228
			return 0;
229
	}
230

231
	/* Reachable from the current ref?  Don't prune. */
232
	if (commit->object.flags & REACHABLE)
233
		return 0;
234

235
	if (cb->mark_list && cb->mark_limit) {
236
		cb->mark_limit = 0; /* dig down to the root */
237
		mark_reachable(cb);
238
	}
239

240
	return !(commit->object.flags & REACHABLE);
241
}
242

243
/*
244
 * Return true iff the specified reflog entry should be expired.
245
 */
246
int should_expire_reflog_ent(struct object_id *ooid, struct object_id *noid,
247
			     const char *email UNUSED,
248
			     timestamp_t timestamp, int tz UNUSED,
249
			     const char *message UNUSED, void *cb_data)
250
{
251
	struct expire_reflog_policy_cb *cb = cb_data;
252
	struct commit *old_commit, *new_commit;
253

254
	if (timestamp < cb->cmd.expire_total)
255
		return 1;
256

257
	old_commit = new_commit = NULL;
258
	if (cb->cmd.stalefix &&
259
	    (!keep_entry(&old_commit, ooid) || !keep_entry(&new_commit, noid)))
260
		return 1;
261

262
	if (timestamp < cb->cmd.expire_unreachable) {
263
		switch (cb->unreachable_expire_kind) {
264
		case UE_ALWAYS:
265
			return 1;
266
		case UE_NORMAL:
267
		case UE_HEAD:
268
			if (unreachable(cb, old_commit, ooid) || unreachable(cb, new_commit, noid))
269
				return 1;
270
			break;
271
		}
272
	}
273

274
	if (cb->cmd.recno && --(cb->cmd.recno) == 0)
275
		return 1;
276

277
	return 0;
278
}
279

280
int should_expire_reflog_ent_verbose(struct object_id *ooid,
281
				     struct object_id *noid,
282
				     const char *email,
283
				     timestamp_t timestamp, int tz,
284
				     const char *message, void *cb_data)
285
{
286
	struct expire_reflog_policy_cb *cb = cb_data;
287
	int expire;
288

289
	expire = should_expire_reflog_ent(ooid, noid, email, timestamp, tz,
290
					  message, cb);
291

292
	if (!expire)
293
		printf("keep %s", message);
294
	else if (cb->dry_run)
295
		printf("would prune %s", message);
296
	else
297
		printf("prune %s", message);
298

299
	return expire;
300
}
301

302
static int push_tip_to_list(const char *refname UNUSED,
303
			    const char *referent UNUSED,
304
			    const struct object_id *oid,
305
			    int flags, void *cb_data)
306
{
307
	struct commit_list **list = cb_data;
308
	struct commit *tip_commit;
309
	if (flags & REF_ISSYMREF)
310
		return 0;
311
	tip_commit = lookup_commit_reference_gently(the_repository, oid, 1);
312
	if (!tip_commit)
313
		return 0;
314
	commit_list_insert(tip_commit, list);
315
	return 0;
316
}
317

318
static int is_head(const char *refname)
319
{
320
	const char *stripped_refname;
321
	parse_worktree_ref(refname, NULL, NULL, &stripped_refname);
322
	return !strcmp(stripped_refname, "HEAD");
323
}
324

325
void reflog_expiry_prepare(const char *refname,
326
			   const struct object_id *oid,
327
			   void *cb_data)
328
{
329
	struct expire_reflog_policy_cb *cb = cb_data;
330
	struct commit_list *elem;
331
	struct commit *commit = NULL;
332

333
	if (!cb->cmd.expire_unreachable || is_head(refname)) {
334
		cb->unreachable_expire_kind = UE_HEAD;
335
	} else {
336
		commit = lookup_commit_reference_gently(the_repository,
337
							oid, 1);
338
		if (commit && is_null_oid(&commit->object.oid))
339
			commit = NULL;
340
		cb->unreachable_expire_kind = commit ? UE_NORMAL : UE_ALWAYS;
341
	}
342

343
	if (cb->cmd.expire_unreachable <= cb->cmd.expire_total)
344
		cb->unreachable_expire_kind = UE_ALWAYS;
345

346
	switch (cb->unreachable_expire_kind) {
347
	case UE_ALWAYS:
348
		return;
349
	case UE_HEAD:
350
		refs_for_each_ref(get_main_ref_store(the_repository),
351
				  push_tip_to_list, &cb->tips);
352
		for (elem = cb->tips; elem; elem = elem->next)
353
			commit_list_insert(elem->item, &cb->mark_list);
354
		break;
355
	case UE_NORMAL:
356
		commit_list_insert(commit, &cb->mark_list);
357
		/* For reflog_expiry_cleanup() below */
358
		cb->tip_commit = commit;
359
	}
360
	cb->mark_limit = cb->cmd.expire_total;
361
	mark_reachable(cb);
362
}
363

364
void reflog_expiry_cleanup(void *cb_data)
365
{
366
	struct expire_reflog_policy_cb *cb = cb_data;
367
	struct commit_list *elem;
368

369
	switch (cb->unreachable_expire_kind) {
370
	case UE_ALWAYS:
371
		return;
372
	case UE_HEAD:
373
		for (elem = cb->tips; elem; elem = elem->next)
374
			clear_commit_marks(elem->item, REACHABLE);
375
		free_commit_list(cb->tips);
376
		break;
377
	case UE_NORMAL:
378
		clear_commit_marks(cb->tip_commit, REACHABLE);
379
		break;
380
	}
381
	for (elem = cb->mark_list; elem; elem = elem->next)
382
		clear_commit_marks(elem->item, REACHABLE);
383
	free_commit_list(cb->mark_list);
384
}
385

386
int count_reflog_ent(struct object_id *ooid UNUSED,
387
		     struct object_id *noid UNUSED,
388
		     const char *email UNUSED,
389
		     timestamp_t timestamp, int tz UNUSED,
390
		     const char *message UNUSED, void *cb_data)
391
{
392
	struct cmd_reflog_expire_cb *cb = cb_data;
393
	if (!cb->expire_total || timestamp < cb->expire_total)
394
		cb->recno++;
395
	return 0;
396
}
397

398
int reflog_delete(const char *rev, enum expire_reflog_flags flags, int verbose)
399
{
400
	struct cmd_reflog_expire_cb cmd = { 0 };
401
	int status = 0;
402
	reflog_expiry_should_prune_fn *should_prune_fn = should_expire_reflog_ent;
403
	const char *spec = strstr(rev, "@{");
404
	char *ep, *ref;
405
	int recno;
406
	struct expire_reflog_policy_cb cb = {
407
		.dry_run = !!(flags & EXPIRE_REFLOGS_DRY_RUN),
408
	};
409

410
	if (verbose)
411
		should_prune_fn = should_expire_reflog_ent_verbose;
412

413
	if (!spec)
414
		return error(_("not a reflog: %s"), rev);
415

416
	if (!repo_dwim_log(the_repository, rev, spec - rev, NULL, &ref)) {
417
		status |= error(_("no reflog for '%s'"), rev);
418
		goto cleanup;
419
	}
420

421
	recno = strtoul(spec + 2, &ep, 10);
422
	if (*ep == '}') {
423
		cmd.recno = -recno;
424
		refs_for_each_reflog_ent(get_main_ref_store(the_repository),
425
					 ref, count_reflog_ent, &cmd);
426
	} else {
427
		cmd.expire_total = approxidate(spec + 2);
428
		refs_for_each_reflog_ent(get_main_ref_store(the_repository),
429
					 ref, count_reflog_ent, &cmd);
430
		cmd.expire_total = 0;
431
	}
432

433
	cb.cmd = cmd;
434
	status |= refs_reflog_expire(get_main_ref_store(the_repository), ref,
435
				     flags,
436
				     reflog_expiry_prepare,
437
				     should_prune_fn,
438
				     reflog_expiry_cleanup,
439
				     &cb);
440

441
 cleanup:
442
	free(ref);
443
	return status;
444
}
445