pg.ddx.io  pgsql-bugs@postgresql.org mailing list archive  
help / color / mirror / Atom feed
BUG #19775: Incremental backup without data checksums restores a stale visibility map page after VACUUM truncati
6+ messages / 3 participants
[nested] [flat]

Commits from this thread:
  2026-11-05 b5545d3f5f dde54ecde2 41b4b8e8bf 0733c72198  Fix stale visibility maps in incremental backups after heap truncation
* BUG #19775: Incremental backup without data checksums restores a stale visibility map page after VACUUM truncati
@ 2026-10-20 03:40  PG Bug reporting form <noreply@postgresql.org>
  0 siblings, 1 reply; 6+ messages in thread

From: PG Bug reporting form @ 2026-10-20 03:40 UTC (permalink / raw)
  To: pgsql-bugs@lists.postgresql.org; +Cc: kehan5800@gmail.com

The following bug has been logged on the website:

Bug reference:      19775
Logged by:          Ke
Email address:      kehan5800@gmail.com
PostgreSQL version: 18.6
Operating system:   Ubuntu 22.04 (Linux 5.15, x86_64)
Description:        

With data checksums and wal_log_hints both off, an incremental backup taken
after VACUUM truncated a table restores the table's last visibility map page
from the prior backup. In that copy, the bits of the truncated heap pages
are
still set. When the restored table grows again, the new heap pages inherit
all-visible/all-frozen bits. VACUUM then skips those pages and advances
relfrozenxid past tuples it never froze, and on 18.6 index-only scans return
deleted rows. pg_verifybackup reports both input backups as valid.

Reproduced on master (45fc51fcbf) and 18.6, built from source with
./configure --without-icu (contrib pg_visibility and amcheck installed). An
earlier run on 17.11 gave the same result as 18.6. With data checksums
enabled
(the initdb default since 18), the same steps restore correctly (checked on
master).

---- repro.sh: PGBIN=/usr/local/pgsql/bin sh repro.sh /tmp/vmtrunc ----
#!/bin/sh
set -e
W=$1; P=5450
rm -rf "$W"; mkdir -p "$W"
"$PGBIN/initdb" -D "$W/src" -A trust --no-locale --no-data-checksums
>/dev/null
cat >> "$W/src/postgresql.conf" <<EOC
port = $P
unix_socket_directories = '$W'
listen_addresses = ''
summarize_wal = on
autovacuum = off
EOC
"$PGBIN/pg_ctl" -D "$W/src" -l "$W/src.log" -w start >/dev/null
q() { "$PGBIN/psql" -X -h "$W" -p "$1" -d postgres -Atq -c "$2"; }
q $P "CREATE EXTENSION pg_visibility; CREATE EXTENSION amcheck"
q $P "CREATE TABLE t (id int PRIMARY KEY, pad text)"
q $P "INSERT INTO t SELECT g, repeat('h', 20) FROM generate_series(1, 10064)
g"          # 74 full heap pages
q $P "INSERT INTO t SELECT 1000000 + g, repeat('x', 20) FROM
generate_series(1, 20000) g"
q $P "DELETE FROM t WHERE id > 1000000"
q $P "VACUUM (FREEZE, TRUNCATE false) t"    # empty tail pages, all-visible
and all-frozen
q $P "CHECKPOINT"
echo "before full backup: heap blocks $(q $P "SELECT pg_relation_size('t') /
8192"), all-frozen $(q $P "SELECT count(*) FROM pg_visibility_map('t') WHERE
all_frozen")"
"$PGBIN/pg_basebackup" -h "$W" -p $P -D "$W/full" -c fast
q $P "VACUUM t"                             # truncates the heap to 74
blocks
echo "after VACUUM: heap blocks $(q $P "SELECT pg_relation_size('t') /
8192")"
"$PGBIN/pg_basebackup" -h "$W" -p $P -D "$W/incr" -c fast --incremental
"$W/full/backup_manifest"
REL=$(q $P "SELECT pg_relation_filepath('t')")
"$PGBIN/pg_ctl" -D "$W/src" -w stop >/dev/null
set -- $(od -A n -t u4 -N 12 "$W/incr/$(dirname $REL)/INCREMENTAL.$(basename
$REL)_vm")
echo "incr/$(dirname $REL)/INCREMENTAL.$(basename $REL)_vm: $2 blocks,
truncation_block_length $3"
"$PGBIN/pg_combinebackup" -o "$W/restored" "$W/full" "$W/incr"
echo "port = $((P + 1))" >> "$W/restored/postgresql.conf"
"$PGBIN/pg_ctl" -D "$W/restored" -l "$W/restored.log" -w start >/dev/null
P=$((P + 1))
q $P "INSERT INTO t SELECT 2000000 + g, 'new' FROM generate_series(1, 5000)
g"
q $P "VACUUM (FREEZE) t"
echo "restored, after INSERT + VACUUM (FREEZE): heap blocks $(q $P "SELECT
pg_relation_size('t') / 8192"), all-frozen $(q $P "SELECT count(*) FROM
pg_visibility_map('t') WHERE all_frozen")"
echo "  relfrozenxid $(q $P "SELECT relfrozenxid FROM pg_class WHERE relname
= 't'"), min xmin of new rows $(q $P "SELECT min(xmin::text::bigint) FROM t
WHERE id > 2000000")"
echo "  pages with VM all-frozen set but PD_ALL_VISIBLE clear: $(q $P
"SELECT count(*) FROM pg_visibility('t') WHERE all_frozen AND NOT
pd_all_visible")"
echo "  verify_heapam: $(q $P "SELECT count(*) || ' errors, first: ' ||
coalesce(min(msg), '-') FROM verify_heapam('t')")"
q $P "DELETE FROM t WHERE id > 2000000"
q $P "VACUUM t"
echo "after DELETE of the new rows + VACUUM:"
echo "  seq scan:        $(q $P "SET enable_indexscan = off; SET
enable_indexonlyscan = off; SET enable_bitmapscan = off; SELECT count(*)
FROM t WHERE id > 2000000")"
echo "  index-only scan: $(q $P "SET enable_seqscan = off; SET
enable_bitmapscan = off; SET enable_indexscan = off; SELECT count(*) FROM t
WHERE id > 2000000")"
"$PGBIN/pg_ctl" -D "$W/restored" -w stop >/dev/null
---- end ----

Output on 18.6:

