PostgreSQL Source Code  git master
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 "replication/slot.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, 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 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 max_standby_archive_delay = 30 * 1000
 
int max_standby_streaming_delay = 30 * 1000
 
bool log_recovery_conflict_waits = false
 
static HTABRecoveryLockHash = NULL
 
static HTABRecoveryLockXidHash = 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

◆ RecoveryLockXidEntry

Function Documentation

◆ CheckRecoveryConflictDeadlock()

void CheckRecoveryConflictDeadlock ( void  )

Definition at line 905 of file standby.c.

906 {
907  Assert(!InRecovery); /* do not call in Startup process */
908 
910  return;
911 
912  /*
913  * Error message should match ProcessInterrupts() but we avoid calling
914  * that because we aren't handling an interrupt at this point. Note that
915  * we only cancel the current transaction here, so if we are in a
916  * subtransaction and the pin is held by a parent, then the Startup
917  * process will continue to wait even though we have avoided deadlock.
918  */
919  ereport(ERROR,
921  errmsg("canceling statement due to conflict with recovery"),
922  errdetail("User transaction caused buffer deadlock with recovery.")));
923 }
bool HoldingBufferPinThatDelaysRecovery(void)
Definition: bufmgr.c:4930
int errdetail(const char *fmt,...)
Definition: elog.c:1202
int errcode(int sqlerrcode)
Definition: elog.c:858
int errmsg(const char *fmt,...)
Definition: elog.c:1069
#define ERROR
Definition: elog.h:39
#define ereport(elevel,...)
Definition: elog.h:149
Assert(fmt[strlen(fmt) - 1] !='\n')
#define ERRCODE_T_R_DEADLOCK_DETECTED
Definition: pgbench.c:77
bool InRecovery
Definition: xlogutils.c:53

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 1486 of file standby.c.

1487 {
1488  const char *reasonDesc = _("unknown reason");
1489 
1490  switch (reason)
1491  {
1493  reasonDesc = _("recovery conflict on buffer pin");
1494  break;
1496  reasonDesc = _("recovery conflict on lock");
1497  break;
1499  reasonDesc = _("recovery conflict on tablespace");
1500  break;
1502  reasonDesc = _("recovery conflict on snapshot");
1503  break;
1505  reasonDesc = _("recovery conflict on replication slot");
1506  break;
1508  reasonDesc = _("recovery conflict on buffer deadlock");
1509  break;
1511  reasonDesc = _("recovery conflict on database");
1512  break;
1513  default:
1514  break;
1515  }
1516 
1517  return reasonDesc;
1518 }
#define _(x)
Definition: elog.c:91
@ PROCSIG_RECOVERY_CONFLICT_BUFFERPIN
Definition: procsignal.h:47
@ PROCSIG_RECOVERY_CONFLICT_LOCK
Definition: procsignal.h:44
@ PROCSIG_RECOVERY_CONFLICT_LOGICALSLOT
Definition: procsignal.h:46
@ PROCSIG_RECOVERY_CONFLICT_DATABASE
Definition: procsignal.h:42
@ PROCSIG_RECOVERY_CONFLICT_SNAPSHOT
Definition: procsignal.h:45
@ PROCSIG_RECOVERY_CONFLICT_TABLESPACE
Definition: procsignal.h:43
@ PROCSIG_RECOVERY_CONFLICT_STARTUP_DEADLOCK
Definition: procsignal.h:48

References _, PROCSIG_RECOVERY_CONFLICT_BUFFERPIN, PROCSIG_RECOVERY_CONFLICT_DATABASE, PROCSIG_RECOVERY_CONFLICT_LOCK, PROCSIG_RECOVERY_CONFLICT_LOGICALSLOT, 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.

202 {
203  TimestampTz rtime;
204  bool fromStream;
205 
206  /*
207  * The cutoff time is the last WAL data receipt time plus the appropriate
208  * delay variable. Delay of -1 means wait forever.
209  */
210  GetXLogReceiptTime(&rtime, &fromStream);
211  if (fromStream)
212  {
214  return 0; /* wait forever */
216  }
217  else
218  {
220  return 0; /* wait forever */
222  }
223 }
int64 TimestampTz
Definition: timestamp.h:39
int max_standby_archive_delay
Definition: standby.c:41
int max_standby_streaming_delay
Definition: standby.c:42
#define TimestampTzPlusMilliseconds(tz, ms)
Definition: timestamp.h:85
void GetXLogReceiptTime(TimestampTz *rtime, bool *fromStream)

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.

