Remove most volatile qualifiers from xlog.c

For the reason outlined in df4077cda2e also remove volatile qualifiers
from xlog.c. Some of these uses of volatile have been added after
noticing problems back when spinlocks didn't imply compiler
barriers. So they are a good test - in fact removing the volatiles
breaks when done without the barriers in spinlocks present.

Several uses of volatile remain where they are explicitly used to
access shared memory without locks. These locations are ok with
slightly out of date data, but removing the volatile might lead to the
variables never being reread from memory. These uses could also be
replaced by barriers, but that's a separate change of doubtful value.

diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c
index 544d76e8524d5cecd2b4cb7a9d1a85c5cbc495cd..46eef5f21bab2bb9cb59ee9f6388c9059bb5499a 100644 (file)
--- a/src/backend/access/transam/xlog.c
+++ b/src/backend/access/transam/xlog.c
@@ -1220,16 +1220,13 @@ begin:;
         */
        if (StartPos / XLOG_BLCKSZ != EndPos / XLOG_BLCKSZ)
        {
-               /* use volatile pointer to prevent code rearrangement */
-               volatile XLogCtlData *xlogctl = XLogCtl;
-
-               SpinLockAcquire(&xlogctl->info_lck);
+               SpinLockAcquire(&XLogCtl->info_lck);
                /* advance global request to include new block(s) */
-               if (xlogctl->LogwrtRqst.Write < EndPos)
-                       xlogctl->LogwrtRqst.Write = EndPos;
+               if (XLogCtl->LogwrtRqst.Write < EndPos)
+                       XLogCtl->LogwrtRqst.Write = EndPos;
                /* update local result copy while I have the chance */
-               LogwrtResult = xlogctl->LogwrtResult;
-               SpinLockRelease(&xlogctl->info_lck);
+               LogwrtResult = XLogCtl->LogwrtResult;
+               SpinLockRelease(&XLogCtl->info_lck);
        }
 
        /*
@@ -1324,7 +1321,7 @@ static void
 ReserveXLogInsertLocation(int size, XLogRecPtr *StartPos, XLogRecPtr *EndPos,
                                                  XLogRecPtr *PrevPtr)
 {
-       volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
+       XLogCtlInsert *Insert = &XLogCtl->Insert;
        uint64          startbytepos;
        uint64          endbytepos;
        uint64          prevbytepos;
@@ -1379,7 +1376,7 @@ ReserveXLogInsertLocation(int size, XLogRecPtr *StartPos, XLogRecPtr *EndPos,
 static bool
 ReserveXLogSwitch(XLogRecPtr *StartPos, XLogRecPtr *EndPos, XLogRecPtr *PrevPtr)
 {
-       volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
+       XLogCtlInsert *Insert = &XLogCtl->Insert;
        uint64          startbytepos;
        uint64          endbytepos;
        uint64          prevbytepos;
@@ -1697,7 +1694,7 @@ WaitXLogInsertionsToFinish(XLogRecPtr upto)
        uint64          bytepos;
        XLogRecPtr      reservedUpto;
        XLogRecPtr      finishedUpto;
-       volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
+       XLogCtlInsert *Insert = &XLogCtl->Insert;
        int                     i;
 
        if (MyProc == NULL)
@@ -2132,16 +2129,11 @@ AdvanceXLInsertBuffer(XLogRecPtr upto, bool opportunistic)
                                break;
 
                        /* Before waiting, get info_lck and update LogwrtResult */
-                       {
-                               /* use volatile pointer to prevent code rearrangement */
-                               volatile XLogCtlData *xlogctl = XLogCtl;
-
-                               SpinLockAcquire(&xlogctl->info_lck);
-                               if (xlogctl->LogwrtRqst.Write < OldPageRqstPtr)
-                                       xlogctl->LogwrtRqst.Write = OldPageRqstPtr;
-                               LogwrtResult = xlogctl->LogwrtResult;
-                               SpinLockRelease(&xlogctl->info_lck);
-                       }
+                       SpinLockAcquire(&XLogCtl->info_lck);
+                       if (XLogCtl->LogwrtRqst.Write < OldPageRqstPtr)
+                               XLogCtl->LogwrtRqst.Write = OldPageRqstPtr;
+                       LogwrtResult = XLogCtl->LogwrtResult;
+                       SpinLockRelease(&XLogCtl->info_lck);
 
                        /*
                         * Now that we have an up-to-date LogwrtResult value, see if we
@@ -2549,16 +2541,13 @@ XLogWrite(XLogwrtRqst WriteRqst, bool flexible)
         * code in a couple of places.
         */
        {
-               /* use volatile pointer to prevent code rearrangement */
-               volatile XLogCtlData *xlogctl = XLogCtl;
-
-               SpinLockAcquire(&xlogctl->info_lck);
-               xlogctl->LogwrtResult = LogwrtResult;
-               if (xlogctl->LogwrtRqst.Write < LogwrtResult.Write)
-                       xlogctl->LogwrtRqst.Write = LogwrtResult.Write;
-               if (xlogctl->LogwrtRqst.Flush < LogwrtResult.Flush)
-                       xlogctl->LogwrtRqst.Flush = LogwrtResult.Flush;
-               SpinLockRelease(&xlogctl->info_lck);
+               SpinLockAcquire(&XLogCtl->info_lck);
+               XLogCtl->LogwrtResult = LogwrtResult;
+               if (XLogCtl->LogwrtRqst.Write < LogwrtResult.Write)
+                       XLogCtl->LogwrtRqst.Write = LogwrtResult.Write;
+               if (XLogCtl->LogwrtRqst.Flush < LogwrtResult.Flush)
+                       XLogCtl->LogwrtRqst.Flush = LogwrtResult.Flush;
+               SpinLockRelease(&XLogCtl->info_lck);
        }
 }
 
