4 #include "string-list.h"
6 #include "xdiff-interface.h"
8 #include "resolve-undo.h"
12 #include "sha1-lookup.h"
16 #define THREE_STAGED 2
17 void *RERERE_RESOLVED
= &RERERE_RESOLVED
;
19 /* if rerere_enabled == -1, fall back to detection of .git/rr-cache */
20 static int rerere_enabled
= -1;
22 /* automatically update cleanly resolved paths to the index */
23 static int rerere_autoupdate
;
25 static int rerere_dir_nr
;
26 static int rerere_dir_alloc
;
28 #define RR_HAS_POSTIMAGE 1
29 #define RR_HAS_PREIMAGE 2
30 static struct rerere_dir
{
31 unsigned char sha1
[20];
32 int status_alloc
, status_nr
;
33 unsigned char *status
;
36 static void free_rerere_dirs(void)
39 for (i
= 0; i
< rerere_dir_nr
; i
++) {
40 free(rerere_dir
[i
]->status
);
43 FREE_AND_NULL(rerere_dir
);
44 rerere_dir_nr
= rerere_dir_alloc
= 0;
47 static void free_rerere_id(struct string_list_item
*item
)
52 static const char *rerere_id_hex(const struct rerere_id
*id
)
54 return sha1_to_hex(id
->collection
->sha1
);
57 static void fit_variant(struct rerere_dir
*rr_dir
, int 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
;
68 static void assign_variant(struct rerere_id
*id
)
71 struct rerere_dir
*rr_dir
= id
->collection
;
73 variant
= id
->variant
;
75 for (variant
= 0; variant
< rr_dir
->status_nr
; variant
++)
76 if (!rr_dir
->status
[variant
])
79 fit_variant(rr_dir
, variant
);
80 id
->variant
= variant
;
83 const char *rerere_path(const struct rerere_id
*id
, const char *file
)
86 return git_path("rr-cache/%s", rerere_id_hex(id
));
89 return git_path("rr-cache/%s/%s", rerere_id_hex(id
), file
);
91 return git_path("rr-cache/%s/%s.%d",
92 rerere_id_hex(id
), file
, id
->variant
);
95 static int is_rr_file(const char *name
, const char *filename
, int *variant
)
100 if (!strcmp(name
, filename
)) {
104 if (!skip_prefix(name
, filename
, &suffix
) || *suffix
!= '.')
108 *variant
= strtol(suffix
+ 1, &ep
, 10);
114 static void scan_rerere_dir(struct rerere_dir
*rr_dir
)
117 DIR *dir
= opendir(git_path("rr-cache/%s", sha1_to_hex(rr_dir
->sha1
)));
121 while ((de
= readdir(dir
)) != NULL
) {
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
;
135 static const unsigned char *rerere_dir_sha1(size_t i
, void *table
)
137 struct rerere_dir
**rr_dir
= table
;
138 return rr_dir
[i
]->sha1
;
141 static struct rerere_dir
*find_rerere_dir(const char *hex
)
143 unsigned char sha1
[20];
144 struct rerere_dir
*rr_dir
;
147 if (get_sha1_hex(hex
, sha1
))
148 return NULL
; /* BUG */
149 pos
= sha1_pos(sha1
, rerere_dir
, rerere_dir_nr
, rerere_dir_sha1
);
151 rr_dir
= xmalloc(sizeof(*rr_dir
));
152 hashcpy(rr_dir
->sha1
, sha1
);
153 rr_dir
->status
= NULL
;
154 rr_dir
->status_nr
= 0;
155 rr_dir
->status_alloc
= 0;
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. */
162 MOVE_ARRAY(rerere_dir
+ pos
+ 1, rerere_dir
+ pos
,
163 rerere_dir_nr
- pos
- 1);
164 rerere_dir
[pos
] = rr_dir
;
165 scan_rerere_dir(rr_dir
);
167 return rerere_dir
[pos
];
170 static int has_rerere_resolution(const struct rerere_id
*id
)
172 const int both
= RR_HAS_POSTIMAGE
|RR_HAS_PREIMAGE
;
173 int variant
= id
->variant
;
177 return ((id
->collection
->status
[variant
] & both
) == both
);
180 static struct rerere_id
*new_rerere_id_hex(char *hex
)
182 struct rerere_id
*id
= xmalloc(sizeof(*id
));
183 id
->collection
= find_rerere_dir(hex
);
184 id
->variant
= -1; /* not known yet */
188 static struct rerere_id
*new_rerere_id(unsigned char *sha1
)
190 return new_rerere_id_hex(sha1_to_hex(sha1
));
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).
200 static void read_rr(struct string_list
*rr
)
202 struct strbuf buf
= STRBUF_INIT
;
203 FILE *in
= fopen_or_warn(git_path_merge_rr(), "r");
207 while (!strbuf_getwholeline(&buf
, in
, '\0')) {
209 unsigned char sha1
[20];
210 struct rerere_id
*id
;
213 /* There has to be the hash, tab, path and then NUL */
214 if (buf
.len
< 42 || get_sha1_hex(buf
.buf
, sha1
))
215 die(_("corrupt MERGE_RR"));
217 if (buf
.buf
[40] != '.') {
222 variant
= strtol(buf
.buf
+ 41, &path
, 10);
224 die(_("corrupt MERGE_RR"));
226 if (*(path
++) != '\t')
227 die(_("corrupt MERGE_RR"));
229 id
= new_rerere_id_hex(buf
.buf
);
230 id
->variant
= variant
;
231 string_list_insert(rr
, path
)->util
= id
;
233 strbuf_release(&buf
);
237 static struct lock_file write_lock
;
239 static int write_rr(struct string_list
*rr
, int out_fd
)
242 for (i
= 0; i
< rr
->nr
; i
++) {
243 struct strbuf buf
= STRBUF_INIT
;
244 struct rerere_id
*id
;
246 assert(rr
->items
[i
].util
!= RERERE_RESOLVED
);
248 id
= rr
->items
[i
].util
;
251 assert(id
->variant
>= 0);
253 strbuf_addf(&buf
, "%s.%d\t%s%c",
254 rerere_id_hex(id
), id
->variant
,
255 rr
->items
[i
].string
, 0);
257 strbuf_addf(&buf
, "%s\t%s%c",
259 rr
->items
[i
].string
, 0);
261 if (write_in_full(out_fd
, buf
.buf
, buf
.len
) < 0)
262 die(_("unable to write rerere record"));
264 strbuf_release(&buf
);
266 if (commit_lock_file(&write_lock
) != 0)
267 die(_("unable to write rerere record"));
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
280 int (*getline
)(struct strbuf
*, struct rerere_io
*);
283 /* some more stuff */
286 static void ferr_write(const void *p
, size_t count
, FILE *fp
, int *err
)
290 if (fwrite(p
, count
, 1, fp
) != 1)
294 static inline void ferr_puts(const char *s
, FILE *fp
, int *err
)
296 ferr_write(s
, strlen(s
), fp
, err
);
299 static void rerere_io_putstr(const char *str
, struct rerere_io
*io
)
302 ferr_puts(str
, io
->output
, &io
->wrerror
);
305 static void rerere_io_putmem(const char *mem
, size_t sz
, struct rerere_io
*io
)
308 ferr_write(mem
, sz
, io
->output
, &io
->wrerror
);
312 * Subclass of rerere_io that reads from an on-disk file
314 struct rerere_io_file
{
320 * ... and its getline() method implementation
322 static int rerere_file_getline(struct strbuf
*sb
, struct rerere_io
*io_
)
324 struct rerere_io_file
*io
= (struct rerere_io_file
*)io_
;
325 return strbuf_getwholeline(sb
, io
->input
, '\n');
329 * Require the exact number of conflict marker letters, no more, no
330 * less, followed by SP or any whitespace
333 static int is_cmarker(char *buf
, int marker_char
, int marker_size
)
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.
345 want_sp
= (marker_char
== '<') || (marker_char
== '>');
347 while (marker_size
--)
348 if (*buf
++ != marker_char
)
350 if (want_sp
&& *buf
!= ' ')
352 return isspace(*buf
);
355 static void rerere_strbuf_putconflict(struct strbuf
*buf
, int ch
, size_t size
)
357 strbuf_addchars(buf
, ch
, size
);
358 strbuf_addch(buf
, '\n');
361 static int handle_conflict(struct strbuf
*out
, struct rerere_io
*io
,
362 int marker_size
, git_SHA_CTX
*ctx
)
365 RR_SIDE_1
= 0, RR_SIDE_2
, RR_ORIGINAL
367 struct strbuf one
= STRBUF_INIT
, two
= STRBUF_INIT
;
368 struct strbuf buf
= STRBUF_INIT
;
369 int has_conflicts
= -1;
371 while (!io
->getline(&buf
, io
)) {
372 if (is_cmarker(buf
.buf
, '<', marker_size
)) {
374 } else if (is_cmarker(buf
.buf
, '|', marker_size
)) {
375 if (hunk
!= RR_SIDE_1
)
378 } else if (is_cmarker(buf
.buf
, '=', marker_size
)) {
379 if (hunk
!= RR_SIDE_1
&& hunk
!= RR_ORIGINAL
)
382 } else if (is_cmarker(buf
.buf
, '>', marker_size
)) {
383 if (hunk
!= RR_SIDE_2
)
385 if (strbuf_cmp(&one
, &two
) > 0)
386 strbuf_swap(&one
, &two
);
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
);
394 git_SHA1_Update(ctx
, one
.buf
? one
.buf
: "",
396 git_SHA1_Update(ctx
, two
.buf
? two
.buf
: "",
400 } else if (hunk
== RR_SIDE_1
)
401 strbuf_addbuf(&one
, &buf
);
402 else if (hunk
== RR_ORIGINAL
)
404 else if (hunk
== RR_SIDE_2
)
405 strbuf_addbuf(&two
, &buf
);
407 strbuf_release(&one
);
408 strbuf_release(&two
);
409 strbuf_release(&buf
);
411 return has_conflicts
;
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.
423 * Return 1 if conflict hunks are found, 0 if there are no conflict
424 * hunks and -1 if an error occured.
426 static int handle_path(unsigned char *sha1
, struct rerere_io
*io
, int marker_size
)
429 struct strbuf buf
= STRBUF_INIT
, out
= STRBUF_INIT
;
430 int has_conflicts
= 0;
434 while (!io
->getline(&buf
, io
)) {
435 if (is_cmarker(buf
.buf
, '<', marker_size
)) {
436 has_conflicts
= handle_conflict(&out
, io
, marker_size
,
438 if (has_conflicts
< 0)
440 rerere_io_putmem(out
.buf
, out
.len
, io
);
443 rerere_io_putstr(buf
.buf
, io
);
445 strbuf_release(&buf
);
446 strbuf_release(&out
);
449 git_SHA1_Final(sha1
, &ctx
);
451 return has_conflicts
;
455 * Scan the path for conflicts, do the "handle_path()" thing above, and
456 * return the number of conflict hunks found.
458 static int handle_file(const char *path
, unsigned char *sha1
, const char *output
)
460 int has_conflicts
= 0;
461 struct rerere_io_file io
;
462 int marker_size
= ll_merge_marker_size(path
);
464 memset(&io
, 0, sizeof(io
));
465 io
.io
.getline
= rerere_file_getline
;
466 io
.input
= fopen(path
, "r");
469 return error_errno(_("could not open '%s'"), path
);
472 io
.io
.output
= fopen(output
, "w");
474 error_errno(_("could not write '%s'"), output
);
480 has_conflicts
= handle_path(sha1
, (struct rerere_io
*)&io
, marker_size
);
484 error(_("there were errors while writing '%s' (%s)"),
485 path
, strerror(io
.io
.wrerror
));
486 if (io
.io
.output
&& fclose(io
.io
.output
))
487 io
.io
.wrerror
= error_errno(_("failed to flush '%s'"), path
);
489 if (has_conflicts
< 0) {
491 unlink_or_warn(output
);
492 return error(_("could not parse conflict hunks in '%s'"), path
);
496 return has_conflicts
;
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
507 static int check_one_conflict(int i
, int *type
)
509 const struct cache_entry
*e
= active_cache
[i
];
517 while (ce_stage(active_cache
[i
]) == 1)
520 /* Only handle regular files with both stages #2 and #3 */
521 if (i
+ 1 < active_nr
) {
522 const struct cache_entry
*e2
= active_cache
[i
];
523 const struct cache_entry
*e3
= active_cache
[i
+ 1];
524 if (ce_stage(e2
) == 2 &&
526 ce_same_name(e
, e3
) &&
527 S_ISREG(e2
->ce_mode
) &&
528 S_ISREG(e3
->ce_mode
))
529 *type
= THREE_STAGED
;
532 /* Skip the entries with the same name */
533 while (i
< active_nr
&& ce_same_name(e
, active_cache
[i
]))
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.
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,
549 static int find_conflict(struct string_list
*conflict
)
552 if (read_cache() < 0)
553 return error(_("index file corrupt"));
555 for (i
= 0; i
< active_nr
;) {
557 const struct cache_entry
*e
= active_cache
[i
];
558 i
= check_one_conflict(i
, &conflict_type
);
559 if (conflict_type
== THREE_STAGED
)
560 string_list_insert(conflict
, (const char *)e
->name
);
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".
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).
575 * Do *not* write MERGE_RR file out after calling this function.
577 * NEEDSWORK: we may want to fix the caller that implements "rerere
578 * remaining" to do this without abusing merge_rr.
580 int rerere_remaining(struct string_list
*merge_rr
)
583 if (setup_rerere(merge_rr
, RERERE_READONLY
))
585 if (read_cache() < 0)
586 return error(_("index file corrupt"));
588 for (i
= 0; i
< active_nr
;) {
590 const struct cache_entry
*e
= active_cache
[i
];
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
);
599 it
->util
= RERERE_RESOLVED
;
607 * Try using the given conflict resolution "ID" to see
608 * if that recorded conflict resolves cleanly what we
611 static int try_merge(const struct rerere_id
*id
, const char *path
,
612 mmfile_t
*cur
, mmbuffer_t
*result
)
615 mmfile_t base
= {NULL
, 0}, other
= {NULL
, 0};
617 if (read_mmfile(&base
, rerere_path(id
, "preimage")) ||
618 read_mmfile(&other
, rerere_path(id
, "postimage")))
622 * A three-way merge. Note that this honors user-customizable
623 * low-level merge driver settings.
625 ret
= ll_merge(result
, path
, &base
, NULL
, cur
, "", &other
, "", NULL
);
634 * Find the conflict identified by "id"; the change between its
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.
640 * Returns 0 for successful replay of recorded resolution, or non-zero
643 static int merge(const struct rerere_id
*id
, const char *path
)
647 mmfile_t cur
= {NULL
, 0};
648 mmbuffer_t result
= {NULL
, 0};
651 * Normalize the conflicts in path and write it out to
652 * "thisimage" temporary file.
654 if ((handle_file(path
, NULL
, rerere_path(id
, "thisimage")) < 0) ||
655 read_mmfile(&cur
, rerere_path(id
, "thisimage"))) {
660 ret
= try_merge(id
, path
, &cur
, &result
);
665 * A successful replay of recorded resolution.
666 * Mark that "postimage" was used to help gc.
668 if (utime(rerere_path(id
, "postimage"), NULL
) < 0)
669 warning_errno(_("failed utime() on '%s'"),
670 rerere_path(id
, "postimage"));
672 /* Update "path" with the resolution */
673 f
= fopen(path
, "w");
675 return error_errno(_("could not open '%s'"), path
);
676 if (fwrite(result
.ptr
, result
.size
, 1, f
) != 1)
677 error_errno(_("could not write '%s'"), path
);
679 return error_errno(_("writing '%s' failed"), path
);
688 static void update_paths(struct string_list
*update
)
690 struct lock_file index_lock
= LOCK_INIT
;
693 hold_locked_index(&index_lock
, LOCK_DIE_ON_ERROR
);
695 for (i
= 0; i
< update
->nr
; i
++) {
696 struct string_list_item
*item
= &update
->items
[i
];
697 if (add_file_to_cache(item
->string
, 0))
699 fprintf_ln(stderr
, _("Staged '%s' using previous resolution."),
703 if (write_locked_index(&the_index
, &index_lock
,
704 COMMIT_LOCK
| SKIP_IF_UNCHANGED
))
705 die(_("unable to write new index file"));
708 static void remove_variant(struct rerere_id
*id
)
710 unlink_or_warn(rerere_path(id
, "postimage"));
711 unlink_or_warn(rerere_path(id
, "preimage"));
712 id
->collection
->status
[id
->variant
] = 0;
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.
722 static void do_rerere_one_path(struct string_list_item
*rr_item
,
723 struct string_list
*update
)
725 const char *path
= rr_item
->string
;
726 struct rerere_id
*id
= rr_item
->util
;
727 struct rerere_dir
*rr_dir
= id
->collection
;
730 variant
= id
->variant
;
732 /* Has the user resolved it already? */
734 if (!handle_file(path
, NULL
, NULL
)) {
735 copy_file(rerere_path(id
, "postimage"), path
, 0666);
736 id
->collection
->status
[variant
] |= RR_HAS_POSTIMAGE
;
737 fprintf_ln(stderr
, _("Recorded resolution for '%s'."), path
);
738 free_rerere_id(rr_item
);
739 rr_item
->util
= NULL
;
743 * There may be other variants that can cleanly
744 * replay. Try them and update the variant number for
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
;
754 if ((rr_dir
->status
[variant
] & both
) != both
)
757 vid
.variant
= variant
;
758 if (merge(&vid
, path
))
759 continue; /* failed to replay */
762 * If there already is a different variant that applies
763 * cleanly, there is no point maintaining our own variant.
765 if (0 <= id
->variant
&& id
->variant
!= variant
)
768 if (rerere_autoupdate
)
769 string_list_insert(update
, path
);
772 _("Resolved '%s' using previous resolution."),
774 free_rerere_id(rr_item
);
775 rr_item
->util
= NULL
;
779 /* None of the existing one applies; we need a new variant */
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");
787 die_errno(_("cannot unlink stray '%s'"), path
);
788 id
->collection
->status
[variant
] &= ~RR_HAS_POSTIMAGE
;
790 id
->collection
->status
[variant
] |= RR_HAS_PREIMAGE
;
791 fprintf_ln(stderr
, _("Recorded preimage for '%s'"), path
);
794 static int do_plain_rerere(struct string_list
*rr
, int fd
)
796 struct string_list conflict
= STRING_LIST_INIT_DUP
;
797 struct string_list update
= STRING_LIST_INIT_DUP
;
800 find_conflict(&conflict
);
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.
808 for (i
= 0; i
< conflict
.nr
; i
++) {
809 struct rerere_id
*id
;
810 unsigned char sha1
[20];
811 const char *path
= conflict
.items
[i
].string
;
815 * Ask handle_file() to scan and assign a
816 * conflict ID. No need to write anything out
819 ret
= handle_file(path
, sha1
, NULL
);
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);
825 if (ret
< 1 || has_string
)
828 id
= new_rerere_id(sha1
);
829 string_list_insert(rr
, path
)->util
= id
;
831 /* Ensure that the directory exists. */
832 mkdir_in_gitdir(rerere_path(id
, NULL
));
835 for (i
= 0; i
< rr
->nr
; i
++)
836 do_rerere_one_path(&rr
->items
[i
], &update
);
839 update_paths(&update
);
841 return write_rr(rr
, fd
);
844 static void git_rerere_config(void)
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
);
851 static GIT_PATH_FUNC(git_path_rr_cache
, "rr-cache")
853 static int is_rerere_enabled(void)
860 rr_cache_exists
= is_directory(git_path_rr_cache());
861 if (rerere_enabled
< 0)
862 return rr_cache_exists
;
864 if (!rr_cache_exists
&& mkdir_in_gitdir(git_path_rr_cache()))
865 die(_("could not create directory '%s'"), git_path_rr_cache());
869 int setup_rerere(struct string_list
*merge_rr
, int flags
)
874 if (!is_rerere_enabled())
877 if (flags
& (RERERE_AUTOUPDATE
|RERERE_NOAUTOUPDATE
))
878 rerere_autoupdate
= !!(flags
& RERERE_AUTOUPDATE
);
879 if (flags
& RERERE_READONLY
)
882 fd
= hold_lock_file_for_update(&write_lock
, git_path_merge_rr(),
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.
893 int rerere(int flags
)
895 struct string_list merge_rr
= STRING_LIST_INIT_DUP
;
898 fd
= setup_rerere(&merge_rr
, flags
);
901 status
= do_plain_rerere(&merge_rr
, fd
);
907 * Subclass of rerere_io that reads from an in-core buffer that is a
910 struct rerere_io_mem
{
916 * ... and its getline() method implementation
918 static int rerere_mem_getline(struct strbuf
*sb
, struct rerere_io
*io_
)
920 struct rerere_io_mem
*io
= (struct rerere_io_mem
*)io_
;
927 ep
= memchr(io
->input
.buf
, '\n', io
->input
.len
);
929 ep
= io
->input
.buf
+ io
->input
.len
;
930 else if (*ep
== '\n')
932 len
= ep
- io
->input
.buf
;
933 strbuf_add(sb
, io
->input
.buf
, len
);
934 strbuf_remove(&io
->input
, 0, len
);
938 static int handle_cache(const char *path
, unsigned char *sha1
, const char *output
)
940 mmfile_t mmfile
[3] = {{NULL
}};
941 mmbuffer_t result
= {NULL
, 0};
942 const struct cache_entry
*ce
;
943 int pos
, len
, i
, has_conflicts
;
944 struct rerere_io_mem io
;
945 int marker_size
= ll_merge_marker_size(path
);
948 * Reproduce the conflicted merge in-core
951 pos
= cache_name_pos(path
, len
);
956 while (pos
< active_nr
) {
957 enum object_type type
;
960 ce
= active_cache
[pos
++];
961 if (ce_namelen(ce
) != len
|| memcmp(ce
->name
, path
, len
))
963 i
= ce_stage(ce
) - 1;
964 if (!mmfile
[i
].ptr
) {
965 mmfile
[i
].ptr
= read_object_file(&ce
->oid
, &type
,
967 mmfile
[i
].size
= size
;
970 for (i
= 0; i
< 3; i
++)
971 if (!mmfile
[i
].ptr
&& !mmfile
[i
].size
)
972 mmfile
[i
].ptr
= xstrdup("");
975 * NEEDSWORK: handle conflicts from merges with
976 * merge.renormalize set, too?
978 ll_merge(&result
, path
, &mmfile
[0], NULL
,
980 &mmfile
[2], "theirs", NULL
);
981 for (i
= 0; i
< 3; i
++)
984 memset(&io
, 0, sizeof(io
));
985 io
.io
.getline
= rerere_mem_getline
;
987 io
.io
.output
= fopen(output
, "w");
990 strbuf_init(&io
.input
, 0);
991 strbuf_attach(&io
.input
, result
.ptr
, result
.size
, result
.size
);
994 * Grab the conflict ID and optionally write the original
995 * contents with conflict markers out.
997 has_conflicts
= handle_path(sha1
, (struct rerere_io
*)&io
, marker_size
);
998 strbuf_release(&io
.input
);
1000 fclose(io
.io
.output
);
1001 return has_conflicts
;
1004 static int rerere_forget_one_path(const char *path
, struct string_list
*rr
)
1006 const char *filename
;
1007 struct rerere_id
*id
;
1008 unsigned char sha1
[20];
1010 struct string_list_item
*item
;
1013 * Recreate the original conflict from the stages in the
1014 * index and compute the conflict ID
1016 ret
= handle_cache(path
, sha1
, NULL
);
1018 return error(_("could not parse conflict hunks in '%s'"), path
);
1020 /* Nuke the recorded resolution for the conflict */
1021 id
= new_rerere_id(sha1
);
1023 for (id
->variant
= 0;
1024 id
->variant
< id
->collection
->status_nr
;
1026 mmfile_t cur
= { NULL
, 0 };
1027 mmbuffer_t result
= {NULL
, 0};
1028 int cleanly_resolved
;
1030 if (!has_rerere_resolution(id
))
1033 handle_cache(path
, sha1
, rerere_path(id
, "thisimage"));
1034 if (read_mmfile(&cur
, rerere_path(id
, "thisimage"))) {
1036 error(_("failed to update conflicted state in '%s'"), path
);
1039 cleanly_resolved
= !try_merge(id
, path
, &cur
, &result
);
1042 if (cleanly_resolved
)
1046 if (id
->collection
->status_nr
<= id
->variant
) {
1047 error(_("no remembered resolution for '%s'"), path
);
1051 filename
= rerere_path(id
, "postimage");
1052 if (unlink(filename
)) {
1053 if (errno
== ENOENT
)
1054 error(_("no remembered resolution for '%s'"), path
);
1056 error_errno(_("cannot unlink '%s'"), filename
);
1061 * Update the preimage so that the user can resolve the
1062 * conflict in the working tree, run us again to record
1065 handle_cache(path
, sha1
, rerere_path(id
, "preimage"));
1066 fprintf_ln(stderr
, _("Updated preimage for '%s'"), path
);
1069 * And remember that we can record resolution for this
1070 * conflict when the user is done.
1072 item
= string_list_insert(rr
, path
);
1073 free_rerere_id(item
);
1075 fprintf(stderr
, _("Forgot resolution for '%s'\n"), path
);
1083 int rerere_forget(struct pathspec
*pathspec
)
1086 struct string_list conflict
= STRING_LIST_INIT_DUP
;
1087 struct string_list merge_rr
= STRING_LIST_INIT_DUP
;
1089 if (read_cache() < 0)
1090 return error(_("index file corrupt"));
1092 fd
= setup_rerere(&merge_rr
, RERERE_NOAUTOUPDATE
);
1097 * The paths may have been resolved (incorrectly);
1098 * recover the original conflicted state and then
1099 * find the conflicted paths.
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
];
1105 if (!match_pathspec(pathspec
, it
->string
,
1106 strlen(it
->string
), 0, NULL
, 0))
1108 rerere_forget_one_path(it
->string
, &merge_rr
);
1110 return write_rr(&merge_rr
, fd
);
1114 * Garbage collection support
1117 static timestamp_t
rerere_created_at(struct rerere_id
*id
)
1121 return stat(rerere_path(id
, "preimage"), &st
) ? (time_t) 0 : st
.st_mtime
;
1124 static timestamp_t
rerere_last_used_at(struct rerere_id
*id
)
1128 return stat(rerere_path(id
, "postimage"), &st
) ? (time_t) 0 : st
.st_mtime
;
1132 * Remove the recorded resolution for a given conflict ID
1134 static void unlink_rr_item(struct rerere_id
*id
)
1136 unlink_or_warn(rerere_path(id
, "thisimage"));
1138 id
->collection
->status
[id
->variant
] = 0;
1141 static void prune_one(struct rerere_id
*id
,
1142 timestamp_t cutoff_resolve
, timestamp_t cutoff_noresolve
)
1147 then
= rerere_last_used_at(id
);
1149 cutoff
= cutoff_resolve
;
1151 then
= rerere_created_at(id
);
1154 cutoff
= cutoff_noresolve
;
1160 void rerere_gc(struct string_list
*rr
)
1162 struct string_list to_remove
= STRING_LIST_INIT_DUP
;
1166 timestamp_t now
= time(NULL
);
1167 timestamp_t cutoff_noresolve
= now
- 15 * 86400;
1168 timestamp_t cutoff_resolve
= now
- 60 * 86400;
1170 if (setup_rerere(rr
, 0) < 0)
1173 git_config_get_expiry_in_days("gc.rerereresolved", &cutoff_resolve
, now
);
1174 git_config_get_expiry_in_days("gc.rerereunresolved", &cutoff_noresolve
, now
);
1175 git_config(git_default_config
, NULL
);
1176 dir
= opendir(git_path("rr-cache"));
1178 die_errno(_("unable to open rr-cache directory"));
1179 /* Collect stale conflict IDs ... */
1180 while ((e
= readdir(dir
))) {
1181 struct rerere_dir
*rr_dir
;
1182 struct rerere_id id
;
1185 if (is_dot_or_dotdot(e
->d_name
))
1187 rr_dir
= find_rerere_dir(e
->d_name
);
1189 continue; /* or should we remove e->d_name? */
1192 for (id
.variant
= 0, id
.collection
= rr_dir
;
1193 id
.variant
< id
.collection
->status_nr
;
1195 prune_one(&id
, cutoff_resolve
, cutoff_noresolve
);
1196 if (id
.collection
->status
[id
.variant
])
1200 string_list_append(&to_remove
, e
->d_name
);
1204 /* ... and then remove the empty directories */
1205 for (i
= 0; i
< to_remove
.nr
; i
++)
1206 rmdir(git_path("rr-cache/%s", to_remove
.items
[i
].string
));
1207 string_list_clear(&to_remove
, 0);
1208 rollback_lock_file(&write_lock
);
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.
1216 * NEEDSWORK: shouldn't we be calling this from "reset --hard"?
1218 void rerere_clear(struct string_list
*merge_rr
)
1222 if (setup_rerere(merge_rr
, 0) < 0)
1225 for (i
= 0; i
< merge_rr
->nr
; i
++) {
1226 struct rerere_id
*id
= merge_rr
->items
[i
].util
;
1227 if (!has_rerere_resolution(id
)) {
1229 rmdir(rerere_path(id
, NULL
));
1232 unlink_or_warn(git_path_merge_rr());
1233 rollback_lock_file(&write_lock
);