97 {
99  HASHCTL hash_ctl;
100 
101  Assert(RecoveryLockHash == NULL); /* don't run this twice */
102 
103  /*
104  * Initialize the hash tables for tracking the locks held by each
105  * transaction.
106  */
107  hash_ctl.keysize = sizeof(xl_standby_lock);
108  hash_ctl.entrysize = sizeof(RecoveryLockEntry);
109  RecoveryLockHash = hash_create("RecoveryLockHash",
110  64,
111  &hash_ctl,
113  hash_ctl.keysize = sizeof(TransactionId);
114  hash_ctl.entrysize = sizeof(RecoveryLockXidEntry);
115  RecoveryLockXidHash = hash_create("RecoveryLockXidHash",
116  64,
117  &hash_ctl,
119 
120  /*
121  * Initialize shared invalidation management for Startup process, being
122  * careful to register ourselves as a sendOnly process so we don't need to
123  * read messages, nor will we get signaled when the queue starts filling
124  * up.
125  */
127 
128  /*
129  * Lock a virtual transaction id for Startup process.
130  *
131  * We need to do GetNextLocalTransactionId() because
132  * SharedInvalBackendInit() leaves localTransactionId invalid and the lock
133  * manager doesn't like that at all.
134  *
135  * Note that we don't need to run XactLockTableInsert() because nobody
136  * needs to wait on xids. That sounds a little strange, but table locks
137  * are held by vxids and row level locks are held by xids. All queries
138  * hold AccessShareLocks so never block while we write or lock new rows.
139  */
140  vxid.backendId = MyBackendId;
143 
145 }
uint32 TransactionId
Definition: c.h:641
HTAB * hash_create(const char *tabname, long nelem, const HASHCTL *info, int flags)
Definition: dynahash.c:350
BackendId MyBackendId
Definition: globals.c:85
#define HASH_ELEM
Definition: hsearch.h:95
#define HASH_BLOBS
Definition: hsearch.h:97
void VirtualXactLockTableInsert(VirtualTransactionId vxid)
Definition: lock.c:4388
struct xl_standby_lock xl_standby_lock
void SharedInvalBackendInit(bool sendOnly)
Definition: sinvaladt.c:266
LocalTransactionId GetNextLocalTransactionId(void)
Definition: sinvaladt.c:780
static HTAB * RecoveryLockXidHash
Definition: standby.c:67
struct RecoveryLockEntry RecoveryLockEntry
struct RecoveryLockXidEntry RecoveryLockXidEntry
static HTAB * RecoveryLockHash
Definition: standby.c:66
Size keysize
Definition: hsearch.h:75
Size entrysize
Definition: hsearch.h:76
LocalTransactionId localTransactionId
Definition: lock.h:62
BackendId backendId
Definition: lock.h:61
HotStandbyState standbyState
Definition: xlogutils.c:56
@ STANDBY_INITIALIZED
Definition: xlogutils.h:50

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 1425 of file standby.c.

1426 {
1427  xl_standby_lock xlrec;
1428 
1429  xlrec.xid = GetCurrentTransactionId();
1430 
1431  xlrec.dbOid = dbOid;
1432  xlrec.relOid = relOid;
1433 
1434  LogAccessExclusiveLocks(1, &xlrec);
1436 }
static void LogAccessExclusiveLocks(int nlocks, xl_standby_lock *locks)
Definition: standby.c:1407
TransactionId xid
Definition: lockdefs.h:51
TransactionId GetCurrentTransactionId(void)
Definition: xact.c:445
int MyXactFlags
Definition: xact.c:136
#define XACT_FLAGS_ACQUIREDACCESSEXCLUSIVELOCK
Definition: xact.h:108

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 1442 of file standby.c.

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

References GetCurrentTransactionId().

Referenced by LockAcquireExtended().

◆ LogAccessExclusiveLocks()

static void LogAccessExclusiveLocks ( int  nlocks,
xl_standby_lock locks 
)
static

Definition at line 1407 of file standby.c.

1408 {
1409  xl_standby_locks xlrec;
1410 
1411  xlrec.nlocks = nlocks;
1412 
1413  XLogBeginInsert();
1414  XLogRegisterData((char *) &xlrec, offsetof(xl_standby_locks, locks));
1415  XLogRegisterData((char *) locks, nlocks * sizeof(xl_standby_lock));
1417 
1418  (void) XLogInsert(RM_STANDBY_ID, XLOG_STANDBY_LOCK);
1419 }
#define XLOG_STANDBY_LOCK
Definition: standbydefs.h:34
#define XLOG_MARK_UNIMPORTANT
Definition: xlog.h:150
void XLogRegisterData(char *data, uint32 len)
Definition: xloginsert.c:351
XLogRecPtr XLogInsert(RmgrId rmid, uint8 info)
Definition: xloginsert.c:461
void XLogSetRecordFlags(uint8 flags)
Definition: xloginsert.c:443
void XLogBeginInsert(void)
Definition: xloginsert.c:150

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 1347 of file standby.c.

1348 {
1349  xl_running_xacts xlrec;
1350  XLogRecPtr recptr;
1351 
1352  xlrec.xcnt = CurrRunningXacts->xcnt;
1353  xlrec.subxcnt = CurrRunningXacts->subxcnt;
1354  xlrec.subxid_overflow = CurrRunningXacts->subxid_overflow;
1355  xlrec.nextXid = CurrRunningXacts->nextXid;
1356  xlrec.oldestRunningXid = CurrRunningXacts->oldestRunningXid;
1357  xlrec.latestCompletedXid = CurrRunningXacts->latestCompletedXid;
1358 
1359  /* Header */
1360  XLogBeginInsert();
1362  XLogRegisterData((char *) (&xlrec), MinSizeOfXactRunningXacts);
1363 
1364  /* array of TransactionIds */
1365  if (xlrec.xcnt > 0)
1366  XLogRegisterData((char *) CurrRunningXacts->xids,
1367  (xlrec.xcnt + xlrec.subxcnt) * sizeof(TransactionId));
1368 
1369  recptr = XLogInsert(RM_STANDBY_ID, XLOG_RUNNING_XACTS);
1370 
1371  if (CurrRunningXacts->subxid_overflow)
1373  "snapshot of %d running transactions overflowed (lsn %X/%X oldest xid %u latest complete %u next xid %u)",
1374  CurrRunningXacts->xcnt,
1375  LSN_FORMAT_ARGS(recptr),
1376  CurrRunningXacts->oldestRunningXid,
1377  CurrRunningXacts->latestCompletedXid,
1378  CurrRunningXacts->nextXid);
1379  else
1381  "snapshot of %d+%d running transaction ids (lsn %X/%X oldest xid %u latest complete %u next xid %u)",
1382  CurrRunningXacts->xcnt, CurrRunningXacts->subxcnt,
1383  LSN_FORMAT_ARGS(recptr),
1384  CurrRunningXacts->oldestRunningXid,
1385  CurrRunningXacts->latestCompletedXid,
1386  CurrRunningXacts->nextXid);
1387 
1388  /*
1389  * Ensure running_xacts information is synced to disk not too far in the
1390  * future. We don't want to stall anything though (i.e. use XLogFlush()),
1391  * so we let the wal writer do it during normal operation.
1392  * XLogSetAsyncXactLSN() conveniently will mark the LSN as to-be-synced
1393  * and nudge the WALWriter into action if sleeping. Check
1394  * XLogBackgroundFlush() for details why a record might not be flushed
1395  * without it.
1396  */
1397  XLogSetAsyncXactLSN(recptr);
1398 
1399  return recptr;
1400 }
int trace_recovery(int trace_level)
Definition: elog.c:3752
#define DEBUG2
Definition: elog.h:29
#define MinSizeOfXactRunningXacts
Definition: standby.h:63
#define XLOG_RUNNING_XACTS
Definition: standbydefs.h:35
TransactionId oldestRunningXid
Definition: standby.h:84
TransactionId nextXid
Definition: standby.h:83
TransactionId latestCompletedXid
Definition: standby.h:85
TransactionId * xids
Definition: standby.h:87
TransactionId latestCompletedXid
Definition: standbydefs.h:54
TransactionId oldestRunningXid
Definition: standbydefs.h:53
TransactionId nextXid
Definition: standbydefs.h:52
void XLogSetAsyncXactLSN(XLogRecPtr asyncXactLSN)
Definition: xlog.c:2380
#define LSN_FORMAT_ARGS(lsn)
Definition: xlogdefs.h:43
uint64 XLogRecPtr
Definition: xlogdefs.h:21

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.

