rerere.c 32.2 KB
Newer Older
1
#include "cache.h"
2
#include "config.h"
3
#include "lockfile.h"
4
#include "string-list.h"
5 6
#include "rerere.h"
#include "xdiff-interface.h"
7 8 9
#include "dir.h"
#include "resolve-undo.h"
#include "ll-merge.h"
10
#include "attr.h"
11
#include "pathspec.h"
12
#include "object-store.h"
13
#include "sha1-lookup.h"
14

15 16 17 18 19
#define RESOLVED 0
#define PUNTED 1
#define THREE_STAGED 2
void *RERERE_RESOLVED = &RERERE_RESOLVED;

20 21 22 23 24 25
/* if rerere_enabled == -1, fall back to detection of .git/rr-cache */
static int rerere_enabled = -1;

/* automatically update cleanly resolved paths to the index */
static int rerere_autoupdate;

26 27 28
static int rerere_dir_nr;
static int rerere_dir_alloc;

29 30
#define RR_HAS_POSTIMAGE 1
#define RR_HAS_PREIMAGE 2
31
static struct rerere_dir {
32
	unsigned char hash[GIT_MAX_HEXSZ];
33 34
	int status_alloc, status_nr;
	unsigned char *status;
35 36 37 38 39
} **rerere_dir;

static void free_rerere_dirs(void)
{
	int i;
40 41
	for (i = 0; i < rerere_dir_nr; i++) {
		free(rerere_dir[i]->status);
42
		free(rerere_dir[i]);
43
	}
44
	FREE_AND_NULL(rerere_dir);
45 46 47
	rerere_dir_nr = rerere_dir_alloc = 0;
}

48
static void free_rerere_id(struct string_list_item *item)
49
{
50
	free(item->util);
51 52
}

53 54
static const char *rerere_id_hex(const struct rerere_id *id)
{
55
	return sha1_to_hex(id->collection->hash);
56 57
}

58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75
static void fit_variant(struct rerere_dir *rr_dir, int variant)
{
	variant++;
	ALLOC_GROW(rr_dir->status, variant, rr_dir->status_alloc);
	if (rr_dir->status_nr < variant) {
		memset(rr_dir->status + rr_dir->status_nr,
		       '\0', variant - rr_dir->status_nr);
		rr_dir->status_nr = variant;
	}
}

static void assign_variant(struct rerere_id *id)
{
	int variant;
	struct rerere_dir *rr_dir = id->collection;

	variant = id->variant;
	if (variant < 0) {
76 77 78
		for (variant = 0; variant < rr_dir->status_nr; variant++)
			if (!rr_dir->status[variant])
				break;
79 80 81
	}
	fit_variant(rr_dir, variant);
	id->variant = variant;
82 83 84 85 86 87 88
}

const char *rerere_path(const struct rerere_id *id, const char *file)
{
	if (!file)
		return git_path("rr-cache/%s", rerere_id_hex(id));

89 90 91 92 93
	if (id->variant <= 0)
		return git_path("rr-cache/%s/%s", rerere_id_hex(id), file);

	return git_path("rr-cache/%s/%s.%d",
			rerere_id_hex(id), file, id->variant);
94 95
}

96
static int is_rr_file(const char *name, const char *filename, int *variant)
97
{
98 99 100 101 102 103 104 105 106 107 108 109 110 111 112
	const char *suffix;
	char *ep;

	if (!strcmp(name, filename)) {
		*variant = 0;
		return 1;
	}
	if (!skip_prefix(name, filename, &suffix) || *suffix != '.')
		return 0;

	errno = 0;
	*variant = strtol(suffix + 1, &ep, 10);
	if (errno || *ep)
		return 0;
	return 1;
113 114 115 116 117
}

static void scan_rerere_dir(struct rerere_dir *rr_dir)
{
	struct dirent *de;
118
	DIR *dir = opendir(git_path("rr-cache/%s", sha1_to_hex(rr_dir->hash)));
119 120 121 122

	if (!dir)
		return;
	while ((de = readdir(dir)) != NULL) {
123 124 125 126 127 128 129 130 131
		int variant;

		if (is_rr_file(de->d_name, "postimage", &variant)) {
			fit_variant(rr_dir, variant);
			rr_dir->status[variant] |= RR_HAS_POSTIMAGE;
		} else if (is_rr_file(de->d_name, "preimage", &variant)) {
			fit_variant(rr_dir, variant);
			rr_dir->status[variant] |= RR_HAS_PREIMAGE;
		}
132 133 134 135
	}
	closedir(dir);
}

136
static const unsigned char *rerere_dir_hash(size_t i, void *table)
137 138
{
	struct rerere_dir **rr_dir = table;
139
	return rr_dir[i]->hash;
140 141 142 143
}

static struct rerere_dir *find_rerere_dir(const char *hex)
{
144
	unsigned char hash[GIT_MAX_RAWSZ];
145 146 147
	struct rerere_dir *rr_dir;
	int pos;

148
	if (get_sha1_hex(hex, hash))
149
		return NULL; /* BUG */
150
	pos = sha1_pos(hash, rerere_dir, rerere_dir_nr, rerere_dir_hash);
151 152
	if (pos < 0) {
		rr_dir = xmalloc(sizeof(*rr_dir));
153
		hashcpy(rr_dir->hash, hash);
154 155 156
		rr_dir->status = NULL;
		rr_dir->status_nr = 0;
		rr_dir->status_alloc = 0;
157 158 159 160 161 162
		pos = -1 - pos;

		/* Make sure the array is big enough ... */
		ALLOC_GROW(rerere_dir, rerere_dir_nr + 1, rerere_dir_alloc);
		/* ... and add it in. */
		rerere_dir_nr++;
Gábor Szeder's avatar
Gábor Szeder committed
163 164
		MOVE_ARRAY(rerere_dir + pos + 1, rerere_dir + pos,
			   rerere_dir_nr - pos - 1);
165
		rerere_dir[pos] = rr_dir;
166
		scan_rerere_dir(rr_dir);
167 168
	}
	return rerere_dir[pos];
169 170
}

