1 #include "git-compat-util.h"
9 #include "string-list.h"
10 #include "read-cache-ll.h"
12 #include "xdiff-interface.h"
14 #include "resolve-undo.h"
19 #include "object-file.h"
20 #include "object-store-ll.h"
21 #include "hash-lookup.h"
27 #define THREE_STAGED 2
28 void *RERERE_RESOLVED
= &RERERE_RESOLVED
;
30 /* if rerere_enabled == -1, fall back to detection of .git/rr-cache */
31 static int rerere_enabled
= -1;
33 /* automatically update cleanly resolved paths to the index */
34 static int rerere_autoupdate
;
36 #define RR_HAS_POSTIMAGE 1
37 #define RR_HAS_PREIMAGE 2
39 int status_alloc
, status_nr
;
40 unsigned char *status
;
41 char name
[FLEX_ARRAY
];
44 static struct strmap rerere_dirs
= STRMAP_INIT
;
46 static void free_rerere_dirs(void)
48 struct hashmap_iter iter
;
49 struct strmap_entry
*ent
;
51 strmap_for_each_entry(&rerere_dirs
, &iter
, ent
) {
52 struct rerere_dir
*rr_dir
= ent
->value
;
56 strmap_clear(&rerere_dirs
, 0);
59 static void free_rerere_id(struct string_list_item
*item
)
64 static const char *rerere_id_hex(const struct rerere_id
*id
)
66 return id
->collection
->name
;
69 static void fit_variant(struct rerere_dir
*rr_dir
, int variant
)
72 ALLOC_GROW(rr_dir
->status
, variant
, rr_dir
->status_alloc
);
73 if (rr_dir
->status_nr
< variant
) {
74 memset(rr_dir
->status
+ rr_dir
->status_nr
,
75 '\0', variant
- rr_dir
->status_nr
);
76 rr_dir
->status_nr
= variant
;
80 static void assign_variant(struct rerere_id
*id
)
83 struct rerere_dir
*rr_dir
= id
->collection
;
85 variant
= id
->variant
;
87 for (variant
= 0; variant
< rr_dir
->status_nr
; variant
++)
88 if (!rr_dir
->status
[variant
])
91 fit_variant(rr_dir
, variant
);
92 id
->variant
= variant
;
95 const char *rerere_path(const struct rerere_id
*id
, const char *file
)
98 return git_path("rr-cache/%s", rerere_id_hex(id
));
100 if (id
->variant
<= 0)
101 return git_path("rr-cache/%s/%s", rerere_id_hex(id
), file
);
103 return git_path("rr-cache/%s/%s.%d",
104 rerere_id_hex(id
), file
, id
->variant
);
107 static int is_rr_file(const char *name
, const char *filename
, int *variant
)
112 if (!strcmp(name
, filename
)) {
116 if (!skip_prefix(name
, filename
, &suffix
) || *suffix
!= '.')
120 *variant
= strtol(suffix
+ 1, &ep
, 10);
126 static void scan_rerere_dir(struct rerere_dir
*rr_dir
)
129 DIR *dir
= opendir(git_path("rr-cache/%s", rr_dir
->name
));
133 while ((de
= readdir(dir
)) != NULL
) {
136 if (is_rr_file(de
->d_name
, "postimage", &variant
)) {
137 fit_variant(rr_dir
, variant
);
138 rr_dir
->status
[variant
] |= RR_HAS_POSTIMAGE
;
139 } else if (is_rr_file(de
->d_name
, "preimage", &variant
)) {
140 fit_variant(rr_dir
, variant
);
141 rr_dir
->status
[variant
] |= RR_HAS_PREIMAGE
;
147 static struct rerere_dir
*find_rerere_dir(const char *hex
)
149 struct rerere_dir
*rr_dir
;
151 rr_dir
= strmap_get(&rerere_dirs
, hex
);
153 FLEX_ALLOC_STR(rr_dir
, name
, hex
);
154 rr_dir
->status
= NULL
;
155 rr_dir
->status_nr
= 0;
156 rr_dir
->status_alloc
= 0;
157 strmap_put(&rerere_dirs
, hex
, rr_dir
);
159 scan_rerere_dir(rr_dir
);
164 static int has_rerere_resolution(const struct rerere_id
*id
)
166 const int both
= RR_HAS_POSTIMAGE
|RR_HAS_PREIMAGE
;
167 int variant
= id
->variant
;
171 return ((id
->collection
->status
[variant
] & both
) == both
);
174 static struct rerere_id
*new_rerere_id_hex(char *hex
)
176 struct rerere_id
*id
= xmalloc(sizeof(*id
));
177 id
->collection
= find_rerere_dir(hex
);
178 id
->variant
= -1; /* not known yet */
182 static struct rerere_id
*new_rerere_id(unsigned char *hash
)
184 return new_rerere_id_hex(hash_to_hex(hash
));
188 * $GIT_DIR/MERGE_RR file is a collection of records, each of which is
189 * "conflict ID", a HT and pathname, terminated with a NUL, and is
190 * used to keep track of the set of paths that "rerere" may need to
191 * work on (i.e. what is left by the previous invocation of "git
192 * rerere" during the current conflict resolution session).
194 static void read_rr(struct repository
*r
, struct string_list
*rr
)
196 struct strbuf buf
= STRBUF_INIT
;
197 FILE *in
= fopen_or_warn(git_path_merge_rr(r
), "r");
201 while (!strbuf_getwholeline(&buf
, in
, '\0')) {
203 unsigned char hash
[GIT_MAX_RAWSZ
];
204 struct rerere_id
*id
;
206 const unsigned hexsz
= the_hash_algo
->hexsz
;
208 /* There has to be the hash, tab, path and then NUL */
209 if (buf
.len
< hexsz
+ 2 || get_sha1_hex(buf
.buf
, hash
))
210 die(_("corrupt MERGE_RR"));
212 if (buf
.buf
[hexsz
] != '.') {
214 path
= buf
.buf
+ hexsz
;
217 variant
= strtol(buf
.buf
+ hexsz
+ 1, &path
, 10);
219 die(_("corrupt MERGE_RR"));
221 if (*(path
++) != '\t')
222 die(_("corrupt MERGE_RR"));
223 buf
.buf
[hexsz
] = '\0';
224 id
= new_rerere_id_hex(buf
.buf
);
225 id
->variant
= variant
;
226 string_list_insert(rr
, path
)->util
= id
;
228 strbuf_release(&buf
);
232 static struct lock_file write_lock
;
234 static int write_rr(struct string_list
*rr
, int out_fd
)
237 for (i
= 0; i
< rr
->nr
; i
++) {
238 struct strbuf buf
= STRBUF_INIT
;
239 struct rerere_id
*id
;
241 assert(rr
->items
[i
].util
!= RERERE_RESOLVED
);
243 id
= rr
->items
[i
].util
;
246 assert(id
->variant
>= 0);
248 strbuf_addf(&buf
, "%s.%d\t%s%c",
249 rerere_id_hex(id
), id
->variant
,
250 rr
->items
[i
].string
, 0);
252 strbuf_addf(&buf
, "%s\t%s%c",
254 rr
->items
[i
].string
, 0);
256 if (write_in_full(out_fd
, buf
.buf
, buf
.len
) < 0)
257 die(_("unable to write rerere record"));
259 strbuf_release(&buf
);
261 if (commit_lock_file(&write_lock
) != 0)
262 die(_("unable to write rerere record"));
267 * "rerere" interacts with conflicted file contents using this I/O
268 * abstraction. It reads a conflicted contents from one place via
269 * "getline()" method, and optionally can write it out after
270 * normalizing the conflicted hunks to the "output". Subclasses of
271 * rerere_io embed this structure at the beginning of their own
275 int (*getline
)(struct strbuf
*, struct rerere_io
*);
278 /* some more stuff */
281 static void ferr_write(const void *p
, size_t count
, FILE *fp
, int *err
)
285 if (fwrite(p
, count
, 1, fp
) != 1)
289 static inline void ferr_puts(const char *s
, FILE *fp
, int *err
)
291 ferr_write(s
, strlen(s
), fp
, err
);
294 static void rerere_io_putstr(const char *str
, struct rerere_io
*io
)
297 ferr_puts(str
, io
->output
, &io
->wrerror
);
300 static void rerere_io_putmem(const char *mem
, size_t sz
, struct rerere_io
*io
)
303 ferr_write(mem
, sz
, io
->output
, &io
->wrerror
);
307 * Subclass of rerere_io that reads from an on-disk file
309 struct rerere_io_file
{
315 * ... and its getline() method implementation
317 static int rerere_file_getline(struct strbuf
*sb
, struct rerere_io
*io_
)
319 struct rerere_io_file
*io
= (struct rerere_io_file
*)io_
;
320 return strbuf_getwholeline(sb
, io
->input
, '\n');
324 * Require the exact number of conflict marker letters, no more, no
325 * less, followed by SP or any whitespace
328 static int is_cmarker(char *buf
, int marker_char
, int marker_size
)
333 * The beginning of our version and the end of their version
334 * always are labeled like "<<<<< ours" or ">>>>> theirs",
335 * hence we set want_sp for them. Note that the version from
336 * the common ancestor in diff3-style output is not always
337 * labelled (e.g. "||||| common" is often seen but "|||||"
338 * alone is also valid), so we do not set want_sp.
340 want_sp
= (marker_char
== '<') || (marker_char
== '>');
342 while (marker_size
--)
343 if (*buf
++ != marker_char
)
345 if (want_sp
&& *buf
!= ' ')
347 return isspace(*buf
);
350 static void rerere_strbuf_putconflict(struct strbuf
*buf
, int ch
, size_t size
)
352 strbuf_addchars(buf
, ch
, size
);
353 strbuf_addch(buf
, '\n');
356 static int handle_conflict(struct strbuf
*out
, struct rerere_io
*io
,
357 int marker_size
, git_hash_ctx
*ctx
)
360 RR_SIDE_1
= 0, RR_SIDE_2
, RR_ORIGINAL
362 struct strbuf one
= STRBUF_INIT
, two
= STRBUF_INIT
;
363 struct strbuf buf
= STRBUF_INIT
, conflict
= STRBUF_INIT
;
364 int has_conflicts
= -1;
366 while (!io
->getline(&buf
, io
)) {
367 if (is_cmarker(buf
.buf
, '<', marker_size
)) {
368 if (handle_conflict(&conflict
, io
, marker_size
, NULL
) < 0)
370 if (hunk
== RR_SIDE_1
)
371 strbuf_addbuf(&one
, &conflict
);
373 strbuf_addbuf(&two
, &conflict
);
374 strbuf_release(&conflict
);
375 } else if (is_cmarker(buf
.buf
, '|', marker_size
)) {
376 if (hunk
!= RR_SIDE_1
)
379 } else if (is_cmarker(buf
.buf
, '=', marker_size
)) {
380 if (hunk
!= RR_SIDE_1
&& hunk
!= RR_ORIGINAL
)
383 } else if (is_cmarker(buf
.buf
, '>', marker_size
)) {
384 if (hunk
!= RR_SIDE_2
)
386 if (strbuf_cmp(&one
, &two
) > 0)
387 strbuf_swap(&one
, &two
);
389 rerere_strbuf_putconflict(out
, '<', marker_size
);
390 strbuf_addbuf(out
, &one
);
391 rerere_strbuf_putconflict(out
, '=', marker_size
);
392 strbuf_addbuf(out
, &two
);
393 rerere_strbuf_putconflict(out
, '>', marker_size
);
395 the_hash_algo
->update_fn(ctx
, one
.buf
?
398 the_hash_algo
->update_fn(ctx
, two
.buf
?
403 } else if (hunk
== RR_SIDE_1
)
404 strbuf_addbuf(&one
, &buf
);
405 else if (hunk
== RR_ORIGINAL
)
407 else if (hunk
== RR_SIDE_2
)
408 strbuf_addbuf(&two
, &buf
);
410 strbuf_release(&one
);
411 strbuf_release(&two
);
412 strbuf_release(&buf
);
414 return has_conflicts
;
418 * Read contents a file with conflicts, normalize the conflicts
419 * by (1) discarding the common ancestor version in diff3-style,
420 * (2) reordering our side and their side so that whichever sorts
421 * alphabetically earlier comes before the other one, while
422 * computing the "conflict ID", which is just an SHA-1 hash of
423 * one side of the conflict, NUL, the other side of the conflict,
424 * and NUL concatenated together.
426 * Return 1 if conflict hunks are found, 0 if there are no conflict
427 * hunks and -1 if an error occurred.
429 static int handle_path(unsigned char *hash
, struct rerere_io
*io
, int marker_size
)
432 struct strbuf buf
= STRBUF_INIT
, out
= STRBUF_INIT
;
433 int has_conflicts
= 0;
435 the_hash_algo
->init_fn(&ctx
);
437 while (!io
->getline(&buf
, io
)) {
438 if (is_cmarker(buf
.buf
, '<', marker_size
)) {
439 has_conflicts
= handle_conflict(&out
, io
, marker_size
,
441 if (has_conflicts
< 0)
443 rerere_io_putmem(out
.buf
, out
.len
, io
);
446 rerere_io_putstr(buf
.buf
, io
);
448 strbuf_release(&buf
);
449 strbuf_release(&out
);
452 the_hash_algo
->final_fn(hash
, &ctx
);
454 return has_conflicts
;
458 * Scan the path for conflicts, do the "handle_path()" thing above, and
459 * return the number of conflict hunks found.
461 static int handle_file(struct index_state
*istate
,
462 const char *path
, unsigned char *hash
, const char *output
)
464 int has_conflicts
= 0;
465 struct rerere_io_file io
;
466 int marker_size
= ll_merge_marker_size(istate
, path
);
468 memset(&io
, 0, sizeof(io
));
469 io
.io
.getline
= rerere_file_getline
;
470 io
.input
= fopen(path
, "r");
473 return error_errno(_("could not open '%s'"), path
);
476 io
.io
.output
= fopen(output
, "w");
478 error_errno(_("could not write '%s'"), output
);
484 has_conflicts
= handle_path(hash
, (struct rerere_io
*)&io
, marker_size
);
488 error(_("there were errors while writing '%s' (%s)"),
489 path
, strerror(io
.io
.wrerror
));
490 if (io
.io
.output
&& fclose(io
.io
.output
))
491 io
.io
.wrerror
= error_errno(_("failed to flush '%s'"), path
);
493 if (has_conflicts
< 0) {
495 unlink_or_warn(output
);
496 return error(_("could not parse conflict hunks in '%s'"), path
);
500 return has_conflicts
;
504 * Look at a cache entry at "i" and see if it is not conflicting,
505 * conflicting and we are willing to handle, or conflicting and
506 * we are unable to handle, and return the determination in *type.
507 * Return the cache index to be looked at next, by skipping the
508 * stages we have already looked at in this invocation of this
511 static int check_one_conflict(struct index_state
*istate
, int i
, int *type
)
513 const struct cache_entry
*e
= istate
->cache
[i
];
521 while (i
< istate
->cache_nr
&& ce_stage(istate
->cache
[i
]) == 1)
524 /* Only handle regular files with both stages #2 and #3 */
525 if (i
+ 1 < istate
->cache_nr
) {
526 const struct cache_entry
*e2
= istate
->cache
[i
];
527 const struct cache_entry
*e3
= istate
->cache
[i
+ 1];
528 if (ce_stage(e2
) == 2 &&
530 ce_same_name(e
, e3
) &&
531 S_ISREG(e2
->ce_mode
) &&
532 S_ISREG(e3
->ce_mode
))
533 *type
= THREE_STAGED
;
536 /* Skip the entries with the same name */
537 while (i
< istate
->cache_nr
&& ce_same_name(e
, istate
->cache
[i
]))
543 * Scan the index and find paths that have conflicts that rerere can
544 * handle, i.e. the ones that has both stages #2 and #3.
546 * NEEDSWORK: we do not record or replay a previous "resolve by
547 * deletion" for a delete-modify conflict, as that is inherently risky
548 * without knowing what modification is being discarded. The only
549 * safe case, i.e. both side doing the deletion and modification that
550 * are identical to the previous round, might want to be handled,
553 static int find_conflict(struct repository
*r
, struct string_list
*conflict
)
557 if (repo_read_index(r
) < 0)
558 return error(_("index file corrupt"));
560 for (i
= 0; i
< r
->index
->cache_nr
;) {
562 const struct cache_entry
*e
= r
->index
->cache
[i
];
563 i
= check_one_conflict(r
->index
, i
, &conflict_type
);
564 if (conflict_type
== THREE_STAGED
)
565 string_list_insert(conflict
, (const char *)e
->name
);
571 * The merge_rr list is meant to hold outstanding conflicted paths
572 * that rerere could handle. Abuse the list by adding other types of
573 * entries to allow the caller to show "rerere remaining".
575 * - Conflicted paths that rerere does not handle are added
576 * - Conflicted paths that have been resolved are marked as such
577 * by storing RERERE_RESOLVED to .util field (where conflict ID
578 * is expected to be stored).
580 * Do *not* write MERGE_RR file out after calling this function.
582 * NEEDSWORK: we may want to fix the caller that implements "rerere
583 * remaining" to do this without abusing merge_rr.
585 int rerere_remaining(struct repository
*r
, struct string_list
*merge_rr
)
589 if (setup_rerere(r
, merge_rr
, RERERE_READONLY
))
591 if (repo_read_index(r
) < 0)
592 return error(_("index file corrupt"));
594 for (i
= 0; i
< r
->index
->cache_nr
;) {
596 const struct cache_entry
*e
= r
->index
->cache
[i
];
597 i
= check_one_conflict(r
->index
, i
, &conflict_type
);
598 if (conflict_type
== PUNTED
)
599 string_list_insert(merge_rr
, (const char *)e
->name
);
600 else if (conflict_type
== RESOLVED
) {
601 struct string_list_item
*it
;
602 it
= string_list_lookup(merge_rr
, (const char *)e
->name
);
605 it
->util
= RERERE_RESOLVED
;
613 * Try using the given conflict resolution "ID" to see
614 * if that recorded conflict resolves cleanly what we
617 static int try_merge(struct index_state
*istate
,
618 const struct rerere_id
*id
, const char *path
,
619 mmfile_t
*cur
, mmbuffer_t
*result
)
621 enum ll_merge_result ret
;
622 mmfile_t base
= {NULL
, 0}, other
= {NULL
, 0};
624 if (read_mmfile(&base
, rerere_path(id
, "preimage")) ||
625 read_mmfile(&other
, rerere_path(id
, "postimage"))) {
626 ret
= LL_MERGE_CONFLICT
;
629 * A three-way merge. Note that this honors user-customizable
630 * low-level merge driver settings.
632 ret
= ll_merge(result
, path
, &base
, NULL
, cur
, "", &other
, "",
643 * Find the conflict identified by "id"; the change between its
644 * "preimage" (i.e. a previous contents with conflict markers) and its
645 * "postimage" (i.e. the corresponding contents with conflicts
646 * resolved) may apply cleanly to the contents stored in "path", i.e.
647 * the conflict this time around.
649 * Returns 0 for successful replay of recorded resolution, or non-zero
652 static int merge(struct index_state
*istate
, const struct rerere_id
*id
, const char *path
)
656 mmfile_t cur
= {NULL
, 0};
657 mmbuffer_t result
= {NULL
, 0};
660 * Normalize the conflicts in path and write it out to
661 * "thisimage" temporary file.
663 if ((handle_file(istate
, path
, NULL
, rerere_path(id
, "thisimage")) < 0) ||
664 read_mmfile(&cur
, rerere_path(id
, "thisimage"))) {
669 ret
= try_merge(istate
, id
, path
, &cur
, &result
);
674 * A successful replay of recorded resolution.
675 * Mark that "postimage" was used to help gc.
677 if (utime(rerere_path(id
, "postimage"), NULL
) < 0)
678 warning_errno(_("failed utime() on '%s'"),
679 rerere_path(id
, "postimage"));
681 /* Update "path" with the resolution */
682 f
= fopen(path
, "w");
684 return error_errno(_("could not open '%s'"), path
);
685 if (fwrite(result
.ptr
, result
.size
, 1, f
) != 1)
686 error_errno(_("could not write '%s'"), path
);
688 return error_errno(_("writing '%s' failed"), path
);
697 static void update_paths(struct repository
*r
, struct string_list
*update
)
699 struct lock_file index_lock
= LOCK_INIT
;
702 repo_hold_locked_index(r
, &index_lock
, LOCK_DIE_ON_ERROR
);
704 for (i
= 0; i
< update
->nr
; i
++) {
705 struct string_list_item
*item
= &update
->items
[i
];
706 if (add_file_to_index(r
->index
, item
->string
, 0))
708 fprintf_ln(stderr
, _("Staged '%s' using previous resolution."),
712 if (write_locked_index(r
->index
, &index_lock
,
713 COMMIT_LOCK
| SKIP_IF_UNCHANGED
))
714 die(_("unable to write new index file"));
717 static void remove_variant(struct rerere_id
*id
)
719 unlink_or_warn(rerere_path(id
, "postimage"));
720 unlink_or_warn(rerere_path(id
, "preimage"));
721 id
->collection
->status
[id
->variant
] = 0;
725 * The path indicated by rr_item may still have conflict for which we
726 * have a recorded resolution, in which case replay it and optionally
727 * update it. Or it may have been resolved by the user and we may
728 * only have the preimage for that conflict, in which case the result
729 * needs to be recorded as a resolution in a postimage file.
731 static void do_rerere_one_path(struct index_state
*istate
,
732 struct string_list_item
*rr_item
,
733 struct string_list
*update
)
735 const char *path
= rr_item
->string
;
736 struct rerere_id
*id
= rr_item
->util
;
737 struct rerere_dir
*rr_dir
= id
->collection
;
740 variant
= id
->variant
;
742 /* Has the user resolved it already? */
744 if (!handle_file(istate
, path
, NULL
, NULL
)) {
745 copy_file(rerere_path(id
, "postimage"), path
, 0666);
746 id
->collection
->status
[variant
] |= RR_HAS_POSTIMAGE
;
747 fprintf_ln(stderr
, _("Recorded resolution for '%s'."), path
);
748 free_rerere_id(rr_item
);
749 rr_item
->util
= NULL
;
753 * There may be other variants that can cleanly
754 * replay. Try them and update the variant number for
759 /* Does any existing resolution apply cleanly? */
760 for (variant
= 0; variant
< rr_dir
->status_nr
; variant
++) {
761 const int both
= RR_HAS_PREIMAGE
| RR_HAS_POSTIMAGE
;
762 struct rerere_id vid
= *id
;
764 if ((rr_dir
->status
[variant
] & both
) != both
)
767 vid
.variant
= variant
;
768 if (merge(istate
, &vid
, path
))
769 continue; /* failed to replay */
772 * If there already is a different variant that applies
773 * cleanly, there is no point maintaining our own variant.
775 if (0 <= id
->variant
&& id
->variant
!= variant
)
778 if (rerere_autoupdate
)
779 string_list_insert(update
, path
);
782 _("Resolved '%s' using previous resolution."),
784 free_rerere_id(rr_item
);
785 rr_item
->util
= NULL
;
789 /* None of the existing one applies; we need a new variant */
792 variant
= id
->variant
;
793 handle_file(istate
, path
, NULL
, rerere_path(id
, "preimage"));
794 if (id
->collection
->status
[variant
] & RR_HAS_POSTIMAGE
) {
795 const char *path
= rerere_path(id
, "postimage");
797 die_errno(_("cannot unlink stray '%s'"), path
);
798 id
->collection
->status
[variant
] &= ~RR_HAS_POSTIMAGE
;
800 id
->collection
->status
[variant
] |= RR_HAS_PREIMAGE
;
801 fprintf_ln(stderr
, _("Recorded preimage for '%s'"), path
);
804 static int do_plain_rerere(struct repository
*r
,
805 struct string_list
*rr
, int fd
)
807 struct string_list conflict
= STRING_LIST_INIT_DUP
;
808 struct string_list update
= STRING_LIST_INIT_DUP
;
811 find_conflict(r
, &conflict
);
814 * MERGE_RR records paths with conflicts immediately after
815 * merge failed. Some of the conflicted paths might have been
816 * hand resolved in the working tree since then, but the
817 * initial run would catch all and register their preimages.
819 for (i
= 0; i
< conflict
.nr
; i
++) {
820 struct rerere_id
*id
;
821 unsigned char hash
[GIT_MAX_RAWSZ
];
822 const char *path
= conflict
.items
[i
].string
;
826 * Ask handle_file() to scan and assign a
827 * conflict ID. No need to write anything out
830 ret
= handle_file(r
->index
, path
, hash
, NULL
);
831 if (ret
!= 0 && string_list_has_string(rr
, path
)) {
832 remove_variant(string_list_lookup(rr
, path
)->util
);
833 string_list_remove(rr
, path
, 1);
838 id
= new_rerere_id(hash
);
839 string_list_insert(rr
, path
)->util
= id
;
841 /* Ensure that the directory exists. */
842 mkdir_in_gitdir(rerere_path(id
, NULL
));
845 for (i
= 0; i
< rr
->nr
; i
++)
846 do_rerere_one_path(r
->index
, &rr
->items
[i
], &update
);
849 update_paths(r
, &update
);
851 return write_rr(rr
, fd
);
854 static void git_rerere_config(void)
856 git_config_get_bool("rerere.enabled", &rerere_enabled
);
857 git_config_get_bool("rerere.autoupdate", &rerere_autoupdate
);
858 git_config(git_default_config
, NULL
);
861 static GIT_PATH_FUNC(git_path_rr_cache
, "rr-cache")
863 static int is_rerere_enabled(void)
870 rr_cache_exists
= is_directory(git_path_rr_cache());
871 if (rerere_enabled
< 0)
872 return rr_cache_exists
;
874 if (!rr_cache_exists
&& mkdir_in_gitdir(git_path_rr_cache()))
875 die(_("could not create directory '%s'"), git_path_rr_cache());
879 int setup_rerere(struct repository
*r
, struct string_list
*merge_rr
, int flags
)
884 if (!is_rerere_enabled())
887 if (flags
& (RERERE_AUTOUPDATE
|RERERE_NOAUTOUPDATE
))
888 rerere_autoupdate
= !!(flags
& RERERE_AUTOUPDATE
);
889 if (flags
& RERERE_READONLY
)
892 fd
= hold_lock_file_for_update(&write_lock
,
893 git_path_merge_rr(r
),
895 read_rr(r
, merge_rr
);
900 * The main entry point that is called internally from codepaths that
901 * perform mergy operations, possibly leaving conflicted index entries
902 * and working tree files.
904 int repo_rerere(struct repository
*r
, int flags
)
906 struct string_list merge_rr
= STRING_LIST_INIT_DUP
;
909 fd
= setup_rerere(r
, &merge_rr
, flags
);
912 status
= do_plain_rerere(r
, &merge_rr
, fd
);
918 * Subclass of rerere_io that reads from an in-core buffer that is a
921 struct rerere_io_mem
{
927 * ... and its getline() method implementation
929 static int rerere_mem_getline(struct strbuf
*sb
, struct rerere_io
*io_
)
931 struct rerere_io_mem
*io
= (struct rerere_io_mem
*)io_
;
938 ep
= memchr(io
->input
.buf
, '\n', io
->input
.len
);
940 ep
= io
->input
.buf
+ io
->input
.len
;
941 else if (*ep
== '\n')
943 len
= ep
- io
->input
.buf
;
944 strbuf_add(sb
, io
->input
.buf
, len
);
945 strbuf_remove(&io
->input
, 0, len
);
949 static int handle_cache(struct index_state
*istate
,
950 const char *path
, unsigned char *hash
, const char *output
)
952 mmfile_t mmfile
[3] = {{NULL
}};
953 mmbuffer_t result
= {NULL
, 0};
954 const struct cache_entry
*ce
;
955 int pos
, len
, i
, has_conflicts
;
956 struct rerere_io_mem io
;
957 int marker_size
= ll_merge_marker_size(istate
, path
);
960 * Reproduce the conflicted merge in-core
963 pos
= index_name_pos(istate
, path
, len
);
968 while (pos
< istate
->cache_nr
) {
969 enum object_type type
;
972 ce
= istate
->cache
[pos
++];
973 if (ce_namelen(ce
) != len
|| memcmp(ce
->name
, path
, len
))
975 i
= ce_stage(ce
) - 1;
976 if (!mmfile
[i
].ptr
) {
977 mmfile
[i
].ptr
= repo_read_object_file(the_repository
,
980 mmfile
[i
].size
= size
;
983 for (i
= 0; i
< 3; i
++)
984 if (!mmfile
[i
].ptr
&& !mmfile
[i
].size
)
985 mmfile
[i
].ptr
= xstrdup("");
988 * NEEDSWORK: handle conflicts from merges with
989 * merge.renormalize set, too?
991 ll_merge(&result
, path
, &mmfile
[0], NULL
,
993 &mmfile
[2], "theirs",
995 for (i
= 0; i
< 3; i
++)
998 memset(&io
, 0, sizeof(io
));
999 io
.io
.getline
= rerere_mem_getline
;
1001 io
.io
.output
= fopen(output
, "w");
1003 io
.io
.output
= NULL
;
1004 strbuf_init(&io
.input
, 0);
1005 strbuf_attach(&io
.input
, result
.ptr
, result
.size
, result
.size
);
1008 * Grab the conflict ID and optionally write the original
1009 * contents with conflict markers out.
1011 has_conflicts
= handle_path(hash
, (struct rerere_io
*)&io
, marker_size
);
1012 strbuf_release(&io
.input
);
1014 fclose(io
.io
.output
);
1015 return has_conflicts
;
1018 static int rerere_forget_one_path(struct index_state
*istate
,
1020 struct string_list
*rr
)
1022 const char *filename
;
1023 struct rerere_id
*id
;
1024 unsigned char hash
[GIT_MAX_RAWSZ
];
1026 struct string_list_item
*item
;
1029 * Recreate the original conflict from the stages in the
1030 * index and compute the conflict ID
1032 ret
= handle_cache(istate
, path
, hash
, NULL
);
1034 return error(_("could not parse conflict hunks in '%s'"), path
);
1036 /* Nuke the recorded resolution for the conflict */
1037 id
= new_rerere_id(hash
);
1039 for (id
->variant
= 0;
1040 id
->variant
< id
->collection
->status_nr
;
1042 mmfile_t cur
= { NULL
, 0 };
1043 mmbuffer_t result
= {NULL
, 0};
1044 int cleanly_resolved
;
1046 if (!has_rerere_resolution(id
))
1049 handle_cache(istate
, path
, hash
, rerere_path(id
, "thisimage"));
1050 if (read_mmfile(&cur
, rerere_path(id
, "thisimage"))) {
1052 error(_("failed to update conflicted state in '%s'"), path
);
1055 cleanly_resolved
= !try_merge(istate
, id
, path
, &cur
, &result
);
1058 if (cleanly_resolved
)
1062 if (id
->collection
->status_nr
<= id
->variant
) {
1063 error(_("no remembered resolution for '%s'"), path
);
1067 filename
= rerere_path(id
, "postimage");
1068 if (unlink(filename
)) {
1069 if (errno
== ENOENT
)
1070 error(_("no remembered resolution for '%s'"), path
);
1072 error_errno(_("cannot unlink '%s'"), filename
);
1077 * Update the preimage so that the user can resolve the
1078 * conflict in the working tree, run us again to record
1081 handle_cache(istate
, path
, hash
, rerere_path(id
, "preimage"));
1082 fprintf_ln(stderr
, _("Updated preimage for '%s'"), path
);
1085 * And remember that we can record resolution for this
1086 * conflict when the user is done.
1088 item
= string_list_insert(rr
, path
);
1089 free_rerere_id(item
);
1091 fprintf(stderr
, _("Forgot resolution for '%s'\n"), path
);
1099 int rerere_forget(struct repository
*r
, struct pathspec
*pathspec
)
1102 struct string_list conflict
= STRING_LIST_INIT_DUP
;
1103 struct string_list merge_rr
= STRING_LIST_INIT_DUP
;
1105 if (repo_read_index(r
) < 0)
1106 return error(_("index file corrupt"));
1108 fd
= setup_rerere(r
, &merge_rr
, RERERE_NOAUTOUPDATE
);
1113 * The paths may have been resolved (incorrectly);
1114 * recover the original conflicted state and then
1115 * find the conflicted paths.
1117 unmerge_index(r
->index
, pathspec
);
1118 find_conflict(r
, &conflict
);
1119 for (i
= 0; i
< conflict
.nr
; i
++) {
1120 struct string_list_item
*it
= &conflict
.items
[i
];
1121 if (!match_pathspec(r
->index
, pathspec
, it
->string
,
1122 strlen(it
->string
), 0, NULL
, 0))
1124 rerere_forget_one_path(r
->index
, it
->string
, &merge_rr
);
1126 return write_rr(&merge_rr
, fd
);
1130 * Garbage collection support
1133 static timestamp_t
rerere_created_at(struct rerere_id
*id
)
1137 return stat(rerere_path(id
, "preimage"), &st
) ? (time_t) 0 : st
.st_mtime
;
1140 static timestamp_t
rerere_last_used_at(struct rerere_id
*id
)
1144 return stat(rerere_path(id
, "postimage"), &st
) ? (time_t) 0 : st
.st_mtime
;
1148 * Remove the recorded resolution for a given conflict ID
1150 static void unlink_rr_item(struct rerere_id
*id
)
1152 unlink_or_warn(rerere_path(id
, "thisimage"));
1154 id
->collection
->status
[id
->variant
] = 0;
1157 static void prune_one(struct rerere_id
*id
,
1158 timestamp_t cutoff_resolve
, timestamp_t cutoff_noresolve
)
1163 then
= rerere_last_used_at(id
);
1165 cutoff
= cutoff_resolve
;
1167 then
= rerere_created_at(id
);
1170 cutoff
= cutoff_noresolve
;
1176 /* Does the basename in "path" look plausibly like an rr-cache entry? */
1177 static int is_rr_cache_dirname(const char *path
)
1179 struct object_id oid
;
1181 return !parse_oid_hex(path
, &oid
, &end
) && !*end
;
1184 void rerere_gc(struct repository
*r
, struct string_list
*rr
)
1186 struct string_list to_remove
= STRING_LIST_INIT_DUP
;
1190 timestamp_t now
= time(NULL
);
1191 timestamp_t cutoff_noresolve
= now
- 15 * 86400;
1192 timestamp_t cutoff_resolve
= now
- 60 * 86400;
1194 if (setup_rerere(r
, rr
, 0) < 0)
1197 git_config_get_expiry_in_days("gc.rerereresolved", &cutoff_resolve
, now
);
1198 git_config_get_expiry_in_days("gc.rerereunresolved", &cutoff_noresolve
, now
);
1199 git_config(git_default_config
, NULL
);
1200 dir
= opendir(git_path("rr-cache"));
1202 die_errno(_("unable to open rr-cache directory"));
1203 /* Collect stale conflict IDs ... */
1204 while ((e
= readdir_skip_dot_and_dotdot(dir
))) {
1205 struct rerere_dir
*rr_dir
;
1206 struct rerere_id id
;
1209 if (!is_rr_cache_dirname(e
->d_name
))
1210 continue; /* or should we remove e->d_name? */
1212 rr_dir
= find_rerere_dir(e
->d_name
);
1215 for (id
.variant
= 0, id
.collection
= rr_dir
;
1216 id
.variant
< id
.collection
->status_nr
;
1218 prune_one(&id
, cutoff_resolve
, cutoff_noresolve
);
1219 if (id
.collection
->status
[id
.variant
])
1223 string_list_append(&to_remove
, e
->d_name
);
1227 /* ... and then remove the empty directories */
1228 for (i
= 0; i
< to_remove
.nr
; i
++)
1229 rmdir(git_path("rr-cache/%s", to_remove
.items
[i
].string
));
1230 string_list_clear(&to_remove
, 0);
1231 rollback_lock_file(&write_lock
);
1235 * During a conflict resolution, after "rerere" recorded the
1236 * preimages, abandon them if the user did not resolve them or
1237 * record their resolutions. And drop $GIT_DIR/MERGE_RR.
1239 * NEEDSWORK: shouldn't we be calling this from "reset --hard"?
1241 void rerere_clear(struct repository
*r
, struct string_list
*merge_rr
)
1245 if (setup_rerere(r
, merge_rr
, 0) < 0)
1248 for (i
= 0; i
< merge_rr
->nr
; i
++) {
1249 struct rerere_id
*id
= merge_rr
->items
[i
].util
;
1250 if (!has_rerere_resolution(id
)) {
1252 rmdir(rerere_path(id
, NULL
));
1255 unlink_or_warn(git_path_merge_rr(r
));
1256 rollback_lock_file(&write_lock
);