277 {
278  long secs;
279  int usecs;
280  long msecs;
282  int nprocs = 0;
283 
284  /*
285  * There must be no conflicting processes when the recovery conflict has
286  * already been resolved.
287  */
288  Assert(still_waiting || wait_list == NULL);
289 
290  TimestampDifference(wait_start, now, &secs, &usecs);
291  msecs = secs * 1000 + usecs / 1000;
292  usecs = usecs % 1000;
293 
294  if (wait_list)
295  {
296  VirtualTransactionId *vxids;
297 
298  /* Construct a string of list of the conflicting processes */
299  vxids = wait_list;
300  while (VirtualTransactionIdIsValid(*vxids))
301  {
302  PGPROC *proc = BackendIdGetProc(vxids->backendId);
303 
304  /* proc can be NULL if the target backend is not active */
305  if (proc)
306  {
307  if (nprocs == 0)
308  {
310  appendStringInfo(&buf, "%d", proc->pid);
311  }
312  else
313  appendStringInfo(&buf, ", %d", proc->pid);
314 
315  nprocs++;
316  }
317 
318  vxids++;
319  }
320  }
321 
322  /*
323  * If wait_list is specified, report the list of PIDs of active
324  * conflicting backends in a detail message. Note that if all the backends
325  * in the list are not active, no detail message is logged.
326  */
327  if (still_waiting)
328  {
329  ereport(LOG,
330  errmsg("recovery still waiting after %ld.%03d ms: %s",
331  msecs, usecs, get_recovery_conflict_desc(reason)),
332  nprocs > 0 ? errdetail_log_plural("Conflicting process: %s.",
333  "Conflicting processes: %s.",
334  nprocs, buf.data) : 0);
335  }
336  else
337  {
338  ereport(LOG,
339  errmsg("recovery finished waiting after %ld.%03d ms: %s",
340  msecs, usecs, get_recovery_conflict_desc(reason)));
341  }
342 
343  if (nprocs > 0)
344  pfree(buf.data);
345 }
void TimestampDifference(TimestampTz start_time, TimestampTz stop_time, long *secs, int *microsecs)
Definition: timestamp.c:1659
Datum now(PG_FUNCTION_ARGS)
Definition: timestamp.c:1547
int errdetail_log_plural(const char *fmt_singular, const char *fmt_plural, unsigned long n,...)
Definition: elog.c:1271
#define LOG
Definition: elog.h:31
#define VirtualTransactionIdIsValid(vxid)
Definition: lock.h:67
void pfree(void *pointer)
Definition: mcxt.c:1456
static char * buf
Definition: pg_test_fsync.c:67
PGPROC * BackendIdGetProc(int backendID)
Definition: sinvaladt.c:385
static const char * get_recovery_conflict_desc(ProcSignalReason reason)
Definition: standby.c:1486
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition: stringinfo.c:91
void initStringInfo(StringInfo str)
Definition: stringinfo.c:59
Definition: proc.h:162
int pid
Definition: proc.h:186

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 1464 of file standby.c.

1466 {
1467  xl_invalidations xlrec;
1468 
1469  /* prepare record */
1470  memset(&xlrec, 0, sizeof(xlrec));
1471  xlrec.dbId = MyDatabaseId;
1472  xlrec.tsId = MyDatabaseTableSpace;
1473  xlrec.relcacheInitFileInval = relcacheInitFileInval;
1474  xlrec.nmsgs = nmsgs;
1475 
1476  /* perform insertion */
1477  XLogBeginInsert();
1478  XLogRegisterData((char *) (&xlrec), MinSizeOfInvalidations);
1479  XLogRegisterData((char *) msgs,
1480  nmsgs * sizeof(SharedInvalidationMessage));
1481  XLogInsert(RM_STANDBY_ID, XLOG_INVALIDATIONS);
1482 }
Oid MyDatabaseTableSpace
Definition: globals.c:91
Oid MyDatabaseId
Definition: globals.c:89
#define XLOG_INVALIDATIONS
Definition: standbydefs.h:36
#define MinSizeOfInvalidations
Definition: standbydefs.h:72
bool relcacheInitFileInval
Definition: standbydefs.h:67

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 1287 of file standby.c.

1288 {
1289  XLogRecPtr recptr;
1290  RunningTransactions running;
1291  xl_standby_lock *locks;
1292  int nlocks;
1293 
1295 
1296  /*
1297  * Get details of any AccessExclusiveLocks being held at the moment.
1298  */
1299  locks = GetRunningTransactionLocks(&nlocks);
1300  if (nlocks > 0)
1301  LogAccessExclusiveLocks(nlocks, locks);
1302  pfree(locks);
1303 
1304  /*
1305  * Log details of all in-progress transactions. This should be the last
1306  * record we write, because standby will open up when it sees this.
1307  */
1308  running = GetRunningTransactionData();
1309 
1310  /*
1311  * GetRunningTransactionData() acquired ProcArrayLock, we must release it.
1312  * For Hot Standby this can be done before inserting the WAL record
1313  * because ProcArrayApplyRecoveryInfo() rechecks the commit status using
1314  * the clog. For logical decoding, though, the lock can't be released
1315  * early because the clog might be "in the future" from the POV of the
1316  * historic snapshot. This would allow for situations where we're waiting
1317  * for the end of a transaction listed in the xl_running_xacts record
1318  * which, according to the WAL, has committed before the xl_running_xacts
1319  * record. Fortunately this routine isn't executed frequently, and it's
1320  * only a shared lock.
1321  */
1323  LWLockRelease(ProcArrayLock);
1324 
1325  recptr = LogCurrentRunningXacts(running);
1326 
1327  /* Release lock if we kept it longer ... */
1329  LWLockRelease(ProcArrayLock);
1330 
1331  /* GetRunningTransactionData() acquired XidGenLock, we must release it */
1332  LWLockRelease(XidGenLock);
1333 
1334  return recptr;
1335 }
xl_standby_lock * GetRunningTransactionLocks(int *nlocks)
Definition: lock.c:3939
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1808
RunningTransactions GetRunningTransactionData(void)
Definition: procarray.c:2670
static XLogRecPtr LogCurrentRunningXacts(RunningTransactions CurrRunningXacts)
Definition: standby.c:1347
int wal_level
Definition: xlog.c:134
@ WAL_LEVEL_LOGICAL
Definition: xlog.h:71
#define XLogStandbyInfoActive()
Definition: xlog.h:118

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 793 of file standby.c.