171
static int has_rerere_resolution(const struct rerere_id *id)
172
{
173
	const int both = RR_HAS_POSTIMAGE|RR_HAS_PREIMAGE;
174
	int variant = id->variant;
175

176 177 178
	if (variant < 0)
		return 0;
	return ((id->collection->status[variant] & both) == both);
179 180
}

181 182 183
static struct rerere_id *new_rerere_id_hex(char *hex)
{
	struct rerere_id *id = xmalloc(sizeof(*id));
184
	id->collection = find_rerere_dir(hex);
185
	id->variant = -1; /* not known yet */
186 187 188 189 190 191
	return id;
}

static struct rerere_id *new_rerere_id(unsigned char *sha1)
{
	return new_rerere_id_hex(sha1_to_hex(sha1));
192 193
}

194 195 196 197 198 199 200
/*
 * $GIT_DIR/MERGE_RR file is a collection of records, each of which is
 * "conflict ID", a HT and pathname, terminated with a NUL, and is
 * used to keep track of the set of paths that "rerere" may need to
 * work on (i.e. what is left by the previous invocation of "git
 * rerere" during the current conflict resolution session).
 */
201
static void read_rr(struct repository *r, struct string_list *rr)
202
{
203
	struct strbuf buf = STRBUF_INIT;
204
	FILE *in = fopen_or_warn(git_path_merge_rr(r), "r");
205

206 207
	if (!in)
		return;
208 209
	while (!strbuf_getwholeline(&buf, in, '\0')) {
		char *path;
210
		unsigned char hash[GIT_MAX_RAWSZ];
211
		struct rerere_id *id;
212
		int variant;
213
		const unsigned hexsz = the_hash_algo->hexsz;
214 215

		/* There has to be the hash, tab, path and then NUL */
216
		if (buf.len < hexsz + 2 || get_sha1_hex(buf.buf, hash))
217
			die(_("corrupt MERGE_RR"));
218

219
		if (buf.buf[hexsz] != '.') {
220
			variant = 0;
221
			path = buf.buf + hexsz;
222 223
		} else {
			errno = 0;
224
			variant = strtol(buf.buf + hexsz + 1, &path, 10);
225
			if (errno)
226
				die(_("corrupt MERGE_RR"));
227 228
		}
		if (*(path++) != '\t')
229
			die(_("corrupt MERGE_RR"));
230
		buf.buf[hexsz] = '\0';
231
		id = new_rerere_id_hex(buf.buf);
232
		id->variant = variant;
233
		string_list_insert(rr, path)->util = id;
234
	}
235
	strbuf_release(&buf);
236 237 238 239 240
	fclose(in);
}

static struct lock_file write_lock;

241
static int write_rr(struct string_list *rr, int out_fd)
242 243 244
{
	int i;
	for (i = 0; i < rr->nr; i++) {
245
		struct strbuf buf = STRBUF_INIT;
246
		struct rerere_id *id;
247 248

		assert(rr->items[i].util != RERERE_RESOLVED);
249 250 251

		id = rr->items[i].util;
		if (!id)
252
			continue;
253 254 255 256 257 258 259 260 261 262
		assert(id->variant >= 0);
		if (0 < id->variant)
			strbuf_addf(&buf, "%s.%d\t%s%c",
				    rerere_id_hex(id), id->variant,
				    rr->items[i].string, 0);
		else
			strbuf_addf(&buf, "%s\t%s%c",
				    rerere_id_hex(id),
				    rr->items[i].string, 0);

263
		if (write_in_full(out_fd, buf.buf, buf.len) < 0)
264
			die(_("unable to write rerere record"));
265 266

		strbuf_release(&buf);
267 268
	}
	if (commit_lock_file(&write_lock) != 0)
269
		die(_("unable to write rerere record"));
270 271 272
	return 0;
}

273 274 275 276 277 278 279 280 281 282 283 284 285 286 287
/*
 * "rerere" interacts with conflicted file contents using this I/O
 * abstraction.  It reads a conflicted contents from one place via
 * "getline()" method, and optionally can write it out after
 * normalizing the conflicted hunks to the "output".  Subclasses of
 * rerere_io embed this structure at the beginning of their own
 * rerere_io object.
 */
struct rerere_io {
	int (*getline)(struct strbuf *, struct rerere_io *);
	FILE *output;
	int wrerror;
	/* some more stuff */
};

288 289 290 291 292 293 294 295 296 297 298 299 300
static void ferr_write(const void *p, size_t count, FILE *fp, int *err)
{
	if (!count || *err)
		return;
	if (fwrite(p, count, 1, fp) != 1)
		*err = errno;
}

static inline void ferr_puts(const char *s, FILE *fp, int *err)
{
	ferr_write(s, strlen(s), fp, err);
}

301 302 303 304 305 306 307 308 309 310 311 312
static void rerere_io_putstr(const char *str, struct rerere_io *io)
{
	if (io->output)
		ferr_puts(str, io->output, &io->wrerror);
}

static void rerere_io_putmem(const char *mem, size_t sz, struct rerere_io *io)
{
	if (io->output)
		ferr_write(mem, sz, io->output, &io->wrerror);
}

313 314 315
/*
 * Subclass of rerere_io that reads from an on-disk file
 */
316 317 318 319 320
struct rerere_io_file {
	struct rerere_io io;
	FILE *input;
};

