standby.c File Reference

#include "postgres.h"
#include "access/transam.h"
#include "access/twophase.h"
#include "access/xact.h"
#include "access/xloginsert.h"
#include "access/xlogrecovery.h"
#include "access/xlogutils.h"
#include "miscadmin.h"
#include "pgstat.h"
#include "storage/bufmgr.h"
#include "storage/lmgr.h"
#include "storage/proc.h"
#include "storage/procarray.h"
#include "storage/sinvaladt.h"
#include "storage/standby.h"
#include "utils/hsearch.h"
#include "utils/memutils.h"
#include "utils/ps_status.h"
#include "utils/timeout.h"
#include "utils/timestamp.h"

Include dependency graph for standby.c:

Go to the source code of this file.

Data Structures
struct	RecoveryLockEntry
struct	RecoveryLockXidEntry

Macros
#define	STANDBY_INITIAL_WAIT_US   1000

Typedefs
typedef struct RecoveryLockEntry	RecoveryLockEntry
typedef struct RecoveryLockXidEntry	RecoveryLockXidEntry

Functions
static void	ResolveRecoveryConflictWithVirtualXIDs (VirtualTransactionId *waitlist, ProcSignalReason reason, uint32 wait_event_info, bool report_waiting)
static void	SendRecoveryConflictWithBufferPin (ProcSignalReason reason)
static XLogRecPtr	LogCurrentRunningXacts (RunningTransactions CurrRunningXacts)
static void	LogAccessExclusiveLocks (int nlocks, xl_standby_lock *locks)
static const char *	get_recovery_conflict_desc (ProcSignalReason reason)
void	InitRecoveryTransactionEnvironment (void)
void	ShutdownRecoveryTransactionEnvironment (void)
static TimestampTz	GetStandbyLimitTime (void)
static bool	WaitExceedsMaxStandbyDelay (uint32 wait_event_info)
void	LogRecoveryConflict (ProcSignalReason reason, TimestampTz wait_start, TimestampTz now, VirtualTransactionId *wait_list, bool still_waiting)
void	ResolveRecoveryConflictWithSnapshot (TransactionId snapshotConflictHorizon, RelFileLocator locator)
void	ResolveRecoveryConflictWithSnapshotFullXid (FullTransactionId snapshotConflictHorizon, 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	StandbyAcquireAccessExclusiveLock (TransactionId xid, Oid dbOid, Oid relOid)
static void	StandbyReleaseXidEntryLocks (RecoveryLockXidEntry *xidentry)
static void	StandbyReleaseLocks (TransactionId xid)
void	StandbyReleaseLockTree (TransactionId xid, int nsubxids, TransactionId *subxids)
void	StandbyReleaseAllLocks (void)
void	StandbyReleaseOldLocks (TransactionId oldxid)
void	standby_redo (XLogReaderState *record)
XLogRecPtr	LogStandbySnapshot (void)
void	LogAccessExclusiveLock (Oid dbOid, Oid relOid)
void	LogAccessExclusiveLockPrepare (void)
void	LogStandbyInvalidations (int nmsgs, SharedInvalidationMessage *msgs, bool relcacheInitFileInval)

Variables
int	vacuum_defer_cleanup_age
int	max_standby_archive_delay = 30 * 1000
int	max_standby_streaming_delay = 30 * 1000
bool	log_recovery_conflict_waits = false
static HTAB *	RecoveryLockHash = NULL
static HTAB *	RecoveryLockXidHash = NULL
static volatile sig_atomic_t	got_standby_deadlock_timeout = false
static volatile sig_atomic_t	got_standby_delay_timeout = false
static volatile sig_atomic_t	got_standby_lock_timeout = false
static int	standbyWait_us = STANDBY_INITIAL_WAIT_US

Macro Definition Documentation

STANDBY_INITIAL_WAIT_US

#define STANDBY_INITIAL_WAIT_US   1000

Definition at line 225 of file standby.c.

Typedef Documentation

RecoveryLockEntry

typedef struct RecoveryLockEntry RecoveryLockEntry

RecoveryLockXidEntry

typedef struct RecoveryLockXidEntry RecoveryLockXidEntry

Function Documentation

CheckRecoveryConflictDeadlock()

void CheckRecoveryConflictDeadlock

(

void

)

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

get_recovery_conflict_desc()

static const char * get_recovery_conflict_desc ( ProcSignalReason  reason )

static

Definition at line 1463 of file standby.c.

{
    const char *reasonDesc = _("unknown reason");
 
    switch (reason)
    {
        case PROCSIG_RECOVERY_CONFLICT_BUFFERPIN:
            reasonDesc = _("recovery conflict on buffer pin");
            break;
        case PROCSIG_RECOVERY_CONFLICT_LOCK:
            reasonDesc = _("recovery conflict on lock");
            break;
        case PROCSIG_RECOVERY_CONFLICT_TABLESPACE:
            reasonDesc = _("recovery conflict on tablespace");
            break;
        case PROCSIG_RECOVERY_CONFLICT_SNAPSHOT:
            reasonDesc = _("recovery conflict on snapshot");
            break;
        case PROCSIG_RECOVERY_CONFLICT_STARTUP_DEADLOCK:
            reasonDesc = _("recovery conflict on buffer deadlock");
            break;
        case PROCSIG_RECOVERY_CONFLICT_DATABASE:
            reasonDesc = _("recovery conflict on database");
            break;
        default:
            break;
    }
 
    return reasonDesc;
}

References _, PROCSIG_RECOVERY_CONFLICT_BUFFERPIN, PROCSIG_RECOVERY_CONFLICT_DATABASE, PROCSIG_RECOVERY_CONFLICT_LOCK, PROCSIG_RECOVERY_CONFLICT_SNAPSHOT, PROCSIG_RECOVERY_CONFLICT_STARTUP_DEADLOCK, and PROCSIG_RECOVERY_CONFLICT_TABLESPACE.

Referenced by LogRecoveryConflict().

GetStandbyLimitTime()

static TimestampTz GetStandbyLimitTime ( void  )

static

Definition at line 201 of file standby.c.

{
    TimestampTz rtime;
    bool        fromStream;
 
    /*
     * The cutoff time is the last WAL data receipt time plus the appropriate
     * delay variable.  Delay of -1 means wait forever.
     */
    GetXLogReceiptTime(&rtime, &fromStream);
    if (fromStream)
    {
        if (max_standby_streaming_delay < 0)
            return 0;           /* wait forever */
        return TimestampTzPlusMilliseconds(rtime, max_standby_streaming_delay);
    }
    else
    {
        if (max_standby_archive_delay < 0)
            return 0;           /* wait forever */
        return TimestampTzPlusMilliseconds(rtime, max_standby_archive_delay);
    }
}

References GetXLogReceiptTime(), max_standby_archive_delay, max_standby_streaming_delay, and TimestampTzPlusMilliseconds.

Referenced by ResolveRecoveryConflictWithBufferPin(), ResolveRecoveryConflictWithLock(), and WaitExceedsMaxStandbyDelay().

InitRecoveryTransactionEnvironment()

void InitRecoveryTransactionEnvironment

(

void

)

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.
     */
    vxid.backendId = MyBackendId;
    vxid.localTransactionId = GetNextLocalTransactionId();
    VirtualXactLockTableInsert(vxid);
 
    standbyState = STANDBY_INITIALIZED;
}

