xlogwait.h File Reference

#include "access/xlogdefs.h"
#include "lib/pairingheap.h"
#include "port/atomics.h"
#include "storage/procnumber.h"
#include "storage/spin.h"
#include "tcop/dest.h"

Include dependency graph for xlogwait.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	WaitLSNProcInfo
struct	WaitLSNState

Macros
#define	WAIT_LSN_TYPE_COUNT   (WAIT_LSN_TYPE_PRIMARY_FLUSH + 1)

Typedefs
typedef enum WaitLSNType	WaitLSNType
typedef struct WaitLSNProcInfo	WaitLSNProcInfo
typedef struct WaitLSNState	WaitLSNState

Enumerations
enum	WaitLSNResult { WAIT_LSN_RESULT_SUCCESS , WAIT_LSN_RESULT_NOT_IN_RECOVERY , WAIT_LSN_RESULT_TIMEOUT }
enum	WaitLSNType { WAIT_LSN_TYPE_STANDBY_REPLAY , WAIT_LSN_TYPE_STANDBY_WRITE , WAIT_LSN_TYPE_STANDBY_FLUSH , WAIT_LSN_TYPE_PRIMARY_FLUSH }

Functions
XLogRecPtr	GetCurrentLSNForWaitType (WaitLSNType lsnType)
void	WaitLSNWakeup (WaitLSNType lsnType, XLogRecPtr currentLSN)
void	WaitLSNCleanup (void)
WaitLSNResult	WaitForLSN (WaitLSNType lsnType, XLogRecPtr targetLSN, int64 timeout)

Variables
PGDLLIMPORT WaitLSNState *	waitLSNState

Macro Definition Documentation

WAIT_LSN_TYPE_COUNT

#define WAIT_LSN_TYPE_COUNT   (WAIT_LSN_TYPE_PRIMARY_FLUSH + 1)

Definition at line 47 of file xlogwait.h.

Typedef Documentation

WaitLSNProcInfo

typedef struct WaitLSNProcInfo WaitLSNProcInfo

WaitLSNState

typedef struct WaitLSNState WaitLSNState

WaitLSNType

typedef enum WaitLSNType WaitLSNType

Enumeration Type Documentation

WaitLSNResult

enum WaitLSNResult

Enumerator
WAIT_LSN_RESULT_SUCCESS
WAIT_LSN_RESULT_NOT_IN_RECOVERY
WAIT_LSN_RESULT_TIMEOUT

Definition at line 25 of file xlogwait.h.

{
    WAIT_LSN_RESULT_SUCCESS,    /* Target LSN is reached */
    WAIT_LSN_RESULT_NOT_IN_RECOVERY,    /* Recovery ended before or during our
                                         * wait */
    WAIT_LSN_RESULT_TIMEOUT     /* Timeout occurred */
} WaitLSNResult;

WaitLSNType

enum WaitLSNType

Enumerator
WAIT_LSN_TYPE_STANDBY_REPLAY
WAIT_LSN_TYPE_STANDBY_WRITE
WAIT_LSN_TYPE_STANDBY_FLUSH
WAIT_LSN_TYPE_PRIMARY_FLUSH

Definition at line 36 of file xlogwait.h.

{
    /* Standby wait types (walreceiver/startup wakes) */
    WAIT_LSN_TYPE_STANDBY_REPLAY,
    WAIT_LSN_TYPE_STANDBY_WRITE,
    WAIT_LSN_TYPE_STANDBY_FLUSH,
 
    /* Primary wait types (WAL writer/backends wake) */
    WAIT_LSN_TYPE_PRIMARY_FLUSH,
} WaitLSNType;

Function Documentation

GetCurrentLSNForWaitType()

XLogRecPtr GetCurrentLSNForWaitType ( WaitLSNType  lsnType )

extern

Definition at line 99 of file xlogwait.c.