321 322 323
/*
 * ... and its getline() method implementation
 */
324 325 326 327 328 329
static int rerere_file_getline(struct strbuf *sb, struct rerere_io *io_)
{
	struct rerere_io_file *io = (struct rerere_io_file *)io_;
	return strbuf_getwholeline(sb, io->input, '\n');
}

330 331 332 333 334 335
/*
 * Require the exact number of conflict marker letters, no more, no
 * less, followed by SP or any whitespace
 * (including LF).
 */
static int is_cmarker(char *buf, int marker_char, int marker_size)
336
{
337 338 339 340 341 342 343 344 345 346 347 348
	int want_sp;

	/*
	 * The beginning of our version and the end of their version
	 * always are labeled like "<<<<< ours" or ">>>>> theirs",
	 * hence we set want_sp for them.  Note that the version from
	 * the common ancestor in diff3-style output is not always
	 * labelled (e.g. "||||| common" is often seen but "|||||"
	 * alone is also valid), so we do not set want_sp.
	 */
	want_sp = (marker_char == '<') || (marker_char == '>');

349 350 351 352 353 354 355 356
	while (marker_size--)
		if (*buf++ != marker_char)
			return 0;
	if (want_sp && *buf != ' ')
		return 0;
	return isspace(*buf);
}

357 358 359 360 361 362 363
static void rerere_strbuf_putconflict(struct strbuf *buf, int ch, size_t size)
{
	strbuf_addchars(buf, ch, size);
	strbuf_addch(buf, '\n');
}

static int handle_conflict(struct strbuf *out, struct rerere_io *io,
364
			   int marker_size, git_hash_ctx *ctx)
365
{
366
	enum {
367 368
		RR_SIDE_1 = 0, RR_SIDE_2, RR_ORIGINAL
	} hunk = RR_SIDE_1;
369
	struct strbuf one = STRBUF_INIT, two = STRBUF_INIT;
370
	struct strbuf buf = STRBUF_INIT, conflict = STRBUF_INIT;
371
	int has_conflicts = -1;
372

373
	while (!io->getline(&buf, io)) {
374
		if (is_cmarker(buf.buf, '<', marker_size)) {
375 376 377 378 379 380 381
			if (handle_conflict(&conflict, io, marker_size, NULL) < 0)
				break;
			if (hunk == RR_SIDE_1)
				strbuf_addbuf(&one, &conflict);
			else
				strbuf_addbuf(&two, &conflict);
			strbuf_release(&conflict);
382
		} else if (is_cmarker(buf.buf, '|', marker_size)) {
383
			if (hunk != RR_SIDE_1)
384
				break;
385
			hunk = RR_ORIGINAL;
386
		} else if (is_cmarker(buf.buf, '=', marker_size)) {
387
			if (hunk != RR_SIDE_1 && hunk != RR_ORIGINAL)
388
				break;
389
			hunk = RR_SIDE_2;
390
		} else if (is_cmarker(buf.buf, '>', marker_size)) {
391
			if (hunk != RR_SIDE_2)
392
				break;
393 394
			if (strbuf_cmp(&one, &two) > 0)
				strbuf_swap(&one, &two);
395
			has_conflicts = 1;
396 397 398 399 400
			rerere_strbuf_putconflict(out, '<', marker_size);
			strbuf_addbuf(out, &one);
			rerere_strbuf_putconflict(out, '=', marker_size);
			strbuf_addbuf(out, &two);
			rerere_strbuf_putconflict(out, '>', marker_size);
401
			if (ctx) {
402 403 404 405 406 407
				the_hash_algo->update_fn(ctx, one.buf ?
							 one.buf : "",
							 one.len + 1);
				the_hash_algo->update_fn(ctx, two.buf ?
							 two.buf : "",
							 two.len + 1);
408
			}
409
			break;
410
		} else if (hunk == RR_SIDE_1)
411
			strbuf_addbuf(&one, &buf);
412 413
		else if (hunk == RR_ORIGINAL)
			; /* discard */
414
		else if (hunk == RR_SIDE_2)
415
			strbuf_addbuf(&two, &buf);
416 417 418
	}
	strbuf_release(&one);
	strbuf_release(&two);
419
	strbuf_release(&buf);
420

421 422 423 424 425 426 427 428 429 430 431 432 433 434 435
	return has_conflicts;
}

/*
 * Read contents a file with conflicts, normalize the conflicts
 * by (1) discarding the common ancestor version in diff3-style,
 * (2) reordering our side and their side so that whichever sorts
 * alphabetically earlier comes before the other one, while
 * computing the "conflict ID", which is just an SHA-1 hash of
 * one side of the conflict, NUL, the other side of the conflict,
 * and NUL concatenated together.
 *
 * Return 1 if conflict hunks are found, 0 if there are no conflict
 * hunks and -1 if an error occured.
 */
436
static int handle_path(unsigned char *hash, struct rerere_io *io, int marker_size)
437
{
438
	git_hash_ctx ctx;
439
	struct strbuf buf = STRBUF_INIT, out = STRBUF_INIT;
440
	int has_conflicts = 0;
441 442
	if (hash)
		the_hash_algo->init_fn(&ctx);
443 444 445

	while (!io->getline(&buf, io)) {
		if (is_cmarker(buf.buf, '<', marker_size)) {
446
			has_conflicts = handle_conflict(&out, io, marker_size,
447
							hash ? &ctx : NULL);
448 449
			if (has_conflicts < 0)
				break;
450 451
			rerere_io_putmem(out.buf, out.len, io);
			strbuf_reset(&out);
452 453 454 455
		} else
			rerere_io_putstr(buf.buf, io);
	}
	strbuf_release(&buf);
456
	strbuf_release(&out);
457

458 459
	if (hash)
		the_hash_algo->final_fn(hash, &ctx);
460

461
	return has_conflicts;
462 463
}

