standby.h File Reference

#include "datatype/timestamp.h"
#include "storage/lock.h"
#include "storage/procsignal.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	MinSizeOfXactRunningXacts   offsetof(xl_running_xacts, xids)

Typedefs
typedef struct RunningTransactionsData	RunningTransactionsData
typedef RunningTransactionsData *	RunningTransactions

Enumerations
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 (ProcSignalReason 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 63 of file standby.h.

Typedef Documentation

RunningTransactions

typedef RunningTransactionsData* RunningTransactions

Definition at line 100 of file standby.h.

RunningTransactionsData

typedef struct RunningTransactionsData RunningTransactionsData

Enumeration Type Documentation

subxids_array_status

enum subxids_array_status

Enumerator
SUBXIDS_IN_ARRAY
SUBXIDS_MISSING
SUBXIDS_IN_SUBTRANS

Definition at line 78 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

)

Definition at line 904 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

)

Definition at line 94 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, HASHCTL::entrysize, GetNextLocalTransactionId(), HASH_BLOBS, hash_create(), HASH_ELEM, HASHCTL::keysize, 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
	)

Definition at line 1419 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 xl_standby_lock::dbOid, GetCurrentTransactionId(), LogAccessExclusiveLocks(), MyXactFlags, xl_standby_lock::relOid, XACT_FLAGS_ACQUIREDACCESSEXCLUSIVELOCK, and xl_standby_lock::xid.

Referenced by LockAcquireExtended().

LogAccessExclusiveLockPrepare()

void LogAccessExclusiveLockPrepare

(

void

)

Definition at line 1436 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 GetCurrentTransactionId().

Referenced by LockAcquireExtended().

LogRecoveryConflict()

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

Definition at line 273 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(), get_recovery_conflict_desc(), initStringInfo(), LOG, now(), pfree(), PGPROC::pid, VirtualTransactionId::procNumber, ProcNumberGetProc(), TimestampDifference(), and VirtualTransactionIdIsValid.

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

LogStandbyInvalidations()

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

Definition at line 1458 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((char *) (&xlrec), MinSizeOfInvalidations);
    XLogRegisterData((char *) msgs,
                     nmsgs * sizeof(SharedInvalidationMessage));
    XLogInsert(RM_STANDBY_ID, XLOG_INVALIDATIONS);
}

References xl_invalidations::dbId, MinSizeOfInvalidations, MyDatabaseId, MyDatabaseTableSpace, xl_invalidations::nmsgs, xl_invalidations::relcacheInitFileInval, xl_invalidations::tsId, XLOG_INVALIDATIONS, XLogBeginInsert(), XLogInsert(), and XLogRegisterData().

Referenced by RecordTransactionCommit().

LogStandbySnapshot()

XLogRecPtr LogStandbySnapshot

(

void

)

Definition at line 1281 of file standby.c.

{
    XLogRecPtr  recptr;
    RunningTransactions running;
    xl_standby_lock *locks;
    int         nlocks;
 
    Assert(XLogStandbyInfoActive());
 
    /*
     * 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 (wal_level < WAL_LEVEL_LOGICAL)
        LWLockRelease(ProcArrayLock);
 
    recptr = LogCurrentRunningXacts(running);
 
    /* Release lock if we kept it longer ... */
    if (wal_level >= WAL_LEVEL_LOGICAL)
        LWLockRelease(ProcArrayLock);
 
    /* GetRunningTransactionData() acquired XidGenLock, we must release it */
    LWLockRelease(XidGenLock);
 
    return recptr;
}

References Assert, GetRunningTransactionData(), GetRunningTransactionLocks(), LogAccessExclusiveLocks(), LogCurrentRunningXacts(), LWLockRelease(), pfree(), wal_level, WAL_LEVEL_LOGICAL, and XLogStandbyInfoActive.

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

ResolveRecoveryConflictWithBufferPin()

void ResolveRecoveryConflictWithBufferPin

(

void

)

Definition at line 792 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(PROCSIG_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_PIN);
 
    if (got_standby_delay_timeout)
        SendRecoveryConflictWithBufferPin(PROCSIG_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(PROCSIG_RECOVERY_CONFLICT_STARTUP_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, EnableTimeoutParams::delay_ms, disable_all_timeouts(), enable_timeouts(), EnableTimeoutParams::fin_time, GetCurrentTimestamp(), GetStandbyLimitTime(), got_standby_deadlock_timeout, got_standby_delay_timeout, EnableTimeoutParams::id, InHotStandby, PROCSIG_RECOVERY_CONFLICT_BUFFERPIN, PROCSIG_RECOVERY_CONFLICT_STARTUP_DEADLOCK, ProcWaitForSignal(), SendRecoveryConflictWithBufferPin(), STANDBY_DEADLOCK_TIMEOUT, STANDBY_TIMEOUT, TMPARAM_AFTER, TMPARAM_AT, and EnableTimeoutParams::type.

Referenced by LockBufferForCleanup().

ResolveRecoveryConflictWithDatabase()

void ResolveRecoveryConflictWithDatabase

(

Oid

dbid

)

Definition at line 568 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)
    {
        CancelDBBackends(dbid, PROCSIG_RECOVERY_CONFLICT_DATABASE, true);
 
        /*
         * Wait awhile for them to die so that we avoid flooding an
         * unresponsive backend when system is heavily loaded.
         */
        pg_usleep(10000);
    }
}

