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
Size	WaitLSNShmemSize (void)
void	WaitLSNShmemInit (void)
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 89 of file xlogwait.c.

{
    Assert(lsnType >= 0 && lsnType < WAIT_LSN_TYPE_COUNT);
 
    switch (lsnType)
    {
        case WAIT_LSN_TYPE_STANDBY_REPLAY:
            return GetXLogReplayRecPtr(NULL);
 
        case WAIT_LSN_TYPE_STANDBY_WRITE:
            return GetWalRcvWriteRecPtr();
 
        case WAIT_LSN_TYPE_STANDBY_FLUSH:
            return GetWalRcvFlushRecPtr(NULL, NULL);
 
        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(), 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 376 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"));
 
        if (rc & WL_LATCH_SET)
            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 ExecWaitStmt().

WaitLSNCleanup()

void WaitLSNCleanup ( void  )

extern

Definition at line 339 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 AbortTransaction(), and ProcKill().

WaitLSNShmemInit()

void WaitLSNShmemInit ( void  )

extern

Definition at line 125 of file xlogwait.c.

{
    bool        found;
 
    waitLSNState = (WaitLSNState *) ShmemInitStruct("WaitLSNState",
                                                    WaitLSNShmemSize(),
                                                    &found);
    if (!found)
    {
        int         i;
 
        /* Initialize heaps and tracking */
        for (i = 0; i < WAIT_LSN_TYPE_COUNT; i++)
        {
            pg_atomic_init_u64(&waitLSNState->minWaitedLSN[i], PG_UINT64_MAX);
            pairingheap_initialize(&waitLSNState->waitersHeap[i], waitlsn_cmp, NULL);
        }
 
        /* Initialize process info array */
        memset(&waitLSNState->procInfos, 0,
               (MaxBackends + NUM_AUXILIARY_PROCS) * sizeof(WaitLSNProcInfo));
    }
}

References fb(), i, MaxBackends, WaitLSNState::minWaitedLSN, NUM_AUXILIARY_PROCS, pairingheap_initialize(), pg_atomic_init_u64(), PG_UINT64_MAX, WaitLSNState::procInfos, ShmemInitStruct(), WAIT_LSN_TYPE_COUNT, WaitLSNState::waitersHeap, waitlsn_cmp(), WaitLSNShmemSize(), and waitLSNState.

Referenced by CreateOrAttachShmemStructs().

WaitLSNShmemSize()

Size WaitLSNShmemSize ( void  )

extern

Definition at line 114 of file xlogwait.c.

{
    Size        size;
 
    size = offsetof(WaitLSNState, procInfos);
    size = add_size(size, mul_size(MaxBackends + NUM_AUXILIARY_PROCS, sizeof(WaitLSNProcInfo)));
    return size;
}

References add_size(), fb(), MaxBackends, mul_size(), NUM_AUXILIARY_PROCS, and WaitLSNState::procInfos.

Referenced by CalculateShmemSize(), and WaitLSNShmemInit().

WaitLSNWakeup()

void WaitLSNWakeup ( WaitLSNType  lsnType, XLogRecPtr  currentLSN  )

extern

Definition at line 318 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).
     */
    if (XLogRecPtrIsValid(currentLSN) &&
        pg_atomic_read_u64(&waitLSNState->minWaitedLSN[i]) > currentLSN)
        return;
 
    wakeupWaiters(lsnType, currentLSN);
}

References Assert, fb(), i, WaitLSNState::minWaitedLSN, pg_atomic_read_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 69 of file xlogwait.c.

Referenced by addLSNWaiter(), deleteLSNWaiter(), PerformWalRecovery(), updateMinWaitedLSN(), WaitForLSN(), WaitLSNCleanup(), WaitLSNShmemInit(), WaitLSNWakeup(), wakeupWaiters(), XLogBackgroundFlush(), XLogFlush(), XLogWalRcvFlush(), and XLogWalRcvWrite().