References Assert(), VirtualTransactionId::backendId, HASHCTL::entrysize, GetNextLocalTransactionId(), HASH_BLOBS, hash_create(), HASH_ELEM, HASHCTL::keysize, VirtualTransactionId::localTransactionId, MyBackendId, RecoveryLockHash, RecoveryLockXidHash, SharedInvalBackendInit(), STANDBY_INITIALIZED, standbyState, and VirtualXactLockTableInsert().

Referenced by StartupXLOG().

LogAccessExclusiveLock()

void LogAccessExclusiveLock	(	Oid	dbOid,
		Oid	relOid
	)

Definition at line 1402 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 1419 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().

LogAccessExclusiveLocks()

static void LogAccessExclusiveLocks ( int  nlocks, xl_standby_lock *  locks  )

static

Definition at line 1384 of file standby.c.

{
    xl_standby_locks xlrec;
 
    xlrec.nlocks = nlocks;
 
    XLogBeginInsert();
    XLogRegisterData((char *) &xlrec, offsetof(xl_standby_locks, locks));
    XLogRegisterData((char *) locks, nlocks * sizeof(xl_standby_lock));
    XLogSetRecordFlags(XLOG_MARK_UNIMPORTANT);
 
    (void) XLogInsert(RM_STANDBY_ID, XLOG_STANDBY_LOCK);
}