References CancelDBBackends(), CountDBBackends(), pg_usleep(), and PROCSIG_RECOVERY_CONFLICT_DATABASE.

Referenced by dbase_redo().

ResolveRecoveryConflictWithLock()

void ResolveRecoveryConflictWithLock	(	LOCKTAG	locktag,
		bool	logging_conflict
	)

Definition at line 622 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,
                                               PROCSIG_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))
        {
            SignalVirtualTransaction(*backends,
                                     PROCSIG_RECOVERY_CONFLICT_STARTUP_DEADLOCK,
                                     false);
            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, EnableTimeoutParams::delay_ms, disable_all_timeouts(), enable_timeouts(), EnableTimeoutParams::fin_time, 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, PROCSIG_RECOVERY_CONFLICT_LOCK, PROCSIG_RECOVERY_CONFLICT_STARTUP_DEADLOCK, ProcWaitForSignal(), ResolveRecoveryConflictWithVirtualXIDs(), SignalVirtualTransaction(), STANDBY_DEADLOCK_TIMEOUT, STANDBY_LOCK_TIMEOUT, TMPARAM_AFTER, TMPARAM_AT, EnableTimeoutParams::type, VirtualTransactionIdIsValid, and PGPROC::waitStart.

Referenced by ProcSleep().

ResolveRecoveryConflictWithSnapshot()

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

Definition at line 467 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,
                                           PROCSIG_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 (wal_level >= WAL_LEVEL_LOGICAL && isCatalogRel)
        InvalidateObsoleteReplicationSlots(RS_INVAL_HORIZON, 0, locator.dbOid,
                                           snapshotConflictHorizon);
}

References Assert, RelFileLocator::dbOid, GetConflictingVirtualXIDs(), InvalidateObsoleteReplicationSlots(), PROCSIG_RECOVERY_CONFLICT_SNAPSHOT, ResolveRecoveryConflictWithVirtualXIDs(), RS_INVAL_HORIZON, TransactionIdIsNormal, TransactionIdIsValid, wal_level, and WAL_LEVEL_LOGICAL.

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
	)

Definition at line 511 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 MaxTransactionId, ReadNextFullTransactionId(), ResolveRecoveryConflictWithSnapshot(), U64FromFullTransactionId, and XidFromFullTransactionId.

Referenced by btree_xlog_reuse_page(), and gistRedoPageReuse().

ResolveRecoveryConflictWithTablespace()

void ResolveRecoveryConflictWithTablespace

(

Oid

tsid

)

Definition at line 538 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,
                                           PROCSIG_RECOVERY_CONFLICT_TABLESPACE,
                                           WAIT_EVENT_RECOVERY_CONFLICT_TABLESPACE,
                                           true);
}

References GetConflictingVirtualXIDs(), InvalidOid, InvalidTransactionId, PROCSIG_RECOVERY_CONFLICT_TABLESPACE, and ResolveRecoveryConflictWithVirtualXIDs().

Referenced by tblspc_redo().

ShutdownRecoveryTransactionEnvironment()

void ShutdownRecoveryTransactionEnvironment

(

void

)

Definition at line 160 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(), hash_destroy(), RecoveryLockHash, RecoveryLockXidHash, StandbyReleaseAllLocks(), and VirtualXactLockTableCleanup().

Referenced by StartupProcExit(), and StartupXLOG().

StandbyAcquireAccessExclusiveLock()

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

Definition at line 985 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, DEBUG4, elog, HASH_ENTER, hash_search(), RecoveryLockXidEntry::head, sort-test::key, LockAcquire(), RecoveryLockEntry::next, OidIsValid, RecoveryLockHash, RecoveryLockXidHash, SET_LOCKTAG_RELATION, TransactionIdDidAbort(), TransactionIdDidCommit(), TransactionIdIsValid, and RecoveryLockXidEntry::xid.

Referenced by lock_twophase_standby_recover(), and standby_redo().

StandbyDeadLockHandler()

void StandbyDeadLockHandler

(

void

)

Definition at line 935 of file standby.c.

{
    got_standby_deadlock_timeout = true;
}

References got_standby_deadlock_timeout.

Referenced by StartupProcessMain().

StandbyLockTimeoutHandler()

void StandbyLockTimeoutHandler

(

void

)

Definition at line 953 of file standby.c.

{
    got_standby_lock_timeout = true;
}

References got_standby_lock_timeout.

Referenced by StartupProcessMain().

StandbyReleaseAllLocks()

void StandbyReleaseAllLocks

(

void

)

Definition at line 1105 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, 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
	)

Definition at line 1091 of file standby.c.

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

References i, and StandbyReleaseLocks().

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

StandbyReleaseOldLocks()

void StandbyReleaseOldLocks

(

TransactionId

oldxid

)

Definition at line 1129 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, 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

)

Definition at line 944 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 41 of file standby.c.

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

max_standby_archive_delay

PGDLLIMPORT int max_standby_archive_delay

extern

Definition at line 39 of file standby.c.

Referenced by GetStandbyLimitTime().

max_standby_streaming_delay

PGDLLIMPORT int max_standby_streaming_delay

extern

Definition at line 40 of file standby.c.

Referenced by GetStandbyLimitTime().