464 465 466 467
/*
 * Scan the path for conflicts, do the "handle_path()" thing above, and
 * return the number of conflict hunks found.
 */
468 469
static int handle_file(struct index_state *istate,
		       const char *path, unsigned char *hash, const char *output)
470
{
471
	int has_conflicts = 0;
472
	struct rerere_io_file io;
473
	int marker_size = ll_merge_marker_size(istate, path);
474 475 476 477 478 479

	memset(&io, 0, sizeof(io));
	io.io.getline = rerere_file_getline;
	io.input = fopen(path, "r");
	io.io.wrerror = 0;
	if (!io.input)
480
		return error_errno(_("could not open '%s'"), path);
481 482 483 484

	if (output) {
		io.io.output = fopen(output, "w");
		if (!io.io.output) {
485
			error_errno(_("could not write '%s'"), output);
486
			fclose(io.input);
487
			return -1;
488 489 490
		}
	}

491
	has_conflicts = handle_path(hash, (struct rerere_io *)&io, marker_size);
492 493 494

	fclose(io.input);
	if (io.io.wrerror)
495
		error(_("there were errors while writing '%s' (%s)"),
496 497
		      path, strerror(io.io.wrerror));
	if (io.io.output && fclose(io.io.output))
498
		io.io.wrerror = error_errno(_("failed to flush '%s'"), path);
499

500
	if (has_conflicts < 0) {
501
		if (output)
502
			unlink_or_warn(output);
503
		return error(_("could not parse conflict hunks in '%s'"), path);
504
	}
505
	if (io.io.wrerror)
506
		return -1;
507
	return has_conflicts;
508 509
}

510 511 512 513 514 515 516 517
/*
 * Look at a cache entry at "i" and see if it is not conflicting,
 * conflicting and we are willing to handle, or conflicting and
 * we are unable to handle, and return the determination in *type.
 * Return the cache index to be looked at next, by skipping the
 * stages we have already looked at in this invocation of this
 * function.
 */
518
static int check_one_conflict(struct index_state *istate, int i, int *type)
519
{
520
	const struct cache_entry *e = istate->cache[i];
521 522 523 524 525 526 527

	if (!ce_stage(e)) {
		*type = RESOLVED;
		return i + 1;
	}

	*type = PUNTED;
528
	while (i < istate->cache_nr && ce_stage(istate->cache[i]) == 1)
529
		i++;
530 531

	/* Only handle regular files with both stages #2 and #3 */
532 533 534
	if (i + 1 < istate->cache_nr) {
		const struct cache_entry *e2 = istate->cache[i];
		const struct cache_entry *e3 = istate->cache[i + 1];
535 536
		if (ce_stage(e2) == 2 &&
		    ce_stage(e3) == 3 &&
537
		    ce_same_name(e, e3) &&
538
		    S_ISREG(e2->ce_mode) &&
539 540 541 542 543
		    S_ISREG(e3->ce_mode))
			*type = THREE_STAGED;
	}

	/* Skip the entries with the same name */
544
	while (i < istate->cache_nr && ce_same_name(e, istate->cache[i]))
545 546 547 548
		i++;
	return i;
}

549 550 551 552 553 554 555 556 557 558 559
/*
 * Scan the index and find paths that have conflicts that rerere can
 * handle, i.e. the ones that has both stages #2 and #3.
 *
 * NEEDSWORK: we do not record or replay a previous "resolve by
 * deletion" for a delete-modify conflict, as that is inherently risky
 * without knowing what modification is being discarded.  The only
 * safe case, i.e. both side doing the deletion and modification that
 * are identical to the previous round, might want to be handled,
 * though.
 */
560
static int find_conflict(struct repository *r, struct string_list *conflict)
561 562
{
	int i;
563

564
	if (repo_read_index(r) < 0)
565
		return error(_("index file corrupt"));
566

567
	for (i = 0; i < r->index->cache_nr;) {
568
		int conflict_type;
569 570
		const struct cache_entry *e = r->index->cache[i];
		i = check_one_conflict(r->index, i, &conflict_type);
571 572 573 574 575 576
		if (conflict_type == THREE_STAGED)
			string_list_insert(conflict, (const char *)e->name);
	}
	return 0;
}

577 578 579 580 581 582 583 584 585 586 587 588 589 590 591
/*
 * The merge_rr list is meant to hold outstanding conflicted paths
 * that rerere could handle.  Abuse the list by adding other types of
 * entries to allow the caller to show "rerere remaining".
 *
 * - Conflicted paths that rerere does not handle are added
 * - Conflicted paths that have been resolved are marked as such
 *   by storing RERERE_RESOLVED to .util field (where conflict ID
 *   is expected to be stored).
 *
 * Do *not* write MERGE_RR file out after calling this function.
 *
 * NEEDSWORK: we may want to fix the caller that implements "rerere
 * remaining" to do this without abusing merge_rr.
 */
592
int rerere_remaining(struct repository *r, struct string_list *merge_rr)
593 594
{
	int i;
595

596
	if (setup_rerere(r, merge_rr, RERERE_READONLY))
597
		return 0;
598
	if (repo_read_index(r) < 0)
599
		return error(_("index file corrupt"));
600

601
	for (i = 0; i < r->index->cache_nr;) {
602
		int conflict_type;
603 604
		const struct cache_entry *e = r->index->cache[i];
		i = check_one_conflict(r->index, i, &conflict_type);
605 606 607 608 609 610
		if (conflict_type == PUNTED)
			string_list_insert(merge_rr, (const char *)e->name);
		else if (conflict_type == RESOLVED) {
			struct string_list_item *it;
			it = string_list_lookup(merge_rr, (const char *)e->name);
			if (it != NULL) {
611
				free_rerere_id(it);
612 613
				it->util = RERERE_RESOLVED;
			}
614 615 616 617 618
		}
	}
	return 0;
}