794 {
795  TimestampTz ltime;
796 
798 
799  ltime = GetStandbyLimitTime();
800 
801  if (GetCurrentTimestamp() >= ltime && ltime != 0)
802  {
803  /*
804  * We're already behind, so clear a path as quickly as possible.
805  */
807  }
808  else
809  {
810  /*
811  * Wake up at ltime, and check for deadlocks as well if we will be
812  * waiting longer than deadlock_timeout
813  */
814  EnableTimeoutParams timeouts[2];
815  int cnt = 0;
816 
817  if (ltime != 0)
818  {
819  timeouts[cnt].id = STANDBY_TIMEOUT;
820  timeouts[cnt].type = TMPARAM_AT;
821  timeouts[cnt].fin_time = ltime;
822  cnt++;
823  }
824 
826  timeouts[cnt].id = STANDBY_DEADLOCK_TIMEOUT;
827  timeouts[cnt].type = TMPARAM_AFTER;
828  timeouts[cnt].delay_ms = DeadlockTimeout;
829  cnt++;
830 
831  enable_timeouts(timeouts, cnt);
832  }
833 
834  /*
835  * Wait to be signaled by UnpinBuffer() or for the wait to be interrupted
836  * by one of the timeouts established above.
837  *
838  * We assume that only UnpinBuffer() and the timeout requests established
839  * above can wake us up here. WakeupRecovery() called by walreceiver or
840  * SIGHUP signal handler, etc cannot do that because it uses the different
841  * latch from that ProcWaitForSignal() waits on.
842  */
843  ProcWaitForSignal(WAIT_EVENT_BUFFER_PIN);
844 
848  {
849  /*
850  * Send out a request for hot-standby backends to check themselves for
851  * deadlocks.
852  *
853  * XXX The subsequent ResolveRecoveryConflictWithBufferPin() will wait
854  * to be signaled by UnpinBuffer() again and send a request for
855  * deadlocks check if deadlock_timeout happens. This causes the
856  * request to continue to be sent every deadlock_timeout until the
857  * buffer is unpinned or ltime is reached. This would increase the
858  * workload in the startup process and backends. In practice it may
859  * not be so harmful because the period that the buffer is kept pinned
860  * is basically no so long. But we should fix this?
861  */
863  }
864 
865  /*
866  * Clear any timeout requests established above. We assume here that the
867  * Startup process doesn't have any other timeouts than what this function
868  * uses. If that stops being true, we could cancel the timeouts
869  * individually, but that'd be slower.
870  */
871  disable_all_timeouts(false);
874 }
TimestampTz GetCurrentTimestamp(void)
Definition: timestamp.c:1583
int DeadlockTimeout
Definition: proc.c:58
void ProcWaitForSignal(uint32 wait_event_info)
Definition: proc.c:1797
static volatile sig_atomic_t got_standby_deadlock_timeout
Definition: standby.c:70
static TimestampTz GetStandbyLimitTime(void)
Definition: standby.c:201
static volatile sig_atomic_t got_standby_delay_timeout
Definition: standby.c:71
static void SendRecoveryConflictWithBufferPin(ProcSignalReason reason)
Definition: standby.c:877
TimeoutType type
Definition: timeout.h:60
TimestampTz fin_time
Definition: timeout.h:62
TimeoutId id
Definition: timeout.h:59
void disable_all_timeouts(bool keep_indicators)
Definition: timeout.c:755
void enable_timeouts(const EnableTimeoutParams *timeouts, int count)
Definition: timeout.c:634
@ STANDBY_DEADLOCK_TIMEOUT
Definition: timeout.h:30
@ STANDBY_TIMEOUT
Definition: timeout.h:31
@ TMPARAM_AT
Definition: timeout.h:53
@ TMPARAM_AFTER
Definition: timeout.h:52
#define InHotStandby
Definition: xlogutils.h:57

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 569 of file standby.c.

570 {
571  /*
572  * We don't do ResolveRecoveryConflictWithVirtualXIDs() here since that
573  * only waits for transactions and completely idle sessions would block
574  * us. This is rare enough that we do this as simply as possible: no wait,
575  * just force them off immediately.
576  *
577  * No locking is required here because we already acquired
578  * AccessExclusiveLock. Anybody trying to connect while we do this will
579  * block during InitPostgres() and then disconnect when they see the
580  * database has been removed.
581  */
582  while (CountDBBackends(dbid) > 0)
583  {
585 
586  /*
587  * Wait awhile for them to die so that we avoid flooding an
588  * unresponsive backend when system is heavily loaded.
589  */
590  pg_usleep(10000);
591  }
592 }
void CancelDBBackends(Oid databaseid, ProcSignalReason sigmode, bool conflictPending)
Definition: procarray.c:3567
int CountDBBackends(Oid databaseid)
Definition: procarray.c:3506
void pg_usleep(long microsec)
Definition: signal.c:53

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 623 of file standby.c.

