Fix MVCC bug with prepared xact with subxacts on standby

We did not recover the subtransaction IDs of prepared transactions
when starting a hot standby from a shutdown checkpoint. As a result,
such subtransactions were considered as aborted, rather than
in-progress. That would lead to hint bits being set incorrectly, and
the subtransactions suddenly becoming visible to old snapshots when
the prepared transaction was committed.

To fix, update pg_subtrans with prepared transactions's subxids when
starting hot standby from a shutdown checkpoint. The snapshots taken
from that state need to be marked as "suboverflowed", so that we also
check the pg_subtrans.

Backport to all supported versions.

Discussion: https://www.postgresql.org/message-id/6b852e98-2d49-4ca1-9e95-db419a2696e0@iki.fi

diff --git a/src/backend/access/transam/twophase.c b/src/backend/access/transam/twophase.c
index 71b54e0292d163cdd8e605c60d79ba04156f0355..ee1f0b7f18299067cceed3acc2f5d3ba9ae4aeb2 100644 (file)
--- a/src/backend/access/transam/twophase.c
+++ b/src/backend/access/transam/twophase.c
@@ -2048,9 +2048,8 @@ PrescanPreparedTransactions(TransactionId **xids_p, int *nxids_p)
  * This is never called at the end of recovery - we use
  * RecoverPreparedTransactions() at that point.
  *
- * The lack of calls to SubTransSetParent() calls here is by design;
- * those calls are made by RecoverPreparedTransactions() at the end of recovery
- * for those xacts that need this.
+ * This updates pg_subtrans, so that any subtransactions will be correctly
+ * seen as in-progress in snapshots taken during recovery.
  */
 void
 StandbyRecoverPreparedTransactions(void)
@@ -2070,7 +2069,7 @@ StandbyRecoverPreparedTransactions(void)
 
                buf = ProcessTwoPhaseBuffer(xid,
                                                                        gxact->prepare_start_lsn,
-                                                                       gxact->ondisk, false, false);
+                                                                       gxact->ondisk, true, false);
                if (buf != NULL)
                        pfree(buf);
        }

diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c
index 98e4cbc27dd91cc053ab0b77723af5a66f3f12dc..d36784627d93fd1c498c3cbd321050e0ea6bdfb1 100644 (file)
--- a/src/backend/access/transam/xlog.c
+++ b/src/backend/access/transam/xlog.c
@@ -7044,6 +7044,9 @@ StartupXLOG(void)
                                RunningTransactionsData running;
                                TransactionId latestCompletedXid;
 
+                               /* Update pg_subtrans entries for any prepared transactions */
+                               StandbyRecoverPreparedTransactions();
+
                                /*
                                 * Construct a RunningTransactions snapshot representing a
                                 * shut down server, with only prepared transactions still
@@ -7052,7 +7055,7 @@ StartupXLOG(void)
                                 */
                                running.xcnt = nxids;
                                running.subxcnt = 0;
-                               running.subxid_overflow = false;
+                               running.subxid_status = SUBXIDS_IN_SUBTRANS;
                                running.nextXid = XidFromFullTransactionId(checkPoint.nextFullXid);
                                running.oldestRunningXid = oldestActiveXID;
                                latestCompletedXid = XidFromFullTransactionId(checkPoint.nextFullXid);
@@ -7062,8 +7065,6 @@ StartupXLOG(void)
                                running.xids = xids;
 
                                ProcArrayApplyRecoveryInfo(&running);
-
-                               StandbyRecoverPreparedTransactions();
                        }
                }
 
@@ -9977,6 +9978,9 @@ xlog_redo(XLogReaderState *record)
 
                        oldestActiveXID = PrescanPreparedTransactions(&xids, &nxids);
 
+                       /* Update pg_subtrans entries for any prepared transactions */
+                       StandbyRecoverPreparedTransactions();
+
                        /*
                         * Construct a RunningTransactions snapshot representing a shut
                         * down server, with only prepared transactions still alive. We're
@@ -9985,7 +9989,7 @@ xlog_redo(XLogReaderState *record)
                         */
                        running.xcnt = nxids;
                        running.subxcnt = 0;
-                       running.subxid_overflow = false;
+                       running.subxid_status = SUBXIDS_IN_SUBTRANS;
                        running.nextXid = XidFromFullTransactionId(checkPoint.nextFullXid);
                        running.oldestRunningXid = oldestActiveXID;
                        latestCompletedXid = XidFromFullTransactionId(checkPoint.nextFullXid);
@@ -9995,8 +9999,6 @@ xlog_redo(XLogReaderState *record)
                        running.xids = xids;
 
                        ProcArrayApplyRecoveryInfo(&running);
-
-                       StandbyRecoverPreparedTransactions();
                }
 
                /* ControlFile->checkPointCopy always tracks the latest ckpt XID */