@@ -2573,15 +2562,12 @@ XLogSetAsyncXactLSN(XLogRecPtr asyncXactLSN)
        XLogRecPtr      WriteRqstPtr = asyncXactLSN;
        bool            sleeping;
 
-       /* use volatile pointer to prevent code rearrangement */
-       volatile XLogCtlData *xlogctl = XLogCtl;
-
-       SpinLockAcquire(&xlogctl->info_lck);
-       LogwrtResult = xlogctl->LogwrtResult;
-       sleeping = xlogctl->WalWriterSleeping;
-       if (xlogctl->asyncXactLSN < asyncXactLSN)
-               xlogctl->asyncXactLSN = asyncXactLSN;
-       SpinLockRelease(&xlogctl->info_lck);
+       SpinLockAcquire(&XLogCtl->info_lck);
+       LogwrtResult = XLogCtl->LogwrtResult;
+       sleeping = XLogCtl->WalWriterSleeping;
+       if (XLogCtl->asyncXactLSN < asyncXactLSN)
+               XLogCtl->asyncXactLSN = asyncXactLSN;
+       SpinLockRelease(&XLogCtl->info_lck);
 
        /*
         * If the WALWriter is sleeping, we should kick it to make it come out of
@@ -2614,12 +2600,9 @@ XLogSetAsyncXactLSN(XLogRecPtr asyncXactLSN)
 void
 XLogSetReplicationSlotMinimumLSN(XLogRecPtr lsn)
 {
-       /* use volatile pointer to prevent code rearrangement */
-       volatile XLogCtlData *xlogctl = XLogCtl;
-
-       SpinLockAcquire(&xlogctl->info_lck);
-       xlogctl->replicationSlotMinLSN = lsn;
-       SpinLockRelease(&xlogctl->info_lck);
+       SpinLockAcquire(&XLogCtl->info_lck);
+       XLogCtl->replicationSlotMinLSN = lsn;
+       SpinLockRelease(&XLogCtl->info_lck);
 }
 
 
@@ -2630,13 +2613,11 @@ XLogSetReplicationSlotMinimumLSN(XLogRecPtr lsn)
 static XLogRecPtr
 XLogGetReplicationSlotMinimumLSN(void)
 {
-       /* use volatile pointer to prevent code rearrangement */
-       volatile XLogCtlData *xlogctl = XLogCtl;
        XLogRecPtr      retval;
 
-       SpinLockAcquire(&xlogctl->info_lck);
-       retval = xlogctl->replicationSlotMinLSN;
-       SpinLockRelease(&xlogctl->info_lck);
+       SpinLockAcquire(&XLogCtl->info_lck);
+       retval = XLogCtl->replicationSlotMinLSN;
+       SpinLockRelease(&XLogCtl->info_lck);
 
        return retval;
 }