619 620 621 622 623
/*
 * Try using the given conflict resolution "ID" to see
 * if that recorded conflict resolves cleanly what we
 * got in the "cur".
 */
624 625
static int try_merge(struct index_state *istate,
		     const struct rerere_id *id, const char *path,
626 627 628 629 630 631 632 633 634 635 636 637 638
		     mmfile_t *cur, mmbuffer_t *result)
{
	int ret;
	mmfile_t base = {NULL, 0}, other = {NULL, 0};

	if (read_mmfile(&base, rerere_path(id, "preimage")) ||
	    read_mmfile(&other, rerere_path(id, "postimage")))
		ret = 1;
	else
		/*
		 * A three-way merge. Note that this honors user-customizable
		 * low-level merge driver settings.
		 */
639
		ret = ll_merge(result, path, &base, NULL, cur, "", &other, "",
640
			       istate, NULL);
641 642 643 644 645 646 647

	free(base.ptr);
	free(other.ptr);

	return ret;
}

648
/*
649
 * Find the conflict identified by "id"; the change between its
650 651 652 653 654 655 656 657
 * "preimage" (i.e. a previous contents with conflict markers) and its
 * "postimage" (i.e. the corresponding contents with conflicts
 * resolved) may apply cleanly to the contents stored in "path", i.e.
 * the conflict this time around.
 *
 * Returns 0 for successful replay of recorded resolution, or non-zero
 * for failure.
 */
658
static int merge(struct index_state *istate, const struct rerere_id *id, const char *path)
659
{
660
	FILE *f;
661
	int ret;
662
	mmfile_t cur = {NULL, 0};
663 664
	mmbuffer_t result = {NULL, 0};

665 666 667 668
	/*
	 * Normalize the conflicts in path and write it out to
	 * "thisimage" temporary file.
	 */
669
	if ((handle_file(istate, path, NULL, rerere_path(id, "thisimage")) < 0) ||
670
	    read_mmfile(&cur, rerere_path(id, "thisimage"))) {
671 672 673
		ret = 1;
		goto out;
	}
674

675
	ret = try_merge(istate, id, path, &cur, &result);
676 677 678 679 680 681 682 683
	if (ret)
		goto out;

	/*
	 * A successful replay of recorded resolution.
	 * Mark that "postimage" was used to help gc.
	 */
	if (utime(rerere_path(id, "postimage"), NULL) < 0)
684
		warning_errno(_("failed utime() on '%s'"),
685
			      rerere_path(id, "postimage"));
686 687 688 689

	/* Update "path" with the resolution */
	f = fopen(path, "w");
	if (!f)
690
		return error_errno(_("could not open '%s'"), path);
691
	if (fwrite(result.ptr, result.size, 1, f) != 1)
692
		error_errno(_("could not write '%s'"), path);
693
	if (fclose(f))
694
		return error_errno(_("writing '%s' failed"), path);
695

696
out:
697 698 699 700 701 702
	free(cur.ptr);
	free(result.ptr);

	return ret;
}

703
static void update_paths(struct repository *r, struct string_list *update)
704
{
705
	struct lock_file index_lock = LOCK_INIT;
706 707
	int i;

708
	repo_hold_locked_index(r, &index_lock, LOCK_DIE_ON_ERROR);
709 710

	for (i = 0; i < update->nr; i++) {
711
		struct string_list_item *item = &update->items[i];
712
		if (add_file_to_index(r->index, item->string, 0))
713
			exit(128);
714
		fprintf_ln(stderr, _("Staged '%s' using previous resolution."),
715
			item->string);
716 717
	}

718
	if (write_locked_index(r->index, &index_lock,
719
			       COMMIT_LOCK | SKIP_IF_UNCHANGED))
720
		die(_("unable to write new index file"));
721 722
}

723 724 725 726 727 728 729
static void remove_variant(struct rerere_id *id)
{
	unlink_or_warn(rerere_path(id, "postimage"));
	unlink_or_warn(rerere_path(id, "preimage"));
	id->collection->status[id->variant] = 0;
}

730 731 732 733 734 735 736
/*
 * The path indicated by rr_item may still have conflict for which we
 * have a recorded resolution, in which case replay it and optionally
 * update it.  Or it may have been resolved by the user and we may
 * only have the preimage for that conflict, in which case the result
 * needs to be recorded as a resolution in a postimage file.
 */
737 738
static void do_rerere_one_path(struct index_state *istate,
			       struct string_list_item *rr_item,
739 740 741
			       struct string_list *update)
{
	const char *path = rr_item->string;
742
	struct rerere_id *id = rr_item->util;
743
	struct rerere_dir *rr_dir = id->collection;
744 745 746
	int variant;

	variant = id->variant;
747

748 749
	/* Has the user resolved it already? */
	if (variant >= 0) {
750
		if (!handle_file(istate, path, NULL, NULL)) {
751 752
			copy_file(rerere_path(id, "postimage"), path, 0666);
			id->collection->status[variant] |= RR_HAS_POSTIMAGE;
753
			fprintf_ln(stderr, _("Recorded resolution for '%s'."), path);
754 755 756 757
			free_rerere_id(rr_item);
			rr_item->util = NULL;
			return;
		}
758
		/*
759 760 761
		 * There may be other variants that can cleanly
		 * replay.  Try them and update the variant number for
		 * this one.
762
		 */
763 764 765 766 767 768 769 770 771
	}

