From patchwork Sat Oct 16 09:39:07 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= X-Patchwork-Id: 12563375 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 810DCC433EF for ; Sat, 16 Oct 2021 09:39:51 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 658CB61073 for ; Sat, 16 Oct 2021 09:39:51 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S244028AbhJPJl6 (ORCPT ); Sat, 16 Oct 2021 05:41:58 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57600 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S244010AbhJPJlu (ORCPT ); Sat, 16 Oct 2021 05:41:50 -0400 Received: from mail-wr1-x436.google.com (mail-wr1-x436.google.com [IPv6:2a00:1450:4864:20::436]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 7ADCEC06176A for ; Sat, 16 Oct 2021 02:39:32 -0700 (PDT) Received: by mail-wr1-x436.google.com with SMTP id e12so30737677wra.4 for ; Sat, 16 Oct 2021 02:39:32 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=UTih+V2Ab8OqP972inaXkIY0GUhGzIH24cMpcgVplDI=; b=DIX5uZWWqqnlRGlf2sjIWUD+1VJPLilnjWv8ZCgkrr5vkhRFF2eQgtyOFXuro1sPWV 3XRSTidVGsb4uXEtl4scH2JapawlHa9My9emWI5JlsC1epLbxToCeggZEG+DEuEpocvx xO/DbAmdngDvb4VqpiVfgVQq6ShwlD1kEI2uP2fT+Kjca2OajHEosOVHR8ZyLpq1IzzP BSzXGRcGonrhdIdJrAT/LeeDz28jFhVoH4altmi2DlwhNROXL8ywRZg2/ZsBTwiCoctR f6mil+XtmHIfA6fWtESRNeP1ycqY6hAL0lR9LlTgIARIhmPTMc5sNZplcRFmbSz1IpRh xj2g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=UTih+V2Ab8OqP972inaXkIY0GUhGzIH24cMpcgVplDI=; b=vUBiVex52uZwT+lP1z9JKshClRBOfCwPCucO3F8eKKkAg2HgjDj4ACitlZrvE3Tf+t YiSI6JeS+M1ow8DHL60LFGFiBN0Z3a5hPqEfHvwVRb3IRhHE9gokd0yNuDtrqYbH9UeZ ErBdg90vAJ5MhRYwAC2fId2geNIcoSERf2ov42xQTOB31FrOk0YsL8gCrsc5SvWXuhha CSUnrlbzxcxFtxsfoiy4JRx+OA6iEuGLMTXx0qqbGjeClMPXLhCDUdLZfYZWfQvX29if YaKopetvskkMBYRNXG4FC45sWjErW/0uknzOiMlXF5fOndv6aH0rmAu+lZVWXhUg5v6m MkuQ== X-Gm-Message-State: AOAM530iXUu8i1WMGmZPxAQ6BVLRfXzyQ673TRVRcpOxVku2tclM9Mwy 60SsX7m5a31Imh/Usnoyx+GcxQUD/EF38g== X-Google-Smtp-Source: ABdhPJzAQxHoj9cOYFbER/uyCj0/SUzruKh92l680ccQXKKyzY8n3VaN0ToOP5l7jerOOrlszf8rDw== X-Received: by 2002:a5d:4ac4:: with SMTP id y4mr20459194wrs.190.1634377170878; Sat, 16 Oct 2021 02:39:30 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id k22sm6993492wrd.59.2021.10.16.02.39.30 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 16 Oct 2021 02:39:30 -0700 (PDT) From: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= To: git@vger.kernel.org Cc: Junio C Hamano , Jeff King , Han-Wen Nienhuys , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBC?= =?utf-8?b?amFybWFzb24=?= Subject: [PATCH v2 01/21] branch tests: test for errno propagating on failing read Date: Sat, 16 Oct 2021 11:39:07 +0200 Message-Id: X-Mailer: git-send-email 2.33.1.1338.g20da966911a In-Reply-To: References: MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org From: Han-Wen Nienhuys Add a test for "git branch" to cover the case where .git/refs is symlinked. To check availability, refs_verify_refname_available() will run refs_read_raw_ref() on each prefix, leading to a read() from .git/refs (which is a directory). It would probably be more robust to re-issue the lstat() as a normal stat(), in which case, we would fall back to the directory case, but for now let's just test for the existing behavior as-is. This test covers a regression in a commit that only ever made it to "next", see [1]. 1. http://lore.kernel.org/git/pull.1068.git.git.1629203489546.gitgitgadget@gmail.com Signed-off-by: Han-Wen Nienhuys Signed-off-by: Ævar Arnfjörð Bjarmason --- t/t3200-branch.sh | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/t/t3200-branch.sh b/t/t3200-branch.sh index e575ffb4ffb..53e0d094bb4 100755 --- a/t/t3200-branch.sh +++ b/t/t3200-branch.sh @@ -731,6 +731,28 @@ test_expect_success SYMLINKS 'git branch -m u v should fail when the reflog for test_must_fail git branch -m u v ' +test_expect_success SYMLINKS 'git branch -m with symlinked .git/refs' ' + test_when_finished "rm -rf subdir" && + git init --bare subdir && + + rm -rfv subdir/refs subdir/objects subdir/packed-refs && + ln -s ../.git/refs subdir/refs && + ln -s ../.git/objects subdir/objects && + ln -s ../.git/packed-refs subdir/packed-refs && + + git -C subdir rev-parse --absolute-git-dir >subdir.dir && + git rev-parse --absolute-git-dir >our.dir && + ! test_cmp subdir.dir our.dir && + + git -C subdir log && + git -C subdir branch rename-src && + git rev-parse rename-src >expect && + git -C subdir branch -m rename-src rename-dest && + git rev-parse rename-dest >actual && + test_cmp expect actual && + git branch -D rename-dest +' + test_expect_success 'test tracking setup via --track' ' git config remote.local.url . && git config remote.local.fetch refs/heads/*:refs/remotes/local/* && From patchwork Sat Oct 16 09:39:08 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= X-Patchwork-Id: 12563379 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 086C2C433F5 for ; Sat, 16 Oct 2021 09:39:58 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id E46BA60E96 for ; Sat, 16 Oct 2021 09:39:57 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S244043AbhJPJmE (ORCPT ); Sat, 16 Oct 2021 05:42:04 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57510 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S244011AbhJPJlu (ORCPT ); Sat, 16 Oct 2021 05:41:50 -0400 Received: from mail-wr1-x42c.google.com (mail-wr1-x42c.google.com [IPv6:2a00:1450:4864:20::42c]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 38C44C06176C for ; Sat, 16 Oct 2021 02:39:33 -0700 (PDT) Received: by mail-wr1-x42c.google.com with SMTP id y3so30850511wrl.1 for ; Sat, 16 Oct 2021 02:39:33 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=+ZBSzSS+JAEkX5OFYI+tGaQjHH7ZgkuB4KEiANw1hTU=; b=fRsRCSNq8AnWXEINe601WPMzPrOXm6h4+BCPgoeltIB5eJPpOcqGm2UU6GgYVJuST3 LgzB/u/pb9fHZdqFWFyd5uYPU5a7WSeglKCYSLsOZEkoRypewNc9pYMrg5hxcxPwPy/Q r3goYV0Sc6oqT0wGpJmvAUDOJBkop+41H0oJfJwB1v3jpyvG4MOd/RqHYIF0gUfg/XH0 c1WhuCUm8iv3cSZeOE3jIv43FoMXqZgZEqw/vG+OXnQ4LQ0IbcTQ93nIQGJJwP3VxnEY 9C4CeifuyoLpVf7x7uN1TWWl9hiN4qRqjhwLneWHfFmNJDbPtYp3qgJMs6CDr/PFcDHP J5qg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=+ZBSzSS+JAEkX5OFYI+tGaQjHH7ZgkuB4KEiANw1hTU=; b=T7N4fIXkfc2l2nDSLhbkBBR4ktUFmIMH8+8WnccnQHIh9E44HtIkoGlGRMAiaVCVF1 /UeVwiRerjCPuDyNFSGAb3AoItUwP8PSkex1wQDn738fBEQc64yt7FFqVQW1rx+byCMp d1Y+hRYaTcc+/4nM5opAbQEWZS+zLiEHmYajGnat+/nJITcu+Tv5P1pQoCD8izzJcIR6 NWYIq6EiQe9+m7XAl1XDwj4wQt0LpLOCjkbxctW+5DaWhdTmPo8fBQbw+tKmkC/YMVQ9 QqYMNQXTrGH/M4eeExZbjiUPoUx5enO3Up1FB/aHhRMfZOJe7AfP6cz52wLVTCQH3Uqs iEPw== X-Gm-Message-State: AOAM530MiSQ01wSzHeskwkEoTg84/EsuSdAwDpNyK9pI8rlwm5Ra1Gut bp4LEqpRZZ5l3JND4oqScwMnyb8TJQMQKQ== X-Google-Smtp-Source: ABdhPJxASb/CWn0i6Svkt0PmA6e4vorU2s9HGoqNZO6KPjvlBxZmmKdp/tSG7U5ke5kHNZAIrVLB9Q== X-Received: by 2002:adf:ee8a:: with SMTP id b10mr20937361wro.335.1634377171629; Sat, 16 Oct 2021 02:39:31 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id k22sm6993492wrd.59.2021.10.16.02.39.30 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 16 Oct 2021 02:39:31 -0700 (PDT) From: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= To: git@vger.kernel.org Cc: Junio C Hamano , Jeff King , Han-Wen Nienhuys , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBC?= =?utf-8?b?amFybWFzb24=?= Subject: [PATCH v2 02/21] refs API: add a version of refs_resolve_ref_unsafe() with "errno" Date: Sat, 16 Oct 2021 11:39:08 +0200 Message-Id: X-Mailer: git-send-email 2.33.1.1338.g20da966911a In-Reply-To: References: MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org Add a new refs_werrres_ref_unsafe() function, which is like refs_resolve_ref_unsafe() except that it explicitly saves away the "errno" to a passed-in parameter, the refs_resolve_ref_unsafe() then becomes a wrapper for it. In subsequent commits we'll migrate code over to it, before finally making "refs_resolve_ref_unsafe()" with an "errno" parameter the canonical version, so this this function exists only so that we can incrementally migrate callers, it will be going away in a subsequent commit. As the added comment notes has a rather tortured name to be the same length as "refs_resolve_ref_unsafe", to avoid churn as we won't need to re-indent the argument lists, similarly the documentation and structure of it in refs.h is designed to minimize a diff in a subsequent commit, where that documentation will be added to the new refs_resolve_ref_unsafe(). At the end of this migration the "meaningful errno" TODO item left in 76d70dc0c63 (refs.c: make resolve_ref_unsafe set errno to something meaningful on error, 2014-06-20) will be resolved. As can be seen from the use of refs_read_raw_ref() we'll also need to convert some functions that the new refs_werrres_ref_unsafe() itself calls to take this "failure_errno". That will be done in subsequent commits. Signed-off-by: Han-Wen Nienhuys Signed-off-by: Ævar Arnfjörð Bjarmason --- refs.c | 36 +++++++++++++++++++++++++++--------- refs.h | 12 ++++++++++++ 2 files changed, 39 insertions(+), 9 deletions(-) diff --git a/refs.c b/refs.c index 7f019c2377e..ad56dbb0125 100644 --- a/refs.c +++ b/refs.c @@ -1679,17 +1679,19 @@ int refs_read_raw_ref(struct ref_store *ref_store, type, &errno); } -/* This function needs to return a meaningful errno on failure */ -const char *refs_resolve_ref_unsafe(struct ref_store *refs, +const char *refs_werrres_ref_unsafe(struct ref_store *refs, const char *refname, int resolve_flags, - struct object_id *oid, int *flags) + struct object_id *oid, + int *flags, int *failure_errno) { static struct strbuf sb_refname = STRBUF_INIT; struct object_id unused_oid; int unused_flags; int symref_count; + assert(failure_errno); + if (!oid) oid = &unused_oid; if (!flags) @@ -1700,7 +1702,7 @@ const char *refs_resolve_ref_unsafe(struct ref_store *refs, if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) { if (!(resolve_flags & RESOLVE_REF_ALLOW_BAD_NAME) || !refname_is_safe(refname)) { - errno = EINVAL; + *failure_errno = EINVAL; return NULL; } @@ -1718,9 +1720,12 @@ const char *refs_resolve_ref_unsafe(struct ref_store *refs, for (symref_count = 0; symref_count < SYMREF_MAXDEPTH; symref_count++) { unsigned int read_flags = 0; + errno = 0; if (refs_read_raw_ref(refs, refname, oid, &sb_refname, &read_flags)) { *flags |= read_flags; + if (errno) + *failure_errno = errno; /* In reading mode, refs must eventually resolve */ if (resolve_flags & RESOLVE_REF_READING) @@ -1731,9 +1736,9 @@ const char *refs_resolve_ref_unsafe(struct ref_store *refs, * may show errors besides ENOENT if there are * similarly-named refs. */ - if (errno != ENOENT && - errno != EISDIR && - errno != ENOTDIR) + if (*failure_errno != ENOENT && + *failure_errno != EISDIR && + *failure_errno != ENOTDIR) return NULL; oidclr(oid); @@ -1760,7 +1765,7 @@ const char *refs_resolve_ref_unsafe(struct ref_store *refs, if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) { if (!(resolve_flags & RESOLVE_REF_ALLOW_BAD_NAME) || !refname_is_safe(refname)) { - errno = EINVAL; + *failure_errno = EINVAL; return NULL; } @@ -1768,10 +1773,23 @@ const char *refs_resolve_ref_unsafe(struct ref_store *refs, } } - errno = ELOOP; + *failure_errno = ELOOP; return NULL; } +const char *refs_resolve_ref_unsafe(struct ref_store *refs, const char *refname, + int resolve_flags, struct object_id *oid, + int *flags) +{ + int failure_errno = 0; + const char *refn; + refn = refs_werrres_ref_unsafe(refs, refname, resolve_flags, + oid, flags, &failure_errno); + if (!refn) + errno = failure_errno; + return refn; +} + /* backend functions */ int refs_init_db(struct strbuf *err) { diff --git a/refs.h b/refs.h index d5099d4984e..c8afde6bb50 100644 --- a/refs.h +++ b/refs.h @@ -11,6 +11,18 @@ struct string_list; struct string_list_item; struct worktree; +/* + * Callers should not inspect "errno" on failure, but rather pass in a + * "failure_errno" parameter, on failure the "errno" will indicate the + * type of failure encountered, but not necessarily one that came from + * a syscall. We might have faked it up. + */ +const char *refs_werrres_ref_unsafe(struct ref_store *refs, + const char *refname, + int resolve_flags, + struct object_id *oid, + int *flags, int *failure_errno); + /* * Resolve a reference, recursively following symbolic refererences. * From patchwork Sat Oct 16 09:39:09 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= X-Patchwork-Id: 12563373 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 179BFC433F5 for ; Sat, 16 Oct 2021 09:39:51 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id ED70761073 for ; Sat, 16 Oct 2021 09:39:50 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S244003AbhJPJl5 (ORCPT ); Sat, 16 Oct 2021 05:41:57 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57604 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S244012AbhJPJlu (ORCPT ); Sat, 16 Oct 2021 05:41:50 -0400 Received: from mail-wm1-x32a.google.com (mail-wm1-x32a.google.com [IPv6:2a00:1450:4864:20::32a]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id F304BC06176D for ; Sat, 16 Oct 2021 02:39:33 -0700 (PDT) Received: by mail-wm1-x32a.google.com with SMTP id 67-20020a1c1946000000b0030d4c90fa87so4056101wmz.2 for ; Sat, 16 Oct 2021 02:39:33 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=Dygm4lUp7okJ2v21gbn/QbIlCNCxJKXdSLwAW/VgnIU=; b=QL1QQ7/sFKrTKe8S4TWfQfnPYyjzevSvNS3+3sAmzVMeg2LUUrpG++xquUY5wSkDvF QOJRS2VGR2k2JD2S4rHr/GKfTWzxiIHcijxHUqD7ZtZw1vGLivAdfueBqh0zETHskRzV Ch2IVit8KT4iFLzumvggDUdJTmtDdfxXkacMuO6R4cbW5lGWwUGKx99RVgPZSUfDX2vS y66apeHCUTu4MrF8p52cow76SPywKHgaup/zvYY7E0r8VH+clJz/1IR1Na15kRsaE/28 AYNfD9t30QHgfaPys8p1Pyl7TJN8se/UrHc/D0ZGNxM8Bb7BSCFoqpsVsfTp9lFPk+c4 S2RQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=Dygm4lUp7okJ2v21gbn/QbIlCNCxJKXdSLwAW/VgnIU=; b=SUH/kq0LKHoxxgXLJvVbTH9WmxBuKdc/QBGtRSgQ8B27lYsdPok9WgSu2YDBrEKGzb FqIbiQms0r3nZ7aX28kvnmbwU7tATzegUzb79ggLCLRgdmPx+bPb2ltvEv2TthmuGyIt YZDJ7vvHIn1Qy3JWsHONhHBlnH6DBV16bGF1Q1q8Co/q8Lr8Yu3eS+T86VxYV2w+luVm +Ljl10FP2fxXvYBcMjOvaxM8aWLg4kFKE6qwUwmFh32RerRIh9QiC4FNxRFwDX2l7pql d01TP7joT++f1FcaeFO8jmUOREOL8Rbu24ncaoQMj4gntK3JwDremvYdBRZtsJbV0//C zk+w== X-Gm-Message-State: AOAM530/W0ag2g+D8snnDzuMhBUzVoGW0x1vJ+Z6IPunUgf76NQmkiW4 IIEuTE43mcxUPeIBAbDsHRREuG1Zpms+KA== X-Google-Smtp-Source: ABdhPJwKgJXCbKQbU6dkAWIMtLarSLA39CWWsSllDoIu2eb+7D0PQVo3csK6ZM4tgeTaT50424beJg== X-Received: by 2002:a1c:3586:: with SMTP id c128mr31792605wma.78.1634377172314; Sat, 16 Oct 2021 02:39:32 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id k22sm6993492wrd.59.2021.10.16.02.39.31 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 16 Oct 2021 02:39:31 -0700 (PDT) From: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= To: git@vger.kernel.org Cc: Junio C Hamano , Jeff King , Han-Wen Nienhuys , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBC?= =?utf-8?b?amFybWFzb24=?= Subject: [PATCH v2 03/21] refs API: make refs_read_raw_ref() not set errno Date: Sat, 16 Oct 2021 11:39:09 +0200 Message-Id: X-Mailer: git-send-email 2.33.1.1338.g20da966911a In-Reply-To: References: MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org From: Han-Wen Nienhuys Add a "failure_errno" to refs_read_raw_ref(), his allows refs_werrres_ref_unsafe() to pass along its "failure_errno", as a first step before its own callers are migrated to pass it further up the chain. We are leaving out out the refs_read_special_head() in refs_read_raw_ref() for now, as noted in a subsequent commit moving it to "failure_errno" will require some special consideration. Signed-off-by: Han-Wen Nienhuys Signed-off-by: Ævar Arnfjörð Bjarmason --- refs.c | 24 ++++++++++++++++-------- refs/files-backend.c | 10 ++++++---- refs/packed-backend.c | 7 ++++--- refs/refs-internal.h | 6 +++--- 4 files changed, 29 insertions(+), 18 deletions(-) diff --git a/refs.c b/refs.c index ad56dbb0125..200c44e6963 100644 --- a/refs.c +++ b/refs.c @@ -1666,17 +1666,18 @@ static int refs_read_special_head(struct ref_store *ref_store, return result; } -int refs_read_raw_ref(struct ref_store *ref_store, - const char *refname, struct object_id *oid, - struct strbuf *referent, unsigned int *type) +int refs_read_raw_ref(struct ref_store *ref_store, const char *refname, + struct object_id *oid, struct strbuf *referent, + unsigned int *type, int *failure_errno) { + assert(failure_errno); if (!strcmp(refname, "FETCH_HEAD") || !strcmp(refname, "MERGE_HEAD")) { return refs_read_special_head(ref_store, refname, oid, referent, type); } return ref_store->be->read_raw_ref(ref_store, refname, oid, referent, - type, &errno); + type, failure_errno); } const char *refs_werrres_ref_unsafe(struct ref_store *refs, @@ -1720,9 +1721,8 @@ const char *refs_werrres_ref_unsafe(struct ref_store *refs, for (symref_count = 0; symref_count < SYMREF_MAXDEPTH; symref_count++) { unsigned int read_flags = 0; - errno = 0; - if (refs_read_raw_ref(refs, refname, - oid, &sb_refname, &read_flags)) { + if (refs_read_raw_ref(refs, refname, oid, &sb_refname, + &read_flags, failure_errno)) { *flags |= read_flags; if (errno) *failure_errno = errno; @@ -2240,6 +2240,13 @@ int refs_verify_refname_available(struct ref_store *refs, strbuf_grow(&dirname, strlen(refname) + 1); for (slash = strchr(refname, '/'); slash; slash = strchr(slash + 1, '/')) { + /* + * Just saying "Is a directory" when we e.g. can't + * lock some multi-level ref isn't very informative, + * the user won't be told *what* is a directory, so + * let's not use strerror() below. + */ + int ignore_errno; /* Expand dirname to the new prefix, not including the trailing slash: */ strbuf_add(&dirname, refname + dirname.len, slash - refname - dirname.len); @@ -2251,7 +2258,8 @@ int refs_verify_refname_available(struct ref_store *refs, if (skip && string_list_has_string(skip, dirname.buf)) continue; - if (!refs_read_raw_ref(refs, dirname.buf, &oid, &referent, &type)) { + if (!refs_read_raw_ref(refs, dirname.buf, &oid, &referent, + &type, &ignore_errno)) { strbuf_addf(err, _("'%s' exists; cannot create '%s'"), dirname.buf, refname); goto cleanup; diff --git a/refs/files-backend.c b/refs/files-backend.c index 6a6ead0b99b..94c194665ed 100644 --- a/refs/files-backend.c +++ b/refs/files-backend.c @@ -381,10 +381,11 @@ static int files_read_raw_ref(struct ref_store *ref_store, const char *refname, goto out; if (lstat(path, &st) < 0) { + int ignore_errno; if (errno != ENOENT) goto out; - if (refs_read_raw_ref(refs->packed_ref_store, refname, - oid, referent, type)) { + if (refs_read_raw_ref(refs->packed_ref_store, refname, oid, + referent, type, &ignore_errno)) { errno = ENOENT; goto out; } @@ -418,13 +419,14 @@ static int files_read_raw_ref(struct ref_store *ref_store, const char *refname, /* Is it a directory? */ if (S_ISDIR(st.st_mode)) { + int ignore_errno; /* * Even though there is a directory where the loose * ref is supposed to be, there could still be a * packed ref: */ - if (refs_read_raw_ref(refs->packed_ref_store, refname, - oid, referent, type)) { + if (refs_read_raw_ref(refs->packed_ref_store, refname, oid, + referent, type, &ignore_errno)) { errno = EISDIR; goto out; } diff --git a/refs/packed-backend.c b/refs/packed-backend.c index 47247a14917..52cdc94a26e 100644 --- a/refs/packed-backend.c +++ b/refs/packed-backend.c @@ -1347,6 +1347,7 @@ int is_packed_transaction_needed(struct ref_store *ref_store, ret = 0; for (i = 0; i < transaction->nr; i++) { struct ref_update *update = transaction->updates[i]; + int failure_errno; unsigned int type; struct object_id oid; @@ -1357,9 +1358,9 @@ int is_packed_transaction_needed(struct ref_store *ref_store, */ continue; - if (!refs_read_raw_ref(ref_store, update->refname, - &oid, &referent, &type) || - errno != ENOENT) { + if (!refs_read_raw_ref(ref_store, update->refname, &oid, + &referent, &type, &failure_errno) || + failure_errno != ENOENT) { /* * We have to actually delete that reference * -> this transaction is needed. diff --git a/refs/refs-internal.h b/refs/refs-internal.h index 72746407fc3..c87f1135e5b 100644 --- a/refs/refs-internal.h +++ b/refs/refs-internal.h @@ -149,9 +149,9 @@ struct ref_update { const char refname[FLEX_ARRAY]; }; -int refs_read_raw_ref(struct ref_store *ref_store, - const char *refname, struct object_id *oid, - struct strbuf *referent, unsigned int *type); +int refs_read_raw_ref(struct ref_store *ref_store, const char *refname, + struct object_id *oid, struct strbuf *referent, + unsigned int *type, int *failure_errno); /* * Write an error to `err` and return a nonzero value iff the same From patchwork Sat Oct 16 09:39:10 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= X-Patchwork-Id: 12563369 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 69BAAC433F5 for ; Sat, 16 Oct 2021 09:39:48 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 4918A6108E for ; Sat, 16 Oct 2021 09:39:48 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S243988AbhJPJly (ORCPT ); Sat, 16 Oct 2021 05:41:54 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57606 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S244013AbhJPJlu (ORCPT ); Sat, 16 Oct 2021 05:41:50 -0400 Received: from mail-wm1-x32a.google.com (mail-wm1-x32a.google.com [IPv6:2a00:1450:4864:20::32a]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id B0B63C06176E for ; Sat, 16 Oct 2021 02:39:34 -0700 (PDT) Received: by mail-wm1-x32a.google.com with SMTP id n40-20020a05600c3ba800b0030da2439b21so4958232wms.0 for ; Sat, 16 Oct 2021 02:39:34 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=Za+FYkUyZbhvl2mb1QyuVCyVvHBId7fHHzDzgdX7ePQ=; b=NblJJE5NirJ/2OsEd4Ve60vVqe2rKBrWGGzE2K3L1Y9XmV8VMoGin78fiCnFqcPONP Yg4dVyY9uw5AiMcC5EZK4gjpFu2JQFnGwJNPbzUpKvktZj+XOey/cTcQzoPfcXCzbOgH fco+kuFEEgP2cBkjCIe3lnKXdmFMUNBFDdmlMrdV/QifEPQzTpF5w1WX9ZeoCjwaek4p GwnO+H5NtC3Uy3L0xT/gjv87wZVeMWTuQTU7OY1rTuYt5YhsZlE/2qOUS7eu1lbchQyq ynd5kHN/Gm84C80JKQCa+4PFzroOEVB8MIAhax7vOewXd5LL1SpzQ9Pz7L21/M8RdbW3 rpDA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=Za+FYkUyZbhvl2mb1QyuVCyVvHBId7fHHzDzgdX7ePQ=; b=xl/ds68MPA0aqICmU1Z9dreUdEm+XmcC5Ha2toN50/qt4Bb7vjVMmddYAMBDQf/7Dk mZWLgceWX8wRlpY5pu066n4Qs7r+AyNglAvUcKODueYRcEO/sGXVWfpp2h0wURzGd6/E hbibJIQR8t4BO9hW6hHojTMb3QyoqqjRtnmJvheOkkqROAHXFDKbIF99+4NnX/dwhRwC 9aYaE1u8ppJJGfuQv+4pbyPskoPP2JhZ4T4mBLGk9h6w/pb/Gdd5zAe8Qngjz9CXtPEy nadNOgtqHcZBXdZZ/T2jebzRGUHXP74gawKvS0AfdDkg2W7FkxvSw+P9VJule3NSborY 5UbQ== X-Gm-Message-State: AOAM531zmsewAslm2mVRJN6CvVjNyuVr9P9sSUh9t9R97CK6miwLnUwd N6P5ED4toJg5PBPlO173vgPKUrPgMOP+SQ== X-Google-Smtp-Source: ABdhPJzje/pq8+Fz4SNgk0xCORwlpXB6xmXCRyPWwQFN0qewoD8AHvx1RaAwiGbC2KCNqsAYYa9jWg== X-Received: by 2002:a1c:770b:: with SMTP id t11mr31951150wmi.19.1634377173053; Sat, 16 Oct 2021 02:39:33 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id k22sm6993492wrd.59.2021.10.16.02.39.32 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 16 Oct 2021 02:39:32 -0700 (PDT) From: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= To: git@vger.kernel.org Cc: Junio C Hamano , Jeff King , Han-Wen Nienhuys , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBC?= =?utf-8?b?amFybWFzb24=?= Subject: [PATCH v2 04/21] refs API: make parse_loose_ref_contents() not set errno Date: Sat, 16 Oct 2021 11:39:10 +0200 Message-Id: X-Mailer: git-send-email 2.33.1.1338.g20da966911a In-Reply-To: References: MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org From: Han-Wen Nienhuys Change the parse_loose_ref_contents() function to stop setting "errno" and failure, and to instead pass up a "failure_errno" via a parameter. This requires changing its callers to do the same. The EINVAL error from parse_loose_ref_contents is used in files-backend to create a custom error message. In untangling this we discovered a tricky edge case. The refs_read_special_head() function was relying on parse_loose_ref_contents() setting EINVAL. By converting it to use "saved_errno" we can migrate away from "errno" in this part of the code entirely, and do away with an existing "save_errno" pattern, its only purpose was to not clobber the "errno" we previously needed at the end of files_read_raw_ref(). Let's assert that we can do that by not having files_read_raw_ref() itself operate on *failure_errno in addition to passing it on. Instead we'll assert that if we return non-zero we actually do set errno, thus assuring ourselves and callers that they can trust the resulting "failure_errno". Signed-off-by: Han-Wen Nienhuys Signed-off-by: Ævar Arnfjörð Bjarmason --- refs.c | 8 +++++--- refs/files-backend.c | 31 ++++++++++++++++++++----------- refs/refs-internal.h | 6 ++++-- 3 files changed, 29 insertions(+), 16 deletions(-) diff --git a/refs.c b/refs.c index 200c44e6963..bb09993c2f9 100644 --- a/refs.c +++ b/refs.c @@ -1648,7 +1648,8 @@ int for_each_fullref_in_prefixes(const char *namespace, static int refs_read_special_head(struct ref_store *ref_store, const char *refname, struct object_id *oid, - struct strbuf *referent, unsigned int *type) + struct strbuf *referent, unsigned int *type, + int *failure_errno) { struct strbuf full_path = STRBUF_INIT; struct strbuf content = STRBUF_INIT; @@ -1658,7 +1659,8 @@ static int refs_read_special_head(struct ref_store *ref_store, if (strbuf_read_file(&content, full_path.buf, 0) < 0) goto done; - result = parse_loose_ref_contents(content.buf, oid, referent, type); + result = parse_loose_ref_contents(content.buf, oid, referent, type, + failure_errno); done: strbuf_release(&full_path); @@ -1673,7 +1675,7 @@ int refs_read_raw_ref(struct ref_store *ref_store, const char *refname, assert(failure_errno); if (!strcmp(refname, "FETCH_HEAD") || !strcmp(refname, "MERGE_HEAD")) { return refs_read_special_head(ref_store, refname, oid, referent, - type); + type, failure_errno); } return ref_store->be->read_raw_ref(ref_store, refname, oid, referent, diff --git a/refs/files-backend.c b/refs/files-backend.c index 94c194665ed..c73ffd1ca33 100644 --- a/refs/files-backend.c +++ b/refs/files-backend.c @@ -355,6 +355,7 @@ static int files_read_raw_ref(struct ref_store *ref_store, const char *refname, int fd; int ret = -1; int remaining_retries = 3; + int myerr = 0; *type = 0; strbuf_reset(&sb_path); @@ -382,11 +383,13 @@ static int files_read_raw_ref(struct ref_store *ref_store, const char *refname, if (lstat(path, &st) < 0) { int ignore_errno; - if (errno != ENOENT) + myerr = errno; + errno = 0; + if (myerr != ENOENT) goto out; if (refs_read_raw_ref(refs->packed_ref_store, refname, oid, referent, type, &ignore_errno)) { - errno = ENOENT; + myerr = ENOENT; goto out; } ret = 0; @@ -397,7 +400,9 @@ static int files_read_raw_ref(struct ref_store *ref_store, const char *refname, if (S_ISLNK(st.st_mode)) { strbuf_reset(&sb_contents); if (strbuf_readlink(&sb_contents, path, st.st_size) < 0) { - if (errno == ENOENT || errno == EINVAL) + myerr = errno; + errno = 0; + if (myerr == ENOENT || myerr == EINVAL) /* inconsistent with lstat; retry */ goto stat_ref; else @@ -427,7 +432,7 @@ static int files_read_raw_ref(struct ref_store *ref_store, const char *refname, */ if (refs_read_raw_ref(refs->packed_ref_store, refname, oid, referent, type, &ignore_errno)) { - errno = EISDIR; + myerr = EISDIR; goto out; } ret = 0; @@ -440,7 +445,8 @@ static int files_read_raw_ref(struct ref_store *ref_store, const char *refname, */ fd = open(path, O_RDONLY); if (fd < 0) { - if (errno == ENOENT && !S_ISLNK(st.st_mode)) + myerr = errno; + if (myerr == ENOENT && !S_ISLNK(st.st_mode)) /* inconsistent with lstat; retry */ goto stat_ref; else @@ -448,26 +454,29 @@ static int files_read_raw_ref(struct ref_store *ref_store, const char *refname, } strbuf_reset(&sb_contents); if (strbuf_read(&sb_contents, fd, 256) < 0) { - int save_errno = errno; + myerr = errno; close(fd); - errno = save_errno; goto out; } close(fd); strbuf_rtrim(&sb_contents); buf = sb_contents.buf; - ret = parse_loose_ref_contents(buf, oid, referent, type); + ret = parse_loose_ref_contents(buf, oid, referent, type, &myerr); out: - *failure_errno = errno; + if (ret && !myerr) + BUG("returning non-zero %d, should have set myerr!", ret); + *failure_errno = myerr; + strbuf_release(&sb_path); strbuf_release(&sb_contents); return ret; } int parse_loose_ref_contents(const char *buf, struct object_id *oid, - struct strbuf *referent, unsigned int *type) + struct strbuf *referent, unsigned int *type, + int *failure_errno) { const char *p; if (skip_prefix(buf, "ref:", &buf)) { @@ -486,7 +495,7 @@ int parse_loose_ref_contents(const char *buf, struct object_id *oid, if (parse_oid_hex(buf, oid, &p) || (*p != '\0' && !isspace(*p))) { *type |= REF_ISBROKEN; - errno = EINVAL; + *failure_errno = EINVAL; return -1; } return 0; diff --git a/refs/refs-internal.h b/refs/refs-internal.h index c87f1135e5b..121b8fdad08 100644 --- a/refs/refs-internal.h +++ b/refs/refs-internal.h @@ -706,10 +706,12 @@ struct ref_store { }; /* - * Parse contents of a loose ref file. + * Parse contents of a loose ref file. *failure_errno maybe be set to EINVAL for + * invalid contents. */ int parse_loose_ref_contents(const char *buf, struct object_id *oid, - struct strbuf *referent, unsigned int *type); + struct strbuf *referent, unsigned int *type, + int *failure_errno); /* * Fill in the generic part of refs and add it to our collection of From patchwork Sat Oct 16 09:39:11 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= X-Patchwork-Id: 12563381 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 5B351C433FE for ; Sat, 16 Oct 2021 09:39:59 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 4623A61073 for ; Sat, 16 Oct 2021 09:39:59 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S244027AbhJPJmF (ORCPT ); Sat, 16 Oct 2021 05:42:05 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57508 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S240067AbhJPJlv (ORCPT ); Sat, 16 Oct 2021 05:41:51 -0400 Received: from mail-wm1-x330.google.com (mail-wm1-x330.google.com [IPv6:2a00:1450:4864:20::330]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 8E64AC06176F for ; Sat, 16 Oct 2021 02:39:35 -0700 (PDT) Received: by mail-wm1-x330.google.com with SMTP id v127so4277095wme.5 for ; Sat, 16 Oct 2021 02:39:35 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=iBHEptvkAw4q8b+yQzDkVePPfr6NEnD3mUnxcrs9pGw=; b=FzriWtVc75DX5wgpvRxyDXmZ6f2dq8XqkmK2eIxtmmFz3c5qfdQpGkyE2NEFjci2Qx zkK37gd3zbRkpRbhlOYedqL5XWgHmFcuBCAp4+pArF1KkvlA/EO1QHVi+yZ/WcuEhbts eHpJxtBsE2qOq0LzdZTrjh7aIZzfJDK1jBVq+w61RQ/e1EBB9oPdOUMq/3XSya/i8Sqq H+xGjpVd0Y4sG+jX+Ea2QwuE6v7ry10nqxU3cJja0Rcm+tDehqw9vKNJ2ePcFJatua+A 9jdueBbxYpIJ09yC14mUY90aB2oXe36vOxZcoZ4hEqIepYWELkxB1Jvv9I30M3+X5ljr oNqA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=iBHEptvkAw4q8b+yQzDkVePPfr6NEnD3mUnxcrs9pGw=; b=7//KrrNt8aCs3ZRP5p7otZt4vAjO7mpLjbDFD02hh5SrSDgU6Q/a4pPZLtM47/Y9eL yOtaeGOocoWx7KuCNthVcXb0XNVmpSNXV/ABXidd0Xq4BP8dSO/yEFm9sIu8Xe4sO1HN L5ZERKqyKvQ1MkTtvKsn1Vg8sVOTAJfotQgiTYZ2cVz3hNZ7b0r+8ia0W8lp7vhvdyxM fqFqdv7cMqP11A+Tl4RwASAqfBScy2eej0ySd8DlKVCmP/TDnwhIpFolmtr5xUglv6s8 EZSzvfPnfc2U5Eq1T9KN6dm4BKZUp0Q1ohSMWjOm6E/MRvllI4T2F6BNMSZU4Vj6GmuQ Q6vw== X-Gm-Message-State: AOAM530+3QciHUlsEWTqiYzGMTgaHoLMjdFPyZRiReI+SUtBXkyRLbF7 eD8IAQBK3rlGP62/EYsihxijgJ0yYNbwWA== X-Google-Smtp-Source: ABdhPJwW0oO1Qwk5b3v+rFEM7BVxfx18c5sDKZh8dhrVGFukc2W5R5vNkbAZxXfd32hJeVk99yuPrg== X-Received: by 2002:a1c:f21a:: with SMTP id s26mr18035467wmc.117.1634377173855; Sat, 16 Oct 2021 02:39:33 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id k22sm6993492wrd.59.2021.10.16.02.39.33 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 16 Oct 2021 02:39:33 -0700 (PDT) From: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= To: git@vger.kernel.org Cc: Junio C Hamano , Jeff King , Han-Wen Nienhuys , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBC?= =?utf-8?b?amFybWFzb24=?= Subject: [PATCH v2 05/21] refs API: make refs_rename_ref_available() static Date: Sat, 16 Oct 2021 11:39:11 +0200 Message-Id: X-Mailer: git-send-email 2.33.1.1338.g20da966911a In-Reply-To: References: MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org Move the refs_rename_ref_available() function into "refs/files-backend.c". It is file-backend specific. This function was added in 5fe7d825da8 (refs.c: pass a list of names to skip to is_refname_available, 2014-05-01) as rename_ref_available() and was only ever used in this one file-backend specific codepath. So let's move it there. Signed-off-by: Ævar Arnfjörð Bjarmason --- refs.c | 19 ------------------- refs/files-backend.c | 29 +++++++++++++++++++++++++++++ refs/refs-internal.h | 14 -------------- 3 files changed, 29 insertions(+), 33 deletions(-) diff --git a/refs.c b/refs.c index bb09993c2f9..44ddbb14f1d 100644 --- a/refs.c +++ b/refs.c @@ -1372,25 +1372,6 @@ const char *find_descendant_ref(const char *dirname, return NULL; } -int refs_rename_ref_available(struct ref_store *refs, - const char *old_refname, - const char *new_refname) -{ - struct string_list skip = STRING_LIST_INIT_NODUP; - struct strbuf err = STRBUF_INIT; - int ok; - - string_list_insert(&skip, old_refname); - ok = !refs_verify_refname_available(refs, new_refname, - NULL, &skip, &err); - if (!ok) - error("%s", err.buf); - - string_list_clear(&skip, 0); - strbuf_release(&err); - return ok; -} - int refs_head_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data) { struct object_id oid; diff --git a/refs/files-backend.c b/refs/files-backend.c index c73ffd1ca33..0af6ee44552 100644 --- a/refs/files-backend.c +++ b/refs/files-backend.c @@ -1363,6 +1363,35 @@ static int commit_ref_update(struct files_ref_store *refs, const struct object_id *oid, const char *logmsg, struct strbuf *err); +/* + * Check whether an attempt to rename old_refname to new_refname would + * cause a D/F conflict with any existing reference (other than + * possibly old_refname). If there would be a conflict, emit an error + * message and return false; otherwise, return true. + * + * Note that this function is not safe against all races with other + * processes (though rename_ref() catches some races that might get by + * this check). + */ +static int refs_rename_ref_available(struct ref_store *refs, + const char *old_refname, + const char *new_refname) +{ + struct string_list skip = STRING_LIST_INIT_NODUP; + struct strbuf err = STRBUF_INIT; + int ok; + + string_list_insert(&skip, old_refname); + ok = !refs_verify_refname_available(refs, new_refname, + NULL, &skip, &err); + if (!ok) + error("%s", err.buf); + + string_list_clear(&skip, 0); + strbuf_release(&err); + return ok; +} + static int files_copy_or_rename_ref(struct ref_store *ref_store, const char *oldrefname, const char *newrefname, const char *logmsg, int copy) diff --git a/refs/refs-internal.h b/refs/refs-internal.h index 121b8fdad08..2ecd3dea9fb 100644 --- a/refs/refs-internal.h +++ b/refs/refs-internal.h @@ -228,20 +228,6 @@ const char *find_descendant_ref(const char *dirname, const struct string_list *extras, const struct string_list *skip); -/* - * Check whether an attempt to rename old_refname to new_refname would - * cause a D/F conflict with any existing reference (other than - * possibly old_refname). If there would be a conflict, emit an error - * message and return false; otherwise, return true. - * - * Note that this function is not safe against all races with other - * processes (though rename_ref() catches some races that might get by - * this check). - */ -int refs_rename_ref_available(struct ref_store *refs, - const char *old_refname, - const char *new_refname); - /* We allow "recursive" symbolic refs. Only within reason, though */ #define SYMREF_MAXDEPTH 5 From patchwork Sat Oct 16 09:39:12 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= X-Patchwork-Id: 12563371 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 0A329C433FE for ; Sat, 16 Oct 2021 09:39:50 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id E048D60E96 for ; Sat, 16 Oct 2021 09:39:49 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S244025AbhJPJl4 (ORCPT ); Sat, 16 Oct 2021 05:41:56 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57628 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S244014AbhJPJlv (ORCPT ); Sat, 16 Oct 2021 05:41:51 -0400 Received: from mail-wm1-x32a.google.com (mail-wm1-x32a.google.com [IPv6:2a00:1450:4864:20::32a]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 4A338C061770 for ; Sat, 16 Oct 2021 02:39:36 -0700 (PDT) Received: by mail-wm1-x32a.google.com with SMTP id g2so4274826wme.4 for ; Sat, 16 Oct 2021 02:39:36 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=0sEIwjiHa2SZKEvpq1PpEPKl5F80/cPDk5R6pxZHMiE=; b=NSUU44sCNOYgoXA/2B/ZYgm0d2uLcpwUMyZcWbFYw7MyHIuUYCz00t9rWfJhrxCMqz Yv9gVv9pqon6PLAIl25RFZpPmnhcQ1LKvsMnDwYgKD8bvPaiLIgyC0ZQv5afPm5Y+2z7 xJ5F5Ik2uu0RynFOb8CCUXYP9NkVP1G7MemeRV0M7aFGXO9SVboyHRNauJjx6AilnXi4 lBjiLXSJO1lBmpO+M9GKWJaws4OpzWR2LWhZwzt8l3Um8xJHp+hW9fDwAoX8Ffa2d50d adLkMR0DAKSLnXh1Ij9UIALYfArD6kZtSKHRS2UtMsJ7gtBMCtVzfhEw3AkVjXkOWVQJ kr1g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=0sEIwjiHa2SZKEvpq1PpEPKl5F80/cPDk5R6pxZHMiE=; b=v2pQz1/qla3pOtR7YoUN/JZl/1V0do0N7wMHDsXD97Bhsvw+1gCwtKjE4Wre+HS4we AqJG54XwhRDXhEsSLYCrUmqvmXRegHQys7gPhSKtiptO9Kv4DoKMKbcQKMhAvG3V7WD5 eXgsTTqLiKPDAGeJ9zSYLQVPY4cgV9C+R1nk/OM0JGHBxwFlClk48mC2Ae/Yr5VXKkP2 70CHnPIKJjl2KI0QH15kGLu1MxRSfjT+6ztYrVF7v8AYVwQjFddr7jSfwao0iFdDzZrX aAQYRHlCNV3Hq85fTvijPSAPo24DbLQ74Ja8gOdNkovlpUYYdG0Sx3rawoRDZueLD4fC PXnA== X-Gm-Message-State: AOAM532fqLLUXaBLG8gw+EgGrNgjkNxeZNBmr4GgK0dS1aS20HIgeAka aFaYyFl7FOOpjhf9QdELzL4NZGo7c/LjFw== X-Google-Smtp-Source: ABdhPJytH0cyWNrbcDf5CwaeqpDDKiU60HwowWtRpzhuXO2oGcweSGAQGWWX8KkWjQ0VqQDKBRltxQ== X-Received: by 2002:a1c:4444:: with SMTP id r65mr17587950wma.174.1634377174666; Sat, 16 Oct 2021 02:39:34 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id k22sm6993492wrd.59.2021.10.16.02.39.33 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 16 Oct 2021 02:39:34 -0700 (PDT) From: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= To: git@vger.kernel.org Cc: Junio C Hamano , Jeff King , Han-Wen Nienhuys , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBC?= =?utf-8?b?amFybWFzb24=?= Subject: [PATCH v2 06/21] reflog tests: add --updateref tests Date: Sat, 16 Oct 2021 11:39:12 +0200 Message-Id: X-Mailer: git-send-email 2.33.1.1338.g20da966911a In-Reply-To: References: MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org Add tests that cover blindspots in "git reflog delete --updateref" behavior. Before this change removing the "type & REF_ISSYMREF" check added in 5e6f003ca8a (reflog_expire(): ignore --updateref for symbolic references, 2015-03-03) would not fail any tests. The "--updateref" option was added in 55f10565371 (git-reflog: add option --updateref to write the last reflog sha1 into the ref, 2008-02-22) for use in git-stash.sh, see e25d5f9c82e (git-stash: add new 'drop' subcommand, 2008-02-22). Even though the regression test I need is just the "C" case here, let's test all these combinations for good measure. I started out doing these as a for-loop, but I think this is more readable. Signed-off-by: Ævar Arnfjörð Bjarmason --- t/t1417-reflog-updateref.sh | 65 +++++++++++++++++++++++++++++++++++++ 1 file changed, 65 insertions(+) create mode 100755 t/t1417-reflog-updateref.sh diff --git a/t/t1417-reflog-updateref.sh b/t/t1417-reflog-updateref.sh new file mode 100755 index 00000000000..14f13b57c6d --- /dev/null +++ b/t/t1417-reflog-updateref.sh @@ -0,0 +1,65 @@ +#!/bin/sh + +test_description='git reflog --updateref' + +TEST_PASSES_SANITIZE_LEAK=true +. ./test-lib.sh + +test_expect_success 'setup' ' + git init -b main repo && + ( + cd repo && + + test_commit A && + test_commit B && + test_commit C && + + cp .git/logs/HEAD HEAD.old && + git reset --hard HEAD~ && + cp HEAD.old .git/logs/HEAD + ) +' + +test_reflog_updateref () { + exp=$1 + shift + args="$@" + + test_expect_success REFFILES "get '$exp' with '$args'" ' + test_when_finished "rm -rf copy" && + cp -R repo copy && + + ( + cd copy && + + $args && + git rev-parse $exp >expect && + git rev-parse HEAD >actual && + + test_cmp expect actual + ) + ' +} + +test_reflog_updateref B git reflog delete --updateref HEAD@{0} +test_reflog_updateref B git reflog delete --updateref HEAD@{1} +test_reflog_updateref C git reflog delete --updateref main@{0} +test_reflog_updateref B git reflog delete --updateref main@{1} +test_reflog_updateref B git reflog delete --updateref --rewrite HEAD@{0} +test_reflog_updateref B git reflog delete --updateref --rewrite HEAD@{1} +test_reflog_updateref C git reflog delete --updateref --rewrite main@{0} +test_reflog_updateref B git reflog delete --updateref --rewrite main@{1} +test_reflog_updateref B test_must_fail git reflog expire HEAD@{0} +test_reflog_updateref B test_must_fail git reflog expire HEAD@{1} +test_reflog_updateref B test_must_fail git reflog expire main@{0} +test_reflog_updateref B test_must_fail git reflog expire main@{1} +test_reflog_updateref B test_must_fail git reflog expire --updateref HEAD@{0} +test_reflog_updateref B test_must_fail git reflog expire --updateref HEAD@{1} +test_reflog_updateref B test_must_fail git reflog expire --updateref main@{0} +test_reflog_updateref B test_must_fail git reflog expire --updateref main@{1} +test_reflog_updateref B test_must_fail git reflog expire --updateref --rewrite HEAD@{0} +test_reflog_updateref B test_must_fail git reflog expire --updateref --rewrite HEAD@{1} +test_reflog_updateref B test_must_fail git reflog expire --updateref --rewrite main@{0} +test_reflog_updateref B test_must_fail git reflog expire --updateref --rewrite main@{1} + +test_done From patchwork Sat Oct 16 09:39:13 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= X-Patchwork-Id: 12563385 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 2B1D5C433FE for ; Sat, 16 Oct 2021 09:40:27 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 1692F6108E for ; Sat, 16 Oct 2021 09:40:27 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S240140AbhJPJme (ORCPT ); Sat, 16 Oct 2021 05:42:34 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57514 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S244015AbhJPJlv (ORCPT ); Sat, 16 Oct 2021 05:41:51 -0400 Received: from mail-wm1-x332.google.com (mail-wm1-x332.google.com [IPv6:2a00:1450:4864:20::332]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 0EB88C061771 for ; Sat, 16 Oct 2021 02:39:37 -0700 (PDT) Received: by mail-wm1-x332.google.com with SMTP id l38-20020a05600c1d2600b0030d80c3667aso4046737wms.5 for ; Sat, 16 Oct 2021 02:39:36 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=XqUfuYNmPmcLugwVlKfE2Jjb4eJpHqrjGGmswPW08C8=; b=Y03VuSZRBirsW9elQ2I6HmU5SL9WlUY4FbuUTdgYWwLtZZ9gjUIMBF6A3+dY7YjgC6 Vhwwh1CQVX9jEVZzxFwrvC33OfrRLufM2LApvjThsKwSpNP+uvL6D306YYuu6GR0aPO/ VKCkMqM2P5jfa6Rqlm04Z+G9rbIwVbYpR4B3ywXzzjn1vaNpiTCIDGq8jrQWAntw+OO+ ZmG3Ukx0JP+LL7R6gGuY6PHKNzrvdI43oeRuCslBAp8AdYvMuJv5zZzCVCK8q1f1nZc9 MR6es50N51zZ7QYumOo1uLEiJX8rz0e918KlnW9dHzebkGnz1sRiR39VswxekYVK6JEW 0pog== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=XqUfuYNmPmcLugwVlKfE2Jjb4eJpHqrjGGmswPW08C8=; b=B+9Ag0Lfx2bbUNB+obSk85ZIlVCyipGYBf4tED8W55/DrnHBi+xbeJEUAzieyVg+Pr dr/+SQ3kd8TT/FsyHADFMQlY64Tnxw1Xk20stv1HLjmMRLqimv62sxBWaf56sjNv+nz/ WFqF53LzPT1t6gPHRuHD+w+uQt+E6XlkhYs6jXMUIzA8Evs/P/uzj7E/+Cg0obQiDOlX czuQJMV7lUQUZfVVYnQfW4QgwAu+7NuNE15YUCoUXuUlgaYpp7SbP3xbjTc0zxtQmi1A oCaOzZbhbc2zI7YVetBMky7i9mrSvSRFWRsRnjgoX5CLnZe2/eqJrCooRl0v74W2ll1B uiBA== X-Gm-Message-State: AOAM5309v7nHyEnu19g/WpRu8/j/8u8nTKGkJ9Hpp3bpxi7PVTc9qKfF u2UuV1j/5MfRb7vF53gxRZeHn7PSHe/X7w== X-Google-Smtp-Source: ABdhPJytGyaQ7FvURXLrXBI0jxqJndE8yZFwH4dDfXxcwrARRC0oCEBHT7oa262wyJ8vVO58ufUmhQ== X-Received: by 2002:a1c:2209:: with SMTP id i9mr31934555wmi.20.1634377175336; Sat, 16 Oct 2021 02:39:35 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id k22sm6993492wrd.59.2021.10.16.02.39.34 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 16 Oct 2021 02:39:34 -0700 (PDT) From: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= To: git@vger.kernel.org Cc: Junio C Hamano , Jeff King , Han-Wen Nienhuys , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBC?= =?utf-8?b?amFybWFzb24=?= Subject: [PATCH v2 07/21] refs/files: remove "name exist?" check in lock_ref_oid_basic() Date: Sat, 16 Oct 2021 11:39:13 +0200 Message-Id: X-Mailer: git-send-email 2.33.1.1338.g20da966911a In-Reply-To: References: MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org In lock_ref_oid_basic() we'll happily lock a reference that doesn't exist yet. That's normal, and is how references are initially born, but we don't need to retain checks here in lock_ref_oid_basic() about the state of the ref, when what we're checking is either checked already, or something we're about to discover by trying to lock the ref with raceproof_create_file(). The one exception is the caller in files_reflog_expire(), who passes us a "type" to find out if the reference is a symref or not. We can move the that logic over to that caller, which can now defer its discovery of whether or not the ref is a symref until it's needed. In the preceding commit an exhaustive regression test was added for that case in a new test in "t1417-reflog-updateref.sh". The improved diagnostics here were added in 5b2d8d6f218 (lock_ref_sha1_basic(): improve diagnostics for ref D/F conflicts, 2015-05-11), and then much of the surrounding code went away recently in my 245fbba46d6 (refs/files: remove unused "errno == EISDIR" code, 2021-08-23). The refs_resolve_ref_unsafe() code being removed here looks like it should be tasked with doing that, but it's actually redundant to other code. The reason for that is as noted in 245fbba46d6 this once widely used function now only has a handful of callers left, which all handle this case themselves. To the extent that we're racy between their check and ours removing this check actually improves the situation, as we'll be doing fewer things between the not-under-lock initial check and acquiring the lock. Why this is OK for all the remaining callers of lock_ref_oid_basic() is noted below. There are only two of those callers: * "git branch -[cm] ": In files_copy_or_rename_ref() we'll call this when we copy or rename refs via rename_ref() and copy_ref(). but only after we've checked if the refname exists already via its own call to refs_resolve_ref_unsafe() and refs_rename_ref_available(). As the updated comment to the latter here notes neither of those are actually needed. If we delete not only this code but also refs_rename_ref_available() we'll do just fine, we'll just emit a less friendly error message if e.g. "git branch -m A B/C" would have a D/F conflict with a "B" file. Actually we'd probably die before that in case reflogs for the branch existed, i.e. when the try to rename() or copy_file() the relevant reflog, since if we've got a D/F conflict with a branch name we'll probably also have the same with its reflogs (but not necessarily, we might have reflogs, but it might not). As some #leftoverbits that code seems buggy to me, i.e. the reflog "protocol" should be to get a lock on the main ref, and then perform ref and/or reflog operations. That code dates back to c976d415e53 (git-branch: add options and tests for branch renaming, 2006-11-28) and probably pre-dated the solidifying of that convention. But in any case, that edge case is not our bug or problem right now. * "git reflog expire ": In files_reflog_expire() we'll call this without previous ref existence checking in files-backend.c, but that code is in turn called by code that's just finished checking if the refname whose reflog we're expiring exists. See ae35e16cd43 (reflog expire: don't lock reflogs using previously seen OID, 2021-08-23) for the current state of that code, and 5e6f003ca8a (reflog_expire(): ignore --updateref for symbolic references, 2015-03-03) for the code we'd break if we only did a "update = !!ref" here, which is covered by the aforementioned regression test in "t1417-reflog-updateref.sh". Signed-off-by: Ævar Arnfjörð Bjarmason --- refs/files-backend.c | 48 ++++++++++++++++++++++---------------------- 1 file changed, 24 insertions(+), 24 deletions(-) diff --git a/refs/files-backend.c b/refs/files-backend.c index 0af6ee44552..16e78326381 100644 --- a/refs/files-backend.c +++ b/refs/files-backend.c @@ -1001,7 +1001,7 @@ static int create_reflock(const char *path, void *cb) * Locks a ref returning the lock on success and NULL on failure. */ static struct ref_lock *lock_ref_oid_basic(struct files_ref_store *refs, - const char *refname, int *type, + const char *refname, struct strbuf *err) { struct strbuf ref_file = STRBUF_INIT; @@ -1013,16 +1013,6 @@ static struct ref_lock *lock_ref_oid_basic(struct files_ref_store *refs, CALLOC_ARRAY(lock, 1); files_ref_path(refs, &ref_file, refname); - if (!refs_resolve_ref_unsafe(&refs->base, refname, - RESOLVE_REF_NO_RECURSE, - &lock->old_oid, type)) { - if (!refs_verify_refname_available(&refs->base, refname, - NULL, NULL, err)) - strbuf_addf(err, "unable to resolve reference '%s': %s", - refname, strerror(errno)); - - goto error_return; - } /* * If the ref did not exist and we are creating it, make sure @@ -1364,14 +1354,14 @@ static int commit_ref_update(struct files_ref_store *refs, struct strbuf *err); /* - * Check whether an attempt to rename old_refname to new_refname would - * cause a D/F conflict with any existing reference (other than - * possibly old_refname). If there would be a conflict, emit an error + * Emit a better error message than lockfile.c's + * unable_to_lock_message() would in case there is a D/F conflict with + * another existing reference. If there would be a conflict, emit an error * message and return false; otherwise, return true. * * Note that this function is not safe against all races with other - * processes (though rename_ref() catches some races that might get by - * this check). + * processes, and that's not its job. We'll emit a more verbose error on D/f + * conflicts if we get past it into lock_ref_oid_basic(). */ static int refs_rename_ref_available(struct ref_store *refs, const char *old_refname, @@ -1492,7 +1482,7 @@ static int files_copy_or_rename_ref(struct ref_store *ref_store, logmoved = log; - lock = lock_ref_oid_basic(refs, newrefname, NULL, &err); + lock = lock_ref_oid_basic(refs, newrefname, &err); if (!lock) { if (copy) error("unable to copy '%s' to '%s': %s", oldrefname, newrefname, err.buf); @@ -1514,7 +1504,7 @@ static int files_copy_or_rename_ref(struct ref_store *ref_store, goto out; rollback: - lock = lock_ref_oid_basic(refs, oldrefname, NULL, &err); + lock = lock_ref_oid_basic(refs, oldrefname, &err); if (!lock) { error("unable to lock %s for rollback: %s", oldrefname, err.buf); strbuf_release(&err); @@ -1921,7 +1911,7 @@ static int files_create_symref(struct ref_store *ref_store, struct ref_lock *lock; int ret; - lock = lock_ref_oid_basic(refs, refname, NULL, &err); + lock = lock_ref_oid_basic(refs, refname, &err); if (!lock) { error("%s", err.buf); strbuf_release(&err); @@ -3125,7 +3115,6 @@ static int files_reflog_expire(struct ref_store *ref_store, struct strbuf log_file_sb = STRBUF_INIT; char *log_file; int status = 0; - int type; struct strbuf err = STRBUF_INIT; const struct object_id *oid; @@ -3139,7 +3128,7 @@ static int files_reflog_expire(struct ref_store *ref_store, * reference itself, plus we might need to update the * reference if --updateref was specified: */ - lock = lock_ref_oid_basic(refs, refname, &type, &err); + lock = lock_ref_oid_basic(refs, refname, &err); if (!lock) { error("cannot lock ref '%s': %s", refname, err.buf); strbuf_release(&err); @@ -3201,9 +3190,20 @@ static int files_reflog_expire(struct ref_store *ref_store, * a reference if there are no remaining reflog * entries. */ - int update = (flags & EXPIRE_REFLOGS_UPDATE_REF) && - !(type & REF_ISSYMREF) && - !is_null_oid(&cb.last_kept_oid); + int update = 0; + + if ((flags & EXPIRE_REFLOGS_UPDATE_REF) && + !is_null_oid(&cb.last_kept_oid)) { + int ignore_errno; + int type; + const char *ref; + + ref = refs_werrres_ref_unsafe(&refs->base, refname, + RESOLVE_REF_NO_RECURSE, + NULL, &type, + &ignore_errno); + update = !!(ref && !(type & REF_ISSYMREF)); + } if (close_lock_file_gently(&reflog_lock)) { status |= error("couldn't write %s: %s", log_file, From patchwork Sat Oct 16 09:39:14 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= X-Patchwork-Id: 12563377 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id E9260C433EF for ; Sat, 16 Oct 2021 09:39:54 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id CC3BA61073 for ; Sat, 16 Oct 2021 09:39:54 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S244034AbhJPJmB (ORCPT ); Sat, 16 Oct 2021 05:42:01 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57630 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S244016AbhJPJlw (ORCPT ); Sat, 16 Oct 2021 05:41:52 -0400 Received: from mail-wm1-x335.google.com (mail-wm1-x335.google.com [IPv6:2a00:1450:4864:20::335]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id CBE2DC061772 for ; Sat, 16 Oct 2021 02:39:37 -0700 (PDT) Received: by mail-wm1-x335.google.com with SMTP id 3-20020a1c0403000000b00322f53b9bbfso389487wme.3 for ; Sat, 16 Oct 2021 02:39:37 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=CyzukmDVpOofAX86YVcnt8Tfs+rypSbqkBMzOHQ81QU=; b=eIliCLpMelFsoOYRS2hITf7Org/vJ0dtKF+5bcP1LHfCSlupN0jqaLTjf1b7QJlHMM skdiLUu+VkhLlZO+fO5spgdpI6pU7aUVQgBnFQQIgAUQT2/zBgC4l6jNUIaOrmxt6WSi 5GEKijR+mn9o4woqNtPWYhUZMNK0cNTi9WB96lDVcsuS0MiTDFMLao0dtu2B5cx2REo0 GYmkZPv3w0RzbGQUSBDVKCvz8Q8lwTWYWESubRRavYPJBpMSMee4ofIHMjSGZPrRUAdr 4yeMPMYk//TiENw4A4UFZnt3vz9vh7JNNO6U6jpiRgOdLpAWqbSNWEU9tF8P8tRNttp3 Sv1A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=CyzukmDVpOofAX86YVcnt8Tfs+rypSbqkBMzOHQ81QU=; b=GuFaMpBQtvP6QjwyYjGXhCnPVs5WNe68Z3Xuzf4lxKI/F+vMbBHnveGp7r1/+156XY 0FEO08371zQTQAFFJw4Pj0vZcGtgGz4jIT0/p1uxiopd8xG/19x1Zm2pU7/7s7vQPRS7 wWD5gsL+u2JHI4pelEeXwDWiV45SSZqcgvoQPBwiU/CySG0pjsCZV3iCUcuKka0RQ6Cv KwbfwYfrHufBqlMItX2zzLN+zBiKODeDD9doFzCGXV4Vj8AZ9iWB+AqqjLU1j3+m9aC2 QZNRje6VYTsZyYNoIgy+B+r64o/i1N8NQzaWd0C/LSxn3kw/AUisi7S0/Jd9hDryYeI+ Y1gw== X-Gm-Message-State: AOAM532y5/KnJ4bnWySBI4CuwrnhCTrY7TnDv8ZUbyUr0B69qX6k7h6B 3lyh1EG0ZNs6ZGm9qsWbqYYp53Iz9jqd4A== X-Google-Smtp-Source: ABdhPJzFS1aZ5MBs6Zhd+l3tIhcEpMtmXjFEYR3loSirvfPI1Mfmlp6ZYgVHvfDFg0rMz0+N/BKxbw== X-Received: by 2002:a1c:2b81:: with SMTP id r123mr8599012wmr.136.1634377176214; Sat, 16 Oct 2021 02:39:36 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id k22sm6993492wrd.59.2021.10.16.02.39.35 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 16 Oct 2021 02:39:35 -0700 (PDT) From: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= To: git@vger.kernel.org Cc: Junio C Hamano , Jeff King , Han-Wen Nienhuys , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBC?= =?utf-8?b?amFybWFzb24=?= Subject: [PATCH v2 08/21] refs API: remove refs_read_ref_full() wrapper Date: Sat, 16 Oct 2021 11:39:14 +0200 Message-Id: X-Mailer: git-send-email 2.33.1.1338.g20da966911a In-Reply-To: References: MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org Remove the refs_read_ref_full() wrapper in favor of migrating various refs.c API users to the underlying refs_werrres_ref_unsafe() function. A careful reading of these callers shows that the callers of this function did not care about "errno", by moving away from the refs_resolve_ref_unsafe() wrapper we can be sure that nothing relies on it anymore. Signed-off-by: Ævar Arnfjörð Bjarmason --- refs.c | 20 +++++++++----------- refs.h | 2 -- refs/files-backend.c | 36 ++++++++++++++++++++++-------------- worktree.c | 9 +++++---- 4 files changed, 36 insertions(+), 31 deletions(-) diff --git a/refs.c b/refs.c index 44ddbb14f1d..80b85d244d2 100644 --- a/refs.c +++ b/refs.c @@ -290,20 +290,17 @@ struct ref_filter { void *cb_data; }; -int refs_read_ref_full(struct ref_store *refs, const char *refname, - int resolve_flags, struct object_id *oid, int *flags) +int read_ref_full(const char *refname, int resolve_flags, struct object_id *oid, int *flags) { - if (refs_resolve_ref_unsafe(refs, refname, resolve_flags, oid, flags)) + int ignore_errno; + struct ref_store *refs = get_main_ref_store(the_repository); + + if (refs_werrres_ref_unsafe(refs, refname, resolve_flags, + oid, flags, &ignore_errno)) return 0; return -1; } -int read_ref_full(const char *refname, int resolve_flags, struct object_id *oid, int *flags) -{ - return refs_read_ref_full(get_main_ref_store(the_repository), refname, - resolve_flags, oid, flags); -} - int read_ref(const char *refname, struct object_id *oid) { return read_ref_full(refname, RESOLVE_REF_READING, oid, NULL); @@ -1376,9 +1373,10 @@ int refs_head_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data) { struct object_id oid; int flag; + int ignore_errno; - if (!refs_read_ref_full(refs, "HEAD", RESOLVE_REF_READING, - &oid, &flag)) + if (refs_werrres_ref_unsafe(refs, "HEAD", RESOLVE_REF_READING, + &oid, &flag, &ignore_errno)) return fn("HEAD", &oid, flag, cb_data); return 0; diff --git a/refs.h b/refs.h index c8afde6bb50..3938f99c902 100644 --- a/refs.h +++ b/refs.h @@ -89,8 +89,6 @@ char *refs_resolve_refdup(struct ref_store *refs, char *resolve_refdup(const char *refname, int resolve_flags, struct object_id *oid, int *flags); -int refs_read_ref_full(struct ref_store *refs, const char *refname, - int resolve_flags, struct object_id *oid, int *flags); int read_ref_full(const char *refname, int resolve_flags, struct object_id *oid, int *flags); int read_ref(const char *refname, struct object_id *oid); diff --git a/refs/files-backend.c b/refs/files-backend.c index 16e78326381..482d04de03a 100644 --- a/refs/files-backend.c +++ b/refs/files-backend.c @@ -1006,6 +1006,7 @@ static struct ref_lock *lock_ref_oid_basic(struct files_ref_store *refs, { struct strbuf ref_file = STRBUF_INIT; struct ref_lock *lock; + int ignore_errno; files_assert_main_repository(refs, "lock_ref_oid_basic"); assert(err); @@ -1032,9 +1033,8 @@ static struct ref_lock *lock_ref_oid_basic(struct files_ref_store *refs, goto error_return; } - if (refs_read_ref_full(&refs->base, lock->ref_name, - 0, - &lock->old_oid, NULL)) + if (!refs_werrres_ref_unsafe(&refs->base, lock->ref_name, 0, + &lock->old_oid, NULL, &ignore_errno)) oidclr(&lock->old_oid); goto out; @@ -1397,6 +1397,7 @@ static int files_copy_or_rename_ref(struct ref_store *ref_store, struct strbuf tmp_renamed_log = STRBUF_INIT; int log, ret; struct strbuf err = STRBUF_INIT; + int ignore_errno; files_reflog_path(refs, &sb_oldref, oldrefname); files_reflog_path(refs, &sb_newref, newrefname); @@ -1454,9 +1455,9 @@ static int files_copy_or_rename_ref(struct ref_store *ref_store, * the safety anyway; we want to delete the reference whatever * its current value. */ - if (!copy && !refs_read_ref_full(&refs->base, newrefname, - RESOLVE_REF_READING | RESOLVE_REF_NO_RECURSE, - NULL, NULL) && + if (!copy && refs_werrres_ref_unsafe(&refs->base, newrefname, + RESOLVE_REF_READING | RESOLVE_REF_NO_RECURSE, + NULL, NULL, &ignore_errno) && refs_delete_ref(&refs->base, NULL, newrefname, NULL, REF_NO_DEREF)) { if (errno == EISDIR) { @@ -1868,9 +1869,12 @@ static void update_symref_reflog(struct files_ref_store *refs, { struct strbuf err = STRBUF_INIT; struct object_id new_oid; + int ignore_errno; + if (logmsg && - !refs_read_ref_full(&refs->base, target, - RESOLVE_REF_READING, &new_oid, NULL) && + refs_werrres_ref_unsafe(&refs->base, target, + RESOLVE_REF_READING, &new_oid, NULL, + &ignore_errno) && files_log_ref_write(refs, refname, &lock->old_oid, &new_oid, logmsg, 0, &err)) { error("%s", err.buf); @@ -2144,6 +2148,7 @@ static int files_reflog_iterator_advance(struct ref_iterator *ref_iterator) (struct files_reflog_iterator *)ref_iterator; struct dir_iterator *diter = iter->dir_iterator; int ok; + int ignore_errno; while ((ok = dir_iterator_advance(diter)) == ITER_OK) { int flags; @@ -2155,9 +2160,10 @@ static int files_reflog_iterator_advance(struct ref_iterator *ref_iterator) if (ends_with(diter->basename, ".lock")) continue; - if (refs_read_ref_full(iter->ref_store, - diter->relative_path, 0, - &iter->oid, &flags)) { + if (!refs_werrres_ref_unsafe(iter->ref_store, + diter->relative_path, 0, + &iter->oid, &flags, + &ignore_errno)) { error("bad ref for %s", diter->path.buf); continue; } @@ -2501,9 +2507,11 @@ static int lock_ref_for_update(struct files_ref_store *refs, * the transaction, so we have to read it here * to record and possibly check old_oid: */ - if (refs_read_ref_full(&refs->base, - referent.buf, 0, - &lock->old_oid, NULL)) { + int ignore_errno; + if (!refs_werrres_ref_unsafe(&refs->base, + referent.buf, 0, + &lock->old_oid, NULL, + &ignore_errno)) { if (update->flags & REF_HAVE_OLD) { strbuf_addf(err, "cannot lock ref '%s': " "error reading reference", diff --git a/worktree.c b/worktree.c index 092a4f92ad2..cfffcdb62b3 100644 --- a/worktree.c +++ b/worktree.c @@ -563,16 +563,17 @@ int other_head_refs(each_ref_fn fn, void *cb_data) struct worktree *wt = *p; struct object_id oid; int flag; + int ignore_errno; if (wt->is_current) continue; strbuf_reset(&refname); strbuf_worktree_ref(wt, &refname, "HEAD"); - if (!refs_read_ref_full(get_main_ref_store(the_repository), - refname.buf, - RESOLVE_REF_READING, - &oid, &flag)) + if (refs_werrres_ref_unsafe(get_main_ref_store(the_repository), + refname.buf, + RESOLVE_REF_READING, + &oid, &flag, &ignore_errno)) ret = fn(refname.buf, &oid, flag, cb_data); if (ret) break; From patchwork Sat Oct 16 09:39:15 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= X-Patchwork-Id: 12563387 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 5A8FBC433EF for ; Sat, 16 Oct 2021 09:40:34 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 4351461073 for ; Sat, 16 Oct 2021 09:40:34 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S244083AbhJPJme (ORCPT ); Sat, 16 Oct 2021 05:42:34 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57490 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S239990AbhJPJlw (ORCPT ); Sat, 16 Oct 2021 05:41:52 -0400 Received: from mail-wm1-x331.google.com (mail-wm1-x331.google.com [IPv6:2a00:1450:4864:20::331]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 8BF2CC0613EF for ; Sat, 16 Oct 2021 02:39:38 -0700 (PDT) Received: by mail-wm1-x331.google.com with SMTP id v127so4277163wme.5 for ; Sat, 16 Oct 2021 02:39:38 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=oLmZ2zA0c5ZCqhb4v82laJzUYRGkOSKnuoZA4LgotXw=; b=fN9gwpWm2nx1IMwcsQhp4Gl0IJPRpkCCXK8UJfiOEvA75GoCNFdi8ZL5uIsapZ9GLD 4Bww9UjJWWCn+2HEMkVee4ki8nSK4cjmTiTOadEHXF7NU6eej9KVkectSEgQZcsFf04e Q3UW6gQaStMDtH6N6AGygZVE4KGhOARQ3BNS8sdyPy5AKVnmttiltAcBLGuQTP6BzV+k VlAurxrG/BGjpsMpPPCP88Edm6PvC8xlzsre88rcZNcIuK1sQwWcMcHTeHB/bPI3t/zF ++Ndo8qzhGt9FT7shAXUo5rhbtxDHFNqZuz44FrV6aA63kwIAQGcQnKU04DA2j9yUEu3 w3xg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=oLmZ2zA0c5ZCqhb4v82laJzUYRGkOSKnuoZA4LgotXw=; b=7Pa9NfosOKhTEC2kPAq2Xozgx5charvNqO6YPdm/ZfuA1Gf7EAn6iDcsS3ueV/KiBR o7GHnT6OhiuMBbPn7nC1xk6zyeLKLKi1dAMZ2G3jUSWXdnAhD8KXvSMClDphT5ZfRglk AOFhw/lIv+kvLOKB3u2tuxtYHXeHAaoyboFYn7uwZJB6gQPtRxuhTV6xGtSHoqdN44Fu P3wwdonr1HNQFXt+JHoQ00IEx7La3UwJtCPHmqz8/d9hfJRkjlXFcWq7nYx8vzf94cEq tjbddw54RNbaMpi4k6uzFAlAdZZyTn7yK8Mt2D977cC8fRFfV4mLTFhldSNFoTuJw2DY 54Og== X-Gm-Message-State: AOAM531oP58S0mk6PKP/Bltp351BgIvp60JmQRnZZyIxRbvKYF0IUJ+1 KJOp39ZRiNkX/9ZBvDyD8/t8BxeE5pQN+Q== X-Google-Smtp-Source: ABdhPJwtcztftDZCtCLIo3C08vxGn182Wueri85jJDuha+9/jolkQC7bD+1UXm1G9SisaGDBEFozfA== X-Received: by 2002:a7b:ca4f:: with SMTP id m15mr17477656wml.113.1634377176952; Sat, 16 Oct 2021 02:39:36 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id k22sm6993492wrd.59.2021.10.16.02.39.36 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 16 Oct 2021 02:39:36 -0700 (PDT) From: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= To: git@vger.kernel.org Cc: Junio C Hamano , Jeff King , Han-Wen Nienhuys , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBC?= =?utf-8?b?amFybWFzb24=?= Subject: [PATCH v2 09/21] refs API: make resolve_gitlink_ref() not set errno Date: Sat, 16 Oct 2021 11:39:15 +0200 Message-Id: X-Mailer: git-send-email 2.33.1.1338.g20da966911a In-Reply-To: References: MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org I have carefully read the upstream callers of resolve_gitlink_ref() and determined that they don't care about errno. So let's move away from the errno-setting refs_resolve_ref_unsafe() wrapper to refs_werrres_ref_unsafe(), and explicitly ignore the errno it sets for us. Signed-off-by: Ævar Arnfjörð Bjarmason --- refs.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/refs.c b/refs.c index 80b85d244d2..dc6ed561492 100644 --- a/refs.c +++ b/refs.c @@ -1791,14 +1791,15 @@ int resolve_gitlink_ref(const char *submodule, const char *refname, { struct ref_store *refs; int flags; + int ignore_errno; refs = get_submodule_ref_store(submodule); if (!refs) return -1; - if (!refs_resolve_ref_unsafe(refs, refname, 0, oid, &flags) || - is_null_oid(oid)) + if (!refs_werrres_ref_unsafe(refs, refname, 0, oid, &flags, + &ignore_errno) || is_null_oid(oid)) return -1; return 0; } From patchwork Sat Oct 16 09:39:16 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= X-Patchwork-Id: 12563389 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 455A2C433EF for ; Sat, 16 Oct 2021 09:40:39 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 271AE60E96 for ; Sat, 16 Oct 2021 09:40:39 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S244042AbhJPJmn (ORCPT ); Sat, 16 Oct 2021 05:42:43 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57668 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S243957AbhJPJlw (ORCPT ); Sat, 16 Oct 2021 05:41:52 -0400 Received: from mail-wm1-x32d.google.com (mail-wm1-x32d.google.com [IPv6:2a00:1450:4864:20::32d]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 33921C0613F0 for ; Sat, 16 Oct 2021 02:39:39 -0700 (PDT) Received: by mail-wm1-x32d.google.com with SMTP id g2so4274904wme.4 for ; Sat, 16 Oct 2021 02:39:39 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=a+/GYTZZy8e5Kz/F593qTISxA5IriUQJ0TZs3Z7GU3w=; b=pPIuA0ZgEnNNoVvPmOv8E8bYcY1S1nITu3u3CMMySWGV/6I4UTrVuUZF/ik7AEsjsF SWmhV3XlINADn6CAk2bVM6uGMyCiCTKNwFz42TeX+GFpNXIRupQ7Hsi7cXyr7MgO0oaA 5IwKULhNBPdbpOV/cd/DV4fAG7xgkGDbBEWc960a1jpoy098Qn4RbKvGJI0szmyo1Svo bKKsXDBXpCwDmRAO5+hInphUDwoNum+DnJ4xhkGFHDdpyANWxcXwa8kRABIm/8PfZ165 RcPvqk11siQr85fsosk0lHQZaA+IbWXNdf9c2cp6Ko48edsFRofTmQ7C2hb7WNnlpD7/ LAYw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=a+/GYTZZy8e5Kz/F593qTISxA5IriUQJ0TZs3Z7GU3w=; b=moGsTYzhfboBkLvt5fnqz+WzUlao36/RfBJrYRT0j4wKCfEfZ9uZQS3NMoJuc+hi6t IxRMQEpOPoe7FgwgU4N4ThHE53VpK+0V/iQ43sVLbiYmNr8I6kuGsjILQVr1P5s+f1tC rPllxtPGTmMIiv5HBU2FLh+ZxbfhFDB9aWIj4Q85CkDPbHt90dtQePjCWDlLkud7ZWwF imTBGG1xvjR1IZU2DdyhYCOhtD2lKCSl8oR51F6WS+vQzruw9NJ5SlWsotF0PAA9uPDC J14/Uw3Vt7UDeKZDwNA7XXmhJuoDRo+wcvBObKkclzOxgIq5H9aFdoi3zgXNgfjZ648N 7nTw== X-Gm-Message-State: AOAM533jTjJHhHf7PHWx6QT1OeE+ctcf+i6Ex9urEYnaieQLp9nL+wXX 3i+JNesqAYslUa6hWMXukaF3pNi7n4sSPg== X-Google-Smtp-Source: ABdhPJyV2vD/qv0qaNbuwOljb6T7tvbbGyCBhJ8naIgL36C4+nYdZe9o7orZn69y0ixSeiVRfyS1KQ== X-Received: by 2002:a1c:e906:: with SMTP id q6mr31921385wmc.126.1634377177604; Sat, 16 Oct 2021 02:39:37 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id k22sm6993492wrd.59.2021.10.16.02.39.37 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 16 Oct 2021 02:39:37 -0700 (PDT) From: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= To: git@vger.kernel.org Cc: Junio C Hamano , Jeff King , Han-Wen Nienhuys , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBC?= =?utf-8?b?amFybWFzb24=?= Subject: [PATCH v2 10/21] refs API: make loose_fill_ref_dir() not set errno Date: Sat, 16 Oct 2021 11:39:16 +0200 Message-Id: X-Mailer: git-send-email 2.33.1.1338.g20da966911a In-Reply-To: References: MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org Change the refs_resolve_ref_unsafe() invoked in loose_fill_ref_dir() to a form that ignores errno. The only eventual caller of this function is create_ref_cache(), whose callers in turn don't have their failure depend on any errno set here. Signed-off-by: Ævar Arnfjörð Bjarmason --- refs/files-backend.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/refs/files-backend.c b/refs/files-backend.c index 482d04de03a..759c21e88ae 100644 --- a/refs/files-backend.c +++ b/refs/files-backend.c @@ -280,10 +280,11 @@ static void loose_fill_ref_dir(struct ref_store *ref_store, create_dir_entry(dir->cache, refname.buf, refname.len)); } else { - if (!refs_resolve_ref_unsafe(&refs->base, + int ignore_errno; + if (!refs_werrres_ref_unsafe(&refs->base, refname.buf, RESOLVE_REF_READING, - &oid, &flag)) { + &oid, &flag, &ignore_errno)) { oidclr(&oid); flag |= REF_ISBROKEN; } else if (is_null_oid(&oid)) { From patchwork Sat Oct 16 09:39:17 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= X-Patchwork-Id: 12563393 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id F27EEC433EF for ; Sat, 16 Oct 2021 09:40:43 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id D68A961073 for ; Sat, 16 Oct 2021 09:40:43 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S244047AbhJPJms (ORCPT ); Sat, 16 Oct 2021 05:42:48 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57590 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S243966AbhJPJlw (ORCPT ); Sat, 16 Oct 2021 05:41:52 -0400 Received: from mail-wm1-x32f.google.com (mail-wm1-x32f.google.com [IPv6:2a00:1450:4864:20::32f]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id DE068C061780 for ; Sat, 16 Oct 2021 02:39:39 -0700 (PDT) Received: by mail-wm1-x32f.google.com with SMTP id p21so4272833wmq.1 for ; Sat, 16 Oct 2021 02:39:39 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=3mlntPm6U4KofzYZF0waMu+lGm+1c2nor+dHQiuOgck=; b=A8Ec0jlR56FRVk7Z/hofgf12IBCyCrUBoy32xYzAGtJjln44kIMf3EFoKDHBiyoGVq fcj7RDPUUQZ+6u3hBiAiOo8TtXIQb7Yn6x1ynxipmP2tFsinCFK+ejog20O1AHdMWeeD 4sok8uvfbMdXUcheRhswT/eHlBxLyjJH7qOPkaIhACQG52+cb7z8qWez+S3B1gu7S9lK FI2FH89yImvaGtYe847844F5NUvjtugEXbkB21EsT4aFyIx6Dk63UcfSoGRImE3PYSRR pxbmcTTNrvDYHq2aaP3KXwtb0EnAKFrHX3Q8oWu7ZvjH+2ObrU3ZfyjLADtuU1jzYo6y cc5A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=3mlntPm6U4KofzYZF0waMu+lGm+1c2nor+dHQiuOgck=; b=oEk9DBGBlnwEGRyX0bOLmpj3fXFuvBgF0OVVcGP10Z2Nr4KrK663CZMKTqaK74c69P 72SHGnXxwqBQjEH/z9q5n/sSYWlaTwEqBkWU9OfPwKhMU6bipmA+HeOqc0tqA09SUo73 MdtLg4sekkZwI7iBhBUkdwNQGNMhSjXHJxhaGurR6orItJQHNPT4iXb8uppEmZcgZ1hP tzEu415/XnoTaR8dTnQbr4FFcApnZhp4EslyXWkRK30rN1BHcdh0yeNpCRbyoeTmqIry 6cyQdzvDQt9z0FnO2rXd0EqSC8vFMgfxFd6FIBSNhoGuWvZkKtYbuqtL2DR08q2GJZYf fWyQ== X-Gm-Message-State: AOAM533n8ds9eBUlgr38nPD8YmCGfVsRM+kmh2/RU3SX1mBX4mFDkKf6 E1zchNBF32G5JT0xxEoSTkopF50OcfqO5A== X-Google-Smtp-Source: ABdhPJxNRKYmFQoHs2nGGv5jY+3V5KGIPlXMlztUCRfvUu7hTocGIL1nZynNSNm5JeVesQf1TNs8bg== X-Received: by 2002:a05:600c:3b24:: with SMTP id m36mr17573853wms.176.1634377178304; Sat, 16 Oct 2021 02:39:38 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id k22sm6993492wrd.59.2021.10.16.02.39.37 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 16 Oct 2021 02:39:37 -0700 (PDT) From: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= To: git@vger.kernel.org Cc: Junio C Hamano , Jeff King , Han-Wen Nienhuys , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBC?= =?utf-8?b?amFybWFzb24=?= Subject: [PATCH v2 11/21] refs API: make files_copy_or_rename_ref() et al not set errno Date: Sat, 16 Oct 2021 11:39:17 +0200 Message-Id: X-Mailer: git-send-email 2.33.1.1338.g20da966911a In-Reply-To: References: MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org None of the callers of rename_ref() and copy_ref() care about errno, and as seen in the context here we already emit our own non-errno using error() in the case where we'd use it. So let's have it explicitly ignore errno, and do the same in commit_ref_update(), which is only used within other code in files_copy_or_rename_ref() itself which doesn't care about errno either. It might actually be sensible to have the callers use errno if the failure was filesystem-specific, and with the upcoming reftable backend we don't want to rely on that sort of thing, so let's keep ignoring that for now. Signed-off-by: Ævar Arnfjörð Bjarmason --- refs/files-backend.c | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/refs/files-backend.c b/refs/files-backend.c index 759c21e88ae..6c854dda533 100644 --- a/refs/files-backend.c +++ b/refs/files-backend.c @@ -1410,9 +1410,9 @@ static int files_copy_or_rename_ref(struct ref_store *ref_store, goto out; } - if (!refs_resolve_ref_unsafe(&refs->base, oldrefname, + if (!refs_werrres_ref_unsafe(&refs->base, oldrefname, RESOLVE_REF_READING | RESOLVE_REF_NO_RECURSE, - &orig_oid, &flag)) { + &orig_oid, &flag, &ignore_errno)) { ret = error("refname %s not found", oldrefname); goto out; } @@ -1823,10 +1823,12 @@ static int commit_ref_update(struct files_ref_store *refs, */ int head_flag; const char *head_ref; + int ignore_errno; - head_ref = refs_resolve_ref_unsafe(&refs->base, "HEAD", + head_ref = refs_werrres_ref_unsafe(&refs->base, "HEAD", RESOLVE_REF_READING, - NULL, &head_flag); + NULL, &head_flag, + &ignore_errno); if (head_ref && (head_flag & REF_ISSYMREF) && !strcmp(head_ref, lock->ref_name)) { struct strbuf log_err = STRBUF_INIT; From patchwork Sat Oct 16 09:39:18 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= X-Patchwork-Id: 12563391 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id EF39FC433EF for ; Sat, 16 Oct 2021 09:40:40 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id D7E4360E96 for ; Sat, 16 Oct 2021 09:40:40 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S244050AbhJPJmr (ORCPT ); Sat, 16 Oct 2021 05:42:47 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57492 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S243971AbhJPJlx (ORCPT ); Sat, 16 Oct 2021 05:41:53 -0400 Received: from mail-wm1-x332.google.com (mail-wm1-x332.google.com [IPv6:2a00:1450:4864:20::332]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id AA344C061781 for ; Sat, 16 Oct 2021 02:39:40 -0700 (PDT) Received: by mail-wm1-x332.google.com with SMTP id p21so4272847wmq.1 for ; Sat, 16 Oct 2021 02:39:40 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=QoqvCC8pgDyqssDtJxlX1OAAMB1SwHadVriWvlC08qc=; b=LW+7wcub1vgHuhE40U22zs///QVPHxVB/uB5FCSGvOCZXUp7C062D09j3X91TQwcLL JgKBqK8TxK9nwIem8fGloQVNvLd1094vOeGNL1g/GNXQN0Ey630dnmZQijY8y3HBqEDM 8f0kJQk5c8qTajUgz/7xJJt4ZoiEwWZTvuGSADV+1OdBq7Az+Fs+dAVfeCYbym/67OHK GBtUbTDaJP9jawlhLvW+k1kbqIv1ed9YyfrfqoaS1cO207AVykacXR4INTtMtxEO2yVJ UCCLGp2zRaqFUU3uDW4VJpS8xT8Wr4c8L4cTDwFZPbJwYslacxhwKY0OfZlgdfTgAC85 SJLg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=QoqvCC8pgDyqssDtJxlX1OAAMB1SwHadVriWvlC08qc=; b=QzrFw/xGrdMpAU223TblndxQMVwJqYocvJuHaLuxjgatEU2giNnGmFA8PzJ1Ezz8qz WsYLbUUToXke4udn+cUmugJz2uGb0oTEXvbTChY5WX54N0mBn8JCrNQzdHg0H0QhY575 LBDoFi8N75kO99jxL/3u6X49yoh8iCL+FMWrweO1TXOBOlaMcYnSx3oSyxj7NU9X8gIq vOFdKymltZEcPbRmhDRDdCQJrHnNXGwJVGckCeDFaGzeWzgYmW2x3AAg+GrXBtDHfThm f9ORUcp9H9bW64tzM6xwN2tTU68nov5a3BVOOvkBU32cfhhf5cU8qiwENLRI8mtpBzWu X2qw== X-Gm-Message-State: AOAM531Vym1Od5hRLWth9WcpXgHv0cdPsgIf6hToEwwb9ByBjG0FQ5yP ju1X4KiN3SPvYQqsEsqZGac8OZYIsEMu/w== X-Google-Smtp-Source: ABdhPJwvJA6SDKQ95UjTUmBbPxvL3urfvsvUaYiSqSGi0sxPtx/9m5hBBfgUPXLwPy+hcpu/UdoopQ== X-Received: by 2002:a05:600c:198d:: with SMTP id t13mr31152751wmq.21.1634377179099; Sat, 16 Oct 2021 02:39:39 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id k22sm6993492wrd.59.2021.10.16.02.39.38 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 16 Oct 2021 02:39:38 -0700 (PDT) From: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= To: git@vger.kernel.org Cc: Junio C Hamano , Jeff King , Han-Wen Nienhuys , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBC?= =?utf-8?b?amFybWFzb24=?= Subject: [PATCH v2 12/21] refs API: ignore errno in worktree.c's add_head_info() Date: Sat, 16 Oct 2021 11:39:18 +0200 Message-Id: X-Mailer: git-send-email 2.33.1.1338.g20da966911a In-Reply-To: References: MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org The static add_head_info() function is only used indirectly by callers of get_worktrees(), none of whom care about errno, and even if they did having the faked-up one from refs_resolve_ref_unsafe() would only confuse them if they used die_errno() et al. So let's explicitly ignore it here. Signed-off-by: Ævar Arnfjörð Bjarmason --- worktree.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/worktree.c b/worktree.c index cfffcdb62b3..fa988ee978f 100644 --- a/worktree.c +++ b/worktree.c @@ -28,11 +28,13 @@ static void add_head_info(struct worktree *wt) { int flags; const char *target; + int ignore_errno; - target = refs_resolve_ref_unsafe(get_worktree_ref_store(wt), + target = refs_werrres_ref_unsafe(get_worktree_ref_store(wt), "HEAD", 0, - &wt->head_oid, &flags); + &wt->head_oid, &flags, + &ignore_errno); if (!target) return; From patchwork Sat Oct 16 09:39:19 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= X-Patchwork-Id: 12563399 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 46EEEC433F5 for ; Sat, 16 Oct 2021 09:41:01 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 2A42260E96 for ; Sat, 16 Oct 2021 09:41:01 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S244020AbhJPJnG (ORCPT ); Sat, 16 Oct 2021 05:43:06 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57606 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S244019AbhJPJlx (ORCPT ); Sat, 16 Oct 2021 05:41:53 -0400 Received: from mail-wr1-x42e.google.com (mail-wr1-x42e.google.com [IPv6:2a00:1450:4864:20::42e]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 71C8BC061773 for ; Sat, 16 Oct 2021 02:39:41 -0700 (PDT) Received: by mail-wr1-x42e.google.com with SMTP id g25so30589256wrb.2 for ; Sat, 16 Oct 2021 02:39:41 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=P0jdE3rAtOsRNXSpEG0dZSOUDxM8h+0jyvekDqckdMQ=; b=odfe8maRtm37ngUOUJE1UJrmeQbDWVQ+5GcvZrEPvFLCt/re99UTfwSLA1GKbsUYIu ASE4VmHQA/RLgQRiBbj1+Qk8/Fg7X1OuLckp4cV/OMdHxvtVn4+ObRF/tVNn+8SO1rYE ZSqITrmzOPgJw2OwiJvvNZO7WprLaDBKz+4ZJ/jQh1diLebS3C2ehzgyEJpdnq1aaxYw FZ5ij/o8EHbCxWmDJ+iuAvFuEZVacTePUje+tCJMrPYAH73RQ+/ZVDUf/lv2jrHJltSO MYwC0l9eGpMg0a+XP7sa5ykqfwkdMo7zzknmiFB29/DP0iVT5aS5niaMHw4RdTCtv2wc tujg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=P0jdE3rAtOsRNXSpEG0dZSOUDxM8h+0jyvekDqckdMQ=; b=uuUALVRg1zeFcbm9jTAsBcGFXViF44ELh48Oo54jZbzDBns6Ejc1X2wt22jBXwnuEu 3wZxFfE9gBR4FETl6V7b14R0OJdR2UyUg+BQ+CIkw51fQiy94GSG2eVIFLjwNJnzBXp/ s9xvSQUUHqAYPv4STpANz9RGUNj1Lc4n17a4wmB3bf9t4p85Dk8zoY8jQ/aeV603JiPZ XpkL2t1PDv1Y/nyHEQLFAPYsdfK8rZPLL9KnZ5uo6HxBHdzMorIasI6JSLhit6hizTYS pOIuNbqQUuTBCuzjRlSrwL6XhYMHwDiKeVKooq74HYgCZjIcFWKbfxjsSWZclahJJixv 8adw== X-Gm-Message-State: AOAM5336CXh7op1+BI6M6DMCltD0OgNIXC7+3EDda3vDu+Jy6iFgwan0 vb29b3gyH7CzLS0caUjXk62ewnfc+NnKXQ== X-Google-Smtp-Source: ABdhPJx+OeHNzRqBlM9IOTIGc9bzRRZ3T0/bmTfqUTuil3wBA4xvk3o4cJty0AwyEWLKNTCpAwHj0Q== X-Received: by 2002:adf:9bc4:: with SMTP id e4mr20213433wrc.257.1634377179810; Sat, 16 Oct 2021 02:39:39 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id k22sm6993492wrd.59.2021.10.16.02.39.39 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 16 Oct 2021 02:39:39 -0700 (PDT) From: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= To: git@vger.kernel.org Cc: Junio C Hamano , Jeff King , Han-Wen Nienhuys , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBC?= =?utf-8?b?amFybWFzb24=?= Subject: [PATCH v2 13/21] refs API: ignore errno in worktree.c's find_shared_symref() Date: Sat, 16 Oct 2021 11:39:19 +0200 Message-Id: X-Mailer: git-send-email 2.33.1.1338.g20da966911a In-Reply-To: References: MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org There are only handful of callers of find_shared_symref(), none of whom care about errno, so let's migrate to the non-errno-propagating version of refs_resolve_ref_unsafe() and explicitly ignore errno here. Signed-off-by: Ævar Arnfjörð Bjarmason --- worktree.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/worktree.c b/worktree.c index fa988ee978f..7d7cf058154 100644 --- a/worktree.c +++ b/worktree.c @@ -420,6 +420,7 @@ const struct worktree *find_shared_symref(const char *symref, const char *symref_target; struct ref_store *refs; int flags; + int ignore_errno; if (wt->is_bare) continue; @@ -436,8 +437,9 @@ const struct worktree *find_shared_symref(const char *symref, } refs = get_worktree_ref_store(wt); - symref_target = refs_resolve_ref_unsafe(refs, symref, 0, - NULL, &flags); + symref_target = refs_werrres_ref_unsafe(refs, symref, 0, + NULL, &flags, + &ignore_errno); if ((flags & REF_ISSYMREF) && symref_target && !strcmp(symref_target, target)) { existing = wt; From patchwork Sat Oct 16 09:39:20 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= X-Patchwork-Id: 12563395 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 442EBC433F5 for ; Sat, 16 Oct 2021 09:40:54 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 2877661073 for ; Sat, 16 Oct 2021 09:40:54 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S240122AbhJPJmx (ORCPT ); Sat, 16 Oct 2021 05:42:53 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57506 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S243981AbhJPJlx (ORCPT ); Sat, 16 Oct 2021 05:41:53 -0400 Received: from mail-wm1-x335.google.com (mail-wm1-x335.google.com [IPv6:2a00:1450:4864:20::335]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 2CD46C061774 for ; Sat, 16 Oct 2021 02:39:42 -0700 (PDT) Received: by mail-wm1-x335.google.com with SMTP id a196so4264674wme.0 for ; Sat, 16 Oct 2021 02:39:42 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=xhFFSMdxvzFbHQKgQfn7DBJML7VzbZVPMMgMUIbnLVg=; b=Ssgbz6jKBiwIH2F52cNspy8UcKI4URu93Hnd5KYk3WedOVQxW3e3a8g1XsFj9bQsRG O/igAD/1j5gtqKuQXApK0YcljosUpFTZpkoxwd1jRIsVVP+bKFg1vOuNu7r6mYD9MkSs sPRnGdZxPtGuOMn1HyRNxz1lzk2Bwdaa+KcKIr62d9QEkhY8O5iP2FOV8M9OTs92OWU0 vQSkJgTBO1PWwgSM6Unb+Uw5S9vsucFUQqgOBHz7mL+lvlzmEhYbU2kh2gR1Ub7b5/86 rEhCLgS6rsfqvD1uQrjbPTpDZhGsglLnNiig4D1Y8eoUu5fmgm4lH+s/EeUFGp/6B0ro bACg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=xhFFSMdxvzFbHQKgQfn7DBJML7VzbZVPMMgMUIbnLVg=; b=riESSThpSEwgEPsS/PJhLBlYZcthtWmnfDmWnXx//iIfoJZAWssmBSI1Y+BhgRYcce gcEXXyGtEahAcFr6QomU6ALXHVZgVR8NSL8Mnj2bNz0BSLwoPxdnBcvwIwYTSbkx91XE 1C6ZSTUf/SbXQImyoMG/R1QBFXT8UE0efXaZABn5cbSgHG+tYCcnTdzcuK6/P+7JxPJa Rdtt2wbeaC6755OK0l3sSrfCw/2xa4aFtAAAfc0asbKJJcn5XgGGX8TkgxDT5MtEFU0f 3vE1iIFYx8pysYAlrJ8LRo3KwlUYMLVpgyxbMjlKfX9J4SZjlyhvsP3cwFaulSne7PUJ vecA== X-Gm-Message-State: AOAM530jKxpZ1djLUt1zqRQQk5Xms5Q5KfnRHyQU8vJBnp0TocIcrsvl pdDWOj47XGf3Y3krsxEP4RmMmbVyB/epyA== X-Google-Smtp-Source: ABdhPJx/Hm+G/tfDzM+4LCtggibPyCVFLPY557puZwm6FXrgKFCGN/sma9StIxYybQpo4OrgzNMaRQ== X-Received: by 2002:a7b:cc8c:: with SMTP id p12mr18034917wma.105.1634377180519; Sat, 16 Oct 2021 02:39:40 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id k22sm6993492wrd.59.2021.10.16.02.39.39 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 16 Oct 2021 02:39:40 -0700 (PDT) From: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= To: git@vger.kernel.org Cc: Junio C Hamano , Jeff King , Han-Wen Nienhuys , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBC?= =?utf-8?b?amFybWFzb24=?= Subject: [PATCH v2 14/21] refs tests: ignore ignore errno in test-ref-store helper Date: Sat, 16 Oct 2021 11:39:20 +0200 Message-Id: X-Mailer: git-send-email 2.33.1.1338.g20da966911a In-Reply-To: References: MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org The cmd_resolve_ref() function has always ignored errno on failure, but let's do so explicitly when using the refs_resolve_ref_unsafe() function. Signed-off-by: Ævar Arnfjörð Bjarmason --- t/helper/test-ref-store.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/t/helper/test-ref-store.c b/t/helper/test-ref-store.c index b314b81a45b..2f91fb9b227 100644 --- a/t/helper/test-ref-store.c +++ b/t/helper/test-ref-store.c @@ -123,9 +123,10 @@ static int cmd_resolve_ref(struct ref_store *refs, const char **argv) int resolve_flags = arg_flags(*argv++, "resolve-flags"); int flags; const char *ref; + int ignore_errno; - ref = refs_resolve_ref_unsafe(refs, refname, resolve_flags, - &oid, &flags); + ref = refs_werrres_ref_unsafe(refs, refname, resolve_flags, + &oid, &flags, &ignore_errno); printf("%s %s 0x%x\n", oid_to_hex(&oid), ref ? ref : "(null)", flags); return ref ? 0 : 1; } From patchwork Sat Oct 16 09:39:21 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= X-Patchwork-Id: 12563403 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 55F8DC433F5 for ; Sat, 16 Oct 2021 09:41:10 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 2BB4860E96 for ; Sat, 16 Oct 2021 09:41:10 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S244135AbhJPJnO (ORCPT ); Sat, 16 Oct 2021 05:43:14 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57512 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S244017AbhJPJlx (ORCPT ); Sat, 16 Oct 2021 05:41:53 -0400 Received: from mail-wm1-x32a.google.com (mail-wm1-x32a.google.com [IPv6:2a00:1450:4864:20::32a]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id D5902C061775 for ; Sat, 16 Oct 2021 02:39:42 -0700 (PDT) Received: by mail-wm1-x32a.google.com with SMTP id z77-20020a1c7e50000000b0030db7b70b6bso4957010wmc.1 for ; Sat, 16 Oct 2021 02:39:42 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=fZAwyZhjWAMyTZl2gWtzaL0W/VV1Xt3SBvOfCgvyAz0=; b=dwznuapVZK5OUtJkTQg/6umqdxpnPJ/rv9JXL711XQgYQzXYpYorI5BYwOug3u5JgY 9XDRtuexS8+bje64sRrGmwQZPg1m9K02TzCZftPFRNAiAWxF+oZsjpFkSgHix8cuTOgM 9msCBvaN9IIYDKfPYCfuxm1wCQbaVlTPxGyRb574dzVxhe225hYJsZOn9SRmB17jLRs1 a7ZUS4+6Omzdwwj9X6WkGIPqhz5uDkEtujDnLKp6mHkJeag73RyCrsVi8+gIzoMU1TP1 L1B8kSDvCGMfso+lCh/l6Ga4wMqe/jwWBCCOeuK5/nzlNfsKoLez64F3j200nx7tLUW+ bmdA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=fZAwyZhjWAMyTZl2gWtzaL0W/VV1Xt3SBvOfCgvyAz0=; b=494wMdfV5Cx+y+NBVIhGdv2nVCBXhi+j0GtZXEWa81GrV7lFHQ1jNObKwGMhyVTJlI /jzN0R4aFbA/lNXdUC1NEzxkYOD0RfGjyXeSN6sdEpYaUytWNc5feKuH8HyRCquW1T4j mWkBmCm4Cy6B1eq1DA/HQ9f6hmzbFwe1BfD5+LbnDWj8G7dwSMTLvMn+sEJP7q/XPPT0 A9IBeTgyaJcp3fmLaMxU9SSVfYNLCjkoH1urxHexzrU7o5wojROxeuSogFH5ZN5FiIsc bnj0jgPQd+/A1WZnbKR6Tsw1InCNL5m+1nr8j3WUBUEpqJ9yjarGNyE60CAUUq5F5EYz N7ag== X-Gm-Message-State: AOAM531bn+iEuNXagkNTDpNW0n6aadhmj8VQzrUmf2u2lbhOIEwSSSkj DmY3BxD+6HJ0tCrqOWOyVxtThZTNXSk2NQ== X-Google-Smtp-Source: ABdhPJwRkIaRQfbIABaNNhWFRjmemaLmPCMIqBEay0HcOAcfFmcQqo/qh0SesRhp6vIwaJn7H2+iTw== X-Received: by 2002:a05:600c:154f:: with SMTP id f15mr18398914wmg.195.1634377181295; Sat, 16 Oct 2021 02:39:41 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id k22sm6993492wrd.59.2021.10.16.02.39.40 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 16 Oct 2021 02:39:40 -0700 (PDT) From: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= To: git@vger.kernel.org Cc: Junio C Hamano , Jeff King , Han-Wen Nienhuys , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBC?= =?utf-8?b?amFybWFzb24=?= Subject: [PATCH v2 15/21] refs API: make refs_resolve_refdup() not set errno Date: Sat, 16 Oct 2021 11:39:21 +0200 Message-Id: X-Mailer: git-send-email 2.33.1.1338.g20da966911a In-Reply-To: References: MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org Move refs_resolve_refdup() from the legacy refs_resolve_ref_unsafe() to the new refs_werrres_ref_unsafe(). I have read its callers and determined that they don't care about errno being set. Signed-off-by: Ævar Arnfjörð Bjarmason --- refs.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/refs.c b/refs.c index dc6ed561492..09452b5e413 100644 --- a/refs.c +++ b/refs.c @@ -268,9 +268,10 @@ char *refs_resolve_refdup(struct ref_store *refs, struct object_id *oid, int *flags) { const char *result; + int ignore_errno; - result = refs_resolve_ref_unsafe(refs, refname, resolve_flags, - oid, flags); + result = refs_werrres_ref_unsafe(refs, refname, resolve_flags, + oid, flags, &ignore_errno); return xstrdup_or_null(result); } From patchwork Sat Oct 16 09:39:22 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= X-Patchwork-Id: 12563401 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 50550C433F5 for ; Sat, 16 Oct 2021 09:41:05 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 2D9AC60E96 for ; Sat, 16 Oct 2021 09:41:05 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S244131AbhJPJnI (ORCPT ); Sat, 16 Oct 2021 05:43:08 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57502 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S244018AbhJPJlx (ORCPT ); Sat, 16 Oct 2021 05:41:53 -0400 Received: from mail-wr1-x431.google.com (mail-wr1-x431.google.com [IPv6:2a00:1450:4864:20::431]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 8F6A1C061570 for ; Sat, 16 Oct 2021 02:39:43 -0700 (PDT) Received: by mail-wr1-x431.google.com with SMTP id v17so30652245wrv.9 for ; Sat, 16 Oct 2021 02:39:43 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=FqZCLL3ZgQsdqVj3WYAePTaxfuMPqit5hVwiHuepOTA=; b=dFC/+fR3jZoqZegSE6pScvUlJKxRCg8THqC9gKr2yK1LokAZ2xLb4OuGily8Mmo7tW 13SLs5h7l4CDBIXulr0xAHJlWaOFkIHgYvGa9NbdZlIrwMG85I16vGgnfKBtiUxLeyO6 xjTAH3mQRyVNmQ0Sj0ZY3ml7jrTMGV1Wuxr5ii23Og3MObWayZNfrqjHE9JRrlwPk+iF +Zx2gfVA2YWY4A4h4ZQ7989ojqfXwYGfmg43PZvNol0ME1J1Zq00y2yORTG+OofpTaIt ag2Jt4PE58Szi9FaFs6KphZbA9useleUXT1GicgUyP6pMjbaaooCtvjH1NCkwIXsMowr gWtA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=FqZCLL3ZgQsdqVj3WYAePTaxfuMPqit5hVwiHuepOTA=; b=K+kfsr/oET7YzVVuTEw8IwBAhrEndU6MPY34lcVGJ/orP9mcnqoo2CIE0e+ZhINDoW bTVV/VyzP92xWnDjuUPSsFjEUYeZuMxg1YBtvK3CYaXpzwTCOTGdTrUveRl1JSplePht B30umLJl/UAdvXgizA7zjxX+B0Qkr22qhNVtkMddrKTlKfi1zd6rvy+iQQ6GUn4KRqye FMMrBPsH1Da3KOu1gdMOWDyGG/1OMpWfb2WCED6+ibtQ6Ct4ACX3ehSRCDrlqEqZZpBH sNmXE/ZtVCcig/+d+2YBBzJYGpIk3p8ams/Vh9xYvCSohdSozqHtWNL7tks06hxAA+F/ fGRA== X-Gm-Message-State: AOAM531DJ6t5/Wsb7V/K/1+sPIX/etvJKYGoD/0Ff0//pKdjHoxDMOJH NCZAbppM2zbSQnsYiRzwC6HKBf9S+quHGA== X-Google-Smtp-Source: ABdhPJwryagies1Eu0Rx65vokFl1Mnf5pAqX4og/3fHPpX2PWjmRpwnfpYdTIAwKrr8wrQSu0xbnYA== X-Received: by 2002:a5d:47ac:: with SMTP id 12mr19812069wrb.352.1634377181936; Sat, 16 Oct 2021 02:39:41 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id k22sm6993492wrd.59.2021.10.16.02.39.41 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 16 Oct 2021 02:39:41 -0700 (PDT) From: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= To: git@vger.kernel.org Cc: Junio C Hamano , Jeff King , Han-Wen Nienhuys , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBC?= =?utf-8?b?amFybWFzb24=?= Subject: [PATCH v2 16/21] refs API: make refs_ref_exists() not set errno Date: Sat, 16 Oct 2021 11:39:22 +0200 Message-Id: X-Mailer: git-send-email 2.33.1.1338.g20da966911a In-Reply-To: References: MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org Move refs_ref_exists from the legacy refs_resolve_ref_unsafe() to the new refs_werrres_ref_unsafe(). I have read its callers and determined that they don't care about errno being set, in particular: git grep -W -w -e refs_ref_exists -e ref_exists Signed-off-by: Ævar Arnfjörð Bjarmason --- refs.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/refs.c b/refs.c index 09452b5e413..8d5a76fbf29 100644 --- a/refs.c +++ b/refs.c @@ -309,7 +309,9 @@ int read_ref(const char *refname, struct object_id *oid) int refs_ref_exists(struct ref_store *refs, const char *refname) { - return !!refs_resolve_ref_unsafe(refs, refname, RESOLVE_REF_READING, NULL, NULL); + int ignore_errno; + return !!refs_werrres_ref_unsafe(refs, refname, RESOLVE_REF_READING, + NULL, NULL, &ignore_errno); } int ref_exists(const char *refname) From patchwork Sat Oct 16 09:39:23 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= X-Patchwork-Id: 12563397 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 54DE2C433EF for ; Sat, 16 Oct 2021 09:40:58 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 31DEE60E96 for ; Sat, 16 Oct 2021 09:40:58 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S244124AbhJPJnB (ORCPT ); Sat, 16 Oct 2021 05:43:01 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57592 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S244020AbhJPJlx (ORCPT ); Sat, 16 Oct 2021 05:41:53 -0400 Received: from mail-wr1-x42e.google.com (mail-wr1-x42e.google.com [IPv6:2a00:1450:4864:20::42e]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 54A7AC061764 for ; Sat, 16 Oct 2021 02:39:44 -0700 (PDT) Received: by mail-wr1-x42e.google.com with SMTP id i12so30668719wrb.7 for ; Sat, 16 Oct 2021 02:39:44 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=R7CVvVLYDXY5/txJKxXakZ7mSCLstn0BZmE5CGZY2zA=; b=hS8QYAu6OLglJ+/KHKtiw/Vd63CZf3s7FX/QItNN4rq5NdmDdu5VCFKdrq/Aa+ngb7 66JSSfhQyYKRlG5H25MG6kU79/AWDeSgASUZExLYmf3ynIcX/Z4hHCDM0JBTGY7aaMqy xAEFvkkPEamdS2KK3L73MeFilHCYZ/YwtPQd/aClZbfq4CkOFf2+8uY4xA7yJcynJIab sFa5+ELyTjruXhflFW58TWfuNynHVMrHjX5XmK+ff7OQTFjARX9Yz2GesKxFaUMQV2h2 9H6mSc/RiNnQA+9aMFT39QLgRy/aa8oc+w4afftNBu2kwtjWDzlxtoGWBWvRypiYRJEl WfcA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=R7CVvVLYDXY5/txJKxXakZ7mSCLstn0BZmE5CGZY2zA=; b=eLza9VB+sSCUITrgBgzzc47FPrx6+e8YdhLloSwboTgE/RLNP8UbAw3mQdYigOsS/m rF3Ijy41JT98v/V1+eJb7TQEm6u/rUcWMa8MFWV/AuqUJU9IkSg///39mNe/0laIWBa3 UHUGsdxtNeGKEwiRcjLM2HsFZ/Fp1dg7G+mBrIulKjynGATCCt07CqGANj56UICszJbk HjT+yDfeGL6rIOTiSS3IBTy+HVlHD3USq9FGvY6JEkXo/6NIAHR9TN/f38oOxqDheo0b aDy+ujcrQEcSZAFSNl0+V7nVVPcV8Fg7t1lCIX4b7BZfL9P25PYkFPBtXLKp8XwXCMFe EPsw== X-Gm-Message-State: AOAM533N1AvDfWK9BPY9QM1kDSDTIHr1u4ayyjUV9i+xbI8bKKkEBvJq Ak2iTUo5TADYP2FipdK7hTzpG5UcDluSrA== X-Google-Smtp-Source: ABdhPJxlYCwfQTL3y39Rr4mq7VOp1INwjUulLmd1nbayLSDoVWNjWXYoJgtkjnm7TRKwzxLVPIGk8w== X-Received: by 2002:adf:9b97:: with SMTP id d23mr20446835wrc.135.1634377182669; Sat, 16 Oct 2021 02:39:42 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id k22sm6993492wrd.59.2021.10.16.02.39.42 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 16 Oct 2021 02:39:42 -0700 (PDT) From: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= To: git@vger.kernel.org Cc: Junio C Hamano , Jeff King , Han-Wen Nienhuys , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBC?= =?utf-8?b?amFybWFzb24=?= Subject: [PATCH v2 17/21] refs API: make resolve_ref_unsafe() not set errno Date: Sat, 16 Oct 2021 11:39:23 +0200 Message-Id: X-Mailer: git-send-email 2.33.1.1338.g20da966911a In-Reply-To: References: MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org Change the resolve_ref_unsafe() wrapper function to use the underlying refs_werrres_ref_unsafe() directly. From a reading of the callers I determined that the only one who cared about errno was a sequencer.c caller added in e47c6cafcb5 (commit: move print_commit_summary() to libgit, 2017-11-24), I'm migrating it to using refs_werrres_ref_unsafe() directly. This adds another "set errno" instance, but in this case it's OK and idiomatic. We are setting it just before calling die_errno(). We could have some hypothetical die_errno_var(&saved_errno, ...) here, but I don't think it's worth it. The problem with errno is subtle action at distance, not this sort of thing. We already use this pattern in a couple of places in wrapper.c Signed-off-by: Ævar Arnfjörð Bjarmason --- refs.c | 6 ++++-- sequencer.c | 10 ++++++++-- 2 files changed, 12 insertions(+), 4 deletions(-) diff --git a/refs.c b/refs.c index 8d5a76fbf29..b563729782b 100644 --- a/refs.c +++ b/refs.c @@ -1785,8 +1785,10 @@ int refs_init_db(struct strbuf *err) const char *resolve_ref_unsafe(const char *refname, int resolve_flags, struct object_id *oid, int *flags) { - return refs_resolve_ref_unsafe(get_main_ref_store(the_repository), refname, - resolve_flags, oid, flags); + int ignore_errno; + + return refs_werrres_ref_unsafe(get_main_ref_store(the_repository), refname, + resolve_flags, oid, flags, &ignore_errno); } int resolve_gitlink_ref(const char *submodule, const char *refname, diff --git a/sequencer.c b/sequencer.c index fac0b5162f6..1223dc2d2bf 100644 --- a/sequencer.c +++ b/sequencer.c @@ -1282,6 +1282,8 @@ void print_commit_summary(struct repository *r, struct pretty_print_context pctx = {0}; struct strbuf author_ident = STRBUF_INIT; struct strbuf committer_ident = STRBUF_INIT; + struct ref_store *refs; + int resolve_errno; commit = lookup_commit(r, oid); if (!commit) @@ -1331,9 +1333,13 @@ void print_commit_summary(struct repository *r, rev.diffopt.break_opt = 0; diff_setup_done(&rev.diffopt); - head = resolve_ref_unsafe("HEAD", 0, NULL, NULL); - if (!head) + refs = get_main_ref_store(the_repository); + head = refs_werrres_ref_unsafe(refs, "HEAD", 0, NULL, NULL, + &resolve_errno); + if (!head) { + errno = resolve_errno; die_errno(_("unable to resolve HEAD after creating commit")); + } if (!strcmp(head, "HEAD")) head = _("detached HEAD"); else From patchwork Sat Oct 16 09:39:24 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= X-Patchwork-Id: 12563407 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id E281AC433EF for ; Sat, 16 Oct 2021 09:41:16 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id CC0D460E96 for ; Sat, 16 Oct 2021 09:41:16 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S244144AbhJPJnX (ORCPT ); Sat, 16 Oct 2021 05:43:23 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57696 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S244013AbhJPJlz (ORCPT ); Sat, 16 Oct 2021 05:41:55 -0400 Received: from mail-wr1-x42b.google.com (mail-wr1-x42b.google.com [IPv6:2a00:1450:4864:20::42b]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 48BB9C061765 for ; Sat, 16 Oct 2021 02:39:45 -0700 (PDT) Received: by mail-wr1-x42b.google.com with SMTP id r18so30735450wrg.6 for ; Sat, 16 Oct 2021 02:39:45 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=DjnL0ehFdK4CUXwhC4UFwdhLlXhGx5//yFCl6dg/Vso=; b=m6KjyTogS1mMB+2ZAdrBr8VAG1Me/TRl1MiKDyysVFL9aF1e0xdktoNSlIz2rssNcd zrYSdyv8UFfPLRyP/oOgLOID8vnJ6J8RY4OxShQqlO7/cKZOb+/eYVYFLsWtnqphmrQM RguRrBbFuu5+Iuelvo+UHq81vnBafA+wu60QLsNAhOHbeMkXapoO0bL/YFiRKhaOEbc4 ZAcrUWyUgQZxg2KtSQADTTarU+IjOSzDB5lgIY4wQDpfmIT78/is5zYAjpxmH6VTaChv NzxGaSkGmjUrIyOp5JIpL0EYVSJ4cvy5VM4khusErreScHjZIQPQjdGvIoZWrfh8mz10 aaow== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=DjnL0ehFdK4CUXwhC4UFwdhLlXhGx5//yFCl6dg/Vso=; b=lq1lwRInk7RyEdjrenhQzSrZkwTbLCr585D2Bl3UlnvifWmDlfn47JndweEpOTESB1 RQ9wXAECeXxk9yB9NZWGtrcQWNojN79uietIq79UumX11WD2tpL4sUX+IBc1MgJtzH+j YUGRHKRfQ6JIQKDXgoR5/qsqjaTVBof5CbI7gs3hwj9oM92u+LnpK58dX5nzPjDzDyXv yGV9gBuIWFs1tUyh65fLeMeQstwPcqsd89sQS6bQ47ehbRwdFfhfINlKwPVZ7bvAEEy/ /JEoOXNTSWN33NalBhnM06Fc2p1s3W6BypdRW/B0ezygdtrrqRZLdMJ78lOTvuw3SIzb 78lw== X-Gm-Message-State: AOAM5311YAOJxFjmvVf+FUwgQDIXTcqMLNbACsZ0UevRfckyGUilyveT gGlYO6/HMKkhpt3ZpTABbSxB59z1Pv4KHg== X-Google-Smtp-Source: ABdhPJyRpQopG38K+Iq7J7s9FLHJ77WV8so6L1X1JOxoJbBjH3yYRqwfrd5snuAIehYe9OgyZtc31A== X-Received: by 2002:a05:6000:2a3:: with SMTP id l3mr20435866wry.12.1634377183664; Sat, 16 Oct 2021 02:39:43 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id k22sm6993492wrd.59.2021.10.16.02.39.42 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 16 Oct 2021 02:39:42 -0700 (PDT) From: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= To: git@vger.kernel.org Cc: Junio C Hamano , Jeff King , Han-Wen Nienhuys , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBC?= =?utf-8?b?amFybWFzb24=?= Subject: [PATCH v2 18/21] refs API: make expand_ref() & repo_dwim_log() not set errno Date: Sat, 16 Oct 2021 11:39:24 +0200 Message-Id: X-Mailer: git-send-email 2.33.1.1338.g20da966911a In-Reply-To: References: MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org The use of these two is rather trivial, and it's easy to see none of their callers care about errno. So let's move them from refs_resolve_ref_unsafe() to refs_resolve_ref_unsafe_with_errno(), these were the last two callers, so we can get rid of that wrapper function. Signed-off-by: Ævar Arnfjörð Bjarmason --- refs.c | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/refs.c b/refs.c index b563729782b..43fe9e6d89d 100644 --- a/refs.c +++ b/refs.c @@ -654,13 +654,16 @@ int expand_ref(struct repository *repo, const char *str, int len, struct object_id oid_from_ref; struct object_id *this_result; int flag; + struct ref_store *refs = get_main_ref_store(repo); + int ignore_errno; this_result = refs_found ? &oid_from_ref : oid; strbuf_reset(&fullref); strbuf_addf(&fullref, *p, len, str); - r = refs_resolve_ref_unsafe(get_main_ref_store(repo), - fullref.buf, RESOLVE_REF_READING, - this_result, &flag); + r = refs_werrres_ref_unsafe(refs, fullref.buf, + RESOLVE_REF_READING, + this_result, &flag, + &ignore_errno); if (r) { if (!refs_found++) *ref = xstrdup(r); @@ -689,12 +692,14 @@ int repo_dwim_log(struct repository *r, const char *str, int len, for (p = ref_rev_parse_rules; *p; p++) { struct object_id hash; const char *ref, *it; + int ignore_errno; strbuf_reset(&path); strbuf_addf(&path, *p, len, str); - ref = refs_resolve_ref_unsafe(refs, path.buf, + ref = refs_werrres_ref_unsafe(refs, path.buf, RESOLVE_REF_READING, - oid ? &hash : NULL, NULL); + oid ? &hash : NULL, NULL, + &ignore_errno); if (!ref) continue; if (refs_reflog_exists(refs, path.buf)) From patchwork Sat Oct 16 09:39:25 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= X-Patchwork-Id: 12563409 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 7DDDAC433FE for ; Sat, 16 Oct 2021 09:41:17 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 6AB4A61073 for ; Sat, 16 Oct 2021 09:41:17 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S244146AbhJPJnY (ORCPT ); Sat, 16 Oct 2021 05:43:24 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57694 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S244004AbhJPJlz (ORCPT ); Sat, 16 Oct 2021 05:41:55 -0400 Received: from mail-wr1-x429.google.com (mail-wr1-x429.google.com [IPv6:2a00:1450:4864:20::429]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id F1C0DC061766 for ; Sat, 16 Oct 2021 02:39:45 -0700 (PDT) Received: by mail-wr1-x429.google.com with SMTP id y3so30851001wrl.1 for ; Sat, 16 Oct 2021 02:39:45 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=EDJMqoeaZ+ObsmXQ+Y2NpaFOPm9lLqHvyM9KrsPHNks=; b=Hoz4WUCysHRYiLNUMUAlNErKuuJR3PruzFDUHpmZVVjdJ5Pt9dfb8xFlYn74jUO3j7 7/2pPpW7AqSCFfynBkJ2EEfuhOGzh1NFWk9Yf9Dy7EHIH5vHUcBDLFWKbIUXgsf+3/bf xfMICAkfNGyFpAMiGCa1VA6e97MiznzqhDpBGN0WtWLMhG87H/AviV+Ncp8HshC3n47n nbXkUgEl0ep5A8/L9BttMoRRGEbIijfgaQxEd+dviITt5uvWZ26sis5vMRRYUKQ7Fc8L hETTYjItjHWdqnewG5UAhNyn3sHHXM9o/UwXnCkBDN9LIRX1kp/8eE/ivOCmxrgETdKO ldvA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=EDJMqoeaZ+ObsmXQ+Y2NpaFOPm9lLqHvyM9KrsPHNks=; b=2pmn/2EtRT+Pr+ktZNTums/O/6UrxojJZafh2tTCGkPHAq0LFZVL3UPMJy0iXRpOr1 LJ3cnsPysqQuINZ41GoAboyLD0IrVNH76QK/R3ViOpKy4cOEUm5v19VDqB+7wSkJmZns JAP/pllIxXeGQEzHBzJ5qBJhN5Hh5BKDVLje4YRGqZV23T7b9vsvcjF9eueDDmV6Ohhd 8O/Y9iEioi/elY0cSEFmQHVgKjIsr/NBM7viO7a0dRqxpBJJpPrmQ8NZ6TFMViJeGqsL NLPGAvmQk8YwQDln4Ou/nwP8eNzLUWPMACr+71WNxH5hWkczvK63oaG9dzZCzqrD1Au6 dSAA== X-Gm-Message-State: AOAM53294IGEMS2h/H72jb+CM3VTQvC4eeHEGFd8EGaXZQgnc+Pr4OQC d8qPM43+1VHpi6jHu0qc/OpNMaQnCn1k5A== X-Google-Smtp-Source: ABdhPJwchhbt63S+CaEOk+LO9G9BsmqTrAMNpPVYaFaWzorDcLRXO4ewIPTsxMrQa0gNHozipOBkVw== X-Received: by 2002:a5d:4d0f:: with SMTP id z15mr21068260wrt.334.1634377184395; Sat, 16 Oct 2021 02:39:44 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id k22sm6993492wrd.59.2021.10.16.02.39.43 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 16 Oct 2021 02:39:43 -0700 (PDT) From: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= To: git@vger.kernel.org Cc: Junio C Hamano , Jeff King , Han-Wen Nienhuys , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBC?= =?utf-8?b?amFybWFzb24=?= Subject: [PATCH v2 19/21] refs API: don't expose "errno" in run_transaction_hook() Date: Sat, 16 Oct 2021 11:39:25 +0200 Message-Id: X-Mailer: git-send-email 2.33.1.1338.g20da966911a In-Reply-To: References: MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org In run_transaction_hook() we've checked errno since 67541597670 (refs: implement reference transaction hook, 2020-06-19), let's reset errno afterwards to make sure nobody using refs.c directly or indirectly relies on it. Signed-off-by: Ævar Arnfjörð Bjarmason --- refs.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/refs.c b/refs.c index 43fe9e6d89d..e90c59539b4 100644 --- a/refs.c +++ b/refs.c @@ -2096,8 +2096,11 @@ static int run_transaction_hook(struct ref_transaction *transaction, update->refname); if (write_in_full(proc.in, buf.buf, buf.len) < 0) { - if (errno != EPIPE) + if (errno != EPIPE) { + /* Don't leak errno outside this API */ + errno = 0; ret = -1; + } break; } } From patchwork Sat Oct 16 09:39:26 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= X-Patchwork-Id: 12563405 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 04418C433EF for ; Sat, 16 Oct 2021 09:41:15 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id DF63961073 for ; Sat, 16 Oct 2021 09:41:14 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S244141AbhJPJnT (ORCPT ); Sat, 16 Oct 2021 05:43:19 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57700 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S244002AbhJPJlz (ORCPT ); Sat, 16 Oct 2021 05:41:55 -0400 Received: from mail-wr1-x42b.google.com (mail-wr1-x42b.google.com [IPv6:2a00:1450:4864:20::42b]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id AEFBDC061767 for ; Sat, 16 Oct 2021 02:39:46 -0700 (PDT) Received: by mail-wr1-x42b.google.com with SMTP id y3so30851019wrl.1 for ; Sat, 16 Oct 2021 02:39:46 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=mV61pg3p6apTs5MLYcOm15T2lzjSG2WI8P687D6XF70=; b=XogMt3IOIABjgqkPtZiFSk2QevZhCo9jUVDtFudYAjjGRTI84IgqoLE+k5BVOnb4Pj rJYZi9WWQp7zDDCXcOIJNDcWbZWDhvoKoRUYIkZ3uLZuLroVXiYy5s4C54oggIMYbKW5 dydxSYj3LIl9y1ujAF/TH119o4Hs+vnO06PdsmIHOHveBDkdmNpMylOrjyJviJcf8ezC Y6DEi14+EiwA1tdqZCo+x2IV0W59sEB2umksJdZZ33cz8wajGMn2vkVKl7PVvfzPHOSq 7X9RzRBBcrrAacX3aRVHIzrdyeVi3S8spvrxr+PPWp1UGQjgRTvhBTCaw4jVOACL6KWr dBoA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=mV61pg3p6apTs5MLYcOm15T2lzjSG2WI8P687D6XF70=; b=VlvwpA5c+A1G9M7CXrCF6AtcC8Ab3wLPHzDiw9oW7UNAWmy5OuGIkpESn+c4n0Qq+Q JuIHn+aykcPPOr1FYQSQTXXw06z2+uCn+AeHQKv9KCKh8iUKoRmzajG/5aQ7eGN6SZdM ovn8rQA8aYysN4Ftf+HJhJziyy7ZwvZU38zf9up2+0QshBnI+pyL5CGhIKDv6SRK02Yz 96VVtmt2Fs/tNr+ZaWPeRL8fS3XMUTvxlPvrpswGci/S4/7XbHiR4oxwpCPCic1gmVJJ Afx7CNjCtwBGyPma3218LYegXICXHeslhRWihuDDrF9GAZ+uKfsK8az77YOVq6QQuVYc 7Y3g== X-Gm-Message-State: AOAM531Xr4D6SjxIVhvAaziiEoijUdMQNbRnot3SrR9Gej3iU7bcu4rZ UOfKhxtd4OhAEsZlJfxxBl+O/oZmAA5jHw== X-Google-Smtp-Source: ABdhPJxKorn9pCjzcGXpG06qDgmneqGtfgPlUZvIY5OIELaesgCyz4vQg+qMtOC+UcWCXgWdebVAmg== X-Received: by 2002:adf:bbc3:: with SMTP id z3mr21071780wrg.10.1634377185128; Sat, 16 Oct 2021 02:39:45 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id k22sm6993492wrd.59.2021.10.16.02.39.44 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 16 Oct 2021 02:39:44 -0700 (PDT) From: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= To: git@vger.kernel.org Cc: Junio C Hamano , Jeff King , Han-Wen Nienhuys , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBC?= =?utf-8?b?amFybWFzb24=?= Subject: [PATCH v2 20/21] refs API: post-migration API renaming [1/2] Date: Sat, 16 Oct 2021 11:39:26 +0200 Message-Id: X-Mailer: git-send-email 2.33.1.1338.g20da966911a In-Reply-To: References: MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org In preceding commits all callers of refs_resolve_ref_unsafe() were migrated to the transitory refs_werrres_ref_unsafe() function. As a first step in getting rid of it let's remove the old function from the public API (it went unused in a preceding commit). We then provide both a coccinelle rule to do the rename, and a macro to avoid breaking the existing callers. Signed-off-by: Ævar Arnfjörð Bjarmason --- contrib/coccinelle/refs.pending.cocci | 5 +++++ refs.c | 15 +-------------- refs.h | 22 +++++++++------------- 3 files changed, 15 insertions(+), 27 deletions(-) create mode 100644 contrib/coccinelle/refs.pending.cocci diff --git a/contrib/coccinelle/refs.pending.cocci b/contrib/coccinelle/refs.pending.cocci new file mode 100644 index 00000000000..b33cb8a12aa --- /dev/null +++ b/contrib/coccinelle/refs.pending.cocci @@ -0,0 +1,5 @@ +@@ +expression refs, refname, resolve_flags, oid, flags, failure_errno; +@@ +- refs_werrres_ref_unsafe(refs, refname, resolve_flags, oid, flags, failure_errno) ++ refs_resolve_ref_unsafe(refs, refname, resolve_flags, oid, flags, failure_errno) diff --git a/refs.c b/refs.c index e90c59539b4..4e06745c97a 100644 --- a/refs.c +++ b/refs.c @@ -1669,7 +1669,7 @@ int refs_read_raw_ref(struct ref_store *ref_store, const char *refname, type, failure_errno); } -const char *refs_werrres_ref_unsafe(struct ref_store *refs, +const char *refs_resolve_ref_unsafe(struct ref_store *refs, const char *refname, int resolve_flags, struct object_id *oid, @@ -1766,19 +1766,6 @@ const char *refs_werrres_ref_unsafe(struct ref_store *refs, return NULL; } -const char *refs_resolve_ref_unsafe(struct ref_store *refs, const char *refname, - int resolve_flags, struct object_id *oid, - int *flags) -{ - int failure_errno = 0; - const char *refn; - refn = refs_werrres_ref_unsafe(refs, refname, resolve_flags, - oid, flags, &failure_errno); - if (!refn) - errno = failure_errno; - return refn; -} - /* backend functions */ int refs_init_db(struct strbuf *err) { diff --git a/refs.h b/refs.h index 3938f99c902..d908a161c06 100644 --- a/refs.h +++ b/refs.h @@ -11,18 +11,6 @@ struct string_list; struct string_list_item; struct worktree; -/* - * Callers should not inspect "errno" on failure, but rather pass in a - * "failure_errno" parameter, on failure the "errno" will indicate the - * type of failure encountered, but not necessarily one that came from - * a syscall. We might have faked it up. - */ -const char *refs_werrres_ref_unsafe(struct ref_store *refs, - const char *refname, - int resolve_flags, - struct object_id *oid, - int *flags, int *failure_errno); - /* * Resolve a reference, recursively following symbolic refererences. * @@ -70,16 +58,24 @@ const char *refs_werrres_ref_unsafe(struct ref_store *refs, * resolved. The function returns NULL for such ref names. * Caps and underscores refers to the special refs, such as HEAD, * FETCH_HEAD and friends, that all live outside of the refs/ directory. + * + * Callers should not inspect "errno" on failure, but rather pass in a + * "failure_errno" parameter, on failure the "errno" will indicate the + * type of failure encountered, but not necessarily one that came from + * a syscall. We might have faked it up. */ #define RESOLVE_REF_READING 0x01 #define RESOLVE_REF_NO_RECURSE 0x02 #define RESOLVE_REF_ALLOW_BAD_NAME 0x04 +#define refs_werrres_ref_unsafe(refs, refname, resolve_flags, oid, flags, failure_errno) \ + refs_resolve_ref_unsafe(refs, refname, resolve_flags, oid, flags, failure_errno) const char *refs_resolve_ref_unsafe(struct ref_store *refs, const char *refname, int resolve_flags, struct object_id *oid, - int *flags); + int *flags, int *failure_errno); + const char *resolve_ref_unsafe(const char *refname, int resolve_flags, struct object_id *oid, int *flags); From patchwork Sat Oct 16 09:39:27 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= X-Patchwork-Id: 12563411 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 8F618C433EF for ; Sat, 16 Oct 2021 09:41:18 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 6B1A360E96 for ; Sat, 16 Oct 2021 09:41:18 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S244150AbhJPJnZ (ORCPT ); Sat, 16 Oct 2021 05:43:25 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57698 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S244008AbhJPJlz (ORCPT ); Sat, 16 Oct 2021 05:41:55 -0400 Received: from mail-wr1-x435.google.com (mail-wr1-x435.google.com [IPv6:2a00:1450:4864:20::435]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 73DA8C061768 for ; Sat, 16 Oct 2021 02:39:47 -0700 (PDT) Received: by mail-wr1-x435.google.com with SMTP id o20so30784647wro.3 for ; Sat, 16 Oct 2021 02:39:47 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=tbUlSJSQbhS8yBSQC8Uq4EqVjfNsgUACswHUTPxNl6g=; b=F2pnEnATgtZ0xvqqtYTy9aZG5q5GgSzpYfjZFsRfDB4FrR9XwsY9GGaOYtZ0SxtGJr v5BmylUyK9G7Kyuj0SsBNHXVceYXJHx33LUyyLTLc5GyIcsefpv8vLktD2aMMDtpQHhO nwspAnMf+xX7dkfMeJBgNyExTu0o3h9/ufh/U0j+SKuI3ylREyVx7n1B1Q+NZjHyIeMl YsqV9raHO8JGwLjD/MyE+ftrUrLuy/3hB+A6ZCnuora16UVIOgCxDEXjJBiOzpuHWv20 n+6ezGzxX8sJ0shdZMWxN+TB8J/3OS5veB4RFVhJvmmQVB4hsGPg9NSAuJ+VT5MdfDcj 2qOQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=tbUlSJSQbhS8yBSQC8Uq4EqVjfNsgUACswHUTPxNl6g=; b=pCjYKFXgSAWyGfC6ilYtpph2JnIShaWZEtHvb/eZ1tdRO5gfreNdOjDqesjCv032a4 8583+6rLD4l8HOh9vT9PciBiPTQK10W+9HY9MtytB7j7q6doyIYyJOP6771fSFIateAC x1p6FgfDbsMwT5mqRvycvPdrmi0KBsQWaWfcYw77qjzpM5ZzkPUzQoTaqLODk1Eij9F1 TaO07xkBJhGF/oRBItezWe+vtPunumob0W1nj3xfWGFyStRV6MgYFC4hKp2/CsZ0lCxr sQHhNb2rjRzdXRQdNd8QwVAfqfbkGK6PPN2qqh/nrv17kB96X2xoF3ROBIFpsYIj28tX k5xA== X-Gm-Message-State: AOAM531+AR1MAa7uCGsPktbe9ktSn2fkfse58ltwUy2VaMbK+WKJ7sf1 qB5IU8FFldqc2bwnEC5V+7wmDE4w3jrM9g== X-Google-Smtp-Source: ABdhPJySAP4MU3Qoa1A9bLB9SETdk2CpbobeYQ62WMd9Rv5LcdzCKu8juO17bOaofkHgJ86y7CJZCg== X-Received: by 2002:adf:c992:: with SMTP id f18mr20460869wrh.138.1634377185806; Sat, 16 Oct 2021 02:39:45 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id k22sm6993492wrd.59.2021.10.16.02.39.45 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 16 Oct 2021 02:39:45 -0700 (PDT) From: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= To: git@vger.kernel.org Cc: Junio C Hamano , Jeff King , Han-Wen Nienhuys , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBC?= =?utf-8?b?amFybWFzb24=?= Subject: [PATCH v2 21/21] refs API: post-migration API renaming [2/2] Date: Sat, 16 Oct 2021 11:39:27 +0200 Message-Id: X-Mailer: git-send-email 2.33.1.1338.g20da966911a In-Reply-To: References: MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org Rename the transitory refs_werrres_ref_unsafe() function to refs_resolve_ref_unsafe(), now that all callers of the old function have learned to pass in a "failure_errno" parameter. The coccinelle semantic patch added in the preceding commit works, but I couldn't figure out how to get spatch(1) to re-flow these argument lists (and sometimes make lines way too long), so this rename was done with: perl -pi -e 's/refs_werrres_ref_unsafe/refs_resolve_ref_unsafe/g' \ $(git grep -l refs_werrres_ref_unsafe -- '*.c') But after that "make contrib/coccinelle/refs.cocci.patch" comes up empty, so the result would have been the same. Let's remove that transitory semantic patch file, we won't need to retain it for any other in-flight changes, refs_werrres_ref_unsafe() only existed within this patch series. Signed-off-by: Ævar Arnfjörð Bjarmason --- contrib/coccinelle/refs.pending.cocci | 5 ----- refs.c | 16 ++++++++-------- refs.h | 2 -- refs/files-backend.c | 18 +++++++++--------- sequencer.c | 2 +- t/helper/test-ref-store.c | 2 +- worktree.c | 6 +++--- 7 files changed, 22 insertions(+), 29 deletions(-) delete mode 100644 contrib/coccinelle/refs.pending.cocci diff --git a/contrib/coccinelle/refs.pending.cocci b/contrib/coccinelle/refs.pending.cocci deleted file mode 100644 index b33cb8a12aa..00000000000 --- a/contrib/coccinelle/refs.pending.cocci +++ /dev/null @@ -1,5 +0,0 @@ -@@ -expression refs, refname, resolve_flags, oid, flags, failure_errno; -@@ -- refs_werrres_ref_unsafe(refs, refname, resolve_flags, oid, flags, failure_errno) -+ refs_resolve_ref_unsafe(refs, refname, resolve_flags, oid, flags, failure_errno) diff --git a/refs.c b/refs.c index 4e06745c97a..cd9b8bb1141 100644 --- a/refs.c +++ b/refs.c @@ -270,7 +270,7 @@ char *refs_resolve_refdup(struct ref_store *refs, const char *result; int ignore_errno; - result = refs_werrres_ref_unsafe(refs, refname, resolve_flags, + result = refs_resolve_ref_unsafe(refs, refname, resolve_flags, oid, flags, &ignore_errno); return xstrdup_or_null(result); } @@ -296,7 +296,7 @@ int read_ref_full(const char *refname, int resolve_flags, struct object_id *oid, int ignore_errno; struct ref_store *refs = get_main_ref_store(the_repository); - if (refs_werrres_ref_unsafe(refs, refname, resolve_flags, + if (refs_resolve_ref_unsafe(refs, refname, resolve_flags, oid, flags, &ignore_errno)) return 0; return -1; @@ -310,7 +310,7 @@ int read_ref(const char *refname, struct object_id *oid) int refs_ref_exists(struct ref_store *refs, const char *refname) { int ignore_errno; - return !!refs_werrres_ref_unsafe(refs, refname, RESOLVE_REF_READING, + return !!refs_resolve_ref_unsafe(refs, refname, RESOLVE_REF_READING, NULL, NULL, &ignore_errno); } @@ -660,7 +660,7 @@ int expand_ref(struct repository *repo, const char *str, int len, this_result = refs_found ? &oid_from_ref : oid; strbuf_reset(&fullref); strbuf_addf(&fullref, *p, len, str); - r = refs_werrres_ref_unsafe(refs, fullref.buf, + r = refs_resolve_ref_unsafe(refs, fullref.buf, RESOLVE_REF_READING, this_result, &flag, &ignore_errno); @@ -696,7 +696,7 @@ int repo_dwim_log(struct repository *r, const char *str, int len, strbuf_reset(&path); strbuf_addf(&path, *p, len, str); - ref = refs_werrres_ref_unsafe(refs, path.buf, + ref = refs_resolve_ref_unsafe(refs, path.buf, RESOLVE_REF_READING, oid ? &hash : NULL, NULL, &ignore_errno); @@ -1383,7 +1383,7 @@ int refs_head_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data) int flag; int ignore_errno; - if (refs_werrres_ref_unsafe(refs, "HEAD", RESOLVE_REF_READING, + if (refs_resolve_ref_unsafe(refs, "HEAD", RESOLVE_REF_READING, &oid, &flag, &ignore_errno)) return fn("HEAD", &oid, flag, cb_data); @@ -1779,7 +1779,7 @@ const char *resolve_ref_unsafe(const char *refname, int resolve_flags, { int ignore_errno; - return refs_werrres_ref_unsafe(get_main_ref_store(the_repository), refname, + return refs_resolve_ref_unsafe(get_main_ref_store(the_repository), refname, resolve_flags, oid, flags, &ignore_errno); } @@ -1795,7 +1795,7 @@ int resolve_gitlink_ref(const char *submodule, const char *refname, if (!refs) return -1; - if (!refs_werrres_ref_unsafe(refs, refname, 0, oid, &flags, + if (!refs_resolve_ref_unsafe(refs, refname, 0, oid, &flags, &ignore_errno) || is_null_oid(oid)) return -1; return 0; diff --git a/refs.h b/refs.h index d908a161c06..45c34e99e3a 100644 --- a/refs.h +++ b/refs.h @@ -68,8 +68,6 @@ struct worktree; #define RESOLVE_REF_NO_RECURSE 0x02 #define RESOLVE_REF_ALLOW_BAD_NAME 0x04 -#define refs_werrres_ref_unsafe(refs, refname, resolve_flags, oid, flags, failure_errno) \ - refs_resolve_ref_unsafe(refs, refname, resolve_flags, oid, flags, failure_errno) const char *refs_resolve_ref_unsafe(struct ref_store *refs, const char *refname, int resolve_flags, diff --git a/refs/files-backend.c b/refs/files-backend.c index 6c854dda533..abb6091fcf5 100644 --- a/refs/files-backend.c +++ b/refs/files-backend.c @@ -281,7 +281,7 @@ static void loose_fill_ref_dir(struct ref_store *ref_store, refname.len)); } else { int ignore_errno; - if (!refs_werrres_ref_unsafe(&refs->base, + if (!refs_resolve_ref_unsafe(&refs->base, refname.buf, RESOLVE_REF_READING, &oid, &flag, &ignore_errno)) { @@ -1034,7 +1034,7 @@ static struct ref_lock *lock_ref_oid_basic(struct files_ref_store *refs, goto error_return; } - if (!refs_werrres_ref_unsafe(&refs->base, lock->ref_name, 0, + if (!refs_resolve_ref_unsafe(&refs->base, lock->ref_name, 0, &lock->old_oid, NULL, &ignore_errno)) oidclr(&lock->old_oid); goto out; @@ -1410,7 +1410,7 @@ static int files_copy_or_rename_ref(struct ref_store *ref_store, goto out; } - if (!refs_werrres_ref_unsafe(&refs->base, oldrefname, + if (!refs_resolve_ref_unsafe(&refs->base, oldrefname, RESOLVE_REF_READING | RESOLVE_REF_NO_RECURSE, &orig_oid, &flag, &ignore_errno)) { ret = error("refname %s not found", oldrefname); @@ -1456,7 +1456,7 @@ static int files_copy_or_rename_ref(struct ref_store *ref_store, * the safety anyway; we want to delete the reference whatever * its current value. */ - if (!copy && refs_werrres_ref_unsafe(&refs->base, newrefname, + if (!copy && refs_resolve_ref_unsafe(&refs->base, newrefname, RESOLVE_REF_READING | RESOLVE_REF_NO_RECURSE, NULL, NULL, &ignore_errno) && refs_delete_ref(&refs->base, NULL, newrefname, @@ -1825,7 +1825,7 @@ static int commit_ref_update(struct files_ref_store *refs, const char *head_ref; int ignore_errno; - head_ref = refs_werrres_ref_unsafe(&refs->base, "HEAD", + head_ref = refs_resolve_ref_unsafe(&refs->base, "HEAD", RESOLVE_REF_READING, NULL, &head_flag, &ignore_errno); @@ -1875,7 +1875,7 @@ static void update_symref_reflog(struct files_ref_store *refs, int ignore_errno; if (logmsg && - refs_werrres_ref_unsafe(&refs->base, target, + refs_resolve_ref_unsafe(&refs->base, target, RESOLVE_REF_READING, &new_oid, NULL, &ignore_errno) && files_log_ref_write(refs, refname, &lock->old_oid, @@ -2163,7 +2163,7 @@ static int files_reflog_iterator_advance(struct ref_iterator *ref_iterator) if (ends_with(diter->basename, ".lock")) continue; - if (!refs_werrres_ref_unsafe(iter->ref_store, + if (!refs_resolve_ref_unsafe(iter->ref_store, diter->relative_path, 0, &iter->oid, &flags, &ignore_errno)) { @@ -2511,7 +2511,7 @@ static int lock_ref_for_update(struct files_ref_store *refs, * to record and possibly check old_oid: */ int ignore_errno; - if (!refs_werrres_ref_unsafe(&refs->base, + if (!refs_resolve_ref_unsafe(&refs->base, referent.buf, 0, &lock->old_oid, NULL, &ignore_errno)) { @@ -3209,7 +3209,7 @@ static int files_reflog_expire(struct ref_store *ref_store, int type; const char *ref; - ref = refs_werrres_ref_unsafe(&refs->base, refname, + ref = refs_resolve_ref_unsafe(&refs->base, refname, RESOLVE_REF_NO_RECURSE, NULL, &type, &ignore_errno); diff --git a/sequencer.c b/sequencer.c index 1223dc2d2bf..cf10f9a332e 100644 --- a/sequencer.c +++ b/sequencer.c @@ -1334,7 +1334,7 @@ void print_commit_summary(struct repository *r, diff_setup_done(&rev.diffopt); refs = get_main_ref_store(the_repository); - head = refs_werrres_ref_unsafe(refs, "HEAD", 0, NULL, NULL, + head = refs_resolve_ref_unsafe(refs, "HEAD", 0, NULL, NULL, &resolve_errno); if (!head) { errno = resolve_errno; diff --git a/t/helper/test-ref-store.c b/t/helper/test-ref-store.c index 2f91fb9b227..3986665037a 100644 --- a/t/helper/test-ref-store.c +++ b/t/helper/test-ref-store.c @@ -125,7 +125,7 @@ static int cmd_resolve_ref(struct ref_store *refs, const char **argv) const char *ref; int ignore_errno; - ref = refs_werrres_ref_unsafe(refs, refname, resolve_flags, + ref = refs_resolve_ref_unsafe(refs, refname, resolve_flags, &oid, &flags, &ignore_errno); printf("%s %s 0x%x\n", oid_to_hex(&oid), ref ? ref : "(null)", flags); return ref ? 0 : 1; diff --git a/worktree.c b/worktree.c index 7d7cf058154..2c155b10150 100644 --- a/worktree.c +++ b/worktree.c @@ -30,7 +30,7 @@ static void add_head_info(struct worktree *wt) const char *target; int ignore_errno; - target = refs_werrres_ref_unsafe(get_worktree_ref_store(wt), + target = refs_resolve_ref_unsafe(get_worktree_ref_store(wt), "HEAD", 0, &wt->head_oid, &flags, @@ -437,7 +437,7 @@ const struct worktree *find_shared_symref(const char *symref, } refs = get_worktree_ref_store(wt); - symref_target = refs_werrres_ref_unsafe(refs, symref, 0, + symref_target = refs_resolve_ref_unsafe(refs, symref, 0, NULL, &flags, &ignore_errno); if ((flags & REF_ISSYMREF) && @@ -574,7 +574,7 @@ int other_head_refs(each_ref_fn fn, void *cb_data) strbuf_reset(&refname); strbuf_worktree_ref(wt, &refname, "HEAD"); - if (refs_werrres_ref_unsafe(get_main_ref_store(the_repository), + if (refs_resolve_ref_unsafe(get_main_ref_store(the_repository), refname.buf, RESOLVE_REF_READING, &oid, &flag, &ignore_errno))