standby.h File Reference

#include "datatype/timestamp.h"
#include "storage/lock.h"
#include "storage/relfilelocator.h"
#include "storage/standbydefs.h"

Include dependency graph for standby.h:

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

Go to the source code of this file.

Data Structures
struct	RunningTransactionsData

Macros
#define	NUM_RECOVERY_CONFLICT_REASONS   (RECOVERY_CONFLICT_BUFFERPIN_DEADLOCK + 1)
#define	MinSizeOfXactRunningXacts   offsetof(xl_running_xacts, xids)

Typedefs
typedef struct RunningTransactionsData	RunningTransactionsData
typedef RunningTransactionsData *	RunningTransactions

Enumerations
enum	RecoveryConflictReason {   RECOVERY_CONFLICT_DATABASE , RECOVERY_CONFLICT_TABLESPACE , RECOVERY_CONFLICT_LOCK , RECOVERY_CONFLICT_SNAPSHOT ,   RECOVERY_CONFLICT_LOGICALSLOT , RECOVERY_CONFLICT_BUFFERPIN , RECOVERY_CONFLICT_STARTUP_DEADLOCK , RECOVERY_CONFLICT_BUFFERPIN_DEADLOCK }
enum	subxids_array_status { SUBXIDS_IN_ARRAY , SUBXIDS_MISSING , SUBXIDS_IN_SUBTRANS }

Functions
void	InitRecoveryTransactionEnvironment (void)
void	ShutdownRecoveryTransactionEnvironment (void)
void	ResolveRecoveryConflictWithSnapshot (TransactionId snapshotConflictHorizon, bool isCatalogRel, RelFileLocator locator)
void	ResolveRecoveryConflictWithSnapshotFullXid (FullTransactionId snapshotConflictHorizon, bool isCatalogRel, RelFileLocator locator)
void	ResolveRecoveryConflictWithTablespace (Oid tsid)
void	ResolveRecoveryConflictWithDatabase (Oid dbid)
void	ResolveRecoveryConflictWithLock (LOCKTAG locktag, bool logging_conflict)
void	ResolveRecoveryConflictWithBufferPin (void)
void	CheckRecoveryConflictDeadlock (void)
void	StandbyDeadLockHandler (void)
void	StandbyTimeoutHandler (void)
void	StandbyLockTimeoutHandler (void)
void	LogRecoveryConflict (RecoveryConflictReason reason, TimestampTz wait_start, TimestampTz now, VirtualTransactionId *wait_list, bool still_waiting)
void	StandbyAcquireAccessExclusiveLock (TransactionId xid, Oid dbOid, Oid relOid)
void	StandbyReleaseLockTree (TransactionId xid, int nsubxids, TransactionId *subxids)
void	StandbyReleaseAllLocks (void)
void	StandbyReleaseOldLocks (TransactionId oldxid)
void	LogAccessExclusiveLock (Oid dbOid, Oid relOid)
void	LogAccessExclusiveLockPrepare (void)
XLogRecPtr	LogStandbySnapshot (void)
void	LogStandbyInvalidations (int nmsgs, SharedInvalidationMessage *msgs, bool relcacheInitFileInval)

Variables
PGDLLIMPORT int	max_standby_archive_delay
PGDLLIMPORT int	max_standby_streaming_delay
PGDLLIMPORT bool	log_recovery_conflict_waits

Macro Definition Documentation

MinSizeOfXactRunningXacts

#define MinSizeOfXactRunningXacts   offsetof(xl_running_xacts, xids)

Definition at line 101 of file standby.h.

NUM_RECOVERY_CONFLICT_REASONS

#define NUM_RECOVERY_CONFLICT_REASONS   (RECOVERY_CONFLICT_BUFFERPIN_DEADLOCK + 1)

Definition at line 64 of file standby.h.

Typedef Documentation

RunningTransactions

typedef RunningTransactionsData* RunningTransactions

Definition at line 138 of file standby.h.

RunningTransactionsData

typedef struct RunningTransactionsData RunningTransactionsData

Enumeration Type Documentation

RecoveryConflictReason

enum RecoveryConflictReason

Enumerator
RECOVERY_CONFLICT_DATABASE
RECOVERY_CONFLICT_TABLESPACE
RECOVERY_CONFLICT_LOCK
RECOVERY_CONFLICT_SNAPSHOT
RECOVERY_CONFLICT_LOGICALSLOT
RECOVERY_CONFLICT_BUFFERPIN
RECOVERY_CONFLICT_STARTUP_DEADLOCK
RECOVERY_CONFLICT_BUFFERPIN_DEADLOCK

Definition at line 28 of file standby.h.

