Fix TwoPhaseGetDummyBackendId().

This was broken in commit ed0b409d22346b1b027a4c2099ca66984d94b6dd,
which revised the GlobalTransactionData struct to not include the
associated PGPROC as its first member, but overlooked one place where
a cast was used in reliance on that equivalence.

The most effective way of fixing this seems to be to create a new function
that looks up the GlobalTransactionData struct given the XID, and make
both TwoPhaseGetDummyBackendId and TwoPhaseGetDummyProc rely on that.

Per report from Robert Ross.

diff --git a/src/backend/access/transam/twophase.c b/src/backend/access/transam/twophase.c
index 7f198c2e3e0478c0719023673781e44372cd5a69..2a60c62dd4d7a233ee0a4422f5fac05b559e6727 100644 (file)
--- a/src/backend/access/transam/twophase.c
+++ b/src/backend/access/transam/twophase.c
@@ -108,8 +108,8 @@ int                 max_prepared_xacts = 0;
 
 typedef struct GlobalTransactionData
 {
-       GlobalTransaction next;
-       int                     pgprocno;               /* dummy proc */
+       GlobalTransaction next;         /* list link for free list */
+       int                     pgprocno;               /* ID of associated dummy PGPROC */
        BackendId       dummyBackendId; /* similar to backend id for backends */
        TimestampTz prepared_at;        /* time of preparation */
        XLogRecPtr      prepare_lsn;    /* XLOG offset of prepare record */
@@ -203,10 +203,13 @@ TwoPhaseShmemInit(void)
                                          sizeof(GlobalTransaction) * max_prepared_xacts));
                for (i = 0; i < max_prepared_xacts; i++)
                {
-                       gxacts[i].pgprocno = PreparedXactProcs[i].pgprocno;
+                       /* insert into linked list */
                        gxacts[i].next = TwoPhaseState->freeGXacts;
                        TwoPhaseState->freeGXacts = &gxacts[i];
 
+                       /* associate it with a PGPROC assigned by InitProcGlobal */
+                       gxacts[i].pgprocno = PreparedXactProcs[i].pgprocno;
+
                        /*
                         * Assign a unique ID for each dummy proc, so that the range of
                         * dummy backend IDs immediately follows the range of normal
@@ -301,7 +304,7 @@ MarkAsPreparing(TransactionId xid, const char *gid,
                                 errhint("Increase max_prepared_transactions (currently %d).",
                                                 max_prepared_xacts)));
        gxact = TwoPhaseState->freeGXacts;
-       TwoPhaseState->freeGXacts = (GlobalTransaction) gxact->next;
+       TwoPhaseState->freeGXacts = gxact->next;
 
        proc = &ProcGlobal->allProcs[gxact->pgprocno];
        pgxact = &ProcGlobal->allPgXact[gxact->pgprocno];
@@ -680,40 +683,25 @@ pg_prepared_xact(PG_FUNCTION_ARGS)
 }
 
 /*
- * TwoPhaseGetDummyProc
- *             Get the dummy backend ID for prepared transaction specified by XID
- *
- * Dummy backend IDs are similar to real backend IDs of real backends.
- * They start at MaxBackends + 1, and are unique across all currently active
- * real backends and prepared transactions.
+ * TwoPhaseGetGXact
+ *             Get the GlobalTransaction struct for a prepared transaction
+ *             specified by XID
  */
-BackendId
-TwoPhaseGetDummyBackendId(TransactionId xid)
-{
-       PGPROC     *proc = TwoPhaseGetDummyProc(xid);
-
-       return ((GlobalTransaction) proc)->dummyBackendId;
-}
-
-/*
- * TwoPhaseGetDummyProc
- *             Get the PGPROC that represents a prepared transaction specified by XID
- */
-PGPROC *
-TwoPhaseGetDummyProc(TransactionId xid)
+static GlobalTransaction
+TwoPhaseGetGXact(TransactionId xid)
 {
-       PGPROC     *result = NULL;
+       GlobalTransaction result = NULL;
        int                     i;
 
        static TransactionId cached_xid = InvalidTransactionId;
-       static PGPROC *cached_proc = NULL;
+       static GlobalTransaction cached_gxact = NULL;
 
        /*
         * During a recovery, COMMIT PREPARED, or ABORT PREPARED, we'll be called
         * repeatedly for the same XID.  We can save work with a simple cache.
         */
        if (xid == cached_xid)
-               return cached_proc;
+               return cached_gxact;
 
        LWLockAcquire(TwoPhaseStateLock, LW_SHARED);
 
@@ -724,7 +712,7 @@ TwoPhaseGetDummyProc(TransactionId xid)
 
                if (pgxact->xid == xid)
                {
-                       result = &ProcGlobal->allProcs[gxact->pgprocno];
+                       result = gxact;
                        break;
                }
        }
@@ -732,14 +720,42 @@ TwoPhaseGetDummyProc(TransactionId xid)
        LWLockRelease(TwoPhaseStateLock);
 
        if (result == NULL)                     /* should not happen */
-               elog(ERROR, "failed to find dummy PGPROC for xid %u", xid);
+               elog(ERROR, "failed to find GlobalTransaction for xid %u", xid);
 
        cached_xid = xid;
-       cached_proc = result;
+       cached_gxact = result;
 
        return result;
 }
 
+/*
+ * TwoPhaseGetDummyProc
+ *             Get the dummy backend ID for prepared transaction specified by XID
+ *
+ * Dummy backend IDs are similar to real backend IDs of real backends.
+ * They start at MaxBackends + 1, and are unique across all currently active
+ * real backends and prepared transactions.
+ */
+BackendId
+TwoPhaseGetDummyBackendId(TransactionId xid)
+{
+       GlobalTransaction gxact = TwoPhaseGetGXact(xid);
+
+       return gxact->dummyBackendId;
+}
+
+/*
+ * TwoPhaseGetDummyProc
+ *             Get the PGPROC that represents a prepared transaction specified by XID
+ */
+PGPROC *
+TwoPhaseGetDummyProc(TransactionId xid)
+{
+       GlobalTransaction gxact = TwoPhaseGetGXact(xid);
+
+       return &ProcGlobal->allProcs[gxact->pgprocno];
+}
+
 /************************************************************************/
 /* State file support                                                                                                  */
 /************************************************************************/