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
2ef1414
rerere: add "gc --skip-locked" for auto maintenance
thomasbachem Sep 28, 2026
cd01828
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
14 changes: 14 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,17 @@ 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

@gitgitgadget gitgitgadget Bot Sep 30, 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 28, 2026 at 11:58:21AM +0000, Thomas Bachem via GitGitGadget wrote:
> diff --git a/Documentation/git-rerere.adoc b/Documentation/git-rerere.adoc
> index 4e6ab9a27c..da7a1d093e 100644
> --- a/Documentation/git-rerere.adoc
> +++ b/Documentation/git-rerere.adoc
> @@ -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.

It's a bit weird to have git-rerere(1) document who calls it. We may
want to document why specifically this is useful though.

> diff --git a/builtin/rerere.c b/builtin/rerere.c
> index a056cb791b..2a8871df41 100644
> --- a/builtin/rerere.c
> +++ b/builtin/rerere.c
> @@ -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(),
>  	};

Thinking about this a bit... I know it was my suggestion, but I wonder
whether "auto" is misnamed. We don't let any heuristics kick in like we
typically do for other commands like `git pack-refs --auto`, we only
know to skip garbage collection if the lock is taken. So there is a bit
of a mismatch here.

How about we instead call this "--skip-locked"? We could even mark it as
a hidden option and not even document it, as it feels very specific to
how git-maintenance(1) wants to invoke it. If so, we could maybe remove
it again at a later point.

An alternative could be to instead call `rerere_gc()` directly, and if
so we wouldn't have to add this flag at all. But that may result in some
bigger changes, so I'll leave it up to you to decide.

>  	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)

Oh dear, this is a mess. The file could really use a refactoring to use
proper subcommands.

But anyway, that's certainly outside the scope of this patch series.

Patrick

@gitgitgadget gitgitgadget Bot Oct 1, 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.

Thomas Bachem wrote on the Git mailing list (how to reply to this email):

Hi Patrick,

On 30/09/2026 17:00, Patrick Steinhardt wrote:
> It's a bit weird to have git-rerere(1) document who calls it. We may
> want to document why specifically this is useful though.

I'll take that out of git-rerere(1) again. I'd keep the last sentence
of the rerere.lockTimeout entry, since that is where I say what each
command does when the time is up, but name the two commands there
instead of the option:

"A `git rerere gc` run by `git maintenance run --auto` or
`git gc --auto` does not wait and does nothing while the lock is held."

> How about we instead call this "--skip-locked"? We could even mark it as
> a hidden option and not even document it, as it feels very specific to
> how git-maintenance(1) wants to invoke it. If so, we could maybe remove
> it again at a later point.

I'll take both, the name and hiding it.

Patch 3 has a RERERE_SKIP_LOCKED flag for the conflict-time callers.
I'll rename that one to RERERE_WARN_LOCKED so it doesn't look like the
option's flag, which stays RERERE_NOWAIT.

> An alternative could be to instead call `rerere_gc()` directly, and if
> so we wouldn't have to add this flag at all. But that may result in some
> bigger changes, so I'll leave it up to you to decide.

I tried it. It is six lines in builtin/gc.c, but rerere_gc() dies when
it can't take the lock. A manual or scheduled "git maintenance run"
then dies with the lockfile's message and exit code 128, where it now
reports "task 'rerere-gc' failed" and exits with 1. The rerere-gc
tests in t7900 fail too, since their helper looks for the
"git rerere gc" child. So I'd keep the option for this series. Say if
you'd rather have the direct call.

I'll wait a day or two for other comments before I send v6.

Thanks,
Thomas

@gitgitgadget gitgitgadget Bot Oct 1, 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 Thu, Oct 01, 2026 at 10:08:16AM +0200, Thomas Bachem wrote:
> Hi Patrick,
> 
> On 30/09/2026 17:00, Patrick Steinhardt wrote:
> > It's a bit weird to have git-rerere(1) document who calls it. We may
> > want to document why specifically this is useful though.
> 
> I'll take that out of git-rerere(1) again. I'd keep the last sentence
> of the rerere.lockTimeout entry, since that is where I say what each
> command does when the time is up, but name the two commands there
> instead of the option:
> 
> "A `git rerere gc` run by `git maintenance run --auto` or
> `git gc --auto` does not wait and does nothing while the lock is held."
> 
> > How about we instead call this "--skip-locked"? We could even mark it as
> > a hidden option and not even document it, as it feels very specific to
> > how git-maintenance(1) wants to invoke it. If so, we could maybe remove
> > it again at a later point.
> 
> I'll take both, the name and hiding it.
> 
> Patch 3 has a RERERE_SKIP_LOCKED flag for the conflict-time callers.
> I'll rename that one to RERERE_WARN_LOCKED so it doesn't look like the
> option's flag, which stays RERERE_NOWAIT.
> 
> > An alternative could be to instead call `rerere_gc()` directly, and if
> > so we wouldn't have to add this flag at all. But that may result in some
> > bigger changes, so I'll leave it up to you to decide.
> 
> I tried it. It is six lines in builtin/gc.c, but rerere_gc() dies when
> it can't take the lock. A manual or scheduled "git maintenance run"
> then dies with the lockfile's message and exit code 128, where it now
> reports "task 'rerere-gc' failed" and exits with 1. The rerere-gc
> tests in t7900 fail too, since their helper looks for the
> "git rerere gc" child. So I'd keep the option for this series. Say if
> you'd rather have the direct call.

Ah, right, that makes sense. Let's keep the hidden option in that case.
Thanks!

Patrick

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.
A `git rerere gc` run by `git maintenance run --auto` or
`git gc --auto` does not wait and does nothing while the lock
is held.
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_WARN_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_WARN_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, "--skip-locked");
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_WARN_LOCKED);
printf(_("Automatic merge failed; "
"fix conflicts and then commit the result.\n"));
return 1;
Expand Down
10 changes: 8 additions & 2 deletions builtin/rerere.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -56,16 +56,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, skip_locked = 0, flags = 0;

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

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

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

repo_config(the_repository, git_xmerge_config, NULL);

if (autoupdate == 1)
Expand Down Expand Up @@ -94,7 +99,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,
skip_locked ? 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_WARN_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_WARN_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_WARN_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_WARN_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_WARN_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_WARN_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_WARN_LOCKED);
else
/*
* In case of problems, we now want to return a positive
Expand Down
Loading
Loading