MIME-Version: 1.0
References: <432626F9-65DF-4F0D-B345-26CFC3E2CFAC@yandex-team.ru>
 <CAN4CZFNCyEOC8exfEn9SVV=uhzUA4KQYcVRUea2E0ts-rvXg3w@mail.gmail.com>
 <A355EB21-614C-43A9-85A0-D4822DC13B04@yandex-team.ru>
 <9A5AEB25-5E58-4657-9064-7D4F8D50A77D@yandex-team.ru>
 <CAN4CZFNdvMqgHpB04SSqDjv1Z5g3Dv2Z6Uyb4P5dDo6p04Z=Kg@mail.gmail.com>
 <35809064-01A3-4449-B393-0F71D4C18F7D@yandex-team.ru>
In-Reply-To: <35809064-01A3-4449-B393-0F71D4C18F7D@yandex-team.ru>
From: Jakub Wartak <jakub.wartak@enterprisedb.com>
Date: Wed, 8 Apr 2026 15:17:45 +0200
Message-ID: 
 <CAKZiRmwCT=pqesAjC4-2rRLWQ2uiBkrmJBhWeTgALn6yfqbuew@mail.gmail.com>
Subject: Re: amcheck: add index-all-keys-match verification for B-Tree
To: Andrey Borodin <x4mmm@yandex-team.ru>
Cc: Zsolt Parragi <zsolt.parragi@percona.com>,
 pgsql-hackers <pgsql-hackers@postgresql.org>,
	Wenbo Lin <linwenbo1994@gmail.com>
Content-Type: multipart/mixed; boundary="0000000000008864de064ef2bae5"
Archived-At: 
 <https://www.postgresql.org/message-id/CAKZiRmwCT%3DpqesAjC4-2rRLWQ2uiBkrmJBhWeTgALn6yfqbuew%40mail.gmail.com>
Precedence: bulk

--0000000000008864de064ef2bae5
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

On Thu, Mar 5, 2026 at 7:00=E2=80=AFAM Andrey Borodin <x4mmm@yandex-team.ru=
> wrote:
> Thanks for the review! I've addressed all these issues in patch steps 4 a=
nd 5. Other steps are intact. PFA.

Hi Andrey and Wenboo,

1. I tried the v4 to see how it would cope with heap missing segments[0]
(with -Dsegsize_blocks=3D6), so given:

create table ptest(id bigint, tenant_id bigint);
insert into ptest select g, mod(g,10) from generate_series(1, 3000) g;
alter table ptest add primary key (id);
checkpoint;

postgres=3D# select count(*) from ptest;
 count
-------
  3000

-- simulate loss of middle segment:
$ mv base/5/24578.1 base/5/24578.1.ORG
$ ls -1 base/5/24578*
base/5/24578
base/5/24578.1.ORG
base/5/24578.2
base/5/24578_fsm
base/5/24578_vm

-- force _mfd_openseg() via new backend to show silent data loss:
postgres=3D# select count(*) from ptest;
 count
-------
  1110

-- try new amcheck
postgres=3D# select bt_index_check(index=3D>'ptest_pkey',
heapallindexed=3D>true, checkunique=3D>true, indexallkeysmatch=3D>false);
 bt_index_check
----------------


-- try the new indexallkeysmatch
-- might need restart before it is able to properly bailout
postgres=3D# select bt_index_check(index=3D>'ptest_pkey',
heapallindexed=3D>true, checkunique=3D>true, indexallkeysmatch=3D>true);
ERROR:  could not open file "base/5/24578.1" (target block 6): No such
file or directory

this error was not quite expected for me (altough it is much better than no=
thing
as on master today), because patch v4-0002 assumes in
bt_verify_index_tuple_points_to_heap() that we should get false and error i=
n
more human-firendly way ("index tuple points to non-existent heap"). The er=
ror
itself is coming out of the following stacktrace:

_mdfd_getseg (forknum=3DMAIN_FORKNUM, blkno=3D6)
<- mdstartreadv (..) <- smgrstartreadv (blocknum=3Dblocknum@entry=3D6 (!))
<- StartReadBuffersImpl (blockNum=3D6 (!)) <- StartReadBuffer()
<- ReadBuffer_common() <- ReadBufferExtended (blockNum=3D6 (!))
<- heap_fetch() <- heapam_fetch_row_version()
<- table_tuple_fetch_row_version()
<- bt_verify_index_tuple_points_to_heap(targetblock=3D5, offset=3D14)
<- bt_target_page_check() <- bt_check_level_from_leftmost()
<- bt_check_every_level() <- bt_index_check_callback()
<- amcheck_lock_relation_and_check() <- bt_index_check()
and it's because itup in bt_target_page_check() has bi_lo =3D 6, ip_posid =
=3D 1

