From patchwork Tue Dec 12 07:18:48 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Patrick Steinhardt X-Patchwork-Id: 13488583 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=pks.im header.i=@pks.im header.b="PjEXYcOH"; dkim=pass (2048-bit key) header.d=messagingengine.com header.i=@messagingengine.com header.b="cF7oiQIu" Received: from wout3-smtp.messagingengine.com (wout3-smtp.messagingengine.com [64.147.123.19]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 48163BF for ; Mon, 11 Dec 2023 23:18:53 -0800 (PST) Received: from compute7.internal (compute7.nyi.internal [10.202.2.48]) by mailout.west.internal (Postfix) with ESMTP id 8CA3B3200A49; Tue, 12 Dec 2023 02:18:52 -0500 (EST) Received: from mailfrontend1 ([10.202.2.162]) by compute7.internal (MEProxy); Tue, 12 Dec 2023 02:18:52 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=pks.im; h=cc:cc :content-type:content-type:date:date:from:from:in-reply-to :in-reply-to:message-id:mime-version:references:reply-to:subject :subject:to:to; s=fm1; t=1702365532; x=1702451932; bh=ht6WP2WCLu iTaS8C7EZrdkVveLwGbvEcCSEFFiZGeJ0=; b=PjEXYcOHQQd1280smGExk6CGIB GLzIy1X6NtZeTz0y9UYYbj7xwPC2w1WM3dOcMcFJrY0lCwX73vXNQ0KzO7sFu29w ZBVH/asOrjYPIwgk+XZ6MlAvS0aUKEpqZWj6Ih8l7ijhZtFQsLe3Y1Clzp8pw10S uWPp90BBlbMMNcI/+ebIcuXxubFmXlY30AW3KWYrFPLAZ6OJIIbawkfYW7G3VjZD HtWsH13Hd7rHLhigeeEryvHlerP28rptDAZ5J7OXT7Ihenge2voKCxuaq7mnuU8C FY6SdabN7Ibe62Mt5JIqKpwiqXxP3rzClrhJqcLkogpSKZlm5hX9Ntqta/NQ== DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d= messagingengine.com; h=cc:cc:content-type:content-type:date:date :feedback-id:feedback-id:from:from:in-reply-to:in-reply-to :message-id:mime-version:references:reply-to:subject:subject:to :to:x-me-proxy:x-me-proxy:x-me-sender:x-me-sender:x-sasl-enc; s= fm1; t=1702365532; x=1702451932; bh=ht6WP2WCLuiTaS8C7EZrdkVveLwG bvEcCSEFFiZGeJ0=; b=cF7oiQIu2dBNnM0uwdpyk7XjKJmWGQleqhlwDuxayrAu sTucN0Modo/wGJcB5wJJutKzUyTnEp+o8U5JybU7TF2BAuUzzCvSXPjFIq2dJzhk NZCQ80Mt8LbyT1XtM43KokEQakCZAmGBfAtsvEaLCoQdLsTRI8MTYVeqwcmbsnwt 02OhLgXjD2EoBQD64AA9Lw1xlaVMyvH4o6LAOL+O/D5SEnncNEJp4LEOWo4PHwn9 r1fiR0tqcQo8M5ZAMKgr1PaUUO1D/CsuYw/jIFH7VGExHAHQeCEuaAyePywz12yS ohvBMAlDqG07gr5AjfTrS0jJ61e9HVVH6VlSbl1vWw== X-ME-Sender: X-ME-Received: X-ME-Proxy-Cause: gggruggvucftvghtrhhoucdtuddrgedvkedrudelfedguddtkecutefuodetggdotefrod ftvfcurfhrohhfihhlvgemucfhrghsthforghilhdpqfgfvfdpuffrtefokffrpgfnqfgh necuuegrihhlohhuthemuceftddtnecusecvtfgvtghiphhivghnthhsucdlqddutddtmd enucfjughrpeffhffvvefukfhfgggtuggjsehgtderredttddvnecuhfhrohhmpefrrght rhhitghkucfuthgvihhnhhgrrhguthcuoehpshesphhkshdrihhmqeenucggtffrrghtth gvrhhnpeeukedtvedtffevleejtefgheehieegkeeluddvfeefgeehgfeltddtheejleff teenucevlhhushhtvghrufhiiigvpedtnecurfgrrhgrmhepmhgrihhlfhhrohhmpehpsh esphhkshdrihhm X-ME-Proxy: Feedback-ID: i197146af:Fastmail Received: by mail.messagingengine.com (Postfix) with ESMTPA; Tue, 12 Dec 2023 02:18:51 -0500 (EST) Received: by vm-mail (OpenSMTPD) with ESMTPSA id c9ad96c2 (TLSv1.3:TLS_AES_256_GCM_SHA384:256:NO); Tue, 12 Dec 2023 07:17:12 +0000 (UTC) Date: Tue, 12 Dec 2023 08:18:48 +0100 From: Patrick Steinhardt To: git@vger.kernel.org Cc: Taylor Blau , Phillip Wood Subject: [PATCH v2 1/4] wt-status: read HEAD and ORIG_HEAD via the refdb Message-ID: <1db3eb3945432964aabe1c559db4c3ac251e83fd.1702365291.git.ps@pks.im> References: Precedence: bulk X-Mailing-List: git@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: We read both the HEAD and ORIG_HEAD references directly from the filesystem in order to figure out whether we're currently splitting a commit. If both of the following are true: - HEAD points to the same object as "rebase-merge/amend". - ORIG_HEAD points to the same object as "rebase-merge/orig-head". Then we are currently splitting commits. The current code only works by chance because we only have a single reference backend implementation. Refactor it to instead read both refs via the refdb layer so that we'll also be compatible with alternate reference backends. Note that we pass `RESOLVE_REF_NO_RECURSE` to `read_ref_full()`. This is because we didn't resolve symrefs before either, and in practice none of the refs in "rebase-merge/" would be symbolic. We thus don't want to resolve symrefs with the new code either to retain the old behaviour. Signed-off-by: Patrick Steinhardt --- wt-status.c | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-) diff --git a/wt-status.c b/wt-status.c index 9f45bf6949..fe9e590b80 100644 --- a/wt-status.c +++ b/wt-status.c @@ -1295,26 +1295,27 @@ static char *read_line_from_git_path(const char *filename) static int split_commit_in_progress(struct wt_status *s) { int split_in_progress = 0; - char *head, *orig_head, *rebase_amend, *rebase_orig_head; + struct object_id head_oid, orig_head_oid; + char *rebase_amend, *rebase_orig_head; if ((!s->amend && !s->nowarn && !s->workdir_dirty) || !s->branch || strcmp(s->branch, "HEAD")) return 0; - head = read_line_from_git_path("HEAD"); - orig_head = read_line_from_git_path("ORIG_HEAD"); + if (read_ref_full("HEAD", RESOLVE_REF_NO_RECURSE, &head_oid, NULL) || + read_ref_full("ORIG_HEAD", RESOLVE_REF_NO_RECURSE, &orig_head_oid, NULL)) + return 0; + rebase_amend = read_line_from_git_path("rebase-merge/amend"); rebase_orig_head = read_line_from_git_path("rebase-merge/orig-head"); - if (!head || !orig_head || !rebase_amend || !rebase_orig_head) + if (!rebase_amend || !rebase_orig_head) ; /* fall through, no split in progress */ else if (!strcmp(rebase_amend, rebase_orig_head)) - split_in_progress = !!strcmp(head, rebase_amend); - else if (strcmp(orig_head, rebase_orig_head)) + split_in_progress = !!strcmp(oid_to_hex(&head_oid), rebase_amend); + else if (strcmp(oid_to_hex(&orig_head_oid), rebase_orig_head)) split_in_progress = 1; - free(head); - free(orig_head); free(rebase_amend); free(rebase_orig_head); From patchwork Tue Dec 12 07:18:52 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Patrick Steinhardt X-Patchwork-Id: 13488584 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=pks.im header.i=@pks.im header.b="lq0pTI2O"; dkim=pass (2048-bit key) header.d=messagingengine.com header.i=@messagingengine.com header.b="caFZAxln" Received: from wout3-smtp.messagingengine.com (wout3-smtp.messagingengine.com [64.147.123.19]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 8D15ABF for ; Mon, 11 Dec 2023 23:18:56 -0800 (PST) Received: from compute4.internal (compute4.nyi.internal [10.202.2.44]) by mailout.west.internal (Postfix) with ESMTP id AD2283200AB5; Tue, 12 Dec 2023 02:18:55 -0500 (EST) Received: from mailfrontend1 ([10.202.2.162]) by compute4.internal (MEProxy); Tue, 12 Dec 2023 02:18:56 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=pks.im; h=cc:cc :content-type:content-type:date:date:from:from:in-reply-to :in-reply-to:message-id:mime-version:references:reply-to:subject :subject:to:to; s=fm1; t=1702365535; x=1702451935; bh=zg5jK5ENLK ikWkpEIKkASgSUD0I+VfOR8qPLyKGmINM=; b=lq0pTI2Oss3GjiWRxleu9SK0rB HBZrTm1+HSILdtJOaYVEVHO+xL1QEAQzY425szNJCtE96nQAGm/VgRp6ub/TpYV9 FOYkTf9Ae7WE278OsXDaRHsZhi9PZEg9cAGhrPOdwhtWguxo44wtje1oSCCmNpz8 TB92Bmv1W1Q3GRQaL2ezg94lnBnz8eMJyLffhUWGc8InQ3aowFoaVK4RZbIzDHTK KUolmLdFcSf1rc85TcvNTybKBNynhBVk6uB97Wd8V/yZBsd0a9f8UZZ7mlJyIwRk ZD1ozMmN3Rz1uoFCgkVxkHdxBrop32DjQVgrVnP2e6VA9gnkBfrT+YijG/zQ== DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d= messagingengine.com; h=cc:cc:content-type:content-type:date:date :feedback-id:feedback-id:from:from:in-reply-to:in-reply-to :message-id:mime-version:references:reply-to:subject:subject:to :to:x-me-proxy:x-me-proxy:x-me-sender:x-me-sender:x-sasl-enc; s= fm1; t=1702365535; x=1702451935; bh=zg5jK5ENLKikWkpEIKkASgSUD0I+ VfOR8qPLyKGmINM=; b=caFZAxlnMpSHkUXZ1W2WA5Ob235JOAx3APb5xtzaNcmy 7TWSXLQePZDnfoMOGtLDHOtnYvXNQ4tPX1TDc2UeVABl/SlJSv9vfX6+C5Y7diVJ nUHx1ErfJHUqES0NTFhrSULkodb7sUg3MkaHj5cCYS76+jXoyekk7jN9RlSqD7IX w1h6jtE41ObwyrhMoTv7bwajrROKLjkKQ9xwmf0lLf5rr6oZANJB+pnNJueD8SE4 dSffKCX/mgoWLbSVEekI1pHbto4e0t7tnRVX9IStYNpFxxOb3ZmagwrwdzRtpW2e 1cikJ/biIl3Ib2Oaavv1+Ph2ucBffSXdSZDoVPl0gA== X-ME-Sender: X-ME-Received: X-ME-Proxy-Cause: gggruggvucftvghtrhhoucdtuddrgedvkedrudelfedguddtkecutefuodetggdotefrod ftvfcurfhrohhfihhlvgemucfhrghsthforghilhdpqfgfvfdpuffrtefokffrpgfnqfgh necuuegrihhlohhuthemuceftddtnecusecvtfgvtghiphhivghnthhsucdlqddutddtmd enucfjughrpeffhffvvefukfhfgggtuggjsehgtderredttddvnecuhfhrohhmpefrrght rhhitghkucfuthgvihhnhhgrrhguthcuoehpshesphhkshdrihhmqeenucggtffrrghtth gvrhhnpeeukedtvedtffevleejtefgheehieegkeeluddvfeefgeehgfeltddtheejleff teenucevlhhushhtvghrufhiiigvpedtnecurfgrrhgrmhepmhgrihhlfhhrohhmpehpsh esphhkshdrihhm X-ME-Proxy: Feedback-ID: i197146af:Fastmail Received: by mail.messagingengine.com (Postfix) with ESMTPA; Tue, 12 Dec 2023 02:18:54 -0500 (EST) Received: by vm-mail (OpenSMTPD) with ESMTPSA id 9f5edc6b (TLSv1.3:TLS_AES_256_GCM_SHA384:256:NO); Tue, 12 Dec 2023 07:17:16 +0000 (UTC) Date: Tue, 12 Dec 2023 08:18:52 +0100 From: Patrick Steinhardt To: git@vger.kernel.org Cc: Taylor Blau , Phillip Wood Subject: [PATCH v2 2/4] refs: propagate errno when reading special refs fails Message-ID: <24032a62e54fb37dad46c3ede7151efc8a7a8818.1702365291.git.ps@pks.im> References: Precedence: bulk X-Mailing-List: git@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: Some refs in Git are more special than others due to reasons explained in the next commit. These refs are read via `refs_read_special_head()`, but this function doesn't behave the same as when we try to read a normal ref. Most importantly, we do not propagate `failure_errno` in the case where the reference does not exist, which is behaviour that we rely on in many parts of Git. Fix this bug by propagating errno when `strbuf_read_file()` fails. Signed-off-by: Patrick Steinhardt --- refs.c | 4 +++- t/t1403-show-ref.sh | 10 ++++++++++ 2 files changed, 13 insertions(+), 1 deletion(-) diff --git a/refs.c b/refs.c index fcae5dddc6..00e72a2abf 100644 --- a/refs.c +++ b/refs.c @@ -1806,8 +1806,10 @@ static int refs_read_special_head(struct ref_store *ref_store, int result = -1; strbuf_addf(&full_path, "%s/%s", ref_store->gitdir, refname); - if (strbuf_read_file(&content, full_path.buf, 0) < 0) + if (strbuf_read_file(&content, full_path.buf, 0) < 0) { + *failure_errno = errno; goto done; + } result = parse_loose_ref_contents(content.buf, oid, referent, type, failure_errno); diff --git a/t/t1403-show-ref.sh b/t/t1403-show-ref.sh index b50ae6fcf1..66e6e77fa9 100755 --- a/t/t1403-show-ref.sh +++ b/t/t1403-show-ref.sh @@ -266,4 +266,14 @@ test_expect_success '--exists with directory fails with generic error' ' test_cmp expect err ' +test_expect_success '--exists with non-existent special ref' ' + test_expect_code 2 git show-ref --exists FETCH_HEAD +' + +test_expect_success '--exists with existing special ref' ' + test_when_finished "rm .git/FETCH_HEAD" && + git rev-parse HEAD >.git/FETCH_HEAD && + git show-ref --exists FETCH_HEAD +' + test_done From patchwork Tue Dec 12 07:18:56 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Patrick Steinhardt X-Patchwork-Id: 13488585 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=pks.im header.i=@pks.im header.b="PhGI/e3+"; dkim=pass (2048-bit key) header.d=messagingengine.com header.i=@messagingengine.com header.b="HSuAWmvR" Received: from wout3-smtp.messagingengine.com (wout3-smtp.messagingengine.com [64.147.123.19]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 7D75DCB for ; Mon, 11 Dec 2023 23:19:00 -0800 (PST) Received: from compute6.internal (compute6.nyi.internal [10.202.2.47]) by mailout.west.internal (Postfix) with ESMTP id C1E4C3200AC4; Tue, 12 Dec 2023 02:18:59 -0500 (EST) Received: from mailfrontend1 ([10.202.2.162]) by compute6.internal (MEProxy); Tue, 12 Dec 2023 02:19:00 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=pks.im; h=cc:cc :content-type:content-type:date:date:from:from:in-reply-to :in-reply-to:message-id:mime-version:references:reply-to:subject :subject:to:to; s=fm1; t=1702365539; x=1702451939; bh=WwP8CMaFHh nhU+nhL0FNVUUXaurPeUYe4TLb8Xjcbko=; b=PhGI/e3+MZfs7tqDFtwVR7c4d3 Txzw8Uzlszh8rA9hQD727Jj+QQDkNOt+kU1494UbWOmKM/pej1M9izi6moPcV2Li NW368hVgD/sFzHC/YoFgKsk6O6u3+kMv6Z7I8Z47zwKJPkV3Ph0N2SAz5YimEuLt jQl3lZlKTiykzPZLfywkZpumAOyg9UfHxxhwJSNX2bArWXA5gyS62FrEGJvE4aJU Tg0iL7ip7TfwY5+ZV1abeyCHNrBRXvu7ZSy+HZ2scv9vDvi6lTo6wmohcIRMCJ8k zkBL+XQ6uRN8yNBZD+EdoeWMNBY1PKk+YzBBYHWb/uEBuyLLFdzwMQCHGAYw== DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d= messagingengine.com; h=cc:cc:content-type:content-type:date:date :feedback-id:feedback-id:from:from:in-reply-to:in-reply-to :message-id:mime-version:references:reply-to:subject:subject:to :to:x-me-proxy:x-me-proxy:x-me-sender:x-me-sender:x-sasl-enc; s= fm1; t=1702365539; x=1702451939; bh=WwP8CMaFHhnhU+nhL0FNVUUXaurP eUYe4TLb8Xjcbko=; b=HSuAWmvRC3Ast9570ZTUbfyuC0SYR4Gn41eV2gTo7EZ/ Mu/qoIoSrqrH6ztGjSef9cCuzSAisO/sST7cWPBZEcHfTP7l8sLIW726/RqsjSTT G3bK7GzuoorBXy5wJUcXfQDssQi/GFWR751MC+BYuz1M4GS+dXBGONzNC8bX6dAn oXKSo5Q+cMTWGjqKyjEqNuZyXNTUOZi0i9j/drW8234p5TOm1DAzuA9DdcETz0xU kstd9VvydbwUEYJa2DlDvE5cX0fbURBcpMb53RP2qSAwRQ6LfrhskMUt3BoUA9mq CKtFP08C8HMDxw8FA8gkI4Od43T0txDJJqNuw5H7bw== X-ME-Sender: X-ME-Received: X-ME-Proxy-Cause: gggruggvucftvghtrhhoucdtuddrgedvkedrudelfedguddtkecutefuodetggdotefrod ftvfcurfhrohhfihhlvgemucfhrghsthforghilhdpqfgfvfdpuffrtefokffrpgfnqfgh necuuegrihhlohhuthemuceftddtnecusecvtfgvtghiphhivghnthhsucdlqddutddtmd enucfjughrpeffhffvvefukfhfgggtuggjsehgtderredttddvnecuhfhrohhmpefrrght rhhitghkucfuthgvihhnhhgrrhguthcuoehpshesphhkshdrihhmqeenucggtffrrghtth gvrhhnpeeukedtvedtffevleejtefgheehieegkeeluddvfeefgeehgfeltddtheejleff teenucevlhhushhtvghrufhiiigvpedtnecurfgrrhgrmhepmhgrihhlfhhrohhmpehpsh esphhkshdrihhm X-ME-Proxy: Feedback-ID: i197146af:Fastmail Received: by mail.messagingengine.com (Postfix) with ESMTPA; Tue, 12 Dec 2023 02:18:58 -0500 (EST) Received: by vm-mail (OpenSMTPD) with ESMTPSA id fd4dbb52 (TLSv1.3:TLS_AES_256_GCM_SHA384:256:NO); Tue, 12 Dec 2023 07:17:20 +0000 (UTC) Date: Tue, 12 Dec 2023 08:18:56 +0100 From: Patrick Steinhardt To: git@vger.kernel.org Cc: Taylor Blau , Phillip Wood Subject: [PATCH v2 3/4] refs: complete list of special refs Message-ID: <3dd9089fd59ca27759dc445664811d52273c8e94.1702365291.git.ps@pks.im> References: Precedence: bulk X-Mailing-List: git@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: We have some references that are more special than others. The reason for them being special is that they either do not follow the usual format of references, or that they are written to the filesystem directly by the respective owning subsystem and thus circumvent the reference backend. This works perfectly fine right now because the reffiles backend will know how to read those refs just fine. But with the prospect of gaining a new reference backend implementation we need to be a lot more careful here: - We need to make sure that we are consistent about how those refs are written. They must either always be written via the filesystem, or they must always be written via the reference backend. Any mixture will lead to inconsistent state. - We need to make sure that such special refs are always handled specially when reading them. We're already mostly good with regard to the first item, except for `BISECT_EXPECTED_REV` which will be addressed in a subsequent commit. But the current list of special refs is missing a lot of refs that really should be treated specially. Right now, we only treat `FETCH_HEAD` and `MERGE_HEAD` specially here. Introduce a new function `is_special_ref()` that contains all current instances of special refs to fix the reading path. Based-on-patch-by: Han-Wen Nienhuys Signed-off-by: Patrick Steinhardt --- refs.c | 54 ++++++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 52 insertions(+), 2 deletions(-) diff --git a/refs.c b/refs.c index 00e72a2abf..8fe34d51e4 100644 --- a/refs.c +++ b/refs.c @@ -1820,15 +1820,65 @@ static int refs_read_special_head(struct ref_store *ref_store, return result; } +static int is_special_ref(const char *refname) +{ + /* + * Special references get written and read directly via the filesystem + * by the subsystems that create them. Thus, they must not go through + * the reference backend but must instead be read directly. It is + * arguable whether this behaviour is sensible, or whether it's simply + * a leaky abstraction enabled by us only having a single reference + * backend implementation. But at least for a subset of references it + * indeed does make sense to treat them specially: + * + * - FETCH_HEAD may contain multiple object IDs, and each one of them + * carries additional metadata like where it came from. + * + * - MERGE_HEAD may contain multiple object IDs when merging multiple + * heads. + * + * There are some exceptions that you might expect to see on this list + * but which are handled exclusively via the reference backend: + * + * - CHERRY_PICK_HEAD + * + * - HEAD + * + * - ORIG_HEAD + * + * - "rebase-apply/" and "rebase-merge/" contain all of the state for + * rebases, including some reference-like files. These are + * exclusively read and written via the filesystem and never go + * through the refdb. + * + * Writing or deleting references must consistently go either through + * the filesystem (special refs) or through the reference backend + * (normal ones). + */ + static const char * const special_refs[] = { + "AUTO_MERGE", + "BISECT_EXPECTED_REV", + "FETCH_HEAD", + "MERGE_AUTOSTASH", + "MERGE_HEAD", + }; + size_t i; + + for (i = 0; i < ARRAY_SIZE(special_refs); i++) + if (!strcmp(refname, special_refs[i])) + return 1; + + return 0; +} + 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")) { + if (is_special_ref(refname)) return refs_read_special_head(ref_store, refname, oid, referent, type, failure_errno); - } return ref_store->be->read_raw_ref(ref_store, refname, oid, referent, type, failure_errno); From patchwork Tue Dec 12 07:19:01 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Patrick Steinhardt X-Patchwork-Id: 13488586 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=pks.im header.i=@pks.im header.b="UN9qxQbV"; dkim=pass (2048-bit key) header.d=messagingengine.com header.i=@messagingengine.com header.b="iSf+xFYS" Received: from wout3-smtp.messagingengine.com (wout3-smtp.messagingengine.com [64.147.123.19]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 940DAA1 for ; Mon, 11 Dec 2023 23:19:04 -0800 (PST) Received: from compute4.internal (compute4.nyi.internal [10.202.2.44]) by mailout.west.internal (Postfix) with ESMTP id D97893200AB3; Tue, 12 Dec 2023 02:19:03 -0500 (EST) Received: from mailfrontend1 ([10.202.2.162]) by compute4.internal (MEProxy); Tue, 12 Dec 2023 02:19:04 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=pks.im; h=cc:cc :content-type:content-type:date:date:from:from:in-reply-to :in-reply-to:message-id:mime-version:references:reply-to:subject :subject:to:to; s=fm1; t=1702365543; x=1702451943; bh=ZwCofbSKxS i8NrVBA2eoxfdHO4uFsNIYjPn75hm1VRw=; b=UN9qxQbVvNAqRkVcN7EMb68BEa xEkH2aZkOiT5vLByIcTut9YLiDU22yhRg+ybrkkMztUvVlonp8goXsmcoas9hFB3 Fr6WISiulHE6ANAnG2XseIZjgSuQbjprrX8Lt4k2kIjOFLp+1UyiZYGVe0iKSmfE p2TlJ7ALztvpqkqX2SM3mGq/fzJRq6/TcBfvHc09tpl6Zp1S13AdHsEY3TLV/ChB DaV3ePMo/9P5jLpHTS7M9zSxfOyjUg0xhczXkNNpp5cxvsRsu/EuVmEMAekh25K4 fiEKBs18hFMJhb9SPG1i6cQLOoUTbtdHt5uqkv74GpUS+zPXuDKcwCfpa0MQ== DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d= messagingengine.com; h=cc:cc:content-type:content-type:date:date :feedback-id:feedback-id:from:from:in-reply-to:in-reply-to :message-id:mime-version:references:reply-to:subject:subject:to :to:x-me-proxy:x-me-proxy:x-me-sender:x-me-sender:x-sasl-enc; s= fm1; t=1702365543; x=1702451943; bh=ZwCofbSKxSi8NrVBA2eoxfdHO4uF sNIYjPn75hm1VRw=; b=iSf+xFYSxdaXS+S7CEoOQ+9Sg9n56cz6GYs5qiOJ7XIO xthar8IRLtKpxRmXivyuRapKYIxiv+0ExC0lYvx0A2qVQEu7Fu811wcn2SFy4SD8 pmdQRctLcXPnx6upnkHpx+rIMjj5sJLj5q9J/zBpA699JoWZVSXNgL4tNMkiS9W7 CXdID2QiOZXfYlvrIONQ6ZO1Fy7z/E12S568Wkv/mh6HZG1cjlNAuEEh+dlhn21v J9/tbcIiSFJQfAN6hvtqTiBJY7ScOLKqgzgvT4CRlnXd18IHq/OD3dpMZxgY45T6 9+z+ZDs2nsPIVebKF3wZYwbUV/mXMuLQBC6yjvanRQ== X-ME-Sender: X-ME-Received: X-ME-Proxy-Cause: gggruggvucftvghtrhhoucdtuddrgedvkedrudelfedguddtkecutefuodetggdotefrod ftvfcurfhrohhfihhlvgemucfhrghsthforghilhdpqfgfvfdpuffrtefokffrpgfnqfgh necuuegrihhlohhuthemuceftddtnecusecvtfgvtghiphhivghnthhsucdlqddutddtmd enucfjughrpeffhffvvefukfhfgggtuggjsehgtderredttddvnecuhfhrohhmpefrrght rhhitghkucfuthgvihhnhhgrrhguthcuoehpshesphhkshdrihhmqeenucggtffrrghtth gvrhhnpeeukedtvedtffevleejtefgheehieegkeeluddvfeefgeehgfeltddtheejleff teenucevlhhushhtvghrufhiiigvpedunecurfgrrhgrmhepmhgrihhlfhhrohhmpehpsh esphhkshdrihhm X-ME-Proxy: Feedback-ID: i197146af:Fastmail Received: by mail.messagingengine.com (Postfix) with ESMTPA; Tue, 12 Dec 2023 02:19:02 -0500 (EST) Received: by vm-mail (OpenSMTPD) with ESMTPSA id 9b9ee6fe (TLSv1.3:TLS_AES_256_GCM_SHA384:256:NO); Tue, 12 Dec 2023 07:17:24 +0000 (UTC) Date: Tue, 12 Dec 2023 08:19:01 +0100 From: Patrick Steinhardt To: git@vger.kernel.org Cc: Taylor Blau , Phillip Wood Subject: [PATCH v2 4/4] bisect: consistently write BISECT_EXPECTED_REV via the refdb Message-ID: <4a4447a3f5ba9ddef1c81703ef9231ee597c2946.1702365291.git.ps@pks.im> References: Precedence: bulk X-Mailing-List: git@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: We're inconsistently writing BISECT_EXPECTED_REV both via the filesystem and via the refdb, which violates the newly established rules for how special refs must be treated. This works alright in practice with the reffiles reference backend, but will cause bugs once we gain additional backends. Fix this issue and consistently write BISECT_EXPECTED_REV via the refdb so that it is no longer a special ref. Signed-off-by: Patrick Steinhardt --- bisect.c | 25 ++++--------------------- builtin/bisect.c | 8 ++------ refs.c | 3 ++- t/t6030-bisect-porcelain.sh | 2 +- 4 files changed, 9 insertions(+), 29 deletions(-) diff --git a/bisect.c b/bisect.c index 1be8e0a271..985b96ed13 100644 --- a/bisect.c +++ b/bisect.c @@ -471,7 +471,6 @@ static int read_bisect_refs(void) } static GIT_PATH_FUNC(git_path_bisect_names, "BISECT_NAMES") -static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV") static GIT_PATH_FUNC(git_path_bisect_ancestors_ok, "BISECT_ANCESTORS_OK") static GIT_PATH_FUNC(git_path_bisect_run, "BISECT_RUN") static GIT_PATH_FUNC(git_path_bisect_start, "BISECT_START") @@ -707,26 +706,10 @@ static enum bisect_error error_if_skipped_commits(struct commit_list *tried, static int is_expected_rev(const struct object_id *oid) { - const char *filename = git_path_bisect_expected_rev(); - struct stat st; - struct strbuf str = STRBUF_INIT; - FILE *fp; - int res = 0; - - if (stat(filename, &st) || !S_ISREG(st.st_mode)) + struct object_id expected_oid; + if (read_ref("BISECT_EXPECTED_REV", &expected_oid)) return 0; - - fp = fopen_or_warn(filename, "r"); - if (!fp) - return 0; - - if (strbuf_getline_lf(&str, fp) != EOF) - res = !strcmp(str.buf, oid_to_hex(oid)); - - strbuf_release(&str); - fclose(fp); - - return res; + return oideq(oid, &expected_oid); } enum bisect_error bisect_checkout(const struct object_id *bisect_rev, @@ -1185,10 +1168,10 @@ int bisect_clean_state(void) struct string_list refs_for_removal = STRING_LIST_INIT_NODUP; for_each_ref_in("refs/bisect", mark_for_removal, (void *) &refs_for_removal); string_list_append(&refs_for_removal, xstrdup("BISECT_HEAD")); + string_list_append(&refs_for_removal, xstrdup("BISECT_EXPECTED_REV")); result = delete_refs("bisect: remove", &refs_for_removal, REF_NO_DEREF); refs_for_removal.strdup_strings = 1; string_list_clear(&refs_for_removal, 0); - unlink_or_warn(git_path_bisect_expected_rev()); unlink_or_warn(git_path_bisect_ancestors_ok()); unlink_or_warn(git_path_bisect_log()); unlink_or_warn(git_path_bisect_names()); diff --git a/builtin/bisect.c b/builtin/bisect.c index 35938b05fd..4e2c43daf5 100644 --- a/builtin/bisect.c +++ b/builtin/bisect.c @@ -17,7 +17,6 @@ #include "revision.h" static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS") -static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV") static GIT_PATH_FUNC(git_path_bisect_ancestors_ok, "BISECT_ANCESTORS_OK") static GIT_PATH_FUNC(git_path_bisect_start, "BISECT_START") static GIT_PATH_FUNC(git_path_bisect_log, "BISECT_LOG") @@ -921,7 +920,6 @@ static enum bisect_error bisect_state(struct bisect_terms *terms, int argc, const char *state; int i, verify_expected = 1; struct object_id oid, expected; - struct strbuf buf = STRBUF_INIT; struct oid_array revs = OID_ARRAY_INIT; if (!argc) @@ -976,10 +974,8 @@ static enum bisect_error bisect_state(struct bisect_terms *terms, int argc, oid_array_append(&revs, &commit->object.oid); } - if (strbuf_read_file(&buf, git_path_bisect_expected_rev(), 0) < the_hash_algo->hexsz || - get_oid_hex(buf.buf, &expected) < 0) + if (read_ref("BISECT_EXPECTED_REV", &expected)) verify_expected = 0; /* Ignore invalid file contents */ - strbuf_release(&buf); for (i = 0; i < revs.nr; i++) { if (bisect_write(state, oid_to_hex(&revs.oid[i]), terms, 0)) { @@ -988,7 +984,7 @@ static enum bisect_error bisect_state(struct bisect_terms *terms, int argc, } if (verify_expected && !oideq(&revs.oid[i], &expected)) { unlink_or_warn(git_path_bisect_ancestors_ok()); - unlink_or_warn(git_path_bisect_expected_rev()); + delete_ref(NULL, "BISECT_EXPECTED_REV", NULL, REF_NO_DEREF); verify_expected = 0; } } diff --git a/refs.c b/refs.c index 8fe34d51e4..c76ce86bef 100644 --- a/refs.c +++ b/refs.c @@ -1840,6 +1840,8 @@ static int is_special_ref(const char *refname) * There are some exceptions that you might expect to see on this list * but which are handled exclusively via the reference backend: * + * - BISECT_EXPECTED_REV + * * - CHERRY_PICK_HEAD * * - HEAD @@ -1857,7 +1859,6 @@ static int is_special_ref(const char *refname) */ static const char * const special_refs[] = { "AUTO_MERGE", - "BISECT_EXPECTED_REV", "FETCH_HEAD", "MERGE_AUTOSTASH", "MERGE_HEAD", diff --git a/t/t6030-bisect-porcelain.sh b/t/t6030-bisect-porcelain.sh index 2a5b7d8379..792c1504bc 100755 --- a/t/t6030-bisect-porcelain.sh +++ b/t/t6030-bisect-porcelain.sh @@ -1176,7 +1176,7 @@ test_expect_success 'git bisect reset cleans bisection state properly' ' git bisect bad $HASH4 && git bisect reset && test -z "$(git for-each-ref "refs/bisect/*")" && - test_path_is_missing ".git/BISECT_EXPECTED_REV" && + test_ref_missing BISECT_EXPECTED_REV && test_path_is_missing ".git/BISECT_ANCESTORS_OK" && test_path_is_missing ".git/BISECT_LOG" && test_path_is_missing ".git/BISECT_RUN" &&