References xl_standby_locks::nlocks, XLOG_MARK_UNIMPORTANT, XLOG_STANDBY_LOCK, XLogBeginInsert(), XLogInsert(), XLogRegisterData(), and XLogSetRecordFlags().

Referenced by LogAccessExclusiveLock(), and LogStandbySnapshot().

LogCurrentRunningXacts()

static XLogRecPtr LogCurrentRunningXacts ( RunningTransactions  CurrRunningXacts )

static

Definition at line 1324 of file standby.c.

{
    xl_running_xacts xlrec;
    XLogRecPtr  recptr;
 
    xlrec.xcnt = CurrRunningXacts->xcnt;
    xlrec.subxcnt = CurrRunningXacts->subxcnt;
    xlrec.subxid_overflow = CurrRunningXacts->subxid_overflow;
    xlrec.nextXid = CurrRunningXacts->nextXid;
    xlrec.oldestRunningXid = CurrRunningXacts->oldestRunningXid;
    xlrec.latestCompletedXid = CurrRunningXacts->latestCompletedXid;
 
    /* Header */
    XLogBeginInsert();
    XLogSetRecordFlags(XLOG_MARK_UNIMPORTANT);
    XLogRegisterData((char *) (&xlrec), MinSizeOfXactRunningXacts);
 
    /* array of TransactionIds */
    if (xlrec.xcnt > 0)
        XLogRegisterData((char *) CurrRunningXacts->xids,
                         (xlrec.xcnt + xlrec.subxcnt) * sizeof(TransactionId));
 
    recptr = XLogInsert(RM_STANDBY_ID, XLOG_RUNNING_XACTS);
 
    if (CurrRunningXacts->subxid_overflow)
        elog(trace_recovery(DEBUG2),
             "snapshot of %u running transactions overflowed (lsn %X/%X oldest xid %u latest complete %u next xid %u)",
             CurrRunningXacts->xcnt,
             LSN_FORMAT_ARGS(recptr),
             CurrRunningXacts->oldestRunningXid,
             CurrRunningXacts->latestCompletedXid,
             CurrRunningXacts->nextXid);
    else
        elog(trace_recovery(DEBUG2),
             "snapshot of %u+%u running transaction ids (lsn %X/%X oldest xid %u latest complete %u next xid %u)",
             CurrRunningXacts->xcnt, CurrRunningXacts->subxcnt,
             LSN_FORMAT_ARGS(recptr),
             CurrRunningXacts->oldestRunningXid,
             CurrRunningXacts->latestCompletedXid,
             CurrRunningXacts->nextXid);
 
    /*
     * Ensure running_xacts information is synced to disk not too far in the
     * future. We don't want to stall anything though (i.e. use XLogFlush()),
     * so we let the wal writer do it during normal operation.
     * XLogSetAsyncXactLSN() conveniently will mark the LSN as to-be-synced
     * and nudge the WALWriter into action if sleeping. Check
     * XLogBackgroundFlush() for details why a record might not be flushed
     * without it.
     */
    XLogSetAsyncXactLSN(recptr);
 
    return recptr;
}