624 {
625  TimestampTz ltime;
627 
629 
630  ltime = GetStandbyLimitTime();
632 
633  /*
634  * Update waitStart if first time through after the startup process
635  * started waiting for the lock. It should not be updated every time
636  * ResolveRecoveryConflictWithLock() is called during the wait.
637  *
638  * Use the current time obtained for comparison with ltime as waitStart
639  * (i.e., the time when this process started waiting for the lock). Since
640  * getting the current time newly can cause overhead, we reuse the
641  * already-obtained time to avoid that overhead.
642  *
643  * Note that waitStart is updated without holding the lock table's
644  * partition lock, to avoid the overhead by additional lock acquisition.
645  * This can cause "waitstart" in pg_locks to become NULL for a very short
646  * period of time after the wait started even though "granted" is false.
647  * This is OK in practice because we can assume that users are likely to
648  * look at "waitstart" when waiting for the lock for a long time.
649  */
650  if (pg_atomic_read_u64(&MyProc->waitStart) == 0)
652 
653  if (now >= ltime && ltime != 0)
654  {
655  /*
656  * We're already behind, so clear a path as quickly as possible.
657  */
658  VirtualTransactionId *backends;
659 
660  backends = GetLockConflicts(&locktag, AccessExclusiveLock, NULL);
661 
662  /*
663  * Prevent ResolveRecoveryConflictWithVirtualXIDs() from reporting
664  * "waiting" in PS display by disabling its argument report_waiting
665  * because the caller, WaitOnLock(), has already reported that.
666  */
669  PG_WAIT_LOCK | locktag.locktag_type,
670  false);
671  }
672  else
673  {
674  /*
675  * Wait (or wait again) until ltime, and check for deadlocks as well
676  * if we will be waiting longer than deadlock_timeout
677  */
678  EnableTimeoutParams timeouts[2];
679  int cnt = 0;
680 
681  if (ltime != 0)
682  {
683  got_standby_lock_timeout = false;
684  timeouts[cnt].id = STANDBY_LOCK_TIMEOUT;
685  timeouts[cnt].type = TMPARAM_AT;
686  timeouts[cnt].fin_time = ltime;
687  cnt++;
688  }
689 
691  timeouts[cnt].id = STANDBY_DEADLOCK_TIMEOUT;
692  timeouts[cnt].type = TMPARAM_AFTER;
693  timeouts[cnt].delay_ms = DeadlockTimeout;
694  cnt++;
695 
696  enable_timeouts(timeouts, cnt);
697  }
698 
699  /* Wait to be signaled by the release of the Relation Lock */
701 
702  /*
703  * Exit if ltime is reached. Then all the backends holding conflicting
704  * locks will be canceled in the next ResolveRecoveryConflictWithLock()
705  * call.
706  */
708  goto cleanup;
709 
711  {
712  VirtualTransactionId *backends;
713 
714  backends = GetLockConflicts(&locktag, AccessExclusiveLock, NULL);
715 
716  /* Quick exit if there's no work to be done */
717  if (!VirtualTransactionIdIsValid(*backends))
718  goto cleanup;
719 
720  /*
721  * Send signals to all the backends holding the conflicting locks, to
722  * ask them to check themselves for deadlocks.
723  */
724  while (VirtualTransactionIdIsValid(*backends))
725  {
726  SignalVirtualTransaction(*backends,
728  false);
729  backends++;
730  }
731 
732  /*
733  * Exit if the recovery conflict has not been logged yet even though
734  * logging is enabled, so that the caller can log that. Then
735  * RecoveryConflictWithLock() is called again and we will wait again
736  * for the lock to be released.
737  */
738  if (logging_conflict)
739  goto cleanup;
740 
741  /*
742  * Wait again here to be signaled by the release of the Relation Lock,
743  * to prevent the subsequent RecoveryConflictWithLock() from causing
744  * deadlock_timeout and sending a request for deadlocks check again.
745  * Otherwise the request continues to be sent every deadlock_timeout
746  * until the relation locks are released or ltime is reached.
747  */
750  }
751 
752 cleanup:
753 
754  /*
755  * Clear any timeout requests established above. We assume here that the
756  * Startup process doesn't have any other outstanding timeouts than those
757  * used by this function. If that stops being true, we could cancel the
758  * timeouts individually, but that'd be slower.
759  */
760  disable_all_timeouts(false);
761  got_standby_lock_timeout = false;
763 }
static void pg_atomic_write_u64(volatile pg_atomic_uint64 *ptr, uint64 val)
Definition: atomics.h:433
static uint64 pg_atomic_read_u64(volatile pg_atomic_uint64 *ptr)
Definition: atomics.h:424
static void cleanup(void)
Definition: bootstrap.c:687
VirtualTransactionId * GetLockConflicts(const LOCKTAG *locktag, LOCKMODE lockmode, int *countp)
Definition: lock.c:2855
#define AccessExclusiveLock
Definition: lockdefs.h:43
pid_t SignalVirtualTransaction(VirtualTransactionId vxid, ProcSignalReason sigmode, bool conflictPending)
Definition: procarray.c:3404
PGPROC * MyProc
Definition: proc.c:66
static void ResolveRecoveryConflictWithVirtualXIDs(VirtualTransactionId *waitlist, ProcSignalReason reason, uint32 wait_event_info, bool report_waiting)
Definition: standby.c:360
static volatile sig_atomic_t got_standby_lock_timeout
Definition: standby.c:72
uint8 locktag_type
Definition: lock.h:170
pg_atomic_uint64 waitStart
Definition: proc.h:228
@ STANDBY_LOCK_TIMEOUT
Definition: timeout.h:32
#define PG_WAIT_LOCK
Definition: wait_event.h:19

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 468 of file standby.c.

471 {
472  VirtualTransactionId *backends;
473 
474  /*
475  * If we get passed InvalidTransactionId then we do nothing (no conflict).
476  *
477  * This can happen when replaying already-applied WAL records after a
478  * standby crash or restart, or when replaying an XLOG_HEAP2_VISIBLE
479  * record that marks as frozen a page which was already all-visible. It's
480  * also quite common with records generated during index deletion
481  * (original execution of the deletion can reason that a recovery conflict
482  * which is sufficient for the deletion operation must take place before
483  * replay of the deletion record itself).
484  */
485  if (!TransactionIdIsValid(snapshotConflictHorizon))
486  return;
487 
488  Assert(TransactionIdIsNormal(snapshotConflictHorizon));
489  backends = GetConflictingVirtualXIDs(snapshotConflictHorizon,
490  locator.dbOid);
493  WAIT_EVENT_RECOVERY_CONFLICT_SNAPSHOT,
494  true);
495 
496  /*
497  * Note that WaitExceedsMaxStandbyDelay() is not taken into account here
498  * (as opposed to ResolveRecoveryConflictWithVirtualXIDs() above). That
499  * seems OK, given that this kind of conflict should not normally be
500  * reached, e.g. due to using a physical replication slot.
501  */
502  if (wal_level >= WAL_LEVEL_LOGICAL && isCatalogRel)
504  snapshotConflictHorizon);
505 }
VirtualTransactionId * GetConflictingVirtualXIDs(TransactionId limitXmin, Oid dbOid)
Definition: procarray.c:3324
bool InvalidateObsoleteReplicationSlots(ReplicationSlotInvalidationCause cause, XLogSegNo oldestSegno, Oid dboid, TransactionId snapshotConflictHorizon)
Definition: slot.c:1526
@ RS_INVAL_HORIZON
Definition: slot.h:50
#define TransactionIdIsValid(xid)
Definition: transam.h:41
#define TransactionIdIsNormal(xid)
Definition: transam.h:42

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_freeze_page(), heap_xlog_prune(), heap_xlog_visible(), ResolveRecoveryConflictWithSnapshotFullXid(), and spgRedoVacuumRedirect().

◆ ResolveRecoveryConflictWithSnapshotFullXid()

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

Definition at line 512 of file standby.c.