before full backup: heap blocks 222, all-frozen 222
after VACUUM: heap blocks 74
incr/base/5/INCREMENTAL.16403_vm: 0 blocks, truncation_block_length 1
WARNING:  page is not marked all-visible but visibility map bit is set in
relation "t" page 96
restored, after INSERT + VACUUM (FREEZE): heap blocks 97, all-frozen 96
  relfrozenxid 759, min xmin of new rows 758
  pages with VM all-frozen set but PD_ALL_VISIBLE clear: 22
  verify_heapam: 4972 errors, first: xmin 758 precedes relation freeze
threshold 0:759
after DELETE of the new rows + VACUUM:
  seq scan:        0
  index-only scan: 4972

Output on master (the 23 WARNING lines, all "page is not marked all-visible
but visibility map bit is set", are shortened to one):

before full backup: heap blocks 222, all-frozen 222
after VACUUM: heap blocks 74
incr/base/5/INCREMENTAL.16403_vm: 0 blocks, truncation_block_length 1
WARNING:  page is not marked all-visible but visibility map bit is set
restored, after INSERT + VACUUM (FREEZE): heap blocks 97, all-frozen 97
  relfrozenxid 671, min xmin of new rows 670
  pages with VM all-frozen set but PD_ALL_VISIBLE clear: 0
  verify_heapam: 4972 errors, first: xmin 670 precedes relation freeze
threshold 0:671
after DELETE of the new rows + VACUUM:
  seq scan:        0
  index-only scan: 0

On master, the checks added by 4f7ecca84d ("Detect and fix visibility map
corruption in more cases") warn and clear the stale bits, so the index-only
scan is right. By then, though, VACUUM (FREEZE) has already advanced
relfrozenxid past the 4972 unfrozen tuples.

Expected: verify_heapam reports no errors, and both scans return 0.

Cause: when VACUUM truncates the heap, visibilitymap_prepare_truncate()
clears
the bits of the removed heap pages in the last remaining VM page. It
WAL-logs
that page only if XLogHintBitIsNeeded():

https://github.com/postgres/postgres/blob/45fc51fcbf4534ea2f6f85e36f8155dbd5ba9851/src/backend/acces...

For XLOG_SMGR_TRUNCATE, the WAL summarizer records only the limit block of
the
VM fork, visibilitymap_truncation_length(), which still includes that page,
so
the page is never marked modified:

https://github.com/postgres/postgres/blob/45fc51fcbf4534ea2f6f85e36f8155dbd5ba9851/src/backend/postm...

The incremental backup therefore sends INCREMENTAL.<rel>_vm with no blocks
and truncation_block_length 1. pg_combinebackup takes VM page 0 from the
full
backup, where the bits for heap blocks 74..221 are still set, and the
restored
cluster does not replay the truncation record, because that record precedes
the incremental backup's start LSN. Crash recovery and plain base backups
are
not affected, because they replay the truncation record and so clear the
bits
again.

One possible fix is to have the summarizer mark the last remaining VM page
as
modified when it summarizes the truncation. With this patch, the script
restores correctly on master (verify_heapam: 0 errors, both scans 0):

inline patch 1: src/backend/postmaster/walsummarizer.c (+0/-0 lines) download inline-1.patch--- a/src/backend/postmaster/walsummarizer.c +++ b/src/backend/postmaster/walsummarizer.c @@ -1457,9 +1457,22 @@ SummarizeSmgrRecord(XLogReaderState *xlogreader,
BlockRefTable *brtab) BlockRefTableSetLimitBlock(brtab, &xlrec->rlocator, MAIN_FORKNUM, xlrec->blkno); if ((xlrec->flags & SMGR_TRUNCATE_VM) != 0) + { + BlockNumber vmlimit = visibilitymap_truncation_length(xlrec->blkno); + BlockRefTableSetLimitBlock(brtab, &xlrec->rlocator, - VISIBILITYMAP_FORKNUM, - visibilitymap_truncation_length(xlrec->blkno)); + VISIBILITYMAP_FORKNUM, vmlimit); + + /* + * visibilitymap_prepare_truncate() clears the tail bits of the + * last remaining VM page without registering it in WAL (unless + * XLogHintBitIsNeeded()), so record that page as modified. + */ + if (vmlimit > 0) + BlockRefTableMarkBlockModified(brtab, &xlrec->rlocator, + VISIBILITYMAP_FORKNUM, + vmlimit - 1); + } } } The other option is to always WAL-log that page in visibilitymap_prepare_truncate(). That question came up in the pgsql-hackers thread "Why clearing the VM doesn't require registering vm buffer in wal record" (Andres Freund, 2026-03-12, and Robert Haas, 2026-03-17, https://www.postgresql.org/message-id/t7xd6gjxdxpzdzr2uamfbyi5rlkdsikiywmtmgwrwcsr77xyw7@i3qhbzy5rpz...). The fixes committed from that thread (ed62d26cac and later) cover VM clears in heap records, not the truncation path. Either way, summaries and backups that already exist would still be affected. ^ permalink raw reply [nested|flat] 6+ messages in thread

* Re: BUG #19775: Incremental backup without data checksums restores a stale visibility map page after VACUUM truncati
@ 2026-10-23 02:01  Fujii Masao <masao.fujii@gmail.com>
  parent: PG Bug reporting form <noreply@postgresql.org>
  0 siblings, 1 reply; 6+ messages in thread

From: Fujii Masao @ 2026-10-23 02:01 UTC (permalink / raw)
  To: kehan5800@gmail.com; pgsql-bugs@lists.postgresql.org

On Thu, Oct 22, 2026 at 3:27 PM PG Bug reporting form
<noreply@postgresql.org> wrote:
> One possible fix is to have the summarizer mark the last remaining VM page
> as
> modified when it summarizes the truncation.

Thanks for the report and investigation! I've attached a patch based on
your approach, along with a TAP test that checks for stale VM bits after
restoring an incremental backup.

Regards,

-- 
Fujii Masao

Attachments: download all (2 files, .tar.gz)

v1-0001-Fix-stale-visibility-maps-in-incremental-backups-.patch (application/octet-stream, 6.8K) download From db51e97460698b37e7c44bf6d5268e5f353410f3 Mon Sep 17 00:00:00 2001 From: Fujii Masao <fujii@postgresql.org> Date: Thu, 22 Oct 2026 20:58:56 +0900 Subject: [PATCH v1] Fix stale visibility maps in incremental backups after heap truncation An incremental backup taken after VACUUM truncates a table can restore stale visibility map bits when both data checksums and wal_log_hints are disabled. If the restored table grows again, the stale bits can cause VACUUM to skip required freezing and advance relfrozenxid past unfrozen tuples, or cause index-only scans to return deleted rows. Heap truncation clears bits for removed heap pages in the last remaining VM page. With both settings disabled, that page is not separately WAL-logged. The WAL summarizer records the VM truncation limit but does not mark the remaining page as modified, allowing incremental backups to reuse its old contents. The truncation record precedes the incremental backup's start LSN, so recovery does not replay it to clear those bits. Fix this by marking the last remaining VM page as modified when summarizing a truncation record, so incremental backups include its current contents. Do this conservatively even when truncation falls on a VM page boundary and the remaining page does not need to change. Note that existing WAL summaries are not regenerated by this fix. Incremental backups taken after updating can therefore still be affected if they use summaries generated before the fix. Take a new full backup from an uncorrupted server after updating and use it as the basis for subsequent incremental backups. This does not repair existing backups or corruption already present in a restored database. Backpatch to PostgreSQL 17, where incremental backup was introduced. Bug: #19775 Author: Ke <kehan5800@gmail.com> Reviewed-by: Fujii Masao <masao.fujii@gmail.com> Discussion: https://postgr.es/m/19775-087aebfa1a709b09@postgresql.org Backpatch-through: 17 --- src/backend/postmaster/walsummarizer.c | 17 +++- src/bin/pg_combinebackup/meson.build | 1 + .../pg_combinebackup/t/013_vm_truncation.pl | 81 +++++++++++++++++++ 3 files changed, 97 insertions(+), 2 deletions(-) create mode 100644 src/bin/pg_combinebackup/t/013_vm_truncation.pl diff --git a/src/backend/postmaster/walsummarizer.c b/src/backend/postmaster/walsummarizer.c index 8333a4eaaa3..b4ef9937499 100644 --- a/src/backend/postmaster/walsummarizer.c +++ b/src/backend/postmaster/walsummarizer.c @@ -1457,9 +1457,22 @@ SummarizeSmgrRecord(XLogReaderState *xlogreader, BlockRefTable *brtab) BlockRefTableSetLimitBlock(brtab, &xlrec->rlocator, MAIN_FORKNUM, xlrec->blkno); if ((xlrec->flags & SMGR_TRUNCATE_VM) != 0) + { + BlockNumber vmlimit = visibilitymap_truncation_length(xlrec->blkno); + BlockRefTableSetLimitBlock(brtab, &xlrec->rlocator, - VISIBILITYMAP_FORKNUM, - visibilitymap_truncation_length(xlrec->blkno)); + VISIBILITYMAP_FORKNUM, vmlimit); + + /* + * visibilitymap_prepare_truncate() may clear bits in the last remaining + * VM page without WAL-logging the page. Conservatively mark it as + * modified so that incremental backups include its current contents. + */ + if (vmlimit > 0) + BlockRefTableMarkBlockModified(brtab, &xlrec->rlocator, + VISIBILITYMAP_FORKNUM, + vmlimit - 1); + } } } diff --git a/src/bin/pg_combinebackup/meson.build b/src/bin/pg_combinebackup/meson.build index ba1c8cfa3d0..ddc39145822 100644 --- a/src/bin/pg_combinebackup/meson.build +++ b/src/bin/pg_combinebackup/meson.build @@ -40,6 +40,7 @@ tests += { 't/010_hardlink.pl', 't/011_ib_truncation.pl', 't/012_vm_consistency.pl', + 't/013_vm_truncation.pl', ], } } diff --git a/src/bin/pg_combinebackup/t/013_vm_truncation.pl b/src/bin/pg_combinebackup/t/013_vm_truncation.pl new file mode 100644 index 00000000000..b313c2ebe81 --- /dev/null +++ b/src/bin/pg_combinebackup/t/013_vm_truncation.pl @@ -0,0 +1,81 @@ +# Copyright (c) 2026, PostgreSQL Global Development Group +# +# Test that incremental backups preserve visibility map changes made by +# VACUUM truncation when both data checksums and wal_log_hints are disabled. +# The restored map must not retain set bits for truncated heap pages. + +use strict; +use warnings FATAL => 'all'; +use PostgreSQL::Test::Cluster; +use PostgreSQL::Test::Utils; +use Test::More; + +my $mode = $ENV{PG_TEST_PG_COMBINEBACKUP_MODE} || '--copy'; + +my $primary = PostgreSQL::Test::Cluster->new('primary'); +$primary->init(allows_streaming => 1, no_data_checksums => 1); +$primary->append_conf('postgresql.conf', <<EOF); +summarize_wal = on +wal_log_hints = off +autovacuum = off +EOF +$primary->start; + +# Use uncompressed inline rows large enough to fit only one per heap page. +$primary->safe_psql( + 'postgres', q{ + CREATE EXTENSION pg_visibility; + CREATE TABLE t (id int, pad text STORAGE PLAIN); + INSERT INTO t + SELECT g, repeat('x', current_setting('block_size')::int / 2) + FROM generate_series(1, 8) g; + DELETE FROM t WHERE id > 2; +}); + +# Set both VM bits for the empty tail pages without truncating them. +$primary->safe_psql('postgres', 'VACUUM (FREEZE, TRUNCATE false) t'); + +my $heap_blocks_sql = + q{SELECT pg_relation_size('t') / current_setting('block_size')::int}; +my $vm_summary_sql = + q{SELECT all_visible, all_frozen FROM pg_visibility_map_summary('t')}; + +is($primary->safe_psql('postgres', $heap_blocks_sql), + '8', 'empty tail pages remain before full backup'); +is($primary->safe_psql('postgres', $vm_summary_sql), + '8|8', 'all pages have both VM bits set before full backup'); +$primary->backup('full'); + +$primary->safe_psql('postgres', 'VACUUM (TRUNCATE) t'); +is($primary->safe_psql('postgres', $heap_blocks_sql), + '2', 'VACUUM truncates the empty tail pages'); +is($primary->safe_psql('postgres', $vm_summary_sql), + '2|2', 'VACUUM clears VM bits for the removed heap pages'); +is( $primary->safe_psql( + 'postgres', + q{SELECT pg_relation_size('t', 'vm') / current_setting('block_size')::int} + ), + '1', + 'VM fork still contains one page after truncation'); + +my $full_backup = $primary->backup_dir . '/full'; +$primary->backup('incr', + backup_options => [ '--incremental', "$full_backup/backup_manifest" ]); +$primary->stop; + +my $restored = PostgreSQL::Test::Cluster->new('restored'); +$restored->init_from_backup( + $primary, 'incr', + combine_with_prior => ['full'], + combine_mode => $mode); +$restored->start; + +# Count all VM bits, including those beyond the end of the heap, to +# detect stale bits inherited from the full backup. +is($restored->safe_psql('postgres', $heap_blocks_sql), + '2', 'restored heap has the truncated length'); +is($restored->safe_psql('postgres', $vm_summary_sql), + '2|2', 'restored VM has no stale bits for removed heap pages'); + +$restored->stop; +done_testing(); -- 2.56.0
nocfbot-v1-0001-PG17-Fix-stale-visibility-maps-in-incremental-backups-.patch (application/octet-stream, 7.0K) download From ec229324c499e144a771800eefdac1681e755e91 Mon Sep 17 00:00:00 2001 From: Fujii Masao <fujii@postgresql.org> Date: Thu, 22 Oct 2026 20:58:56 +0900 Subject: [PATCH v1] Fix stale visibility maps in incremental backups after heap truncation An incremental backup taken after VACUUM truncates a table can restore stale visibility map bits when both data checksums and wal_log_hints are disabled. If the restored table grows again, the stale bits can cause VACUUM to skip required freezing and advance relfrozenxid past unfrozen tuples, or cause index-only scans to return deleted rows. Heap truncation clears bits for removed heap pages in the last remaining VM page. With both settings disabled, that page is not separately WAL-logged. The WAL summarizer records the VM truncation limit but does not mark the remaining page as modified, allowing incremental backups to reuse its old contents. The truncation record precedes the incremental backup's start LSN, so recovery does not replay it to clear those bits. Fix this by marking the last remaining VM page as modified when summarizing a truncation record, so incremental backups include its current contents. Do this conservatively even when truncation falls on a VM page boundary and the remaining page does not need to change. Note that existing WAL summaries are not regenerated by this fix. Incremental backups taken after updating can therefore still be affected if they use summaries generated before the fix. Take a new full backup from an uncorrupted server after updating and use it as the basis for subsequent incremental backups. This does not repair existing backups or corruption already present in a restored database. Backpatch to PostgreSQL 17, where incremental backup was introduced. Bug: #19775 Author: Ke <kehan5800@gmail.com> Reviewed-by: Fujii Masao <masao.fujii@gmail.com> Discussion: https://postgr.es/m/19775-087aebfa1a709b09@postgresql.org Backpatch-through: 17 --- src/backend/postmaster/walsummarizer.c | 17 +++- src/bin/pg_combinebackup/meson.build | 1 + .../pg_combinebackup/t/013_vm_truncation.pl | 86 +++++++++++++++++++ 3 files changed, 102 insertions(+), 2 deletions(-) create mode 100644 src/bin/pg_combinebackup/t/013_vm_truncation.pl diff --git a/src/backend/postmaster/walsummarizer.c b/src/backend/postmaster/walsummarizer.c index 02a4ef8433a..be4fa3eae90 100644 --- a/src/backend/postmaster/walsummarizer.c +++ b/src/backend/postmaster/walsummarizer.c @@ -1452,9 +1452,22 @@ SummarizeSmgrRecord(XLogReaderState *xlogreader, BlockRefTable *brtab) BlockRefTableSetLimitBlock(brtab, &xlrec->rlocator, MAIN_FORKNUM, xlrec->blkno); if ((xlrec->flags & SMGR_TRUNCATE_VM) != 0) + { + BlockNumber vmlimit = visibilitymap_truncation_length(xlrec->blkno); + BlockRefTableSetLimitBlock(brtab, &xlrec->rlocator, - VISIBILITYMAP_FORKNUM, - visibilitymap_truncation_length(xlrec->blkno)); + VISIBILITYMAP_FORKNUM, vmlimit); + + /* + * visibilitymap_prepare_truncate() may clear bits in the last remaining + * VM page without WAL-logging the page. Conservatively mark it as + * modified so that incremental backups include its current contents. + */ + if (vmlimit > 0) + BlockRefTableMarkBlockModified(brtab, &xlrec->rlocator, + VISIBILITYMAP_FORKNUM, + vmlimit - 1); + } } } diff --git a/src/bin/pg_combinebackup/meson.build b/src/bin/pg_combinebackup/meson.build index f93dcaafee3..8f7e7be9870 100644 --- a/src/bin/pg_combinebackup/meson.build +++ b/src/bin/pg_combinebackup/meson.build @@ -39,6 +39,7 @@ tests += { 't/009_no_full_file.pl', 't/011_ib_truncation.pl', 't/012_vm_consistency.pl', + 't/013_vm_truncation.pl', ], } } diff --git a/src/bin/pg_combinebackup/t/013_vm_truncation.pl b/src/bin/pg_combinebackup/t/013_vm_truncation.pl new file mode 100644 index 00000000000..61ee2b35247 --- /dev/null +++ b/src/bin/pg_combinebackup/t/013_vm_truncation.pl @@ -0,0 +1,86 @@ +# Copyright (c) 2026, PostgreSQL Global Development Group +# +# Test that incremental backups preserve visibility map changes made by +# VACUUM truncation when both data checksums and wal_log_hints are disabled. +# The restored map must not retain set bits for truncated heap pages. + +use strict; +use warnings FATAL => 'all'; +use PostgreSQL::Test::Cluster; +use PostgreSQL::Test::Utils; +use Test::More; + +my $mode = $ENV{PG_TEST_PG_COMBINEBACKUP_MODE} || '--copy'; + +my $primary = PostgreSQL::Test::Cluster->new('primary'); +# Enable checksums explicitly, then disable them before starting the server. +# This also works when PG_TEST_INITDB_EXTRA_OPTS enables checksums. +$primary->init(allows_streaming => 1, extra => ['--data-checksums']); +$primary->command_ok( + [ 'pg_checksums', '--disable', '--no-sync', '-D', $primary->data_dir ], + 'disable data checksums'); +$primary->append_conf('postgresql.conf', <<EOF); +summarize_wal = on +wal_log_hints = off +autovacuum = off +EOF +$primary->start; + +# Use uncompressed inline rows large enough to fit only one per heap page. +$primary->safe_psql( + 'postgres', q{ + CREATE EXTENSION pg_visibility; + CREATE TABLE t (id int, pad text STORAGE PLAIN); + INSERT INTO t + SELECT g, repeat('x', current_setting('block_size')::int / 2) + FROM generate_series(1, 8) g; + DELETE FROM t WHERE id > 2; +}); + +# Set both VM bits for the empty tail pages without truncating them. +$primary->safe_psql('postgres', 'VACUUM (FREEZE, TRUNCATE false) t'); + +my $heap_blocks_sql = + q{SELECT pg_relation_size('t') / current_setting('block_size')::int}; +my $vm_summary_sql = + q{SELECT all_visible, all_frozen FROM pg_visibility_map_summary('t')}; + +is($primary->safe_psql('postgres', $heap_blocks_sql), + '8', 'empty tail pages remain before full backup'); +is($primary->safe_psql('postgres', $vm_summary_sql), + '8|8', 'all pages have both VM bits set before full backup'); +$primary->backup('full'); + +$primary->safe_psql('postgres', 'VACUUM (TRUNCATE) t'); +is($primary->safe_psql('postgres', $heap_blocks_sql), + '2', 'VACUUM truncates the empty tail pages'); +is($primary->safe_psql('postgres', $vm_summary_sql), + '2|2', 'VACUUM clears VM bits for the removed heap pages'); +is( $primary->safe_psql( + 'postgres', + q{SELECT pg_relation_size('t', 'vm') / current_setting('block_size')::int} + ), + '1', + 'VM fork still contains one page after truncation'); + +my $full_backup = $primary->backup_dir . '/full'; +$primary->backup('incr', + backup_options => [ '--incremental', "$full_backup/backup_manifest" ]); +$primary->stop; + +my $restored = PostgreSQL::Test::Cluster->new('restored'); +$restored->init_from_backup( + $primary, 'incr', + combine_with_prior => ['full'], + combine_mode => $mode); +$restored->start; + +# Count all VM bits, including those beyond the end of the heap, to +# detect stale bits inherited from the full backup. +is($restored->safe_psql('postgres', $heap_blocks_sql), + '2', 'restored heap has the truncated length'); +is($restored->safe_psql('postgres', $vm_summary_sql), + '2|2', 'restored VM has no stale bits for removed heap pages'); + +$restored->stop; +done_testing(); -- 2.56.0
^ permalink raw reply [nested|flat] 6+ messages in thread

* Re: BUG #19775: Incremental backup without data checksums restores a stale visibility map page after VACUUM truncati
@ 2026-10-23 03:01  shihao zhong <zhong950419@gmail.com>
  parent: Fujii Masao <masao.fujii@gmail.com>
  0 siblings, 1 reply; 6+ messages in thread

From: shihao zhong @ 2026-10-23 03:01 UTC (permalink / raw)
  To: Fujii Masao <masao.fujii@gmail.com>; +Cc: kehan5800@gmail.com; pgsql-bugs@lists.postgresql.org

Hi Fujii-san,

Thanks for the patch. I reported this on pgsql-hackers a day after
Ke [1]. I fixed it on the WAL writer side instead. My patch always
WAL-logs the VM page in visibilitymap_prepare_truncate(), as Andres
suggested in [2]. I tested both fixes.

1. Writer side vs summarizer side. The writer side fix gives the VM
page a new LSN and a WAL block reference. So any tool that reads WAL
or page LSNs may sees it, not only the summarizer. For example, WAL-G
delta backups track page LSNs. I think they may miss the page with a
summarizer only fix, but I have not tested them. The cost is a page
image when checksums and wal_log_hints are off. It also misses WAL
written before the update but not yet in a summary file, and an
updated standby with an old primary. Yours covers both and adds no
WAL. So yours fits the back branches better. Whether the master should
WAL-log the page is your call.

2. On 17 and 18, 013 passes even without the fix. The attached patch
reads the VM with pg_visibility_map() per block, so it fails there
too.

3. A correction to [1]. A later VACUUM does not fix the wrong results

[1]
https://postgr.es/m/CAGRkXqSnghF+wbyP-PdfjVLfbejJG3cvZd9hN-gxsvCWj2F64Q@mail.gmail.com
[2]
https://postgr.es/m/t7xd6gjxdxpzdzr2uamfbyi5rlkdsikiywmtmgwrwcsr77xyw7@i3qhbzy5rpzx

Thanks,
Shihao

Attachments:

0001-Read-VM-bits-past-the-heap-end-in-013_vm_truncation.patch (application/octet-stream, 1.3K) download From 6e566b58cec918ec258275935dcef0f6cab03dc3 Mon Sep 17 00:00:00 2001 From: shihao zhong <zhong950419@gmail.com> Date: Thu, 22 Oct 2026 22:36:39 -0400 Subject: [PATCH] Read VM bits past the heap end in 013_vm_truncation --- src/bin/pg_combinebackup/t/013_vm_truncation.pl | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/src/bin/pg_combinebackup/t/013_vm_truncation.pl b/src/bin/pg_combinebackup/t/013_vm_truncation.pl index b313c2ebe81..029c5bbfc9a 100644 --- a/src/bin/pg_combinebackup/t/013_vm_truncation.pl +++ b/src/bin/pg_combinebackup/t/013_vm_truncation.pl @@ -37,8 +37,11 @@ $primary->safe_psql('postgres', 'VACUUM (FREEZE, TRUNCATE false) t'); my $heap_blocks_sql = q{SELECT pg_relation_size('t') / current_setting('block_size')::int}; -my $vm_summary_sql = - q{SELECT all_visible, all_frozen FROM pg_visibility_map_summary('t')}; +# Read the VM bits of every block the table ever had. Before v19, +# pg_visibility_map_summary() stops at the end of the heap. +my $vm_summary_sql = q{ + SELECT count(*) FILTER (WHERE all_visible), count(*) FILTER (WHERE all_frozen) + FROM generate_series(0, 7) AS b, pg_visibility_map('t', b)}; is($primary->safe_psql('postgres', $heap_blocks_sql), '8', 'empty tail pages remain before full backup'); -- 2.37.1 (Apple Git-137.1)
^ permalink raw reply [nested|flat] 6+ messages in thread

* Re: BUG #19775: Incremental backup without data checksums restores a stale visibility map page after VACUUM truncati
@ 2026-11-04 13:55  Fujii Masao <masao.fujii@gmail.com>
  parent: shihao zhong <zhong950419@gmail.com>
  0 siblings, 1 reply; 6+ messages in thread

From: Fujii Masao @ 2026-11-04 13:55 UTC (permalink / raw)
  To: shihao zhong <zhong950419@gmail.com>; +Cc: kehan5800@gmail.com; pgsql-bugs@lists.postgresql.org

On Fri, Oct 23, 2026 at 12:01 PM shihao zhong <zhong950419@gmail.com> wrote:
> Yours covers both and adds no
> WAL. So yours fits the back branches better. Whether the master should
> WAL-log the page is your call.

Agreed. I'd prefer the summarizer-side fix for that reason. I understand
the potential benefit of WAL-logging the page for other backup tools,
but I'm not yet sure how useful that would be in practice. I have no strong
objections to considering it for master later, but I'd like to apply
the summarizer-side fix first.


> 2. On 17 and 18, 013 passes even without the fix. The attached patch
> reads the VM with pg_visibility_map() per block, so it fails there
> too.

Thanks for the review and test fix! The attached v2 incorporates your
test fix and renames the test from 013_vm_truncation.pl to
014_vm_truncation.pl to avoid a numbering conflict.

Regards,

-- 
Fujii Masao

Attachments: download all (2 files, .tar.gz)

v2-0001-Fix-stale-visibility-maps-in-incremental-backups-.patch (application/octet-stream, 7.1K) download From e054e2c477c2e8303d70635efd174334f9342e71 Mon Sep 17 00:00:00 2001 From: Fujii Masao <fujii@postgresql.org> Date: Thu, 22 Oct 2026 20:58:56 +0900 Subject: [PATCH v2] Fix stale visibility maps in incremental backups after heap truncation An incremental backup taken after VACUUM truncates a table can restore stale visibility map bits when both data checksums and wal_log_hints are disabled. If the restored table grows again, the stale bits can cause VACUUM to skip required freezing and advance relfrozenxid past unfrozen tuples, or cause index-only scans to return deleted rows. Heap truncation clears bits for removed heap pages in the last remaining VM page. With both settings disabled, that page is not separately WAL-logged. The WAL summarizer records the VM truncation limit but does not mark the remaining page as modified, allowing incremental backups to reuse its old contents. The truncation record precedes the incremental backup's start LSN, so recovery does not replay it to clear those bits. Fix this by marking the last remaining VM page as modified when summarizing a truncation record, so incremental backups include its current contents. Do this conservatively even when truncation falls on a VM page boundary and the remaining page does not need to change. Note that existing WAL summaries are not regenerated by this fix. Incremental backups taken after updating can therefore still be affected if they use summaries generated before the fix. Take a new full backup from an uncorrupted server after updating and use it as the basis for subsequent incremental backups. This does not repair existing backups or corruption already present in a restored database. Backpatch to PostgreSQL 17, where incremental backup was introduced. Bug: #19775 Author: Ke <kehan5800@gmail.com> Co-authored-by: Fujii Masao <masao.fujii@gmail.com> Co-authored-by: Shihao Zhong <zhong950419@gmail.com> Discussion: https://postgr.es/m/19775-087aebfa1a709b09@postgresql.org Discussion: https://postgr.es/m/CAGRkXqSnghF+wbyP-PdfjVLfbejJG3cvZd9hN-gxsvCWj2F64Q@mail.gmail.com Backpatch-through: 17 --- src/backend/postmaster/walsummarizer.c | 19 ++++- src/bin/pg_combinebackup/meson.build | 1 + .../pg_combinebackup/t/014_vm_truncation.pl | 85 +++++++++++++++++++ 3 files changed, 103 insertions(+), 2 deletions(-) create mode 100644 src/bin/pg_combinebackup/t/014_vm_truncation.pl diff --git a/src/backend/postmaster/walsummarizer.c b/src/backend/postmaster/walsummarizer.c index 8333a4eaaa3..cf78a29d3f0 100644 --- a/src/backend/postmaster/walsummarizer.c +++ b/src/backend/postmaster/walsummarizer.c @@ -1457,9 +1457,24 @@ SummarizeSmgrRecord(XLogReaderState *xlogreader, BlockRefTable *brtab) BlockRefTableSetLimitBlock(brtab, &xlrec->rlocator, MAIN_FORKNUM, xlrec->blkno); if ((xlrec->flags & SMGR_TRUNCATE_VM) != 0) + { + BlockNumber vmlimit = visibilitymap_truncation_length(xlrec->blkno); + BlockRefTableSetLimitBlock(brtab, &xlrec->rlocator, - VISIBILITYMAP_FORKNUM, - visibilitymap_truncation_length(xlrec->blkno)); + VISIBILITYMAP_FORKNUM, vmlimit); + + /* + * visibilitymap_prepare_truncate() may clear trailing bits in the + * last remaining VM page without WAL-logging the page. Mark it + * as modified so that incremental backups include its current + * contents. Do this even at a VM page boundary, where no bits + * need clearing. + */ + if (vmlimit > 0) + BlockRefTableMarkBlockModified(brtab, &xlrec->rlocator, + VISIBILITYMAP_FORKNUM, + vmlimit - 1); + } } } diff --git a/src/bin/pg_combinebackup/meson.build b/src/bin/pg_combinebackup/meson.build index 10702f36a5d..64da66b338e 100644 --- a/src/bin/pg_combinebackup/meson.build +++ b/src/bin/pg_combinebackup/meson.build @@ -41,6 +41,7 @@ tests += { 't/011_ib_truncation.pl', 't/012_vm_consistency.pl', 't/013_summary_order.pl', + 't/014_vm_truncation.pl', ], } } diff --git a/src/bin/pg_combinebackup/t/014_vm_truncation.pl b/src/bin/pg_combinebackup/t/014_vm_truncation.pl new file mode 100644 index 00000000000..557ac190d71 --- /dev/null +++ b/src/bin/pg_combinebackup/t/014_vm_truncation.pl @@ -0,0 +1,85 @@ +# Copyright (c) 2026, PostgreSQL Global Development Group +# +# Test that incremental backups preserve visibility map changes made by +# VACUUM truncation when both data checksums and wal_log_hints are disabled. +# The restored map must not retain set bits for truncated heap pages. + +use strict; +use warnings FATAL => 'all'; +use PostgreSQL::Test::Cluster; +use PostgreSQL::Test::Utils; +use Test::More; + +my $mode = $ENV{PG_TEST_PG_COMBINEBACKUP_MODE} || '--copy'; + +my $primary = PostgreSQL::Test::Cluster->new('primary'); +$primary->init(allows_streaming => 1, no_data_checksums => 1); +$primary->append_conf('postgresql.conf', <<EOF); +summarize_wal = on +wal_log_hints = off +autovacuum = off +EOF +$primary->start; + +# Use uncompressed inline rows large enough to fit only one per heap page. +$primary->safe_psql( + 'postgres', q{ + CREATE EXTENSION pg_visibility; + CREATE TABLE t (id int, pad text STORAGE PLAIN); + INSERT INTO t + SELECT g, repeat('x', current_setting('block_size')::int / 2) + FROM generate_series(1, 8) g; + DELETE FROM t WHERE id > 2; +}); + +# Set both VM bits for all pages, keeping the empty tail pages. +$primary->safe_psql('postgres', 'VACUUM (FREEZE, TRUNCATE false) t'); + +my $heap_blocks_sql = + q{SELECT pg_relation_size('t') / current_setting('block_size')::int}; + +# Check all eight original heap blocks, including those removed by truncation. +my $vm_summary_sql = q{ + SELECT count(*) FILTER (WHERE all_visible), count(*) FILTER (WHERE all_frozen) + FROM generate_series(0, 7) AS b, pg_visibility_map('t', b)}; + +is($primary->safe_psql('postgres', $heap_blocks_sql), + '8', 'empty tail pages remain before full backup'); +is($primary->safe_psql('postgres', $vm_summary_sql), + '8|8', 'all pages have both VM bits set before full backup'); + +$primary->backup('full'); + +$primary->safe_psql('postgres', 'VACUUM (TRUNCATE) t'); +is($primary->safe_psql('postgres', $heap_blocks_sql), + '2', 'VACUUM truncates the empty tail pages'); +is($primary->safe_psql('postgres', $vm_summary_sql), + '2|2', 'VACUUM clears VM bits for the removed heap pages'); +is( $primary->safe_psql( + 'postgres', + q{SELECT pg_relation_size('t', 'vm') / current_setting('block_size')::int} + ), + '1', + 'VM fork still contains one page after truncation'); + +my $full_backup = $primary->backup_dir . '/full'; +$primary->backup('incr', + backup_options => [ '--incremental', "$full_backup/backup_manifest" ]); +$primary->stop; + +my $restored = PostgreSQL::Test::Cluster->new('restored'); +$restored->init_from_backup( + $primary, 'incr', + combine_with_prior => ['full'], + combine_mode => $mode); +$restored->start; + +# Count all VM bits, including those beyond the end of the heap, to +# detect stale bits inherited from the full backup. +is($restored->safe_psql('postgres', $heap_blocks_sql), + '2', 'restored heap has the truncated length'); +is($restored->safe_psql('postgres', $vm_summary_sql), + '2|2', 'restored VM has no stale bits for removed heap pages'); + +$restored->stop; +done_testing(); -- 2.56.0
nocfbot-v2-0001-PG17-Fix-stale-visibility-maps-in-incremental-backups-.patch (application/octet-stream, 7.4K) download From 273c38817079825159978bdbe577dcc40d1ed627 Mon Sep 17 00:00:00 2001 From: Fujii Masao <fujii@postgresql.org> Date: Thu, 22 Oct 2026 20:58:56 +0900 Subject: [PATCH v2] Fix stale visibility maps in incremental backups after heap truncation An incremental backup taken after VACUUM truncates a table can restore stale visibility map bits when both data checksums and wal_log_hints are disabled. If the restored table grows again, the stale bits can cause VACUUM to skip required freezing and advance relfrozenxid past unfrozen tuples, or cause index-only scans to return deleted rows. Heap truncation clears bits for removed heap pages in the last remaining VM page. With both settings disabled, that page is not separately WAL-logged. The WAL summarizer records the VM truncation limit but does not mark the remaining page as modified, allowing incremental backups to reuse its old contents. The truncation record precedes the incremental backup's start LSN, so recovery does not replay it to clear those bits. Fix this by marking the last remaining VM page as modified when summarizing a truncation record, so incremental backups include its current contents. Do this conservatively even when truncation falls on a VM page boundary and the remaining page does not need to change. Note that existing WAL summaries are not regenerated by this fix. Incremental backups taken after updating can therefore still be affected if they use summaries generated before the fix. Take a new full backup from an uncorrupted server after updating and use it as the basis for subsequent incremental backups. This does not repair existing backups or corruption already present in a restored database. Backpatch to PostgreSQL 17, where incremental backup was introduced. Bug: #19775 Author: Ke <kehan5800@gmail.com> Co-authored-by: Fujii Masao <masao.fujii@gmail.com> Co-authored-by: Shihao Zhong <zhong950419@gmail.com> Discussion: https://postgr.es/m/19775-087aebfa1a709b09@postgresql.org Discussion: https://postgr.es/m/CAGRkXqSnghF+wbyP-PdfjVLfbejJG3cvZd9hN-gxsvCWj2F64Q@mail.gmail.com Backpatch-through: 17 --- src/backend/postmaster/walsummarizer.c | 19 +++- src/bin/pg_combinebackup/meson.build | 1 + .../pg_combinebackup/t/014_vm_truncation.pl | 90 +++++++++++++++++++ 3 files changed, 108 insertions(+), 2 deletions(-) create mode 100644 src/bin/pg_combinebackup/t/014_vm_truncation.pl diff --git a/src/backend/postmaster/walsummarizer.c b/src/backend/postmaster/walsummarizer.c index 02a4ef8433a..245a592425c 100644 --- a/src/backend/postmaster/walsummarizer.c +++ b/src/backend/postmaster/walsummarizer.c @@ -1452,9 +1452,24 @@ SummarizeSmgrRecord(XLogReaderState *xlogreader, BlockRefTable *brtab) BlockRefTableSetLimitBlock(brtab, &xlrec->rlocator, MAIN_FORKNUM, xlrec->blkno); if ((xlrec->flags & SMGR_TRUNCATE_VM) != 0) + { + BlockNumber vmlimit = visibilitymap_truncation_length(xlrec->blkno); + BlockRefTableSetLimitBlock(brtab, &xlrec->rlocator, - VISIBILITYMAP_FORKNUM, - visibilitymap_truncation_length(xlrec->blkno)); + VISIBILITYMAP_FORKNUM, vmlimit); + + /* + * visibilitymap_prepare_truncate() may clear trailing bits in the + * last remaining VM page without WAL-logging the page. Mark it + * as modified so that incremental backups include its current + * contents. Do this even at a VM page boundary, where no bits + * need clearing. + */ + if (vmlimit > 0) + BlockRefTableMarkBlockModified(brtab, &xlrec->rlocator, + VISIBILITYMAP_FORKNUM, + vmlimit - 1); + } } } diff --git a/src/bin/pg_combinebackup/meson.build b/src/bin/pg_combinebackup/meson.build index 2ae49de5410..084f3da6710 100644 --- a/src/bin/pg_combinebackup/meson.build +++ b/src/bin/pg_combinebackup/meson.build @@ -40,6 +40,7 @@ tests += { 't/011_ib_truncation.pl', 't/012_vm_consistency.pl', 't/013_summary_order.pl', + 't/014_vm_truncation.pl', ], } } diff --git a/src/bin/pg_combinebackup/t/014_vm_truncation.pl b/src/bin/pg_combinebackup/t/014_vm_truncation.pl new file mode 100644 index 00000000000..68a138bb729 --- /dev/null +++ b/src/bin/pg_combinebackup/t/014_vm_truncation.pl @@ -0,0 +1,90 @@ +# Copyright (c) 2026, PostgreSQL Global Development Group +# +# Test that incremental backups preserve visibility map changes made by +# VACUUM truncation when both data checksums and wal_log_hints are disabled. +# The restored map must not retain set bits for truncated heap pages. + +use strict; +use warnings FATAL => 'all'; +use PostgreSQL::Test::Cluster; +use PostgreSQL::Test::Utils; +use Test::More; + +my $mode = $ENV{PG_TEST_PG_COMBINEBACKUP_MODE} || '--copy'; + +my $primary = PostgreSQL::Test::Cluster->new('primary'); +# Enable checksums explicitly, then disable them before starting the server. +# This also works when PG_TEST_INITDB_EXTRA_OPTS enables checksums. +$primary->init(allows_streaming => 1, extra => ['--data-checksums']); +$primary->command_ok( + [ 'pg_checksums', '--disable', '--no-sync', '-D', $primary->data_dir ], + 'disable data checksums'); +$primary->append_conf('postgresql.conf', <<EOF); +summarize_wal = on +wal_log_hints = off +autovacuum = off +EOF +$primary->start; + +# Use uncompressed inline rows large enough to fit only one per heap page. +$primary->safe_psql( + 'postgres', q{ + CREATE EXTENSION pg_visibility; + CREATE TABLE t (id int, pad text STORAGE PLAIN); + INSERT INTO t + SELECT g, repeat('x', current_setting('block_size')::int / 2) + FROM generate_series(1, 8) g; + DELETE FROM t WHERE id > 2; +}); + +# Set both VM bits for all pages, keeping the empty tail pages. +$primary->safe_psql('postgres', 'VACUUM (FREEZE, TRUNCATE false) t'); + +my $heap_blocks_sql = + q{SELECT pg_relation_size('t') / current_setting('block_size')::int}; + +# Check all eight original heap blocks, including those removed by truncation. +my $vm_summary_sql = q{ + SELECT count(*) FILTER (WHERE all_visible), count(*) FILTER (WHERE all_frozen) + FROM generate_series(0, 7) AS b, pg_visibility_map('t', b)}; + +is($primary->safe_psql('postgres', $heap_blocks_sql), + '8', 'empty tail pages remain before full backup'); +is($primary->safe_psql('postgres', $vm_summary_sql), + '8|8', 'all pages have both VM bits set before full backup'); + +$primary->backup('full'); + +$primary->safe_psql('postgres', 'VACUUM (TRUNCATE) t'); +is($primary->safe_psql('postgres', $heap_blocks_sql), + '2', 'VACUUM truncates the empty tail pages'); +is($primary->safe_psql('postgres', $vm_summary_sql), + '2|2', 'VACUUM clears VM bits for the removed heap pages'); +is( $primary->safe_psql( + 'postgres', + q{SELECT pg_relation_size('t', 'vm') / current_setting('block_size')::int} + ), + '1', + 'VM fork still contains one page after truncation'); + +my $full_backup = $primary->backup_dir . '/full'; +$primary->backup('incr', + backup_options => [ '--incremental', "$full_backup/backup_manifest" ]); +$primary->stop; + +my $restored = PostgreSQL::Test::Cluster->new('restored'); +$restored->init_from_backup( + $primary, 'incr', + combine_with_prior => ['full'], + combine_mode => $mode); +$restored->start; + +# Count all VM bits, including those beyond the end of the heap, to +# detect stale bits inherited from the full backup. +is($restored->safe_psql('postgres', $heap_blocks_sql), + '2', 'restored heap has the truncated length'); +is($restored->safe_psql('postgres', $vm_summary_sql), + '2|2', 'restored VM has no stale bits for removed heap pages'); + +$restored->stop; +done_testing(); -- 2.56.0
^ permalink raw reply [nested|flat] 6+ messages in thread

* Re: BUG #19775: Incremental backup without data checksums restores a stale visibility map page after VACUUM truncati
@ 2026-11-04 14:33  shihao zhong <zhong950419@gmail.com>
  parent: Fujii Masao <masao.fujii@gmail.com>
  0 siblings, 1 reply; 6+ messages in thread

From: shihao zhong @ 2026-11-04 14:33 UTC (permalink / raw)
  To: Fujii Masao <masao.fujii@gmail.com>; +Cc: kehan5800@gmail.com; pgsql-bugs@lists.postgresql.org

Hi Fujii-san,

Thanks for v2, and for adding me as a co-author.

v2 looks good to me.

> .... but I'd like to apply
> the summarizer-side fix first

That sounds great!

Thanks,
Shihao

^ permalink  raw  reply  [nested|flat] 6+ messages in thread

* Re: BUG #19775: Incremental backup without data checksums restores a stale visibility map page after VACUUM truncati
@ 2026-11-05 09:10  Fujii Masao <masao.fujii@gmail.com>
  parent: shihao zhong <zhong950419@gmail.com>
  0 siblings, 0 replies; 6+ messages in thread

From: Fujii Masao @ 2026-11-05 09:10 UTC (permalink / raw)
  To: shihao zhong <zhong950419@gmail.com>; +Cc: kehan5800@gmail.com; pgsql-bugs@lists.postgresql.org

On Wed, Nov 4, 2026 at 11:34 PM shihao zhong <zhong950419@gmail.com> wrote:
> Thanks for v2, and for adding me as a co-author.
>
> v2 looks good to me.

I've pushed the patch. Thanks!

Regards,


-- 
Fujii Masao






^ permalink  raw  reply  [nested|flat] 6+ messages in thread


end of thread, other threads:[~2026-11-05 09:10 UTC | newest]

Thread overview: 6+ messages (download: mbox mbox.gz follow: Atom feed)
-- links below jump to the message on this page --
2026-10-20 03:40 BUG #19775: Incremental backup without data checksums restores a stale visibility map page after VACUUM truncati PG Bug reporting form <noreply@postgresql.org>
2026-10-23 02:01 ` Fujii Masao <masao.fujii@gmail.com>
2026-10-23 03:01   ` shihao zhong <zhong950419@gmail.com>
2026-11-04 13:55     ` Fujii Masao <masao.fujii@gmail.com>
2026-11-04 14:33       ` shihao zhong <zhong950419@gmail.com>
2026-11-05 09:10         ` Fujii Masao <masao.fujii@gmail.com>

This inbox is served by DDX for PostgreSQL; see mirroring instructions
for how to clone and mirror all data and code used for this inbox