References DEBUG2, elog(), RunningTransactionsData::latestCompletedXid, xl_running_xacts::latestCompletedXid, LSN_FORMAT_ARGS, MinSizeOfXactRunningXacts, RunningTransactionsData::nextXid, xl_running_xacts::nextXid, RunningTransactionsData::oldestRunningXid, xl_running_xacts::oldestRunningXid, RunningTransactionsData::subxcnt, xl_running_xacts::subxcnt, RunningTransactionsData::subxid_overflow, xl_running_xacts::subxid_overflow, trace_recovery(), RunningTransactionsData::xcnt, xl_running_xacts::xcnt, RunningTransactionsData::xids, XLOG_MARK_UNIMPORTANT, XLOG_RUNNING_XACTS, XLogBeginInsert(), XLogInsert(), XLogRegisterData(), XLogSetAsyncXactLSN(), and XLogSetRecordFlags().

Referenced by LogStandbySnapshot().

LogRecoveryConflict()

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

Definition at line 274 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 = BackendIdGetProc(vxids->backendId);
 
            /* 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(), VirtualTransactionId::backendId, BackendIdGetProc(), buf, ereport, errdetail_log_plural(), errmsg(), get_recovery_conflict_desc(), initStringInfo(), LOG, now(), pfree(), PGPROC::pid, TimestampDifference(), and VirtualTransactionIdIsValid.

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

LogStandbyInvalidations()

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

Definition at line 1441 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 1264 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(), ReplicationSlotReserveWal(), and SnapBuildWaitSnapshot().

ResolveRecoveryConflictWithBufferPin()

void ResolveRecoveryConflictWithBufferPin

(

void

)

Definition at line 779 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(PG_WAIT_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, PG_WAIT_BUFFER_PIN, 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 555 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 609 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,
		RelFileLocator	locator
	)

Definition at line 468 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);
}

References Assert(), RelFileLocator::dbOid, GetConflictingVirtualXIDs(), PROCSIG_RECOVERY_CONFLICT_SNAPSHOT, ResolveRecoveryConflictWithVirtualXIDs(), TransactionIdIsNormal, TransactionIdIsValid, and WAIT_EVENT_RECOVERY_CONFLICT_SNAPSHOT.

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

ResolveRecoveryConflictWithSnapshotFullXid()

void ResolveRecoveryConflictWithSnapshotFullXid	(	FullTransactionId	snapshotConflictHorizon,
		RelFileLocator	locator
	)

Definition at line 501 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, locator);
    }
}

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

Referenced by btree_xlog_reuse_page(), and gistRedoPageReuse().

ResolveRecoveryConflictWithTablespace()

void ResolveRecoveryConflictWithTablespace

(

Oid

tsid

)

Definition at line 525 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, ResolveRecoveryConflictWithVirtualXIDs(), and WAIT_EVENT_RECOVERY_CONFLICT_TABLESPACE.

Referenced by tblspc_redo().

ResolveRecoveryConflictWithVirtualXIDs()

static void ResolveRecoveryConflictWithVirtualXIDs ( VirtualTransactionId *  waitlist, ProcSignalReason  reason, uint32  wait_event_info, bool  report_waiting  )

static

Definition at line 360 of file standby.c.

{
    TimestampTz waitStart = 0;
    bool        waiting = false;
    bool        logged_recovery_conflict = false;
 
    /* Fast exit, to avoid a kernel call if there's no work to be done. */
    if (!VirtualTransactionIdIsValid(*waitlist))
        return;
 
    /* Set the wait start timestamp for reporting */
    if (report_waiting && (log_recovery_conflict_waits || update_process_title))
        waitStart = GetCurrentTimestamp();
 
    while (VirtualTransactionIdIsValid(*waitlist))
    {
        /* reset standbyWait_us for each xact we wait for */
        standbyWait_us = STANDBY_INITIAL_WAIT_US;
 
        /* wait until the virtual xid is gone */
        while (!VirtualXactLock(*waitlist, false))
        {
            /* Is it time to kill it? */
            if (WaitExceedsMaxStandbyDelay(wait_event_info))
            {
                pid_t       pid;
 
                /*
                 * Now find out who to throw out of the balloon.
                 */
                Assert(VirtualTransactionIdIsValid(*waitlist));
                pid = CancelVirtualTransaction(*waitlist, reason);
 
                /*
                 * Wait a little bit for it to die so that we avoid flooding
                 * an unresponsive backend when system is heavily loaded.
                 */
                if (pid != 0)
                    pg_usleep(5000L);
            }
 
            if (waitStart != 0 && (!logged_recovery_conflict || !waiting))
            {
                TimestampTz now = 0;
                bool        maybe_log_conflict;
                bool        maybe_update_title;
 
                maybe_log_conflict = (log_recovery_conflict_waits && !logged_recovery_conflict);
                maybe_update_title = (update_process_title && !waiting);
 
                /* Get the current timestamp if not report yet */
                if (maybe_log_conflict || maybe_update_title)
                    now = GetCurrentTimestamp();
 
                /*
                 * Report via ps if we have been waiting for more than 500
                 * msec (should that be configurable?)
                 */
                if (maybe_update_title &&
                    TimestampDifferenceExceeds(waitStart, now, 500))
                {
                    set_ps_display_suffix("waiting");
                    waiting = true;
                }
 
                /*
                 * Emit the log message if the startup process is waiting
                 * longer than deadlock_timeout for recovery conflict.
                 */
                if (maybe_log_conflict &&
                    TimestampDifferenceExceeds(waitStart, now, DeadlockTimeout))
                {
                    LogRecoveryConflict(reason, waitStart, now, waitlist, true);
                    logged_recovery_conflict = true;
                }
            }
        }
 
        /* The virtual transaction is gone now, wait for the next one */
        waitlist++;
    }
 
    /*
     * Emit the log message if recovery conflict was resolved but the startup
     * process waited longer than deadlock_timeout for it.
     */
    if (logged_recovery_conflict)
        LogRecoveryConflict(reason, waitStart, GetCurrentTimestamp(),
                            NULL, false);
 
    /* reset ps display to remove the suffix if we added one */
    if (waiting)
        set_ps_display_remove_suffix();
 
}