	/* Does any existing resolution apply cleanly? */
	for (variant = 0; variant < rr_dir->status_nr; variant++) {
		const int both = RR_HAS_PREIMAGE | RR_HAS_POSTIMAGE;
		struct rerere_id vid = *id;

		if ((rr_dir->status[variant] & both) != both)
			continue;
772

773
		vid.variant = variant;
774
		if (merge(istate, &vid, path))
775 776 777 778 779 780 781 782
			continue; /* failed to replay */

		/*
		 * If there already is a different variant that applies
		 * cleanly, there is no point maintaining our own variant.
		 */
		if (0 <= id->variant && id->variant != variant)
			remove_variant(id);
783 784 785 786

		if (rerere_autoupdate)
			string_list_insert(update, path);
		else
787 788 789
			fprintf_ln(stderr,
				   _("Resolved '%s' using previous resolution."),
				   path);
790 791
		free_rerere_id(rr_item);
		rr_item->util = NULL;
792
		return;
793
	}
794 795 796 797 798

	/* None of the existing one applies; we need a new variant */
	assign_variant(id);

	variant = id->variant;
799
	handle_file(istate, path, NULL, rerere_path(id, "preimage"));
800 801 802
	if (id->collection->status[variant] & RR_HAS_POSTIMAGE) {
		const char *path = rerere_path(id, "postimage");
		if (unlink(path))
803
			die_errno(_("cannot unlink stray '%s'"), path);
804 805 806
		id->collection->status[variant] &= ~RR_HAS_POSTIMAGE;
	}
	id->collection->status[variant] |= RR_HAS_PREIMAGE;
807
	fprintf_ln(stderr, _("Recorded preimage for '%s'"), path);
808 809
}

810 811
static int do_plain_rerere(struct repository *r,
			   struct string_list *rr, int fd)
812
{
813 814
	struct string_list conflict = STRING_LIST_INIT_DUP;
	struct string_list update = STRING_LIST_INIT_DUP;
815 816
	int i;

817
	find_conflict(r, &conflict);
818 819

	/*
820 821 822 823
	 * MERGE_RR records paths with conflicts immediately after
	 * merge failed.  Some of the conflicted paths might have been
	 * hand resolved in the working tree since then, but the
	 * initial run would catch all and register their preimages.
824 825
	 */
	for (i = 0; i < conflict.nr; i++) {
826
		struct rerere_id *id;
827
		unsigned char hash[GIT_MAX_RAWSZ];
828
		const char *path = conflict.items[i].string;
829
		int ret;
830

831 832 833 834 835
		/*
		 * Ask handle_file() to scan and assign a
		 * conflict ID.  No need to write anything out
		 * yet.
		 */
836
		ret = handle_file(r->index, path, hash, NULL);
837
		if (ret != 0 && string_list_has_string(rr, path)) {
838 839 840
			remove_variant(string_list_lookup(rr, path)->util);
			string_list_remove(rr, path, 1);
		}
841 842
		if (ret < 1)
			continue;
843

844
		id = new_rerere_id(hash);
845
		string_list_insert(rr, path)->util = id;
846

847 848
		/* Ensure that the directory exists. */
		mkdir_in_gitdir(rerere_path(id, NULL));
849 850
	}

851
	for (i = 0; i < rr->nr; i++)
852
		do_rerere_one_path(r->index, &rr->items[i], &update);
853 854

	if (update.nr)
855
		update_paths(r, &update);
856 857 858 859

	return write_rr(rr, fd);
}

860
static void git_rerere_config(void)
861
{
862 863 864
	git_config_get_bool("rerere.enabled", &rerere_enabled);
	git_config_get_bool("rerere.autoupdate", &rerere_autoupdate);
	git_config(git_default_config, NULL);
865 866
}

867 868
static GIT_PATH_FUNC(git_path_rr_cache, "rr-cache")

869 870 871 872 873 874 875
static int is_rerere_enabled(void)
{
	int rr_cache_exists;

	if (!rerere_enabled)
		return 0;

876
	rr_cache_exists = is_directory(git_path_rr_cache());
877 878 879
	if (rerere_enabled < 0)
		return rr_cache_exists;

880
	if (!rr_cache_exists && mkdir_in_gitdir(git_path_rr_cache()))
881
		die(_("could not create directory '%s'"), git_path_rr_cache());
882 883 884
	return 1;
}

885
int setup_rerere(struct repository *r, struct string_list *merge_rr, int flags)
886 887 888
{
	int fd;

889
	git_rerere_config();
890 891 892
	if (!is_rerere_enabled())
		return -1;

893 894
	if (flags & (RERERE_AUTOUPDATE|RERERE_NOAUTOUPDATE))
		rerere_autoupdate = !!(flags & RERERE_AUTOUPDATE);
895 896 897
	if (flags & RERERE_READONLY)
		fd = 0;
	else
898
		fd = hold_lock_file_for_update(&write_lock,
899
					       git_path_merge_rr(r),
900
					       LOCK_DIE_ON_ERROR);
901
	read_rr(r, merge_rr);
902 903 904
	return fd;
}

905 906 907 908 909
/*
 * The main entry point that is called internally from codepaths that
 * perform mergy operations, possibly leaving conflicted index entries
 * and working tree files.
 */
910
int repo_rerere(struct repository *r, int flags)
911
{
912
	struct string_list merge_rr = STRING_LIST_INIT_DUP;
913
	int fd, status;
914

915
	fd = setup_rerere(r, &merge_rr, flags);
916 917
	if (fd < 0)
		return 0;
918
	status = do_plain_rerere(r, &merge_rr, fd);
919 920
	free_rerere_dirs();
	return status;
921
}
922