515 {
516  /*
517  * ResolveRecoveryConflictWithSnapshot operates on 32-bit TransactionIds,
518  * so truncate the logged FullTransactionId. If the logged value is very
519  * old, so that XID wrap-around already happened on it, there can't be any
520  * snapshots that still see it.
521  */
523  uint64 diff;
524 
525  diff = U64FromFullTransactionId(nextXid) -
526  U64FromFullTransactionId(snapshotConflictHorizon);
527  if (diff < MaxTransactionId / 2)
528  {
529  TransactionId truncated;
530 
531  truncated = XidFromFullTransactionId(snapshotConflictHorizon);
533  isCatalogRel,
534  locator);
535  }
536 }
void ResolveRecoveryConflictWithSnapshot(TransactionId snapshotConflictHorizon, bool isCatalogRel, RelFileLocator locator)
Definition: standby.c:468
#define U64FromFullTransactionId(x)
Definition: transam.h:49
#define XidFromFullTransactionId(x)
Definition: transam.h:48
#define MaxTransactionId
Definition: transam.h:35
FullTransactionId ReadNextFullTransactionId(void)
Definition: varsup.c:261

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

Referenced by btree_xlog_reuse_page(), and gistRedoPageReuse().

◆ ResolveRecoveryConflictWithTablespace()

void ResolveRecoveryConflictWithTablespace ( Oid  tsid)

Definition at line 539 of file standby.c.

540 {
541  VirtualTransactionId *temp_file_users;
542 
543  /*
544  * Standby users may be currently using this tablespace for their
545  * temporary files. We only care about current users because
546  * temp_tablespace parameter will just ignore tablespaces that no longer
547  * exist.
548  *
549  * Ask everybody to cancel their queries immediately so we can ensure no
550  * temp files remain and we can remove the tablespace. Nuke the entire
551  * site from orbit, it's the only way to be sure.
552  *
553  * XXX: We could work out the pids of active backends using this
554  * tablespace by examining the temp filenames in the directory. We would
555  * then convert the pids into VirtualXIDs before attempting to cancel
556  * them.
557  *
558  * We don't wait for commit because drop tablespace is non-transactional.
559  */
561  InvalidOid);
564  WAIT_EVENT_RECOVERY_CONFLICT_TABLESPACE,
565  true);
566 }
#define InvalidOid
Definition: postgres_ext.h:36
#define InvalidTransactionId
Definition: transam.h:31

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

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.