References Assert(), CancelVirtualTransaction(), DeadlockTimeout, GetCurrentTimestamp(), log_recovery_conflict_waits, LogRecoveryConflict(), now(), pg_usleep(), set_ps_display_remove_suffix(), set_ps_display_suffix(), STANDBY_INITIAL_WAIT_US, standbyWait_us, TimestampDifferenceExceeds(), update_process_title, VirtualTransactionIdIsValid, VirtualXactLock(), WaitExceedsMaxStandbyDelay(), and waiting.

Referenced by ResolveRecoveryConflictWithLock(), ResolveRecoveryConflictWithSnapshot(), and ResolveRecoveryConflictWithTablespace().

SendRecoveryConflictWithBufferPin()

static void SendRecoveryConflictWithBufferPin ( ProcSignalReason  reason )

static

Definition at line 863 of file standby.c.

{
    Assert(reason == PROCSIG_RECOVERY_CONFLICT_BUFFERPIN ||
           reason == PROCSIG_RECOVERY_CONFLICT_STARTUP_DEADLOCK);
 
    /*
     * We send signal to all backends to ask them if they are holding the
     * buffer pin which is delaying the Startup process. We must not set the
     * conflict flag yet, since most backends will be innocent. Let the
     * SIGUSR1 handling in each backend decide their own fate.
     */
    CancelDBBackends(InvalidOid, reason, false);
}