@@ -2672,8 +2653,6 @@ UpdateMinRecoveryPoint(XLogRecPtr lsn, bool force)
                updateMinRecoveryPoint = false;
        else if (force || minRecoveryPoint < lsn)
        {
-               /* use volatile pointer to prevent code rearrangement */
-               volatile XLogCtlData *xlogctl = XLogCtl;
                XLogRecPtr      newMinRecoveryPoint;
                TimeLineID      newMinRecoveryPointTLI;
 
@@ -2690,10 +2669,10 @@ UpdateMinRecoveryPoint(XLogRecPtr lsn, bool force)
                 * all.  Instead, we just log a warning and continue with recovery.
                 * (See also the comments about corrupt LSNs in XLogFlush.)
                 */
-               SpinLockAcquire(&xlogctl->info_lck);
-               newMinRecoveryPoint = xlogctl->replayEndRecPtr;
-               newMinRecoveryPointTLI = xlogctl->replayEndTLI;
-               SpinLockRelease(&xlogctl->info_lck);
+               SpinLockAcquire(&XLogCtl->info_lck);
+               newMinRecoveryPoint = XLogCtl->replayEndRecPtr;
+               newMinRecoveryPointTLI = XLogCtl->replayEndTLI;
+               SpinLockRelease(&XLogCtl->info_lck);
 
                if (!force && newMinRecoveryPoint < lsn)
                        elog(WARNING,
@@ -2777,16 +2756,14 @@ XLogFlush(XLogRecPtr record)
         */
        for (;;)
        {
-               /* use volatile pointer to prevent code rearrangement */
-               volatile XLogCtlData *xlogctl = XLogCtl;
                XLogRecPtr      insertpos;
 
                /* read LogwrtResult and update local state */
-               SpinLockAcquire(&xlogctl->info_lck);
-               if (WriteRqstPtr < xlogctl->LogwrtRqst.Write)
-                       WriteRqstPtr = xlogctl->LogwrtRqst.Write;
-               LogwrtResult = xlogctl->LogwrtResult;
-               SpinLockRelease(&xlogctl->info_lck);
+               SpinLockAcquire(&XLogCtl->info_lck);
+               if (WriteRqstPtr < XLogCtl->LogwrtRqst.Write)
+                       WriteRqstPtr = XLogCtl->LogwrtRqst.Write;
+               LogwrtResult = XLogCtl->LogwrtResult;
+               SpinLockRelease(&XLogCtl->info_lck);
 
                /* done already? */
                if (record <= LogwrtResult.Flush)
@@ -2923,15 +2900,10 @@ XLogBackgroundFlush(void)
                return false;
 
        /* read LogwrtResult and update local state */
-       {
-               /* use volatile pointer to prevent code rearrangement */
-               volatile XLogCtlData *xlogctl = XLogCtl;
-
-               SpinLockAcquire(&xlogctl->info_lck);
-               LogwrtResult = xlogctl->LogwrtResult;
-               WriteRqstPtr = xlogctl->LogwrtRqst.Write;
-               SpinLockRelease(&xlogctl->info_lck);
-       }
+       SpinLockAcquire(&XLogCtl->info_lck);
+       LogwrtResult = XLogCtl->LogwrtResult;
+       WriteRqstPtr = XLogCtl->LogwrtRqst.Write;
+       SpinLockRelease(&XLogCtl->info_lck);
 
        /* back off to last completed page boundary */
        WriteRqstPtr -= WriteRqstPtr % XLOG_BLCKSZ;
@@ -2939,12 +2911,9 @@ XLogBackgroundFlush(void)
        /* if we have already flushed that far, consider async commit records */
        if (WriteRqstPtr <= LogwrtResult.Flush)
        {
-               /* use volatile pointer to prevent code rearrangement */
-               volatile XLogCtlData *xlogctl = XLogCtl;
-
-               SpinLockAcquire(&xlogctl->info_lck);
-               WriteRqstPtr = xlogctl->asyncXactLSN;
-               SpinLockRelease(&xlogctl->info_lck);
+               SpinLockAcquire(&XLogCtl->info_lck);
+               WriteRqstPtr = XLogCtl->asyncXactLSN;
+               SpinLockRelease(&XLogCtl->info_lck);
                flexible = false;               /* ensure it all gets written */
        }
 
@@ -3055,14 +3024,9 @@ XLogNeedsFlush(XLogRecPtr record)
                return false;
 
        /* read LogwrtResult and update local state */
-       {
-               /* use volatile pointer to prevent code rearrangement */
-               volatile XLogCtlData *xlogctl = XLogCtl;
-
-               SpinLockAcquire(&xlogctl->info_lck);
-               LogwrtResult = xlogctl->LogwrtResult;
-               SpinLockRelease(&xlogctl->info_lck);
-       }
+       SpinLockAcquire(&XLogCtl->info_lck);
+       LogwrtResult = XLogCtl->LogwrtResult;
+       SpinLockRelease(&XLogCtl->info_lck);
 
        /* check again */
        if (record <= LogwrtResult.Flush)
@@ -3684,13 +3648,11 @@ PreallocXlogFiles(XLogRecPtr endptr)
 void
 CheckXLogRemoved(XLogSegNo segno, TimeLineID tli)
 {
-       /* use volatile pointer to prevent code rearrangement */
-       volatile XLogCtlData *xlogctl = XLogCtl;
        XLogSegNo       lastRemovedSegNo;
 
-       SpinLockAcquire(&xlogctl->info_lck);
-       lastRemovedSegNo = xlogctl->lastRemovedSegNo;
-       SpinLockRelease(&xlogctl->info_lck);
+       SpinLockAcquire(&XLogCtl->info_lck);
+       lastRemovedSegNo = XLogCtl->lastRemovedSegNo;
+       SpinLockRelease(&XLogCtl->info_lck);
 
        if (segno <= lastRemovedSegNo)
        {
@@ -3714,13 +3676,11 @@ CheckXLogRemoved(XLogSegNo segno, TimeLineID tli)
 XLogSegNo
 XLogGetLastRemovedSegno(void)
 {
-       /* use volatile pointer to prevent code rearrangement */
-       volatile XLogCtlData *xlogctl = XLogCtl;
        XLogSegNo       lastRemovedSegNo;
 
-       SpinLockAcquire(&xlogctl->info_lck);
-       lastRemovedSegNo = xlogctl->lastRemovedSegNo;
-       SpinLockRelease(&xlogctl->info_lck);
+       SpinLockAcquire(&XLogCtl->info_lck);
+       lastRemovedSegNo = XLogCtl->lastRemovedSegNo;
+       SpinLockRelease(&XLogCtl->info_lck);
 
        return lastRemovedSegNo;
 }
@@ -3732,17 +3692,15 @@ XLogGetLastRemovedSegno(void)
 static void
 UpdateLastRemovedPtr(char *filename)
 {
-       /* use volatile pointer to prevent code rearrangement */
-       volatile XLogCtlData *xlogctl = XLogCtl;
        uint32          tli;
        XLogSegNo       segno;
 
        XLogFromFileName(filename, &tli, &segno);
 
-       SpinLockAcquire(&xlogctl->info_lck);
-       if (segno > xlogctl->lastRemovedSegNo)
-               xlogctl->lastRemovedSegNo = segno;
-       SpinLockRelease(&xlogctl->info_lck);
+       SpinLockAcquire(&XLogCtl->info_lck);
+       if (segno > XLogCtl->lastRemovedSegNo)
+               XLogCtl->lastRemovedSegNo = segno;
+       SpinLockRelease(&XLogCtl->info_lck);
 }
 
 /*
@@ -4700,13 +4658,10 @@ GetFakeLSNForUnloggedRel(void)
 {
        XLogRecPtr      nextUnloggedLSN;
 
-       /* use volatile pointer to prevent code rearrangement */
-       volatile XLogCtlData *xlogctl = XLogCtl;
-
        /* increment the unloggedLSN counter, need SpinLock */
-       SpinLockAcquire(&xlogctl->ulsn_lck);
-       nextUnloggedLSN = xlogctl->unloggedLSN++;
-       SpinLockRelease(&xlogctl->ulsn_lck);
+       SpinLockAcquire(&XLogCtl->ulsn_lck);
+       nextUnloggedLSN = XLogCtl->unloggedLSN++;
+       SpinLockRelease(&XLogCtl->ulsn_lck);
 
        return nextUnloggedLSN;
 }
@@ -5738,13 +5693,11 @@ recoveryPausesHere(void)
 bool
 RecoveryIsPaused(void)
 {
-       /* use volatile pointer to prevent code rearrangement */
-       volatile XLogCtlData *xlogctl = XLogCtl;
        bool            recoveryPause;
 
-       SpinLockAcquire(&xlogctl->info_lck);
-       recoveryPause = xlogctl->recoveryPause;
-       SpinLockRelease(&xlogctl->info_lck);
+       SpinLockAcquire(&XLogCtl->info_lck);
+       recoveryPause = XLogCtl->recoveryPause;
+       SpinLockRelease(&XLogCtl->info_lck);
 
        return recoveryPause;
 }
@@ -5752,12 +5705,9 @@ RecoveryIsPaused(void)
 void
 SetRecoveryPause(bool recoveryPause)
 {
-       /* use volatile pointer to prevent code rearrangement */
-       volatile XLogCtlData *xlogctl = XLogCtl;
-
-       SpinLockAcquire(&xlogctl->info_lck);
-       xlogctl->recoveryPause = recoveryPause;
-       SpinLockRelease(&xlogctl->info_lck);
+       SpinLockAcquire(&XLogCtl->info_lck);
+       XLogCtl->recoveryPause = recoveryPause;
+       SpinLockRelease(&XLogCtl->info_lck);
 }
 
 /*
@@ -5855,12 +5805,9 @@ recoveryApplyDelay(XLogRecord *record)
 static void
 SetLatestXTime(TimestampTz xtime)
 {
-       /* use volatile pointer to prevent code rearrangement */
-       volatile XLogCtlData *xlogctl = XLogCtl;
-
-       SpinLockAcquire(&xlogctl->info_lck);
-       xlogctl->recoveryLastXTime = xtime;
-       SpinLockRelease(&xlogctl->info_lck);
+       SpinLockAcquire(&XLogCtl->info_lck);
+       XLogCtl->recoveryLastXTime = xtime;
+       SpinLockRelease(&XLogCtl->info_lck);
 }
 
 /*
@@ -5869,13 +5816,11 @@ SetLatestXTime(TimestampTz xtime)
 TimestampTz
 GetLatestXTime(void)
 {
-       /* use volatile pointer to prevent code rearrangement */
-       volatile XLogCtlData *xlogctl = XLogCtl;
        TimestampTz xtime;
 
-       SpinLockAcquire(&xlogctl->info_lck);
-       xtime = xlogctl->recoveryLastXTime;
-       SpinLockRelease(&xlogctl->info_lck);
+       SpinLockAcquire(&XLogCtl->info_lck);
+       xtime = XLogCtl->recoveryLastXTime;
+       SpinLockRelease(&XLogCtl->info_lck);
 
        return xtime;
 }
@@ -5889,12 +5834,9 @@ GetLatestXTime(void)
 static void
 SetCurrentChunkStartTime(TimestampTz xtime)
 {
-       /* use volatile pointer to prevent code rearrangement */
-       volatile XLogCtlData *xlogctl = XLogCtl;
-
-       SpinLockAcquire(&xlogctl->info_lck);
-       xlogctl->currentChunkStartTime = xtime;
-       SpinLockRelease(&xlogctl->info_lck);
+       SpinLockAcquire(&XLogCtl->info_lck);
+       XLogCtl->currentChunkStartTime = xtime;
+       SpinLockRelease(&XLogCtl->info_lck);
 }
 
 /*
@@ -5904,13 +5846,11 @@ SetCurrentChunkStartTime(TimestampTz xtime)
 TimestampTz
 GetCurrentChunkReplayStartTime(void)
 {
-       /* use volatile pointer to prevent code rearrangement */
-       volatile XLogCtlData *xlogctl = XLogCtl;
        TimestampTz xtime;
 
-       SpinLockAcquire(&xlogctl->info_lck);
-       xtime = xlogctl->currentChunkStartTime;
-       SpinLockRelease(&xlogctl->info_lck);
+       SpinLockAcquire(&XLogCtl->info_lck);
+       xtime = XLogCtl->currentChunkStartTime;
+       SpinLockRelease(&XLogCtl->info_lck);
 
        return xtime;
 }
@@ -6434,9 +6374,6 @@ StartupXLOG(void)
        {
                int                     rmid;
 
-               /* use volatile pointer to prevent code rearrangement */
-               volatile XLogCtlData *xlogctl = XLogCtl;
-
                /*
                 * Update pg_control to show that we are recovering and to show the
                 * selected checkpoint as the place we are starting from. We also mark
@@ -6623,18 +6560,18 @@ StartupXLOG(void)
                 * if we had just replayed the record before the REDO location (or the
                 * checkpoint record itself, if it's a shutdown checkpoint).
                 */
-               SpinLockAcquire(&xlogctl->info_lck);
+               SpinLockAcquire(&XLogCtl->info_lck);
                if (checkPoint.redo < RecPtr)
-                       xlogctl->replayEndRecPtr = checkPoint.redo;
+                       XLogCtl->replayEndRecPtr = checkPoint.redo;
                else
-                       xlogctl->replayEndRecPtr = EndRecPtr;
-               xlogctl->replayEndTLI = ThisTimeLineID;
-               xlogctl->lastReplayedEndRecPtr = xlogctl->replayEndRecPtr;
-               xlogctl->lastReplayedTLI = xlogctl->replayEndTLI;
-               xlogctl->recoveryLastXTime = 0;
-               xlogctl->currentChunkStartTime = 0;
-               xlogctl->recoveryPause = false;
-               SpinLockRelease(&xlogctl->info_lck);
+                       XLogCtl->replayEndRecPtr = EndRecPtr;
+               XLogCtl->replayEndTLI = ThisTimeLineID;
+               XLogCtl->lastReplayedEndRecPtr = XLogCtl->replayEndRecPtr;
+               XLogCtl->lastReplayedTLI = XLogCtl->replayEndTLI;
+               XLogCtl->recoveryLastXTime = 0;
+               XLogCtl->currentChunkStartTime = 0;
+               XLogCtl->recoveryPause = false;
+               SpinLockRelease(&XLogCtl->info_lck);
 
                /* Also ensure XLogReceiptTime has a sane value */
                XLogReceiptTime = GetCurrentTimestamp();
@@ -6733,7 +6670,7 @@ StartupXLOG(void)
                                 * otherwise would is a minor issue, so it doesn't seem worth
                                 * adding another spinlock cycle to prevent that.
                                 */
-                               if (xlogctl->recoveryPause)
+                               if (((volatile XLogCtlData *) XLogCtl)->recoveryPause)
                                        recoveryPausesHere();
 
                                /*
@@ -6758,7 +6695,7 @@ StartupXLOG(void)
                                         * here otherwise pausing during the delay-wait wouldn't
                                         * work.
                                         */
-                                       if (xlogctl->recoveryPause)
+                                       if (((volatile XLogCtlData *) XLogCtl)->recoveryPause)
                                                recoveryPausesHere();
                                }
 
@@ -6831,10 +6768,10 @@ StartupXLOG(void)
                                 * Update shared replayEndRecPtr before replaying this record,
                                 * so that XLogFlush will update minRecoveryPoint correctly.
                                 */
-                               SpinLockAcquire(&xlogctl->info_lck);
-                               xlogctl->replayEndRecPtr = EndRecPtr;
-                               xlogctl->replayEndTLI = ThisTimeLineID;
-                               SpinLockRelease(&xlogctl->info_lck);
+                               SpinLockAcquire(&XLogCtl->info_lck);
+                               XLogCtl->replayEndRecPtr = EndRecPtr;
+                               XLogCtl->replayEndTLI = ThisTimeLineID;
+                               SpinLockRelease(&XLogCtl->info_lck);
 
                                /*
                                 * If we are attempting to enter Hot Standby mode, process
@@ -6854,10 +6791,10 @@ StartupXLOG(void)
                                 * Update lastReplayedEndRecPtr after this record has been
                                 * successfully replayed.
                                 */
-                               SpinLockAcquire(&xlogctl->info_lck);
-                               xlogctl->lastReplayedEndRecPtr = EndRecPtr;
-                               xlogctl->lastReplayedTLI = ThisTimeLineID;
-                               SpinLockRelease(&xlogctl->info_lck);
+                               SpinLockAcquire(&XLogCtl->info_lck);
+                               XLogCtl->lastReplayedEndRecPtr = EndRecPtr;
+                               XLogCtl->lastReplayedTLI = ThisTimeLineID;
+                               SpinLockRelease(&XLogCtl->info_lck);
 
                                /* Remember this record as the last-applied one */
                                LastRec = ReadRecPtr;
@@ -7267,14 +7204,9 @@ StartupXLOG(void)
         * there are no race conditions concerning visibility of other recent
         * updates to shared memory.)
         */