So with the attached patch it becomes more human understandable, but it is
somehow orthogonal check? Still maybe we can combine this under this $threa=
d
ambrella and make it as an option of indexallkeysmatch too? Attached
behaves likes this:

postgres=3D# select bt_index_check(index=3D>'ptest_pkey');
ERROR:  index line pointer in index "ptest_pkey" points to missing
page in table "ptest"
DETAIL:  Index tid=3D(5,14)  points to heap tid=3D(6,1) but heap has only 6=
 blocks.
HINT:  this can be caused by lost relation segment (missing or removed file=
).

(note it does not need to indexallkeysmatch, but it's related)

Also, the attached patch right now blows up pg_amcheck test (not
contrib/amcheck), where we ask to ignore certain corrupted schemas/tables t=
o
test exclusion logic, but we still verify btrees and with attached this btr=
ee
verification ends up discovering short heap segment :D I honestly do not kn=
ow
what to do in this situation (we ask to ignore one table T, but still launc=
h
bt_index_check() on it's index and discover illegal sitation about state of=
 T).

Also I'm not sure if the rechecking of heapnblocks is good way. It's just s=
ome
idea.

2. For some reason email from Wenbo didn't get to my emailbox, but I can
see his email here:
https://www.postgresql.org/message-id/resend/ba92ac77-24f1-44ad-abf0-11e64e=
0a7831%40gmail.com
(and resending is is somewhat not effective)

> I've been reviewing the patch and ran some concurrent tests against it.
> I found an issue with false positive corruption reports under concurrent
> VACUUM.
>
> + slot =3D table_slot_create(state->heaprel, NULL);
> + found =3D table_tuple_fetch_row_version(state->heaprel, tid,
> +                         SnapshotAny, slot);
> + if (!found)
> + {
> +         ExecDropSingleTupleTableSlot(slot);
> +         ereport(ERROR,
>
>
> bt_verify_index_tuple_points_to_heap uses SnapshotAny with
> table_tuple_fetch_row_version to distinguish "tuple doesn't exist" from
> "tuple exists but is dead". However, bt_index_check only holds
> AccessShareLock which compatible with VACUUM's ShareUpdateExclusiveLock.
> A concurrent VACUUM Phase 1 can prune heap pages(ItemIdSetDead) between
> Bloom filter probe and the heap lookup. Causing
> table_tuple_fetch_row_version to return false for a legal
> dead-but-now-pruned tuple and a false positive corruption report.
>
> The table_tuple_satisfies_snapshot check does not help, it only runs
> when the fetch succeeds(LP_NORMAL). Once VACUUM sets LP_DEAD,
> heapam_fetch sees !ItemIdIsNormal(lp) and returns false before any
> snapshot checks.
>
> The reproduce should be: DELETE all rows form a big table, then launch
> VACUUM and bt_index_check concurrently. A POC test script attached.

I think this is spot-on. I haven't run repro, but if we take ASL and VACUUM
is allowed to run (under ShareUpdateExclusiveLock) then amcheck performs th=
e
heap bloom building (but ignores dead tuples, while btree still can
point to those),
but VACUUM could later remove the heap tuple. It seems to be impossible (un=
der
ASL) to differentiate orphaned index tuple from concurrently vacuumed
dead tuple?

Maybe we should grab ShareUpdateExclusiveLock in bt_index_check for
indexallkeysmatch=3D=3Dtrue? With some new documentation warning about
this? (to block
just VACUUM, but not DML)

Alternative is to do it via bt_index_parent_check()/ShareLock, but it's kin=
d of
hardly acceptable in many sitations.

3. This is more a question than finding: assuming extremly big tables, woul=
dn't
we benefit from some form of caching for EState in
bt_verify_index_tuple_points_to_heap()? Or we do not care about such stuff
in amcheck? (we seem to re-create Estate with each call to FormIndexDatum()=
)

-J.

[0] - https://www.postgresql.org/message-id/flat/013D63E2-5D75-492E-85FF-1D=
5CC0148C82%40gmail.com

--0000000000008864de064ef2bae5
Content-Type: text/x-patch; charset="US-ASCII";
	name="nocfbot_v4b-0001-amcheck-attempt-to-detect-lost-heap-segments-bas.patch"
Content-Disposition: attachment;
	filename="nocfbot_v4b-0001-amcheck-attempt-to-detect-lost-heap-segments-bas.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_mnq2l0ta0>
X-Attachment-Id: f_mnq2l0ta0
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--0000000000008864de064ef2bae5--