{
    Assert(lsnType >= 0 && lsnType < WAIT_LSN_TYPE_COUNT);
 
    /*
     * All of the cases below provide memory barrier semantics:
     * GetWalRcvWriteRecPtr() and GetFlushRecPtr() have explicit barriers,
     * while GetXLogReplayRecPtr() and GetWalRcvFlushRecPtr() use spinlocks.
     */
    switch (lsnType)
    {
        case WAIT_LSN_TYPE_STANDBY_REPLAY:
            return GetXLogReplayRecPtr(NULL);
 
        case WAIT_LSN_TYPE_STANDBY_WRITE:
            {
                XLogRecPtr  recptr = GetWalRcvWriteRecPtr();
                XLogRecPtr  replay = GetXLogReplayRecPtr(NULL);
 
                /*
                 * Use the replay position as a floor.  WAL up to the replay
                 * point is already on disk from a base backup, archive
                 * restore, or prior streaming, so there is no reason to wait
                 * for the walreceiver to re-receive it.
                 */
                return Max(recptr, replay);
            }
 
        case WAIT_LSN_TYPE_STANDBY_FLUSH:
            {
                XLogRecPtr  recptr = GetWalRcvFlushRecPtr(NULL, NULL);
                XLogRecPtr  replay = GetXLogReplayRecPtr(NULL);
 
                /* Same floor as standby_write; see comment above. */
                return Max(recptr, replay);
            }
 
        case WAIT_LSN_TYPE_PRIMARY_FLUSH:
            return GetFlushRecPtr(NULL);
    }
 
    elog(ERROR, "invalid LSN wait type: %d", lsnType);
    pg_unreachable();
}

References Assert, elog, ERROR, fb(), GetFlushRecPtr(), GetWalRcvFlushRecPtr(), GetWalRcvWriteRecPtr(), GetXLogReplayRecPtr(), Max, pg_unreachable, WAIT_LSN_TYPE_COUNT, WAIT_LSN_TYPE_PRIMARY_FLUSH, WAIT_LSN_TYPE_STANDBY_FLUSH, WAIT_LSN_TYPE_STANDBY_REPLAY, and WAIT_LSN_TYPE_STANDBY_WRITE.

Referenced by ExecWaitStmt(), and WaitForLSN().

WaitForLSN()

WaitLSNResult WaitForLSN ( WaitLSNType  lsnType, XLogRecPtr  targetLSN, int64  timeout  )

extern

Definition at line 403 of file xlogwait.c.

{
    XLogRecPtr  currentLSN;
    TimestampTz endtime = 0;
    int         wake_events = WL_LATCH_SET | WL_POSTMASTER_DEATH;
 
    /* Shouldn't be called when shmem isn't initialized */
    Assert(waitLSNState);
 
    /* Should have a valid proc number */
    Assert(MyProcNumber >= 0 && MyProcNumber < MaxBackends + NUM_AUXILIARY_PROCS);
 
    if (timeout > 0)
    {
        endtime = TimestampTzPlusMilliseconds(GetCurrentTimestamp(), timeout);
        wake_events |= WL_TIMEOUT;
    }
 
    /*
     * Add our process to the waiters heap.  It might happen that target LSN
     * gets reached before we do.  The check at the beginning of the loop
     * below prevents the race condition.
     */
    addLSNWaiter(targetLSN, lsnType);
 
    for (;;)
    {
        int         rc;
        long        delay_ms = -1;
 
        /* Get current LSN for the wait type */
        currentLSN = GetCurrentLSNForWaitType(lsnType);
 
        /* Check that recovery is still in-progress */
        if (WaitLSNTypeRequiresRecovery(lsnType) && !RecoveryInProgress())
        {
            /*
             * Recovery was ended, but check if target LSN was already
             * reached.
             */
            deleteLSNWaiter(lsnType);
 
            if (PromoteIsTriggered() && targetLSN <= currentLSN)
                return WAIT_LSN_RESULT_SUCCESS;
            return WAIT_LSN_RESULT_NOT_IN_RECOVERY;
        }
        else
        {
            /* Check if the waited LSN has been reached */
            if (targetLSN <= currentLSN)
                break;
        }
 
        if (timeout > 0)
        {
            delay_ms = TimestampDifferenceMilliseconds(GetCurrentTimestamp(), endtime);
            if (delay_ms <= 0)
                break;
        }
 
        CHECK_FOR_INTERRUPTS();
 
        rc = WaitLatch(MyLatch, wake_events, delay_ms,
                       WaitLSNWaitEvents[lsnType]);
 
        /*
         * Emergency bailout if postmaster has died.  This is to avoid the
         * necessity for manual cleanup of all postmaster children.
         */
        if (rc & WL_POSTMASTER_DEATH)
            ereport(FATAL,
                    errcode(ERRCODE_ADMIN_SHUTDOWN),
                    errmsg("terminating connection due to unexpected postmaster exit"),
                    errcontext("while waiting for LSN"));
 
        ResetLatch(MyLatch);
    }
 
    /*
     * Delete our process from the shared memory heap.  We might already be
     * deleted by the startup process.  The 'inHeap' flags prevents us from
     * the double deletion.
     */
    deleteLSNWaiter(lsnType);
 
    /*
     * If we didn't reach the target LSN, we must be exited by timeout.
     */
    if (targetLSN > currentLSN)
        return WAIT_LSN_RESULT_TIMEOUT;
 
    return WAIT_LSN_RESULT_SUCCESS;
}

