refs: verify does not work if there are v2.43.0 or older worktrees w/o wt. refs
From: Kristoffer Haugsbakk <[email protected]>
(regular git-bugreport(1) follows after this, then a demo patch)
git-refs-verify(1) checks worktree refs since v2.47.0-111-g7c78d819e6a (ref: support multiple worktrees check for refs, 2024-11-20). This causes the command to always exit with code 255 and stderr output lines for each worktree created on v2.43.0 or older that does not have worktree refs:
error: cannot open directory .git/worktrees/<worktree name>/refs: No such file or directory
This is apparently caused by worktrees created on Git v2.43.0 or older. Apparently these worktrees don’t have this directory unless there exist worktree refs:
.git/worktrees/<worktree name>/refs
Again: any such worktrees work fine if you for example have bisect refs. But the command will always fail if you have one or more v2.43.0 or older worktrees with no worktree refs.
git-fsck(1) also now prints the same warnings because of the default --reference. But the operation of the command seems unaffected.
So to reproduce (also see patch at the end)
1. Make a worktree on v2.43.0 or just make a worktree and delete the refs/ directory for the worktree
2. Run git refs verify
• On your regular git(1): not on v2.43.0
3. Expected: succeeds without output
4. Actual: exit code 255, cannot open directory on stderr
Or reproduce with this script (replace with clone with worktree if you prefer):
git config set --global safe.directory /tmp &&
cd /tmp &&
dir=$(mktemp -d)
cd $dir
git clone https://github.com/git/git git-older &&
cd git-older &&
git checkout v2.43.0 &&
make &&
# use Git v2.43.0
./git worktree add --detach worktree1234 &&
# will fail
git refs verify
# Cleanup
git config unset --global safe.directory§ Testing on seen and next
• seen: bfa90786bc5 (Merge branch 'jk/diff-no-index-with-pathspec' into seen, 2025-05-29)
• next: d4ff7b7c865 (Sync with 'master', 2025-05-29)
§ Regular report
Quoted 4 lines
Thank you for filling out a Git bug report!
Please answer the following questions to help us understand your issue.What did you do before the bug happened? (Steps to reproduce your issue)
Using a repository with worktrees that were apparently made on v2.43.0 or older, based on testing. Some of them have no worktree refs which is what triggers this behavior.
Quoted 1 line
What did you expect to happen? (Expected behavior)
git refs verify with exit code 0 and no output.
Quoted 1 line
What happened instead? (Actual behavior)
The same command exits with exit code 255 and output like
error: cannot open directory .git/worktrees/<worktree name>/refs: No such file or directory
What's different between what you expected and what actually happened?
See above.
Quoted 4 lines
Anything else you want to add:
Please review the rest of the bug report below.
You can delete any lines you don't wish to share.
[System Info]
git version:
git version 2.50.0.rc0
cpu: x86_64
built from commit: b32feae0f1b21faaf8e191e8d3314a32470a536b
sizeof-long: 8
sizeof-size_t: 8
shell-path: /bin/sh
libcurl: 7.81.0
OpenSSL: OpenSSL 3.0.2 15 Mar 2022
zlib: 1.2.11
SHA-1: SHA1_DC
SHA-256: SHA256_BLK
uname: Linux 6.8.0-59-generic #61~22.04.1-Ubuntu SMP PREEMPT_DYNAMIC Tue Apr 15 17:03:15 UTC 2 x86_64 compiler info: gnuc: 11.4
libc info: glibc: 2.35
$SHELL (typically, interactive shell): /bin/bash
[Enabled Hooks]
post-rewrite
sendemail-validate
-- 8< --
From: Kristoffer Haugsbakk <[email protected]>
Subject: [PATCH] t0602: demo v2.43.0 worktree problem
--- t/t0602-reffiles-fsck.sh | 43 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 43 insertions(+)
t/t0602-reffiles-fsck.sh +43 -0
@@ -886,4 +886,47 @@ test_expect_success '--[no-]references option should apply to fsck' ' ) ' +# These worktrees will not have a refs/ directory unless there +# actually exist worktree refs +test_expect_failure 'works with worktrees from v2.43.0 or older without worktree refs' ' + test_when_finished "rm -rf repo" && + git init repo && + ( + cd repo && + test_commit initial && + git checkout -b default-branch && + git worktree add --detach ./worktree && + # Simulate old directory layout + rmdir .git/worktrees/worktree/refs && + git refs verify 2>err && + test_must_be_empty err + ) +' + +test_expect_success 'works with worktrees from v2.43.0 or older with worktree refs' ' + test_when_finished "rm -rf repo" && + git init repo && + ( + cd repo && + test_commit initial && + test_commit second && + git checkout -b default-branch && + git worktree add --detach ./worktree && + ( + cd worktree && + git bisect start && + git bisect bad HEAD && + git bisect good initial && + # Simulate old directory layout: delete if empty + # But there should exist a refs/bisect/ directory now + if [ ! -e ../.git/worktrees/worktree/refs/bisect ] + then + rmdir ../.git/worktrees/worktree/refs + fi && + git refs verify 2>err && + test_must_be_empty err + ) + ) +' + test_done
Signature · 1 line
Don’t cry because the bug is fixed. Smile because it happened.
Quoted 7 lines · On Fri, May 30, 2025 at 3:00 PM <[email protected]> wrote:
git-refs-verify(1) checks worktree refs since v2.47.0-111-g7c78d819e6a (ref: support multiple worktrees check for refs, 2024-11-20). This causes the command to always exit with code
255and stderr output lines for each worktree created on v2.43.0 or older that does not have worktree refs:error: cannot open directory .git/worktrees/<worktree name>/refs: No such file or directory
Interesting. I didn't follow the topic which introduced 7c78d819e6 (ref: support multiple worktrees check for refs, 2024-11-20), but I can confirm that this is a problem.
Quoted 5 lines
This is apparently caused by worktrees created on Git v2.43.0 or older. Apparently these worktrees don’t have this directory unless there exist worktree refs:
.git/worktrees/<worktree name>/refs
Indeed, the "refs" subdirectory was not present by default in older Git versions. Were you able to track down which commit is responsible for that directory getting created automatically when the worktree gets created?
Quoted 5 lines
-- 8< --
From: Kristoffer Haugsbakk <[email protected]>
Subject: [PATCH] t0602: demo v2.43.0 worktree problemSigned-off-by Kristoffer Haugsbakk <[email protected]>
Even though this is a bug report and the patch you included doesn't provide a fix, you did craft a couple tests, presumably with the intention that they should be used by whomever fixes the problem. As such, I'll give them a bit of a critique...
t/t0602-reffiles-fsck.sh test_expect_success '--[no-]references option should apply to fsck' ' · line 894
Quoted 11 lines
t/t0602-reffiles-fsck.sh | 43 ++++++++++++++++++++++++++++++++++++++++t/t0602-reffiles-fsck.sh +9
-0@@ -886,4 +886,47 @@ test_expect_success '--[no-]references option should apply to fsck' ' +# These worktrees will not have a refs/ directory unless there +# actually exist worktree refs +test_expect_failure 'works with worktrees from v2.43.0 or older without worktree refs' ' + test_when_finished "rm -rf repo" && + git init repo && + ( + cd repo && + test_commit initial && + git checkout -b default-branch &&
This git checkout -b seems unnecessary. The expected test failure occurs without this step. As such, it's probably just noise which will confuse readers rather than help them. I suggest omitting it.
Quoted 6 lines
t/t0602-reffiles-fsck.sh +6
-0+ git worktree add --detach ./worktree && + # Simulate old directory layout + rmdir .git/worktrees/worktree/refs && + git refs verify 2>err && + test_must_be_empty err + )
t/t0602-reffiles-fsck.sh test_expect_success '--[no-]references option should apply to fsck' ' · line 913
Quoted 10 lines
t/t0602-reffiles-fsck.sh +10
-0+' + +test_expect_success 'works with worktrees from v2.43.0 or older with worktree refs' ' + test_when_finished "rm -rf repo" && + git init repo && + ( + cd repo && + test_commit initial && + test_commit second && + git checkout -b default-branch &&
Unnecessary branch creation?
t/t0602-reffiles-fsck.sh test_expect_success '--[no-]references option should apply to fsck' ' · line 925
Quoted 12 lines
t/t0602-reffiles-fsck.sh +12
-0+ git worktree add --detach ./worktree && + ( + cd worktree && + git bisect start && + git bisect bad HEAD && + git bisect good initial && + # Simulate old directory layout: delete if empty + # But there should exist a refs/bisect/ directory now + if [ ! -e ../.git/worktrees/worktree/refs/bisect ] + then + rmdir ../.git/worktrees/worktree/refs + fi &&
A few comments...
First, I'm having trouble understanding what the intention is here; the comment does not illuminate. Even with v2.43.0, .git/worktrees/worktree/refs/bisect exists after "git bisect bad HEAD", so it seems that the if condition can never fail, and the rmdir is dead code.
Second, this project uses test rather than [ in shell scripts.
Finally, I see that other parts of the script are already (perhaps) too intimate with the structure of the .git/ directory, and you may have simply been following suit, but these days we often want to abstract away such familiarity. Hence, rather than hardcoding the path "../.git/worktrees/<worktree>/refs", you could do this:
refs="$(git rev-parse --git-dir)/refs" &&
if test ! -e "$refs/bisect"
then
rmdir "$refs"
fi &&t/t0602-reffiles-fsck.sh test_expect_success '--[no-]references option should apply to fsck' ' · line 930
Quoted 5 lines
t/t0602-reffiles-fsck.sh +5
-0+ git refs verify 2>err && + test_must_be_empty err + ) + ) +'
Overall, although the first new test makes sense, it is not at all clear to me what the second test is checking or what its purpose is.
Quoted 7 lines · Eric Sunshine
Quoted 6 lines · On Fri, May 30, 2025 at 3:00 PM <[email protected]> wrote:
git-refs-verify(1) checks worktree refs since v2.47.0-111-g7c78d819e6a (ref: support multiple worktrees check for refs, 2024-11-20). This causes the command to always exit with code
255and stderr output lines for each worktree created on v2.43.0 or older that does not have worktree refs:
Quoted 6 lines
Quoted 1 line
error: cannot open directory .git/worktrees/<worktree name>/refs: No such file or directory
Interesting. I didn't follow the topic which introduced
7c78d819e6(ref: support multiple worktrees check for refs, 2024-11-20), but I can confirm that this is a problem.
Yes, I didn't realize about this. Thank Kristoffer for reporting this issue and you for confirming this. I would write a patch today to fix this issue. And hope that this fix would land in this release.
Quoted 11 lines
Quoted 5 lines
This is apparently caused by worktrees created on Git v2.43.0 or older. Apparently these worktrees don’t have this directory unless there exist worktree refs:
.git/worktrees/<worktree name>/refs
Indeed, the "refs" subdirectory was not present by default in older Git versions. Were you able to track down which commit is responsible for that directory getting created automatically when the worktree gets created?
I find out that; in 8f4c00de95 (builtin/worktree: create refdb via ref backend, 2024-01-08)
Quoted 9 lines · Eric Sunshine
Quoted 4 lines
From: Kristoffer Haugsbakk <[email protected]>
Subject: [PATCH] t0602: demo v2.43.0 worktree problemSigned-off-by Kristoffer Haugsbakk <[email protected]>Even though this is a bug report and the patch you included doesn't provide a fix, you did craft a couple tests, presumably with the intention that they should be used by whomever fixes the problem. As such, I'll give them a bit of a critique...
Yes if s/should/could.[1] These are reproduction scripts as patches. So they can be applied and show the current state (first test is expect-failed, the second is expect-success) of the code.
My previous reproduction script with the git-clone(1) is inconvenient but either cloning or using a worktree is necessary in order to truly reproduce the problem (as opposed to simulating it).
A -subject-prefix='PATCH THROWAWAY' would have been in order.
On the other hand I did write the first test (the second is ugly) as if I was doing a quote-unquote real patch. In that light learning more about the proper style is useful for me. So thanks for the review!
Quoted 2 lines
Overall, although the first new test makes sense, it is not at all clear to me what the second test is checking or what its purpose is.
The idea behind the second test was to show a case where it does work with old worktrees. But simulating the old worktree didn’t make sense since it looks just like a new worktree when there *are* indeed worktree refs. So it just ended up being confusing.
† 1: As in troubleshooting and fixing the problem, not the final test in
the submitted patch. The test is unlikely to be good enough for that. But the patch is signed off on the small chance that it can be used because why not.
PATCH 1/1 fsck: ignore missing "refs" directory for linked worktrees
In reply to [email protected]It is reported that "git refs verify" would fail when encountering worktrees created on Git v2.43.0 or older versions. These versions don't automatically create the "refs" directory, causing the error:
error: cannot open directory .git/worktrees/<worktree name>/refs:
No such file or directory
Since 8f4c00de95 (builtin/worktree: create refdb via ref backend, 2024-01-08), we automatically create the "refs" directory for new worktrees. However, the fsck code incorrectly assumes all linked worktrees have this directory, thus introducing compatibility issue.
Check for ENOENT errno before reporting directory access errors for linked worktrees to maintain backward compatibility.
--- refs/files-backend.c | 3 +++ t/t0602-reffiles-fsck.sh | 15 +++++++++++++++ 2 files changed, 18 insertions(+)
refs/files-backend.c +3 -0
@@ -3762,6 +3762,9 @@ static int files_fsck_refs_dir(struct ref_store *ref_store, iter =dir_iterator_begin (sb.buf,0 );if (!iter) { +if (errno ==ENOENT && !is_main_worktree (wt)) + goto out; + ret =error_errno (_ ("cannot open directory %s" ), sb.buf); goto out; }
t/t0602-reffiles-fsck.sh +15 -0
@@ -110,6 +110,21 @@ test_expect_success 'ref name check should be adapted into fsck messages' ' ) ' +test_expect_success 'no refs directory of worktree should not cause problems' ' + test_when_finished "rm -rf repo" && + git init repo && + ( + cd repo && + test_commit initial && + + git worktree add --detach ./worktree && + # Simulate old directory layout + rm -rf ./git/worktrees/worktree/refs && + git refs verify 2>err && + test_must_be_empty err + ) +' + test_expect_success 'ref name check should work for multiple worktrees' ' test_when_finished "rm -rf repo" && git init repo &&
Signature · 1 line
2.49.0
Re: [PATCH] fsck: ignore missing "refs" directory for linked worktrees
Quoted 2 lines · shejialuo
It is reported that "git refs verify" would fail when encountering worktrees created on Git v2.43.0 or older versions. These versions
Nit: maybe
"git refs verify" doesn't work if there are worktrees created on Git v2.43.0 ...
The part about it specifically not working if there are no worktree refs might be obvious when you take in all of the context here (no refs/ directory). I don’t know.
Quoted 9 lines
don't automatically create the "refs" directory, causing the error:
error: cannot open directory .git/worktrees/<worktree name>/refs:
No such file or directorySince
8f4c00de95(builtin/worktree: create refdb via ref backend, 2024-01-08), we automatically create the "refs" directory for new worktrees. However, the fsck code incorrectly assumes all linked worktrees have this directory, thus introducing compatibility issue.
Thanks for finding that commit.
At this point in the message it seems like the fsck code never worked with these old linked worktrees. But git refs verify used to work with them until 7c78d819e6a (ref: support multiple worktrees check for refs, 2024-11-20) which was part of v2.48.0. So I think it’s worth mentioning that commit as well.
You wrote on the first email which I’ll just respond to here since it’s relevant:
https://lore.kernel.org/git/[email protected]/T/#mada29f8b0d02091d21412d8bd57cc666bc657c04
Quoted 1 line
Quoted 1 line
And hope that this fix would land in this release.
Like I said in the first email the only minor regression in this release cycle is that git-fsck(1) reports these errors on stderr because the default --reference. This was how I spotted the issue on rc0. But I neglected to mention that the commit that introduced --references (default) for git-fsck(1) is v2.48.0-rc1-49-gc1cf918d3ad (builtin/fsck:
add git refs verify child process, 2025-02-28).[1]
So based on the last what’s cooking email[2] it depends on if the stderr output regresssion from git-fsck(1) in this release cycle is severe enough to need be fixed in this release. Because the git refs-verify problem has been there since v2.48.0.
† 1: Part of the reason for neglecting that was that building that
commit fails for me. So the bisection skipped it and couldn’t find the commit. Is that just me? The merge commit does build de35b7b3ff (Merge branch 'sj/ref-consistency-checks-more', 2025-03-26). I changed start_progress(r, _("Checking ref database"), 1); to progress = start_progress(_("Checking ref database"), 1);. I don’t know if that is wrong but it made the bisection script run without having to error out with 125.
[2]: https://lore.kernel.org/git/[email protected]/T/#u
Quoted 32 lines
Check for ENOENT errno before reporting directory access errors for linked worktrees to maintain backward compatibility.
Reported-by Kristoffer Haugsbakk <[email protected]>Signed-off-by shejialuo <[email protected]>--- refs/files-backend.c | 3 +++ t/t0602-reffiles-fsck.sh | 15 +++++++++++++++ 2 files changed, 18 insertions(+)refs/files-backend.c +3
-0@@ -3762,6 +3762,9 @@ static int files_fsck_refs_dir(struct ref_store *ref_store, iter =dir_iterator_begin (sb.buf,0 );if (!iter) { +if (errno ==ENOENT && !is_main_worktree (wt)) + goto out; + ret =error_errno (_ ("cannot open directory %s" ), sb.buf); goto out;refs/files-backend.c +0
-0}t/t0602-reffiles-fsck.sh +0
-0@@ -110,6 +110,21 @@ test_expect_success 'ref name check should beadapted into fsck messages' '
t/t0602-reffiles-fsck.sh test_expect_success 'ref name check should be adapted into fsck messages' ' · line 119
Quoted 10 lines
t/t0602-reffiles-fsck.sh +7
-0) ' +test_expect_success 'no refs directory of worktree should not cause problems' ' + test_when_finished "rm -rf repo" && + git init repo && + ( + cd repo && + test_commit initial && +
Nit: blank line?
t/t0602-reffiles-fsck.sh test_expect_success 'ref name check should be adapted into fsck messages' ' · line 122
Quoted 3 lines
t/t0602-reffiles-fsck.sh +3
-0+ git worktree add --detach ./worktree && + # Simulate old directory layout + rm -rf ./git/worktrees/worktree/refs &&
Eric[3] had a git rev-parse --git-dir suggestion instead of using .git.
[3]: https://lore.kernel.org/git/[email protected]/T/#mb42bdb046c391f2583c2200668945408a2d0396f
Quoted 10 lines
t/t0602-reffiles-fsck.sh +5
-1+ git refs verify 2>err && + test_must_be_empty err + ) +' + test_expect_success 'ref name check should work for multiple worktrees' ' test_when_finished "rm -rf repo" && git init repo && --2.49.0
Re: [PATCH] fsck: ignore missing "refs" directory for linked worktrees
Quoted 8 lines · Kristoffer Haugsbakk
Quoted 2 lines · shejialuo
It is reported that "git refs verify" would fail when encountering worktrees created on Git v2.43.0 or older versions. These versions
Nit: maybe
"git refs verify" doesn't work if there are worktrees created on Git v2.43.0 ...
Yeah, "It is reported that" was somewhat odd introduction.
Quoted 4 lines
Quoted 4 lines
don't automatically create the "refs" directory, causing the error:
error: cannot open directory .git/worktrees/<worktree name>/refs:
No such file or directory
The original of this part already reads quite well, I think.
Quoted 6 lines
Quoted 4 lines
Since
8f4c00de95(builtin/worktree: create refdb via ref backend, 2024-01-08), we automatically create the "refs" directory for new worktrees. However, the fsck code incorrectly assumes all linked worktrees have this directory, thus introducing compatibility issue.Thanks for finding that commit.
Yup. And that one is v2.44.0-rc0~58^2, and that is where "v2.43" in the above description comes from.
Quoted 5 lines
At this point in the message it seems like the fsck code never worked with these old linked worktrees. But
git refs verifyused to work with them until7c78d819e6a(ref: support multiple worktrees check for refs, 2024-11-20) which was part of v2.48.0. So I think it’s worth mentioning that commit as well.
Good suggestion.
Quoted 6 lines
Like I said in the first email the only minor regression in this release cycle is that git-fsck(1) reports these errors on stderr because the default
--reference. This was how I spotted the issue on rc0. But I neglected to mention that the commit that introduced--references(default) for git-fsck(1) is v2.48.0-rc1-49-gc1cf918d3ad (builtin/fsck:
addgit refs verifychild process, 2025-02-28).[1]
Thanks for a careful analysis. The "fix" is rather obvious, so let's see if we can come up with the final wording of the commit log message and merge it down in time ;-).
Re: [PATCH] fsck: ignore missing "refs" directory for linked worktrees
In reply to Kristoffer HaugsbakkQuoted 4 lines · Kristoffer Haugsbakk
Quoted 2 lines · shejialuo
It is reported that "git refs verify" would fail when encountering worktrees created on Git v2.43.0 or older versions. These versions
Quoted 9 lines
Nit: maybe
"git refs verify" doesn't work if there are worktrees created on Git v2.43.0 ...
The part about it specifically not working if there are no worktree refs might be obvious when you take in all of the context here (no refs/ directory). I don’t know.
Right, I will improve this.
Quoted 10 lines
Quoted 9 lines
don't automatically create the "refs" directory, causing the error:
error: cannot open directory .git/worktrees/<worktree name>/refs:
No such file or directorySince
8f4c00de95(builtin/worktree: create refdb via ref backend, 2024-01-08), we automatically create the "refs" directory for new worktrees. However, the fsck code incorrectly assumes all linked worktrees have this directory, thus introducing compatibility issue.
Quoted 8 lines
Thanks for finding that commit.
At this point in the message it seems like the fsck code never worked with these old linked worktrees. But
git refs verifyused to work with them until7c78d819e6a(ref: support multiple worktrees check for refs, 2024-11-20) which was part of v2.48.0. So I think it’s worth mentioning that commit as well.
Good suggestion.
Quoted 5 lines
You wrote on the first email which I’ll just respond to here since it’s relevant:
https://lore.kernel.org/git/[email protected]/T/#mada29f8b0d02091d21412d8bd57cc666bc657c04
Quoted 9 lines
Quoted 1 line
Quoted 1 line
And hope that this fix would land in this release.
Like I said in the first email the only minor regression in this release cycle is that git-fsck(1) reports these errors on stderr because the default
--reference. This was how I spotted the issue on rc0. But I neglected to mention that the commit that introduced--references(default) for git-fsck(1) is v2.48.0-rc1-49-gc1cf918d3ad (builtin/fsck:
addgit refs verifychild process, 2025-02-28).[1]
Because we would call "git refs verify" subprocess in "git-fsck(1)" in this release cycle, I just want to fix this problem before the release. Thus, it won't affect the users.
Quoted 51 lines
So based on the last what’s cooking email[2] it depends on if the stderr output regresssion from git-fsck(1) in this release cycle is severe enough to need be fixed in this release. Because the
git refs-verifyproblem has been there since v2.48.0.† 1: Part of the reason for neglecting that was that building that
commit fails for me. So the bisection skipped it and couldn’t find the commit. Is that just me? The merge commit does buildde35b7b3ff(Merge branch 'sj/ref-consistency-checks-more', 2025-03-26). I changedstart_progress(r, _("Checking ref database"), 1);toprogress = start_progress(_("Checking ref database"), 1);. I don’t know if that is wrong but it made the bisection script run without having to error out with125.[2]: https://lore.kernel.org/git/[email protected]/T/#u
Quoted 35 lines
Check for ENOENT errno before reporting directory access errors for linked worktrees to maintain backward compatibility.
Reported-by Kristoffer Haugsbakk <[email protected]>Signed-off-by shejialuo <[email protected]>--- refs/files-backend.c | 3 +++ t/t0602-reffiles-fsck.sh | 15 +++++++++++++++ 2 files changed, 18 insertions(+)refs/files-backend.c +3
-0@@ -3762,6 +3762,9 @@ static int files_fsck_refs_dir(struct ref_store *ref_store, iter =dir_iterator_begin (sb.buf,0 );if (!iter) { +if (errno ==ENOENT && !is_main_worktree (wt)) + goto out; + ret =error_errno (_ ("cannot open directory %s" ), sb.buf); goto out;refs/files-backend.c +0
-0}t/t0602-reffiles-fsck.sh +0
-0@@ -110,6 +110,21 @@ test_expect_success 'ref name check should beadapted into fsck messages' '
)
'
Quoted 10 lines
t/t0602-reffiles-fsck.sh test_expect_success 'ref name check should be adapted into fsck messages' ' · line 119
Quoted 7 lines
t/t0602-reffiles-fsck.sh +7
-0+test_expect_success 'no refs directory of worktree should not cause problems' ' + test_when_finished "rm -rf repo" && + git init repo && + ( + cd repo && + test_commit initial && +Nit: blank line?
I would improve this. Normally in this test file, I would add a blank line to indicate the basic setup ends. So, I should do the following
cd repo && test_commit initial && git worktree add --detach ./worktree && rm -rf ...
I would improve this in the next version.
Quoted 8 lines
t/t0602-reffiles-fsck.sh test_expect_success 'ref name check should be adapted into fsck messages' ' · line 122
Quoted 3 lines
t/t0602-reffiles-fsck.sh +3
-0+ git worktree add --detach ./worktree && + # Simulate old directory layout + rm -rf ./git/worktrees/worktree/refs &&Eric[3] had a
git rev-parse --git-dirsuggestion instead of using.git.[3]: https://lore.kernel.org/git/[email protected]/T/#mb42bdb046c391f2583c2200668945408a2d0396f
Good suggestion, let me improve this.
Quoted 10 lines
Quoted 10 lines
t/t0602-reffiles-fsck.sh +5
-1+ git refs verify 2>err && + test_must_be_empty err + ) +' + test_expect_success 'ref name check should work for multiple worktrees' ' test_when_finished "rm -rf repo" && git init repo && --2.49.0
Thanks,
Jialuo
Re: [PATCH] fsck: ignore missing "refs" directory for linked worktrees
In reply to shejialuoHi Shejialuo
Quoted 5 lines · shejialuo
refs/files-backend.c +0
-0
refs/files-backend.c static int files_fsck_refs_dir(struct ref_store *ref_store, · line 3770
Quoted 9 lines
refs/files-backend.c +3
-0@@ -3762,6 +3762,9 @@ static int files_fsck_refs_dir(struct ref_store *ref_store, iter =dir_iterator_begin (sb.buf,0 );if (!iter) { +if (errno ==ENOENT && !is_main_worktree (wt)) + goto out; + ret =error_errno (_ ("cannot open directory %s" ), sb.buf); goto out; }
I think it would be clearer to write this as
if (is_main_worktree(wt) || errno != ENOENT)
ret = error_errno(_("cannot open directory %s"), sb.buf);
goto out;so that the condition that triggers the error message is explicit rather than having to mentally invert the condition to figure out when we return an error
Best Wishes
Phillip
Quoted 26 lines
t/t0602-reffiles-fsck.sh +15
-0@@ -110,6 +110,21 @@ test_expect_success 'ref name check should be adapted into fsck messages' ' ) ' +test_expect_success 'no refs directory of worktree should not cause problems' ' + test_when_finished "rm -rf repo" && + git init repo && + ( + cd repo && + test_commit initial && + + git worktree add --detach ./worktree && + # Simulate old directory layout + rm -rf ./git/worktrees/worktree/refs && + git refs verify 2>err && + test_must_be_empty err + ) +' + test_expect_success 'ref name check should work for multiple worktrees' ' test_when_finished "rm -rf repo" && git init repo &&
Re: [PATCH] fsck: ignore missing "refs" directory for linked worktrees
Quoted 19 lines · Phillip Wood
Hi Shejialuo
refs/files-backend.c static int files_fsck_refs_dir(struct ref_store *ref_store, · line 3769
Quoted 13 lines · shejialuo
refs/files-backend.c +3
-0@@ -3762,6 +3762,9 @@ static int files_fsck_refs_dir(struct ref_store *ref_store, iter =dir_iterator_begin (sb.buf,0 );if (!iter) { +if (errno ==ENOENT && !is_main_worktree (wt)) + goto out; + ret =error_errno (_ ("cannot open directory %s" ), sb.buf); goto out; }I think it would be clearer to write this as
Quoted 7 lines
if (is_main_worktree(wt) || errno != ENOENT) ret = error_errno(_("cannot open directory %s"), sb.buf); goto out;so that the condition that triggers the error message is explicit rather than having to mentally invert the condition to figure out when we return an error
The downside though is that this mandates that is_main_worktree() must never set errno itself. So while it may be clearer, the original version feels safer to me.
Patrick
Re: [PATCH] fsck: ignore missing "refs" directory for linked worktrees
Quoted 24 lines · Patrick Steinhardt
Quoted 23 lines · Phillip Wood
Hi Shejialuo
refs/files-backend.c static int files_fsck_refs_dir(struct ref_store *ref_store, · line 3769
Quoted 13 lines · shejialuo
refs/files-backend.c +3
-0@@ -3762,6 +3762,9 @@ static int files_fsck_refs_dir(struct ref_store *ref_store, iter =dir_iterator_begin (sb.buf,0 );if (!iter) { +if (errno ==ENOENT && !is_main_worktree (wt)) + goto out; + ret =error_errno (_ ("cannot open directory %s" ), sb.buf); goto out; }I think it would be clearer to write this as
if (is_main_worktree(wt) || errno != ENOENT) ret = error_errno(_("cannot open directory %s"), sb.buf); goto out;
Quoted 7 lines
Quoted 3 lines
so that the condition that triggers the error message is explicit rather than having to mentally invert the condition to figure out when we return an error
The downside though is that this mandates that
is_main_worktree()must never seterrnoitself. So while it may be clearer, the original version feels safer to me.
Oh good point. We could save errno and then check the saved version but it maybe it is not worth changing it.
Best Wishes
Phillip>
Quoted 1 line
Patrick
Re: [PATCH] fsck: ignore missing "refs" directory for linked worktrees
In reply to Patrick SteinhardtQuoted 24 lines · Patrick Steinhardt
Quoted 23 lines · Phillip Wood
Hi Shejialuo
refs/files-backend.c static int files_fsck_refs_dir(struct ref_store *ref_store, · line 3769
Quoted 13 lines · shejialuo
refs/files-backend.c +3
-0@@ -3762,6 +3762,9 @@ static int files_fsck_refs_dir(struct ref_store *ref_store, iter =dir_iterator_begin (sb.buf,0 );if (!iter) { +if (errno ==ENOENT && !is_main_worktree (wt)) + goto out; + ret =error_errno (_ ("cannot open directory %s" ), sb.buf); goto out; }I think it would be clearer to write this as
if (is_main_worktree(wt) || errno != ENOENT) ret = error_errno(_("cannot open directory %s"), sb.buf); goto out;
Quoted 7 lines
Quoted 3 lines
so that the condition that triggers the error message is explicit rather than having to mentally invert the condition to figure out when we return an error
The downside though is that this mandates that
is_main_worktree()must never seterrnoitself. So while it may be clearer, the original version feels safer to me.
FWIW, I found that the logic flow of the original more natural than the proposed rewrite. "dir_iterator_begin() appears to have failed by not returning a usable iterator, so we may need to complain, but as a special case, we can tolerate missing refs/ hierarchy if we are not in the primary working tree." was how I read these three additional lines.
Re: [PATCH] fsck: ignore missing "refs" directory for linked worktrees
In reply to Phillip WoodQuoted 19 lines · Phillip Wood
Hi Shejialuo
refs/files-backend.c static int files_fsck_refs_dir(struct ref_store *ref_store, · line 3769
Quoted 13 lines · shejialuo
refs/files-backend.c +3
-0@@ -3762,6 +3762,9 @@ static int files_fsck_refs_dir(struct ref_store *ref_store, iter =dir_iterator_begin (sb.buf,0 );if (!iter) { +if (errno ==ENOENT && !is_main_worktree (wt)) + goto out; + ret =error_errno (_ ("cannot open directory %s" ), sb.buf); goto out; }I think it would be clearer to write this as
Quoted 8 lines
if (is_main_worktree(wt) || errno != ENOENT) ret = error_errno(_("cannot open directory %s"), sb.buf); goto out;so that the condition that triggers the error message is explicit rather than having to mentally invert the condition to figure out when we return an error
I agree with you that by using this way, when reading above code, we could know explicitly in which situation, we would report the error.
Patrick has given his safety concern with reordering the condition check. If is_main_worktree(wt) were to modify error (although there is a minor possibility that it would), it could interfere with next errno check.
Besides this, I somehow prefer the short-circuit way. Although in the current code, we only have small code paths after the short-circuit way, this pattern follows a common defensive programming practice where we handle special cases early and exit quickly. This approach reduces nesting and makes the main logic flow cleaner by filtering out edge cases upfront.
So, let's keep this. Really thanks for your suggestion.
Quoted 4 lines
Best Wishes
Phillip
Jialuo
Re: [PATCH] fsck: ignore missing "refs" directory for linked worktrees
In reply to shejialuot/t0602-reffiles-fsck.sh test_expect_success 'ref name check should be adapted into fsck messages' ' · line 122
Quoted 10 lines · shejialuo
t/t0602-reffiles-fsck.sh +10
-0+test_expect_success 'no refs directory of worktree should not cause problems' ' + test_when_finished "rm -rf repo" && + git init repo && + ( + cd repo && + test_commit initial && + + git worktree add --detach ./worktree && + # Simulate old directory layout + rm -rf ./git/worktrees/worktree/refs &&
FYI. I made a mistake here, it should be ".git/worktrees" but not "./git".
Quoted 11 lines
t/t0602-reffiles-fsck.sh +5
-0+ git refs verify 2>err && + test_must_be_empty err + ) +' + test_expect_success 'ref name check should work for multiple worktrees' ' test_when_finished "rm -rf repo" && git init repo &&Signature · 1 line
2.49.0
v2 cover refs: verify does not work if there are v2.43.0 or older worktrees w/o wt. refs
In reply to shejialuoHi All:
This version updates the following things:
1. Update the commit message to incorporate the commit message that introduces the BUG to better explain.
2. Update the shell script to avoid hardcode gitdir path.
3. Change "rm -rf" to be "rmdir", which would be safer because we should delete an empty directory, which has a better semantics.
Thanks,
Jialuo
shejialuo (1):
fsck: ignore missing "refs" directory for linked worktrees
refs/files-backend.c | 3 +++ t/t0602-reffiles-fsck.sh | 17 +++++++++++++++++ 2 files changed, 20 insertions(+)
Range-diff against v1:
1: bfde11adb6 ! 1: d949a8a646 fsck: ignore missing "refs" directory for linked worktrees
@@ Metadata
## Commit message ##
fsck: ignore missing "refs" directory for linked worktrees
- It is reported that "git refs verify" would fail when encountering
- worktrees created on Git v2.43.0 or older versions. These versions
- don't automatically create the "refs" directory, causing the error:
+ "git refs verify" doesn't work if there are worktrees created on Git
+ v2.43.0 or older versions. These versions don't automatically create the
+ "refs" directory, causing the error:
error: cannot open directory .git/worktrees/<worktree name>/refs:
No such file or directory
Since 8f4c00de95 (builtin/worktree: create refdb via ref backend, 2024-01-08), we automatically create the "refs" directory for new
- worktrees. However, the fsck code incorrectly assumes all linked
- worktrees have this directory, thus introducing compatibility issue.
+ worktrees. And in 7c78d819e6 (ref: support multiple worktrees check for
+ refs, 2024-11-20), we assume that all linked worktrees have this
+ directory and would wrongly report an error to the user, thus
+ introducing compatibility issue.
Check for ENOENT errno before reporting directory access errors for linked worktrees to maintain backward compatibility.
@@ t/t0602-reffiles-fsck.sh: test_expect_success 'ref name check should be adapted
+ (
+ cd repo &&
+ test_commit initial &&
-+
+ git worktree add --detach ./worktree &&
++
++ cd worktree &&
++ worktree_refdir="$(git rev-parse --git-dir)/refs" &&
+ # Simulate old directory layout
-+ rm -rf ./git/worktrees/worktree/refs &&
++ rmdir "$worktree_refdir" &&
+ git refs verify 2>err &&
+ test_must_be_empty err
+ )
Signature · 1 line
2.49.0
PATCH v2 1/1 fsck: ignore missing "refs" directory for linked worktrees
"git refs verify" doesn't work if there are worktrees created on Git v2.43.0 or older versions. These versions don't automatically create the "refs" directory, causing the error:
error: cannot open directory .git/worktrees/<worktree name>/refs:
No such file or directory
Since 8f4c00de95 (builtin/worktree: create refdb via ref backend, 2024-01-08), we automatically create the "refs" directory for new worktrees. And in 7c78d819e6 (ref: support multiple worktrees check for refs, 2024-11-20), we assume that all linked worktrees have this directory and would wrongly report an error to the user, thus introducing compatibility issue.
Check for ENOENT errno before reporting directory access errors for linked worktrees to maintain backward compatibility.
--- refs/files-backend.c | 3 +++ t/t0602-reffiles-fsck.sh | 17 +++++++++++++++++ 2 files changed, 20 insertions(+)
refs/files-backend.c +3 -0
@@ -3762,6 +3762,9 @@ static int files_fsck_refs_dir(struct ref_store *ref_store, iter =dir_iterator_begin (sb.buf,0 );if (!iter) { +if (errno ==ENOENT && !is_main_worktree (wt)) + goto out; + ret =error_errno (_ ("cannot open directory %s" ), sb.buf); goto out; }
t/t0602-reffiles-fsck.sh +17 -0
@@ -110,6 +110,23 @@ test_expect_success 'ref name check should be adapted into fsck messages' ' ) ' +test_expect_success 'no refs directory of worktree should not cause problems' ' + test_when_finished "rm -rf repo" && + git init repo && + ( + cd repo && + test_commit initial && + git worktree add --detach ./worktree && + + cd worktree && + worktree_refdir="$(git rev-parse --git-dir)/refs" && + # Simulate old directory layout + rmdir "$worktree_refdir" && + git refs verify 2>err && + test_must_be_empty err + ) +' + test_expect_success 'ref name check should work for multiple worktrees' ' test_when_finished "rm -rf repo" && git init repo &&
Signature · 1 line
2.49.0
Re: [PATCH v2 1/1] fsck: ignore missing "refs" directory for linked worktrees
Quoted 6 lines · shejialuo
"git refs verify" doesn't work if there are worktrees created on Git v2.43.0 or older versions. These versions don't automatically create the "refs" directory, causing the error:
error: cannot open directory .git/worktrees/<worktree name>/refs:
No such file or directory
Good.
Quoted 6 lines
Since
8f4c00de95(builtin/worktree: create refdb via ref backend, 2024-01-08), we automatically create the "refs" directory for new worktrees. And in7c78d819e6(ref: support multiple worktrees check for refs, 2024-11-20), we assume that all linked worktrees have this directory and would wrongly report an error to the user, thus introducing compatibility issue.
Okay, you don’t mention c1cf918d3ad (builtin/fsck: add git refs verify child process, 2025-02-28) in the commit message because of your reply:
Quoted 3 lines
Quoted 3 lines
Because we would call "git refs verify" subprocess in "git-fsck(1)" in this release cycle, I just want to fix this problem before the release. Thus, it won't affect the users.
https://lore.kernel.org/git/[email protected]/T/#m01231abb77735b0f480743e0d2adecc172e1f170
Which I just mention here for completeness and my own memory. ;)
All good.
Quoted 6 lines
Check for ENOENT errno before reporting directory access errors for linked worktrees to maintain backward compatibility.
Reported-by Kristoffer Haugsbakk <[email protected]>Signed-off-by shejialuo <[email protected]>[snip]
t/t0602-reffiles-fsck.sh test_expect_success 'ref name check should be adapted into fsck messages' ' · line 121
Quoted 9 lines
t/t0602-reffiles-fsck.sh +9
-0+test_expect_success 'no refs directory of worktree should not cause problems' ' + test_when_finished "rm -rf repo" && + git init repo && + ( + cd repo && + test_commit initial && + git worktree add --detach ./worktree && + + cd worktree &&
Now in this version you change-directory into worktree. You would need a new subshell for that (test style). But I don’t see the need to chdir in the first place?
Quoted 12 lines
t/t0602-reffiles-fsck.sh +8
-1+ worktree_refdir="$(git rev-parse --git-dir)/refs" && + # Simulate old directory layout + rmdir "$worktree_refdir" && + git refs verify 2>err && + test_must_be_empty err + ) +' + test_expect_success 'ref name check should work for multiple worktrees' ' test_when_finished "rm -rf repo" && git init repo && --
Quoted 1 line
2.49.0
The test passes for me. Also when applying only the test (and not the fix) the test fails as expected. Good.
Re: [PATCH v2 1/1] fsck: ignore missing "refs" directory for linked worktrees
Quoted 5 lines · Kristoffer Haugsbakk
Quoted 5 lines
t/t0602-reffiles-fsck.sh +5
-0+test_expect_success 'no refs directory of worktree should not cause problems' ' + test_when_finished "rm -rf repo" && + git init repo && + ( + cd repo &&
Quoted 9 lines
t/t0602-reffiles-fsck.sh test_expect_success 'ref name check should be adapted into fsck messages' ' · line 121
Quoted 4 lines
t/t0602-reffiles-fsck.sh +4
-0+ test_commit initial && + git worktree add --detach ./worktree && + + cd worktree &&Now in this version you change-directory into
worktree. You would need a new subshell for that (test style). But I don’t see the need to chdir in the first place?
We should change directory into the worktree. This is because now in the test, we use "git rev-parse --git-dir" to get the git directory. We need to find gitdir of the linked worktree but not the gitdir of the main worktree. If we do not cd into the directory, we would get the gitdir of the main worktree.
And I agree with you that we need to spawn a subshell. Let me update the code. Thanks for reminding me, I forgot about that.
Quoted 8 lines
Quoted 8 lines
t/t0602-reffiles-fsck.sh +8
-0+ worktree_refdir="$(git rev-parse --git-dir)/refs" && + # Simulate old directory layout + rmdir "$worktree_refdir" && + git refs verify 2>err && + test_must_be_empty err + ) +' +
Quoted 8 lines
Quoted 5 lines
test_expect_success'ref name check should work for multiple worktrees' 't/t0602-reffiles-fsck.sh +0
-1test_when_finished "rm -rf repo" && git init repo && --2.49.0
The test passes for me. Also when applying only the test (and not the fix) the test fails as expected. Good.
Thanks for the feedback.
Jialuo
v3 cover refs: verify does not work if there are v2.43.0 or older worktrees w/o wt. refs
In reply to shejialuoHi All:
Changes in v2:
1. Update the commit message to incorporate the commit message that introduces the BUG to better explain.
2. Update the shell script to avoid hardcode gitdir path.
3. Change "rm -rf" to be "rmdir", which would be safer because we should delete an empty directory, which has a better semantics.
---
Changes in v3:
1. Use subshell for test style.
Thanks,
Jialuo
shejialuo (1):
fsck: ignore missing "refs" directory for linked worktrees
refs/files-backend.c | 3 +++ t/t0602-reffiles-fsck.sh | 19 +++++++++++++++++++ 2 files changed, 22 insertions(+)
Range-diff against v2:
1: d949a8a646 ! 1: e4c32971da fsck: ignore missing "refs" directory for linked worktrees
@@ t/t0602-reffiles-fsck.sh: test_expect_success 'ref name check should be adapted
+ test_commit initial &&
+ git worktree add --detach ./worktree &&
+
-+ cd worktree &&
-+ worktree_refdir="$(git rev-parse --git-dir)/refs" &&
-+ # Simulate old directory layout
-+ rmdir "$worktree_refdir" &&
-+ git refs verify 2>err &&
-+ test_must_be_empty err
++ (
++ cd worktree &&
++ worktree_refdir="$(git rev-parse --git-dir)/refs" &&
++ # Simulate old directory layout
++ rmdir "$worktree_refdir" &&
++ git refs verify 2>err &&
++ test_must_be_empty err
++ )
+ )
+'
+Signature · 1 line
2.49.0
PATCH v3 1/1 fsck: ignore missing "refs" directory for linked worktrees
"git refs verify" doesn't work if there are worktrees created on Git v2.43.0 or older versions. These versions don't automatically create the "refs" directory, causing the error:
error: cannot open directory .git/worktrees/<worktree name>/refs:
No such file or directory
Since 8f4c00de95 (builtin/worktree: create refdb via ref backend, 2024-01-08), we automatically create the "refs" directory for new worktrees. And in 7c78d819e6 (ref: support multiple worktrees check for refs, 2024-11-20), we assume that all linked worktrees have this directory and would wrongly report an error to the user, thus introducing compatibility issue.
Check for ENOENT errno before reporting directory access errors for linked worktrees to maintain backward compatibility.
--- refs/files-backend.c | 3 +++ t/t0602-reffiles-fsck.sh | 19 +++++++++++++++++++ 2 files changed, 22 insertions(+)
refs/files-backend.c +3 -0
@@ -3762,6 +3762,9 @@ static int files_fsck_refs_dir(struct ref_store *ref_store, iter =dir_iterator_begin (sb.buf,0 );if (!iter) { +if (errno ==ENOENT && !is_main_worktree (wt)) + goto out; + ret =error_errno (_ ("cannot open directory %s" ), sb.buf); goto out; }
t/t0602-reffiles-fsck.sh +19 -0
@@ -110,6 +110,25 @@ test_expect_success 'ref name check should be adapted into fsck messages' ' ) ' +test_expect_success 'no refs directory of worktree should not cause problems' ' + test_when_finished "rm -rf repo" && + git init repo && + ( + cd repo && + test_commit initial && + git worktree add --detach ./worktree && + + ( + cd worktree && + worktree_refdir="$(git rev-parse --git-dir)/refs" && + # Simulate old directory layout + rmdir "$worktree_refdir" && + git refs verify 2>err && + test_must_be_empty err + ) + ) +' + test_expect_success 'ref name check should work for multiple worktrees' ' test_when_finished "rm -rf repo" && git init repo &&
Signature · 1 line
2.49.0
Quoted 27 lines · shejialuo
[snip]
Range-diff against v2:
1:d949a8a646! 1:e4c32971dafsck: ignore missing "refs" directory for linked worktrees
@@t/t0602-reffiles-fsck.sh:test_expect_success'ref name check
should be adapted+ test_commit initial && + git worktree add --detach ./worktree && + -+ cd worktree && -+ worktree_refdir="$(git rev-parse --git-dir)/refs" && -+ # Simulate old directory layout -+ rmdir "$worktree_refdir" && -+ git refs verify 2>err && -+ test_must_be_empty err ++ ( ++ cd worktree && ++ worktree_refdir="$(git rev-parse --git-dir)/refs" && ++ # Simulate old directory layout ++ rmdir "$worktree_refdir" && ++ git refs verify 2>err && ++ test_must_be_empty err ++ ) + ) +' +
Quoted 2 lines
--
2.49.0
This version works as well. Thanks!
$ git range-diff --no-color --no-notes --inter-hunk-context=1 --ignore-all-space <range>
1: ddbf0f8cf4c ! 1: ce802ef6698 fsck: ignore missing "refs" directory for linked worktrees
@@ t/t0602-reffiles-fsck.sh: test_expect_success 'ref name check should be adapted
+ test_commit initial &&
+ git worktree add --detach ./worktree &&
+
++ (
+ cd worktree &&
+ worktree_refdir="$(git rev-parse --git-dir)/refs" &&
+ # Simulate old directory layout
+ rmdir "$worktree_refdir" &&
+ git refs verify 2>err &&
+ test_must_be_empty err
+ )
++ )
+'
+
test_expect_success 'ref name check should work for multiple worktrees' '