Feedback-ID: i675e48f3:Fastmail
MIME-Version: 1.0
Date: Mon, 14 Sep 2026 09:19:21 -0400
From: "Greg Burd" <greg@burd.me>
To: "Virender Singla" <virender.cse@gmail.com>
Cc: "PostgreSQL Hackers" <pgsql-hackers@lists.postgresql.org>,
 "Andres Freund" <andres@anarazel.de>,
 "Michael Paquier" <michael@paquier.xyz>,
 "Dilip Kumar" <dilipbalaut@gmail.com>
Message-Id: <9d79b7ff-1267-4a2e-b441-dddbc7c81781@app.fastmail.com>
In-Reply-To: 
 <CAFiTN-uu6DE12=htWTERqS8CDjpPyMd5ZKARc20ZyLRdykOAPg@mail.gmail.com>
References: 
 <CAM6Zo8wZOLnCWRO_tuuXVX9J4N4JN6GsEnk8WJtT0=_0zy-1dw@mail.gmail.com>
 <CAM6Zo8x+_4KQrEGh9SNDcM852ARrKK=uY9HgSrZMHQCyJ-vj9Q@mail.gmail.com>
 <4F3E438F-A854-4C82-88C2-0797FE5EDF2D@burd.me>
 <CAFiTN-uu6DE12=htWTERqS8CDjpPyMd5ZKARc20ZyLRdykOAPg@mail.gmail.com>
Subject: Re: [PATCH] Corruption Issue: Fix missing tts_tid in
 ExecForceStoreHeapTuple
Content-Type: multipart/mixed;
 boundary=f340a1ad2a7346d1a892735caea364d48fed8ecd
Archived-At: 
 <https://www.postgresql.org/message-id/9d79b7ff-1267-4a2e-b441-dddbc7c81781%40app.fastmail.com>
Precedence: bulk

--f340a1ad2a7346d1a892735caea364d48fed8ecd
Content-Type: text/plain; charset=utf-8
Content-Transfer-Encoding: quoted-printable


On Mon, Sep 14, 2026, at 8:31 AM, Dilip Kumar wrote:
> On Mon, Sep 14, 2026 at 5:47=E2=80=AFPM Burd, Greg <greg@burd.me> wrot=
e:
>>
>>
>>
>> > On Sep 14, 2026, at 8:10=E2=80=AFAM, Virender Singla <virender.cse@=
gmail.com> wrote:
>> >
>> > Just a quick ping on this patch.
>> > It appears the `tts_tid` assignment was inadvertently omitted from =
the
>> > BufferHeapTupleTableSlot path in ExecForceStoreHeapTuple() when the
>> > function was first introduced during the PG12 TupleTableSlot
>> > refactoring [1].
>>
>> I ran into this myself and posted a patch [1] as well.  I had not not=
iced your
>> patch.  Looks like both patches are essentially identical with differ=
ent tests
>> we could combine those into one and then possibly get the attention o=
f a
>> committer.
>>
>> > This was subsequently exposed when the GiST index scan reorder queue
>> > was updated to route popped tuples through this same function [2]. =
The
>> > relevant code hasn't changed since those commits.
>> >
>> > Thanks,
>> > Virender
>> > [1] https://git.postgresql.org/gitweb/?p=3Dpostgresql.git;a=3Dcommi=
t;h=3D4da597edf1b
>> > [2] https://git.postgresql.org/gitweb/?p=3Dpostgresql.git;a=3Dcommi=
t;h=3Db8b94ea129f
>>
>> I agree, it's a bug/oversight that has lingered since v12 and should =
be fixed.
>
> +1 this seems like and issue, we can compare this with
> ExecStoreHeapTuple() which restore back the ctid so I think here it
> seems like and oversight and attached patch seems to be doing right
> thing.

Hey Dilip, thanks for chiming in.

> --=20
> Regards,
> Dilip Kumar
> Google

Virender,

I've re-worked the tests to include your two checks, and found something
about them worth flagging: at LIMIT 1 neither one fails on unpatched cod=
e.

The first tuple out of IndexNextWithReorder() is the one whose advertised
distance compared equal to the recomputed one, so was_exact is true and =
it
never enters the reorder queue. It keeps its real ctid. Only the tuples
behind it get requeued through ExecForceStoreHeapTuple(). I built your
test against a tree with the execTuples.c hunk reverted and valid_tid
comes back 't', and the FOR UPDATE succeeds. Raise the same table to
LIMIT 5 and 4 of 5 rows are (4294967295,0) and the FOR UPDATE dies. Your
checks are right, it's just the LIMIT.

So v2 keeps both of your assertions at LIMIT 5, on the polygon fixture
from my patch, plus an EXPLAIN to pin the plan (worth having, since your
block landed after the reset enable_seqscan at the end of gist.sql). A/B
with only the execTuples.c hunk reverted:

                                    unpatched   patched
    sentinel ctids at LIMIT 5             4         0
    ctid self-join, expect 5              1         5
    ORDER BY ... LIMIT 5 FOR UPDATE   assert        5

I dropped the separate circle_ops table. Unpatched it fails at LIMIT 5
just like the polygon one (19 of 20 sentinels), same reorderqueue_pop
path, so it wasn't buying coverage. The polygon case is only a stronger
trigger in degree.

The FOR UPDATE case is important. I reproduced the assert
(ItemPointerIsValid in itemptr.h). The non-assert consequence, P_NEW
extending the relation and leaving a block that later breaks seqscans,
I've taken from your mail rather than tested and credited as such.
It's the strongest argument for back-patching, since it turns a
wrong-answer bug into on-disk damage.

One refinement on provenance. 4da597edf1b did create the function without
the assignment, but tts_tid didn't exist yet. The field arrives in
b8d71745eac, which sets it in both tts_heap_store_tuple and
tts_buffer_heap_store_tuple and misses this branch, and it only becomes
observable at ff11e7f4b9a, which made tts_buffer_heap_clear invalidate
tts_tid. Before that ExecClearTuple left it alone, so the slot kept a
stale value instead of the sentinel. Then b8b94ea129f made it reachable,
as you say, by dropping iss_ReorderQueueSlot, which was TTSOpsHeapTuple
and took the correct branch. All in the v12 cycle, so your conclusion
holds, just a different commit as the origin.

On that basis I've also switched to your Backpatch-through: 14 rather
than the 13 I'd written, since 13 is out of support.

On author attribution, you first since your post predates mine. Dilip,
thanks for the review.

v3 attached,

-greg
--f340a1ad2a7346d1a892735caea364d48fed8ecd
Content-Disposition: attachment;
	filename*0="v3-0001-Restore-slot-tts_tid-in-ExecForceStoreHeapTuple-s.pat";
	filename*1="ch"
Content-Type: text/x-patch;
	name="=?UTF-8?Q?v3-0001-Restore-slot-tts=5Ftid-in-ExecForceStoreHeapTuple-s.pa?=
 =?UTF-8?Q?tch?="
Content-Transfer-Encoding: base64
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--f340a1ad2a7346d1a892735caea364d48fed8ecd--