References addLSNWaiter(), Assert, CHECK_FOR_INTERRUPTS, deleteLSNWaiter(), ereport, errcode(), errcontext, errmsg, FATAL, fb(), GetCurrentLSNForWaitType(), GetCurrentTimestamp(), MaxBackends, MyLatch, MyProcNumber, NUM_AUXILIARY_PROCS, PromoteIsTriggered(), RecoveryInProgress(), ResetLatch(), TimestampDifferenceMilliseconds(), TimestampTzPlusMilliseconds, WAIT_LSN_RESULT_NOT_IN_RECOVERY, WAIT_LSN_RESULT_SUCCESS, WAIT_LSN_RESULT_TIMEOUT, WaitLatch(), waitLSNState, WaitLSNTypeRequiresRecovery(), WaitLSNWaitEvents, WL_LATCH_SET, WL_POSTMASTER_DEATH, and WL_TIMEOUT.

Referenced by decode_concurrent_changes(), and ExecWaitStmt().

WaitLSNCleanup()

void WaitLSNCleanup ( void  )

extern

Definition at line 366 of file xlogwait.c.

{
    if (waitLSNState)
    {
        /*
         * We do a fast-path check of the inHeap flag without the lock.  This
         * flag is set to true only by the process itself.  So, it's only
         * possible to get a false positive.  But that will be eliminated by a
         * recheck inside deleteLSNWaiter().
         */
        if (waitLSNState->procInfos[MyProcNumber].inHeap)
            deleteLSNWaiter(waitLSNState->procInfos[MyProcNumber].lsnType);
    }
}

References deleteLSNWaiter(), WaitLSNProcInfo::inHeap, WaitLSNProcInfo::lsnType, MyProcNumber, WaitLSNState::procInfos, and waitLSNState.

Referenced by AbortSubTransaction(), AbortTransaction(), and ProcKill().

WaitLSNWakeup()

void WaitLSNWakeup ( WaitLSNType  lsnType, XLogRecPtr  currentLSN  )

extern

Definition at line 344 of file xlogwait.c.

{
    int         i = (int) lsnType;
 
    Assert(i >= 0 && i < WAIT_LSN_TYPE_COUNT);
 
    /*
     * Fast path check.  Skip if currentLSN is InvalidXLogRecPtr, which means
     * "wake all waiters" (e.g., during promotion when recovery ends). Pairs
     * with pg_atomic_write_membarrier_u64() in updateMinWaitedLSN().
     */
    if (XLogRecPtrIsValid(currentLSN) &&
        pg_atomic_read_membarrier_u64(&waitLSNState->minWaitedLSN[i]) > currentLSN)
        return;
 
    wakeupWaiters(lsnType, currentLSN);
}

References Assert, fb(), i, WaitLSNState::minWaitedLSN, pg_atomic_read_membarrier_u64(), WAIT_LSN_TYPE_COUNT, waitLSNState, wakeupWaiters(), and XLogRecPtrIsValid.

Referenced by PerformWalRecovery(), StartupXLOG(), XLogBackgroundFlush(), XLogFlush(), XLogWalRcvFlush(), and XLogWalRcvWrite().

Variable Documentation

waitLSNState

PGDLLIMPORT WaitLSNState* waitLSNState

extern

Definition at line 70 of file xlogwait.c.

Referenced by addLSNWaiter(), deleteLSNWaiter(), updateMinWaitedLSN(), WaitForLSN(), WaitLSNCleanup(), WaitLSNShmemInit(), WaitLSNShmemRequest(), WaitLSNWakeup(), and wakeupWaiters().