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

rerere: wait for MERGE_RR.lock before giving up 

setup_rerere() takes MERGE_RR.lock with LOCK_DIE_ON_ERROR, so of two
processes that want it at the same time the second one dies. That
used to be rare. Since 452b12c2e0 (builtin/maintenance: use
"geometric" strategy by default, 2026-02-24) the auto maintenance
after a commit runs "git rerere gc" whenever rr-cache has enough
stale entries, and the gc holds the lock while it prunes.

A rebase whose next pick conflicts while that happens dies inside
repo_rerere(), before the sequencer has written the state that
"git rebase --continue" needs. Every later "git rebase --continue"
then fails with "you have staged changes in your working tree".

Wait for the lock for up to rerere.lockTimeout milliseconds, 1000 by
default, and only then fail as before. Pruning a few thousand entries
takes well under a second, so the default covers a rebase that runs
into the gc.

Assisted-by: Claude Fable 5.1
Signed-off-by: Thomas Bachem <mail@thomasbachem.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
seen
Thomas Bachem 2026-10-10 10:13:23 +00:00 committed by Junio C Hamano
parent a018953688
commit 19ff18e6d4
3 changed files with 78 additions and 5 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
Documentation/config/rerere.adoc
View File

@ -10,3 +10,11 @@ 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, the command fails as it does
for any other lock it cannot take.

22
rerere.c
View File

@ -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,19 @@ 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) {
fd = 0;
else
fd = repo_hold_lock_file_for_update(r, &write_lock,
git_path_merge_rr(r),
LOCK_DIE_ON_ERROR);
} else {
/*
* 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.
*/
fd = repo_hold_lock_file_for_update_timeout(r, &write_lock,
git_path_merge_rr(r),
LOCK_DIE_ON_ERROR,
rerere_lock_timeout_ms);
}
read_rr(r, merge_rr);
return fd;
}

53
t/t4200-rerere.sh
View File

@ -242,6 +242,59 @@ test_expect_success 'old records rest in peace' '
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 fails 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 "Unable to create" err &&
test_grep "^=======\$" a1 &&
test_path_is_missing $rr/preimage
'

test_expect_success 'rerere, forget, clear and gc 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_must_fail git -c rerere.lockTimeout=0 rerere gc 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)" '