diff --git a/src/backend/storage/ipc/procarray.c b/src/backend/storage/ipc/procarray.c
index 1cdd3d3f3e5c6ede37d8f3adee9b5b345398d234..cf4ddcc0bd5f98346cd901f6ce167f09286ae0c1 100644 (file)
--- a/src/backend/storage/ipc/procarray.c
+++ b/src/backend/storage/ipc/procarray.c
@@ -734,7 +734,7 @@ ProcArrayApplyRecoveryInfo(RunningTransactions running)
                 * If the snapshot isn't overflowed or if its empty we can reset our
                 * pending state and use this snapshot instead.
                 */
-               if (!running->subxid_overflow || running->xcnt == 0)
+               if (running->subxid_status != SUBXIDS_MISSING || running->xcnt == 0)
                {
                        /*
                         * If we have already collected known assigned xids, we need to
@@ -888,7 +888,7 @@ ProcArrayApplyRecoveryInfo(RunningTransactions running)
         * missing, so conservatively assume the last one is latestObservedXid.
         * ----------
         */
-       if (running->subxid_overflow)
+       if (running->subxid_status == SUBXIDS_MISSING)
        {
                standbyState = STANDBY_SNAPSHOT_PENDING;
 
@@ -900,6 +900,18 @@ ProcArrayApplyRecoveryInfo(RunningTransactions running)
                standbyState = STANDBY_SNAPSHOT_READY;
 
                standbySnapshotPendingXmin = InvalidTransactionId;
+
+               /*
+                * If the 'xids' array didn't include all subtransactions, we have to
+                * mark any snapshots taken as overflowed.
+                */
+               if (running->subxid_status == SUBXIDS_IN_SUBTRANS)
+                       procArray->lastOverflowedXid = latestObservedXid;
+               else
+               {
+                       Assert(running->subxid_status == SUBXIDS_IN_ARRAY);
+                       procArray->lastOverflowedXid = InvalidTransactionId;
+               }
        }
 
        /*
@@ -2117,7 +2129,7 @@ GetRunningTransactionData(void)
 
        CurrentRunningXacts->xcnt = count - subcount;
        CurrentRunningXacts->subxcnt = subcount;
-       CurrentRunningXacts->subxid_overflow = suboverflowed;
+       CurrentRunningXacts->subxid_status = suboverflowed ? SUBXIDS_IN_SUBTRANS : SUBXIDS_IN_ARRAY;
        CurrentRunningXacts->nextXid = XidFromFullTransactionId(ShmemVariableCache->nextFullXid);
        CurrentRunningXacts->oldestRunningXid = oldestRunningXid;
        CurrentRunningXacts->latestCompletedXid = latestCompletedXid;

diff --git a/src/backend/storage/ipc/standby.c b/src/backend/storage/ipc/standby.c
index d5adc3e61a3e20544fe28efee33d29a7ad320370..b67fe9a481d4b858deb5c5e63453bdaf729984b0 100644 (file)
--- a/src/backend/storage/ipc/standby.c
+++ b/src/backend/storage/ipc/standby.c
@@ -927,7 +927,7 @@ standby_redo(XLogReaderState *record)
 
                running.xcnt = xlrec->xcnt;
                running.subxcnt = xlrec->subxcnt;
-               running.subxid_overflow = xlrec->subxid_overflow;
+               running.subxid_status = xlrec->subxid_overflow ? SUBXIDS_MISSING : SUBXIDS_IN_ARRAY;
                running.nextXid = xlrec->nextXid;
                running.latestCompletedXid = xlrec->latestCompletedXid;
                running.oldestRunningXid = xlrec->oldestRunningXid;
@@ -1083,7 +1083,7 @@ LogCurrentRunningXacts(RunningTransactions CurrRunningXacts)
 
        xlrec.xcnt = CurrRunningXacts->xcnt;
        xlrec.subxcnt = CurrRunningXacts->subxcnt;
-       xlrec.subxid_overflow = CurrRunningXacts->subxid_overflow;
+       xlrec.subxid_overflow = (CurrRunningXacts->subxid_status != SUBXIDS_IN_ARRAY);
        xlrec.nextXid = CurrRunningXacts->nextXid;
        xlrec.oldestRunningXid = CurrRunningXacts->oldestRunningXid;
        xlrec.latestCompletedXid = CurrRunningXacts->latestCompletedXid;
@@ -1100,7 +1100,7 @@ LogCurrentRunningXacts(RunningTransactions CurrRunningXacts)
 
        recptr = XLogInsert(RM_STANDBY_ID, XLOG_RUNNING_XACTS);
 
-       if (CurrRunningXacts->subxid_overflow)
+       if (xlrec.subxid_overflow)
                elog(trace_recovery(DEBUG2),
                         "snapshot of %u running transactions overflowed (lsn %X/%X oldest xid %u latest complete %u next xid %u)",
                         CurrRunningXacts->xcnt,

diff --git a/src/include/storage/standby.h b/src/include/storage/standby.h
index a3f8f82ff32fbf429751952210c73a0098d3e052..24195fefe013246a6cc63d4120b73f22713085a0 100644 (file)
--- a/src/include/storage/standby.h
+++ b/src/include/storage/standby.h
@@ -67,11 +67,19 @@ extern void StandbyReleaseOldLocks(TransactionId oldxid);
  * almost immediately see the data we need to begin executing queries.
  */
 
+typedef enum
+{
+       SUBXIDS_IN_ARRAY,                       /* xids array includes all running subxids */
+       SUBXIDS_MISSING,                        /* snapshot overflowed, subxids are missing */
+       SUBXIDS_IN_SUBTRANS,            /* subxids are not included in 'xids', but
+                                                                * pg_subtrans is fully up-to-date */
+} subxids_array_status;
+
 typedef struct RunningTransactionsData
 {
        int                     xcnt;                   /* # of xact ids in xids[] */
        int                     subxcnt;                /* # of subxact ids in xids[] */
-       bool            subxid_overflow;        /* snapshot overflowed, subxids missing */
+       subxids_array_status subxid_status;
        TransactionId nextXid;          /* xid from ShmemVariableCache->nextFullXid */
        TransactionId oldestRunningXid; /* *not* oldestXmin */
        TransactionId latestCompletedXid;       /* so we can set xmax */

diff --git a/src/test/recovery/t/009_twophase.pl b/src/test/recovery/t/009_twophase.pl
index 4a79c5ebfdb80297cdf9894d763a38fc7764d2d6..308014a98767120c4f951f4b22a13ea5169178d9 100644 (file)
--- a/src/test/recovery/t/009_twophase.pl
+++ b/src/test/recovery/t/009_twophase.pl
@@ -4,7 +4,7 @@ use warnings;
 
 use PostgresNode;
 use TestLib;
-use Test::More tests => 24;
+use Test::More tests => 27;
 
 my $psql_out = '';
 my $psql_rc  = '';
@@ -305,6 +305,52 @@ $cur_standby->start;
 
 $cur_master->psql('postgres', "COMMIT PREPARED 'xact_009_12'");
 
+###############################################################################
+# Check visibility of prepared transactions in standby after a restart while
+# primary is down.
+###############################################################################
+
+$cur_master->psql(
+       'postgres', "
+       CREATE TABLE t_009_tbl_standby_mvcc (id int, msg text);
+       BEGIN;
+       INSERT INTO t_009_tbl_standby_mvcc VALUES (1, 'issued to ${cur_master_name}');
+       SAVEPOINT s1;
+       INSERT INTO t_009_tbl_standby_mvcc VALUES (2, 'issued to ${cur_master_name}');
+       PREPARE TRANSACTION 'xact_009_standby_mvcc';
+       ");
+$cur_master->stop;
+$cur_standby->restart;
+
+# Acquire a snapshot in standby, before we commit the prepared transaction
+my $standby_session = $cur_standby->background_psql('postgres', on_error_die => 1);
+$standby_session->query_safe("BEGIN ISOLATION LEVEL REPEATABLE READ");
+$psql_out = $standby_session->query_safe(
+       "SELECT count(*) FROM t_009_tbl_standby_mvcc");
+is($psql_out, '0',
+       "Prepared transaction not visible in standby before commit");
+
+# Commit the transaction in primary
+$cur_master->start;
+$cur_master->psql('postgres', "
+SET synchronous_commit='remote_apply'; -- To ensure the standby is caught up
+COMMIT PREPARED 'xact_009_standby_mvcc';
+");
+
+# Still not visible to the old snapshot
+$psql_out = $standby_session->query_safe(
+       "SELECT count(*) FROM t_009_tbl_standby_mvcc");
+is($psql_out, '0',
+       "Committed prepared transaction not visible to old snapshot in standby");
+
+# Is visible to a new snapshot
+$standby_session->query_safe("COMMIT");
+$psql_out = $standby_session->query_safe(
+       "SELECT count(*) FROM t_009_tbl_standby_mvcc");
+is($psql_out, '2',
+   "Committed prepared transaction is visible to new snapshot in standby");
+$standby_session->quit;
+
 ###############################################################################
 # Check for a lock conflict between prepared transaction with DDL inside and
 # replay of XLOG_STANDBY_LOCK wal record.

diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
index 66c28f0ff4adedfbe1c2cae23454ef2a46e24a1f..b4abd380c7070ecd40aa9d920deab8930df0fa53 100644 (file)
--- a/src/tools/pgindent/typedefs.list
+++ b/src/tools/pgindent/typedefs.list
@@ -3263,6 +3263,7 @@ string
 substitute_actual_parameters_context
 substitute_actual_srf_parameters_context
 substitute_phv_relids_context
+subxids_array_status
 svtype
 symbol
 tablespaceinfo