References Assert(), CancelDBBackends(), InvalidOid, PROCSIG_RECOVERY_CONFLICT_BUFFERPIN, and PROCSIG_RECOVERY_CONFLICT_STARTUP_DEADLOCK.

Referenced by ResolveRecoveryConflictWithBufferPin().

ShutdownRecoveryTransactionEnvironment()

void ShutdownRecoveryTransactionEnvironment

(

void

)

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

standby_redo()

void standby_redo

(

XLogReaderState *

record

)

Definition at line 1147 of file standby.c.

{
    uint8       info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
 
    /* Backup blocks are not used in standby records */
    Assert(!XLogRecHasAnyBlockRefs(record));
 
    /* Do nothing if we're not in hot standby mode */
    if (standbyState == STANDBY_DISABLED)
        return;
 
    if (info == XLOG_STANDBY_LOCK)
    {
        xl_standby_locks *xlrec = (xl_standby_locks *) XLogRecGetData(record);
        int         i;
 
        for (i = 0; i < xlrec->nlocks; i++)
            StandbyAcquireAccessExclusiveLock(xlrec->locks[i].xid,
                                              xlrec->locks[i].dbOid,
                                              xlrec->locks[i].relOid);
    }
    else if (info == XLOG_RUNNING_XACTS)
    {
        xl_running_xacts *xlrec = (xl_running_xacts *) XLogRecGetData(record);
        RunningTransactionsData running;
 
        running.xcnt = xlrec->xcnt;
        running.subxcnt = xlrec->subxcnt;
        running.subxid_overflow = xlrec->subxid_overflow;
        running.nextXid = xlrec->nextXid;
        running.latestCompletedXid = xlrec->latestCompletedXid;
        running.oldestRunningXid = xlrec->oldestRunningXid;
        running.xids = xlrec->xids;
 
        ProcArrayApplyRecoveryInfo(&running);
    }
    else if (info == XLOG_INVALIDATIONS)
    {
        xl_invalidations *xlrec = (xl_invalidations *) XLogRecGetData(record);
 
        ProcessCommittedInvalidationMessages(xlrec->msgs,
                                             xlrec->nmsgs,
                                             xlrec->relcacheInitFileInval,
                                             xlrec->dbId,
                                             xlrec->tsId);
    }
    else
        elog(PANIC, "standby_redo: unknown op code %u", info);
}

References Assert(), xl_invalidations::dbId, xl_standby_lock::dbOid, elog(), i, RunningTransactionsData::latestCompletedXid, xl_running_xacts::latestCompletedXid, xl_standby_locks::locks, xl_invalidations::msgs, RunningTransactionsData::nextXid, xl_running_xacts::nextXid, xl_standby_locks::nlocks, xl_invalidations::nmsgs, RunningTransactionsData::oldestRunningXid, xl_running_xacts::oldestRunningXid, PANIC, ProcArrayApplyRecoveryInfo(), ProcessCommittedInvalidationMessages(), xl_invalidations::relcacheInitFileInval, xl_standby_lock::relOid, STANDBY_DISABLED, StandbyAcquireAccessExclusiveLock(), standbyState, RunningTransactionsData::subxcnt, xl_running_xacts::subxcnt, RunningTransactionsData::subxid_overflow, xl_running_xacts::subxid_overflow, xl_invalidations::tsId, RunningTransactionsData::xcnt, xl_running_xacts::xcnt, xl_standby_lock::xid, RunningTransactionsData::xids, xl_running_xacts::xids, XLOG_INVALIDATIONS, XLOG_RUNNING_XACTS, XLOG_STANDBY_LOCK, XLogRecGetData, XLogRecGetInfo, XLogRecHasAnyBlockRefs, and XLR_INFO_MASK.

StandbyAcquireAccessExclusiveLock()

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

