From patchwork Sun Jul 11 16:30: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: 12369229 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-15.8 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,FREEMAIL_FORGED_FROMDOMAIN,FREEMAIL_FROM, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 9A4D4C07E96 for ; Sun, 11 Jul 2021 16:30:49 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 710AE61176 for ; Sun, 11 Jul 2021 16:30:49 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232441AbhGKQdf (ORCPT ); Sun, 11 Jul 2021 12:33:35 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:40702 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229660AbhGKQdf (ORCPT ); Sun, 11 Jul 2021 12:33:35 -0400 Received: from mail-wr1-x433.google.com (mail-wr1-x433.google.com [IPv6:2a00:1450:4864:20::433]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 50D76C0613E5 for ; Sun, 11 Jul 2021 09:30:48 -0700 (PDT) Received: by mail-wr1-x433.google.com with SMTP id p8so21150346wrr.1 for ; Sun, 11 Jul 2021 09:30:48 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=5+7GT2xFKsv7AOrhfKfiWL8WObGs1ENfr3pJ8yskksI=; b=uoyxnR7A/n9KXFxwO9sm+x69N4dqI6i0rGr8LqjMfRMLcqKUVdI13T2FL+prwOX2PS 05VO/vEms1hkuMoopGbRbGrMYa9pSCsNE46ExzIj+EWWpLNccD7LsE3L/UR1EDJR8f7T EHoKEf8HSVWQIIy/72B2RKE/W7ePp9u3diDUbpDsJZWgFSj4qX1rf1KQlI+b/mQ0+EHn qec6rfSoNGgjcIkeOUHbPtnFiOs87opfeSQkV9ZSMY3ilsv6HJyPgzkatkofPt6mbrdH /runQO9PZXRTnbTYP5XEvVGesddlvVNPVwmzdSkdf6bCnK8G5gcPcFwo2zhjlM1ioJEl luvQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=5+7GT2xFKsv7AOrhfKfiWL8WObGs1ENfr3pJ8yskksI=; b=qlGy8U8+2fEAkPazjX7lSeG8KiNi+fQlQQqN4ICS3wYsNK/9Ki2PB8YK0tWHNEARRb Nd03r3aeLJK9JLF8Ru1HeDOCmhCpnVHiuSAZEtJv46pXJ9YDn60hshje6JA2NYXqlXv1 WrGa29/QyBBN+2CS54H+Vmvd4b85sdRT/TVAvQa+Cky5VZUOecMdiVjwpuXUYUvM5WeC SRQzLmdAFTKBbzqnN/BbENn9HHbBXtJB3dvGkKrMkR6pTZdTPvsgKLBGKsYimbbNoZjz LxE64bFczV/aY7o6TpZWlpGNlea5R5eHy3AQH5LzKB/PiSh8zo4qZLvDAytQaXELG3CE AhEA== X-Gm-Message-State: AOAM533oCOlCftAK+4OWPmTFbGLXeRSraJ8m/X1MAzIY5RiBWLNFxSIf YHB/L5KLx2JtryxmAqNrUinVEdfze5kHLA== X-Google-Smtp-Source: ABdhPJwvj0MNiWbptBg7tUALZPXidGKev79/de68VbyIdqBRB+XBchiEOvJdw+F87AW+k8fL3Z2gKg== X-Received: by 2002:a5d:64aa:: with SMTP id m10mr4732174wrp.351.1626021046663; Sun, 11 Jul 2021 09:30:46 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id w3sm678091wrt.55.2021.07.11.09.30.46 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 11 Jul 2021 09:30:46 -0700 (PDT) From: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= To: git@vger.kernel.org Cc: Junio C Hamano , Jeff King , Han-Wen Nienhuys , Jonathan Tan , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBC?= =?utf-8?b?amFybWFzb24=?= Subject: [PATCH v6? 01/17] refs: remove EINVAL errno output from specification of read_raw_ref_fn Date: Sun, 11 Jul 2021 18:30:25 +0200 Message-Id: X-Mailer: git-send-email 2.32.0-dev In-Reply-To: References: MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org From: Han-Wen Nienhuys This commit does not change code; it documents the fact that an alternate ref backend does not need to return EINVAL from read_raw_ref_fn to function properly. This is correct, because refs_read_raw_ref is only called from; * resolve_ref_unsafe(), which does not care for the EINVAL errno result. * refs_verify_refname_available(), which does not inspect errno. * files-backend.c, where errno is overwritten on failure. * packed-backend.c (is_packed_transaction_needed), which calls it for the packed ref backend, which never emits EINVAL. A grep for EINVAL */*c reveals that no code checks errno against EINVAL after reading references. In addition, the refs.h file does not mention errno at all. A grep over resolve_ref_unsafe() turned up the following callers that inspect errno: * sequencer.c::print_commit_summary, which uses it for die_errno * lock_ref_oid_basic(), which only treats EISDIR and ENOTDIR specially. The files ref backend does use EINVAL. The files backend does not call into the generic API (refs_read_raw), but into the files-specific function (files_read_raw_ref), which we are not changing in this commit. As the errno sideband is unintuitive and error-prone, remove EINVAL value, as a step towards getting rid of the errno sideband altogether. Spotted by Ævar Arnfjörð Bjarmason . Signed-off-by: Han-Wen Nienhuys Signed-off-by: Ævar Arnfjörð Bjarmason --- refs/refs-internal.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/refs/refs-internal.h b/refs/refs-internal.h index 467f4b3c936..f4445e32904 100644 --- a/refs/refs-internal.h +++ b/refs/refs-internal.h @@ -619,9 +619,9 @@ typedef int reflog_expire_fn(struct ref_store *ref_store, * * Return 0 on success. If the ref doesn't exist, set errno to ENOENT * and return -1. If the ref exists but is neither a symbolic ref nor - * an object ID, it is broken; set REF_ISBROKEN in type, set errno to - * EINVAL, and return -1. If there is another error reading the ref, - * set errno appropriately and return -1. + * an object ID, it is broken; set REF_ISBROKEN in type, and return -1 + * (errno should not be ENOENT) If there is another error reading the + * ref, set errno appropriately and return -1. * * Backend-specific flags might be set in type as well, regardless of * outcome. From patchwork Sun Jul 11 16:30: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: 12369237 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-15.8 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,FREEMAIL_FORGED_FROMDOMAIN,FREEMAIL_FROM, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id CDD91C07E9E for ; Sun, 11 Jul 2021 16:30:51 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id AFE0E61182 for ; Sun, 11 Jul 2021 16:30:51 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232566AbhGKQdh (ORCPT ); Sun, 11 Jul 2021 12:33:37 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:40706 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229660AbhGKQdh (ORCPT ); Sun, 11 Jul 2021 12:33:37 -0400 Received: from mail-wm1-x332.google.com (mail-wm1-x332.google.com [IPv6:2a00:1450:4864:20::332]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 151FFC0613E5 for ; Sun, 11 Jul 2021 09:30:49 -0700 (PDT) Received: by mail-wm1-x332.google.com with SMTP id h18-20020a05600c3512b029020e4ceb9588so12575159wmq.5 for ; Sun, 11 Jul 2021 09:30:49 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=za+jQ+6tQ/XAQO+SnRw8nPU+lR0oqLdGjG6IwOQMctw=; b=RogishPoqNEh6TB36sX3seBHp1Ng60khU5tY4NMWZoVLEMR8F0LgYcoMG6USVMtqD8 dI/VKK2WSPrSfpss5F6G4k+L7eB24GrAVvXDGaQp26vKjbwJ71fNtih7GsamVGrt1qQy sYF53yivCsFdjRwGljoWtAUxBkh+OLH3OgwhSSas5pJ8j4meo6hp6Hr0cAqnnuwTTueZ JETIY6CnYTBIpjgMhzghvDAsjBbfG4Hbb/bqq3Io4PO3BbKyGIpMCtpYjuYN4mSensTz R88HVv3mjFic9vE+8VP/FtsQuGE3EB7rvqmLCwxEvseCQEh8Rf6xymBwFOHiU+yjlxo/ B9aw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=za+jQ+6tQ/XAQO+SnRw8nPU+lR0oqLdGjG6IwOQMctw=; b=SmAMJ2zBpHek975u17LcxCw4rpZGCKfuOuYUZU5olWjAUEyxue2xmLDPAaNHARAb56 VOAiRIVIsxIWMAfR5DvWyFBmyubRbeEYMhLKvZQrmY7Fcz3HyDCETfeW4kJ9C+Bmk8Hk QKunFxtBLjUXOLGceWEgaIbEGoe+DGIbiBaju/+nGQbkF5vZOYzkX9co+GZMNYzn6D+C aaRFxj3QOp2IyPJ00uMxOpibe1g4x7agebYoAZY34+JOhHgyHGh9fKbn3hDG9vf9CGuN ibPKzAsZfjhJnZKeiQ5LgO34X1hMjMt/WTykmYq5NmyPlkoPwJrvpZ5cHRaAscNDKk0E lTzw== X-Gm-Message-State: AOAM530Bbi/P9InsuDDWPxFqySFJ2ESXdl0F8l5t8jFt3TqlTLZnkVyh 1DWzFpWO/5Q3QNeJmxGgEKmzlEGydUXtWA== X-Google-Smtp-Source: ABdhPJxEwn2Um3fOEZBuI0/RleXgruW3dhwl6ZqA/g6xcLwa5MlSlNaXnLGJtZW+7teiT1BJFYoj7Q== X-Received: by 2002:a05:600c:2a4b:: with SMTP id x11mr19150594wme.22.1626021047439; Sun, 11 Jul 2021 09:30:47 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id w3sm678091wrt.55.2021.07.11.09.30.46 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 11 Jul 2021 09:30:46 -0700 (PDT) From: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= To: git@vger.kernel.org Cc: Junio C Hamano , Jeff King , Han-Wen Nienhuys , Jonathan Tan , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBC?= =?utf-8?b?amFybWFzb24=?= Subject: [PATCH v6? 02/17] refs/files-backend: stop setting errno from lock_ref_oid_basic Date: Sun, 11 Jul 2021 18:30:26 +0200 Message-Id: X-Mailer: git-send-email 2.32.0-dev In-Reply-To: References: MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org From: Han-Wen Nienhuys refs/files-backend.c::lock_ref_oid_basic() tries to signal how it failed to its callers using errno. It is safe to stop setting errno here, because the callers of this file-scope static function are * files_copy_or_rename_ref() * files_create_symref() * files_reflog_expire() None of them looks at errno after seeing a negative return from lock_ref_oid_basic() to make any decision, and no caller of these three functions looks at errno after they signal a failure by returning a negative value. In particular, * files_copy_or_rename_ref() - here, calls are followed by error() (which performs I/O) or write_ref_to_lockfile() (which calls parse_object() which may perform I/O) * files_create_symref() - here, calls are followed by error() or create_symref_locked() (which performs I/O and does not inspect errno) * files_reflog_expire() - here, calls are followed by error() or refs_reflog_exists() (which calls a function in a vtable that is not documented to use and/or preserve errno) In the case of the "errno != ENOTDIR" case that originates in 5b2d8d6f218 (lock_ref_sha1_basic(): improve diagnostics for ref D/F conflicts, 2015-05-11), there the "last_errno" was saved away to return it from lock_ref_oid_basic(), now that we're no longer doing that we can skip that entirely and use "errno" directly. A follow-up change will extract the specific errno we want earlier in this function. Signed-off-by: Han-Wen Nienhuys Signed-off-by: Ævar Arnfjörð Bjarmason --- refs/files-backend.c | 24 +++++++++--------------- 1 file changed, 9 insertions(+), 15 deletions(-) diff --git a/refs/files-backend.c b/refs/files-backend.c index 677b7e4cdd2..f0ce0aac857 100644 --- a/refs/files-backend.c +++ b/refs/files-backend.c @@ -910,7 +910,6 @@ static int create_reflock(const char *path, void *cb) /* * Locks a ref returning the lock on success and NULL on failure. - * On failure errno is set to something meaningful. */ static struct ref_lock *lock_ref_oid_basic(struct files_ref_store *refs, const char *refname, @@ -922,7 +921,6 @@ static struct ref_lock *lock_ref_oid_basic(struct files_ref_store *refs, { struct strbuf ref_file = STRBUF_INIT; struct ref_lock *lock; - int last_errno = 0; int mustexist = (old_oid && !is_null_oid(old_oid)); int resolve_flags = RESOLVE_REF_NO_RECURSE; int resolved; @@ -949,7 +947,6 @@ static struct ref_lock *lock_ref_oid_basic(struct files_ref_store *refs, * to remain. */ if (remove_empty_directories(&ref_file)) { - last_errno = errno; if (!refs_verify_refname_available( &refs->base, refname, extras, skip, err)) @@ -961,14 +958,15 @@ static struct ref_lock *lock_ref_oid_basic(struct files_ref_store *refs, refname, resolve_flags, &lock->old_oid, type); } - if (!resolved) { - last_errno = errno; - if (last_errno != ENOTDIR || - !refs_verify_refname_available(&refs->base, refname, - extras, skip, err)) - strbuf_addf(err, "unable to resolve reference '%s': %s", - refname, strerror(last_errno)); - + if (!resolved && + (errno != ENOTDIR || + /* in case of D/F conflict, try to generate a better error + * message. If that fails, fall back to strerror(ENOTDIR). + */ + !refs_verify_refname_available(&refs->base, refname, extras, + skip, err))) { + strbuf_addf(err, "unable to resolve reference '%s': %s", + refname, strerror(errno)); goto error_return; } @@ -981,20 +979,17 @@ static struct ref_lock *lock_ref_oid_basic(struct files_ref_store *refs, if (is_null_oid(&lock->old_oid) && refs_verify_refname_available(refs->packed_ref_store, refname, extras, skip, err)) { - last_errno = ENOTDIR; goto error_return; } lock->ref_name = xstrdup(refname); if (raceproof_create_file(ref_file.buf, create_reflock, &lock->lk)) { - last_errno = errno; unable_to_lock_message(ref_file.buf, errno, err); goto error_return; } if (verify_lock(&refs->base, lock, old_oid, mustexist, err)) { - last_errno = errno; goto error_return; } goto out; @@ -1005,7 +1000,6 @@ static struct ref_lock *lock_ref_oid_basic(struct files_ref_store *refs, out: strbuf_release(&ref_file); - errno = last_errno; return lock; } From patchwork Sun Jul 11 16:30: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: 12369231 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-15.8 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,FREEMAIL_FORGED_FROMDOMAIN,FREEMAIL_FROM, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 3FD4AC07E9C for ; Sun, 11 Jul 2021 16:30:51 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 201D661175 for ; Sun, 11 Jul 2021 16:30:51 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232540AbhGKQdh (ORCPT ); Sun, 11 Jul 2021 12:33:37 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:40712 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232521AbhGKQdg (ORCPT ); Sun, 11 Jul 2021 12:33:36 -0400 Received: from mail-wm1-x329.google.com (mail-wm1-x329.google.com [IPv6:2a00:1450:4864:20::329]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id D0A2FC0613DD for ; Sun, 11 Jul 2021 09:30:49 -0700 (PDT) Received: by mail-wm1-x329.google.com with SMTP id g12so1790307wme.2 for ; Sun, 11 Jul 2021 09:30:49 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=4NwDnpHX1EvhPI+J7A6xZVdtE8fDpZSpeWacgrJ7O5g=; b=NuBnquqha75s486GQnS88wSUtZ1ruJZV63qLmSQ56/OdbZij5IR0SG22ySEBS2kNZ+ oNte/qrH9FkO0JWE+tI8A8KdysnNBv2QNpvUHE4GxpYy7X9UCza1l4DwNYESdabz5YEa dBEEN2xoUW3FXkzCDNQ3IujFJeRyrAcYemtkYX4ODM0W9W+lJIO12V/tj9e/zDzjs8/t cDtiqAjawa+SyBXKwqFDCWKZclHMH0JYD38n/2NJ4B6/CrEoo1U9dt+dnxh8oxZxsrac I/7VO+LAAdX3hLSbkLz+jWM++2XMV/oFONddu1urwxKDW5vi7Noaph8JNfZUPOiR56O8 FUbA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=4NwDnpHX1EvhPI+J7A6xZVdtE8fDpZSpeWacgrJ7O5g=; b=K3DluSG0oCcxe5WfhGk7YlBy8tWT1M+OUzqh1l7PQY9ZUU4xYYG5WM9dobsCer0HL4 8pnoMKIMupb8wdTH+EEVu12ezKwjgazflLbFWMdHByJtVGrFt5m1se9OsCNIr+DCf4oS 36s/yF1iwqPYu45SUpZTJYW43Y7bNqzWvNP0TFXdYhwyuc+HhmgVOrKZAuYhQQeYNaN/ A8JWxMx79HkP90nlWcxdjpdb2vVE2I3epn+ftxxu7qYXk8ml+YJib7fIJC+Kv6kuYFUU 4psYCYi++bmZB+904d4RpRd6R1hHh8YcNZypSPPy+w27R3VUTEL4KoIGbpq7Td0APeKh mxMA== X-Gm-Message-State: AOAM531+1EilqWb4EXuZ0dnI1c8l+86jNlwK810fHTXzTnfmo604mGT6 YFKa2Dlc2kcWLb6akJHePEexmH/5tbM3HQ== X-Google-Smtp-Source: ABdhPJzKh6SN2dpFfHBzGBqGVIeitR87vy2kjXrPa28Q07Q4WUWMfVJtd7vQo+gr50pZEfjVFpapoA== X-Received: by 2002:a7b:ce05:: with SMTP id m5mr10271955wmc.64.1626021048200; Sun, 11 Jul 2021 09:30:48 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id w3sm678091wrt.55.2021.07.11.09.30.47 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 11 Jul 2021 09:30:47 -0700 (PDT) From: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= To: git@vger.kernel.org Cc: Junio C Hamano , Jeff King , Han-Wen Nienhuys , Jonathan Tan , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBC?= =?utf-8?b?amFybWFzb24=?= Subject: [PATCH v6? 03/17] refs: make errno output explicit for read_raw_ref_fn Date: Sun, 11 Jul 2021 18:30:27 +0200 Message-Id: X-Mailer: git-send-email 2.32.0-dev In-Reply-To: References: MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org From: Han-Wen Nienhuys This makes it explicit how alternative ref backends should report errors in read_raw_ref_fn. read_raw_ref_fn needs to supply a credible errno for a number of cases. These are primarily: 1) The files backend calls read_raw_ref from lock_raw_ref, and uses the resulting error codes to create/remove directories as needed. 2) ENOENT should be translated in a zero OID, optionally with REF_ISBROKEN set, returning the last successfully resolved symref. This is necessary so read_raw_ref("HEAD") on an empty repo returns refs/heads/main (or the default branch du-jour), and we know on which branch to create the first commit. Make this information flow explicit by adding a failure_errno to the signature of read_raw_ref. All errnos from the files backend are still propagated unchanged, even though inspection suggests only ENOTDIR, EISDIR and ENOENT are relevant. Signed-off-by: Han-Wen Nienhuys Signed-off-by: Ævar Arnfjörð Bjarmason --- refs.c | 2 +- refs/debug.c | 4 ++-- refs/files-backend.c | 29 +++++++++++++++-------------- refs/packed-backend.c | 8 ++++---- refs/refs-internal.h | 20 ++++++++++++-------- 5 files changed, 34 insertions(+), 29 deletions(-) diff --git a/refs.c b/refs.c index 8c9490235ea..7b3f05a66ff 100644 --- a/refs.c +++ b/refs.c @@ -1681,7 +1681,7 @@ int refs_read_raw_ref(struct ref_store *ref_store, } return ref_store->be->read_raw_ref(ref_store, refname, oid, referent, - type); + type, &errno); } /* This function needs to return a meaningful errno on failure */ diff --git a/refs/debug.c b/refs/debug.c index 7db4abccc34..f12413a9bc0 100644 --- a/refs/debug.c +++ b/refs/debug.c @@ -238,7 +238,7 @@ debug_ref_iterator_begin(struct ref_store *ref_store, const char *prefix, static int debug_read_raw_ref(struct ref_store *ref_store, const char *refname, struct object_id *oid, struct strbuf *referent, - unsigned int *type) + unsigned int *type, int *failure_errno) { struct debug_ref_store *drefs = (struct debug_ref_store *)ref_store; int res = 0; @@ -246,7 +246,7 @@ static int debug_read_raw_ref(struct ref_store *ref_store, const char *refname, oidcpy(oid, null_oid()); errno = 0; res = drefs->refs->be->read_raw_ref(drefs->refs, refname, oid, referent, - type); + type, failure_errno); if (res == 0) { trace_printf_key(&trace_refs, "read_raw_ref: %s: %s (=> %s) type %x: %d\n", diff --git a/refs/files-backend.c b/refs/files-backend.c index f0ce0aac857..b9df7862e57 100644 --- a/refs/files-backend.c +++ b/refs/files-backend.c @@ -341,9 +341,9 @@ static struct ref_cache *get_loose_ref_cache(struct files_ref_store *refs) return refs->loose; } -static int files_read_raw_ref(struct ref_store *ref_store, - const char *refname, struct object_id *oid, - struct strbuf *referent, unsigned int *type) +static int files_read_raw_ref(struct ref_store *ref_store, const char *refname, + struct object_id *oid, struct strbuf *referent, + unsigned int *type, int *failure_errno) { struct files_ref_store *refs = files_downcast(ref_store, REF_STORE_READ, "read_raw_ref"); @@ -354,7 +354,6 @@ static int files_read_raw_ref(struct ref_store *ref_store, struct stat st; int fd; int ret = -1; - int save_errno; int remaining_retries = 3; *type = 0; @@ -459,10 +458,9 @@ static int files_read_raw_ref(struct ref_store *ref_store, ret = parse_loose_ref_contents(buf, oid, referent, type); out: - save_errno = errno; + *failure_errno = errno; strbuf_release(&sb_path); strbuf_release(&sb_contents); - errno = save_errno; return ret; } @@ -541,6 +539,7 @@ static int lock_raw_ref(struct files_ref_store *refs, struct strbuf ref_file = STRBUF_INIT; int attempts_remaining = 3; int ret = TRANSACTION_GENERIC_ERROR; + int failure_errno; assert(err); files_assert_main_repository(refs, "lock_raw_ref"); @@ -611,7 +610,9 @@ static int lock_raw_ref(struct files_ref_store *refs, if (hold_lock_file_for_update_timeout( &lock->lk, ref_file.buf, LOCK_NO_DEREF, get_files_ref_lock_timeout_ms()) < 0) { - if (errno == ENOENT && --attempts_remaining > 0) { + int myerr = errno; + errno = 0; + if (myerr == ENOENT && --attempts_remaining > 0) { /* * Maybe somebody just deleted one of the * directories leading to ref_file. Try @@ -619,7 +620,7 @@ static int lock_raw_ref(struct files_ref_store *refs, */ goto retry; } else { - unable_to_lock_message(ref_file.buf, errno, err); + unable_to_lock_message(ref_file.buf, myerr, err); goto error_return; } } @@ -629,9 +630,9 @@ static int lock_raw_ref(struct files_ref_store *refs, * fear that its value will change. */ - if (files_read_raw_ref(&refs->base, refname, - &lock->old_oid, referent, type)) { - if (errno == ENOENT) { + if (files_read_raw_ref(&refs->base, refname, &lock->old_oid, referent, + type, &failure_errno)) { + if (failure_errno == ENOENT) { if (mustexist) { /* Garden variety missing reference. */ strbuf_addf(err, "unable to resolve reference '%s'", @@ -655,7 +656,7 @@ static int lock_raw_ref(struct files_ref_store *refs, * reference named "refs/foo/bar/baz". */ } - } else if (errno == EISDIR) { + } else if (failure_errno == EISDIR) { /* * There is a directory in the way. It might have * contained references that have been deleted. If @@ -693,13 +694,13 @@ static int lock_raw_ref(struct files_ref_store *refs, goto error_return; } } - } else if (errno == EINVAL && (*type & REF_ISBROKEN)) { + } else if (failure_errno == EINVAL && (*type & REF_ISBROKEN)) { strbuf_addf(err, "unable to resolve reference '%s': " "reference broken", refname); goto error_return; } else { strbuf_addf(err, "unable to resolve reference '%s': %s", - refname, strerror(errno)); + refname, strerror(failure_errno)); goto error_return; } diff --git a/refs/packed-backend.c b/refs/packed-backend.c index dfecdbc1db6..a457f18e93c 100644 --- a/refs/packed-backend.c +++ b/refs/packed-backend.c @@ -724,9 +724,9 @@ static struct snapshot *get_snapshot(struct packed_ref_store *refs) return refs->snapshot; } -static int packed_read_raw_ref(struct ref_store *ref_store, - const char *refname, struct object_id *oid, - struct strbuf *referent, unsigned int *type) +static int packed_read_raw_ref(struct ref_store *ref_store, const char *refname, + struct object_id *oid, struct strbuf *referent, + unsigned int *type, int *failure_errno) { struct packed_ref_store *refs = packed_downcast(ref_store, REF_STORE_READ, "read_raw_ref"); @@ -739,7 +739,7 @@ static int packed_read_raw_ref(struct ref_store *ref_store, if (!rec) { /* refname is not a packed reference. */ - errno = ENOENT; + *failure_errno = ENOENT; return -1; } diff --git a/refs/refs-internal.h b/refs/refs-internal.h index f4445e32904..79dfb3af484 100644 --- a/refs/refs-internal.h +++ b/refs/refs-internal.h @@ -617,11 +617,15 @@ typedef int reflog_expire_fn(struct ref_store *ref_store, * properly-formatted or even safe reference name. NEITHER INPUT NOR * OUTPUT REFERENCE NAMES ARE VALIDATED WITHIN THIS FUNCTION. * - * Return 0 on success. If the ref doesn't exist, set errno to ENOENT - * and return -1. If the ref exists but is neither a symbolic ref nor - * an object ID, it is broken; set REF_ISBROKEN in type, and return -1 - * (errno should not be ENOENT) If there is another error reading the - * ref, set errno appropriately and return -1. + * Return 0 on success, or -1 on failure. If the ref exists but is neither a + * symbolic ref nor an object ID, it is broken. In this case set REF_ISBROKEN in + * type, and return -1 (failure_errno should not be ENOENT) + * + * failure_errno provides errno codes that are interpreted beyond error + * reporting. The following error codes have special meaning: + * * ENOENT: the ref doesn't exist + * * EISDIR: ref name is a directory + * * ENOTDIR: ref prefix is not a directory * * Backend-specific flags might be set in type as well, regardless of * outcome. @@ -635,9 +639,9 @@ typedef int reflog_expire_fn(struct ref_store *ref_store, * - in all other cases, referent will be untouched, and therefore * refname will still be valid and unchanged. */ -typedef int read_raw_ref_fn(struct ref_store *ref_store, - const char *refname, struct object_id *oid, - struct strbuf *referent, unsigned int *type); +typedef int read_raw_ref_fn(struct ref_store *ref_store, const char *refname, + struct object_id *oid, struct strbuf *referent, + unsigned int *type, int *failure_errno); struct ref_storage_be { struct ref_storage_be *next; From patchwork Sun Jul 11 16:30: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: 12369235 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-15.8 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,FREEMAIL_FORGED_FROMDOMAIN,FREEMAIL_FROM, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 29BB1C07E96 for ; Sun, 11 Jul 2021 16:30:52 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 1518C61175 for ; Sun, 11 Jul 2021 16:30:52 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232577AbhGKQdi (ORCPT ); Sun, 11 Jul 2021 12:33:38 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:40718 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232544AbhGKQdh (ORCPT ); Sun, 11 Jul 2021 12:33:37 -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 AC0CBC0613DD for ; Sun, 11 Jul 2021 09:30:50 -0700 (PDT) Received: by mail-wr1-x42c.google.com with SMTP id g16so11228190wrw.5 for ; Sun, 11 Jul 2021 09:30:50 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=fCG8q3upYBltskfBbQUSKYagc53c/mGirK1576W+rKQ=; b=W9+MyU4zGn/B3OSFStlqgqHrZWQ+jdf5IxmlbtkmhA92baAaCTlReXrxsQrTNVKb+u vfcaCfenMKCwq/Xwp0IYIoCO6r4B0b0loHaf1OaydFRq7bCP93+5pFJV3bS9Mmx6Uxbn JzhmnhKKVDXl87m/kJaFgusVxbmBROj9qrM83bNXXajZt9QAnr5KNCM+P2P7Pkqlwr9N ZM5pMRpJOmsqUE4SiN7MKmgxpTHKmLygmO8VV9BOa6oVBycMXRdlLOsCS1rylil4DjG5 QuulvdU3oMLmdvBVMKErJmQer/IBlLTkaiNkVPk0XYuynn9dGBJSB4nOL+tJP+wOyM+z fCpw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=fCG8q3upYBltskfBbQUSKYagc53c/mGirK1576W+rKQ=; b=ntCSaHKPPbh6iRbixua9vSJaFR0FRghkm2Js7Uq++ekWXIiVGl51AJjTg5Jwe5ZJ7S npZKRKVmTxsjEEjKjVcTBPUNyrxgx+eZw2rRVi2nbF58XTUXFqOC+mYfuFO2t9GoTyKL iO/7GiSzK77lUuW/F7D94Wo07bZ4iga6XehzavnC+XNvHDmcMTNQa7ihob3q2qaewVBx tTj8QdzoCqGnPzda7USOVPvI6/o6O3tLGy+u6n+ZPzyN6qSAt6HF/eRtk/nvL5a6K6mi j/BXALrJZNddS2OyVYH2mMgeV4vMX+xeA/N7ZlQE88ZDhncmpMiNIXcUvuFunLHKKxuX wYWg== X-Gm-Message-State: AOAM533EtYx4IvG/MMzIYIG8xq1fu+QB3inGPe+a4GcMn8/6nyShBVEm DVoQyAN8vgGK6J6ZY8y+1bG6q1xZOrNCQA== X-Google-Smtp-Source: ABdhPJxL8HFjNAUXUMvSQs+3lYofix7FcW2ND6/5Ttuh9WbjTPiymmOIV1rDl+IGgnXBhp8WEh9tfw== X-Received: by 2002:a5d:4402:: with SMTP id z2mr6449229wrq.44.1626021049060; Sun, 11 Jul 2021 09:30:49 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id w3sm678091wrt.55.2021.07.11.09.30.48 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 11 Jul 2021 09:30:48 -0700 (PDT) From: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= To: git@vger.kernel.org Cc: Junio C Hamano , Jeff King , Han-Wen Nienhuys , Jonathan Tan , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBC?= =?utf-8?b?amFybWFzb24=?= Subject: [PATCH v6? 04/17] refs: add failure_errno to refs_read_raw_ref() signature Date: Sun, 11 Jul 2021 18:30:28 +0200 Message-Id: X-Mailer: git-send-email 2.32.0-dev In-Reply-To: References: MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org From: Han-Wen Nienhuys This lets us use the explicit errno output parameter in refs_resolve_ref_unsafe. Some of our callers explicitly do not care about the errno, rather than understanding NULL let's have them declare that they don't care by passing in an "ignore_errno". There's only three of them, and using that pattern will make it more obvious that they want to throw away data, let's also add a comment to one of the callers about why we'd like to ignore the errno. Let's not extend that to refs_resolve_ref_unsafe() itself for now, it has a large set of legacy callers, so we're faking up the old "errno" behavior for it. We can convert those callers to refs_resolve_ref_unsafe_with_errno() later. We are leaving out out the refs_read_special_head() in refs_read_raw_ref() for now, as noted in the next commit moving it to "failure_errno" will require some special consideration. We're intentionally mis-indenting the argument list of the new refs_resolve_ref_unsafe_with_errno(), it will be non-static in a subsequent commit, doing it this way makes that diff smaller. Signed-off-by: Han-Wen Nienhuys Signed-off-by: Ævar Arnfjörð Bjarmason --- refs.c | 61 ++++++++++++++++++++++++++++++------------- refs/files-backend.c | 10 ++++--- refs/packed-backend.c | 7 ++--- refs/refs-internal.h | 6 ++--- 4 files changed, 56 insertions(+), 28 deletions(-) diff --git a/refs.c b/refs.c index 7b3f05a66ff..406e27213b8 100644 --- a/refs.c +++ b/refs.c @@ -1671,30 +1671,33 @@ 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); } -/* This function needs to return a meaningful errno on failure */ -const char *refs_resolve_ref_unsafe(struct ref_store *refs, - const char *refname, - int resolve_flags, - struct object_id *oid, int *flags) +static const char *refs_resolve_ref_unsafe_with_errno(struct ref_store *refs, + const char *refname, + int resolve_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) @@ -1705,7 +1708,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; } @@ -1723,8 +1726,8 @@ 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; - 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; /* In reading mode, refs must eventually resolve */ @@ -1736,9 +1739,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); @@ -1765,7 +1768,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; } @@ -1773,10 +1776,24 @@ 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_resolve_ref_unsafe_with_errno(refs, refname, resolve_flags, + oid, flags, &failure_errno); + if (!refn) + /* For unmigrated legacy callers */ + errno = failure_errno; + return refn; +} + /* backend functions */ int refs_init_db(struct strbuf *err) { @@ -2227,6 +2244,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); @@ -2238,7 +2262,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 b9df7862e57..79f96ba1058 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 a457f18e93c..928e5d2a994 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 79dfb3af484..54f57c6a2df 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 Sun Jul 11 16:30: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: 12369239 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-15.8 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,FREEMAIL_FORGED_FROMDOMAIN,FREEMAIL_FROM, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 08F7CC07E96 for ; Sun, 11 Jul 2021 16:30:58 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id E2D9461182 for ; Sun, 11 Jul 2021 16:30:57 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232755AbhGKQdn (ORCPT ); Sun, 11 Jul 2021 12:33:43 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:40720 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232600AbhGKQdj (ORCPT ); Sun, 11 Jul 2021 12:33:39 -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 8A17CC0613DD for ; Sun, 11 Jul 2021 09:30:51 -0700 (PDT) Received: by mail-wr1-x434.google.com with SMTP id r11so15888907wro.9 for ; Sun, 11 Jul 2021 09:30:51 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=833KG8yaATp3+0NQDvqN8evVqhT9Kkj8kaIPBzcV83I=; b=HSojEoGOG2tQhOXWxSb9QN1wiRjFZ/aIoC2JBLhFsTc3ywCwxkUqEjMM1XKKswih+x ab6C/zO5scpb68+L4CPKCL0xLKvfp6XZvlJWdhczEpJ+KD7HR0/cwBmRDrDgZ3vwEYvi sBIp+IeTxwMWlqykZ3wW5apu2o6YWLGeJc4xajXGwO4klYO15abM4LNTo+RlWWdZ11aX FqxfgQkTpWbCLkwqT8G/+kv9Kh9h8/OhA/5OZu3/77H5ypbakqICdg+0ZJJE7fSVdTrS sy2hgpq8WHp3GlA+g5yLdK39rg2aJTRvb+i3YC+USUebbpV09rkTCJ7Y6Sv5dydRv6Yx SnDQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=833KG8yaATp3+0NQDvqN8evVqhT9Kkj8kaIPBzcV83I=; b=C66ms07TcXaXQ7yDCr3LJo+YJ0Ipb7uIdYYW+qP6UdXFpoHGRgPCJmbsVDZY40CISR gyAsPoXACRNJNTwQPgViYDOygaAwlj78oTOiCEX9y2paCrJ98Qb6Fw5FAjJY8xajbKI2 7+Cn3TGgBSvZxyLdtVf8Loto7o1Te2AZl+j9o922F5euvl3ic37+MnOAA5oq/8mA2Nh1 hiRiY3l7i8SrL8c5w0y9gD9CGKtbbZV4egZ80V2M17JBpyzz5kpiTACvk9CM+Ea2daGa Tjig6oyap+ES+9rGWkODv7OvbLBNzY4sRPhLtx4xQ5anW/U82v1MENamDg+eqL1jP8ni zBoA== X-Gm-Message-State: AOAM531KZZ1rMxhh7FWw+IzfzG4gMaEVT+zjjSPpPcVEf4e3vij5q+i0 hLgFEIGaJvjrdXbcMpFKtHUR77Zl2IeeGA== X-Google-Smtp-Source: ABdhPJz6ngDZOQiB5Fp1M3S2m+77E7ZSJZHo6KysCTARazlRCQbaJr2AnPqlCA0Z3J0iD9Q2jWtzSg== X-Received: by 2002:adf:e582:: with SMTP id l2mr4462931wrm.101.1626021049879; Sun, 11 Jul 2021 09:30:49 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id w3sm678091wrt.55.2021.07.11.09.30.49 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 11 Jul 2021 09:30:49 -0700 (PDT) From: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= To: git@vger.kernel.org Cc: Junio C Hamano , Jeff King , Han-Wen Nienhuys , Jonathan Tan , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBC?= =?utf-8?b?amFybWFzb24=?= Subject: [PATCH v6? 05/17] refs: explicitly return failure_errno from parse_loose_ref_contents Date: Sun, 11 Jul 2021 18:30:29 +0200 Message-Id: X-Mailer: git-send-email 2.32.0-dev In-Reply-To: References: MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org From: Han-Wen Nienhuys 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 | 30 +++++++++++++++++++----------- refs/refs-internal.h | 6 ++++-- 3 files changed, 28 insertions(+), 16 deletions(-) diff --git a/refs.c b/refs.c index 406e27213b8..af01a692cb9 100644 --- a/refs.c +++ b/refs.c @@ -1653,7 +1653,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; @@ -1663,7 +1664,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); @@ -1678,7 +1680,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 79f96ba1058..702e38a2b06 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,28 @@ 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; 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 +494,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 54f57c6a2df..bf581e70cf6 100644 --- a/refs/refs-internal.h +++ b/refs/refs-internal.h @@ -689,10 +689,12 @@ struct ref_store { }; /* - * Parse contents of a loose ref file. + * Parse contents of a loose ref file. *failure_errno maybe be set to EINVAL for + * invalid contents. */ int parse_loose_ref_contents(const char *buf, struct object_id *oid, - struct strbuf *referent, unsigned int *type); + struct strbuf *referent, unsigned int *type, + int *failure_errno); /* * Fill in the generic part of refs and add it to our collection of From patchwork Sun Jul 11 16:30: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: 12369241 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-15.8 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,FREEMAIL_FORGED_FROMDOMAIN,FREEMAIL_FROM, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 5A244C07E9C for ; Sun, 11 Jul 2021 16:30:58 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 45AFD61182 for ; Sun, 11 Jul 2021 16:30:58 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232648AbhGKQdo (ORCPT ); Sun, 11 Jul 2021 12:33:44 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:40726 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232640AbhGKQdk (ORCPT ); Sun, 11 Jul 2021 12:33:40 -0400 Received: from mail-wm1-x332.google.com (mail-wm1-x332.google.com [IPv6:2a00:1450:4864:20::332]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 6B5F5C0613E5 for ; Sun, 11 Jul 2021 09:30:52 -0700 (PDT) Received: by mail-wm1-x332.google.com with SMTP id l18-20020a1ced120000b029014c1adff1edso12553594wmh.4 for ; Sun, 11 Jul 2021 09:30:52 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=bPjsclnnKKfm4eVG4vfMZB0exx266GwZmnGqzPzs+JY=; b=abeatMbHvjrV3dHOVi94hSmwBp4YaW1X134LRx3S+uaxisZtFIP5SDlcrI+j6AAili Pp17ncmaZpCaF39DsXJq8NKn0E5m0GbzDQ4yYwaqznyehU3qWxFXM5Qr79Eh372SYo5z XJPvjb1xYkEW2tsp1BoJbUA+zY9vPcwbvDgYN6PrurPh81QNgC1CSqEHiHF+uN5myEkU Mj5zrVfBMsC02RF6ZV/+rDMeFqfFy8X3njQN7FgNfPStNG3Dv6roZSVcXmosoyK8FhQ2 zVan86hli+kBL+B9r+DAfXE0RsVxPUHyUH8zWn6/mnKyH2PYdAH4K95KnVmnHvaOOnlm uBww== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=bPjsclnnKKfm4eVG4vfMZB0exx266GwZmnGqzPzs+JY=; b=iJGCX8InR4zzSFsI6s2amCAGZoB2Dc5rE9t2dRGc3iG2aSd/l+IxfA4rmLekuYECjz pNVT25Y0N3j/+yeDM4REq37uMor9itFYulvT8xf17wB2H31uweMPBvlsFtsD/JJu1hHW tqUiBFsgaO5e31BfjkeG+ifP9kWTHfuDtRF94Yb3wYOdK/6oCGqaMES78pFhpW6aT3E/ FT1K4b0+KvH884DQteGx5CoG7pXNLxQildfarJnbF9XEsRIR4RkDitaymCXh+zObs6Cs ywHd1eK8LPqpe5dAw9VUhYsBVnAUH3EjiPFijfa5uBqr+bhrTaAulbwMzoo24idlCVTB Ia4A== X-Gm-Message-State: AOAM531/snUz1Rl0vjMFiflj7SPHbXBAzLpYu/Cku9Unrilx3Q0sO70I TDQQUvC0GXeZmJVddBEUx8AniEVrZ7RiGQ== X-Google-Smtp-Source: ABdhPJzNvLq4dnpIb/IitEuTF190SZ8mGKhmq2y3Q2fFgU+v3FLUD6cmkmTDqaUoiaWAPRPHOvdFeg== X-Received: by 2002:a05:600c:2197:: with SMTP id e23mr25600981wme.101.1626021050821; Sun, 11 Jul 2021 09:30:50 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id w3sm678091wrt.55.2021.07.11.09.30.49 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 11 Jul 2021 09:30:50 -0700 (PDT) From: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= To: git@vger.kernel.org Cc: Junio C Hamano , Jeff King , Han-Wen Nienhuys , Jonathan Tan , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBC?= =?utf-8?b?amFybWFzb24=?= Subject: [PATCH v6? 06/17] refs: make errno output explicit for refs_resolve_ref_unsafe Date: Sun, 11 Jul 2021 18:30:30 +0200 Message-Id: X-Mailer: git-send-email 2.32.0-dev In-Reply-To: References: MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org From: Han-Wen Nienhuys This introduces refs_resolve_ref_unsafe_with_errno(), which makes the API contract for the errno output explicit. The implementation still relies on the global errno variable to ensure no side effects of this refactoring. lock_ref_oid_basic() in files-backend.c is the only caller of refs_resolve_ref() that needs error information to make logic decisions, so update that caller Signed-off-by: Han-Wen Nienhuys Signed-off-by: Ævar Arnfjörð Bjarmason --- refs.c | 2 +- refs.h | 11 +++++++++++ refs/files-backend.c | 14 ++++++++------ 3 files changed, 20 insertions(+), 7 deletions(-) diff --git a/refs.c b/refs.c index af01a692cb9..1dacb5fe27b 100644 --- a/refs.c +++ b/refs.c @@ -1687,7 +1687,7 @@ int refs_read_raw_ref(struct ref_store *ref_store, const char *refname, type, failure_errno); } -static const char *refs_resolve_ref_unsafe_with_errno(struct ref_store *refs, +const char *refs_resolve_ref_unsafe_with_errno(struct ref_store *refs, const char *refname, int resolve_flags, struct object_id *oid, diff --git a/refs.h b/refs.h index 48970dfc7e0..344a3c51a8c 100644 --- a/refs.h +++ b/refs.h @@ -68,6 +68,17 @@ const char *refs_resolve_ref_unsafe(struct ref_store *refs, int resolve_flags, struct object_id *oid, int *flags); +/** + * refs_resolve_ref_unsafe_with_errno() is like + * refs_resolve_ref_unsafe(), but provide access to errno code that + * lead to a failure. We guarantee that errno is set to a meaningful + * value on non-zero return. + */ +const char *refs_resolve_ref_unsafe_with_errno(struct ref_store *refs, + const char *refname, + int resolve_flags, + struct object_id *oid, + int *flags, int *failure_errno); const char *resolve_ref_unsafe(const char *refname, int resolve_flags, struct object_id *oid, int *flags); diff --git a/refs/files-backend.c b/refs/files-backend.c index 702e38a2b06..d6ee7c1172f 100644 --- a/refs/files-backend.c +++ b/refs/files-backend.c @@ -935,6 +935,7 @@ static struct ref_lock *lock_ref_oid_basic(struct files_ref_store *refs, int mustexist = (old_oid && !is_null_oid(old_oid)); int resolve_flags = RESOLVE_REF_NO_RECURSE; int resolved; + int resolve_errno = 0; files_assert_main_repository(refs, "lock_ref_oid_basic"); assert(err); @@ -947,10 +948,11 @@ static struct ref_lock *lock_ref_oid_basic(struct files_ref_store *refs, resolve_flags |= RESOLVE_REF_ALLOW_BAD_NAME; files_ref_path(refs, &ref_file, refname); - resolved = !!refs_resolve_ref_unsafe(&refs->base, - refname, resolve_flags, - &lock->old_oid, type); - if (!resolved && errno == EISDIR) { + resolved = !!refs_resolve_ref_unsafe_with_errno(&refs->base, refname, + resolve_flags, + &lock->old_oid, type, + &resolve_errno); + if (!resolved && resolve_errno == EISDIR) { /* * we are trying to lock foo but we used to * have foo/bar which now does not exist; @@ -970,14 +972,14 @@ static struct ref_lock *lock_ref_oid_basic(struct files_ref_store *refs, &lock->old_oid, type); } if (!resolved && - (errno != ENOTDIR || + (resolve_errno != ENOTDIR || /* in case of D/F conflict, try to generate a better error * message. If that fails, fall back to strerror(ENOTDIR). */ !refs_verify_refname_available(&refs->base, refname, extras, skip, err))) { strbuf_addf(err, "unable to resolve reference '%s': %s", - refname, strerror(errno)); + refname, strerror(resolve_errno)); goto error_return; } From patchwork Sun Jul 11 16:30: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: 12369243 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-15.8 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,FREEMAIL_FORGED_FROMDOMAIN,FREEMAIL_FROM, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id EA6D5C07E9B for ; Sun, 11 Jul 2021 16:30:58 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id CF32F61183 for ; Sun, 11 Jul 2021 16:30:58 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232746AbhGKQdp (ORCPT ); Sun, 11 Jul 2021 12:33:45 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:40738 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232679AbhGKQdk (ORCPT ); Sun, 11 Jul 2021 12:33:40 -0400 Received: from mail-wm1-x32a.google.com (mail-wm1-x32a.google.com [IPv6:2a00:1450:4864:20::32a]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 67A23C0613EE for ; Sun, 11 Jul 2021 09:30:53 -0700 (PDT) Received: by mail-wm1-x32a.google.com with SMTP id a5-20020a7bc1c50000b02901e3bbe0939bso9711638wmj.0 for ; Sun, 11 Jul 2021 09:30:53 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=UBvGiZFOHzWy6eephCuM9Ij7J4C+tYPO23bkdiPO5vM=; b=AYnzDWRP7k/wPH/3NlnOk7LlOwhyJPLDoEtB0k9mA1ABSzcynMtOmrQHQmSs3M4/pB 1lBvFyzKwEbRdYfA3vDxc06v1UxD/3tOQbNgXDvPCSMvFtKCAOSYeBidcFpbIgL4Edit G6+Gm0V0lIB1uQhUNe1JDESMj7ao6xUx6BIysAJX9kI/1XTHDsqeUhynP+Z6kRay9oMg VevUgKSz+BXlPBy2L9Gl2G8p1ahcHUabmsjOfJZyDuRludjYiehPKZtpGKHnxE/MWMHt tb2if9VH2Jm9RCLsbvZngcfdXgcNho7eLi6RB30R2bMbyVoiVU+//5KWStMbMyZfdS6V tWQw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=UBvGiZFOHzWy6eephCuM9Ij7J4C+tYPO23bkdiPO5vM=; b=D9U4B4RCj0Gwp3/VFLQRwgdqyw+gOpfGXXkHbUBiXOrGfZkFdFi6nlhGO/kNHRUB91 OXglSIJrLBVPsVDlwKzc67W+gtOXBLVrVh9O4jI557FeXBa1tX4tiK1KTfYU/GRsRZ7K SXw1ca62WUm+TT+j4YUT6hmkNwzlDb3NK8pDaVYsEkI5nGMth9hkMQLvAOQ99J/BSAvu pjzs/70tiNN2qHNT2koBeEs9gCrPDHI4l0y30xyHjbhiCJc6WzlCt/FQ0Qrhj4Q+8eMr haZbI1SyxX5ffi2mvQ61fHQ2Fqo7vxTv59LW3CL2yekhhtzYyEe5Hkz0ikql4lSfHv8J ULiw== X-Gm-Message-State: AOAM532k6g5iJ7LKid4WcBDXoxg8VYGMIuZgV7o1/hetBwSdyjY8cwrQ X/IVEYzCB5rohj64AHDYQMtvJfGAqAlm7Q== X-Google-Smtp-Source: ABdhPJwB2M+VZLLmQFT7ocknmcuSdVboTg7xkJ7bGoGhBMJqXMGHwVnW9CFuQwPSCJiyMD99yQLm1Q== X-Received: by 2002:a05:600c:3501:: with SMTP id h1mr43862938wmq.157.1626021051724; Sun, 11 Jul 2021 09:30:51 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id w3sm678091wrt.55.2021.07.11.09.30.50 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 11 Jul 2021 09:30:51 -0700 (PDT) From: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= To: git@vger.kernel.org Cc: Junio C Hamano , Jeff King , Han-Wen Nienhuys , Jonathan Tan , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBC?= =?utf-8?b?amFybWFzb24=?= Subject: [PATCH v6? 07/17] refs: make errno ignoring explicit in lock_ref_oid_basic() Date: Sun, 11 Jul 2021 18:30:31 +0200 Message-Id: X-Mailer: git-send-email 2.32.0-dev In-Reply-To: References: MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org In the preceding commit we moved away from refs_resolve_ref_unsafe() in this function and started using a "resolve_errno" variable, which means that if this refs_resolve_ref_unsafe() invocation sets "errno" we'd end up ignoring it for our earlier "resolve_errno" (if any). I'm not sure if this is what we should be doing, but let's add a BUG() here for now to indicate that we hit a case we'd previously "handle", but which we now ignore. Signed-off-by: Ævar Arnfjörð Bjarmason --- refs/files-backend.c | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/refs/files-backend.c b/refs/files-backend.c index d6ee7c1172f..a4e9344ac8b 100644 --- a/refs/files-backend.c +++ b/refs/files-backend.c @@ -953,6 +953,7 @@ static struct ref_lock *lock_ref_oid_basic(struct files_ref_store *refs, &lock->old_oid, type, &resolve_errno); if (!resolved && resolve_errno == EISDIR) { + int ignore_errno = 0; /* * we are trying to lock foo but we used to * have foo/bar which now does not exist; @@ -967,9 +968,15 @@ static struct ref_lock *lock_ref_oid_basic(struct files_ref_store *refs, refname); goto error_return; } - resolved = !!refs_resolve_ref_unsafe(&refs->base, - refname, resolve_flags, - &lock->old_oid, type); + resolved = !!refs_resolve_ref_unsafe_with_errno(&refs->base, + refname, resolve_flags, + &lock->old_oid, type, + &ignore_errno); + if (ignore_errno) + BUG("hit errno %d (%s) that will be ignored, " + "resolve errno is %d (%s)", + ignore_errno, strerror(ignore_errno), + resolve_errno, strerror(resolve_errno)); } if (!resolved && (resolve_errno != ENOTDIR || From patchwork Sun Jul 11 16:30: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: 12369249 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-15.8 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,FREEMAIL_FORGED_FROMDOMAIN,FREEMAIL_FROM, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 79130C07E9B for ; Sun, 11 Jul 2021 16:31:01 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 65EAC6117A for ; Sun, 11 Jul 2021 16:31:01 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232813AbhGKQdr (ORCPT ); Sun, 11 Jul 2021 12:33:47 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:40752 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232600AbhGKQdo (ORCPT ); Sun, 11 Jul 2021 12:33:44 -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 45060C0613F0 for ; Sun, 11 Jul 2021 09:30:54 -0700 (PDT) Received: by mail-wr1-x42d.google.com with SMTP id d12so20507661wre.13 for ; Sun, 11 Jul 2021 09:30:54 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=slVCEbpC68iN+1wykIByDC9NFAOozpz9S0n3idpjG/8=; b=PuB0dqCNIypR1iPNe14nHlWIwg8NG9RXMkUdTgu/rr7Zfd6DvkE75M3EtnqsU/1qvW HVSQcQ88iGMJxQ05fX37ozsBvBgkGFVLnBVtmqXAmYqCnouXcfaelsEVd6YRPy00wxPv DbxZXAfZFaJl6ihPi7tzBMKXXc5XSm2Waz9LL2f9hIbY38wdIbA4OliV0hEw0oIx7R2F bvHsVLU+cUSmb5oc/El2V+dLOTWvUfyqx1Vcg2YFofcyOn6KEk4djB/Ge7HUl1ZbqYro LIEfxhSCLWVwoxhydEfnRIV3hmBNS61Gvmdb+YuxpClm8zHebxLEp7KwTMavxs4I+zJ1 /Nkw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=slVCEbpC68iN+1wykIByDC9NFAOozpz9S0n3idpjG/8=; b=ggaO5krCHqW8WliEPjZ8CNll4VJ+a2gVfPBZM+XCvC6LFU3x8mie8aLTnrAz7PqBQP u49mAVobMusTloy8232kZ9hnqKVWLFVAc09gLDNP4UzS2Gd0G7o65GwlvTR4V8AO5Ypo oBrpaP7TU/zV0zRCrhfrPCuWwVWekten5+xSgCLdG8s7Dy/MpJ+FVZNdSbaJiLx28rK8 +CIPeiTF2Qeda5anJErfRRGuoyeEMXFb8XE0pwRNfhVB7n9o4/J5IhgnpNdLDN7FJXMr Z1dIQu8jeiawS8Xygm+IKJ3N7giOgfzgTifFlQcoW5N0qxc7m8wrpHxbrEmhAlX+e8q+ N5aA== X-Gm-Message-State: AOAM533wI9pNOGtI6/N2EWJmhA5mTWDLp/NE3C32EKhVS4BwnMZIGhIw 5wKIH6rkKxwZuqjMqW3xvb3XrCH1i7t7KQ== X-Google-Smtp-Source: ABdhPJxRqI4w7YbTAEpTWKxcdBtHzDLG9wGvlvzC2OMI/dHHisRlnpaVFLxbpGwE20PuF7qOl285Ug== X-Received: by 2002:a05:6000:1141:: with SMTP id d1mr28651665wrx.396.1626021052617; Sun, 11 Jul 2021 09:30:52 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id w3sm678091wrt.55.2021.07.11.09.30.51 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 11 Jul 2021 09:30:52 -0700 (PDT) From: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= To: git@vger.kernel.org Cc: Junio C Hamano , Jeff King , Han-Wen Nienhuys , Jonathan Tan , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBC?= =?utf-8?b?amFybWFzb24=?= Subject: [PATCH v6? 08/17] refs file-backend.c: stop setting "EBUSY" in verify_lock() Date: Sun, 11 Jul 2021 18:30:32 +0200 Message-Id: X-Mailer: git-send-email 2.32.0-dev In-Reply-To: References: MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org This EBUSY was set in 835e3c992fd (refs.c: verify_lock should set errno to something meaningful, 2014-06-20) to fix a bug in code that was later refactored in cd94f765720 (fetch.c: change s_update_ref to use a ref transaction, 2014-04-28) to not use errno at all, the two were a part of the same series. So this was only ever needed for an intra-series bugfix, and we kept it around for no reason. Removing it makes subsequent commits where we refactor code surrounding verify_lock() (which may use errno) easier to reason about. Signed-off-by: Ævar Arnfjörð Bjarmason --- refs/files-backend.c | 3 --- 1 file changed, 3 deletions(-) diff --git a/refs/files-backend.c b/refs/files-backend.c index a4e9344ac8b..abed0572fea 100644 --- a/refs/files-backend.c +++ b/refs/files-backend.c @@ -880,9 +880,7 @@ static int verify_lock(struct ref_store *ref_store, struct ref_lock *lock, mustexist ? RESOLVE_REF_READING : 0, &lock->old_oid, NULL)) { if (old_oid) { - int save_errno = errno; strbuf_addf(err, "can't verify ref '%s'", lock->ref_name); - errno = save_errno; return -1; } else { oidclr(&lock->old_oid); @@ -894,7 +892,6 @@ static int verify_lock(struct ref_store *ref_store, struct ref_lock *lock, lock->ref_name, oid_to_hex(&lock->old_oid), oid_to_hex(old_oid)); - errno = EBUSY; return -1; } return 0; From patchwork Sun Jul 11 16:30:33 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: 12369251 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-15.8 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,FREEMAIL_FORGED_FROMDOMAIN,FREEMAIL_FROM, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id B8893C07E96 for ; Sun, 11 Jul 2021 16:31:02 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id A07D061175 for ; Sun, 11 Jul 2021 16:31:02 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232819AbhGKQds (ORCPT ); Sun, 11 Jul 2021 12:33:48 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:40756 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232661AbhGKQdo (ORCPT ); Sun, 11 Jul 2021 12:33:44 -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 DD593C061787 for ; Sun, 11 Jul 2021 09:30:54 -0700 (PDT) Received: by mail-wr1-x42b.google.com with SMTP id r11so15889108wro.9 for ; Sun, 11 Jul 2021 09:30:54 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=FdL2+R2Jjft+ZwBfwukMjoVQZrRrFOveq9+G63RgWsE=; b=bOHYLqNAT5YX296PBty+SPOcWcG6H/5qcTbX18RKhRaoOtcYpMgISiQ1Fms4mfskCH Pwdm3rgprrJBl5OiGUGH8+Sq9Tub5PdWT0n1Pg8gFjx5/hhvxUcE9nNLpl0MKp0P1oH0 hT+JgkkbqCGZdhOKEnHHr0hCr83XH/TwYtlJXkrf5zLcME3ReC8TuN+8K2mLXKYl5WN/ 044AoegvIkTMAnzTbO41wG5EEStxddNqQShkOc/1wgzfqqtnwPQ6MNkYP6RP+myy1vpH cIz4pLAgQ6/tc3apsxlmGqXlBMqrl7k5lTldnQofrLVDrKrBz54/TlBBhcPzgXAq/mXI 0Z0g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=FdL2+R2Jjft+ZwBfwukMjoVQZrRrFOveq9+G63RgWsE=; b=L01O5Toofg2PjzKNpSEI0QyXxQKDRamNj4zkXkIHFDESF31vuwpFjeyPP8aPW+8UVc o2Z+HcgXC2U6eVTle5YaR4PimXzt/7TWtJ7n56tyKg7BDxUW1UuSfq4nMqIWY0qb8ulF 0DSbsoLAIBp6QEo+4SE+3nviLlsYGsTbugu2eL1LDDO55IXrdgPyKkcfW3p8XjiM4yCl LLqeKxHgoFkxtXbH0v5dZtSyvOsJTQtymckP4/OMqxV8t7ajy5UY0tOzp7Nt87dNHu9y mI/GfouVKlLN7WBWFqvTGnqLyM8vayQ3cxqHbnpjoHlNdQ4UIx/vUqIGeWXAXKbXhHvi lo/Q== X-Gm-Message-State: AOAM532C5j3XNzWc02+XrTslO/seRwbTbVPWMSgaBUPstqfonD5hN2+I YggboTVH27M6rjrYWWYJjt2NB5w1NZkttQ== X-Google-Smtp-Source: ABdhPJw2Xv687K8noLKYXCpW9GTxS6h1EjFxxVEfB7784TZcMh2LBe7URW9Vea3TXRHRUcLX0JL13w== X-Received: by 2002:a5d:48ca:: with SMTP id p10mr53722646wrs.87.1626021053331; Sun, 11 Jul 2021 09:30:53 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id w3sm678091wrt.55.2021.07.11.09.30.52 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 11 Jul 2021 09:30:52 -0700 (PDT) From: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= To: git@vger.kernel.org Cc: Junio C Hamano , Jeff King , Han-Wen Nienhuys , Jonathan Tan , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBC?= =?utf-8?b?amFybWFzb24=?= Subject: [PATCH v6? 09/17] refs file-backend.c: deal with errno directly in verify_lock() Date: Sun, 11 Jul 2021 18:30:33 +0200 Message-Id: X-Mailer: git-send-email 2.32.0-dev In-Reply-To: References: MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org Instead of using the refs_read_ref_full() wrapper function let's use the refs_resolve_ref_unsafe_with_errno() function it resolves to (note the inverted return values). Per a preceding change to remove an "errno" assignment from verify_lock() we can explicitly ignore errno here, we use the strbuf "err" API instead. Signed-off-by: Ævar Arnfjörð Bjarmason --- refs/files-backend.c | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/refs/files-backend.c b/refs/files-backend.c index abed0572fea..e3d27001b86 100644 --- a/refs/files-backend.c +++ b/refs/files-backend.c @@ -874,11 +874,12 @@ static int verify_lock(struct ref_store *ref_store, struct ref_lock *lock, const struct object_id *old_oid, int mustexist, struct strbuf *err) { + int ignore_errno; assert(err); - if (refs_read_ref_full(ref_store, lock->ref_name, - mustexist ? RESOLVE_REF_READING : 0, - &lock->old_oid, NULL)) { + if (!refs_resolve_ref_unsafe_with_errno(ref_store, lock->ref_name, + mustexist ? RESOLVE_REF_READING : 0, + &lock->old_oid, NULL, &ignore_errno)) { if (old_oid) { strbuf_addf(err, "can't verify ref '%s'", lock->ref_name); return -1; From patchwork Sun Jul 11 16:30:34 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: 12369245 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-15.8 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,FREEMAIL_FORGED_FROMDOMAIN,FREEMAIL_FROM, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id BB541C11F66 for ; Sun, 11 Jul 2021 16:30:59 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 9E18161182 for ; Sun, 11 Jul 2021 16:30:59 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232768AbhGKQdp (ORCPT ); Sun, 11 Jul 2021 12:33:45 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:40758 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232613AbhGKQdn (ORCPT ); Sun, 11 Jul 2021 12:33:43 -0400 Received: from mail-wm1-x332.google.com (mail-wm1-x332.google.com [IPv6:2a00:1450:4864:20::332]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id AE161C061788 for ; Sun, 11 Jul 2021 09:30:55 -0700 (PDT) Received: by mail-wm1-x332.google.com with SMTP id k31-20020a05600c1c9fb029021727d66d33so8256521wms.0 for ; Sun, 11 Jul 2021 09:30:55 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=PqWzZgLjH6vj+2q3SCxhBeG56Hl1Jm7qgAN8iW9Zc0A=; b=kJAHqxCnQLCbOZul52KC1d8q16/LDT8ly/Ddjnytaitb04PoHUtWedDm2MUqgB9/0+ cteP57OY6UIfopAFZ7wG1hmtSIWzDNZl6p97961WxaWTTUIEwj15vV42S3/yIp3iTwxZ FhH8139hSOPw95BEmg3DA9c/XQnspZJZtLl718CR1A/maNj5+kHTBXd8vnJxh2p8f7WD LHuMaLR3E2UrsFkvwVSvckLGl8nbyHz2ao+zk295TH3mAiFORXPhiT7EawKDUofWMvhn gUioh6VHoiOP/diHwiXfg/vkNgKk8ODahKrSuHDZNwfF/CY6PfRXLI9Hbyv+rP6AKSr0 FBjQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=PqWzZgLjH6vj+2q3SCxhBeG56Hl1Jm7qgAN8iW9Zc0A=; b=XnZAIiI+Ta/YgTgVAQMelrA0xhoHD2/kan42tFn/Xe9z1LfOaAHXSNexNW8t8+OXoT PUM8bmNOwFgAVe9N9/yO7boLBffKo+3IPXJPN58GCFRHPuHEtkNm8iMymISG69dSoU1c htTQ1GGqwWGFBBdVUaWT9KDBECgEIyFZBUW7i1UYynZ4oWfi9AjnAaULL2mi8skzxXbZ rqoLTyudjEY9IZx8KwlIE3+itxXNA3ttHFd+vME3hTLFeAtZ7/ONpdCJgjYJRfC3ZM4t YqMpDE0pkGjmW6nN0Ho2CnPO05V8DA/aYnNrwmwC/JSI5nZ6StqLYhWsgbtaFihvQr75 Cdqw== X-Gm-Message-State: AOAM531iuXub4YQmsS4f7cGyM0ei4V/h4n0NBTJUgGZaNqsS+piRo6pg KLl8IjmX9PcE9s/73Fjg47w8nqxpQa95NA== X-Google-Smtp-Source: ABdhPJyTzwxUxingg2k8WIhU8WgtwcHzOQ/VTZDjejDWZ8UZaxEHL0VXY0M3t8kW0/HXdTnpN3xTZA== X-Received: by 2002:a7b:c84d:: with SMTP id c13mr10235452wml.30.1626021054108; Sun, 11 Jul 2021 09:30:54 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id w3sm678091wrt.55.2021.07.11.09.30.53 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 11 Jul 2021 09:30:53 -0700 (PDT) From: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= To: git@vger.kernel.org Cc: Junio C Hamano , Jeff King , Han-Wen Nienhuys , Jonathan Tan , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBC?= =?utf-8?b?amFybWFzb24=?= Subject: [PATCH v6? 10/17] refs API: remove refs_read_ref_full() wrapper Date: Sun, 11 Jul 2021 18:30:34 +0200 Message-Id: X-Mailer: git-send-email 2.32.0-dev 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_resolve_ref_unsafe_with_errno() 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 | 22 ++++++++++------------ refs.h | 2 -- refs/files-backend.c | 30 +++++++++++++++++++----------- worktree.c | 9 +++++---- 4 files changed, 34 insertions(+), 29 deletions(-) diff --git a/refs.c b/refs.c index 1dacb5fe27b..91320f092fb 100644 --- a/refs.c +++ b/refs.c @@ -294,20 +294,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_resolve_ref_unsafe_with_errno(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); @@ -1398,9 +1395,10 @@ int refs_head_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data) { struct object_id oid; int flag; - - if (!refs_read_ref_full(refs, "HEAD", RESOLVE_REF_READING, - &oid, &flag)) + int ignore_errno; + + if (refs_resolve_ref_unsafe_with_errno(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 344a3c51a8c..d80184dd8e0 100644 --- a/refs.h +++ b/refs.h @@ -88,8 +88,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 e3d27001b86..b3bc2f57387 100644 --- a/refs/files-backend.c +++ b/refs/files-backend.c @@ -1342,6 +1342,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); @@ -1399,9 +1400,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_resolve_ref_unsafe_with_errno(&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) { @@ -1815,9 +1816,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_resolve_ref_unsafe_with_errno(&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); @@ -2093,6 +2097,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; @@ -2104,9 +2109,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_resolve_ref_unsafe_with_errno(iter->ref_store, + diter->relative_path, 0, + &iter->oid, &flags, + &ignore_errno)) { error("bad ref for %s", diter->path.buf); continue; } @@ -2450,9 +2456,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_resolve_ref_unsafe_with_errno(&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 237517baee6..1dcdb481d61 100644 --- a/worktree.c +++ b/worktree.c @@ -562,16 +562,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_resolve_ref_unsafe_with_errno(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 Sun Jul 11 16:30:35 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: 12369247 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-15.8 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,FREEMAIL_FORGED_FROMDOMAIN,FREEMAIL_FROM, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 0CC8EC07E96 for ; Sun, 11 Jul 2021 16:31:01 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id EB4E661178 for ; Sun, 11 Jul 2021 16:31:00 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232788AbhGKQdq (ORCPT ); Sun, 11 Jul 2021 12:33:46 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:40748 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232625AbhGKQdn (ORCPT ); Sun, 11 Jul 2021 12:33:43 -0400 Received: from mail-wr1-x433.google.com (mail-wr1-x433.google.com [IPv6:2a00:1450:4864:20::433]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 57275C061793 for ; Sun, 11 Jul 2021 09:30:56 -0700 (PDT) Received: by mail-wr1-x433.google.com with SMTP id f9so15458969wrq.11 for ; Sun, 11 Jul 2021 09:30:56 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=bJHfKOKPqgfi4LZvpQMrDOShrxS8fJLbsRy+4PtGM8Y=; b=dOIaC3Fl9CLEklx5ePTl09nAaTmC8GK3iuIjXZSF5ppz6lY10q/UJGkJO+omxScCKR l8KEMqHUqcX2ctOUfAiRL4k00JiUFpJH1D244UiepSTdMgRqjA3QRui5nrQ6FBFKahQ4 i9J/Ne4MFIWbAf9LRBxT+rYkCJb4BCZ/AR4H6plV6Sg9yvMpszLgbmvRtYb5eeqFU0lG To4wgSRHdES+ljIXJYyOI2cc3wc+9kDNoWLmwBkBEBCc/FeahXUsRDl4ngJy1FjTYS+U e0k1Xxxt9cmKgqkd0EdayEoNiwuu4SHeqvQcZRN+/AVJN4T7CMy8jck/shFNRPY/HnJI qTCQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=bJHfKOKPqgfi4LZvpQMrDOShrxS8fJLbsRy+4PtGM8Y=; b=QQjFZ4cAJb3dJqX0cRTaZB81TlzOTHLWeD4O9PEaUJdrSH1OYkGpKL+RuwvMPuWnw1 AlEOfLEy1MQQQ+4jzfmZ8U/+VpsXbeMjWj05nMC/4ZiIpFT4PTf1RpKGpMMn00JwY72S AV4ZJ/P6mjjecKfGIMzeVLIqefnc2KZB5rF80aKQdG/aw4tRU3BQvun1LU6AzaQ5qri9 1EKplNMFKkglzuhZsJQp7fWlIQey6YCqZM1MM3WkPK4aFL51MWddWPr6HVqkvZYFOp29 68TsgzooBxHEc15XgWXOan8DzEPo8TGLDLVdq/4a+R93MhtwwKfqFUBDgMXJn2AtUSYz fpuw== X-Gm-Message-State: AOAM533Z0AHen5eqaf4zfG5GoeXIJFPftflbGx37IzEdhayWXfWNK7vK V8GRBRWCa9dqCjGusGVzmRmTf2JyoJPyAA== X-Google-Smtp-Source: ABdhPJyE5rYmv/eUbH10n5y/T/Y4woJkmxr//wfLmcHaBha1an8X4ghEjQf2coKTxMjZxbIiCCi1MA== X-Received: by 2002:a5d:4a0f:: with SMTP id m15mr15856220wrq.350.1626021054797; Sun, 11 Jul 2021 09:30:54 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id w3sm678091wrt.55.2021.07.11.09.30.54 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 11 Jul 2021 09:30:54 -0700 (PDT) From: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= To: git@vger.kernel.org Cc: Junio C Hamano , Jeff King , Han-Wen Nienhuys , Jonathan Tan , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBC?= =?utf-8?b?amFybWFzb24=?= Subject: [PATCH v6? 11/17] refs API: make resolve_gitlink_ref() not set errno Date: Sun, 11 Jul 2021 18:30:35 +0200 Message-Id: X-Mailer: git-send-email 2.32.0-dev 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_resolve_ref_unsafe_with_errno(), 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 91320f092fb..7a9cdb1d720 100644 --- a/refs.c +++ b/refs.c @@ -1814,14 +1814,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_resolve_ref_unsafe_with_errno(refs, refname, 0, oid, &flags, + &ignore_errno) || is_null_oid(oid)) return -1; return 0; } From patchwork Sun Jul 11 16:30:36 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: 12369253 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-15.8 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,FREEMAIL_FORGED_FROMDOMAIN,FREEMAIL_FROM, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 97568C07E9B for ; Sun, 11 Jul 2021 16:31:03 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 823A96117A for ; Sun, 11 Jul 2021 16:31:03 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232822AbhGKQdt (ORCPT ); Sun, 11 Jul 2021 12:33:49 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:40758 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232717AbhGKQdp (ORCPT ); Sun, 11 Jul 2021 12:33:45 -0400 Received: from mail-wm1-x329.google.com (mail-wm1-x329.google.com [IPv6:2a00:1450:4864:20::329]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 4520FC0613DD for ; Sun, 11 Jul 2021 09:30:57 -0700 (PDT) Received: by mail-wm1-x329.google.com with SMTP id l17-20020a05600c1d11b029021f84fcaf75so2738254wms.1 for ; Sun, 11 Jul 2021 09:30:57 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=PCUNNcBmvvoCqS7c9KX/3qk8HkkrgW4bxUHoFrPnHAs=; b=BTWiEmtkrDpMRce7LU/tWyPK4gTOX7HtMht/otMmgZKKyt2SSI0Xkz1dCi7C7/S4DC PnyKanYm/vg519A5pg5JkvYHloKHf58L5qTIXBClSR4UgD2wLnzPhnmMfsReBFv99F6Q b5eEjXdCjx3nl8sDJoVcaC1D89pYpK2TF3IvWmw6rAvPoohh/FQi5Rf3O5ObhpEWHims lSgPpskxBfuDAlI6Lt/FJec3BywMLEWA78OaEuH4X9kZJz/6TXOGO+mWh8gaxJVBuadk F8v2wpmkKyifDxsBFIyXP1r8qTTN9rfcOhWmd/IgV4NTlqBSrihJ78b4/lM6QAF2HUcI D3ZQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=PCUNNcBmvvoCqS7c9KX/3qk8HkkrgW4bxUHoFrPnHAs=; b=IkzPGPG+DVIf2W3TPZIKjr+f8Cs4K0OTk4eC+NkOFk+pdA2/l9VFWwe3QEkTva2U/F HRu6EOCI2Xd/hBl8TnYe8KHAzWJR88o6g5LHkEvGIcTAPMd31Fp49I6kqPChWt3rfEFb d4ryoAA0eQn0M36Yw89fVXSkYn9I2EQtLU0hq98DiYItbBQH05b78f3i69jxwQtjEKpQ jNsL6BRF49yzRkvd+tzKiOSxdclZJScArm7Dpg3S0GwvMUeglNzOrlyF5DnxdYtm5Shh u6A5TSrjLL3cFex22r72JkphKxxZEoVI6PZEfNqONhTl6uAYel8N6M80pYwFKak6rZ3R letA== X-Gm-Message-State: AOAM533pPcERC2YJVji5t2PunHGnj1w2+rOMfWPM6tiD+RE/SdCza+wV Imm7oY5GgaolfxnzWwWuXXjDAAUyUl9UfA== X-Google-Smtp-Source: ABdhPJxYYuAii0vtfvgB35GEUEhySkmIGpa+v2J6WPBCWtC3SadKRiV8b/lLOx1v4JIgupYjzvyjhA== X-Received: by 2002:a05:600c:4304:: with SMTP id p4mr9758761wme.43.1626021055602; Sun, 11 Jul 2021 09:30:55 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id w3sm678091wrt.55.2021.07.11.09.30.54 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 11 Jul 2021 09:30:55 -0700 (PDT) From: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= To: git@vger.kernel.org Cc: Junio C Hamano , Jeff King , Han-Wen Nienhuys , Jonathan Tan , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBC?= =?utf-8?b?amFybWFzb24=?= Subject: [PATCH v6? 12/17] refs API: make refs_resolve_ref_unsafe() static Date: Sun, 11 Jul 2021 18:30:36 +0200 Message-Id: X-Mailer: git-send-email 2.32.0-dev In-Reply-To: References: MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org Remove public users of refs_resolve_ref_unsafe() over to refs_resolve_ref_unsafe_with_errno(), and explicitly ignore the provided errno in those callers. At that point the only remaining users are the legacy functions in refs.c itself, so we can make the wrapper static. Signed-off-by: Ævar Arnfjörð Bjarmason --- refs.c | 29 +++++++++++++++-------------- refs.h | 8 +------- refs/files-backend.c | 24 ++++++++++++++---------- t/helper/test-ref-store.c | 5 +++-- worktree.c | 18 ++++++++++++------ 5 files changed, 45 insertions(+), 39 deletions(-) diff --git a/refs.c b/refs.c index 7a9cdb1d720..214f3f4f79f 100644 --- a/refs.c +++ b/refs.c @@ -267,6 +267,21 @@ int ref_resolves_to_object(const char *refname, return 1; } +static 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_resolve_ref_unsafe_with_errno(refs, refname, resolve_flags, + oid, flags, &failure_errno); + if (!refn) + /* For unmigrated legacy callers */ + errno = failure_errno; + return refn; +} + char *refs_resolve_refdup(struct ref_store *refs, const char *refname, int resolve_flags, struct object_id *oid, int *flags) @@ -1780,20 +1795,6 @@ const char *refs_resolve_ref_unsafe_with_errno(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_resolve_ref_unsafe_with_errno(refs, refname, resolve_flags, - oid, flags, &failure_errno); - if (!refn) - /* For unmigrated legacy callers */ - errno = failure_errno; - return refn; -} - /* backend functions */ int refs_init_db(struct strbuf *err) { diff --git a/refs.h b/refs.h index d80184dd8e0..a3284adb8f8 100644 --- a/refs.h +++ b/refs.h @@ -63,14 +63,8 @@ struct worktree; #define RESOLVE_REF_NO_RECURSE 0x02 #define RESOLVE_REF_ALLOW_BAD_NAME 0x04 -const char *refs_resolve_ref_unsafe(struct ref_store *refs, - const char *refname, - int resolve_flags, - struct object_id *oid, - int *flags); /** - * refs_resolve_ref_unsafe_with_errno() is like - * refs_resolve_ref_unsafe(), but provide access to errno code that + * refs_resolve_ref_unsafe_with_errno() provides access to errno code that * lead to a failure. We guarantee that errno is set to a meaningful * value on non-zero return. */ diff --git a/refs/files-backend.c b/refs/files-backend.c index b3bc2f57387..158c0146484 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, 1)); } else { - if (!refs_resolve_ref_unsafe(&refs->base, - refname.buf, - RESOLVE_REF_READING, - &oid, &flag)) { + int ignore_errno; + if (!refs_resolve_ref_unsafe_with_errno(&refs->base, + refname.buf, + RESOLVE_REF_READING, + &oid, &flag, &ignore_errno)) { oidclr(&oid); flag |= REF_ISBROKEN; } else if (is_null_oid(&oid)) { @@ -1354,9 +1355,9 @@ static int files_copy_or_rename_ref(struct ref_store *ref_store, goto out; } - if (!refs_resolve_ref_unsafe(&refs->base, oldrefname, - RESOLVE_REF_READING | RESOLVE_REF_NO_RECURSE, - &orig_oid, &flag)) { + if (!refs_resolve_ref_unsafe_with_errno(&refs->base, oldrefname, + RESOLVE_REF_READING | RESOLVE_REF_NO_RECURSE, + &orig_oid, &flag, &ignore_errno)) { ret = error("refname %s not found", oldrefname); goto out; } @@ -1769,10 +1770,13 @@ 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", - RESOLVE_REF_READING, - NULL, &head_flag); + head_ref = refs_resolve_ref_unsafe_with_errno(&refs->base, + "HEAD", + RESOLVE_REF_READING, + NULL, &head_flag, + &ignore_errno); if (head_ref && (head_flag & REF_ISSYMREF) && !strcmp(head_ref, lock->ref_name)) { struct strbuf log_err = STRBUF_INIT; diff --git a/t/helper/test-ref-store.c b/t/helper/test-ref-store.c index bba5f841c6a..ca69a793171 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_resolve_ref_unsafe_with_errno(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 1dcdb481d61..1dbdec82461 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), - "HEAD", - 0, - &wt->head_oid, &flags); + target = refs_resolve_ref_unsafe_with_errno(get_worktree_ref_store(wt), + "HEAD", + 0, + &wt->head_oid, &flags, + &ignore_errno); if (!target) return; @@ -417,6 +419,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; @@ -433,8 +436,11 @@ 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_resolve_ref_unsafe_with_errno(refs, + symref, + 0, NULL, + &flags, + &ignore_errno); if ((flags & REF_ISSYMREF) && symref_target && !strcmp(symref_target, target)) { existing = wt; From patchwork Sun Jul 11 16:30:37 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: 12369255 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-15.8 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,FREEMAIL_FORGED_FROMDOMAIN,FREEMAIL_FROM, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 051D6C07E9E for ; Sun, 11 Jul 2021 16:31:04 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id E68EC61178 for ; Sun, 11 Jul 2021 16:31:03 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232876AbhGKQdu (ORCPT ); Sun, 11 Jul 2021 12:33:50 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:40760 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232762AbhGKQdp (ORCPT ); Sun, 11 Jul 2021 12:33:45 -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 D9A0AC0613E5 for ; Sun, 11 Jul 2021 09:30:57 -0700 (PDT) Received: by mail-wr1-x42b.google.com with SMTP id i94so21116201wri.4 for ; Sun, 11 Jul 2021 09:30:57 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=0CzOF3oPc5FYJ+HpgSDbzr0Y8ARY09LQZWdRTgdKbgA=; b=ewUV/CqumwL1xrtD/igmSh0GOvqS1WobllNDtL0xRMjKSLIxP1HgDND5VwuR1AsbVs ziSD/sbwC+uzHJOt7u/CHhoBiI1ZbZeJCg5MDwNjduVVA+2mPchYWY3WPEgsv9JR8dfC xjq6uyrDJkfDxNErBlxUctVbIEw6kLKUFvdyyzQ3Yw3gyGLQ//MzEufgijcB1Ve4B+yk MWTrBne9dRZTY8VNqkCZjtbgDYoMl+P3iQnR5NhTrmJTbWX8o/RTQIMRo6yY3DzdpDnA MIx5470JK4GDySSOeX6jQuoMHZ+RjvGBMHJQoCWp8zQpMOII2D5+gw6EV15h0kkfemWa w1ww== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=0CzOF3oPc5FYJ+HpgSDbzr0Y8ARY09LQZWdRTgdKbgA=; b=ahdcBrPgpW/iThDCad0yc9iCDYW5hxGxAh2vJqvZEfgi5kv0yEkQje6r5UEA6U3AdW s4Le2QalSWr/jkd2fYmbAduFWglRCp03bB+IUDlxrLay5ntJRksZ6wbBi6am6qgSu4PS 5w4TLCXSS+q7fmOP6Dq+BFfpMqXxyBG5H6IPfgxdeoncS65mnSYrwVvaqhBA1XcfQW8W tvjmYFZ21EOkYpzTjnvIsnRZZQeb/98VIffik9oENrueXZQ0illuElW/x3WgLhyZ3c0q ZqVvlwOyZ9Qx3e3PnH7QAHxpXt9c92z+QS1K/etLBRXkvnDIzv55LuNBefXkj2g+a7Vw XyfA== X-Gm-Message-State: AOAM530acCIZuCQVRofnbgrRShmLYkMntmuQ4d5x3yRRpo/ogf277g17 lQNpiy4+VMjn5R4FjjvQKEU9fFiuF99Dqg== X-Google-Smtp-Source: ABdhPJyGwqkNkaaNfFodaW1Ake/06llMaXfAqKaSl8AV8UasOB6fhfn5Aq1J4If4fAbMueODFgfVYQ== X-Received: by 2002:adf:fb51:: with SMTP id c17mr55233562wrs.106.1626021056345; Sun, 11 Jul 2021 09:30:56 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id w3sm678091wrt.55.2021.07.11.09.30.55 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 11 Jul 2021 09:30:55 -0700 (PDT) From: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= To: git@vger.kernel.org Cc: Junio C Hamano , Jeff King , Han-Wen Nienhuys , Jonathan Tan , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBC?= =?utf-8?b?amFybWFzb24=?= Subject: [PATCH v6? 13/17] refs API: make refs_resolve_refdup() not set errno Date: Sun, 11 Jul 2021 18:30:37 +0200 Message-Id: X-Mailer: git-send-email 2.32.0-dev 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_resolve_ref_unsafe_with_errno(). 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 | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/refs.c b/refs.c index 214f3f4f79f..45b51c0a532 100644 --- a/refs.c +++ b/refs.c @@ -287,9 +287,11 @@ 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_resolve_ref_unsafe_with_errno(refs, refname, + resolve_flags, oid, flags, + &ignore_errno); return xstrdup_or_null(result); } From patchwork Sun Jul 11 16:30:38 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: 12369257 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-15.8 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,FREEMAIL_FORGED_FROMDOMAIN,FREEMAIL_FROM, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 3CEDAC07E96 for ; Sun, 11 Jul 2021 16:31:05 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 268EB61175 for ; Sun, 11 Jul 2021 16:31:05 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232917AbhGKQdv (ORCPT ); Sun, 11 Jul 2021 12:33:51 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:40762 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232774AbhGKQdq (ORCPT ); Sun, 11 Jul 2021 12:33:46 -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 A82D4C0613E8 for ; Sun, 11 Jul 2021 09:30:58 -0700 (PDT) Received: by mail-wr1-x42c.google.com with SMTP id f17so21148560wrt.6 for ; Sun, 11 Jul 2021 09:30:58 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=7oykJRG09Iyb1WUHShrrSrCpgMd8k5HFyoxkgJLjWMA=; b=pK30bb9s4TG0sOXpp8Bt2rbVTQesDLoj/Rxe1V8Og1fEiRN+FM91Gf9XFVbusqOfP/ sYGJjJNesMcu2NVZAtODxZP7K/fy/1U2wp2f+c5DJzycPV/fht3Z7ieW+NGR144An3wx 2yJSyMeqqntyvGefhYyuTumvLTSqevJhkAbaSeFIW5sWaWyqjKdYTMq9JT28FErkhajH 2dNtgYCehA6ikxGNzhwPHnMTbO23UaA6GTqIEbLA+zl2aUSNTFRbpSUe7JFbedDWhw+u KCcRS3SWQezocTuiZj8s/ceOJYgEL3FTQ8NgD4As9M3HXyvoNN85UzUPueAF/qRnZ8T7 JhgQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=7oykJRG09Iyb1WUHShrrSrCpgMd8k5HFyoxkgJLjWMA=; b=IJ3ZAwxjEheLCS1P3+TJ0zEh8/iarW2zCvPY90e8Te45/mbVSmSjsvmYgtpVcRy64R AGq3eN7k7f2stnqIvmV5RLgJzvH9k2d4GLzdOStsv+iIS/1wEcsX2djeUlemxcbSOSxG bTg3a+K04jO9sI9uXTQJgUz6s7OvgWvyhiJ3vgBXGS9csiiZoTl9ZgyUQUGsenC354tq wdm1hadC1z/NSMoZOZIXitR4XF4BIMosRwjjqGPZhuFpoSKCZSPd02BYqrl9OOeFokxp 0JIstPnl8xd68kWpdD9BQd5K1HtMafsYX6FsnGTplfrB5D6S6lOT/RqofF8UvuI1xxDj O2fQ== X-Gm-Message-State: AOAM532KOhFe8vCb1IKhh0j6VmD2YyvAmfrf+jgItbdL1EozmKj7MJEQ ZHTmVwTwb05cA/9RD1CRuQHpWWR+ACS//Q== X-Google-Smtp-Source: ABdhPJyNzMWV0ISEMOssndHsC89zbc65/Ry3dugdmdbaoNPy1AV6pWNWE+/Y6vgVkIup8CTLJV1nOw== X-Received: by 2002:adf:f8cd:: with SMTP id f13mr14634563wrq.328.1626021057119; Sun, 11 Jul 2021 09:30:57 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id w3sm678091wrt.55.2021.07.11.09.30.56 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 11 Jul 2021 09:30:56 -0700 (PDT) From: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= To: git@vger.kernel.org Cc: Junio C Hamano , Jeff King , Han-Wen Nienhuys , Jonathan Tan , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBC?= =?utf-8?b?amFybWFzb24=?= Subject: [PATCH v6? 14/17] refs API: make refs_ref_exists() not set errno Date: Sun, 11 Jul 2021 18:30:38 +0200 Message-Id: X-Mailer: git-send-email 2.32.0-dev 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_resolve_ref_unsafe_with_errno(). 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 | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/refs.c b/refs.c index 45b51c0a532..0364b68f8fa 100644 --- a/refs.c +++ b/refs.c @@ -329,7 +329,10 @@ 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_resolve_ref_unsafe_with_errno(refs, refname, + RESOLVE_REF_READING, NULL, + NULL, &ignore_errno); } int ref_exists(const char *refname) From patchwork Sun Jul 11 16:30:39 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: 12369259 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-15.8 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,FREEMAIL_FORGED_FROMDOMAIN,FREEMAIL_FROM, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 1868CC07E9B for ; Sun, 11 Jul 2021 16:31:06 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 007D761178 for ; Sun, 11 Jul 2021 16:31:05 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232762AbhGKQdw (ORCPT ); Sun, 11 Jul 2021 12:33:52 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:40756 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232792AbhGKQdr (ORCPT ); Sun, 11 Jul 2021 12:33:47 -0400 Received: from mail-wm1-x332.google.com (mail-wm1-x332.google.com [IPv6:2a00:1450:4864:20::332]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 74CFDC0613E9 for ; Sun, 11 Jul 2021 09:30:59 -0700 (PDT) Received: by mail-wm1-x332.google.com with SMTP id u5-20020a7bc0450000b02901480e40338bso8621498wmc.1 for ; Sun, 11 Jul 2021 09:30:59 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=HJB4h/BPmsQfEf0oxTBZeyv4+54xSoIbq0oBAmPjj3I=; b=PRSQWEzdeY8ZRZuq2tI6Wj/PcKO/7pOaxitbXznFW+bMGvpj2d9RiVLVwxvXfqazX7 swetODGCfB0+pucmdrh9ezu5og1+DtNml4TuI4KqRxMF16tnBkGBqd+wQHORU+ifm5v4 wcTkAytWqgJ3hc4F0xO50urwLhcVnF0ev5g/ABwVUmzFVeyMzofViuFe2HVHkI5UIxPT yArlS6uuGojGOwjCz64b03oQbpu4HHTvp9dUm8w0Bz9BcCUZaNnXlnCKkfJ9CW1SjrUt yPGMDCmWE7HoVRiKhEghinz5nAaso9a144sbbCupm1RmaPwIU7/KdWKgWYOpsgAMuC57 G4hQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=HJB4h/BPmsQfEf0oxTBZeyv4+54xSoIbq0oBAmPjj3I=; b=ujNHJTuBr0u8p9BEmVvdEZlA2rSTHjHsSr5ONcBPlFqrAn5VFp6CxOrwbED6JeZ/vS HLIxvDPMOdtBsCJekNlKZqQniWtJlYVkSdmNhw4oE8Xutn1EwPFBvlZPQmEMDkQEh4hU t4o8wbc/C/+H52KefW4mGOGd46CUjRG/AbaPeqcjt4ELf5gGOpW2yIS0B4w282MKTbyw zZ14grArFhKHdSvSb4zv8j0F2+GASceL1UhJEc9d0ZRMiPUxlekQTudWrg3Xtq8v+JNC 9rPo5El5SKnOjjEo9YkXCYnF68+vWnWwuyUeaYrVKHbi3pv4raPWhhW8XCULszeSi60z IsKQ== X-Gm-Message-State: AOAM532ZpzLf/iHSc+v/T5/XtZi93QI760byJibmBKOBLbCX7AnAIsyV Atx0196BerVcHdAbzv1icc5MOoHmTCqTOA== X-Google-Smtp-Source: ABdhPJyD901QIs6ZFy9Mu2e/hLe0MqlGEBCctmc0TrRmIsIuceUgM30r6kGEZGsjnj68GPCnzOaSpw== X-Received: by 2002:a1c:7407:: with SMTP id p7mr211057wmc.111.1626021057785; Sun, 11 Jul 2021 09:30:57 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id w3sm678091wrt.55.2021.07.11.09.30.57 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 11 Jul 2021 09:30:57 -0700 (PDT) From: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= To: git@vger.kernel.org Cc: Junio C Hamano , Jeff King , Han-Wen Nienhuys , Jonathan Tan , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBC?= =?utf-8?b?amFybWFzb24=?= Subject: [PATCH v6? 15/17] refs API: make resolve_ref_unsafe() not set errno Date: Sun, 11 Jul 2021 18:30:39 +0200 Message-Id: X-Mailer: git-send-email 2.32.0-dev 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 refs_resolve_ref_unsafe_with_errno() 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_resolve_ref_unsafe_with_errno() directly. Signed-off-by: Ævar Arnfjörð Bjarmason --- refs.c | 7 +++++-- sequencer.c | 10 ++++++++-- 2 files changed, 13 insertions(+), 4 deletions(-) diff --git a/refs.c b/refs.c index 0364b68f8fa..1d44027497e 100644 --- a/refs.c +++ b/refs.c @@ -1811,8 +1811,11 @@ 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); + struct ref_store *refs = get_main_ref_store(the_repository); + int ignore_errno; + + return refs_resolve_ref_unsafe_with_errno(refs, 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 0bec01cf38e..c4772413b86 100644 --- a/sequencer.c +++ b/sequencer.c @@ -1267,6 +1267,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) @@ -1316,9 +1318,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_resolve_ref_unsafe_with_errno(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 Sun Jul 11 16:30:40 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: 12369263 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-15.8 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,FREEMAIL_FORGED_FROMDOMAIN,FREEMAIL_FROM, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 5F56DC07E96 for ; Sun, 11 Jul 2021 16:31:08 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 4C3CC61175 for ; Sun, 11 Jul 2021 16:31:08 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232949AbhGKQdx (ORCPT ); Sun, 11 Jul 2021 12:33:53 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:40778 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232884AbhGKQdu (ORCPT ); Sun, 11 Jul 2021 12:33:50 -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 42764C0613EE for ; Sun, 11 Jul 2021 09:31:00 -0700 (PDT) Received: by mail-wr1-x42d.google.com with SMTP id l7so20211392wrv.7 for ; Sun, 11 Jul 2021 09:31:00 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=8nMyCyHolcaK2kOMgpAUGy+3zXJjg/kP9UbsXFu6KwQ=; b=a/7EW5rJD2h8C66/0tdBcidB6GSdSrcNKJHJbdI4V3T+acJNWaXpp6psyCQ/onssPu N1S7tL1FBcS20yr8zCKeTeh8yKOa0RlkDE3D1VO2GCWMxwM2So6K3pCpLa+76x6Dawop TOVWGtPuOkK1+9zmwKgnMsOvHN6LVPXT3yZxrf6ty+M98F0B7z5qfBlULazOKDldB8V6 Vw9YCdfb84lmTCI7uAMeMO7agtuKxXGdUAlySPJ644SK5Dodv44TkiCtoGheEl+fgmlN t++MNiMR0bW/HDh2EdM0bzAzbL44PoQulyQGfuvxVQ6QdnPaWo5gu8pgvSUu5IjdETFn SQ8Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=8nMyCyHolcaK2kOMgpAUGy+3zXJjg/kP9UbsXFu6KwQ=; b=ZRk+7IJ74petmrejFZ56Yj8PooQ+fkRiq2vV+2URd/9R/44opnbhgZOxV4jxOqT/0M 9h6hnE9hiwzXoxM3L4DHxyn9iUncWYrQaaZ6GSec8i04rKVM4XrPQOkWAjFssnWyRiZL ih54iQlWI+7CDmJcz2opXUo3gmGVxFrf15c2/HaQxkncJj8D9PZRS0HA5e+REAu3iqQE Z5f1u67UpJiVuqRcROtMrOKa9J2o8mBvRGG7qcHRpvzSo/hGM+QmvtVvv/VZT2negLV+ 4se2Kp8bbRudUo2wAJ7h5Sw9xe05kiF0D3UYt+heDaWk0w2k6P/nab/BZbO4hvMV8KCz RWSw== X-Gm-Message-State: AOAM531Uqvaq3xZR4Z/W/lNct/fCGp29Dk6OiNzjRxhwquXyPLYPGP2a D+cQ2f8IkvJPG4ZuWfUMMDg3xL5UzJc8Lw== X-Google-Smtp-Source: ABdhPJw5ieDGoejcF8eAZcJ4B7c18eHmYAsh6CAAyLBrg+RXSzPgYtYH47T6JXBvmSa+Gftb5XrAlQ== X-Received: by 2002:adf:b605:: with SMTP id f5mr54141232wre.419.1626021058660; Sun, 11 Jul 2021 09:30:58 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id w3sm678091wrt.55.2021.07.11.09.30.57 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 11 Jul 2021 09:30:58 -0700 (PDT) From: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= To: git@vger.kernel.org Cc: Junio C Hamano , Jeff King , Han-Wen Nienhuys , Jonathan Tan , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBC?= =?utf-8?b?amFybWFzb24=?= Subject: [PATCH v6? 16/17] refs API: make expand_ref() and repo_dwim_log() not set errno Date: Sun, 11 Jul 2021 18:30:40 +0200 Message-Id: X-Mailer: git-send-email 2.32.0-dev 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 | 32 +++++++++++--------------------- 1 file changed, 11 insertions(+), 21 deletions(-) diff --git a/refs.c b/refs.c index 1d44027497e..3357ba14e1d 100644 --- a/refs.c +++ b/refs.c @@ -267,21 +267,6 @@ int ref_resolves_to_object(const char *refname, return 1; } -static 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_resolve_ref_unsafe_with_errno(refs, refname, resolve_flags, - oid, flags, &failure_errno); - if (!refn) - /* For unmigrated legacy callers */ - errno = failure_errno; - return refn; -} - char *refs_resolve_refdup(struct ref_store *refs, const char *refname, int resolve_flags, struct object_id *oid, int *flags) @@ -675,13 +660,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_resolve_ref_unsafe_with_errno(refs, fullref.buf, + RESOLVE_REF_READING, + this_result, &flag, + &ignore_errno); if (r) { if (!refs_found++) *ref = xstrdup(r); @@ -710,12 +698,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, - RESOLVE_REF_READING, - &hash, NULL); + ref = refs_resolve_ref_unsafe_with_errno(refs, path.buf, + RESOLVE_REF_READING, + &hash, NULL, + &ignore_errno); if (!ref) continue; if (refs_reflog_exists(refs, path.buf)) From patchwork Sun Jul 11 16:30:41 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: 12369261 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-15.8 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,FREEMAIL_FORGED_FROMDOMAIN,FREEMAIL_FROM, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id A02F6C07E9E for ; Sun, 11 Jul 2021 16:31:06 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 89FE861176 for ; Sun, 11 Jul 2021 16:31:06 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232896AbhGKQdw (ORCPT ); Sun, 11 Jul 2021 12:33:52 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:40758 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232820AbhGKQds (ORCPT ); Sun, 11 Jul 2021 12:33:48 -0400 Received: from mail-wm1-x334.google.com (mail-wm1-x334.google.com [IPv6:2a00:1450:4864:20::334]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id EE6EEC0613DD for ; Sun, 11 Jul 2021 09:31:00 -0700 (PDT) Received: by mail-wm1-x334.google.com with SMTP id g12so1790583wme.2 for ; Sun, 11 Jul 2021 09:31:00 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=l3e+4dVxz7m4Dxf32tQc1AXV0BOf72Tt1Pj5m+DiaiY=; b=eud5JuPL6B7NqhLjWOYmhdmD9q/KLWfrVdpsKNkKVQRueXPisUZ/T629wN2XWda0r2 3gBsvuir8s/zOE1ko5cjFX2wCXjFEAnVk2Cd45gDzIz/2UeE/Wg1dCimbrXtm9YNS3WE NGAb9vIZtKluWwOOcMh/ZE+3RAs0SVlBXWqGvGNuEmmoCl4uGwB7H7dNeL+R0jl6cosi TEA4a9K3yHAJ5t4102paHDSQ/eP2fRM95GpsYG7YE4PDSjyPJC7L990mGxrajR21QZ04 p+O0Pmezy/uYpb+GGGqqZoFR6fRf3Ux9o+ZsmH1N7LodF5CD84i38JlYt2bjG4xT7+zi nyHg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=l3e+4dVxz7m4Dxf32tQc1AXV0BOf72Tt1Pj5m+DiaiY=; b=H58yFtRqLGaQwCZ5Zy4ZYM3pzXH6k/duVJQQML5qHymrE8W6ER98XVCstRK9EUw2aH PWrb3RRsq+9hYXEXhu7jxb2KixM/ld8D3mrzxtvEp7Rs5y+zyIy2B2i20rSWFHL3zrJY jZRwnvoymBY/9jMbHZWu9hfztYg/hIzfoAavwf5T0UDm0P2WO7R/TdV0WwXGZtZqunyX DWgog6BdKVn8sSLguEPnvncDw2AVM4sVmXEkxbQDP6xpIUQM1Dw1iQZrGxsM0Nqs43Sj 3/I8HBCn9AUsQcIEPbquyXKLy7lhMo/mDDsStyue/fddg7BMO+xWAFLuAaIeCDj0pBv/ bmlw== X-Gm-Message-State: AOAM530mOmzeAiKtTRuohnbB+dmCZwAnDzvYRKcmMv/xSrw+9PRc51VV iGPDKeY/u3eTUqbZEdO7DgwnBWBsV1dHHQ== X-Google-Smtp-Source: ABdhPJyxH02zMmFKmwt9okgEdp4RNx6uPEmj7gqP5Ry8ln5IiblKGfJHdsylIAT6rj3HnxcoJWblMA== X-Received: by 2002:a1c:4302:: with SMTP id q2mr10020484wma.37.1626021059313; Sun, 11 Jul 2021 09:30:59 -0700 (PDT) Received: from vm.nix.is (vm.nix.is. [2a01:4f8:120:2468::2]) by smtp.gmail.com with ESMTPSA id w3sm678091wrt.55.2021.07.11.09.30.58 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 11 Jul 2021 09:30:58 -0700 (PDT) From: =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBCamFybWFzb24=?= To: git@vger.kernel.org Cc: Junio C Hamano , Jeff King , Han-Wen Nienhuys , Jonathan Tan , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsCBC?= =?utf-8?b?amFybWFzb24=?= Subject: [PATCH v6? 17/17] refs API: don't leak "errno" in run_transaction_hook() Date: Sun, 11 Jul 2021 18:30:41 +0200 Message-Id: X-Mailer: git-send-email 2.32.0-dev 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 3357ba14e1d..f1477eed27a 100644 --- a/refs.c +++ b/refs.c @@ -2108,8 +2108,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; } }