923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954
/*
 * Subclass of rerere_io that reads from an in-core buffer that is a
 * strbuf
 */
struct rerere_io_mem {
	struct rerere_io io;
	struct strbuf input;
};

/*
 * ... and its getline() method implementation
 */
static int rerere_mem_getline(struct strbuf *sb, struct rerere_io *io_)
{
	struct rerere_io_mem *io = (struct rerere_io_mem *)io_;
	char *ep;
	size_t len;

	strbuf_release(sb);
	if (!io->input.len)
		return -1;
	ep = memchr(io->input.buf, '\n', io->input.len);
	if (!ep)
		ep = io->input.buf + io->input.len;
	else if (*ep == '\n')
		ep++;
	len = ep - io->input.buf;
	strbuf_add(sb, io->input.buf, len);
	strbuf_remove(&io->input, 0, len);
	return 0;
}

955 956
static int handle_cache(struct index_state *istate,
			const char *path, unsigned char *hash, const char *output)
957 958 959 960
{
	mmfile_t mmfile[3] = {{NULL}};
	mmbuffer_t result = {NULL, 0};
	const struct cache_entry *ce;
961
	int pos, len, i, has_conflicts;
962
	struct rerere_io_mem io;
963
	int marker_size = ll_merge_marker_size(istate, path);
964 965 966 967 968

	/*
	 * Reproduce the conflicted merge in-core
	 */
	len = strlen(path);
969
	pos = index_name_pos(istate, path, len);
970 971 972 973
	if (0 <= pos)
		return -1;
	pos = -pos - 1;

974
	while (pos < istate->cache_nr) {
975 976 977
		enum object_type type;
		unsigned long size;

978
		ce = istate->cache[pos++];
979 980 981 982
		if (ce_namelen(ce) != len || memcmp(ce->name, path, len))
			break;
		i = ce_stage(ce) - 1;
		if (!mmfile[i].ptr) {
983 984
			mmfile[i].ptr = read_object_file(&ce->oid, &type,
							 &size);
985 986 987 988 989 990 991 992 993 994 995 996 997
			mmfile[i].size = size;
		}
	}
	for (i = 0; i < 3; i++)
		if (!mmfile[i].ptr && !mmfile[i].size)
			mmfile[i].ptr = xstrdup("");

	/*
	 * NEEDSWORK: handle conflicts from merges with
	 * merge.renormalize set, too?
	 */
	ll_merge(&result, path, &mmfile[0], NULL,
		 &mmfile[1], "ours",
998
		 &mmfile[2], "theirs",
999
		 istate, NULL);
1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015
	for (i = 0; i < 3; i++)
		free(mmfile[i].ptr);

	memset(&io, 0, sizeof(io));
	io.io.getline = rerere_mem_getline;
	if (output)
		io.io.output = fopen(output, "w");
	else
		io.io.output = NULL;
	strbuf_init(&io.input, 0);
	strbuf_attach(&io.input, result.ptr, result.size, result.size);

	/*
	 * Grab the conflict ID and optionally write the original
	 * contents with conflict markers out.
	 */
1016
	has_conflicts = handle_path(hash, (struct rerere_io *)&io, marker_size);
1017 1018 1019
	strbuf_release(&io.input);
	if (io.io.output)
		fclose(io.io.output);
1020
	return has_conflicts;
1021
}
1022

1023 1024 1025
static int rerere_forget_one_path(struct index_state *istate,
				  const char *path,
				  struct string_list *rr)
1026 1027
{
	const char *filename;
1028
	struct rerere_id *id;
1029
	unsigned char hash[GIT_MAX_RAWSZ];
1030
	int ret;
1031
	struct string_list_item *item;
1032

1033 1034 1035 1036
	/*
	 * Recreate the original conflict from the stages in the
	 * index and compute the conflict ID
	 */
1037
	ret = handle_cache(istate, path, hash, NULL);
1038
	if (ret < 1)
1039
		return error(_("could not parse conflict hunks in '%s'"), path);
1040 1041

	/* Nuke the recorded resolution for the conflict */
1042
	id = new_rerere_id(hash);
1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053

	for (id->variant = 0;
	     id->variant < id->collection->status_nr;
	     id->variant++) {
		mmfile_t cur = { NULL, 0 };
		mmbuffer_t result = {NULL, 0};
		int cleanly_resolved;

		if (!has_rerere_resolution(id))
			continue;

1054
		handle_cache(istate, path, hash, rerere_path(id, "thisimage"));
1055 1056
		if (read_mmfile(&cur, rerere_path(id, "thisimage"))) {
			free(cur.ptr);
1057
			error(_("failed to update conflicted state in '%s'"), path);
1058
			goto fail_exit;
1059
		}
1060
		cleanly_resolved = !try_merge(istate, id, path, &cur, &result);
1061 1062 1063 1064 1065 1066
		free(result.ptr);
		free(cur.ptr);
		if (cleanly_resolved)
			break;
	}

1067
	if (id->collection->status_nr <= id->variant) {
1068
		error(_("no remembered resolution for '%s'"), path);
1069 1070
		goto fail_exit;
	}
1071

1072
	filename = rerere_path(id, "postimage");
1073 1074
	if (unlink(filename)) {
		if (errno == ENOENT)
1075
			error(_("no remembered resolution for '%s'"), path);
1076
		else
1077
			error_errno(_("cannot unlink '%s'"), filename);
1078
		goto fail_exit;
1079
	}
1080

1081 1082 1083 1084 1085
	/*
	 * Update the preimage so that the user can resolve the
	 * conflict in the working tree, run us again to record
	 * the postimage.
	 */
1086
	handle_cache(istate, path, hash, rerere_path(id, "preimage"));
1087
	fprintf_ln(stderr, _("Updated preimage for '%s'"), path);
1088

1089 1090 1091 1092
	/*
	 * And remember that we can record resolution for this
	 * conflict when the user is done.
	 */
1093
	item = string_list_insert(rr, path);
1094
	free_rerere_id(item);
1095
	item->util = id;
1096
	fprintf(stderr, _("Forgot resolution for '%s'\n"), path);
1097
	return 0;
1098 1099 1100 1101

fail_exit:
	free(id);
	return -1;
1102 1103
}

