From patchwork Thu Oct 14 00:06: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: 12557541 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 6B024C433EF for ; Thu, 14 Oct 2021 00:06:38 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 4CFB161164 for ; Thu, 14 Oct 2021 00:06:38 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S229984AbhJNAIl (ORCPT ); Wed, 13 Oct 2021 20:08:41 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42364 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229677AbhJNAIl (ORCPT ); Wed, 13 Oct 2021 20:08:41 -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 EFC74C061570 for ; Wed, 13 Oct 2021 17:06:36 -0700 (PDT) Received: by mail-wr1-x42e.google.com with SMTP id m22so13966564wrb.0 for ; Wed, 13 Oct 2021 17:06: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=K4BONn6rBYvZlYQkN77M+zhw1mX5XxmJwhe1VEK3aUI=; b=ZIcP1CP1dlA5nAyCOeB7YOX8fUcmKT83Q9LmRNRIjhf3xs9ZhuEiszvhGDz9q9WZfh JZuJeO8bD4p2JXOqf9LvnXl9DL/SdTiwFkTqJHKZ8wmp2dNsbMwGoYvm6m2lPqaE2VmQ ZjBoHDvRUuyoDSNbsiayxk4v1inMVOwNSSEevXTfGeMBdQznaTQNwVJcbgzhxQ60L0OM Fv/ECnV6HemhUpy7WixVxM5GtmzXl49v9760WdTd80sBR0bYd6WKCwR6k0ImLbmzei4j Vou1jOvXARzchCFlHduySHLQS57kS+XQrIUNAIyfOj4jMrIqVmHSIS9gtnre2V2l48By Mm2A== 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=K4BONn6rBYvZlYQkN77M+zhw1mX5XxmJwhe1VEK3aUI=; b=yf7SYvhzvspmjIqBViybON+9bKbQuiuFV7Gd5hBA7RafP89YP1FkMv86cFvtMW3cAD aiGhJiUkDdgtPgRpiHAA+5JbR+1cLn+GUOzTthhNsbv2qpYFCvibsjEYRMIG7o1v1MGt GuynMNpH3s3dy2rW6ClySm19wtC1FZavKHftwopQZJ4PpzRFRcctqCMgy3TFtFTjpTCB 0tt7JSBsw743yULeDdh+t7CH8DQVaeXhxthzppHoljlfbnX2iKWzqj4e3bCULdXcK8rV bk6lmvteXJNQutrxrzCWTPXGqRHmeIyYi33YusE393sEmJM/SpthpI4QjosTGPHN/mLf woIg== X-Gm-Message-State: AOAM530utQ2CnVKF9ZnnpuSXvL/fufrmeKgAnl8jpqtMQS4a+EhvjV6s kVW9iHhFSS5p73ugm3yHFDbJ2CWoIXVLwQ== X-Google-Smtp-Source: ABdhPJzR1qVKVh4og6IKnYDPWYTnq36Z6pElmS7doqscQ5T4PrjlB3u1+jEzU96qPW/SgUjloPekRw== X-Received: by 2002:a05:6000:18aa:: with SMTP id b10mr2692484wri.270.1634169995378; Wed, 13 Oct 2021 17:06:35 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id y8sm670711wmi.43.2021.10.13.17.06.34 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 13 Oct 2021 17:06: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 01/20] branch tests: test for errno propagating on failing read Date: Thu, 14 Oct 2021 02:06:13 +0200 Message-Id: X-Mailer: git-send-email 2.33.1.1346.g48288c3c089 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 | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/t/t3200-branch.sh b/t/t3200-branch.sh index e575ffb4ffb..b5242719159 100755 --- a/t/t3200-branch.sh +++ b/t/t3200-branch.sh @@ -731,6 +731,26 @@ 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 subdir && + + ( + cd subdir && + for d in refs objects packed-refs + do + rm -rf .git/$d && + ln -s ../../.git/$d .git/$d + done + ) && + git --git-dir subdir/.git/ branch rename-src && + git rev-parse rename-src >expect && + git --git-dir subdir/.git/ 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 Thu Oct 14 00:06: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: 12557545 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 F0FC0C433EF for ; Thu, 14 Oct 2021 00:06:42 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id D2BC96113B for ; Thu, 14 Oct 2021 00:06:42 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230072AbhJNAIp (ORCPT ); Wed, 13 Oct 2021 20:08:45 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42372 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229994AbhJNAIl (ORCPT ); Wed, 13 Oct 2021 20:08:41 -0400 Received: from mail-wr1-x42f.google.com (mail-wr1-x42f.google.com [IPv6:2a00:1450:4864:20::42f]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id B3FC5C061570 for ; Wed, 13 Oct 2021 17:06:37 -0700 (PDT) Received: by mail-wr1-x42f.google.com with SMTP id r7so13819394wrc.10 for ; Wed, 13 Oct 2021 17:06: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=CVh4a02a0MZJTqSJLkGG2ikpEvd5JeCFm3gR5JXQWcQ=; b=av97jK8uVZwmMlWBMi7xMfQzky+SLzpWJA8CRu8+NS2o0rr+JZZBNpN6YWTGD9h3LL a6NficbX9fKGC37l/MS80FPAp9/aMjiZlfGpTde/wo7ApN+CBP/7C7L8HukMoLPuagc/ O4wVI4J+j3k+sqeRDIUnS8J5jmFGWYzzFCcZLF33aYSEyrWH4vamTOWSMdUARVXfdxCa ZJa3jrrK98H/zjH14myHT8p0DtJz/yTDd2Hc886EXab8JQSUHbX9yBpI2QFGHQ1zdttO g9D7MYdy5ycAhRTr+cZY+AU5mcTmXJKTQuoZmlzkJxdPTPH7B8TPbE+NzKcsC1hIYf6/ tqdw== 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=CVh4a02a0MZJTqSJLkGG2ikpEvd5JeCFm3gR5JXQWcQ=; b=QVbWN+qiAREt/Yubt7NpxXK3aycLinuSVXw+F2MBC8NkNyk6s85Sf5I0m/QEXo72nM 7zQHgh0YGv7x9NfZuKoxXW/wIi289IDCgSoLVkUbXiCZb3ReVAVIBBgZ8swiOS2Uvjhu +0VByTm3Uuir0kPPSNyQjsEeWdBtgbrar0WLM2tIAP/7NvFVKS+quovO0putmGJRCG0J kRrWZd1bg0mWGwkf/gE0sppEkYjXu6VxW6gPgkSDwD2EKpbgqVjD3JCmToRf29KGqR0O TTm2+GqGKFFV70uk6nDXBZAXkx7832kxgGKgYw6c2GJoWLNlf4xeC+/RfGHDLOnMyCJY KPAQ== X-Gm-Message-State: AOAM533oyANnVhlk7Jbx+rmXPCQkANUrxNFozGpdxInQ+gz05EhtFRFF 2leFGA03wLPls9369qkWv5wockdQfuGklA== X-Google-Smtp-Source: ABdhPJyhmBKT7brKwRJeyAJyh7bXfrpjTsLQPLgKhDbe41YOhKYZaXRkvmcOmHpRDb3QSPiCmF05NA== X-Received: by 2002:adf:a4ca:: with SMTP id h10mr2742150wrb.28.1634169996084; Wed, 13 Oct 2021 17:06:36 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id y8sm670711wmi.43.2021.10.13.17.06.35 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 13 Oct 2021 17:06: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 02/20] refs API: add a version of refs_resolve_ref_unsafe() with "errno" Date: Thu, 14 Oct 2021 02:06:14 +0200 Message-Id: X-Mailer: git-send-email 2.33.1.1346.g48288c3c089 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 2166f37399d..46e3c785016 100644 --- a/refs.c +++ b/refs.c @@ -1678,17 +1678,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) @@ -1699,7 +1701,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; } @@ -1717,9 +1719,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) @@ -1730,9 +1735,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); @@ -1759,7 +1764,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; } @@ -1767,10 +1772,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 Thu Oct 14 00:06: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: 12557547 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 E39D1C433FE for ; Thu, 14 Oct 2021 00:06:43 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id CC03561152 for ; Thu, 14 Oct 2021 00:06:43 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230107AbhJNAIq (ORCPT ); Wed, 13 Oct 2021 20:08:46 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42378 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230007AbhJNAIm (ORCPT ); Wed, 13 Oct 2021 20:08:42 -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 6B5F9C061746 for ; Wed, 13 Oct 2021 17:06:38 -0700 (PDT) Received: by mail-wr1-x436.google.com with SMTP id o20so13858565wro.3 for ; Wed, 13 Oct 2021 17:06: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=Kl9dXg+E8VgirTawpUZoZT1wEwhd49b+/11me4RFFS4=; b=m+Zb4T3vz3si8Hli/cQcv4TRaDfzSiujh+0HERq37H0DD4mxt0Zr6tArbvbBngDsWb yfYdPV1sthGDTRBaneCNPzjFzuz1oa/1o8gX82xJupL6zVRrDTePMTI9T+bMHs1mHu5t sT1ssrXfNXnIwG9Y/dMS/+XOegwj9WekFAmos2rmu+vS32S9o/RFAi+TwZsTczLN1q/P O9t+i4sthNL8PfF2ptKDPTlj4kejqEXQ/FWifp5BFoILcXsmNBtJ/1XBjFOUmf2lV09G tD7ELRNqwtLxPCU5NmVe9r82Kt1BMZwLJnB0feRXxEJ36VdV13ZWvCX3Brul/oFBVw/M tfeQ== 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=Kl9dXg+E8VgirTawpUZoZT1wEwhd49b+/11me4RFFS4=; b=Qcm3Qqw2XucMiFULEtoR0k39zFJLdd+31m/J341IA3bd0R6LTUuq/4FGfqneGDlb4Z lQFctprO6xAWCSAM+esqj6UrfIcYJhDKeocedAe/IP9BfqXJz3fSFV5a4XdGcfNZdagi ++Gq7+u9rKmgeHltttXeC70Y9F5pJZJZCl7D/jGYOQuV6cIyPhS85lQONLhGUEJ1JPfr 8xU842HErw6dpPNIP2O/ZdYIOoclwGPbYSuhc4B434p+1qTE1lCrIELomj21aYTNV6GC 3J5YT81YZI0ReOehv7I1ti11kfSlULwf1PdBf91sHR/9tUPLlUKKVrIeuaYkSW6KZahj OETw== X-Gm-Message-State: AOAM531PG4SOCu1RH6Mpq+fr8noDAT8SVc+EMb7WDOohmT2Ym3RZWd1F cY0W35Ly17DHhhBLLPwQN1XYn74S5zR15A== X-Google-Smtp-Source: ABdhPJz7E4YGg4F0zdn/46OQGBqWIDqtWBUX6+5owYRGNn5JxWNisgOutASD12pOUITegeh/FfwEvA== X-Received: by 2002:a1c:9a4d:: with SMTP id c74mr2295505wme.139.1634169996805; Wed, 13 Oct 2021 17:06:36 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id y8sm670711wmi.43.2021.10.13.17.06.36 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 13 Oct 2021 17:06: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 03/20] refs API: make refs_read_raw_ref() not set errno Date: Thu, 14 Oct 2021 02:06:15 +0200 Message-Id: X-Mailer: git-send-email 2.33.1.1346.g48288c3c089 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 46e3c785016..acc5d5fa578 100644 --- a/refs.c +++ b/refs.c @@ -1665,17 +1665,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, @@ -1719,9 +1720,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; @@ -2239,6 +2239,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); @@ -2250,7 +2257,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 Thu Oct 14 00:06: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: 12557549 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 7C16BC433F5 for ; Thu, 14 Oct 2021 00:06:44 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 64D5461152 for ; Thu, 14 Oct 2021 00:06:44 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230119AbhJNAIr (ORCPT ); Wed, 13 Oct 2021 20:08:47 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42380 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229677AbhJNAIn (ORCPT ); Wed, 13 Oct 2021 20:08:43 -0400 Received: from mail-wr1-x42a.google.com (mail-wr1-x42a.google.com [IPv6:2a00:1450:4864:20::42a]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 35CADC061749 for ; Wed, 13 Oct 2021 17:06:39 -0700 (PDT) Received: by mail-wr1-x42a.google.com with SMTP id o20so13858630wro.3 for ; Wed, 13 Oct 2021 17:06: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=RuCoCy3aAtEK5argRboSpqI+1CTSCPfqbTNlqC3tJg0=; b=bzchS8x4Ilti/g0+jPyben9okUfP40/ju4OeIXMiLC/xJF7cjh+W3lFUW26xocvMSt tBzkrPWzJBojUZFcpFJOjzwjlTX36vvKuqilBXox9z6MgtlSBNFD35j9NrJgx/rOJEFg nLJ433aGDkWznNIemC0MZeEBK7Ls4Dut9TyUqJ9RhcdRgi6Xz/2mNS3rs00RTUX0hZcH YCAwxPInaaTjGSdGY6QtYRo+tF9NPzsHOfw2ImGlikR7h1iQbVuAEZ3Hq+BbT21o3zGf o/Qg0qNftkd8/4kIiUjClIli5x4gDJ77ijusxdhf8ojsL2HQf+rYQx9WGTt4LwAJ4DXO LSzQ== 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=RuCoCy3aAtEK5argRboSpqI+1CTSCPfqbTNlqC3tJg0=; b=P3tPDUGmVcMB65mC9KinXxxjj6CJ6wETOkVjho4E+WQ3ETNlopc186W/s9gkquuibH w9dqc8gvwkmqMyvVqcKlip+mysWa+t20Nqm1rRAvY3GneD22KG78JjJLX5VIK0+AikE+ INHNQ7fQ9IOXtotOoDEyzaB6L4lgwpQ7R2a2a1jYrFK5WtrVAnFYD2bndmRfvK1v9qqe RE1H3UNOK5mZw+UrY+JgFn2K4eRoG+ZWjFTD1yoq7QU5QRWdaGMNKw6apZYU++V5f1Rh QjrsJJOageUVe8ucza0R2wVo9qRUrczAysr6FmXL9r3pxIqVFCq/0xcgGB22i8VPXfYC EEBw== X-Gm-Message-State: AOAM532XbEOjfGvxTaKFT6pULBJ4AoRkcsGDCqGo71v4k1gr+4lKsThm zIZj5tbRfUtGgZtmCvYY9naExG0rnpC1cA== X-Google-Smtp-Source: ABdhPJxKpQPX7ZNEFz9y9B09KAGVIH5Wf+kkVDHJXnK9qPfwSd9ZSWb76qFeo4DXlKDX4NiW7wfWcA== X-Received: by 2002:a5d:45c9:: with SMTP id b9mr2592691wrs.365.1634169997505; Wed, 13 Oct 2021 17:06:37 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id y8sm670711wmi.43.2021.10.13.17.06.36 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 13 Oct 2021 17:06: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 04/20] refs API: make parse_loose_ref_contents() not set errno Date: Thu, 14 Oct 2021 02:06:16 +0200 Message-Id: X-Mailer: git-send-email 2.33.1.1346.g48288c3c089 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 ++++-- t/t3200-branch.sh | 1 + 4 files changed, 30 insertions(+), 16 deletions(-) diff --git a/refs.c b/refs.c index acc5d5fa578..b1640b5d582 100644 --- a/refs.c +++ b/refs.c @@ -1647,7 +1647,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; @@ -1657,7 +1658,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); @@ -1672,7 +1674,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 diff --git a/t/t3200-branch.sh b/t/t3200-branch.sh index b5242719159..7486688d292 100755 --- a/t/t3200-branch.sh +++ b/t/t3200-branch.sh @@ -745,6 +745,7 @@ test_expect_success SYMLINKS 'git branch -m with symlinked .git/refs' ' ) && git --git-dir subdir/.git/ branch rename-src && git rev-parse rename-src >expect && + # Tests a BUG() assertion in files_read_raw_ref() git --git-dir subdir/.git/ branch -m rename-src rename-dest && git rev-parse rename-dest >actual && test_cmp expect actual && From patchwork Thu Oct 14 00:06: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: 12557551 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 A7FF8C433EF for ; Thu, 14 Oct 2021 00:06:46 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 89AF361152 for ; Thu, 14 Oct 2021 00:06:46 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230129AbhJNAIs (ORCPT ); Wed, 13 Oct 2021 20:08:48 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42378 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230023AbhJNAIo (ORCPT ); Wed, 13 Oct 2021 20:08:44 -0400 Received: from mail-wr1-x42f.google.com (mail-wr1-x42f.google.com [IPv6:2a00:1450:4864:20::42f]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 1BC61C061570 for ; Wed, 13 Oct 2021 17:06:40 -0700 (PDT) Received: by mail-wr1-x42f.google.com with SMTP id g25so13837706wrb.2 for ; Wed, 13 Oct 2021 17:06: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=wfy+L0Ju34ELGxinFhgtLc8GWe2ePSbl6YjaNh7zGeM=; b=cnif7kEM82dJLLfV3bM78uquPt0AEWezA6LdBF459YXS3ef61aKbl/m+aQzpf4qZQS fIdseCA4nhuXu0LR258pkqtqzzKqL0sUwQkWJmvFbTYuUf7KfwLu1G6T3za1z/puC7wi VHh/kfDjM7f/ENUg8yFU8S445u4X4eLaI1QjvAOAIs5TlCqsi7Ob+DTGT33DeWyy2BLn WbQWQEdT132hfeV9slgzsWiCxCvnJAQuTXoj3rHlhI24q/0b+P6ubduW1uEJrkI7tXmX tmnH0INjs3EGWg3MSoAkUZUyu6lch68p8+KytgnOfJu1EFSJs1al/UmEn73USoyq84ep jskA== 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=wfy+L0Ju34ELGxinFhgtLc8GWe2ePSbl6YjaNh7zGeM=; b=LVpROZyiFwyK3xu9d25CPVDtuWlNbK5yNpW3tYXfgW749ZwPouLnIHGnpmiI3BHPVN y1aOPjGVe+6uw1dodsOMWY3OEnStSO1RGDi1/KJPEtE92azhsmVVwLAREUsZj1cWuofF v6kb/9FwTP69UDyFMf7azOIxZ6C5vsY+au86yJKAk2FWE7PEh29YQSiuWGpkpSCZRbZR Jgl/QDmkOm91Jw0HePX6XxgHDpt+Jn33bcqgDoX0zGQQNFgKVgkcbCOHNRKEhu1DdHlQ hLux4+luPGKHn0ufXCBTiph8VuBcTxtWWOPGvVFLEL0OFJ7guxdk9+dZtG+Dfk8fTaY5 x3NA== X-Gm-Message-State: AOAM533Wfz0mblRel4ZcPZ78JJqlxp/VjsDpdDEsokfW5nfEwnYPtXzO bP3XAK3R7q6GJs15tH48M/AUsxdPVB9pwA== X-Google-Smtp-Source: ABdhPJz+gRCfasqbNTctFSugDnXG6a4seIscs66pvZUJMT1LEuqtEEZZW0fsagSw9trJ8d8FWiUfEQ== X-Received: by 2002:adf:cf04:: with SMTP id o4mr2680504wrj.129.1634169998503; Wed, 13 Oct 2021 17:06:38 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id y8sm670711wmi.43.2021.10.13.17.06.37 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 13 Oct 2021 17:06: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 05/20] refs API: make refs_rename_ref_available() static Date: Thu, 14 Oct 2021 02:06:17 +0200 Message-Id: X-Mailer: git-send-email 2.33.1.1346.g48288c3c089 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 b1640b5d582..4398a4c0257 100644 --- a/refs.c +++ b/refs.c @@ -1371,25 +1371,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 Thu Oct 14 00:06: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: 12557553 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 347DFC433F5 for ; Thu, 14 Oct 2021 00:06:47 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 1C65C61164 for ; Thu, 14 Oct 2021 00:06:47 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230153AbhJNAIu (ORCPT ); Wed, 13 Oct 2021 20:08:50 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42392 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230063AbhJNAIp (ORCPT ); Wed, 13 Oct 2021 20:08:45 -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 E63E7C061760 for ; Wed, 13 Oct 2021 17:06:40 -0700 (PDT) Received: by mail-wr1-x431.google.com with SMTP id v17so13749749wrv.9 for ; Wed, 13 Oct 2021 17:06: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=+9KQ3D0B6zButhuTSLtZuiZ/+JQO65I/xGCF1uYoJYE=; b=RH9l/U7sM9duHMhndm4vehUy2sVDoymkBtY5dcH+Y4AOUyyT1a2C/z0h3VLxGHrmFx PpE63r2uQ/V0pLMXLfWxYaj+Z2Um2WRRYkNNv1LuWADMY1tLCLaVkh8Hnt7rNP3RM1sh TkYi+RHrAXMU75H6n+XFr7XLtyLps5wpNwXiuCESVeucRfjRStfT5fUgpavzl1TRXQOv KtcTnqWikg1Zz+pZMXhTGTkg529S5iR+O3gOd/UXIVrMJlXeev/bO+dW/sIMBlEnB+5J ocexUpgL66+NMNm1z37zoyx0siIVH9IAGt489XF1blMDEXICQpT0FeHEcEwIX66LBf4H 1lhA== 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=+9KQ3D0B6zButhuTSLtZuiZ/+JQO65I/xGCF1uYoJYE=; b=Omqfxn5WgepFatmsshG5eic1MFoK3VlzIgGS7W3x1mXkSU2Kz5ha+EkqMQKY8e4IWg JQoc3ymh8Xej2WS4k0lnISnV8JpEFKNMjIlzORcZxz5triHD49RXqlYa0A4d2hA/8db7 AjYSvquubrgJEzAJj3owtyo058RYwOblf2ourXe1kUVXeWCkxsmLQ7RsECG8ApmyiS31 l6iV+Y/liYWc1NETzm0+IT2pSbXLj/XLI9UrnAvRNU/sw3H2xMUt8g20j11XWCqRrHjy HyGC1mhtDkTwxUCTytpDSlHmyFX+w2bKmy0OBvlSoGDtQfD53nUPUIZtz74bQvDglHkn C8gA== X-Gm-Message-State: AOAM530uYv4CwkX6Ou75HSnj1XxnSIEWIK+Jdl3LFFAH+tDX6RHlPQes OLkNvTulmMX0Em4hWFNEswp31+UMaxOnAQ== X-Google-Smtp-Source: ABdhPJz/5UAsWqbrGBPxIJU80bP+3hHqGjb98Q6OOHS5GePxGuHnVM3NmUv+CM0nySVGYSA8fu78Pg== X-Received: by 2002:a1c:4b16:: with SMTP id y22mr16005292wma.73.1634169999276; Wed, 13 Oct 2021 17:06:39 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id y8sm670711wmi.43.2021.10.13.17.06.38 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 13 Oct 2021 17:06: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 06/20] refs/files: remove "name exist?" check in lock_ref_oid_basic() Date: Thu, 14 Oct 2021 02:06:18 +0200 Message-Id: X-Mailer: git-send-email 2.33.1.1346.g48288c3c089 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 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. Signed-off-by: Ævar Arnfjörð Bjarmason --- refs/files-backend.c | 20 +++++--------------- 1 file changed, 5 insertions(+), 15 deletions(-) diff --git a/refs/files-backend.c b/refs/files-backend.c index 0af6ee44552..0dd21b2e205 100644 --- a/refs/files-backend.c +++ b/refs/files-backend.c @@ -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, From patchwork Thu Oct 14 00:06: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: 12557555 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 33306C433F5 for ; Thu, 14 Oct 2021 00:06:50 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 0EDBC61152 for ; Thu, 14 Oct 2021 00:06:50 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230219AbhJNAIx (ORCPT ); Wed, 13 Oct 2021 20:08:53 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42380 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230076AbhJNAIq (ORCPT ); Wed, 13 Oct 2021 20:08:46 -0400 Received: from mail-wr1-x42d.google.com (mail-wr1-x42d.google.com [IPv6:2a00:1450:4864:20::42d]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 0D1C8C061762 for ; Wed, 13 Oct 2021 17:06:42 -0700 (PDT) Received: by mail-wr1-x42d.google.com with SMTP id y3so13898399wrl.1 for ; Wed, 13 Oct 2021 17:06: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=wlVV4fD+PH9il3n0J4FiOSuaE+1vZj6vgZjihvx9yL0=; b=dIbuVac1S6N6CG/yERvOJgGaxz9Enkrauabpdd46Bxfx5PTVsM+mOXdNOxMu4B2L6r EMrTc9lKaM5mJgTTXSe8aL0p1xY/iVn8aS442Kv2K9Z/ciX52MBg1uh9w2H1DXeXHKnr K4qbBUtKF7n6tyyAIJK/uhlTvxruWcjpUOX/+6V8raWaXTL8AejQxV83Mhj+xrWlcFQC l+R9nCv+SZz4gZL+ZafikOM7eiCSBmZLss8YfDxIZSKJ7i7nmg+50eHqr2E95UW9Bg6C MfkbG60p6ljXrh8uKUBtOaaJxC7eYsoGRbEsPtqV/geAxlh6gFfGAff8eAit1KspM2X/ doSg== 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=wlVV4fD+PH9il3n0J4FiOSuaE+1vZj6vgZjihvx9yL0=; b=jzDywBvv9T0FaQf5y8eIx5ef67N8ujdfb8sniRDa6cmyFwnjBZRAOijOe6B08cgYD+ 2plsIq8zd7A4vNONcGii+oS6SMSOIvSnhQMjS1mmcDbp3lc4kq5HmJ9of+W2TMl3TbJr AvunWjyK4tEFK9Y1L0KQikDK16oWo9VKSuVbl1Nwu+DauePrXf0cRrMFvcOUTwO6HUpK IC2PsRxUirhX+l8+vyjhbZU1LpGNv7DnMUEXJLhSKwkzEcD2y0UGtKpNw63/feBqVcnJ LPsp3G0RtSyNkkbK+IBah68hVd/CZobCLSpA9JQhxmKZrZsK5r3TciDral6K2k34Quf3 SCvw== X-Gm-Message-State: AOAM533Gs2DL7Cs7ty3LYRtJLN4X0fbjYXahmEinjfFr9wLYAk+x/Kby J9QBwtsTj16brilp632O62FEsF37jBOI0g== X-Google-Smtp-Source: ABdhPJzaZzzIaL3+vwmAJiGHDNYd2nz5qgfBzmyXEW6F1DZEJQ4+Rx8vVtByRn3YT8xn4temClFcNA== X-Received: by 2002:adf:bb93:: with SMTP id q19mr2722493wrg.423.1634170000039; Wed, 13 Oct 2021 17:06:40 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id y8sm670711wmi.43.2021.10.13.17.06.39 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 13 Oct 2021 17:06: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 07/20] refs API: remove refs_read_ref_full() wrapper Date: Thu, 14 Oct 2021 02:06:19 +0200 Message-Id: X-Mailer: git-send-email 2.33.1.1346.g48288c3c089 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 4398a4c0257..08101a13318 100644 --- a/refs.c +++ b/refs.c @@ -289,20 +289,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); @@ -1375,9 +1372,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 0dd21b2e205..be27823d099 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 Thu Oct 14 00:06: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: 12557557 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 B1082C433FE for ; Thu, 14 Oct 2021 00:06:51 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 96A2161164 for ; Thu, 14 Oct 2021 00:06:51 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230245AbhJNAIx (ORCPT ); Wed, 13 Oct 2021 20:08:53 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42404 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230109AbhJNAIq (ORCPT ); Wed, 13 Oct 2021 20:08:46 -0400 Received: from mail-wr1-x42f.google.com (mail-wr1-x42f.google.com [IPv6:2a00:1450:4864:20::42f]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id B54E1C061570 for ; Wed, 13 Oct 2021 17:06:42 -0700 (PDT) Received: by mail-wr1-x42f.google.com with SMTP id r10so13703614wra.12 for ; Wed, 13 Oct 2021 17:06: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=eSMzc+cuX/2Zad5LAVhzbvvAM3bkvavdRPxJJTEKn+0=; b=bRaD6MGKfSrRJL8qmGa4IGU8Dzo9HgNJcgIn/GWQptJnvmarbQWyECn0Ul2iqLsIMd 5wVVD6m+AQ8tId+CMYVetmUvuSyEItLiLoAjN4aGp/yF2SW0KcNK7BwrzOP9wAMuqkYx Mo95XLI+ehcTg3+Ta8txcgHiS8VbhgiKG6Him8/XeEOiAOkJ579yXUiYukoUKoWdDdoN M1YA8uatJ+wlN7wq4cdCuoazUwWa7QOC5f+f8YVCKw1H4bpTI/uvBBjLrMqAIh3j25Du YLfXBYTLl6c9sLCjYx6uf0Yar3MOtdy5P4sAOlbOtQGE5sloUUYrOuMmJcoCkYsf6f81 MJhA== 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=eSMzc+cuX/2Zad5LAVhzbvvAM3bkvavdRPxJJTEKn+0=; b=oWPsalCnURDYaIv1ybQ3ANz23rUW7n12EArPU33Vn7Hjg2pP2qOhUvSA/dfkKu18sP GnC4tiWfaM6PO0DGSQxMrSpR+wFnScxrpqIFC9VwF7hdiy1DDZl8pHe3VsndwjngQdtp ZgnPZcXGR6R7QtwavUbj7qNHcE7QOF6TqbUGOqP7gQ4qaaWFGUWWLZ+rZF6FHVU+y9/s bn5jm489VZ3caPfE33uGghZ/M6pMUrp0+4iKkYm5xIw5FAQFmIIuJw5VOw5IKQuRaTnV yyLXNKcyQIfrEhirIGq/dsYbuFZ/Q8YO1hdDZyxqLQaDD0p0QnrdrCSNzUM7HqtIFLCO M57A== X-Gm-Message-State: AOAM530ePLzKy+jy2356hikQjqPvF61yZhvUOQecwAg/7cR/SG0VN4LA jvFthmmj7LXB1XSYTnw0NE7lsUv/V9jTGg== X-Google-Smtp-Source: ABdhPJxQBddc2fmdtsif3LvXx48sMjAi9lfNfMHhepVr+9qsKOrh5Ktmg2kIy4/FjXW5lrkwRrfNjg== X-Received: by 2002:adf:aad7:: with SMTP id i23mr2590946wrc.209.1634170000883; Wed, 13 Oct 2021 17:06:40 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id y8sm670711wmi.43.2021.10.13.17.06.40 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 13 Oct 2021 17:06: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 08/20] refs API: make resolve_gitlink_ref() not set errno Date: Thu, 14 Oct 2021 02:06:20 +0200 Message-Id: X-Mailer: git-send-email 2.33.1.1346.g48288c3c089 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 08101a13318..001f54845a7 100644 --- a/refs.c +++ b/refs.c @@ -1790,14 +1790,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 Thu Oct 14 00:06: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: 12557559 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 4F268C433EF for ; Thu, 14 Oct 2021 00:06:54 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id C663361164 for ; Thu, 14 Oct 2021 00:06:53 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230260AbhJNAI4 (ORCPT ); Wed, 13 Oct 2021 20:08:56 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42406 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230007AbhJNAIr (ORCPT ); Wed, 13 Oct 2021 20:08:47 -0400 Received: from mail-wr1-x434.google.com (mail-wr1-x434.google.com [IPv6:2a00:1450:4864:20::434]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 2A165C061749 for ; Wed, 13 Oct 2021 17:06:43 -0700 (PDT) Received: by mail-wr1-x434.google.com with SMTP id i12so13777010wrb.7 for ; Wed, 13 Oct 2021 17:06: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=bxgX/gVIYLs66RMlG4oKqiflJASBIdu+81T4D7md82U=; b=QJNgNSENrTeY4KKZrKM0JHVdfbkq8jczW0bf55KnLkAJ6MqkXqcHuTG57mj7Dve1is vljweWgjlYURIhTxnO8zdl/XFqz9QfuOQ5uAK7/PAE7G2t+og6z71/bVkohbenqcwXbs ZptvqKwca0+1qwS0hVATOgLdKsX+++Bxq4lN8t6zT+YV14MzDjpRXX+LHD1C7rYQWN04 h5AbbgK8TTS2dj8cebuanvC6LNy+WBB4N7fkIhTn13H+ASh/zoG8cOeWwOlvNOOD13Z+ z5IENFW7Uhk+tNLD6dhn0mcIAWyCZ1H9KOuEtJ8oNSU3j8tXOaIYXyKOmCcoumAG/7bt OtbQ== 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=bxgX/gVIYLs66RMlG4oKqiflJASBIdu+81T4D7md82U=; b=tAXrFA36Y25mXhgJ3H4kC//5cOy9cND1+T20+l2Hf2Ut3ior6QgvYOuFX5w9SwSmKr C0EIygq3QKapu3as/oFU9fr0meYVgE5G9jzP5acFlVKfUdMG1hJ18ncaauGiV0CVgEZj ZuFP/OHuWD5Gu/chF+FMmGq0DwoTm97716bJA3+IioCHHo65uVCpBOvYBonT33PPmTln 7iVzioquLgQJ1uMytavpqzyW1fAc1n/eboBaUqRSiXsFvVZkqFHfRU2U2/hnybn6ixOu r0ejey3NA0NINz6CXi4bEQJ0YUmjE2gBT/RN3oZGLKewVFX0fPMwRYbHBhEyCu3FzkjY A6Fg== X-Gm-Message-State: AOAM532BdfCymuV0uxuKEiPrMLYFNfFAl3tEcvDf4QeEg4F00Jt+3HP3 NS6jpAI7wAT3TAs+HqL/JxuhjnnUUJ6n9g== X-Google-Smtp-Source: ABdhPJwvC2siMZEPUzCYKirUE4UbLb1uqR5Schasz9N5/qNUVRdtsGq2unNw0DDCNCEg3TOVeMmjjw== X-Received: by 2002:a1c:2b85:: with SMTP id r127mr16022432wmr.134.1634170001578; Wed, 13 Oct 2021 17:06:41 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id y8sm670711wmi.43.2021.10.13.17.06.40 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 13 Oct 2021 17:06: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 09/20] refs API: make loose_fill_ref_dir() not set errno Date: Thu, 14 Oct 2021 02:06:21 +0200 Message-Id: X-Mailer: git-send-email 2.33.1.1346.g48288c3c089 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 be27823d099..1d27f915638 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 Thu Oct 14 00:06: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: 12557561 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 BAC43C433FE for ; Thu, 14 Oct 2021 00:06:54 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id A2B1D61152 for ; Thu, 14 Oct 2021 00:06:54 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230281AbhJNAI5 (ORCPT ); Wed, 13 Oct 2021 20:08:57 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42390 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229677AbhJNAIr (ORCPT ); Wed, 13 Oct 2021 20:08:47 -0400 Received: from mail-wr1-x42f.google.com (mail-wr1-x42f.google.com [IPv6:2a00:1450:4864:20::42f]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id DEA76C061765 for ; Wed, 13 Oct 2021 17:06:43 -0700 (PDT) Received: by mail-wr1-x42f.google.com with SMTP id e12so13821211wra.4 for ; Wed, 13 Oct 2021 17:06: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=oY5wmqqFAoPPkDO+3Qk5K1rXb2KC11EZfFtbk/XIqZw=; b=fdM5Ym1OOoxf7flgxJiAtSRn/JABmQi9F5x1Oro4Q2bqJ/+XrzaLej8MYJz3lLDfQB qaov2SqBiwg7qZaS8Tj04Q138OoQHwwfnp3N2U65TP7k/iLJcd7rvM+0PbdyIZSdjMEz ae8JcdeZlI+/R1hgDutMvNCAhQtu364xtwHIhZCLD++55oVadJONxZkToLEJWXjss5FG bChprPJxbKN0pJFKjE/N6X8ytJPhyjS8JrxcMhkCSrCfHYOhfCSP5AHD0f8WR9+H4JQD HbwKUz3PdvXu2K6gIIA31OVAqPWTEGZYoND6CI/JrTlBxrU00fxq7iS9yltKGi7IJ7CU Pm6A== 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=oY5wmqqFAoPPkDO+3Qk5K1rXb2KC11EZfFtbk/XIqZw=; b=LZc/5u8B1q0ZUgI/aT+6/RP0rssxONAqwjzx0lyhmDYHl4uZua+CWvKnbs1tx3arLQ 6/XGuMJ16L3Mldm6EVloWu2mdsu2h5xFsSN7ENz51iTE3Pt12ZbOk+nitbCNTio0oPvP Vv2StVvqNUvXmREPdwnkpcxQb0/yFn9Q01F2O2QJy4ERC0PC7fhOXIGV+xCwbqtiBCfi rlfVXL3FlW5XvmDLzRUTRl1Q4NiivYsMzOY1YCdCWPUDkeZCekkM7mdwHtwzPPiJTu53 wkJzxsaTDEn9Umj/1jGtyCiVo3ldl4urHAQv4hOjO3Z0/LbiileooG3ga2AGTDZriEWe 60ng== X-Gm-Message-State: AOAM531SBZhxABcl9J61jZ7iX50aLD3Ni3N2RwKnHPsmUHh5F6CWVUoN y30qRWMEg+lmfSVxuzOgrlZF21nI+spZIw== X-Google-Smtp-Source: ABdhPJx2EIOYqPB7849daq4uZMkTwDhZoP7d8nHdgoPPXzk4I+rkrFd57zC/KUahwLKsUtWhAxS4zg== X-Received: by 2002:a05:6000:18cf:: with SMTP id w15mr2644170wrq.314.1634170002245; Wed, 13 Oct 2021 17:06:42 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id y8sm670711wmi.43.2021.10.13.17.06.41 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 13 Oct 2021 17:06: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 10/20] refs API: make files_copy_or_rename_ref() et al not set errno Date: Thu, 14 Oct 2021 02:06:22 +0200 Message-Id: X-Mailer: git-send-email 2.33.1.1346.g48288c3c089 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 1d27f915638..b3d4544dcf0 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 Thu Oct 14 00:06: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: 12557563 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 6A18AC433F5 for ; Thu, 14 Oct 2021 00:06:55 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 56AC5611AD for ; Thu, 14 Oct 2021 00:06:55 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230290AbhJNAI6 (ORCPT ); Wed, 13 Oct 2021 20:08:58 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42416 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230137AbhJNAIs (ORCPT ); Wed, 13 Oct 2021 20:08:48 -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 8BEBCC061766 for ; Wed, 13 Oct 2021 17:06:44 -0700 (PDT) Received: by mail-wr1-x431.google.com with SMTP id e12so13821299wra.4 for ; Wed, 13 Oct 2021 17:06: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=6WYqeyardRFERObpiiRjNvb8/9ZqvqzS9Ne9z87LDwI=; b=Jxzlg7gVZFej2zUoG4HDMFdeF7G62bstoVWfYI9Xdblsng3/Js/qa3LGyYYuu4TjG0 OixgYXTNITISvbYlCM3O9kM23/2QjElETcaC5msjV7l1DOCp4BZS8IM1SrBR5N+thT0U ov6WYxzDp+uRJUkk1RtmjzxqBDyYuePzHjLtdnrRYrxd8WPnG/maJKTjdeJVhrNo/9Tm SCGZmSoOGKH0ilrnLfjHvBapMBFYcDpIjfiwZ5MEdronahyS9h7Wp2fNVDJuz2+pxvVF O+p9TQ+TgNMM7r/S9gYd9gJZ5qzwe0YnMgHU+qUWrVaWAGzwRLaHdD9K9Y0JTIo9bHNs v4mA== 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=6WYqeyardRFERObpiiRjNvb8/9ZqvqzS9Ne9z87LDwI=; b=pkYVnx1HYV83IBnOzKWVAa09vogXYglUwAvCUlDA3z5RMujX+vE5ZnBBXTPNuYkXs3 w58rJReuF4M+eUCS5ECtjs8pwJQ8RDW3QzehIDKi0ICZOFemC9ZWNhtod+83c4oPE+d5 jFAw+UAQl0TGZ4KajQzcUbqay4PP/oA5/87mni8ZY6dR7oN71eQtqAvNYostdwuD7JHs djnnkNDSuiVlmOa1bUwJi6T7srZAAH2Y2UQM92FlnRmVMItgCJrzoAp97saiT775tCrs aGnG2bnQN7PD3TSliTEro9RjQIDCw4ZRX4ssBhEGrS6+FW7JeXXnkYdr4Wiex0CF6pSO bTag== X-Gm-Message-State: AOAM532s4XQRVwRjlI61Rj0nO+nG/lO0wnlfPQMuIYDBKzFQ9phB87sm LCjWqzawEvFSMY93W9Ge2hfHIoa7stUKPQ== X-Google-Smtp-Source: ABdhPJxSqB7CbU1pf5l5AfiwDNwrAVubWuF+/IsMzAMaIL5weGVg9AfMFoTp9yXeCnhQZCCo5gQWkw== X-Received: by 2002:adf:a4d5:: with SMTP id h21mr2614920wrb.203.1634170002948; Wed, 13 Oct 2021 17:06:42 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id y8sm670711wmi.43.2021.10.13.17.06.42 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 13 Oct 2021 17:06: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 11/20] refs API: ignore errno in worktree.c's add_head_info() Date: Thu, 14 Oct 2021 02:06:23 +0200 Message-Id: X-Mailer: git-send-email 2.33.1.1346.g48288c3c089 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 Thu Oct 14 00:06: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: 12557565 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 CCCD6C433EF for ; Thu, 14 Oct 2021 00:07:01 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id B3B2161152 for ; Thu, 14 Oct 2021 00:07:01 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230341AbhJNAJE (ORCPT ); Wed, 13 Oct 2021 20:09:04 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42398 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230185AbhJNAIw (ORCPT ); Wed, 13 Oct 2021 20:08:52 -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 700A4C06176C for ; Wed, 13 Oct 2021 17:06:45 -0700 (PDT) Received: by mail-wr1-x431.google.com with SMTP id r7so13820063wrc.10 for ; Wed, 13 Oct 2021 17:06: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=GA+RHp46ay6iCXjwSgGrKy9Rll3MkBt+CEWq4husYJg=; b=BlvH1GCYtDtfMjMBP+bmwrpFr7siu/kJb5IW0vPMIp8eLRPb0iYyeytZEFVtbKPWCu QpzNLHwsf6xuTJioH9IB4Rg5D2wYrBdl5GEejJNd8wrbau522Co5IXUSGIrPF63ThZAz qCF+LMAZEbxA0vFLCLURNOeI/bZIrLZ1TbqWOTOkrzdpEOqUF4RagNwcEqHxoNq/xD2P m/u6a/AjMtH2cR+OQMfGfJqzzQVYYoBUKtUVfh60bRo1K27tNju5N5wFBbmL9PFRivgQ Z/UzRAlcCiL29vK+/tdpLjMAbDKOzgP8r+TiFTH+VSsracR2hrL/HMEBzBSdxr7Vepua ewgg== 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=GA+RHp46ay6iCXjwSgGrKy9Rll3MkBt+CEWq4husYJg=; b=Di0T6M9Ic6EI/M2ZEfroR1mF9SQq9lsBh06uTamzUHpXVmEcnTS9eIa9xtBeL8C3Xu tuEbUCB5LGdRWA5H0qyaDaep8tYc/EBemW5nbb3ILK9em46AZImpO3xbv54MQVpgg4ed 3IiMHexbs7UXjThBW/0e/B7lVYFCuJFZJb1d6gNmm3s0qUwYmKw1/jUddNk/YAUD86a7 Dul1IBUc49BGo4CKj+zgvMBeckNG6USm1IWn6j0dbdSIljJB5+jp4568GdBL3bI0YoAS fUOV2HPmkU6tyZM71jzl4LX2w1LwG6hhnS+WTu8jP2YjHM4h6PFMelRpNLPuekhbnk1k JmBQ== X-Gm-Message-State: AOAM530tyLHvlEAj6kHHPsH8SWNPE5J9Uw2kDzKhap/crcI2PaTBpJ2B Ap3r9ZCZTVhBzQYNTVlqRGNHKnUVXrgvTw== X-Google-Smtp-Source: ABdhPJwdmh7C5SbZ/MOM/zepZI5lgM9uBTOGmRzMcRKVFIJ4Xe7IstWwQkaeP8PeZZ/W0G32TKXWsA== X-Received: by 2002:adf:a347:: with SMTP id d7mr2724174wrb.139.1634170003685; Wed, 13 Oct 2021 17:06:43 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id y8sm670711wmi.43.2021.10.13.17.06.42 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 13 Oct 2021 17:06: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 12/20] refs API: ignore errno in worktree.c's find_shared_symref() Date: Thu, 14 Oct 2021 02:06:24 +0200 Message-Id: X-Mailer: git-send-email 2.33.1.1346.g48288c3c089 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 Thu Oct 14 00:06: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: 12557569 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 BF2D1C433EF for ; Thu, 14 Oct 2021 00:07:08 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 9E1B961130 for ; Thu, 14 Oct 2021 00:07:08 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230369AbhJNAJI (ORCPT ); Wed, 13 Oct 2021 20:09:08 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42404 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230201AbhJNAIw (ORCPT ); Wed, 13 Oct 2021 20:08:52 -0400 Received: from mail-wr1-x430.google.com (mail-wr1-x430.google.com [IPv6:2a00:1450:4864:20::430]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id E4C7CC06176F for ; Wed, 13 Oct 2021 17:06:45 -0700 (PDT) Received: by mail-wr1-x430.google.com with SMTP id m22so13967537wrb.0 for ; Wed, 13 Oct 2021 17:06: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=0Jb7ESRNUDqbmp+WOVWaLABeIGo2jgSgvBcuodkix7A=; b=pPi1nD5t4asUpep69HIkGuFKckINCSlRVnZEOSYqtKjk+9HB0kNbnEcE5lM0EwfD9U WXxe7+3u54Ev6oQkc1859MW0kSDhYdePH6M0e+I34A15SGFaZTzPB6wItd0YS4ByTLin QN/tc7XVZcZXvxNR757xNTR9tIolWcZND9De/ve4foJZY0gBc+Pc/JH+4rmedDT2N372 rSTrFuXHiIL+tHcKFPGs3SR6rUgaIbmU0vq7kjq2p9FWRyipwdbyVLLWAa6eRJjhZZFl 0i9Xkd0XzFJ0x6aNgxSZSQ8Iacmqkx8bwC/mGrtpxypvbFqMkl+s42PdQg7Kgk+avZmy v71A== 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=0Jb7ESRNUDqbmp+WOVWaLABeIGo2jgSgvBcuodkix7A=; b=Ftsk0mDnxsTSHlkLiKre5IokCic/A9DL+imZGWJpFAre79mi5z+mHI8FRuErxiURbh lWglaHiEDMoXorkCSGdoyW74MVTx7HlG/Zmpu3tKVQ/BdgvNbBs6K6pJY6L/choaJiCk pAUrWbnG9g0xdXcGjkxTW75XgJkmjtSLIaVtZYbzGRj0sa/m0ZtlcCfqrSSaAVctsZSt V4ZT9sf2GhivF+8n89/kz5KQNYHF/w3ydny0DL/3EXIqQag1rHTT6HoZYVqncQ4cm+Dd NpoY5OmSHGUABNl8YvxOInPxFlgJz1Ym1HujVM9JSC6xtezLOdkyc5LkUrRcZXOp5hAj xjLw== X-Gm-Message-State: AOAM532r/aIpGwexjahYOFP+MkIb6z2lqmlP0bPTa0X2O/xzYhvMQGjR p6gvrP9RPF54hfHCLbImF4LQeC8RpPnVbQ== X-Google-Smtp-Source: ABdhPJzkhPfXf14Rfwhxhkm9wiZUuV4K42sj7b7O2leNzAraFFvOnAxtzmtuouXr5vkmsMtUayz+Wg== X-Received: by 2002:a05:600c:21cc:: with SMTP id x12mr7664038wmj.8.1634170004321; Wed, 13 Oct 2021 17:06:44 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id y8sm670711wmi.43.2021.10.13.17.06.43 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 13 Oct 2021 17:06: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 13/20] refs tests: ignore ignore errno in test-ref-store helper Date: Thu, 14 Oct 2021 02:06:25 +0200 Message-Id: X-Mailer: git-send-email 2.33.1.1346.g48288c3c089 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 Thu Oct 14 00:06: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: 12557567 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 E31EBC433FE for ; Thu, 14 Oct 2021 00:07:02 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id CAE5B6113B for ; Thu, 14 Oct 2021 00:07:02 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230176AbhJNAJF (ORCPT ); Wed, 13 Oct 2021 20:09:05 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42446 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230014AbhJNAIx (ORCPT ); Wed, 13 Oct 2021 20:08:53 -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 9CAB1C061775 for ; Wed, 13 Oct 2021 17:06:46 -0700 (PDT) Received: by mail-wr1-x42c.google.com with SMTP id r18so13822935wrg.6 for ; Wed, 13 Oct 2021 17:06: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=ivS5BuUXx6xI3vzfLGCUk6QPCf7Z5o0K9/GWjz7Pkuo=; b=cqklIL85clIFbVstdO+SGenSW5Vx8qXXk0ro6cIyyFluuCcxHzF2W+wg1ezLZoSL0T bAlh2oi/v2X1DxSkP9wIHwIPWrg7QawETCJkTWe+viqEkhQ2VyZ4+m/jZR+v0pf2RPjr ZRsDBysjEEVh3S8KisXtn1+6t3cyYn6ZBBwgcSvSMmqJZSHKpoyuXTdy/6UCrpiEEZPU HukOS6ZjIsYwOzesz0lz4z5E9fZnxgjzclL9JRmE1zi25RxmTgb3VBbYcbhLHPgayS7O LOy5/STXT31+nGyj0FFayF6AJg+RwyzAOLOJ6Soze7y1+wC9RlKa2aS480xPG9BSbk9Q f93w== 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=ivS5BuUXx6xI3vzfLGCUk6QPCf7Z5o0K9/GWjz7Pkuo=; b=nnC93uNR5BCY8qBsRT0Nr6i1XhPQd6W/4b7Bqek3c+3f0Eq+18DV6FSlNoWjTBtjJY sWElzN/E8Opk8+mOhPMxWyRrEyZSOrZJQ2k/P2jYXsa70thGD3eofaaKqkl4RoTvbMU3 P7lRsSsGNhuvV6GhEtkf1gvfnnqE0Mkbww8wmVKDWCfRCoj1GYphOE6+KaaxZdt+zwSB qglvj9nPy2/B2CgXqNCtVvTs0eikP7PdafSJjr35OCYJy9qFGr8koxIjqK3rJse1uOnP gnti+RtODgkdfhcxnwWDufJFlaslFWnstlVbSB/cFEKIkmbOzdOvhHXROAobNwkmObFb LAfg== X-Gm-Message-State: AOAM531m6w58Tc7uaCU1mBcsbiCGFsiZPx7ixhe+nrsFD6cgFopAnF/q C9cClZjX2SscHmZ8Lu+BTaiLAS37m/yVCg== X-Google-Smtp-Source: ABdhPJytcaIe2wUdJm7qDQlUYmRhgcjnISUhGkO6gYQ16AeC4I4B1/zh2OJj1rS8wWjGyMilnp8yzg== X-Received: by 2002:a5d:47c3:: with SMTP id o3mr2740411wrc.25.1634170004998; Wed, 13 Oct 2021 17:06:44 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id y8sm670711wmi.43.2021.10.13.17.06.44 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 13 Oct 2021 17:06: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 14/20] refs API: make refs_resolve_refdup() not set errno Date: Thu, 14 Oct 2021 02:06:26 +0200 Message-Id: X-Mailer: git-send-email 2.33.1.1346.g48288c3c089 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 001f54845a7..c64ed6285a6 100644 --- a/refs.c +++ b/refs.c @@ -267,9 +267,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 Thu Oct 14 00:06: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: 12557571 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 EF7B7C433F5 for ; Thu, 14 Oct 2021 00:07:10 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id D449961130 for ; Thu, 14 Oct 2021 00:07:10 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230088AbhJNAJN (ORCPT ); Wed, 13 Oct 2021 20:09:13 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42392 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230222AbhJNAIx (ORCPT ); Wed, 13 Oct 2021 20:08: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 6741FC061778 for ; Wed, 13 Oct 2021 17:06:47 -0700 (PDT) Received: by mail-wr1-x42e.google.com with SMTP id u18so13867906wrg.5 for ; Wed, 13 Oct 2021 17:06: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=B+rhMDunkStFv+m46TBKut8CGMdemjLOjFlqUp/bDQg=; b=CeSWbg//W4QpuBFSDmzFHNTgEZHL2ilYiu2U4Opt4F1wEcnuAUScAUEncEPfQRHB/r +kimoMpC9wg+rcIrxTuH+vHfxH3yLrgaIThWX1vcTfl7wRo2yMwQ5rH9ztVuRh6k3xHB 5VQa1QMd/3rv0V92IzSnYLZUJHl9MiNbhny/HEb3rTRvFLz6mDPev51YYi1BmJUvwoY9 aN+uWDpHm/inQIVvv72OIwqSNrfQ1OubmdCaFgFLfSHqHAtAsZ1gkQ5lRHpY/X4aayKQ f7V8tXcfAYvsAmkhAAW1/s5D4L+p6PFVsNJFTEcQRmcaPMqe86rFB0450xq+AcqU+/eY J84w== 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=B+rhMDunkStFv+m46TBKut8CGMdemjLOjFlqUp/bDQg=; b=FURO+PQrHphl1wdNnJXmLYE8tiRZV9/7n2GZwEIEfYfg8vb7GzmPnxtw6Rs8wxtSrA oK4m3Rft8JWNqUVXfm7d8zy3yi46G256xpC7wlqMlXsMFCUgSiNM+ZiQ6tpAJN/o7wBT SA0d6ZJH7PH2tX4QlZv5rLafY19APsg2zCKdfepDzCIy0kOIdWkhV0t2c09vA7g6Qw1d 3cmBaKQ9UrrdKSO7FolSFfgXT5cMoPbHP/MuShq8y+p1rTfVJFICqa9z5FOiFXNjs6bB OoRZIMeDXzmzT/tE/6PTLK6qB2L+2R2Vob8UHNz7uav4shNxg5KYU7rvBj7b5F8vav6O kc9Q== X-Gm-Message-State: AOAM53070DikbeCvnoZRgU5AJvV/bL914qHc8Et1nVxbxjRNR74r290J 0/2+o+8dAa/6SQO04jpn+f9l8tFzDexUwQ== X-Google-Smtp-Source: ABdhPJxgLg4c/zr89h5e+PvBfm4QAZZ0q/zNk6Ljar/5MWycYxIGIsz5twmafKEhACtJrNZI/ZSj6Q== X-Received: by 2002:a7b:c010:: with SMTP id c16mr2408718wmb.141.1634170005830; Wed, 13 Oct 2021 17:06:45 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id y8sm670711wmi.43.2021.10.13.17.06.45 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 13 Oct 2021 17:06: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 15/20] refs API: make refs_ref_exists() not set errno Date: Thu, 14 Oct 2021 02:06:27 +0200 Message-Id: X-Mailer: git-send-email 2.33.1.1346.g48288c3c089 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 c64ed6285a6..f2a56a216c3 100644 --- a/refs.c +++ b/refs.c @@ -308,7 +308,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 Thu Oct 14 00:06:28 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: 12557573 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 6199DC433FE for ; Thu, 14 Oct 2021 00:07:12 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 49A7E6113B for ; Thu, 14 Oct 2021 00:07:12 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230222AbhJNAJO (ORCPT ); Wed, 13 Oct 2021 20:09:14 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42416 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230231AbhJNAIx (ORCPT ); Wed, 13 Oct 2021 20:08:53 -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 2DC8DC06177B for ; Wed, 13 Oct 2021 17:06:48 -0700 (PDT) Received: by mail-wr1-x436.google.com with SMTP id v17so13750576wrv.9 for ; Wed, 13 Oct 2021 17:06:48 -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=UF0m0fy+FrS7BOfPF9cFoV3A5sGFM+8xFbei8mU2nxM=; b=KoMA552J/2dsMAyWfm1g9NXTQK8fLz6xUdhmsIu5Lkx372L0ZiqNZ2fuaBpTXpj47w rNDcNwCM+pUprT/G+aqIf9qFqOPiKZpEOu5n/iJTlKXTPBwIoBN/HlFrYDYLtCzNmeBi Ga+8IqxZOlzMtif6c6zfKZFcIsv8DzYvcSuCaNj9EcGQci1obVvj9HcURVYYgIv6okHh E+4rGqVQ2Awiv8n+Q/i1gBETG3FaLkv/WOoBcSpbkuspztgihevh6UNC0+4CxjrPJBUt IpfJ5JVGADmxdDXvbIS0/jM4GJM77mMVQS3AOkPN9sHR8ulTkKQKfuN2c5WsWa0UNHJp vvWw== 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=UF0m0fy+FrS7BOfPF9cFoV3A5sGFM+8xFbei8mU2nxM=; b=sULW0JPHopMBszUT/5zFeeXziypLW3U9NtoshBmOgfvARYOGUooom7Kjf5SXw60GXQ XtENpGeAPOjN0/HGjJ/Sn/HlXFNnqrgkOxEMSGldvBxTQtz9xJC7kcOKo6Y8Z/uPdXeh Jz5cfmNicaf/V0gWc5HZkR4jAp6ct+T3fiTCFAIRfm568fRTuZ2ULSIuqM7AcCXMheBu k9T5oiPqYIBge21LG7pL+CEGt9+Q/hntKzEUceSYf8FATi7CoGkopZM8E4QtvTl5vEuh 5QnP1BSIaJsKlWnoK/w5aRwuZB+LoTXwbq0jWZiOipyfa0Y4U98SfCUNhKTfm83ZQ6Wv ZfNQ== X-Gm-Message-State: AOAM531I2g/t5qDZPuo555+5n0mP/++0disPjuy/o4w1NMHXNhzZQI2r DGF9USGdI9/iyN1VWWcvxe0+IHxZXiyLpA== X-Google-Smtp-Source: ABdhPJw4gAye/TJAJEl+YyTZxX9eGdCUvsvhLoBsx60A8jfdxBSFZQEHgioJ8JqUNaEV1c13Gnp2xA== X-Received: by 2002:a5d:64cd:: with SMTP id f13mr2865529wri.92.1634170006570; Wed, 13 Oct 2021 17:06:46 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id y8sm670711wmi.43.2021.10.13.17.06.45 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 13 Oct 2021 17:06:46 -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 16/20] refs API: make resolve_ref_unsafe() not set errno Date: Thu, 14 Oct 2021 02:06:28 +0200 Message-Id: X-Mailer: git-send-email 2.33.1.1346.g48288c3c089 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 f2a56a216c3..4b0c1a30a18 100644 --- a/refs.c +++ b/refs.c @@ -1784,8 +1784,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 64b1f2e681c..7052f791410 100644 --- a/sequencer.c +++ b/sequencer.c @@ -1281,6 +1281,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) @@ -1330,9 +1332,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 Thu Oct 14 00:06:29 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: 12557575 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 91E8CC433EF for ; Thu, 14 Oct 2021 00:07:18 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 795FE6113B for ; Thu, 14 Oct 2021 00:07:18 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230265AbhJNAJV (ORCPT ); Wed, 13 Oct 2021 20:09:21 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42398 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230322AbhJNAJD (ORCPT ); Wed, 13 Oct 2021 20:09:03 -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 DD49FC061762 for ; Wed, 13 Oct 2021 17:06:48 -0700 (PDT) Received: by mail-wr1-x431.google.com with SMTP id i12so13777594wrb.7 for ; Wed, 13 Oct 2021 17:06:48 -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=w4OKEV8dT7MqqU1hQfaaJEcFIsFEHQYaLHN78Ea6SQo=; b=MO0k89Rgfv6Z3WWVSUgNPIq0la9VmdLhqmVbe5jGBCmJnKOq/hyEvLpiJX6CqP/gVl 2KRlmavAiizQ1XVdQuEuZqTW1G6NEiUJ71Somjwui12leULeMeiHahkKobUQZXPKSKew YDIBXW9EM2BpiI4pTT0wHQD8RF60YoUhKlS6kvYArsP1TvTfyCHi7YisD+jvu9FXyy/i PN2skBuc1YIxC11IwV3lZWvKmuQCm70eFdFvrZH6fJ08oNy1K7Y0+5pxgWZW40+9O36d rGMGYcSHeyanYTfn34/KHT4MVihUicSr6qKGtsFQDlMckpZtEeFiIVbb7e82WhTJa/uQ TiNA== 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=w4OKEV8dT7MqqU1hQfaaJEcFIsFEHQYaLHN78Ea6SQo=; b=4oPmw6OD9y2D+ZG9bT6JfRgxVkBAOb3FKIoBkNQDaBCfvgny+CTB8mYbVxRVkG/1an 3zcDWyFoBpwZvrsiaoPRl2nQE01A6/cpInTpRq+624Zf7rr2k/uj6qkNfCUIcVSZEfeR f6w4b08jlOxhB7F4AxY6LfumIh4jFrJyO5doAg+yL/+8dllSTkjPje1BGz9uHLjNg2ze g7jia78ri3faE3hZ9kb+YW0yJJ9GiFs7Q6BcfMVOEpGCJarUmhvV+FRYEGZsrYDkNe9g cOPDNkG4YuC9IydNhmvHrNh0hdVZcv+koZ2JTrjyfkOkhBdrb+NOPkLgst1xo1F/VPY0 o+xg== X-Gm-Message-State: AOAM532+xECIoexOsxAdMrA98vJXVGmmd0tY2AZptWg01k6YuyHKQNdV 11Kclmf2InHMoRBkxLg3P7OJxjEOy/vtzA== X-Google-Smtp-Source: ABdhPJwUMWJql3K5qpxF5Q3rTjwrBWqMdtyNWH+xNL0M7mkrQRN5Wd1vSPFz+bKiEyRNbTXdsAPKrg== X-Received: by 2002:a1c:8054:: with SMTP id b81mr2411630wmd.87.1634170007323; Wed, 13 Oct 2021 17:06:47 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id y8sm670711wmi.43.2021.10.13.17.06.46 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 13 Oct 2021 17:06:46 -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 17/20] refs API: make expand_ref() & repo_dwim_log() not set errno Date: Thu, 14 Oct 2021 02:06:29 +0200 Message-Id: X-Mailer: git-send-email 2.33.1.1346.g48288c3c089 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 4b0c1a30a18..16f8220b108 100644 --- a/refs.c +++ b/refs.c @@ -653,13 +653,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); @@ -688,12 +691,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 Thu Oct 14 00:06:30 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: 12557577 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 BB1A6C433FE for ; Thu, 14 Oct 2021 00:07:19 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id A30236113B for ; Thu, 14 Oct 2021 00:07:19 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230314AbhJNAJW (ORCPT ); Wed, 13 Oct 2021 20:09:22 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42442 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230329AbhJNAJE (ORCPT ); Wed, 13 Oct 2021 20:09:04 -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 911ACC061749 for ; Wed, 13 Oct 2021 17:06:49 -0700 (PDT) Received: by mail-wr1-x436.google.com with SMTP id k7so13665371wrd.13 for ; Wed, 13 Oct 2021 17:06:49 -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=s6j3yp6C58c0SnY0buPOfFanHYz9OMOAQb8QO7SzTYU=; b=nwF2MR9cBOOEYcVxnty1+yW7nqGzNRfD2MR/juCirr4MCPq8WFDglYkU5vDi+l4Bdj UPEwizM0tkCW9qUBpof4q/oINOzTC5AxPjwRHe9qLhEn9D+0vAE603vMY9iE/JPV0sqi VKVWEEgu8fUdHVSQXVHUZI4dvfSWL15CiGKsrIB9yd2tjWH7ZYmW76QqJMSa2z2Mhet6 EDkxIU4Ic0If11YbZ5MxVVjx/BRwhDDv5qmhyhrkf75jVwYaH/CU6sUDl7jJpB/KQfgc 9wz6XD6v/qEua8DEJQBBtwO8VCHqWuXS8pESrlc1qZ8MKJiyu8AtetGDAVyJIXWgAShN QOMw== 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=s6j3yp6C58c0SnY0buPOfFanHYz9OMOAQb8QO7SzTYU=; b=hpNfexX4CUhyWvVxOwRlBlgFGEo+kjSEQbkWYBUQ59OW5iClGv+QJmVdGhi3ykLpeB RpMf3l8eIXn2mM6APw7M8SkhJ05VvZvBdjoTwiTVMgPtBKzqM+HBZocgeiA62g5izm5A SIQ/v9npQQrv4/Klk9bxFfe+bthKWE0DPXtEXgkRPyWmYvJ2+owiQr8t25l7zDhXwcMe 5jqNuQoFD/VVQnOq96d4e+7zU69mEsmESC4I4ZRuhTbA0Bn2YhbmPo4tzRpDwhRXBP5O RsOpcxGHDhpoYUHSHsBz+VbZ1oJqFg6haoEGeZ3bLrfY0jfGTOhx6luUn2thDkjVAl4Q YtwA== X-Gm-Message-State: AOAM531UKpUCEDTdKsbu+Nc6Jk9zxMY65f2XFfJL9UxibHQQuiqHj/H4 uz+jly6tbVVWQf45Z/pHEEwTiLZcvzOUpw== X-Google-Smtp-Source: ABdhPJz4mV95lEf6p+C7tyZpOJMMlwA2yR9eDySgmTRKPZjRH0IBJlD8o9VjcajncFv92sTJq5Db7A== X-Received: by 2002:a05:600c:3b24:: with SMTP id m36mr2371071wms.176.1634170007957; Wed, 13 Oct 2021 17:06:47 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id y8sm670711wmi.43.2021.10.13.17.06.47 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 13 Oct 2021 17:06:47 -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 18/20] refs API: don't expose "errno" in run_transaction_hook() Date: Thu, 14 Oct 2021 02:06:30 +0200 Message-Id: X-Mailer: git-send-email 2.33.1.1346.g48288c3c089 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 16f8220b108..9aa41b55c7b 100644 --- a/refs.c +++ b/refs.c @@ -2095,8 +2095,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 Thu Oct 14 00:06:31 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: 12557581 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 34FB3C43217 for ; Thu, 14 Oct 2021 00:07:21 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 1E4EE6113B for ; Thu, 14 Oct 2021 00:07:21 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230336AbhJNAJY (ORCPT ); Wed, 13 Oct 2021 20:09:24 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42392 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230357AbhJNAJF (ORCPT ); Wed, 13 Oct 2021 20:09:05 -0400 Received: from mail-wr1-x434.google.com (mail-wr1-x434.google.com [IPv6:2a00:1450:4864:20::434]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 45903C061767 for ; Wed, 13 Oct 2021 17:06:50 -0700 (PDT) Received: by mail-wr1-x434.google.com with SMTP id i12so13777752wrb.7 for ; Wed, 13 Oct 2021 17:06:50 -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=wkYrxre2dnsOXLTpy002kGSMxv8nM7qfZ/JSb0vU+ss=; b=YVXIS0GtU99Vu0wbUJp5X2kIXna5aXkCFW4YC/crajndf2itYTV7xjdH1EpRSR9s4Z 8bIGnjBK6zjUlaRX40iZ2AIB2Sk4KFFdA9M3aW0JWu9twSgkgImWP5DMHek1OGHpEks+ BA9GnAMkQ6GQtsqVMbM3XQZIJnNIeIL/m2htO79bZb2NFy4AoAPYLGxXGfX2Z/Pxti4v fzEtc3sXAnE7AdFaxMtLCoXlveMUP1jNFJZQeSlCrtxsrZG6FxxUOu9A+RFnh1MsMSDC ZewGanMaUJ+8JCRQJ3uHPD3EA3Si2gCbnh81WHs1k6xSDaSfy6LvjkEyCuZC0CiI10OM NMOQ== 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=wkYrxre2dnsOXLTpy002kGSMxv8nM7qfZ/JSb0vU+ss=; b=py7rFcvYSxSz0IAfH8pzs+1XymSVihzt2IiERhy/+TC73LmBfPQBHb77EW+a2a2UYY liwbKKY0+u074zNBqMUmzwzUw/TStH+GXpgXOVnGKIxAtsMQxUBn5UgjIlVL5tMEhCiH gqR4Y0aeisnHZ8PFwOiPgcuLNuNqyFunRTqFX8t1ySNV4kLaz10Ktbd9ZNd4bcLcQPfq 4i1oZm6T570BkF8GyYfoOmOSwUoo4rM7CPhMFTrEE5in8It522x5XtvBRABzXWmj8kiT KmaHii9p4uxWxSGobCPZJj1IuFCRd8XUNUc5uJ5J8JOyTkk0wam8J326YY4zR48ToD0w CeAQ== X-Gm-Message-State: AOAM532RticAnGfnusQ1bQyzpvpxRQQ4RkU68eN9QcLH6XE5wNLmJso9 iaNb2jXK3uf7cL8jBCyIXQF6nR1W1azNOw== X-Google-Smtp-Source: ABdhPJyalaPuZgujLLw1udLal7UXq46aWQtac0fC91n3lyaigIhNJzU++ufXXqeCWPzwkTa11vFPmg== X-Received: by 2002:a5d:4a46:: with SMTP id v6mr2688250wrs.262.1634170008628; Wed, 13 Oct 2021 17:06:48 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id y8sm670711wmi.43.2021.10.13.17.06.48 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 13 Oct 2021 17:06:48 -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 19/20] refs API: post-migration API renaming [1/2] Date: Thu, 14 Oct 2021 02:06:31 +0200 Message-Id: X-Mailer: git-send-email 2.33.1.1346.g48288c3c089 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 9aa41b55c7b..a19f156b66a 100644 --- a/refs.c +++ b/refs.c @@ -1668,7 +1668,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, @@ -1765,19 +1765,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 Thu Oct 14 00:06:32 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: 12557579 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 51D0CC433F5 for ; Thu, 14 Oct 2021 00:07:20 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 3A15961130 for ; Thu, 14 Oct 2021 00:07:20 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230329AbhJNAJX (ORCPT ); Wed, 13 Oct 2021 20:09:23 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42448 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230355AbhJNAJF (ORCPT ); Wed, 13 Oct 2021 20:09:05 -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 EF548C061769 for ; Wed, 13 Oct 2021 17:06:50 -0700 (PDT) Received: by mail-wr1-x42b.google.com with SMTP id i12so13777871wrb.7 for ; Wed, 13 Oct 2021 17:06:50 -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=SM8XJKLKk9TtRkPMKMNSjNc5hu3LS4nterCbfmlXPNI=; b=H1200iul4lBOeHu5HORivR7NzEYbiXNw6gWhx90voUhw7x9FAFCHl1ZZ9vc4kB8a/z 00gLcFSBaZJijTDwMdUCEHR10UIXktap21z0pwCh1mQTRNPXBH5KzLNtYdxBUcus4N+g D6s0tb9kwwbfLAQd9pDqZBTCDQWJMathdRe6ZRoQCdkeY9cwz7mhLukdYoyyqcTsg77R my05wS2EQZDqedSkCnwA31h4nnSACqaHS3pi5TUNhF+08+55i2Rm5p+Xank+R4Xk2d33 f9IrLUjYX+mV7NzBquNkviVNyKnRBf9250WMrJZN5zdBUN1pcmZae3Ads252XThAlftd sgiw== 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=SM8XJKLKk9TtRkPMKMNSjNc5hu3LS4nterCbfmlXPNI=; b=6Uo7Q8he143BEnc8DqWxorNp3JMH0dc5hmvgGr7eCDX5RepV97WnDybob4t9VEDowF nPq0J05Ihr7wjzivA6t3eeVHh16OSMOqlLRkS6W/9pzIolorWjFogwdr1fFygvzKS8AC GELOXKtbDdWLtefsarbhgknaLRsjgwIgGeQnJF5lcxQnx4U6q5h8qFT65lcHJwm/aYrG UISy7ib7obOUeJirAX4m62VOPyUGCRyv7gV16VaJnXwlKayXBM1Vqgadk9mjFXstjlwy bIbqvdZMPlM8uRZbEes0T6exo4dPiOwhF2yF/ghx9RU+r7oNpwygomIC3TsM0zgCq1l+ WorA== X-Gm-Message-State: AOAM531bhB1z5vjIzYO+ACx25Rv6V8XS+42RmTPsoFzkL9So7elqIYeB emuq6NkWFi/jpszlmvQq8wba/T5OxPJ8oA== X-Google-Smtp-Source: ABdhPJwGecXDRvpws01/BzgjtmaERHwcpEtOw31xBMlE20VMlk3wgs2QpVeIw4PjAdXnXYIbTr034A== X-Received: by 2002:a1c:750b:: with SMTP id o11mr2396732wmc.5.1634170009338; Wed, 13 Oct 2021 17:06:49 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id y8sm670711wmi.43.2021.10.13.17.06.48 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 13 Oct 2021 17:06:48 -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 20/20] refs API: post-migration API renaming [2/2] Date: Thu, 14 Oct 2021 02:06:32 +0200 Message-Id: X-Mailer: git-send-email 2.33.1.1346.g48288c3c089 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 | 16 ++++++++-------- sequencer.c | 2 +- t/helper/test-ref-store.c | 2 +- worktree.c | 6 +++--- 7 files changed, 21 insertions(+), 28 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 a19f156b66a..75c6eafa847 100644 --- a/refs.c +++ b/refs.c @@ -269,7 +269,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); } @@ -295,7 +295,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; @@ -309,7 +309,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); } @@ -659,7 +659,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); @@ -695,7 +695,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); @@ -1382,7 +1382,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); @@ -1778,7 +1778,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); } @@ -1794,7 +1794,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 b3d4544dcf0..e9d754d5ad3 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)) { diff --git a/sequencer.c b/sequencer.c index 7052f791410..d848c5dc985 100644 --- a/sequencer.c +++ b/sequencer.c @@ -1333,7 +1333,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))