kernel
/
git
mirror of https://git.kernel.org/pub/scm/git/git.git
1
0
Fork 0
Code Releases Activity

Merge branch 'tb/rerere-wait-for-merge-rr-lock' into seen 

Instead of failing to record conflicts to be resolved immediately,
wait while "rerere gc" is ongoing.

* tb/rerere-wait-for-merge-rr-lock:
  rerere: go on at a conflict when the lock stays busy
  rerere: wait for MERGE_RR.lock, and let the gc skip it
seen
Junio C Hamano 2026-09-21 10:04:25 -07:00
parent d6746aed7f 4ec42e1d80
commit 707be48d48
11 changed files with 246 additions and 13 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
Documentation/config/rerere.adoc
View File

@ -10,3 +10,16 @@ rerere.enabled::
enabled if there is an `rr-cache` directory under the
`$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
`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` never waits and skips its run while the lock
is held.

4
Documentation/git-rerere.adoc
View File

@ -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.


DISCUSSION

2
apply.c
View File

@ -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;

3
builtin/am.c
View File

@ -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."));
}

2
builtin/merge.c
View File

@ -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;

2
builtin/stash.c
View File

@ -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."));

49
rerere.c
View File

@ -3,6 +3,7 @@

#include "git-compat-util.h"
#include "abspath.h"
#include "advice.h"
#include "config.h"
#include "copy.h"
#include "environment.h"
@ -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 {
@ -872,6 +876,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);
}

@ -904,12 +910,43 @@ 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;
long 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 itself never
* 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;
}
}
read_rr(r, merge_rr);
return fd;
}
@ -1304,7 +1341,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, RERERE_NOWAIT) < 0)
return;

rerere_gc_cutoffs(r, &cutoff_resolve, &cutoff_noresolve);

4
rerere.h
View File

@ -10,6 +10,10 @@ struct repository;
#define RERERE_AUTOUPDATE 01
#define RERERE_NOAUTOUPDATE 02
#define RERERE_READONLY 04
/* Never wait for MERGE_RR.lock, and skip the run when it is held */
#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

4
sequencer.c
View File

@ -2702,7 +2702,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;
}

@ -4691,7 +4691,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

168
t/t4200-rerere.sh
View File

@ -242,6 +242,174 @@ test_expect_success 'old records rest in peace' '
test_path_is_missing $rr2/preimage
'

test_expect_success 'gc does nothing while MERGE_RR is locked' '
mkdir -p $rr2 &&
echo Hello >$rr2/preimage &&
test-tool chmtime =$just_over_15_days_ago $rr2/preimage &&

test_when_finished "rm -f .git/MERGE_RR.lock" &&
>.git/MERGE_RR.lock &&
git rerere gc 2>err &&
test_grep "MERGE_RR.lock" err &&
test_path_is_file $rr2/preimage &&

rm .git/MERGE_RR.lock &&
git rerere gc &&
test_path_is_missing $rr2/preimage
'

test_expect_success 'a held lock is waited out within rerere.lockTimeout' '
git reset --hard &&
rm -rf $rr &&
test_when_finished "rm -f .git/MERGE_RR.lock" &&
>.git/MERGE_RR.lock &&
{
( sleep 1 && rm -f .git/MERGE_RR.lock ) &
} &&
test_must_fail git -c rerere.lockTimeout=5000 merge first 2>err &&
wait &&
test_grep ! "MERGE_RR" err &&
test_grep "^=======\$" $rr/preimage
'

test_expect_success 'merge goes on without rerere once rerere.lockTimeout is up' '
git reset --hard &&
rm -rf $rr &&
test_when_finished "rm -f .git/MERGE_RR.lock" &&
>.git/MERGE_RR.lock &&
test_must_fail git -c rerere.lockTimeout=0 merge first 2>err &&
test_grep "skipping rerere" err &&
test_grep "hint: .*git rerere" err &&
test_grep "^=======\$" a1 &&
test_path_is_missing $rr/preimage
'

test_expect_success 'rerere run at the stop records what was skipped' '
git reset --hard &&
rm -rf $rr &&
git checkout -b lock-held-catch-up third &&
test_when_finished "git checkout third && git branch -D lock-held-catch-up" &&
test_when_finished "rm -f .git/MERGE_RR.lock" &&
>.git/MERGE_RR.lock &&
test_must_fail git -c rerere.lockTimeout=0 merge first &&
test_path_is_missing $rr/preimage &&
rm .git/MERGE_RR.lock &&
git rerere &&
test_grep "^=======\$" $rr/preimage &&
echo resolved >a1 &&
git add a1 &&
git commit -qm resolved &&
test_path_is_file $rr/postimage
'

test_expect_success 'rebase goes on without rerere once rerere.lockTimeout is up' '
git reset --hard &&
rm -rf $rr &&
git checkout -b lock-held third &&
test_when_finished "git checkout third && git branch -D lock-held" &&
test_when_finished "rm -f .git/MERGE_RR.lock" &&
>.git/MERGE_RR.lock &&
test_must_fail git -c rerere.lockTimeout=0 rebase first 2>err &&
test_grep "skipping rerere" err &&
test_path_is_file .git/rebase-merge/stopped-sha &&
rm .git/MERGE_RR.lock &&
echo resolved >a1 &&
git add a1 &&
git rebase --continue &&
test_path_is_missing .git/rebase-merge &&
test_path_is_missing $rr/preimage
'

test_expect_success 'commit fails on a lock it cannot take' '
git reset --hard &&
rm -rf $rr &&
git checkout -b lock-held-commit third &&
test_when_finished "git checkout third && git branch -D lock-held-commit" &&
test_must_fail git merge first &&
test_path_is_file $rr/preimage &&
echo resolved >a1 &&
git add a1 &&
test_when_finished "rm -f .git/MERGE_RR.lock" &&
>.git/MERGE_RR.lock &&
test_must_fail git -c rerere.lockTimeout=0 commit -qm resolved 2>err &&
test_grep "Unable to create" err &&
test_path_is_missing $rr/postimage
'

test_expect_success 'am goes on without rerere once rerere.lockTimeout is up' '
git reset --hard &&
rm -rf $rr &&
git checkout -b lock-held-am third &&
test_when_finished "test_might_fail git am --abort &&
git checkout third && git branch -D lock-held-am" &&
git format-patch -1 --stdout first >first.patch &&
test_when_finished "rm -f .git/MERGE_RR.lock" &&
>.git/MERGE_RR.lock &&
test_must_fail git -c rerere.lockTimeout=0 am --3way first.patch 2>err &&
test_grep "skipping rerere" err &&
test_path_is_dir .git/rebase-apply &&
rm .git/MERGE_RR.lock &&
git am --abort &&
test_path_is_missing .git/rebase-apply
'

test_expect_success 'stash pop goes on without rerere once rerere.lockTimeout is up' '
git reset --hard &&
rm -rf $rr &&
git checkout -b lock-held-stash third &&
test_when_finished "git reset --hard && git stash drop &&
git checkout third && git branch -D lock-held-stash" &&
echo stashed >>a1 &&
git stash &&
echo committed >>a1 &&
git commit -qam committed &&
test_when_finished "rm -f .git/MERGE_RR.lock" &&
>.git/MERGE_RR.lock &&
test_must_fail git -c rerere.lockTimeout=0 stash pop 2>err &&
test_grep "skipping rerere" err &&
test_grep "^=======\$" a1
'

test_expect_success 'apply --3way goes on without rerere once rerere.lockTimeout is up' '
git reset --hard &&
rm -rf $rr &&
git checkout -b lock-held-apply third &&
test_when_finished "git reset --hard &&
git checkout third && git branch -D lock-held-apply" &&
git format-patch -1 --stdout first >first.patch &&
test_when_finished "rm -f .git/MERGE_RR.lock" &&
>.git/MERGE_RR.lock &&
test_must_fail git -c rerere.lockTimeout=0 apply --3way first.patch 2>err &&
test_grep "skipping rerere" err &&
test_grep "^=======\$" a1
'

test_expect_success 'rerere, forget and clear fail on a lock they cannot take' '
test_when_finished "rm -f .git/MERGE_RR.lock" &&
>.git/MERGE_RR.lock &&
test_must_fail git -c rerere.lockTimeout=0 rerere 2>err &&
test_grep "Unable to create" err &&
test_must_fail git -c rerere.lockTimeout=0 rerere forget a1 2>err &&
test_grep "Unable to create" err &&
test_must_fail git -c rerere.lockTimeout=0 rerere clear 2>err &&
test_grep "Unable to create" err
'

test_expect_success 'rebase --abort fails on a lock it cannot take' '
git reset --hard &&
git checkout -b lock-held-abort third &&
test_when_finished "git checkout third && git branch -D lock-held-abort" &&
test_must_fail git rebase first &&
test_when_finished "rm -f .git/MERGE_RR.lock" &&
>.git/MERGE_RR.lock &&
test_must_fail git -c rerere.lockTimeout=0 rebase --abort 2>err &&
test_grep "Unable to create" err &&
test_path_is_dir .git/rebase-merge &&
rm .git/MERGE_RR.lock &&
git rebase --abort &&
test_path_is_missing .git/rebase-merge
'

rerere_gc_custom_expiry_test () {
five_days="$1" right_now="$2"
test_expect_success "rerere gc with custom expiry ($five_days, $right_now)" '

8
t/t7900-maintenance.sh
View File

@ -1084,6 +1084,14 @@ test_expect_success 'rerere-gc task with --auto honors maintenance.rerere-gc.aut
test_expect_rerere_gc ! git -c maintenance.rerere-gc.auto=0 maintenance run --auto --task=rerere-gc
'

test_expect_success 'rerere-gc task succeeds while MERGE_RR is locked' '
test_when_finished "rm -rf .git/rr-cache .git/MERGE_RR.lock" &&
mkdir .git/rr-cache &&
: >.git/rr-cache/entry &&
>.git/MERGE_RR.lock &&
test_expect_rerere_gc git maintenance run --task=rerere-gc
'

test_expect_success '--auto and --schedule incompatible' '
test_must_fail git maintenance run --auto --schedule=daily 2>err &&
test_grep "cannot be used together" err