Skip to content

rerere: wait for MERGE_RR.lock, and go on at a conflict #2214

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
thomasbachem wants to merge 3 commits into
base: master
Choose a base branch
from
Open

rerere: wait for MERGE_RR.lock, and go on at a conflict #2214

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
3dc3d02
rerere: wait for MERGE_RR.lock before giving up
thomasbachem Sep 28, 2026
2767313
rerere: add "gc --auto" that skips a held lock
thomasbachem Sep 28, 2026
3984c76
rerere: go on at a conflict when the lock stays busy
thomasbachem Sep 28, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
13 changes: 13 additions & 0 deletions Documentation/config/rerere.adoc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -10,3 +10,16 @@ rerere.enabled::
enabled if there is an `rr-cache` directory under the

@gitgitgadget gitgitgadget Bot Sep 28, 2026

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Patrick Steinhardt wrote on the Git mailing list (how to reply to this email):

On Mon, Sep 14, 2026 at 08:04:20AM +0000, Thomas Bachem via GitGitGadget wrote:
> diff --git a/Documentation/git-rerere.adoc b/Documentation/git-rerere.adoc
> index 4e6ab9a27c..4df653367e 100644
> --- a/Documentation/git-rerere.adoc
> +++ b/Documentation/git-rerere.adoc
> @@ -70,7 +70,9 @@ occurred a long time ago.  By default, unresolved conflicts older
>  than 15 days and resolved conflicts older than 60
>  days are pruned.  These defaults are controlled via the
>  `gc.rerereUnresolved` and `gc.rerereResolved` configuration
> -variables respectively.
> +variables respectively.  If another process holds the rerere lock,
> +for example a merge or rebase that is recording a conflict, `gc`
> +does nothing and says so.

Do we maybe want to drop these examples? I don't feel like they add any
value.