-       {
-               /* use volatile pointer to prevent code rearrangement */
-               volatile XLogCtlData *xlogctl = XLogCtl;
-
-               SpinLockAcquire(&xlogctl->info_lck);
-               xlogctl->SharedRecoveryInProgress = false;
-               SpinLockRelease(&xlogctl->info_lck);
-       }
+       SpinLockAcquire(&XLogCtl->info_lck);
+       XLogCtl->SharedRecoveryInProgress = false;
+       SpinLockRelease(&XLogCtl->info_lck);
 
        /*
         * If there were cascading standby servers connected to us, nudge any wal
@@ -7377,12 +7309,9 @@ CheckRecoveryConsistency(void)
                reachedConsistency &&
                IsUnderPostmaster)
        {
-               /* use volatile pointer to prevent code rearrangement */
-               volatile XLogCtlData *xlogctl = XLogCtl;
-
-               SpinLockAcquire(&xlogctl->info_lck);
-               xlogctl->SharedHotStandbyActive = true;
-               SpinLockRelease(&xlogctl->info_lck);
+               SpinLockAcquire(&XLogCtl->info_lck);
+               XLogCtl->SharedHotStandbyActive = true;
+               SpinLockRelease(&XLogCtl->info_lck);
 
                LocalHotStandbyActive = true;
 
