rerere: return strbuf from handle path
[git/git.git] / rerere.c
CommitLineData
5b2fd956 1#include "cache.h"
b2141fc1 2#include "config.h"
697cc8ef 3#include "lockfile.h"
c455c87c 4#include "string-list.h"
5b2fd956 5#include "rerere.h"
5b2fd956 6#include "xdiff-interface.h"
dea4562b
JH
7#include "dir.h"
8#include "resolve-undo.h"
9#include "ll-merge.h"
8588567c 10#include "attr.h"
01a10b0a 11#include "pathspec.h"
1869bbe1 12#include "sha1-lookup.h"
5b2fd956 13
ac49f5ca
MZ
14#define RESOLVED 0
15#define PUNTED 1
16#define THREE_STAGED 2
17void *RERERE_RESOLVED = &RERERE_RESOLVED;
18
5b2fd956
SB
19/* if rerere_enabled == -1, fall back to detection of .git/rr-cache */
20static int rerere_enabled = -1;
21
22/* automatically update cleanly resolved paths to the index */
23static int rerere_autoupdate;
24
1869bbe1
JH
25static int rerere_dir_nr;
26static int rerere_dir_alloc;
27
2c7929b1
JH
28#define RR_HAS_POSTIMAGE 1
29#define RR_HAS_PREIMAGE 2
1869bbe1
JH
30static struct rerere_dir {
31 unsigned char sha1[20];
a13d1370
JH
32 int status_alloc, status_nr;
33 unsigned char *status;
1869bbe1
JH
34} **rerere_dir;
35
36static void free_rerere_dirs(void)
37{
38 int i;
a13d1370
JH
39 for (i = 0; i < rerere_dir_nr; i++) {
40 free(rerere_dir[i]->status);
1869bbe1 41 free(rerere_dir[i]);
a13d1370 42 }
88ce3ef6 43 FREE_AND_NULL(rerere_dir);
1869bbe1 44 rerere_dir_nr = rerere_dir_alloc = 0;
1869bbe1
JH
45}
46
1d51eced 47static void free_rerere_id(struct string_list_item *item)
5b2fd956 48{
1d51eced 49 free(item->util);
5b2fd956
SB
50}
51
1d51eced
JH
52static const char *rerere_id_hex(const struct rerere_id *id)
53{
1869bbe1 54 return sha1_to_hex(id->collection->sha1);
1d51eced
JH
55}
56
a13d1370
JH
57static void fit_variant(struct rerere_dir *rr_dir, int variant)
58{
59 variant++;
60 ALLOC_GROW(rr_dir->status, variant, rr_dir->status_alloc);
61 if (rr_dir->status_nr < variant) {
62 memset(rr_dir->status + rr_dir->status_nr,
63 '\0', variant - rr_dir->status_nr);
64 rr_dir->status_nr = variant;
65 }
66}
67
68static void assign_variant(struct rerere_id *id)
69{
70 int variant;
71 struct rerere_dir *rr_dir = id->collection;
72
73 variant = id->variant;
74 if (variant < 0) {
629716d2
JH
75 for (variant = 0; variant < rr_dir->status_nr; variant++)
76 if (!rr_dir->status[variant])
77 break;
a13d1370
JH
78 }
79 fit_variant(rr_dir, variant);
80 id->variant = variant;
1d51eced
JH
81}
82
83const char *rerere_path(const struct rerere_id *id, const char *file)
84{
85 if (!file)
86 return git_path("rr-cache/%s", rerere_id_hex(id));
87
a13d1370
JH
88 if (id->variant <= 0)
89 return git_path("rr-cache/%s/%s", rerere_id_hex(id), file);
90
91 return git_path("rr-cache/%s/%s.%d",
92 rerere_id_hex(id), file, id->variant);
5b2fd956
SB
93}
94
a13d1370 95static int is_rr_file(const char *name, const char *filename, int *variant)
2c7929b1 96{
a13d1370
JH
97 const char *suffix;
98 char *ep;
99
100 if (!strcmp(name, filename)) {
101 *variant = 0;
102 return 1;
103 }
104 if (!skip_prefix(name, filename, &suffix) || *suffix != '.')
105 return 0;
106
107 errno = 0;
108 *variant = strtol(suffix + 1, &ep, 10);
109 if (errno || *ep)
110 return 0;
111 return 1;
2c7929b1
JH
112}
113
114static void scan_rerere_dir(struct rerere_dir *rr_dir)
115{
116 struct dirent *de;
117 DIR *dir = opendir(git_path("rr-cache/%s", sha1_to_hex(rr_dir->sha1)));
118
119 if (!dir)
120 return;
121 while ((de = readdir(dir)) != NULL) {
a13d1370
JH
122 int variant;
123
124 if (is_rr_file(de->d_name, "postimage", &variant)) {
125 fit_variant(rr_dir, variant);
126 rr_dir->status[variant] |= RR_HAS_POSTIMAGE;
127 } else if (is_rr_file(de->d_name, "preimage", &variant)) {
128 fit_variant(rr_dir, variant);
129 rr_dir->status[variant] |= RR_HAS_PREIMAGE;
130 }
2c7929b1
JH
131 }
132 closedir(dir);
133}
134
1869bbe1
JH
135static const unsigned char *rerere_dir_sha1(size_t i, void *table)
136{
137 struct rerere_dir **rr_dir = table;
138 return rr_dir[i]->sha1;
139}
140
141static struct rerere_dir *find_rerere_dir(const char *hex)
142{
143 unsigned char sha1[20];
144 struct rerere_dir *rr_dir;
145 int pos;
146
147 if (get_sha1_hex(hex, sha1))
148 return NULL; /* BUG */
149 pos = sha1_pos(sha1, rerere_dir, rerere_dir_nr, rerere_dir_sha1);
150 if (pos < 0) {
151 rr_dir = xmalloc(sizeof(*rr_dir));
152 hashcpy(rr_dir->sha1, sha1);
a13d1370
JH
153 rr_dir->status = NULL;
154 rr_dir->status_nr = 0;
155 rr_dir->status_alloc = 0;
1869bbe1
JH
156 pos = -1 - pos;
157
158 /* Make sure the array is big enough ... */
159 ALLOC_GROW(rerere_dir, rerere_dir_nr + 1, rerere_dir_alloc);
160 /* ... and add it in. */
161 rerere_dir_nr++;
f919ffeb
SG
162 MOVE_ARRAY(rerere_dir + pos + 1, rerere_dir + pos,
163 rerere_dir_nr - pos - 1);
1869bbe1 164 rerere_dir[pos] = rr_dir;
2c7929b1 165 scan_rerere_dir(rr_dir);
1869bbe1
JH
166 }
167 return rerere_dir[pos];
5b2fd956
SB
168}
169
1d51eced 170static int has_rerere_resolution(const struct rerere_id *id)
5b2fd956 171{
05dd9f13 172 const int both = RR_HAS_POSTIMAGE|RR_HAS_PREIMAGE;
a13d1370 173 int variant = id->variant;
1d51eced 174
a13d1370
JH
175 if (variant < 0)
176 return 0;
177 return ((id->collection->status[variant] & both) == both);
5b2fd956
SB
178}
179
1d51eced
JH
180static struct rerere_id *new_rerere_id_hex(char *hex)
181{
182 struct rerere_id *id = xmalloc(sizeof(*id));
1869bbe1 183 id->collection = find_rerere_dir(hex);
a13d1370 184 id->variant = -1; /* not known yet */
1d51eced
JH
185 return id;
186}
187
188static struct rerere_id *new_rerere_id(unsigned char *sha1)
189{
190 return new_rerere_id_hex(sha1_to_hex(sha1));
5b2fd956
SB
191}
192
4b68c2a0
JH
193/*
194 * $GIT_DIR/MERGE_RR file is a collection of records, each of which is
195 * "conflict ID", a HT and pathname, terminated with a NUL, and is
196 * used to keep track of the set of paths that "rerere" may need to
197 * work on (i.e. what is left by the previous invocation of "git
198 * rerere" during the current conflict resolution session).
199 */
c455c87c 200static void read_rr(struct string_list *rr)
5b2fd956 201{
f5800f6a 202 struct strbuf buf = STRBUF_INIT;
e9d983f1 203 FILE *in = fopen_or_warn(git_path_merge_rr(), "r");
f5800f6a 204
5b2fd956
SB
205 if (!in)
206 return;
f5800f6a
JH
207 while (!strbuf_getwholeline(&buf, in, '\0')) {
208 char *path;
209 unsigned char sha1[20];
1d51eced 210 struct rerere_id *id;
a13d1370 211 int variant;
f5800f6a
JH
212
213 /* There has to be the hash, tab, path and then NUL */
214 if (buf.len < 42 || get_sha1_hex(buf.buf, sha1))
2373b650 215 die(_("corrupt MERGE_RR"));
f5800f6a 216
a13d1370
JH
217 if (buf.buf[40] != '.') {
218 variant = 0;
219 path = buf.buf + 40;
220 } else {
221 errno = 0;
222 variant = strtol(buf.buf + 41, &path, 10);
223 if (errno)
2373b650 224 die(_("corrupt MERGE_RR"));
a13d1370
JH
225 }
226 if (*(path++) != '\t')
2373b650 227 die(_("corrupt MERGE_RR"));
f5800f6a 228 buf.buf[40] = '\0';
1d51eced 229 id = new_rerere_id_hex(buf.buf);
a13d1370 230 id->variant = variant;
1d51eced 231 string_list_insert(rr, path)->util = id;
5b2fd956 232 }
f5800f6a 233 strbuf_release(&buf);
5b2fd956
SB
234 fclose(in);
235}
236
237static struct lock_file write_lock;
238
c455c87c 239static int write_rr(struct string_list *rr, int out_fd)
5b2fd956
SB
240{
241 int i;
242 for (i = 0; i < rr->nr; i++) {
e2cb6a95 243 struct strbuf buf = STRBUF_INIT;
1d51eced 244 struct rerere_id *id;
e2cb6a95
JH
245
246 assert(rr->items[i].util != RERERE_RESOLVED);
1d51eced
JH
247
248 id = rr->items[i].util;
249 if (!id)
5b2fd956 250 continue;
a13d1370
JH
251 assert(id->variant >= 0);
252 if (0 < id->variant)
253 strbuf_addf(&buf, "%s.%d\t%s%c",
254 rerere_id_hex(id), id->variant,
255 rr->items[i].string, 0);
256 else
257 strbuf_addf(&buf, "%s\t%s%c",
258 rerere_id_hex(id),
259 rr->items[i].string, 0);
260
06f46f23 261 if (write_in_full(out_fd, buf.buf, buf.len) < 0)
2373b650 262 die(_("unable to write rerere record"));
e2cb6a95
JH
263
264 strbuf_release(&buf);
5b2fd956
SB
265 }
266 if (commit_lock_file(&write_lock) != 0)
2373b650 267 die(_("unable to write rerere record"));
5b2fd956
SB
268 return 0;
269}
270
a96847cc
JH
271/*
272 * "rerere" interacts with conflicted file contents using this I/O
273 * abstraction. It reads a conflicted contents from one place via
274 * "getline()" method, and optionally can write it out after
275 * normalizing the conflicted hunks to the "output". Subclasses of
276 * rerere_io embed this structure at the beginning of their own
277 * rerere_io object.
278 */
279struct rerere_io {
280 int (*getline)(struct strbuf *, struct rerere_io *);
281 FILE *output;
282 int wrerror;
283 /* some more stuff */
284};
285
47d32af2
AR
286static void ferr_write(const void *p, size_t count, FILE *fp, int *err)
287{
288 if (!count || *err)
289 return;
290 if (fwrite(p, count, 1, fp) != 1)
291 *err = errno;
292}
293
294static inline void ferr_puts(const char *s, FILE *fp, int *err)
295{
296 ferr_write(s, strlen(s), fp, err);
297}
298
27d6b085
JH
299static void rerere_io_putstr(const char *str, struct rerere_io *io)
300{
301 if (io->output)
302 ferr_puts(str, io->output, &io->wrerror);
303}
304
305static void rerere_io_putmem(const char *mem, size_t sz, struct rerere_io *io)
306{
307 if (io->output)
308 ferr_write(mem, sz, io->output, &io->wrerror);
309}
310
a96847cc
JH
311/*
312 * Subclass of rerere_io that reads from an on-disk file
313 */
27d6b085
JH
314struct rerere_io_file {
315 struct rerere_io io;
316 FILE *input;
317};
318
a96847cc
JH
319/*
320 * ... and its getline() method implementation
321 */
27d6b085
JH
322static int rerere_file_getline(struct strbuf *sb, struct rerere_io *io_)
323{
324 struct rerere_io_file *io = (struct rerere_io_file *)io_;
325 return strbuf_getwholeline(sb, io->input, '\n');
326}
327
67711cdc
JH
328/*
329 * Require the exact number of conflict marker letters, no more, no
330 * less, followed by SP or any whitespace
331 * (including LF).
332 */
333static int is_cmarker(char *buf, int marker_char, int marker_size)
191f2417 334{
67711cdc
JH
335 int want_sp;
336
337 /*
338 * The beginning of our version and the end of their version
339 * always are labeled like "<<<<< ours" or ">>>>> theirs",
340 * hence we set want_sp for them. Note that the version from
341 * the common ancestor in diff3-style output is not always
342 * labelled (e.g. "||||| common" is often seen but "|||||"
343 * alone is also valid), so we do not set want_sp.
344 */
345 want_sp = (marker_char == '<') || (marker_char == '>');
346
191f2417
JH
347 while (marker_size--)
348 if (*buf++ != marker_char)
349 return 0;
350 if (want_sp && *buf != ' ')
351 return 0;
352 return isspace(*buf);
353}
354
5ebbdad3
TG
355static void rerere_strbuf_putconflict(struct strbuf *buf, int ch, size_t size)
356{
357 strbuf_addchars(buf, ch, size);
358 strbuf_addch(buf, '\n');
359}
360
361static int handle_conflict(struct strbuf *out, struct rerere_io *io,
362 int marker_size, git_SHA_CTX *ctx)
5b2fd956 363{
cc58d7df 364 enum {
c0f16f8e
TG
365 RR_SIDE_1 = 0, RR_SIDE_2, RR_ORIGINAL
366 } hunk = RR_SIDE_1;
f285a2d7 367 struct strbuf one = STRBUF_INIT, two = STRBUF_INIT;
d58ee6db 368 struct strbuf buf = STRBUF_INIT;
c0f16f8e 369 int has_conflicts = -1;
5b2fd956 370
27d6b085 371 while (!io->getline(&buf, io)) {
67711cdc 372 if (is_cmarker(buf.buf, '<', marker_size)) {
c0f16f8e 373 break;
67711cdc 374 } else if (is_cmarker(buf.buf, '|', marker_size)) {
cc58d7df 375 if (hunk != RR_SIDE_1)
c0f16f8e 376 break;
387c9d49 377 hunk = RR_ORIGINAL;
67711cdc 378 } else if (is_cmarker(buf.buf, '=', marker_size)) {
387c9d49 379 if (hunk != RR_SIDE_1 && hunk != RR_ORIGINAL)
c0f16f8e 380 break;
cc58d7df 381 hunk = RR_SIDE_2;
67711cdc 382 } else if (is_cmarker(buf.buf, '>', marker_size)) {
cc58d7df 383 if (hunk != RR_SIDE_2)
c0f16f8e 384 break;
5b2fd956
SB
385 if (strbuf_cmp(&one, &two) > 0)
386 strbuf_swap(&one, &two);
221444f5 387 has_conflicts = 1;
5ebbdad3
TG
388 rerere_strbuf_putconflict(out, '<', marker_size);
389 strbuf_addbuf(out, &one);
390 rerere_strbuf_putconflict(out, '=', marker_size);
391 strbuf_addbuf(out, &two);
392 rerere_strbuf_putconflict(out, '>', marker_size);
c0f16f8e
TG
393 if (ctx) {
394 git_SHA1_Update(ctx, one.buf ? one.buf : "",
5b2fd956 395 one.len + 1);
c0f16f8e 396 git_SHA1_Update(ctx, two.buf ? two.buf : "",
5b2fd956
SB
397 two.len + 1);
398 }
c0f16f8e 399 break;
cc58d7df 400 } else if (hunk == RR_SIDE_1)
e992d1eb 401 strbuf_addbuf(&one, &buf);
387c9d49
JH
402 else if (hunk == RR_ORIGINAL)
403 ; /* discard */
cc58d7df 404 else if (hunk == RR_SIDE_2)
e992d1eb 405 strbuf_addbuf(&two, &buf);
5b2fd956
SB
406 }
407 strbuf_release(&one);
408 strbuf_release(&two);
d58ee6db 409 strbuf_release(&buf);
5b2fd956 410
c0f16f8e
TG
411 return has_conflicts;
412}
413
414/*
415 * Read contents a file with conflicts, normalize the conflicts
416 * by (1) discarding the common ancestor version in diff3-style,
417 * (2) reordering our side and their side so that whichever sorts
418 * alphabetically earlier comes before the other one, while
419 * computing the "conflict ID", which is just an SHA-1 hash of
420 * one side of the conflict, NUL, the other side of the conflict,
421 * and NUL concatenated together.
422 *
423 * Return 1 if conflict hunks are found, 0 if there are no conflict
424 * hunks and -1 if an error occured.
425 */
426static int handle_path(unsigned char *sha1, struct rerere_io *io, int marker_size)
427{
428 git_SHA_CTX ctx;
5ebbdad3 429 struct strbuf buf = STRBUF_INIT, out = STRBUF_INIT;
c0f16f8e
TG
430 int has_conflicts = 0;
431 if (sha1)
432 git_SHA1_Init(&ctx);
433
434 while (!io->getline(&buf, io)) {
435 if (is_cmarker(buf.buf, '<', marker_size)) {
5ebbdad3 436 has_conflicts = handle_conflict(&out, io, marker_size,
c0f16f8e
TG
437 sha1 ? &ctx : NULL);
438 if (has_conflicts < 0)
439 break;
5ebbdad3
TG
440 rerere_io_putmem(out.buf, out.len, io);
441 strbuf_reset(&out);
c0f16f8e
TG
442 } else
443 rerere_io_putstr(buf.buf, io);
444 }
445 strbuf_release(&buf);
5ebbdad3 446 strbuf_release(&out);
c0f16f8e 447
5b2fd956 448 if (sha1)
9126f009 449 git_SHA1_Final(sha1, &ctx);
c0f16f8e 450
221444f5 451 return has_conflicts;
27d6b085
JH
452}
453
cc899eca
JH
454/*
455 * Scan the path for conflicts, do the "handle_path()" thing above, and
456 * return the number of conflict hunks found.
457 */
27d6b085
JH
458static int handle_file(const char *path, unsigned char *sha1, const char *output)
459{
221444f5 460 int has_conflicts = 0;
27d6b085 461 struct rerere_io_file io;
8588567c 462 int marker_size = ll_merge_marker_size(path);
27d6b085
JH
463
464 memset(&io, 0, sizeof(io));
465 io.io.getline = rerere_file_getline;
466 io.input = fopen(path, "r");
467 io.io.wrerror = 0;
468 if (!io.input)
2373b650 469 return error_errno(_("could not open '%s'"), path);
27d6b085
JH
470
471 if (output) {
472 io.io.output = fopen(output, "w");
473 if (!io.io.output) {
2373b650 474 error_errno(_("could not write '%s'"), output);
27d6b085 475 fclose(io.input);
f7566f07 476 return -1;
27d6b085
JH
477 }
478 }
479
221444f5 480 has_conflicts = handle_path(sha1, (struct rerere_io *)&io, marker_size);
27d6b085
JH
481
482 fclose(io.input);
483 if (io.io.wrerror)
2373b650 484 error(_("there were errors while writing '%s' (%s)"),
27d6b085
JH
485 path, strerror(io.io.wrerror));
486 if (io.io.output && fclose(io.io.output))
2373b650 487 io.io.wrerror = error_errno(_("failed to flush '%s'"), path);
27d6b085 488
221444f5 489 if (has_conflicts < 0) {
5b2fd956 490 if (output)
691f1a28 491 unlink_or_warn(output);
2373b650 492 return error(_("could not parse conflict hunks in '%s'"), path);
5b2fd956 493 }
27d6b085 494 if (io.io.wrerror)
47d32af2 495 return -1;
221444f5 496 return has_conflicts;
5b2fd956
SB
497}
498
4b68c2a0
JH
499/*
500 * Look at a cache entry at "i" and see if it is not conflicting,
501 * conflicting and we are willing to handle, or conflicting and
502 * we are unable to handle, and return the determination in *type.
503 * Return the cache index to be looked at next, by skipping the
504 * stages we have already looked at in this invocation of this
505 * function.
506 */
ac49f5ca 507static int check_one_conflict(int i, int *type)
5b2fd956 508{
9c5e6c80 509 const struct cache_entry *e = active_cache[i];
ac49f5ca
MZ
510
511 if (!ce_stage(e)) {
512 *type = RESOLVED;
513 return i + 1;
514 }
515
516 *type = PUNTED;
5eda906b 517 while (ce_stage(active_cache[i]) == 1)
fb70a06d 518 i++;
ac49f5ca
MZ
519
520 /* Only handle regular files with both stages #2 and #3 */
521 if (i + 1 < active_nr) {
9c5e6c80
NTND
522 const struct cache_entry *e2 = active_cache[i];
523 const struct cache_entry *e3 = active_cache[i + 1];
5b2fd956
SB
524 if (ce_stage(e2) == 2 &&
525 ce_stage(e3) == 3 &&
ac49f5ca 526 ce_same_name(e, e3) &&
5b2fd956 527 S_ISREG(e2->ce_mode) &&
ac49f5ca
MZ
528 S_ISREG(e3->ce_mode))
529 *type = THREE_STAGED;
530 }
531
532 /* Skip the entries with the same name */
533 while (i < active_nr && ce_same_name(e, active_cache[i]))
534 i++;
535 return i;
536}
537
4b68c2a0
JH
538/*
539 * Scan the index and find paths that have conflicts that rerere can
540 * handle, i.e. the ones that has both stages #2 and #3.
541 *
542 * NEEDSWORK: we do not record or replay a previous "resolve by
543 * deletion" for a delete-modify conflict, as that is inherently risky
544 * without knowing what modification is being discarded. The only
545 * safe case, i.e. both side doing the deletion and modification that
546 * are identical to the previous round, might want to be handled,
547 * though.
548 */
ac49f5ca
MZ
549static int find_conflict(struct string_list *conflict)
550{
551 int i;
552 if (read_cache() < 0)
2373b650 553 return error(_("index file corrupt"));
ac49f5ca
MZ
554
555 for (i = 0; i < active_nr;) {
556 int conflict_type;
9c5e6c80 557 const struct cache_entry *e = active_cache[i];
ac49f5ca
MZ
558 i = check_one_conflict(i, &conflict_type);
559 if (conflict_type == THREE_STAGED)
560 string_list_insert(conflict, (const char *)e->name);
561 }
562 return 0;
563}
564
4b68c2a0
JH
565/*
566 * The merge_rr list is meant to hold outstanding conflicted paths
567 * that rerere could handle. Abuse the list by adding other types of
568 * entries to allow the caller to show "rerere remaining".
569 *
570 * - Conflicted paths that rerere does not handle are added
571 * - Conflicted paths that have been resolved are marked as such
572 * by storing RERERE_RESOLVED to .util field (where conflict ID
573 * is expected to be stored).
574 *
575 * Do *not* write MERGE_RR file out after calling this function.
576 *
577 * NEEDSWORK: we may want to fix the caller that implements "rerere
578 * remaining" to do this without abusing merge_rr.
579 */
ac49f5ca
MZ
580int rerere_remaining(struct string_list *merge_rr)
581{
582 int i;
9dd330e6
JK
583 if (setup_rerere(merge_rr, RERERE_READONLY))
584 return 0;
ac49f5ca 585 if (read_cache() < 0)
2373b650 586 return error(_("index file corrupt"));
ac49f5ca
MZ
587
588 for (i = 0; i < active_nr;) {
589 int conflict_type;
9c5e6c80 590 const struct cache_entry *e = active_cache[i];
ac49f5ca
MZ
591 i = check_one_conflict(i, &conflict_type);
592 if (conflict_type == PUNTED)
593 string_list_insert(merge_rr, (const char *)e->name);
594 else if (conflict_type == RESOLVED) {
595 struct string_list_item *it;
596 it = string_list_lookup(merge_rr, (const char *)e->name);
597 if (it != NULL) {
1d51eced 598 free_rerere_id(it);
ac49f5ca
MZ
599 it->util = RERERE_RESOLVED;
600 }
5b2fd956
SB
601 }
602 }
603 return 0;
604}
605
0ce02b36
JH
606/*
607 * Try using the given conflict resolution "ID" to see
608 * if that recorded conflict resolves cleanly what we
609 * got in the "cur".
610 */
611static int try_merge(const struct rerere_id *id, const char *path,
612 mmfile_t *cur, mmbuffer_t *result)
613{
614 int ret;
615 mmfile_t base = {NULL, 0}, other = {NULL, 0};
616
617 if (read_mmfile(&base, rerere_path(id, "preimage")) ||
618 read_mmfile(&other, rerere_path(id, "postimage")))
619 ret = 1;
620 else
621 /*
622 * A three-way merge. Note that this honors user-customizable
623 * low-level merge driver settings.
624 */
625 ret = ll_merge(result, path, &base, NULL, cur, "", &other, "", NULL);
626
627 free(base.ptr);
628 free(other.ptr);
629
630 return ret;
631}
632
cc899eca 633/*
18bb9934 634 * Find the conflict identified by "id"; the change between its
cc899eca
JH
635 * "preimage" (i.e. a previous contents with conflict markers) and its
636 * "postimage" (i.e. the corresponding contents with conflicts
637 * resolved) may apply cleanly to the contents stored in "path", i.e.
638 * the conflict this time around.
639 *
640 * Returns 0 for successful replay of recorded resolution, or non-zero
641 * for failure.
642 */
1d51eced 643static int merge(const struct rerere_id *id, const char *path)
5b2fd956 644{
15ed07d5 645 FILE *f;
5b2fd956 646 int ret;
0ce02b36 647 mmfile_t cur = {NULL, 0};
5b2fd956 648 mmbuffer_t result = {NULL, 0};
5b2fd956 649
cc899eca
JH
650 /*
651 * Normalize the conflicts in path and write it out to
652 * "thisimage" temporary file.
653 */
0ce02b36
JH
654 if ((handle_file(path, NULL, rerere_path(id, "thisimage")) < 0) ||
655 read_mmfile(&cur, rerere_path(id, "thisimage"))) {
689b8c29
BW
656 ret = 1;
657 goto out;
658 }
cc899eca 659
0ce02b36 660 ret = try_merge(id, path, &cur, &result);
15ed07d5
JH
661 if (ret)
662 goto out;
663
664 /*
665 * A successful replay of recorded resolution.
666 * Mark that "postimage" was used to help gc.
667 */
668 if (utime(rerere_path(id, "postimage"), NULL) < 0)
2373b650 669 warning_errno(_("failed utime() on '%s'"),
033e011e 670 rerere_path(id, "postimage"));
15ed07d5
JH
671
672 /* Update "path" with the resolution */
673 f = fopen(path, "w");
674 if (!f)
2373b650 675 return error_errno(_("could not open '%s'"), path);
15ed07d5 676 if (fwrite(result.ptr, result.size, 1, f) != 1)
2373b650 677 error_errno(_("could not write '%s'"), path);
15ed07d5 678 if (fclose(f))
2373b650 679 return error_errno(_("writing '%s' failed"), path);
5b2fd956 680
689b8c29 681out:
5b2fd956 682 free(cur.ptr);
5b2fd956
SB
683 free(result.ptr);
684
685 return ret;
686}
687
89ea9035 688static void update_paths(struct string_list *update)
5b2fd956 689{
0fa5a2ed 690 struct lock_file index_lock = LOCK_INIT;
5b2fd956 691 int i;
5b2fd956 692
b3e83cc7 693 hold_locked_index(&index_lock, LOCK_DIE_ON_ERROR);
5b2fd956
SB
694
695 for (i = 0; i < update->nr; i++) {
c455c87c 696 struct string_list_item *item = &update->items[i];
89ea9035
JN
697 if (add_file_to_cache(item->string, 0))
698 exit(128);
2373b650 699 fprintf_ln(stderr, _("Staged '%s' using previous resolution."),
a14c7ab8 700 item->string);
5b2fd956
SB
701 }
702
61000814
703 if (write_locked_index(&the_index, &index_lock,
704 COMMIT_LOCK | SKIP_IF_UNCHANGED))
2373b650 705 die(_("unable to write new index file"));
5b2fd956
SB
706}
707
629716d2
JH
708static void remove_variant(struct rerere_id *id)
709{
710 unlink_or_warn(rerere_path(id, "postimage"));
711 unlink_or_warn(rerere_path(id, "preimage"));
712 id->collection->status[id->variant] = 0;
713}
714
8e7768b2
JH
715/*
716 * The path indicated by rr_item may still have conflict for which we
717 * have a recorded resolution, in which case replay it and optionally
718 * update it. Or it may have been resolved by the user and we may
719 * only have the preimage for that conflict, in which case the result
720 * needs to be recorded as a resolution in a postimage file.
721 */
722static void do_rerere_one_path(struct string_list_item *rr_item,
723 struct string_list *update)
724{
725 const char *path = rr_item->string;
a13d1370 726 struct rerere_id *id = rr_item->util;
629716d2 727 struct rerere_dir *rr_dir = id->collection;
a13d1370
JH
728 int variant;
729
a13d1370 730 variant = id->variant;
8e7768b2 731
629716d2
JH
732 /* Has the user resolved it already? */
733 if (variant >= 0) {
734 if (!handle_file(path, NULL, NULL)) {
735 copy_file(rerere_path(id, "postimage"), path, 0666);
736 id->collection->status[variant] |= RR_HAS_POSTIMAGE;
2373b650 737 fprintf_ln(stderr, _("Recorded resolution for '%s'."), path);
629716d2
JH
738 free_rerere_id(rr_item);
739 rr_item->util = NULL;
740 return;
741 }
c0a5423b 742 /*
629716d2
JH
743 * There may be other variants that can cleanly
744 * replay. Try them and update the variant number for
745 * this one.
c0a5423b 746 */
629716d2
JH
747 }
748
749 /* Does any existing resolution apply cleanly? */
750 for (variant = 0; variant < rr_dir->status_nr; variant++) {
751 const int both = RR_HAS_PREIMAGE | RR_HAS_POSTIMAGE;
752 struct rerere_id vid = *id;
753
754 if ((rr_dir->status[variant] & both) != both)
755 continue;
8e7768b2 756
629716d2
JH
757 vid.variant = variant;
758 if (merge(&vid, path))
759 continue; /* failed to replay */
760
761 /*
762 * If there already is a different variant that applies
763 * cleanly, there is no point maintaining our own variant.
764 */
765 if (0 <= id->variant && id->variant != variant)
766 remove_variant(id);
8e7768b2
JH
767
768 if (rerere_autoupdate)
769 string_list_insert(update, path);
770 else
2373b650
TG
771 fprintf_ln(stderr,
772 _("Resolved '%s' using previous resolution."),
773 path);
629716d2
JH
774 free_rerere_id(rr_item);
775 rr_item->util = NULL;
925d73c4 776 return;
8e7768b2 777 }
629716d2
JH
778
779 /* None of the existing one applies; we need a new variant */
780 assign_variant(id);
781
782 variant = id->variant;
783 handle_file(path, NULL, rerere_path(id, "preimage"));
784 if (id->collection->status[variant] & RR_HAS_POSTIMAGE) {
785 const char *path = rerere_path(id, "postimage");
786 if (unlink(path))
2373b650 787 die_errno(_("cannot unlink stray '%s'"), path);
629716d2
JH
788 id->collection->status[variant] &= ~RR_HAS_POSTIMAGE;
789 }
790 id->collection->status[variant] |= RR_HAS_PREIMAGE;
2373b650 791 fprintf_ln(stderr, _("Recorded preimage for '%s'"), path);
8e7768b2
JH
792}
793
c455c87c 794static int do_plain_rerere(struct string_list *rr, int fd)
5b2fd956 795{
183113a5
TF
796 struct string_list conflict = STRING_LIST_INIT_DUP;
797 struct string_list update = STRING_LIST_INIT_DUP;
5b2fd956
SB
798 int i;
799
800 find_conflict(&conflict);
801
802 /*
cc899eca
JH
803 * MERGE_RR records paths with conflicts immediately after
804 * merge failed. Some of the conflicted paths might have been
805 * hand resolved in the working tree since then, but the
806 * initial run would catch all and register their preimages.
5b2fd956 807 */
5b2fd956 808 for (i = 0; i < conflict.nr; i++) {
1d51eced 809 struct rerere_id *id;
c7a25d37 810 unsigned char sha1[20];
c455c87c 811 const char *path = conflict.items[i].string;
93406a28 812 int ret, has_string;
5b2fd956 813
c7a25d37
JH
814 /*
815 * Ask handle_file() to scan and assign a
816 * conflict ID. No need to write anything out
817 * yet.
818 */
819 ret = handle_file(path, sha1, NULL);
93406a28
TG
820 has_string = string_list_has_string(rr, path);
821 if (ret < 0 && has_string) {
822 remove_variant(string_list_lookup(rr, path)->util);
823 string_list_remove(rr, path, 1);
824 }
825 if (ret < 1 || has_string)
c7a25d37 826 continue;
5b2fd956 827
1d51eced 828 id = new_rerere_id(sha1);
18bb9934 829 string_list_insert(rr, path)->util = id;
cc899eca 830
c0a5423b
JH
831 /* Ensure that the directory exists. */
832 mkdir_in_gitdir(rerere_path(id, NULL));
5b2fd956
SB
833 }
834
8e7768b2
JH
835 for (i = 0; i < rr->nr; i++)
836 do_rerere_one_path(&rr->items[i], &update);
5b2fd956
SB
837
838 if (update.nr)
839 update_paths(&update);
840
841 return write_rr(rr, fd);
842}
843
633e5ad3 844static void git_rerere_config(void)
5b2fd956 845{
633e5ad3
TA
846 git_config_get_bool("rerere.enabled", &rerere_enabled);
847 git_config_get_bool("rerere.autoupdate", &rerere_autoupdate);
848 git_config(git_default_config, NULL);
5b2fd956
SB
849}
850
f932729c
JK
851static GIT_PATH_FUNC(git_path_rr_cache, "rr-cache")
852
5b2fd956
SB
853static int is_rerere_enabled(void)
854{
5b2fd956
SB
855 int rr_cache_exists;
856
857 if (!rerere_enabled)
858 return 0;
859
f932729c 860 rr_cache_exists = is_directory(git_path_rr_cache());
5b2fd956
SB
861 if (rerere_enabled < 0)
862 return rr_cache_exists;
863
f932729c 864 if (!rr_cache_exists && mkdir_in_gitdir(git_path_rr_cache()))
2373b650 865 die(_("could not create directory '%s'"), git_path_rr_cache());
5b2fd956
SB
866 return 1;
867}
868
cb6020bb 869int setup_rerere(struct string_list *merge_rr, int flags)
5b2fd956
SB
870{
871 int fd;
872
633e5ad3 873 git_rerere_config();
5b2fd956
SB
874 if (!is_rerere_enabled())
875 return -1;
876
cb6020bb
JH
877 if (flags & (RERERE_AUTOUPDATE|RERERE_NOAUTOUPDATE))
878 rerere_autoupdate = !!(flags & RERERE_AUTOUPDATE);
9dd330e6
JK
879 if (flags & RERERE_READONLY)
880 fd = 0;
881 else
882 fd = hold_lock_file_for_update(&write_lock, git_path_merge_rr(),
883 LOCK_DIE_ON_ERROR);
5b2fd956
SB
884 read_rr(merge_rr);
885 return fd;
886}
887
cc899eca
JH
888/*
889 * The main entry point that is called internally from codepaths that
890 * perform mergy operations, possibly leaving conflicted index entries
891 * and working tree files.
892 */
cb6020bb 893int rerere(int flags)
5b2fd956 894{
183113a5 895 struct string_list merge_rr = STRING_LIST_INIT_DUP;
1869bbe1 896 int fd, status;
5b2fd956 897
cb6020bb 898 fd = setup_rerere(&merge_rr, flags);
5b2fd956
SB
899 if (fd < 0)
900 return 0;
1869bbe1
JH
901 status = do_plain_rerere(&merge_rr, fd);
902 free_rerere_dirs();
903 return status;
5b2fd956 904}
dea4562b 905
3d730ed9
JH
906/*
907 * Subclass of rerere_io that reads from an in-core buffer that is a
908 * strbuf
909 */
910struct rerere_io_mem {
911 struct rerere_io io;
912 struct strbuf input;
913};
914
915/*
916 * ... and its getline() method implementation
917 */
918static int rerere_mem_getline(struct strbuf *sb, struct rerere_io *io_)
919{
920 struct rerere_io_mem *io = (struct rerere_io_mem *)io_;
921 char *ep;
922 size_t len;
923
924 strbuf_release(sb);
925 if (!io->input.len)
926 return -1;
927 ep = memchr(io->input.buf, '\n', io->input.len);
928 if (!ep)
929 ep = io->input.buf + io->input.len;
930 else if (*ep == '\n')
931 ep++;
932 len = ep - io->input.buf;
933 strbuf_add(sb, io->input.buf, len);
934 strbuf_remove(&io->input, 0, len);
935 return 0;
936}
937
938static int handle_cache(const char *path, unsigned char *sha1, const char *output)
939{
940 mmfile_t mmfile[3] = {{NULL}};
941 mmbuffer_t result = {NULL, 0};
942 const struct cache_entry *ce;
221444f5 943 int pos, len, i, has_conflicts;
3d730ed9
JH
944 struct rerere_io_mem io;
945 int marker_size = ll_merge_marker_size(path);
946
947 /*
948 * Reproduce the conflicted merge in-core
949 */
950 len = strlen(path);
951 pos = cache_name_pos(path, len);
952 if (0 <= pos)
953 return -1;
954 pos = -pos - 1;
955
956 while (pos < active_nr) {
957 enum object_type type;
958 unsigned long size;
959
960 ce = active_cache[pos++];
961 if (ce_namelen(ce) != len || memcmp(ce->name, path, len))
962 break;
963 i = ce_stage(ce) - 1;
964 if (!mmfile[i].ptr) {
b4f5aca4 965 mmfile[i].ptr = read_object_file(&ce->oid, &type,
966 &size);
3d730ed9
JH
967 mmfile[i].size = size;
968 }
969 }
970 for (i = 0; i < 3; i++)
971 if (!mmfile[i].ptr && !mmfile[i].size)
972 mmfile[i].ptr = xstrdup("");
973
974 /*
975 * NEEDSWORK: handle conflicts from merges with
976 * merge.renormalize set, too?
977 */
978 ll_merge(&result, path, &mmfile[0], NULL,
979 &mmfile[1], "ours",
980 &mmfile[2], "theirs", NULL);
981 for (i = 0; i < 3; i++)
982 free(mmfile[i].ptr);
983
984 memset(&io, 0, sizeof(io));
985 io.io.getline = rerere_mem_getline;
986 if (output)
987 io.io.output = fopen(output, "w");
988 else
989 io.io.output = NULL;
990 strbuf_init(&io.input, 0);
991 strbuf_attach(&io.input, result.ptr, result.size, result.size);
992
993 /*
994 * Grab the conflict ID and optionally write the original
995 * contents with conflict markers out.
996 */
221444f5 997 has_conflicts = handle_path(sha1, (struct rerere_io *)&io, marker_size);
3d730ed9
JH
998 strbuf_release(&io.input);
999 if (io.io.output)
1000 fclose(io.io.output);
221444f5 1001 return has_conflicts;
5b2fd956 1002}
dea4562b
JH
1003
1004static int rerere_forget_one_path(const char *path, struct string_list *rr)
1005{
1006 const char *filename;
1d51eced 1007 struct rerere_id *id;
dea4562b
JH
1008 unsigned char sha1[20];
1009 int ret;
8d9b5a4a 1010 struct string_list_item *item;
dea4562b 1011
963ec003
JH
1012 /*
1013 * Recreate the original conflict from the stages in the
1014 * index and compute the conflict ID
1015 */
dea4562b
JH
1016 ret = handle_cache(path, sha1, NULL);
1017 if (ret < 1)
2373b650 1018 return error(_("could not parse conflict hunks in '%s'"), path);
963ec003
JH
1019
1020 /* Nuke the recorded resolution for the conflict */
1d51eced 1021 id = new_rerere_id(sha1);
890fca84
JH
1022
1023 for (id->variant = 0;
1024 id->variant < id->collection->status_nr;
1025 id->variant++) {
1026 mmfile_t cur = { NULL, 0 };
1027 mmbuffer_t result = {NULL, 0};
1028 int cleanly_resolved;
1029
1030 if (!has_rerere_resolution(id))
1031 continue;
1032
1033 handle_cache(path, sha1, rerere_path(id, "thisimage"));
1034 if (read_mmfile(&cur, rerere_path(id, "thisimage"))) {
1035 free(cur.ptr);
2373b650 1036 error(_("failed to update conflicted state in '%s'"), path);
8f449614 1037 goto fail_exit;
890fca84
JH
1038 }
1039 cleanly_resolved = !try_merge(id, path, &cur, &result);
1040 free(result.ptr);
1041 free(cur.ptr);
1042 if (cleanly_resolved)
1043 break;
1044 }
1045
8f449614 1046 if (id->collection->status_nr <= id->variant) {
2373b650 1047 error(_("no remembered resolution for '%s'"), path);
8f449614
JH
1048 goto fail_exit;
1049 }
890fca84 1050
18bb9934 1051 filename = rerere_path(id, "postimage");
8f449614
JH
1052 if (unlink(filename)) {
1053 if (errno == ENOENT)
2373b650 1054 error(_("no remembered resolution for '%s'"), path);
8f449614 1055 else
2373b650 1056 error_errno(_("cannot unlink '%s'"), filename);
8f449614 1057 goto fail_exit;
d9d501b0 1058 }
dea4562b 1059
963ec003
JH
1060 /*
1061 * Update the preimage so that the user can resolve the
1062 * conflict in the working tree, run us again to record
1063 * the postimage.
1064 */
18bb9934 1065 handle_cache(path, sha1, rerere_path(id, "preimage"));
2373b650 1066 fprintf_ln(stderr, _("Updated preimage for '%s'"), path);
dea4562b 1067
963ec003
JH
1068 /*
1069 * And remember that we can record resolution for this
1070 * conflict when the user is done.
1071 */
8d9b5a4a 1072 item = string_list_insert(rr, path);
1d51eced 1073 free_rerere_id(item);
18bb9934 1074 item->util = id;
2373b650 1075 fprintf(stderr, _("Forgot resolution for '%s'\n"), path);
dea4562b 1076 return 0;
8f449614
JH
1077
1078fail_exit:
1079 free(id);
1080 return -1;
dea4562b
JH
1081}
1082
01a10b0a 1083int rerere_forget(struct pathspec *pathspec)
dea4562b
JH
1084{
1085 int i, fd;
183113a5
TF
1086 struct string_list conflict = STRING_LIST_INIT_DUP;
1087 struct string_list merge_rr = STRING_LIST_INIT_DUP;
dea4562b
JH
1088
1089 if (read_cache() < 0)
2373b650 1090 return error(_("index file corrupt"));
dea4562b 1091
6751e047 1092 fd = setup_rerere(&merge_rr, RERERE_NOAUTOUPDATE);
0544574c
JK
1093 if (fd < 0)
1094 return 0;
dea4562b 1095
963ec003
JH
1096 /*
1097 * The paths may have been resolved (incorrectly);
1098 * recover the original conflicted state and then
1099 * find the conflicted paths.
1100 */
dea4562b
JH
1101 unmerge_cache(pathspec);
1102 find_conflict(&conflict);
1103 for (i = 0; i < conflict.nr; i++) {
1104 struct string_list_item *it = &conflict.items[i];
854b0959 1105 if (!match_pathspec(pathspec, it->string,
ae8d0824 1106 strlen(it->string), 0, NULL, 0))
dea4562b
JH
1107 continue;
1108 rerere_forget_one_path(it->string, &merge_rr);
1109 }
1110 return write_rr(&merge_rr, fd);
1111}
0f891e7d 1112
e828de82
JH
1113/*
1114 * Garbage collection support
1115 */
1d51eced 1116
5ea82279 1117static timestamp_t rerere_created_at(struct rerere_id *id)
0f891e7d
JH
1118{
1119 struct stat st;
1d51eced 1120
18bb9934 1121 return stat(rerere_path(id, "preimage"), &st) ? (time_t) 0 : st.st_mtime;
0f891e7d
JH
1122}
1123
5ea82279 1124static timestamp_t rerere_last_used_at(struct rerere_id *id)
0f891e7d
JH
1125{
1126 struct stat st;
1d51eced 1127
18bb9934 1128 return stat(rerere_path(id, "postimage"), &st) ? (time_t) 0 : st.st_mtime;
0f891e7d
JH
1129}
1130
e828de82
JH
1131/*
1132 * Remove the recorded resolution for a given conflict ID
1133 */
1d51eced 1134static void unlink_rr_item(struct rerere_id *id)
0f891e7d 1135{
1be1e851
JH
1136 unlink_or_warn(rerere_path(id, "thisimage"));
1137 remove_variant(id);
1138 id->collection->status[id->variant] = 0;
1139}
1140
5ea82279
JH
1141static void prune_one(struct rerere_id *id,
1142 timestamp_t cutoff_resolve, timestamp_t cutoff_noresolve)
1be1e851 1143{
5ea82279
JH
1144 timestamp_t then;
1145 timestamp_t cutoff;
1be1e851
JH
1146
1147 then = rerere_last_used_at(id);
1148 if (then)
1149 cutoff = cutoff_resolve;
1150 else {
1151 then = rerere_created_at(id);
1152 if (!then)
1153 return;
1154 cutoff = cutoff_noresolve;
1155 }
5ea82279 1156 if (then < cutoff)
1be1e851 1157 unlink_rr_item(id);
0f891e7d
JH
1158}
1159
0f891e7d
JH
1160void rerere_gc(struct string_list *rr)
1161{
1162 struct string_list to_remove = STRING_LIST_INIT_DUP;
1163 DIR *dir;
1164 struct dirent *e;
1be1e851 1165 int i;
5ea82279
JH
1166 timestamp_t now = time(NULL);
1167 timestamp_t cutoff_noresolve = now - 15 * 86400;
1168 timestamp_t cutoff_resolve = now - 60 * 86400;
0f891e7d 1169
9dd330e6
JK
1170 if (setup_rerere(rr, 0) < 0)
1171 return;
1172
6e96cb52
JH
1173 git_config_get_expiry_in_days("gc.rerereresolved", &cutoff_resolve, now);
1174 git_config_get_expiry_in_days("gc.rerereunresolved", &cutoff_noresolve, now);
633e5ad3 1175 git_config(git_default_config, NULL);
0f891e7d
JH
1176 dir = opendir(git_path("rr-cache"));
1177 if (!dir)
2373b650 1178 die_errno(_("unable to open rr-cache directory"));
e828de82 1179 /* Collect stale conflict IDs ... */
0f891e7d 1180 while ((e = readdir(dir))) {
1be1e851
JH
1181 struct rerere_dir *rr_dir;
1182 struct rerere_id id;
1183 int now_empty;
1184
0f891e7d
JH
1185 if (is_dot_or_dotdot(e->d_name))
1186 continue;
1be1e851
JH
1187 rr_dir = find_rerere_dir(e->d_name);
1188 if (!rr_dir)
1189 continue; /* or should we remove e->d_name? */
1190
1191 now_empty = 1;
1192 for (id.variant = 0, id.collection = rr_dir;
1193 id.variant < id.collection->status_nr;
1194 id.variant++) {
5ea82279 1195 prune_one(&id, cutoff_resolve, cutoff_noresolve);
1be1e851
JH
1196 if (id.collection->status[id.variant])
1197 now_empty = 0;
0f891e7d 1198 }
1be1e851 1199 if (now_empty)
0f891e7d
JH
1200 string_list_append(&to_remove, e->d_name);
1201 }
a9930e35 1202 closedir(dir);
1be1e851
JH
1203
1204 /* ... and then remove the empty directories */
0f891e7d 1205 for (i = 0; i < to_remove.nr; i++)
1be1e851 1206 rmdir(git_path("rr-cache/%s", to_remove.items[i].string));
0f891e7d 1207 string_list_clear(&to_remove, 0);
9dd330e6 1208 rollback_lock_file(&write_lock);
0f891e7d
JH
1209}
1210
e828de82
JH
1211/*
1212 * During a conflict resolution, after "rerere" recorded the
1213 * preimages, abandon them if the user did not resolve them or
1214 * record their resolutions. And drop $GIT_DIR/MERGE_RR.
1215 *
1216 * NEEDSWORK: shouldn't we be calling this from "reset --hard"?
1217 */
0f891e7d
JH
1218void rerere_clear(struct string_list *merge_rr)
1219{
1220 int i;
1221
9dd330e6
JK
1222 if (setup_rerere(merge_rr, 0) < 0)
1223 return;
1224
0f891e7d 1225 for (i = 0; i < merge_rr->nr; i++) {
1d51eced 1226 struct rerere_id *id = merge_rr->items[i].util;
1be1e851 1227 if (!has_rerere_resolution(id)) {
18bb9934 1228 unlink_rr_item(id);
1be1e851
JH
1229 rmdir(rerere_path(id, NULL));
1230 }
0f891e7d 1231 }
f932729c 1232 unlink_or_warn(git_path_merge_rr());
9dd330e6 1233 rollback_lock_file(&write_lock);
0f891e7d 1234}