363 {
364  TimestampTz waitStart = 0;
365  bool waiting = false;
366  bool logged_recovery_conflict = false;
367 
368  /* Fast exit, to avoid a kernel call if there's no work to be done. */
369  if (!VirtualTransactionIdIsValid(*waitlist))
370  return;
371 
372  /* Set the wait start timestamp for reporting */
373  if (report_waiting && (log_recovery_conflict_waits || update_process_title))
374  waitStart = GetCurrentTimestamp();
375 
376  while (VirtualTransactionIdIsValid(*waitlist))
377  {
378  /* reset standbyWait_us for each xact we wait for */
380 
381  /* wait until the virtual xid is gone */
382  while (!VirtualXactLock(*waitlist, false))
383  {
384  /* Is it time to kill it? */
385  if (WaitExceedsMaxStandbyDelay(wait_event_info))
386  {
387  pid_t pid;
388 
389  /*
390  * Now find out who to throw out of the balloon.
391  */
393  pid = CancelVirtualTransaction(*waitlist, reason);
394 
395  /*
396  * Wait a little bit for it to die so that we avoid flooding
397  * an unresponsive backend when system is heavily loaded.
398  */
399  if (pid != 0)
400  pg_usleep(5000L);
401  }
402 
403  if (waitStart != 0 && (!logged_recovery_conflict || !waiting))
404  {
405  TimestampTz now = 0;
406  bool maybe_log_conflict;
407  bool maybe_update_title;
408 
409  maybe_log_conflict = (log_recovery_conflict_waits && !logged_recovery_conflict);
410  maybe_update_title = (update_process_title && !waiting);
411 
412  /* Get the current timestamp if not report yet */
413  if (maybe_log_conflict || maybe_update_title)
415 
416  /*
417  * Report via ps if we have been waiting for more than 500
418  * msec (should that be configurable?)
419  */
420  if (maybe_update_title &&
421  TimestampDifferenceExceeds(waitStart, now, 500))
422  {
423  set_ps_display_suffix("waiting");
424  waiting = true;
425  }
426 
427  /*
428  * Emit the log message if the startup process is waiting
429  * longer than deadlock_timeout for recovery conflict.
430  */
431  if (maybe_log_conflict &&
433  {
434  LogRecoveryConflict(reason, waitStart, now, waitlist, true);
435  logged_recovery_conflict = true;
436  }
437  }
438  }
439 
440  /* The virtual transaction is gone now, wait for the next one */
441  waitlist++;
442  }
443 
444  /*
445  * Emit the log message if recovery conflict was resolved but the startup
446  * process waited longer than deadlock_timeout for it.
447  */
448  if (logged_recovery_conflict)
449  LogRecoveryConflict(reason, waitStart, GetCurrentTimestamp(),
450  NULL, false);
451 
452  /* reset ps display to remove the suffix if we added one */
453  if (waiting)
455 
456 }
bool TimestampDifferenceExceeds(TimestampTz start_time, TimestampTz stop_time, int msec)
Definition: timestamp.c:1719
static volatile sig_atomic_t waiting
Definition: latch.c:160
bool VirtualXactLock(VirtualTransactionId vxid, bool wait)
Definition: lock.c:4511
pid_t CancelVirtualTransaction(VirtualTransactionId vxid, ProcSignalReason sigmode)
Definition: procarray.c:3398
void set_ps_display_remove_suffix(void)
Definition: ps_status.c:396
void set_ps_display_suffix(const char *suffix)
Definition: ps_status.c:344
bool update_process_title
Definition: ps_status.c:31
static bool WaitExceedsMaxStandbyDelay(uint32 wait_event_info)
Definition: standby.c:234
static int standbyWait_us
Definition: standby.c:226
bool log_recovery_conflict_waits
Definition: standby.c:43
#define STANDBY_INITIAL_WAIT_US
Definition: standby.c:225
void LogRecoveryConflict(ProcSignalReason reason, TimestampTz wait_start, TimestampTz now, VirtualTransactionId *wait_list, bool still_waiting)
Definition: standby.c:274

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 877 of file standby.c.

878 {
881 
882  /*
883  * We send signal to all backends to ask them if they are holding the
884  * buffer pin which is delaying the Startup process. We must not set the
885  * conflict flag yet, since most backends will be innocent. Let the
886  * SIGUSR1 handling in each backend decide their own fate.
887  */
888  CancelDBBackends(InvalidOid, reason, false);
889 }

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.

162 {
163  /*
164  * Do nothing if RecoveryLockHash is NULL because that means that
165  * transaction tracking has not yet been initialized or has already been
166  * shut down. This makes it safe to have possibly-redundant calls of this
167  * function during process exit.
168  */
169  if (RecoveryLockHash == NULL)
170  return;
171 
172  /* Mark all tracked in-progress transactions as finished. */
174 
175  /* Release all locks the tracked transactions were holding */
177 
178  /* Destroy the lock hash tables. */
181  RecoveryLockHash = NULL;
182  RecoveryLockXidHash = NULL;
183 
184  /* Cleanup our VirtualTransaction */
186 }
void hash_destroy(HTAB *hashp)
Definition: dynahash.c:863
void VirtualXactLockTableCleanup(void)
Definition: lock.c:4411
void ExpireAllKnownAssignedTransactionIds(void)
Definition: procarray.c:4432
void StandbyReleaseAllLocks(void)
Definition: standby.c:1107

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

Referenced by StartupProcExit(), and StartupXLOG().

◆ standby_redo()

void standby_redo ( XLogReaderState record)

Definition at line 1161 of file standby.c.

1162 {
1163  uint8 info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
1164 
1165  /* Backup blocks are not used in standby records */
1166  Assert(!XLogRecHasAnyBlockRefs(record));
1167 
1168  /* Do nothing if we're not in hot standby mode */
1170  return;
1171 
1172  if (info == XLOG_STANDBY_LOCK)
1173  {
1174  xl_standby_locks *xlrec = (xl_standby_locks *) XLogRecGetData(record);
1175  int i;
1176 
1177  for (i = 0; i < xlrec->nlocks; i++)
1179  xlrec->locks[i].dbOid,
1180  xlrec->locks[i].relOid);
1181  }
1182  else if (info == XLOG_RUNNING_XACTS)
1183  {
1184  xl_running_xacts *xlrec = (xl_running_xacts *) XLogRecGetData(record);
1185  RunningTransactionsData running;
1186 
1187  running.xcnt = xlrec->xcnt;
1188  running.subxcnt = xlrec->subxcnt;
1189  running.subxid_overflow = xlrec->subxid_overflow;
1190  running.nextXid = xlrec->nextXid;
1191  running.latestCompletedXid = xlrec->latestCompletedXid;
1192  running.oldestRunningXid = xlrec->oldestRunningXid;
1193  running.xids = xlrec->xids;
1194 
1195  ProcArrayApplyRecoveryInfo(&running);
1196 
1197  /*
1198  * The startup process currently has no convenient way to schedule
1199  * stats to be reported. XLOG_RUNNING_XACTS records issued at a
1200  * regular cadence, making this a convenient location to report stats.
1201  * While these records aren't generated with wal_level=minimal, stats
1202  * also cannot be accessed during WAL replay.
1203  */
1204  pgstat_report_stat(true);
1205  }
1206  else if (info == XLOG_INVALIDATIONS)
1207  {
1208  xl_invalidations *xlrec = (xl_invalidations *) XLogRecGetData(record);
1209 
1211  xlrec->nmsgs,
1212  xlrec->relcacheInitFileInval,
1213  xlrec->dbId,
1214  xlrec->tsId);
1215  }
1216  else
1217  elog(PANIC, "standby_redo: unknown op code %u", info);
1218 }
unsigned char uint8
Definition: c.h:493
#define PANIC
Definition: elog.h:42
void ProcessCommittedInvalidationMessages(SharedInvalidationMessage *msgs, int nmsgs, bool RelcacheInitFileInval, Oid dbid, Oid tsid)
Definition: inval.c:963
int i
Definition: isn.c:73
long pgstat_report_stat(bool force)
Definition: pgstat.c:582
void ProcArrayApplyRecoveryInfo(RunningTransactions running)
Definition: procarray.c:1053
void StandbyAcquireAccessExclusiveLock(TransactionId xid, Oid dbOid, Oid relOid)
Definition: standby.c:986
SharedInvalidationMessage msgs[FLEXIBLE_ARRAY_MEMBER]
Definition: standbydefs.h:69
TransactionId xids[FLEXIBLE_ARRAY_MEMBER]
Definition: standbydefs.h:56
xl_standby_lock locks[FLEXIBLE_ARRAY_MEMBER]
Definition: standbydefs.h:41
#define XLogRecGetInfo(decoder)
Definition: xlogreader.h:410
#define XLogRecGetData(decoder)
Definition: xlogreader.h:415
#define XLogRecHasAnyBlockRefs(decoder)
Definition: xlogreader.h:417
#define XLR_INFO_MASK
Definition: xlogrecord.h:62
@ STANDBY_DISABLED
Definition: xlogutils.h:49

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, pgstat_report_stat(), 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 986 of file standby.c.

987 {
988  RecoveryLockXidEntry *xidentry;
989  RecoveryLockEntry *lockentry;
991  LOCKTAG locktag;
992  bool found;
993 
994  /* Already processed? */
995  if (!TransactionIdIsValid(xid) ||
996  TransactionIdDidCommit(xid) ||
998  return;
999 
1001  "adding recovery lock: db %u rel %u", dbOid, relOid);
1002 
1003  /* dbOid is InvalidOid when we are locking a shared relation. */
1004  Assert(OidIsValid(relOid));
1005 
1006  /* Create a hash entry for this xid, if we don't have one already. */
1007  xidentry = hash_search(RecoveryLockXidHash, &xid, HASH_ENTER, &found);
1008  if (!found)
1009  {
1010  Assert(xidentry->xid == xid); /* dynahash should have set this */
1011  xidentry->head = NULL;
1012  }
1013 
1014  /* Create a hash entry for this lock, unless we have one already. */
1015  key.xid = xid;
1016  key.dbOid = dbOid;
1017  key.relOid = relOid;
1018  lockentry = hash_search(RecoveryLockHash, &key, HASH_ENTER, &found);
1019  if (!found)
1020  {
1021  /* It's new, so link it into the XID's list ... */
1022  lockentry->next = xidentry->head;
1023  xidentry->head = lockentry;
1024 
1025  /* ... and acquire the lock locally. */
1026  SET_LOCKTAG_RELATION(locktag, dbOid, relOid);
1027 
1028  (void) LockAcquire(&locktag, AccessExclusiveLock, true, false);
1029  }
1030 }
#define OidIsValid(objectId)
Definition: c.h:764
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:953
#define DEBUG4
Definition: elog.h:27
@ HASH_ENTER
Definition: hsearch.h:114
LockAcquireResult LockAcquire(const LOCKTAG *locktag, LOCKMODE lockmode, bool sessionLock, bool dontWait)
Definition: lock.c:735
#define SET_LOCKTAG_RELATION(locktag, dboid, reloid)
Definition: lock.h:181
Definition: lock.h:165
struct RecoveryLockEntry * next
Definition: standby.c:57
TransactionId xid
Definition: standby.c:62
struct RecoveryLockEntry * head
Definition: standby.c:63
bool TransactionIdDidCommit(TransactionId transactionId)
Definition: transam.c:126
bool TransactionIdDidAbort(TransactionId transactionId)
Definition: transam.c:188

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 936 of file standby.c.