@@ -7467,13 +7396,10 @@ HotStandbyActive(void)
                return true;
        else
        {
-               /* use volatile pointer to prevent code rearrangement */
-               volatile XLogCtlData *xlogctl = XLogCtl;
-
                /* spinlock is essential on machines with weak memory ordering! */
-               SpinLockAcquire(&xlogctl->info_lck);
-               LocalHotStandbyActive = xlogctl->SharedHotStandbyActive;
-               SpinLockRelease(&xlogctl->info_lck);
+               SpinLockAcquire(&XLogCtl->info_lck);
+               LocalHotStandbyActive = XLogCtl->SharedHotStandbyActive;
+               SpinLockRelease(&XLogCtl->info_lck);
 
                return LocalHotStandbyActive;
        }
@@ -7688,8 +7614,6 @@ InitXLOGAccess(void)
 XLogRecPtr
 GetRedoRecPtr(void)
 {
-       /* use volatile pointer to prevent code rearrangement */
-       volatile XLogCtlData *xlogctl = XLogCtl;
        XLogRecPtr      ptr;
 
        /*
@@ -7697,9 +7621,9 @@ GetRedoRecPtr(void)
         * grabbed a WAL insertion lock to read the master copy, someone might
         * update it just after we've released the lock.
         */
-       SpinLockAcquire(&xlogctl->info_lck);
-       ptr = xlogctl->RedoRecPtr;
-       SpinLockRelease(&xlogctl->info_lck);
+       SpinLockAcquire(&XLogCtl->info_lck);
+       ptr = XLogCtl->RedoRecPtr;
+       SpinLockRelease(&XLogCtl->info_lck);
 
        if (RedoRecPtr < ptr)
                RedoRecPtr = ptr;
@@ -7718,13 +7642,11 @@ GetRedoRecPtr(void)
 XLogRecPtr
 GetInsertRecPtr(void)
 {
-       /* use volatile pointer to prevent code rearrangement */
-       volatile XLogCtlData *xlogctl = XLogCtl;
        XLogRecPtr      recptr;
 
-       SpinLockAcquire(&xlogctl->info_lck);
-       recptr = xlogctl->LogwrtRqst.Write;
-       SpinLockRelease(&xlogctl->info_lck);
+       SpinLockAcquire(&XLogCtl->info_lck);
+       recptr = XLogCtl->LogwrtRqst.Write;
+       SpinLockRelease(&XLogCtl->info_lck);
 
        return recptr;
 }
@@ -7736,13 +7658,11 @@ GetInsertRecPtr(void)
 XLogRecPtr
 GetFlushRecPtr(void)
 {
-       /* use volatile pointer to prevent code rearrangement */
-       volatile XLogCtlData *xlogctl = XLogCtl;
        XLogRecPtr      recptr;
 
-       SpinLockAcquire(&xlogctl->info_lck);
-       recptr = xlogctl->LogwrtResult.Flush;
-       SpinLockRelease(&xlogctl->info_lck);
+       SpinLockAcquire(&XLogCtl->info_lck);
+       recptr = XLogCtl->LogwrtResult.Flush;
+       SpinLockRelease(&XLogCtl->info_lck);
 
        return recptr;
 }
@@ -7779,15 +7699,10 @@ GetNextXidAndEpoch(TransactionId *xid, uint32 *epoch)
        TransactionId nextXid;
 
        /* Must read checkpoint info first, else have race condition */
-       {
-               /* use volatile pointer to prevent code rearrangement */
-               volatile XLogCtlData *xlogctl = XLogCtl;
-
-               SpinLockAcquire(&xlogctl->info_lck);
-               ckptXidEpoch = xlogctl->ckptXidEpoch;
-               ckptXid = xlogctl->ckptXid;
-               SpinLockRelease(&xlogctl->info_lck);
-       }
+       SpinLockAcquire(&XLogCtl->info_lck);
+       ckptXidEpoch = XLogCtl->ckptXidEpoch;
+       ckptXid = XLogCtl->ckptXid;
+       SpinLockRelease(&XLogCtl->info_lck);
 
        /* Now fetch current nextXid */
        nextXid = ReadNewTransactionId();
@@ -7990,8 +7905,6 @@ LogCheckpointEnd(bool restartpoint)
 void
 CreateCheckPoint(int flags)
 {
-       /* use volatile pointer to prevent code rearrangement */
-       volatile XLogCtlData *xlogctl = XLogCtl;
        bool            shutdown;
        CheckPoint      checkPoint;
        XLogRecPtr      recptr;
@@ -8151,7 +8064,7 @@ CreateCheckPoint(int flags)
         * XLogInserts that happen while we are dumping buffers must assume that
         * their buffer changes are not included in the checkpoint.
         */
-       RedoRecPtr = xlogctl->Insert.RedoRecPtr = checkPoint.redo;
+       RedoRecPtr = XLogCtl->Insert.RedoRecPtr = checkPoint.redo;
 
        /*
         * Now we can release the WAL insertion locks, allowing other xacts to
@@ -8160,9 +8073,9 @@ CreateCheckPoint(int flags)
        WALInsertLockRelease();
 
        /* Update the info_lck-protected copy of RedoRecPtr as well */
-       SpinLockAcquire(&xlogctl->info_lck);
-       xlogctl->RedoRecPtr = checkPoint.redo;
-       SpinLockRelease(&xlogctl->info_lck);
+       SpinLockAcquire(&XLogCtl->info_lck);
+       XLogCtl->RedoRecPtr = checkPoint.redo;
+       SpinLockRelease(&XLogCtl->info_lck);
 
        /*
         * If enabled, log checkpoint start.  We postpone this until now so as not
@@ -8334,15 +8247,10 @@ CreateCheckPoint(int flags)
        LWLockRelease(ControlFileLock);
 
        /* Update shared-memory copy of checkpoint XID/epoch */
-       {
-               /* use volatile pointer to prevent code rearrangement */
-               volatile XLogCtlData *xlogctl = XLogCtl;
-
-               SpinLockAcquire(&xlogctl->info_lck);
-               xlogctl->ckptXidEpoch = checkPoint.nextXidEpoch;
-               xlogctl->ckptXid = checkPoint.nextXid;
-               SpinLockRelease(&xlogctl->info_lck);
-       }
+       SpinLockAcquire(&XLogCtl->info_lck);
+       XLogCtl->ckptXidEpoch = checkPoint.nextXidEpoch;
+       XLogCtl->ckptXid = checkPoint.nextXid;
+       SpinLockRelease(&XLogCtl->info_lck);
 
        /*
         * We are now done with critical updates; no need for system panic if we
@@ -8497,9 +8405,6 @@ CheckPointGuts(XLogRecPtr checkPointRedo, int flags)
 static void
 RecoveryRestartPoint(const CheckPoint *checkPoint)
 {
-       /* use volatile pointer to prevent code rearrangement */
-       volatile XLogCtlData *xlogctl = XLogCtl;
-
        /*
         * Also refrain from creating a restartpoint if we have seen any
         * references to non-existent pages. Restarting recovery from the
@@ -8521,10 +8426,10 @@ RecoveryRestartPoint(const CheckPoint *checkPoint)
         * Copy the checkpoint record to shared memory, so that checkpointer can
         * work out the next time it wants to perform a restartpoint.
         */
-       SpinLockAcquire(&xlogctl->info_lck);
-       xlogctl->lastCheckPointRecPtr = ReadRecPtr;
-       xlogctl->lastCheckPoint = *checkPoint;
-       SpinLockRelease(&xlogctl->info_lck);
+       SpinLockAcquire(&XLogCtl->info_lck);
+       XLogCtl->lastCheckPointRecPtr = ReadRecPtr;
+       XLogCtl->lastCheckPoint = *checkPoint;
+       SpinLockRelease(&XLogCtl->info_lck);
 }
 
 /*
@@ -8546,9 +8451,6 @@ CreateRestartPoint(int flags)
        XLogSegNo       _logSegNo;
        TimestampTz xtime;
 
-       /* use volatile pointer to prevent code rearrangement */
-       volatile XLogCtlData *xlogctl = XLogCtl;
-
        /*
         * Acquire CheckpointLock to ensure only one restartpoint or checkpoint
         * happens at a time.
@@ -8556,10 +8458,10 @@ CreateRestartPoint(int flags)
        LWLockAcquire(CheckpointLock, LW_EXCLUSIVE);
 
        /* Get a local copy of the last safe checkpoint record. */
-       SpinLockAcquire(&xlogctl->info_lck);
-       lastCheckPointRecPtr = xlogctl->lastCheckPointRecPtr;
-       lastCheckPoint = xlogctl->lastCheckPoint;
-       SpinLockRelease(&xlogctl->info_lck);
+       SpinLockAcquire(&XLogCtl->info_lck);
+       lastCheckPointRecPtr = XLogCtl->lastCheckPointRecPtr;
+       lastCheckPoint = XLogCtl->lastCheckPoint;
+       SpinLockRelease(&XLogCtl->info_lck);
 
        /*
         * Check that we're still in recovery mode. It's ok if we exit recovery
@@ -8618,13 +8520,13 @@ CreateRestartPoint(int flags)
         * happening.
         */
        WALInsertLockAcquireExclusive();
-       xlogctl->Insert.RedoRecPtr = lastCheckPoint.redo;
+       XLogCtl->Insert.RedoRecPtr = lastCheckPoint.redo;
        WALInsertLockRelease();
 
        /* Also update the info_lck-protected copy */
-       SpinLockAcquire(&xlogctl->info_lck);
-       xlogctl->RedoRecPtr = lastCheckPoint.redo;
-       SpinLockRelease(&xlogctl->info_lck);
+       SpinLockAcquire(&XLogCtl->info_lck);
+       XLogCtl->RedoRecPtr = lastCheckPoint.redo;
+       SpinLockRelease(&XLogCtl->info_lck);
 
        /*
         * Prepare to accumulate statistics.
@@ -9384,15 +9286,10 @@ xlog_redo(XLogRecPtr lsn, XLogRecord *record)
                ControlFile->checkPointCopy.nextXid = checkPoint.nextXid;
 
                /* Update shared-memory copy of checkpoint XID/epoch */
-               {
-                       /* use volatile pointer to prevent code rearrangement */
-                       volatile XLogCtlData *xlogctl = XLogCtl;
-
-                       SpinLockAcquire(&xlogctl->info_lck);
-                       xlogctl->ckptXidEpoch = checkPoint.nextXidEpoch;
-                       xlogctl->ckptXid = checkPoint.nextXid;
-                       SpinLockRelease(&xlogctl->info_lck);
-               }
+               SpinLockAcquire(&XLogCtl->info_lck);
+               XLogCtl->ckptXidEpoch = checkPoint.nextXidEpoch;
+               XLogCtl->ckptXid = checkPoint.nextXid;
+               SpinLockRelease(&XLogCtl->info_lck);
 
                /*
                 * We should've already switched to the new TLI before replaying this
@@ -9436,15 +9333,10 @@ xlog_redo(XLogRecPtr lsn, XLogRecord *record)
                ControlFile->checkPointCopy.nextXid = checkPoint.nextXid;
 
                /* Update shared-memory copy of checkpoint XID/epoch */
-               {
-                       /* use volatile pointer to prevent code rearrangement */
-                       volatile XLogCtlData *xlogctl = XLogCtl;
-
-                       SpinLockAcquire(&xlogctl->info_lck);
-                       xlogctl->ckptXidEpoch = checkPoint.nextXidEpoch;
-                       xlogctl->ckptXid = checkPoint.nextXid;
-                       SpinLockRelease(&xlogctl->info_lck);
-               }
+               SpinLockAcquire(&XLogCtl->info_lck);
+               XLogCtl->ckptXidEpoch = checkPoint.nextXidEpoch;
+               XLogCtl->ckptXid = checkPoint.nextXid;
+               SpinLockRelease(&XLogCtl->info_lck);
 
                /* TLI should not change in an on-line checkpoint */
                if (checkPoint.ThisTimeLineID != ThisTimeLineID)
@@ -9581,8 +9473,6 @@ xlog_redo(XLogRecPtr lsn, XLogRecord *record)
        }
        else if (info == XLOG_FPW_CHANGE)
        {
-               /* use volatile pointer to prevent code rearrangement */
-               volatile XLogCtlData *xlogctl = XLogCtl;
                bool            fpw;
 
                memcpy(&fpw, XLogRecGetData(record), sizeof(bool));
@@ -9594,10 +9484,10 @@ xlog_redo(XLogRecPtr lsn, XLogRecord *record)
                 */
                if (!fpw)
                {
-                       SpinLockAcquire(&xlogctl->info_lck);
-                       if (xlogctl->lastFpwDisableRecPtr < ReadRecPtr)
-                               xlogctl->lastFpwDisableRecPtr = ReadRecPtr;
-                       SpinLockRelease(&xlogctl->info_lck);
+                       SpinLockAcquire(&XLogCtl->info_lck);
+                       if (XLogCtl->lastFpwDisableRecPtr < ReadRecPtr)
+                               XLogCtl->lastFpwDisableRecPtr = ReadRecPtr;
+                       SpinLockRelease(&XLogCtl->info_lck);
                }
 
                /* Keep track of full_page_writes */
@@ -9972,8 +9862,6 @@ do_pg_start_backup(const char *backupidstr, bool fast, TimeLineID *starttli_p,
 
                        if (backup_started_in_recovery)
                        {
-                               /* use volatile pointer to prevent code rearrangement */
-                               volatile XLogCtlData *xlogctl = XLogCtl;
                                XLogRecPtr      recptr;
 
                                /*
@@ -9981,9 +9869,9 @@ do_pg_start_backup(const char *backupidstr, bool fast, TimeLineID *starttli_p,
                                 * (i.e., since last restartpoint used as backup starting
                                 * checkpoint) contain full-page writes.
                                 */
-                               SpinLockAcquire(&xlogctl->info_lck);
-                               recptr = xlogctl->lastFpwDisableRecPtr;
-                               SpinLockRelease(&xlogctl->info_lck);
+                               SpinLockAcquire(&XLogCtl->info_lck);
+                               recptr = XLogCtl->lastFpwDisableRecPtr;
+                               SpinLockRelease(&XLogCtl->info_lck);
 
                                if (!checkpointfpw || startpoint <= recptr)
                                        ereport(ERROR,
@@ -10326,17 +10214,15 @@ do_pg_stop_backup(char *labelfile, bool waitforarchive, TimeLineID *stoptli_p)
         */
        if (backup_started_in_recovery)
        {
-               /* use volatile pointer to prevent code rearrangement */
-               volatile XLogCtlData *xlogctl = XLogCtl;
                XLogRecPtr      recptr;
 
                /*
                 * Check to see if all WAL replayed during online backup contain
                 * full-page writes.
                 */
-               SpinLockAcquire(&xlogctl->info_lck);
-               recptr = xlogctl->lastFpwDisableRecPtr;
-               SpinLockRelease(&xlogctl->info_lck);
+               SpinLockAcquire(&XLogCtl->info_lck);
+               recptr = XLogCtl->lastFpwDisableRecPtr;
+               SpinLockRelease(&XLogCtl->info_lck);
 
                if (startpoint <= recptr)
                        ereport(ERROR,
@@ -10523,15 +10409,13 @@ do_pg_abort_backup(void)
 XLogRecPtr
 GetXLogReplayRecPtr(TimeLineID *replayTLI)
 {
-       /* use volatile pointer to prevent code rearrangement */
-       volatile XLogCtlData *xlogctl = XLogCtl;
        XLogRecPtr      recptr;
        TimeLineID      tli;
 
-       SpinLockAcquire(&xlogctl->info_lck);
-       recptr = xlogctl->lastReplayedEndRecPtr;
-       tli = xlogctl->lastReplayedTLI;
-       SpinLockRelease(&xlogctl->info_lck);
+       SpinLockAcquire(&XLogCtl->info_lck);
+       recptr = XLogCtl->lastReplayedEndRecPtr;
+       tli = XLogCtl->lastReplayedTLI;
+       SpinLockRelease(&XLogCtl->info_lck);
 
        if (replayTLI)
                *replayTLI = tli;
@@ -10544,7 +10428,7 @@ GetXLogReplayRecPtr(TimeLineID *replayTLI)
 XLogRecPtr
 GetXLogInsertRecPtr(void)
 {
-       volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
+       XLogCtlInsert *Insert = &XLogCtl->Insert;
        uint64          current_bytepos;
 
        SpinLockAcquire(&Insert->insertpos_lck);
@@ -10560,14 +10444,9 @@ GetXLogInsertRecPtr(void)
 XLogRecPtr
 GetXLogWriteRecPtr(void)
 {
-       {
-               /* use volatile pointer to prevent code rearrangement */
-               volatile XLogCtlData *xlogctl = XLogCtl;
-
-               SpinLockAcquire(&xlogctl->info_lck);
-               LogwrtResult = xlogctl->LogwrtResult;
-               SpinLockRelease(&xlogctl->info_lck);
-       }
+       SpinLockAcquire(&XLogCtl->info_lck);
+       LogwrtResult = XLogCtl->LogwrtResult;
+       SpinLockRelease(&XLogCtl->info_lck);
 
        return LogwrtResult.Write;
 }
@@ -11393,10 +11272,7 @@ WakeupRecovery(void)
 void
 SetWalWriterSleeping(bool sleeping)
 {
-       /* use volatile pointer to prevent code rearrangement */
-       volatile XLogCtlData *xlogctl = XLogCtl;
-
-       SpinLockAcquire(&xlogctl->info_lck);
-       xlogctl->WalWriterSleeping = sleeping;
-       SpinLockRelease(&xlogctl->info_lck);
+       SpinLockAcquire(&XLogCtl->info_lck);
+       XLogCtl->WalWriterSleeping = sleeping;
+       SpinLockRelease(&XLogCtl->info_lck);
 }