refs API: use "failure_errno", not "errno"

Fix a logic error in refs_resolve_ref_unsafe() introduced in a recent
series of mine to abstract the refs API away from errno. See
96f6623ada0 (Merge branch 'ab/refs-errno-cleanup', 2021-11-29)for that
series.

In that series introduction of "failure_errno" to
refs_resolve_ref_unsafe came in ef18119dec8 (refs API: add a version
of refs_resolve_ref_unsafe() with "errno", 2021-10-16). There we'd set
"errno = 0" immediately before refs_read_raw_ref(), and then set
"failure_errno" to "errno" if errno was non-zero afterwards.

Then in the next commit 8b72fea7e91 (refs API: make
refs_read_raw_ref() not set errno, 2021-10-16) we started expecting
"refs_read_raw_ref()" to set "failure_errno". It would do that if
refs_read_raw_ref() failed, but it wouldn't be the same errno.

So we might set the "errno" here to any arbitrary bad value, and end
up e.g. returning NULL when we meant to return the refname from
refs_resolve_ref_unsafe(), or the other way around. Instrumenting this
code will reveal cases where refs_read_raw_ref() will fail, and
"errno" and "failure_errno" will be set to different values.

In practice I haven't found a case where this scary bug changed
anything in practice. The reason for that is that we'll not care about
the actual value of "errno" here per-se, but only whether:

 1. We have an errno
 2. If it's one of ENOENT, EISDIR or ENOTDIR. See the adjacent code
    added in a1c1d8170db (refs_resolve_ref_unsafe: handle d/f
    conflicts for writes, 2017-10-06)

I.e. if we clobber "failure_errno" with "errno", but it happened to be
one of those three, and we'll clobber it with another one of the three
we were OK.

Perhaps there are cases where the difference ended up mattering, but I
haven't found them. Instrumenting the test suite to fail if "errno"
and "failure_errno" are different shows a lot of failures, checking if
they're different *and* one is but not the other is outside that list
of three "errno" values yields no failures.

But let's fix the obvious bug. We should just stop paying attention to
"errno" in refs_resolve_ref_unsafe(). In addition let's change the
partial resetting of "errno" in files_read_raw_ref() to happen just
before the "return", to ensure that any such bug will be more easily
spotted in the future.

Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/refs.c b/refs.c
index cd9b8bb1141325c5b2eb8bbc6cd247644160c63a..fe373bae4e19e0772e22bd6a837989a7f78acd91 100644 (file)
--- a/refs.c
+++ b/refs.c
@@ -1713,8 +1713,6 @@ const char *refs_resolve_ref_unsafe(struct ref_store *refs,
                if (refs_read_raw_ref(refs, refname, oid, &sb_refname,
                                      &read_flags, failure_errno)) {
                        *flags |= read_flags;
-                       if (errno)
-                               *failure_errno = errno;
 
                        /* In reading mode, refs must eventually resolve */
                        if (resolve_flags & RESOLVE_REF_READING)

diff --git a/refs/files-backend.c b/refs/files-backend.c
index abb6091fcf50ff01fefd43e46b69adcc552e581d..4bb4de72b6a2d5929943c515ff5c67d63f6cf900 100644 (file)
--- a/refs/files-backend.c
+++ b/refs/files-backend.c
@@ -385,7 +385,6 @@ stat_ref:
        if (lstat(path, &st) < 0) {
                int ignore_errno;
                myerr = errno;
-               errno = 0;
                if (myerr != ENOENT)
                        goto out;
                if (refs_read_raw_ref(refs->packed_ref_store, refname, oid,
@@ -402,7 +401,6 @@ stat_ref:
                strbuf_reset(&sb_contents);
                if (strbuf_readlink(&sb_contents, path, st.st_size) < 0) {
                        myerr = errno;
-                       errno = 0;
                        if (myerr == ENOENT || myerr == EINVAL)
                                /* inconsistent with lstat; retry */
                                goto stat_ref;
@@ -472,6 +470,7 @@ out:
 
        strbuf_release(&sb_path);
        strbuf_release(&sb_contents);
+       errno = 0;
        return ret;
 }