937 {
939 }

References got_standby_deadlock_timeout.

Referenced by StartupProcessMain().

◆ StandbyLockTimeoutHandler()

void StandbyLockTimeoutHandler ( void  )

Definition at line 954 of file standby.c.

955 {
957 }

References got_standby_lock_timeout.

Referenced by StartupProcessMain().

◆ StandbyReleaseAllLocks()

void StandbyReleaseAllLocks ( void  )

Definition at line 1107 of file standby.c.

1108 {
1109  HASH_SEQ_STATUS status;
1110  RecoveryLockXidEntry *entry;
1111 
1112  elog(trace_recovery(DEBUG2), "release all standby locks");
1113 
1115  while ((entry = hash_seq_search(&status)))
1116  {
1119  }
1120 }
void * hash_seq_search(HASH_SEQ_STATUS *status)
Definition: dynahash.c:1431
void hash_seq_init(HASH_SEQ_STATUS *status, HTAB *hashp)
Definition: dynahash.c:1421
@ HASH_REMOVE
Definition: hsearch.h:115
static void StandbyReleaseXidEntryLocks(RecoveryLockXidEntry *xidentry)
Definition: standby.c:1036

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

Referenced by ShutdownRecoveryTransactionEnvironment(), and StandbyReleaseLocks().

◆ StandbyReleaseLocks()

static void StandbyReleaseLocks ( TransactionId  xid)
static

Definition at line 1069 of file standby.c.

1070 {
1071  RecoveryLockXidEntry *entry;
1072 
1073  if (TransactionIdIsValid(xid))
1074  {
1075  if ((entry = hash_search(RecoveryLockXidHash, &xid, HASH_FIND, NULL)))
1076  {
1079  }
1080  }
1081  else
1083 }
@ HASH_FIND
Definition: hsearch.h:113

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 1093 of file standby.c.

1094 {
1095  int i;
1096 
1097  StandbyReleaseLocks(xid);
1098 
1099  for (i = 0; i < nsubxids; i++)
1100  StandbyReleaseLocks(subxids[i]);
1101 }
static void StandbyReleaseLocks(TransactionId xid)
Definition: standby.c:1069

References i, and StandbyReleaseLocks().

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

◆ StandbyReleaseOldLocks()

void StandbyReleaseOldLocks ( TransactionId  oldxid)

Definition at line 1128 of file standby.c.

1129 {
1130  HASH_SEQ_STATUS status;
1131  RecoveryLockXidEntry *entry;
1132 
1134  while ((entry = hash_seq_search(&status)))
1135  {
1136  Assert(TransactionIdIsValid(entry->xid));
1137 
1138  /* Skip if prepared transaction. */
1139  if (StandbyTransactionIdIsPrepared(entry->xid))
1140  continue;
1141 
1142  /* Skip if >= oldxid. */
1143  if (!TransactionIdPrecedes(entry->xid, oldxid))
1144  continue;
1145 
1146  /* Remove all locks and hash table entry. */
1149  }
1150 }
bool TransactionIdPrecedes(TransactionId id1, TransactionId id2)
Definition: transam.c:280
bool StandbyTransactionIdIsPrepared(TransactionId xid)
Definition: twophase.c:1453

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

Referenced by ProcArrayApplyRecoveryInfo().

◆ StandbyReleaseXidEntryLocks()

static void StandbyReleaseXidEntryLocks ( RecoveryLockXidEntry xidentry)
static

Definition at line 1036 of file standby.c.

1037 {
1038  RecoveryLockEntry *entry;
1040 
1041  for (entry = xidentry->head; entry != NULL; entry = next)
1042  {
1043  LOCKTAG locktag;
1044 
1046  "releasing recovery lock: xid %u db %u rel %u",
1047  entry->key.xid, entry->key.dbOid, entry->key.relOid);
1048  /* Release the lock ... */
1049  SET_LOCKTAG_RELATION(locktag, entry->key.dbOid, entry->key.relOid);
1050  if (!LockRelease(&locktag, AccessExclusiveLock, true))
1051  {
1052  elog(LOG,
1053  "RecoveryLockHash contains entry for lock no longer recorded by lock manager: xid %u database %u relation %u",
1054  entry->key.xid, entry->key.dbOid, entry->key.relOid);
1055  Assert(false);
1056  }
1057  /* ... and remove the per-lock hash entry */
1058  next = entry->next;
1059  hash_search(RecoveryLockHash, entry, HASH_REMOVE, NULL);
1060  }
1061 
1062  xidentry->head = NULL; /* just for paranoia */
1063 }
static int32 next
Definition: blutils.c:219
bool LockRelease(const LOCKTAG *locktag, LOCKMODE lockmode, bool sessionLock)
Definition: lock.c:1925
xl_standby_lock key
Definition: standby.c:56

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 945 of file standby.c.

946 {
948 }

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.

235 {
236  TimestampTz ltime;
237 
239 
240  /* Are we past the limit time? */
241  ltime = GetStandbyLimitTime();
242  if (ltime && GetCurrentTimestamp() >= ltime)
243  return true;
244 
245  /*
246  * Sleep a bit (this is essential to avoid busy-waiting).
247  */
248  pgstat_report_wait_start(wait_event_info);
251 
252  /*
253  * Progressively increase the sleep times, but not to more than 1s, since
254  * pg_usleep isn't interruptible on some platforms.
255  */
256  standbyWait_us *= 2;
257  if (standbyWait_us > 1000000)
258  standbyWait_us = 1000000;
259 
260  return false;
261 }
#define CHECK_FOR_INTERRUPTS()
Definition: miscadmin.h:121
static void pgstat_report_wait_start(uint32 wait_event_info)
Definition: wait_event.h:88
static void pgstat_report_wait_end(void)
Definition: wait_event.h:104

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

◆ 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

◆ 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

◆ RecoveryLockXidHash

◆ standbyWait_us

int standbyWait_us = STANDBY_INITIAL_WAIT_US
static