1104
int rerere_forget(struct repository *r, struct pathspec *pathspec)
1105 1106
{
	int i, fd;
1107 1108
	struct string_list conflict = STRING_LIST_INIT_DUP;
	struct string_list merge_rr = STRING_LIST_INIT_DUP;
1109

1110
	if (repo_read_index(r) < 0)
1111
		return error(_("index file corrupt"));
1112

1113
	fd = setup_rerere(r, &merge_rr, RERERE_NOAUTOUPDATE);
1114 1115
	if (fd < 0)
		return 0;
1116

1117 1118 1119 1120 1121
	/*
	 * The paths may have been resolved (incorrectly);
	 * recover the original conflicted state and then
	 * find the conflicted paths.
	 */
1122 1123
	unmerge_index(r->index, pathspec);
	find_conflict(r, &conflict);
1124 1125
	for (i = 0; i < conflict.nr; i++) {
		struct string_list_item *it = &conflict.items[i];
1126
		if (!match_pathspec(r->index, pathspec, it->string,
1127
				    strlen(it->string), 0, NULL, 0))
1128
			continue;
1129
		rerere_forget_one_path(r->index, it->string, &merge_rr);
1130 1131 1132
	}
	return write_rr(&merge_rr, fd);
}
1133

1134 1135 1136
/*
 * Garbage collection support
 */
1137

1138
static timestamp_t rerere_created_at(struct rerere_id *id)
1139 1140
{
	struct stat st;
1141

1142
	return stat(rerere_path(id, "preimage"), &st) ? (time_t) 0 : st.st_mtime;
1143 1144
}

1145
static timestamp_t rerere_last_used_at(struct rerere_id *id)
1146 1147
{
	struct stat st;
1148

1149
	return stat(rerere_path(id, "postimage"), &st) ? (time_t) 0 : st.st_mtime;
1150 1151
}

1152 1153 1154
/*
 * Remove the recorded resolution for a given conflict ID
 */
1155
static void unlink_rr_item(struct rerere_id *id)
1156
{
Junio C Hamano's avatar
Junio C Hamano committed
1157 1158 1159 1160 1161
	unlink_or_warn(rerere_path(id, "thisimage"));
	remove_variant(id);
	id->collection->status[id->variant] = 0;
}

1162 1163
static void prune_one(struct rerere_id *id,
		      timestamp_t cutoff_resolve, timestamp_t cutoff_noresolve)
Junio C Hamano's avatar
Junio C Hamano committed
1164
{
1165 1166
	timestamp_t then;
	timestamp_t cutoff;
Junio C Hamano's avatar
Junio C Hamano committed
1167 1168 1169 1170 1171 1172 1173 1174 1175 1176

	then = rerere_last_used_at(id);
	if (then)
		cutoff = cutoff_resolve;
	else {
		then = rerere_created_at(id);
		if (!then)
			return;
		cutoff = cutoff_noresolve;
	}
1177
	if (then < cutoff)
Junio C Hamano's avatar
Junio C Hamano committed
1178
		unlink_rr_item(id);
1179 1180
}

1181
void rerere_gc(struct repository *r, struct string_list *rr)
1182 1183 1184 1185
{
	struct string_list to_remove = STRING_LIST_INIT_DUP;
	DIR *dir;
	struct dirent *e;
Junio C Hamano's avatar
Junio C Hamano committed
1186
	int i;
1187 1188 1189
	timestamp_t now = time(NULL);
	timestamp_t cutoff_noresolve = now - 15 * 86400;
	timestamp_t cutoff_resolve = now - 60 * 86400;
1190

1191
	if (setup_rerere(r, rr, 0) < 0)
1192 1193
		return;

1194 1195
	git_config_get_expiry_in_days("gc.rerereresolved", &cutoff_resolve, now);
	git_config_get_expiry_in_days("gc.rerereunresolved", &cutoff_noresolve, now);
1196
	git_config(git_default_config, NULL);
1197 1198
	dir = opendir(git_path("rr-cache"));
	if (!dir)
1199
		die_errno(_("unable to open rr-cache directory"));
1200
	/* Collect stale conflict IDs ... */
1201
	while ((e = readdir(dir))) {
Junio C Hamano's avatar
Junio C Hamano committed
1202 1203 1204 1205
		struct rerere_dir *rr_dir;
		struct rerere_id id;
		int now_empty;

1206 1207
		if (is_dot_or_dotdot(e->d_name))
			continue;
Junio C Hamano's avatar
Junio C Hamano committed
1208 1209 1210 1211 1212 1213 1214 1215
		rr_dir = find_rerere_dir(e->d_name);
		if (!rr_dir)
			continue; /* or should we remove e->d_name? */

		now_empty = 1;
		for (id.variant = 0, id.collection = rr_dir;
		     id.variant < id.collection->status_nr;
		     id.variant++) {
1216
			prune_one(&id, cutoff_resolve, cutoff_noresolve);
Junio C Hamano's avatar
Junio C Hamano committed
1217 1218
			if (id.collection->status[id.variant])
				now_empty = 0;
1219
		}