{
    /* Backend is connected to a database that is being dropped */
    RECOVERY_CONFLICT_DATABASE,
 
    /* Backend is using a tablespace that is being dropped */
    RECOVERY_CONFLICT_TABLESPACE,
 
    /* Backend is holding a lock that is blocking recovery */
    RECOVERY_CONFLICT_LOCK,
 
    /* Backend is holding a snapshot that is blocking recovery */
    RECOVERY_CONFLICT_SNAPSHOT,
 
    /* Backend is using a logical replication slot that must be invalidated */
    RECOVERY_CONFLICT_LOGICALSLOT,
 
    /* Backend is holding a pin on a buffer that is blocking recovery */
    RECOVERY_CONFLICT_BUFFERPIN,
 
    /*
     * The backend is requested to check for deadlocks. The startup process
     * doesn't check for deadlock directly, because we want to kill one of the
     * other backends instead of the startup process.
     */
    RECOVERY_CONFLICT_STARTUP_DEADLOCK,
 
    /*
     * Like RECOVERY_CONFLICT_STARTUP_DEADLOCK is, but the suspected deadlock
     * involves a buffer pin that some other backend is holding. That needs
     * special checking because the normal deadlock detector doesn't track the
     * buffer pins.
     */
    RECOVERY_CONFLICT_BUFFERPIN_DEADLOCK,
} RecoveryConflictReason;

subxids_array_status

enum subxids_array_status

Enumerator
SUBXIDS_IN_ARRAY
SUBXIDS_MISSING
SUBXIDS_IN_SUBTRANS

Definition at line 116 of file standby.h.