Definition at line 972 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(trace_recovery(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, trace_recovery(), TransactionIdDidAbort(), TransactionIdDidCommit(), TransactionIdIsValid, and RecoveryLockXidEntry::xid.

Referenced by lock_twophase_standby_recover(), and standby_redo().

StandbyDeadLockHandler()

void StandbyDeadLockHandler

(

void

)

Definition at line 922 of file standby.c.

{
    got_standby_deadlock_timeout = true;
}

References got_standby_deadlock_timeout.

Referenced by StartupProcessMain().

StandbyLockTimeoutHandler()

void StandbyLockTimeoutHandler

(

void

)

Definition at line 940 of file standby.c.

{
    got_standby_lock_timeout = true;
}

References got_standby_lock_timeout.

Referenced by StartupProcessMain().

StandbyReleaseAllLocks()

void StandbyReleaseAllLocks

(

void

)

Definition at line 1093 of file standby.c.

{
    HASH_SEQ_STATUS status;
    RecoveryLockXidEntry *entry;
 
    elog(trace_recovery(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, StandbyReleaseXidEntryLocks(), status(), and trace_recovery().

Referenced by ShutdownRecoveryTransactionEnvironment(), and StandbyReleaseLocks().

StandbyReleaseLocks()

static void StandbyReleaseLocks ( TransactionId  xid )

static

Definition at line 1055 of file standby.c.

{
    RecoveryLockXidEntry *entry;
 
    if (TransactionIdIsValid(xid))
    {
        if ((entry = hash_search(RecoveryLockXidHash, &xid, HASH_FIND, NULL)))
        {
            StandbyReleaseXidEntryLocks(entry);
            hash_search(RecoveryLockXidHash, entry, HASH_REMOVE, NULL);
        }
    }
    else
        StandbyReleaseAllLocks();
}

References HASH_FIND, HASH_REMOVE, hash_search(), RecoveryLockXidHash, StandbyReleaseAllLocks(), StandbyReleaseXidEntryLocks(), and TransactionIdIsValid.

Referenced by StandbyReleaseLockTree().

StandbyReleaseLockTree()

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

Definition at line 1079 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 1114 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(), status(), TransactionIdIsValid, TransactionIdPrecedes(), and RecoveryLockXidEntry::xid.

Referenced by ProcArrayApplyRecoveryInfo().

StandbyReleaseXidEntryLocks()

static void StandbyReleaseXidEntryLocks ( RecoveryLockXidEntry *  xidentry )

static

Definition at line 1022 of file standby.c.

{
    RecoveryLockEntry *entry;
    RecoveryLockEntry *next;
 
    for (entry = xidentry->head; entry != NULL; entry = next)
    {
        LOCKTAG     locktag;
 
        elog(trace_recovery(DEBUG4),
             "releasing recovery lock: xid %u db %u rel %u",
             entry->key.xid, entry->key.dbOid, entry->key.relOid);
        /* Release the lock ... */
        SET_LOCKTAG_RELATION(locktag, entry->key.dbOid, entry->key.relOid);
        if (!LockRelease(&locktag, AccessExclusiveLock, true))
        {
            elog(LOG,
                 "RecoveryLockHash contains entry for lock no longer recorded by lock manager: xid %u database %u relation %u",
                 entry->key.xid, entry->key.dbOid, entry->key.relOid);
            Assert(false);
        }
        /* ... and remove the per-lock hash entry */
        next = entry->next;
        hash_search(RecoveryLockHash, entry, HASH_REMOVE, NULL);
    }
 
    xidentry->head = NULL;      /* just for paranoia */
}

References AccessExclusiveLock, Assert(), xl_standby_lock::dbOid, DEBUG4, elog(), HASH_REMOVE, hash_search(), RecoveryLockXidEntry::head, RecoveryLockEntry::key, LockRelease(), LOG, next, RecoveryLockEntry::next, RecoveryLockHash, xl_standby_lock::relOid, SET_LOCKTAG_RELATION, trace_recovery(), and xl_standby_lock::xid.

Referenced by StandbyReleaseAllLocks(), StandbyReleaseLocks(), and StandbyReleaseOldLocks().

StandbyTimeoutHandler()

void StandbyTimeoutHandler

(

void

)

Definition at line 931 of file standby.c.

{
    got_standby_delay_timeout = true;
}

References got_standby_delay_timeout.

Referenced by StartupProcessMain().

WaitExceedsMaxStandbyDelay()

static bool WaitExceedsMaxStandbyDelay ( uint32  wait_event_info )

static

Definition at line 234 of file standby.c.

{
    TimestampTz ltime;
 
    CHECK_FOR_INTERRUPTS();
 
    /* Are we past the limit time? */
    ltime = GetStandbyLimitTime();
    if (ltime && GetCurrentTimestamp() >= ltime)
        return true;
 
    /*
     * Sleep a bit (this is essential to avoid busy-waiting).
     */
    pgstat_report_wait_start(wait_event_info);
    pg_usleep(standbyWait_us);
    pgstat_report_wait_end();
 
    /*
     * Progressively increase the sleep times, but not to more than 1s, since
     * pg_usleep isn't interruptible on some platforms.
     */
    standbyWait_us *= 2;
    if (standbyWait_us > 1000000)
        standbyWait_us = 1000000;
 
    return false;
}

References CHECK_FOR_INTERRUPTS, GetCurrentTimestamp(), GetStandbyLimitTime(), pg_usleep(), pgstat_report_wait_end(), pgstat_report_wait_start(), and standbyWait_us.

Referenced by ResolveRecoveryConflictWithVirtualXIDs().

Variable Documentation

got_standby_deadlock_timeout

volatile sig_atomic_t got_standby_deadlock_timeout = false

static

Definition at line 70 of file standby.c.

Referenced by ResolveRecoveryConflictWithBufferPin(), ResolveRecoveryConflictWithLock(), and StandbyDeadLockHandler().

got_standby_delay_timeout

volatile sig_atomic_t got_standby_delay_timeout = false

static

Definition at line 71 of file standby.c.

Referenced by ResolveRecoveryConflictWithBufferPin(), and StandbyTimeoutHandler().

got_standby_lock_timeout

volatile sig_atomic_t got_standby_lock_timeout = false

static

Definition at line 72 of file standby.c.

Referenced by ResolveRecoveryConflictWithLock(), and StandbyLockTimeoutHandler().

log_recovery_conflict_waits

bool log_recovery_conflict_waits = false

Definition at line 43 of file standby.c.

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

max_standby_archive_delay

int max_standby_archive_delay = 30 * 1000

Definition at line 41 of file standby.c.

Referenced by GetStandbyLimitTime().

max_standby_streaming_delay

int max_standby_streaming_delay = 30 * 1000

Definition at line 42 of file standby.c.

Referenced by GetStandbyLimitTime().

RecoveryLockHash

HTAB* RecoveryLockHash = NULL

static

Definition at line 66 of file standby.c.

Referenced by InitRecoveryTransactionEnvironment(), ShutdownRecoveryTransactionEnvironment(), StandbyAcquireAccessExclusiveLock(), and StandbyReleaseXidEntryLocks().

RecoveryLockXidHash

HTAB* RecoveryLockXidHash = NULL

static

Definition at line 67 of file standby.c.

Referenced by InitRecoveryTransactionEnvironment(), ShutdownRecoveryTransactionEnvironment(), StandbyAcquireAccessExclusiveLock(), StandbyReleaseAllLocks(), StandbyReleaseLocks(), and StandbyReleaseOldLocks().

standbyWait_us

int standbyWait_us = STANDBY_INITIAL_WAIT_US

static

Definition at line 226 of file standby.c.

Referenced by ResolveRecoveryConflictWithVirtualXIDs(), and WaitExceedsMaxStandbyDelay().

vacuum_defer_cleanup_age

int vacuum_defer_cleanup_age

Definition at line 40 of file standby.c.

Referenced by ComputeXidHorizons(), and GetSnapshotData().