> diff --git a/rerere.c b/rerere.c
> index 3d3bd0db16..7d44f3937c 100644
> --- a/rerere.c
> +++ b/rerere.c
> @@ -33,6 +33,9 @@ static int rerere_enabled = -1;
>  /* automatically update cleanly resolved paths to the index */
>  static int rerere_autoupdate;
>  
> +/* how long to wait for MERGE_RR.lock, in milliseconds */
> +static int rerere_lock_timeout_ms = 1000;
> +
>  #define RR_HAS_POSTIMAGE 1
>  #define RR_HAS_PREIMAGE 2
>  struct rerere_dir {
> @@ -850,6 +853,8 @@ static void git_rerere_config(void)
>  {
>  	repo_config_get_bool(the_repository, "rerere.enabled", &rerere_enabled);
>  	repo_config_get_bool(the_repository, "rerere.autoupdate", &rerere_autoupdate);
> +	repo_config_get_int(the_repository, "rerere.locktimeout",
> +			    &rerere_lock_timeout_ms);
>  	repo_config(the_repository, git_default_config, NULL);
>  }
>  
> @@ -882,12 +887,34 @@ int setup_rerere(struct repository *r, struct string_list *merge_rr, int flags)
>  
>  	if (flags & (RERERE_AUTOUPDATE|RERERE_NOAUTOUPDATE))
>  		rerere_autoupdate = !!(flags & RERERE_AUTOUPDATE);
> -	if (flags & RERERE_READONLY)
> +	if ((flags & RERERE_READONLY) && (flags & RERERE_NOWAIT))
> +		BUG("RERERE_READONLY takes no lock, so RERERE_NOWAIT does not apply");
> +	if (flags & RERERE_READONLY) {
>  		fd = 0;
> -	else
> -		fd = repo_hold_lock_file_for_update(r, &write_lock,
> -						    git_path_merge_rr(r),
> -						    LOCK_DIE_ON_ERROR);
> +	} else {
> +		const char *path = git_path_merge_rr(r);
> +		int lock_flags = LOCK_DIE_ON_ERROR;
> +		long timeout_ms = rerere_lock_timeout_ms;

Here you're using a `long` whereas `rerere_lock_timeout_ms` is an `int`.
Of course we'd ideally use a `long` consistently as that's also what
`repo_hold_lock_file_for_update_timeout()` accepts. But I guess the
reason you didn't is that we don't have `repo_config_get_long()`. So I
guess this is good enough for now.

> @@ -1211,7 +1238,7 @@ void rerere_gc(struct repository *r, struct string_list *rr)
>  	timestamp_t cutoff_resolve = now - 60 * 86400;
>  	struct strbuf buf = STRBUF_INIT;
>  
> -	if (setup_rerere(r, rr, 0) < 0)
> +	if (setup_rerere(r, rr, RERERE_NOWAIT) < 0)
>  		return;
>  
>  	repo_config_get_expiry_in_days(the_repository, "gc.rerereresolved",

I'm not a 100% sold on this change. There's two different scenarios
under which we want to perform garbage collection:

  - As part of auto-maintenance, triggered by Git automatically. Here
    I'm fully aligned that it makes sense to just silently ignore the
    case where we couldn't acquire the lock, as auto-maintenance is done
    on a best-effort basis anyway.

  - As part of `git rerere gc`, which is invoked manually by the user.
    Here I'm less so, as the user has explicitly asked us to garbage
    collect. Sure, we print a warning now, but the exit code does not
    signal that we failed garbage collecting.

So I'd argue that we should discern those two use cases. I think that in
the second use case, we'd probably want to use a timeout and if we fail
to acquire the lock, we should make `git rerere gc` fail with a non-zero
exit code.

Patrick

`$GIT_DIR`, e.g. if "rerere" was previously used in the
repository.

rerere.lockTimeout::
The length of time, in milliseconds, to wait for the rerere
lock when another process holds it, typically a background

@gitgitgadget gitgitgadget Bot Sep 28, 2026

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Patrick Steinhardt wrote on the Git mailing list (how to reply to this email):

On Mon, Sep 14, 2026 at 08:04:21AM +0000, Thomas Bachem via GitGitGadget wrote:
> diff --git a/rerere.c b/rerere.c
> index 7d44f3937c..a996d39159 100644
> --- a/rerere.c
> +++ b/rerere.c
> @@ -900,18 +902,26 @@ int setup_rerere(struct repository *r, struct string_list *merge_rr, int flags)
>  		 * Another process may hold the lock for a while, e.g.
>  		 * "git rerere gc" while it prunes rr-cache, so wait for
>  		 * it instead of dying right away.  The gc itself never
> -		 * waits: skipping one of its runs costs nothing.
> +		 * waits: skipping one of its runs costs nothing.  A
> +		 * command that stops at a conflict must not die here
> +		 * either, so it warns and goes on without rerere.
>  		 */
>  		if (flags & RERERE_NOWAIT) {
>  			lock_flags = 0;
>  			timeout_ms = 0;
>  		}
> +		if (flags & RERERE_SKIP_LOCKED)
> +			lock_flags = 0;
>  		fd = repo_hold_lock_file_for_update_timeout(r, &write_lock,
>  							    path, lock_flags,
>  							    timeout_ms);
>  		if (fd < 0) {
>  			warning_errno(_("skipping rerere, "
>  					"unable to create '%s.lock'"), path);
> +			if (flags & RERERE_SKIP_LOCKED)
> +				advise(_("run \"git rerere\" before resolving "
> +					 "the conflict to record or replay "
> +					 "its resolution"));
>  			return -1;
>  		}
>  	}

Should this use `advise_if_enabled()`?

Patrick

`git rerere gc`. Value 0 means not to wait at all; -1 means
to wait indefinitely. Default is 1000 (i.e., wait for 1
second). When the time is up, a command that stops at a
conflict, such as `git merge` or `git rebase`, prints a
warning and goes on without rerere; run `git rerere` before
resolving the conflict to record it after all. Any other
command fails, as it does for any other lock it cannot take.
`git rerere gc --auto` does not wait and does nothing while
the lock is held.
9 changes: 6 additions & 3 deletions Documentation/git-rerere.adoc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -8,7 +8,7 @@ git-rerere - Reuse recorded resolution of conflicted merges
SYNOPSIS
--------
[verse]
'git rerere' [clear | forget <pathspec>... | diff | status | remaining | gc]
'git rerere' [clear | forget <pathspec>... | diff | status | remaining | gc [--auto]]

DESCRIPTION
-----------
Expand Down Expand Up @@ -63,14 +63,17 @@ Print paths with conflicts that have not been autoresolved by rerere.
This includes paths whose resolutions cannot be tracked by rerere,
such as conflicting submodules.

'gc'::
'gc' [--auto]::

Prune records of conflicted merges that
occurred a long time ago. By default, unresolved conflicts older
than 15 days and resolved conflicts older than 60
days are pruned. These defaults are controlled via the
`gc.rerereUnresolved` and `gc.rerereResolved` configuration
variables respectively.
variables respectively. With `--auto`, which `git maintenance run
--auto` and `git gc --auto` pass, `gc` does nothing while another
process holds the rerere lock. Without it, `gc` waits for the lock
as long as `rerere.lockTimeout` allows and then fails.


DISCUSSION
Expand Down
2 changes: 1 addition & 1 deletion apply.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -4865,7 +4865,7 @@ static int write_out_results(struct apply_state *state, struct patch *list)
* tree with conflict markers, but that isn't written with --cached.
*/
if (!state->cached)
repo_rerere(state->repo, 0);
repo_rerere(state->repo, RERERE_SKIP_LOCKED);
}

return errs;
Expand Down
3 changes: 2 additions & 1 deletion builtin/am.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1649,7 +1649,8 @@ static int fall_back_threeway(const struct am_state *state, const char *index_pa
o.verbosity = 0;

if (merge_ort_generic(&o, &our_tree, &their_tree, 1, bases, &result)) {
repo_rerere(the_repository, state->allow_rerere_autoupdate);
repo_rerere(the_repository, state->allow_rerere_autoupdate |
RERERE_SKIP_LOCKED);
free(their_tree_name);
return error(_("Failed to merge in the changes."));
}
Expand Down
4 changes: 3 additions & 1 deletion builtin/gc.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -385,12 +385,14 @@ static int worktree_prune_condition(struct gc_config *cfg)
return should_prune;
}

static int maintenance_task_rerere_gc(struct maintenance_run_opts *opts UNUSED,
static int maintenance_task_rerere_gc(struct maintenance_run_opts *opts,
struct gc_config *cfg UNUSED)
{
struct child_process rerere_cmd = CHILD_PROCESS_INIT;
rerere_cmd.git_cmd = 1;
strvec_pushl(&rerere_cmd.args, "rerere", "gc", NULL);
if (opts->auto_flag)
strvec_push(&rerere_cmd.args, "--auto");
return run_command(&rerere_cmd);
}

Expand Down
2 changes: 1 addition & 1 deletion builtin/merge.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1061,7 +1061,7 @@ static int suggest_conflicts(void)
fputs(msgbuf.buf, fp);
strbuf_release(&msgbuf);
fclose(fp);
repo_rerere(the_repository, allow_rerere_auto);
repo_rerere(the_repository, allow_rerere_auto | RERERE_SKIP_LOCKED);
printf(_("Automatic merge failed; "
"fix conflicts and then commit the result.\n"));
return 1;
Expand Down
13 changes: 10 additions & 3 deletions builtin/rerere.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -12,7 +12,8 @@
#include "pathspec.h"

static const char * const rerere_usage[] = {
N_("git rerere [clear | forget <pathspec>... | diff | status | remaining | gc]"),
N_("git rerere [clear | forget <pathspec>... | diff | status | "
"remaining | gc [--auto]]"),
NULL,
};

Expand Down Expand Up @@ -56,16 +57,21 @@ int cmd_rerere(int argc,
struct repository *repo UNUSED)
{
struct string_list merge_rr = STRING_LIST_INIT_DUP;
int autoupdate = -1, flags = 0;
int autoupdate = -1, auto_flag = 0, flags = 0;

struct option options[] = {
OPT_SET_INT(0, "rerere-autoupdate", &autoupdate,
N_("register clean resolutions in index"), 1),
OPT_BOOL(0, "auto", &auto_flag,
N_("skip gc while another process holds the lock")),
OPT_END(),
};

argc = parse_options(argc, argv, prefix, options, rerere_usage, 0);

if (auto_flag && (argc < 1 || strcmp(argv[0], "gc")))
die(_("the option '%s' requires '%s'"), "--auto", "gc");

repo_config(the_repository, git_xmerge_config, NULL);

if (autoupdate == 1)
Expand Down Expand Up @@ -94,7 +100,8 @@ int cmd_rerere(int argc,
if (!strcmp(argv[0], "clear")) {
rerere_clear(the_repository, &merge_rr);
} else if (!strcmp(argv[0], "gc"))
rerere_gc(the_repository, &merge_rr);
rerere_gc(the_repository, &merge_rr,
auto_flag ? RERERE_NOWAIT : 0);
else if (!strcmp(argv[0], "status")) {
if (setup_rerere(the_repository, &merge_rr,
flags | RERERE_READONLY) < 0)
Expand Down
2 changes: 1 addition & 1 deletion builtin/stash.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -732,7 +732,7 @@ static enum stash_apply_result do_apply_stash(const char *prefix,
ret = error(_("could not write index"));

if (ret) {
repo_rerere(the_repository, 0);
repo_rerere(the_repository, RERERE_SKIP_LOCKED);

if (index)
fprintf_ln(stderr, _("Index was not unstashed."));
Expand Down
56 changes: 49 additions & 7 deletions rerere.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -3,6 +3,7 @@

#include "git-compat-util.h"
#include "abspath.h"
#include "advice.h"
#include "config.h"
#include "copy.h"
#include "environment.h"
Expand Down Expand Up @@ -33,6 +34,9 @@ static int rerere_enabled = -1;
/* automatically update cleanly resolved paths to the index */
static int rerere_autoupdate;

/* how long to wait for MERGE_RR.lock, in milliseconds */
static int rerere_lock_timeout_ms = 1000;

#define RR_HAS_POSTIMAGE 1
#define RR_HAS_PREIMAGE 2
struct rerere_dir {
Expand Down Expand Up @@ -850,6 +854,8 @@ static void git_rerere_config(void)
{
repo_config_get_bool(the_repository, "rerere.enabled", &rerere_enabled);
repo_config_get_bool(the_repository, "rerere.autoupdate", &rerere_autoupdate);
repo_config_get_int(the_repository, "rerere.locktimeout",
&rerere_lock_timeout_ms);
repo_config(the_repository, git_default_config, NULL);
}

Expand Down Expand Up @@ -882,12 +888,48 @@ int setup_rerere(struct repository *r, struct string_list *merge_rr, int flags)

if (flags & (RERERE_AUTOUPDATE|RERERE_NOAUTOUPDATE))
rerere_autoupdate = !!(flags & RERERE_AUTOUPDATE);
if (flags & RERERE_READONLY)
if ((flags & RERERE_READONLY) &&
(flags & (RERERE_NOWAIT | RERERE_SKIP_LOCKED)))
BUG("RERERE_READONLY takes no lock, so no lock flag applies");
if (flags & RERERE_READONLY) {
fd = 0;
else
fd = repo_hold_lock_file_for_update(r, &write_lock,
git_path_merge_rr(r),
LOCK_DIE_ON_ERROR);
} else {
const char *path = git_path_merge_rr(r);
int lock_flags = LOCK_DIE_ON_ERROR;
int timeout_ms = rerere_lock_timeout_ms;

/*
* Another process may hold the lock for a while, e.g.
* "git rerere gc" while it prunes rr-cache, so wait for
* it instead of dying right away. The gc of an automatic
* maintenance run does not wait, since skipping one of
* its runs costs nothing. A command that stops at a
* conflict must not die here either, so it warns and
* goes on without rerere.
*/
if (flags & RERERE_NOWAIT) {
lock_flags = 0;
timeout_ms = 0;
}
if (flags & RERERE_SKIP_LOCKED)
lock_flags = 0;
fd = repo_hold_lock_file_for_update_timeout(r, &write_lock,
path, lock_flags,
timeout_ms);
if (fd < 0) {
if (flags & RERERE_SKIP_LOCKED) {
warning_errno(_("skipping rerere, "
"unable to create '%s.lock'"),
path);
advise_if_enabled(ADVICE_MERGE_CONFLICT,
_("run \"git rerere\" before "
"resolving the conflict to "
"record or replay its "
"resolution"));
}
return -1;
}
}
read_rr(r, merge_rr);
return fd;
}
Expand Down Expand Up @@ -1272,7 +1314,7 @@ bool rerere_gc_needed(struct repository *r, size_t limit)
return needed;
}

void rerere_gc(struct repository *r, struct string_list *rr)
void rerere_gc(struct repository *r, struct string_list *rr, int flags)
{
struct string_list to_remove = STRING_LIST_INIT_DUP;
DIR *dir;
Expand All @@ -1282,7 +1324,7 @@ void rerere_gc(struct repository *r, struct string_list *rr)
timestamp_t cutoff_resolve;
struct strbuf buf = STRBUF_INIT;

if (setup_rerere(r, rr, 0) < 0)
if (setup_rerere(r, rr, flags) < 0)
return;

rerere_gc_cutoffs(r, &cutoff_resolve, &cutoff_noresolve);
Expand Down
6 changes: 5 additions & 1 deletion rerere.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -10,6 +10,10 @@ struct repository;
#define RERERE_AUTOUPDATE 01
#define RERERE_NOAUTOUPDATE 02
#define RERERE_READONLY 04
/* Take MERGE_RR.lock only if it is free, and return quietly otherwise */
#define RERERE_NOWAIT 010
/* Warn and go on without rerere if MERGE_RR.lock cannot be taken in time */
#define RERERE_SKIP_LOCKED 020

/*
* Marks paths that have been hand-resolved and added to the
Expand Down Expand Up @@ -37,7 +41,7 @@ const char *rerere_path(struct strbuf *buf, const struct rerere_id *,
int rerere_forget(struct repository *, struct pathspec *);
int rerere_remaining(struct repository *, struct string_list *);
void rerere_clear(struct repository *, struct string_list *);
void rerere_gc(struct repository *, struct string_list *);
void rerere_gc(struct repository *, struct string_list *, int);

/*
* Check whether garbage collection for rerere entries is needed, which is
Expand Down
4 changes: 2 additions & 2 deletions sequencer.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2520,7 +2520,7 @@ static enum pick_result do_pick_commit(struct repository *r,
: _("could not apply %s... %s"),
short_commit_name(r, commit), msg.subject);
print_advice(r, res == 1, opts);
repo_rerere(r, opts->allow_rerere_auto);
repo_rerere(r, opts->allow_rerere_auto | RERERE_SKIP_LOCKED);
goto leave;
}

Expand Down Expand Up @@ -4449,7 +4449,7 @@ static int do_merge(struct repository *r,

rollback_lock_file(&lock);
if (ret)
repo_rerere(r, opts->allow_rerere_auto);
repo_rerere(r, opts->allow_rerere_auto | RERERE_SKIP_LOCKED);
else
/*
* In case of problems, we now want to return a positive
Expand Down
Loading
Loading