{
    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;

Function Documentation

CheckRecoveryConflictDeadlock()

void CheckRecoveryConflictDeadlock ( void  )

extern

Definition at line 906 of file standby.c.

{
    Assert(!InRecovery);        /* do not call in Startup process */
 
    if (!HoldingBufferPinThatDelaysRecovery())
        return;
 
    /*
     * Error message should match ProcessInterrupts() but we avoid calling
     * that because we aren't handling an interrupt at this point. Note that
     * we only cancel the current transaction here, so if we are in a
     * subtransaction and the pin is held by a parent, then the Startup
     * process will continue to wait even though we have avoided deadlock.
     */
    ereport(ERROR,
            (errcode(ERRCODE_T_R_DEADLOCK_DETECTED),
             errmsg("canceling statement due to conflict with recovery"),
             errdetail("User transaction caused buffer deadlock with recovery.")));
}

References Assert, ereport, errcode(), ERRCODE_T_R_DEADLOCK_DETECTED, errdetail(), errmsg, ERROR, HoldingBufferPinThatDelaysRecovery(), and InRecovery.

Referenced by ProcSleep().

InitRecoveryTransactionEnvironment()

void InitRecoveryTransactionEnvironment ( void  )

extern

Definition at line 96 of file standby.c.

{
    VirtualTransactionId vxid;
    HASHCTL     hash_ctl;
 
    Assert(RecoveryLockHash == NULL);   /* don't run this twice */
 
    /*
     * Initialize the hash tables for tracking the locks held by each
     * transaction.
     */
    hash_ctl.keysize = sizeof(xl_standby_lock);
    hash_ctl.entrysize = sizeof(RecoveryLockEntry);
    RecoveryLockHash = hash_create("RecoveryLockHash",
                                   64,
                                   &hash_ctl,
                                   HASH_ELEM | HASH_BLOBS);
    hash_ctl.keysize = sizeof(TransactionId);
    hash_ctl.entrysize = sizeof(RecoveryLockXidEntry);
    RecoveryLockXidHash = hash_create("RecoveryLockXidHash",
                                      64,
                                      &hash_ctl,
                                      HASH_ELEM | HASH_BLOBS);
 
    /*
     * Initialize shared invalidation management for Startup process, being
     * careful to register ourselves as a sendOnly process so we don't need to
     * read messages, nor will we get signaled when the queue starts filling
     * up.
     */
    SharedInvalBackendInit(true);
 
    /*
     * Lock a virtual transaction id for Startup process.
     *
     * We need to do GetNextLocalTransactionId() because
     * SharedInvalBackendInit() leaves localTransactionId invalid and the lock
     * manager doesn't like that at all.
     *
     * Note that we don't need to run XactLockTableInsert() because nobody
     * needs to wait on xids. That sounds a little strange, but table locks
     * are held by vxids and row level locks are held by xids. All queries
     * hold AccessShareLocks so never block while we write or lock new rows.
     */
    MyProc->vxid.procNumber = MyProcNumber;
    vxid.procNumber = MyProcNumber;
    vxid.localTransactionId = GetNextLocalTransactionId();
    VirtualXactLockTableInsert(vxid);
 
    standbyState = STANDBY_INITIALIZED;
}

References Assert, fb(), GetNextLocalTransactionId(), HASH_BLOBS, hash_create(), HASH_ELEM, VirtualTransactionId::localTransactionId, MyProc, MyProcNumber, VirtualTransactionId::procNumber, PGPROC::procNumber, RecoveryLockHash, RecoveryLockXidHash, SharedInvalBackendInit(), STANDBY_INITIALIZED, standbyState, VirtualXactLockTableInsert(), and PGPROC::vxid.

Referenced by StartupXLOG().

LogAccessExclusiveLock()

void LogAccessExclusiveLock ( Oid  dbOid, Oid  relOid  )

extern

Definition at line 1433 of file standby.c.

{
    xl_standby_lock xlrec;
 
    xlrec.xid = GetCurrentTransactionId();
 
    xlrec.dbOid = dbOid;
    xlrec.relOid = relOid;
 
    LogAccessExclusiveLocks(1, &xlrec);
    MyXactFlags |= XACT_FLAGS_ACQUIREDACCESSEXCLUSIVELOCK;
}

References fb(), GetCurrentTransactionId(), LogAccessExclusiveLocks(), MyXactFlags, XACT_FLAGS_ACQUIREDACCESSEXCLUSIVELOCK, and xl_standby_lock::xid.

Referenced by LockAcquireExtended().

LogAccessExclusiveLockPrepare()

void LogAccessExclusiveLockPrepare ( void  )

extern

Definition at line 1450 of file standby.c.

{
    /*
     * Ensure that a TransactionId has been assigned to this transaction, for
     * two reasons, both related to lock release on the standby. First, we
     * must assign an xid so that RecordTransactionCommit() and
     * RecordTransactionAbort() do not optimise away the transaction
     * completion record which recovery relies upon to release locks. It's a
     * hack, but for a corner case not worth adding code for into the main
     * commit path. Second, we must assign an xid before the lock is recorded
     * in shared memory, otherwise a concurrently executing
     * GetRunningTransactionLocks() might see a lock associated with an
     * InvalidTransactionId which we later assert cannot happen.
     */
    (void) GetCurrentTransactionId();
}

References fb(), and GetCurrentTransactionId().

Referenced by LockAcquireExtended().

LogRecoveryConflict()

void LogRecoveryConflict ( RecoveryConflictReason  reason, TimestampTz  wait_start, TimestampTz  now, VirtualTransactionId *  wait_list, bool  still_waiting  )

extern

Definition at line 275 of file standby.c.

{
    long        secs;
    int         usecs;
    long        msecs;
    StringInfoData buf;
    int         nprocs = 0;
 
    /*
     * There must be no conflicting processes when the recovery conflict has
     * already been resolved.
     */
    Assert(still_waiting || wait_list == NULL);
 
    TimestampDifference(wait_start, now, &secs, &usecs);
    msecs = secs * 1000 + usecs / 1000;
    usecs = usecs % 1000;
 
    if (wait_list)
    {
        VirtualTransactionId *vxids;
 
        /* Construct a string of list of the conflicting processes */
        vxids = wait_list;
        while (VirtualTransactionIdIsValid(*vxids))
        {
            PGPROC     *proc = ProcNumberGetProc(vxids->procNumber);
 
            /* proc can be NULL if the target backend is not active */
            if (proc)
            {
                if (nprocs == 0)
                {
                    initStringInfo(&buf);
                    appendStringInfo(&buf, "%d", proc->pid);
                }
                else
                    appendStringInfo(&buf, ", %d", proc->pid);
 
                nprocs++;
            }
 
            vxids++;
        }
    }
 
    /*
     * If wait_list is specified, report the list of PIDs of active
     * conflicting backends in a detail message. Note that if all the backends
     * in the list are not active, no detail message is logged.
     */
    if (still_waiting)
    {
        ereport(LOG,
                errmsg("recovery still waiting after %ld.%03d ms: %s",
                       msecs, usecs, get_recovery_conflict_desc(reason)),
                nprocs > 0 ? errdetail_log_plural("Conflicting process: %s.",
                                                  "Conflicting processes: %s.",
                                                  nprocs, buf.data) : 0);
    }
    else
    {
        ereport(LOG,
                errmsg("recovery finished waiting after %ld.%03d ms: %s",
                       msecs, usecs, get_recovery_conflict_desc(reason)));
    }
 
    if (nprocs > 0)
        pfree(buf.data);
}

References appendStringInfo(), Assert, buf, ereport, errdetail_log_plural(), errmsg, fb(), get_recovery_conflict_desc(), initStringInfo(), LOG, now(), pfree(), PGPROC::pid, ProcNumberGetProc(), TimestampDifference(), and VirtualTransactionIdIsValid.

Referenced by LockBufferForCleanup(), ProcSleep(), and ResolveRecoveryConflictWithVirtualXIDs().

LogStandbyInvalidations()

void LogStandbyInvalidations ( int  nmsgs, SharedInvalidationMessage *  msgs, bool  relcacheInitFileInval  )

extern

Definition at line 1472 of file standby.c.

{
    xl_invalidations xlrec;
 
    /* prepare record */
    memset(&xlrec, 0, sizeof(xlrec));
    xlrec.dbId = MyDatabaseId;
    xlrec.tsId = MyDatabaseTableSpace;
    xlrec.relcacheInitFileInval = relcacheInitFileInval;
    xlrec.nmsgs = nmsgs;
 
    /* perform insertion */
    XLogBeginInsert();
    XLogRegisterData(&xlrec, MinSizeOfInvalidations);
    XLogRegisterData(msgs,
                     nmsgs * sizeof(SharedInvalidationMessage));
    XLogInsert(RM_STANDBY_ID, XLOG_INVALIDATIONS);
}

References fb(), MinSizeOfInvalidations, MyDatabaseId, MyDatabaseTableSpace, XLOG_INVALIDATIONS, XLogBeginInsert(), XLogInsert(), and XLogRegisterData().

Referenced by RecordTransactionCommit().

LogStandbySnapshot()

XLogRecPtr LogStandbySnapshot ( void  )

extern

Definition at line 1283 of file standby.c.

{
    XLogRecPtr  recptr;
    RunningTransactions running;
    xl_standby_lock *locks;
    int         nlocks;
    bool        logical_decoding_enabled = IsLogicalDecodingEnabled();
 
    Assert(XLogStandbyInfoActive());
 
#ifdef USE_INJECTION_POINTS
    if (IS_INJECTION_POINT_ATTACHED("skip-log-running-xacts"))
    {
        /*
         * This record could move slot's xmin forward during decoding, leading
         * to unpredictable results, so skip it when requested by the test.
         */
        return GetInsertRecPtr();
    }
#endif
 
    /*
     * Get details of any AccessExclusiveLocks being held at the moment.
     */
    locks = GetRunningTransactionLocks(&nlocks);
    if (nlocks > 0)
        LogAccessExclusiveLocks(nlocks, locks);
    pfree(locks);
 
    /*
     * Log details of all in-progress transactions. This should be the last
     * record we write, because standby will open up when it sees this.
     */
    running = GetRunningTransactionData();
 
    /*
     * GetRunningTransactionData() acquired ProcArrayLock, we must release it.
     * For Hot Standby this can be done before inserting the WAL record
     * because ProcArrayApplyRecoveryInfo() rechecks the commit status using
     * the clog. For logical decoding, though, the lock can't be released
     * early because the clog might be "in the future" from the POV of the
     * historic snapshot. This would allow for situations where we're waiting
     * for the end of a transaction listed in the xl_running_xacts record
     * which, according to the WAL, has committed before the xl_running_xacts
     * record. Fortunately this routine isn't executed frequently, and it's
     * only a shared lock.
     */
    if (!logical_decoding_enabled)
        LWLockRelease(ProcArrayLock);
 
    recptr = LogCurrentRunningXacts(running);
 
    /* Release lock if we kept it longer ... */
    if (logical_decoding_enabled)
        LWLockRelease(ProcArrayLock);
 
    /* GetRunningTransactionData() acquired XidGenLock, we must release it */
    LWLockRelease(XidGenLock);
 
    return recptr;
}

References Assert, fb(), GetInsertRecPtr(), GetRunningTransactionData(), GetRunningTransactionLocks(), IS_INJECTION_POINT_ATTACHED, IsLogicalDecodingEnabled(), LogAccessExclusiveLocks(), LogCurrentRunningXacts(), LWLockRelease(), pfree(), and XLogStandbyInfoActive.

Referenced by BackgroundWriterMain(), CreateCheckPoint(), pg_log_standby_snapshot(), ReplicationSlotReserveWal(), and SnapBuildWaitSnapshot().

ResolveRecoveryConflictWithBufferPin()

void ResolveRecoveryConflictWithBufferPin ( void  )

extern

Definition at line 794 of file standby.c.

{
    TimestampTz ltime;
 
    Assert(InHotStandby);
 
    ltime = GetStandbyLimitTime();
 
    if (GetCurrentTimestamp() >= ltime && ltime != 0)
    {
        /*
         * We're already behind, so clear a path as quickly as possible.
         */
        SendRecoveryConflictWithBufferPin(RECOVERY_CONFLICT_BUFFERPIN);
    }
    else
    {
        /*
         * Wake up at ltime, and check for deadlocks as well if we will be
         * waiting longer than deadlock_timeout
         */
        EnableTimeoutParams timeouts[2];
        int         cnt = 0;
 
        if (ltime != 0)
        {
            timeouts[cnt].id = STANDBY_TIMEOUT;
            timeouts[cnt].type = TMPARAM_AT;
            timeouts[cnt].fin_time = ltime;
            cnt++;
        }
 
        got_standby_deadlock_timeout = false;
        timeouts[cnt].id = STANDBY_DEADLOCK_TIMEOUT;
        timeouts[cnt].type = TMPARAM_AFTER;
        timeouts[cnt].delay_ms = DeadlockTimeout;
        cnt++;
 
        enable_timeouts(timeouts, cnt);
    }
 
    /*
     * Wait to be signaled by UnpinBuffer() or for the wait to be interrupted
     * by one of the timeouts established above.
     *
     * We assume that only UnpinBuffer() and the timeout requests established
     * above can wake us up here. WakeupRecovery() called by walreceiver or
     * SIGHUP signal handler, etc cannot do that because it uses the different
     * latch from that ProcWaitForSignal() waits on.
     */
    ProcWaitForSignal(WAIT_EVENT_BUFFER_CLEANUP);
 
    if (got_standby_delay_timeout)
        SendRecoveryConflictWithBufferPin(RECOVERY_CONFLICT_BUFFERPIN);
    else if (got_standby_deadlock_timeout)
    {
        /*
         * Send out a request for hot-standby backends to check themselves for
         * deadlocks.
         *
         * XXX The subsequent ResolveRecoveryConflictWithBufferPin() will wait
         * to be signaled by UnpinBuffer() again and send a request for
         * deadlocks check if deadlock_timeout happens. This causes the
         * request to continue to be sent every deadlock_timeout until the
         * buffer is unpinned or ltime is reached. This would increase the
         * workload in the startup process and backends. In practice it may
         * not be so harmful because the period that the buffer is kept pinned
         * is basically no so long. But we should fix this?
         */
        SendRecoveryConflictWithBufferPin(RECOVERY_CONFLICT_BUFFERPIN_DEADLOCK);
    }
 
    /*
     * Clear any timeout requests established above.  We assume here that the
     * Startup process doesn't have any other timeouts than what this function
     * uses.  If that stops being true, we could cancel the timeouts
     * individually, but that'd be slower.
     */
    disable_all_timeouts(false);
    got_standby_delay_timeout = false;
    got_standby_deadlock_timeout = false;
}

References Assert, DeadlockTimeout, disable_all_timeouts(), enable_timeouts(), fb(), GetCurrentTimestamp(), GetStandbyLimitTime(), got_standby_deadlock_timeout, got_standby_delay_timeout, EnableTimeoutParams::id, InHotStandby, ProcWaitForSignal(), RECOVERY_CONFLICT_BUFFERPIN, RECOVERY_CONFLICT_BUFFERPIN_DEADLOCK, SendRecoveryConflictWithBufferPin(), STANDBY_DEADLOCK_TIMEOUT, STANDBY_TIMEOUT, TMPARAM_AFTER, and TMPARAM_AT.

Referenced by LockBufferForCleanup().

ResolveRecoveryConflictWithDatabase()

void ResolveRecoveryConflictWithDatabase ( Oid  dbid )

extern

Definition at line 571 of file standby.c.

{
    /*
     * We don't do ResolveRecoveryConflictWithVirtualXIDs() here since that
     * only waits for transactions and completely idle sessions would block
     * us. This is rare enough that we do this as simply as possible: no wait,
     * just force them off immediately.
     *
     * No locking is required here because we already acquired
     * AccessExclusiveLock. Anybody trying to connect while we do this will
     * block during InitPostgres() and then disconnect when they see the
     * database has been removed.
     */
    while (CountDBBackends(dbid) > 0)
    {
        SignalRecoveryConflictWithDatabase(dbid, RECOVERY_CONFLICT_DATABASE);
 
        /*
         * Wait awhile for them to die so that we avoid flooding an
         * unresponsive backend when system is heavily loaded.
         */
        pg_usleep(10000);
    }
}

References CountDBBackends(), pg_usleep(), RECOVERY_CONFLICT_DATABASE, and SignalRecoveryConflictWithDatabase().

Referenced by dbase_redo().

ResolveRecoveryConflictWithLock()

void ResolveRecoveryConflictWithLock ( LOCKTAG  locktag, bool  logging_conflict  )

extern

Definition at line 625 of file standby.c.

{
    TimestampTz ltime;
    TimestampTz now;
 
    Assert(InHotStandby);
 
    ltime = GetStandbyLimitTime();
    now = GetCurrentTimestamp();
 
    /*
     * Update waitStart if first time through after the startup process
     * started waiting for the lock. It should not be updated every time
     * ResolveRecoveryConflictWithLock() is called during the wait.
     *
     * Use the current time obtained for comparison with ltime as waitStart
     * (i.e., the time when this process started waiting for the lock). Since
     * getting the current time newly can cause overhead, we reuse the
     * already-obtained time to avoid that overhead.
     *
     * Note that waitStart is updated without holding the lock table's
     * partition lock, to avoid the overhead by additional lock acquisition.
     * This can cause "waitstart" in pg_locks to become NULL for a very short
     * period of time after the wait started even though "granted" is false.
     * This is OK in practice because we can assume that users are likely to
     * look at "waitstart" when waiting for the lock for a long time.
     */
    if (pg_atomic_read_u64(&MyProc->waitStart) == 0)
        pg_atomic_write_u64(&MyProc->waitStart, now);
 
    if (now >= ltime && ltime != 0)
    {
        /*
         * We're already behind, so clear a path as quickly as possible.
         */
        VirtualTransactionId *backends;
 
        backends = GetLockConflicts(&locktag, AccessExclusiveLock, NULL);
 
        /*
         * Prevent ResolveRecoveryConflictWithVirtualXIDs() from reporting
         * "waiting" in PS display by disabling its argument report_waiting
         * because the caller, WaitOnLock(), has already reported that.
         */
        ResolveRecoveryConflictWithVirtualXIDs(backends,
                                               RECOVERY_CONFLICT_LOCK,
                                               PG_WAIT_LOCK | locktag.locktag_type,
                                               false);
    }
    else
    {
        /*
         * Wait (or wait again) until ltime, and check for deadlocks as well
         * if we will be waiting longer than deadlock_timeout
         */
        EnableTimeoutParams timeouts[2];
        int         cnt = 0;
 
        if (ltime != 0)
        {
            got_standby_lock_timeout = false;
            timeouts[cnt].id = STANDBY_LOCK_TIMEOUT;
            timeouts[cnt].type = TMPARAM_AT;
            timeouts[cnt].fin_time = ltime;
            cnt++;
        }
 
        got_standby_deadlock_timeout = false;
        timeouts[cnt].id = STANDBY_DEADLOCK_TIMEOUT;
        timeouts[cnt].type = TMPARAM_AFTER;
        timeouts[cnt].delay_ms = DeadlockTimeout;
        cnt++;
 
        enable_timeouts(timeouts, cnt);
    }
 
    /* Wait to be signaled by the release of the Relation Lock */
    ProcWaitForSignal(PG_WAIT_LOCK | locktag.locktag_type);
 
    /*
     * Exit if ltime is reached. Then all the backends holding conflicting
     * locks will be canceled in the next ResolveRecoveryConflictWithLock()
     * call.
     */
    if (got_standby_lock_timeout)
        goto cleanup;
 
    if (got_standby_deadlock_timeout)
    {
        VirtualTransactionId *backends;
 
        backends = GetLockConflicts(&locktag, AccessExclusiveLock, NULL);
 
        /* Quick exit if there's no work to be done */
        if (!VirtualTransactionIdIsValid(*backends))
            goto cleanup;
 
        /*
         * Send signals to all the backends holding the conflicting locks, to
         * ask them to check themselves for deadlocks.
         */
        while (VirtualTransactionIdIsValid(*backends))
        {
            (void) SignalRecoveryConflictWithVirtualXID(*backends,
                                                        RECOVERY_CONFLICT_STARTUP_DEADLOCK);
            backends++;
        }
 
        /*
         * Exit if the recovery conflict has not been logged yet even though
         * logging is enabled, so that the caller can log that. Then
         * RecoveryConflictWithLock() is called again and we will wait again
         * for the lock to be released.
         */
        if (logging_conflict)
            goto cleanup;
 
        /*
         * Wait again here to be signaled by the release of the Relation Lock,
         * to prevent the subsequent RecoveryConflictWithLock() from causing
         * deadlock_timeout and sending a request for deadlocks check again.
         * Otherwise the request continues to be sent every deadlock_timeout
         * until the relation locks are released or ltime is reached.
         */
        got_standby_deadlock_timeout = false;
        ProcWaitForSignal(PG_WAIT_LOCK | locktag.locktag_type);
    }
 
cleanup:
 
    /*
     * Clear any timeout requests established above.  We assume here that the
     * Startup process doesn't have any other outstanding timeouts than those
     * used by this function. If that stops being true, we could cancel the
     * timeouts individually, but that'd be slower.
     */
    disable_all_timeouts(false);
    got_standby_lock_timeout = false;
    got_standby_deadlock_timeout = false;
}

References AccessExclusiveLock, Assert, cleanup(), DeadlockTimeout, disable_all_timeouts(), enable_timeouts(), fb(), GetCurrentTimestamp(), GetLockConflicts(), GetStandbyLimitTime(), got_standby_deadlock_timeout, got_standby_lock_timeout, EnableTimeoutParams::id, InHotStandby, LOCKTAG::locktag_type, MyProc, now(), pg_atomic_read_u64(), pg_atomic_write_u64(), PG_WAIT_LOCK, ProcWaitForSignal(), RECOVERY_CONFLICT_LOCK, RECOVERY_CONFLICT_STARTUP_DEADLOCK, ResolveRecoveryConflictWithVirtualXIDs(), SignalRecoveryConflictWithVirtualXID(), STANDBY_DEADLOCK_TIMEOUT, STANDBY_LOCK_TIMEOUT, TMPARAM_AFTER, TMPARAM_AT, VirtualTransactionIdIsValid, and PGPROC::waitStart.

Referenced by ProcSleep().

ResolveRecoveryConflictWithSnapshot()

void ResolveRecoveryConflictWithSnapshot ( TransactionId  snapshotConflictHorizon, bool  isCatalogRel, RelFileLocator  locator  )

extern

Definition at line 470 of file standby.c.

{
    VirtualTransactionId *backends;
 
    /*
     * If we get passed InvalidTransactionId then we do nothing (no conflict).
     *
     * This can happen when replaying already-applied WAL records after a
     * standby crash or restart, or when replaying an XLOG_HEAP2_VISIBLE
     * record that marks as frozen a page which was already all-visible.  It's
     * also quite common with records generated during index deletion
     * (original execution of the deletion can reason that a recovery conflict
     * which is sufficient for the deletion operation must take place before
     * replay of the deletion record itself).
     */
    if (!TransactionIdIsValid(snapshotConflictHorizon))
        return;
 
    Assert(TransactionIdIsNormal(snapshotConflictHorizon));
    backends = GetConflictingVirtualXIDs(snapshotConflictHorizon,
                                         locator.dbOid);
    ResolveRecoveryConflictWithVirtualXIDs(backends,
                                           RECOVERY_CONFLICT_SNAPSHOT,
                                           WAIT_EVENT_RECOVERY_CONFLICT_SNAPSHOT,
                                           true);
 
    /*
     * Note that WaitExceedsMaxStandbyDelay() is not taken into account here
     * (as opposed to ResolveRecoveryConflictWithVirtualXIDs() above). That
     * seems OK, given that this kind of conflict should not normally be
     * reached, e.g. due to using a physical replication slot.
     */
    if (IsLogicalDecodingEnabled() && isCatalogRel)
        InvalidateObsoleteReplicationSlots(RS_INVAL_HORIZON, 0, locator.dbOid,
                                           snapshotConflictHorizon);
}

References Assert, RelFileLocator::dbOid, fb(), GetConflictingVirtualXIDs(), InvalidateObsoleteReplicationSlots(), IsLogicalDecodingEnabled(), RECOVERY_CONFLICT_SNAPSHOT, ResolveRecoveryConflictWithVirtualXIDs(), RS_INVAL_HORIZON, TransactionIdIsNormal, and TransactionIdIsValid.

Referenced by btree_xlog_delete(), gistRedoDeleteRecord(), hash_xlog_vacuum_one_page(), heap_xlog_prune_freeze(), heap_xlog_visible(), ResolveRecoveryConflictWithSnapshotFullXid(), and spgRedoVacuumRedirect().

ResolveRecoveryConflictWithSnapshotFullXid()

void ResolveRecoveryConflictWithSnapshotFullXid ( FullTransactionId  snapshotConflictHorizon, bool  isCatalogRel, RelFileLocator  locator  )

extern

Definition at line 514 of file standby.c.

{
    /*
     * ResolveRecoveryConflictWithSnapshot operates on 32-bit TransactionIds,
     * so truncate the logged FullTransactionId.  If the logged value is very
     * old, so that XID wrap-around already happened on it, there can't be any
     * snapshots that still see it.
     */
    FullTransactionId nextXid = ReadNextFullTransactionId();
    uint64      diff;
 
    diff = U64FromFullTransactionId(nextXid) -
        U64FromFullTransactionId(snapshotConflictHorizon);
    if (diff < MaxTransactionId / 2)
    {
        TransactionId truncated;
 
        truncated = XidFromFullTransactionId(snapshotConflictHorizon);
        ResolveRecoveryConflictWithSnapshot(truncated,
                                            isCatalogRel,
                                            locator);
    }
}

References fb(), MaxTransactionId, ReadNextFullTransactionId(), ResolveRecoveryConflictWithSnapshot(), U64FromFullTransactionId, and XidFromFullTransactionId.

Referenced by btree_xlog_reuse_page(), and gistRedoPageReuse().

ResolveRecoveryConflictWithTablespace()

void ResolveRecoveryConflictWithTablespace ( Oid  tsid )

extern

Definition at line 541 of file standby.c.

{
    VirtualTransactionId *temp_file_users;
 
    /*
     * Standby users may be currently using this tablespace for their
     * temporary files. We only care about current users because
     * temp_tablespace parameter will just ignore tablespaces that no longer
     * exist.
     *
     * Ask everybody to cancel their queries immediately so we can ensure no
     * temp files remain and we can remove the tablespace. Nuke the entire
     * site from orbit, it's the only way to be sure.
     *
     * XXX: We could work out the pids of active backends using this
     * tablespace by examining the temp filenames in the directory. We would
     * then convert the pids into VirtualXIDs before attempting to cancel
     * them.
     *
     * We don't wait for commit because drop tablespace is non-transactional.
     */
    temp_file_users = GetConflictingVirtualXIDs(InvalidTransactionId,
                                                InvalidOid);
    ResolveRecoveryConflictWithVirtualXIDs(temp_file_users,
                                           RECOVERY_CONFLICT_TABLESPACE,
                                           WAIT_EVENT_RECOVERY_CONFLICT_TABLESPACE,
                                           true);
}

References fb(), GetConflictingVirtualXIDs(), InvalidOid, InvalidTransactionId, RECOVERY_CONFLICT_TABLESPACE, and ResolveRecoveryConflictWithVirtualXIDs().

Referenced by tblspc_redo().

ShutdownRecoveryTransactionEnvironment()

void ShutdownRecoveryTransactionEnvironment ( void  )

extern

Definition at line 162 of file standby.c.

{
    /*
     * Do nothing if RecoveryLockHash is NULL because that means that
     * transaction tracking has not yet been initialized or has already been
     * shut down.  This makes it safe to have possibly-redundant calls of this
     * function during process exit.
     */
    if (RecoveryLockHash == NULL)
        return;
 
    /* Mark all tracked in-progress transactions as finished. */
    ExpireAllKnownAssignedTransactionIds();
 
    /* Release all locks the tracked transactions were holding */
    StandbyReleaseAllLocks();
 
    /* Destroy the lock hash tables. */
    hash_destroy(RecoveryLockHash);
    hash_destroy(RecoveryLockXidHash);
    RecoveryLockHash = NULL;
    RecoveryLockXidHash = NULL;
 
    /* Cleanup our VirtualTransaction */
    VirtualXactLockTableCleanup();
}

References ExpireAllKnownAssignedTransactionIds(), fb(), hash_destroy(), RecoveryLockHash, RecoveryLockXidHash, StandbyReleaseAllLocks(), and VirtualXactLockTableCleanup().

Referenced by StartupProcExit(), and StartupXLOG().

StandbyAcquireAccessExclusiveLock()

void StandbyAcquireAccessExclusiveLock ( TransactionId  xid, Oid  dbOid, Oid  relOid  )

extern

Definition at line 987 of file standby.c.

{
    RecoveryLockXidEntry *xidentry;
    RecoveryLockEntry *lockentry;
    xl_standby_lock key;
    LOCKTAG     locktag;
    bool        found;
 
    /* Already processed? */
    if (!TransactionIdIsValid(xid) ||
        TransactionIdDidCommit(xid) ||
        TransactionIdDidAbort(xid))
        return;
 
    elog(DEBUG4, "adding recovery lock: db %u rel %u", dbOid, relOid);
 
    /* dbOid is InvalidOid when we are locking a shared relation. */
    Assert(OidIsValid(relOid));
 
    /* Create a hash entry for this xid, if we don't have one already. */
    xidentry = hash_search(RecoveryLockXidHash, &xid, HASH_ENTER, &found);
    if (!found)
    {
        Assert(xidentry->xid == xid);   /* dynahash should have set this */
        xidentry->head = NULL;
    }
 
    /* Create a hash entry for this lock, unless we have one already. */
    key.xid = xid;
    key.dbOid = dbOid;
    key.relOid = relOid;
    lockentry = hash_search(RecoveryLockHash, &key, HASH_ENTER, &found);
    if (!found)
    {
        /* It's new, so link it into the XID's list ... */
        lockentry->next = xidentry->head;
        xidentry->head = lockentry;
 
        /* ... and acquire the lock locally. */
        SET_LOCKTAG_RELATION(locktag, dbOid, relOid);
 
        (void) LockAcquire(&locktag, AccessExclusiveLock, true, false);
    }
}

References AccessExclusiveLock, Assert, xl_standby_lock::dbOid, DEBUG4, elog, fb(), HASH_ENTER, hash_search(), RecoveryLockEntry::key, LockAcquire(), OidIsValid, RecoveryLockHash, RecoveryLockXidHash, xl_standby_lock::relOid, SET_LOCKTAG_RELATION, TransactionIdDidAbort(), TransactionIdDidCommit(), TransactionIdIsValid, and xl_standby_lock::xid.

Referenced by lock_twophase_standby_recover(), and standby_redo().

StandbyDeadLockHandler()

void StandbyDeadLockHandler ( void  )

extern

Definition at line 937 of file standby.c.

{
    got_standby_deadlock_timeout = true;
}

References got_standby_deadlock_timeout.

Referenced by StartupProcessMain().

StandbyLockTimeoutHandler()

void StandbyLockTimeoutHandler ( void  )

extern

Definition at line 955 of file standby.c.

{
    got_standby_lock_timeout = true;
}

References got_standby_lock_timeout.

Referenced by StartupProcessMain().

StandbyReleaseAllLocks()

void StandbyReleaseAllLocks ( void  )

extern

Definition at line 1107 of file standby.c.

{
    HASH_SEQ_STATUS status;
    RecoveryLockXidEntry *entry;
 
    elog(DEBUG2, "release all standby locks");
 
    hash_seq_init(&status, RecoveryLockXidHash);
    while ((entry = hash_seq_search(&status)))
    {
        StandbyReleaseXidEntryLocks(entry);
        hash_search(RecoveryLockXidHash, entry, HASH_REMOVE, NULL);
    }
}

References DEBUG2, elog, fb(), HASH_REMOVE, hash_search(), hash_seq_init(), hash_seq_search(), RecoveryLockXidHash, and StandbyReleaseXidEntryLocks().

Referenced by ShutdownRecoveryTransactionEnvironment(), and StandbyReleaseLocks().

StandbyReleaseLockTree()

void StandbyReleaseLockTree ( TransactionId  xid, int  nsubxids, TransactionId *  subxids  )

extern

Definition at line 1093 of file standby.c.

{
    int         i;
 
    StandbyReleaseLocks(xid);
 
    for (i = 0; i < nsubxids; i++)
        StandbyReleaseLocks(subxids[i]);
}

References fb(), i, and StandbyReleaseLocks().

Referenced by RecoverPreparedTransactions(), xact_redo_abort(), and xact_redo_commit().

StandbyReleaseOldLocks()

void StandbyReleaseOldLocks ( TransactionId  oldxid )

extern

Definition at line 1131 of file standby.c.

{
    HASH_SEQ_STATUS status;
    RecoveryLockXidEntry *entry;
 
    hash_seq_init(&status, RecoveryLockXidHash);
    while ((entry = hash_seq_search(&status)))
    {
        Assert(TransactionIdIsValid(entry->xid));
 
        /* Skip if prepared transaction. */
        if (StandbyTransactionIdIsPrepared(entry->xid))
            continue;
 
        /* Skip if >= oldxid. */
        if (!TransactionIdPrecedes(entry->xid, oldxid))
            continue;
 
        /* Remove all locks and hash table entry. */
        StandbyReleaseXidEntryLocks(entry);
        hash_search(RecoveryLockXidHash, entry, HASH_REMOVE, NULL);
    }
}

References Assert, fb(), HASH_REMOVE, hash_search(), hash_seq_init(), hash_seq_search(), RecoveryLockXidHash, StandbyReleaseXidEntryLocks(), StandbyTransactionIdIsPrepared(), TransactionIdIsValid, TransactionIdPrecedes(), and RecoveryLockXidEntry::xid.

Referenced by ProcArrayApplyRecoveryInfo().

StandbyTimeoutHandler()

void StandbyTimeoutHandler ( void  )

extern

Definition at line 946 of file standby.c.

{
    got_standby_delay_timeout = true;
}

References got_standby_delay_timeout.

Referenced by StartupProcessMain().

Variable Documentation

log_recovery_conflict_waits

PGDLLIMPORT bool log_recovery_conflict_waits

extern

Definition at line 43 of file standby.c.

Referenced by LockBufferForCleanup(), ProcSleep(), and ResolveRecoveryConflictWithVirtualXIDs().

max_standby_archive_delay

PGDLLIMPORT int max_standby_archive_delay

extern

Definition at line 41 of file standby.c.

Referenced by GetStandbyLimitTime().

max_standby_streaming_delay

PGDLLIMPORT int max_standby_streaming_delay

extern

Definition at line 42 of file standby.c.

Referenced by GetStandbyLimitTime().