215 for (
i = 0;
i < TotalProcs;
i++)
303 PGPROC *
volatile *procgloballist;
310 elog(
PANIC,
"proc header uninitialized");
354 (
errcode(ERRCODE_TOO_MANY_CONNECTIONS),
355 errmsg(
"number of requested standby connections exceeds max_wal_senders (currently %d)",
358 (
errcode(ERRCODE_TOO_MANY_CONNECTIONS),
359 errmsg(
"sorry, too many clients already")));
405 #ifdef USE_ASSERT_CHECKING
525 elog(
PANIC,
"proc header uninitialized");
547 if (auxproc->
pid == 0)
553 elog(
FATAL,
"all AuxiliaryProcs are in use");
587 #ifdef USE_ASSERT_CHECKING
667 while (n > 0 && proc != NULL)
806 PGPROC *
volatile *procgloballist;
813 #ifdef USE_ASSERT_CHECKING
857 *procgloballist = leader;
861 else if (leader !=
MyProc)
897 *procgloballist = proc;
980 if (proc->
pid == pid)
1002 ProcQueueAlloc(
const char *
name)
1055 bool early_deadlock =
false;
1056 bool allow_autovacuum_cancel =
true;
1057 bool logged_recovery_conflict =
false;
1080 while (otherproclock != NULL)
1083 myHeldLocks |= otherproclock->
holdMask;
1107 if (myHeldLocks != 0)
1112 for (
i = 0;
i < waitQueue->
size;
i++)
1138 early_deadlock =
true;
1142 if ((lockMethodTable->
conflictTab[lockmode] & aheadRequests) == 0 &&
1297 bool maybe_log_conflict =
1298 (standbyWaitStart != 0 && !logged_recovery_conflict);
1302 maybe_log_conflict);
1308 if (maybe_log_conflict)
1329 standbyWaitStart,
now,
1330 cnt > 0 ? vxids : NULL,
true);
1331 logged_recovery_conflict =
true;
1364 uint8 lockmethod_copy;
1379 locktag_copy = lock->
tag;
1389 int pid = autovac->
pid;
1401 "Process %d waits for %s on %s.",
1416 if (
kill(pid, SIGINT) < 0)
1430 (
errmsg(
"could not send signal to process %d: %m",
1436 allow_autovacuum_cancel =
false;
1448 const char *modename;
1454 bool first_holder =
true,
1455 first_waiter =
true;
1456 int lockHoldersNum = 0;
1468 msecs = secs * 1000 + usecs / 1000;
1469 usecs = usecs % 1000;
1498 first_waiter =
false;
1510 first_holder =
false;
1527 (
errmsg(
"process %d avoided deadlock for %s on %s by rearranging queue order after %ld.%03d ms",
1530 "Processes holding the lock: %s. Wait queue: %s.",
1531 lockHoldersNum, lock_holders_sbuf.
data, lock_waiters_sbuf.
data))));
1542 (
errmsg(
"process %d detected deadlock while waiting for %s on %s after %ld.%03d ms",
1545 "Processes holding the lock: %s. Wait queue: %s.",
1546 lockHoldersNum, lock_holders_sbuf.
data, lock_waiters_sbuf.
data))));
1551 (
errmsg(
"process %d still waiting for %s on %s after %ld.%03d ms",
1554 "Processes holding the lock: %s. Wait queue: %s.",
1555 lockHoldersNum, lock_holders_sbuf.
data, lock_waiters_sbuf.
data))));
1558 (
errmsg(
"process %d acquired %s on %s after %ld.%03d ms",
1575 (
errmsg(
"process %d failed to acquire %s on %s after %ld.%03d ms",
1578 "Processes holding the lock: %s. Wait queue: %s.",
1579 lockHoldersNum, lock_holders_sbuf.
data, lock_waiters_sbuf.
data))));
1705 int queue_size = waitQueue->
size;
1711 if (queue_size == 0)
1716 while (queue_size-- > 0)
1724 if ((lockMethodTable->
conflictTab[lockmode] & aheadRequests) == 0 &&
1793 if (Debug_deadlocks)
1849 int save_errno = errno;
static void pg_atomic_write_u64(volatile pg_atomic_uint64 *ptr, uint64 val)
static void pg_atomic_init_u32(volatile pg_atomic_uint32 *ptr, uint32 val)
static uint32 pg_atomic_read_u32(volatile pg_atomic_uint32 *ptr)
static void pg_atomic_init_u64(volatile pg_atomic_uint64 *ptr, uint64 val)
int AutovacuumLauncherPid
int autovacuum_max_workers
bool IsAutoVacuumLauncherProcess(void)
bool IsAutoVacuumWorkerProcess(void)
#define IsAnyAutoVacuumProcess()
void TimestampDifference(TimestampTz start_time, TimestampTz stop_time, long *secs, int *microsecs)
bool TimestampDifferenceExceeds(TimestampTz start_time, TimestampTz stop_time, int msec)
TimestampTz GetCurrentTimestamp(void)
Datum now(PG_FUNCTION_ARGS)
#define offsetof(type, field)
#define MemSet(start, val, len)
#define PG_USED_FOR_ASSERTS_ONLY
#define TRANSACTION_STATUS_IN_PROGRESS
void ConditionVariableCancelSleep(void)
elog(ERROR, "%s: %s", p2, msg)
PGPROC * GetBlockingAutoVacuumPgproc(void)
void RememberSimpleDeadLock(PGPROC *proc1, LOCKMODE lockmode, LOCK *lock, PGPROC *proc2)
void InitDeadLockChecking(void)
DeadLockState DeadLockCheck(PGPROC *proc)
int errmsg_internal(const char *fmt,...)
bool message_level_is_interesting(int elevel)
int errcode(int sqlerrcode)
int errdetail_log_plural(const char *fmt_singular, const char *fmt_plural, unsigned long n,...)
int errmsg(const char *fmt,...)
int errdetail_log(const char *fmt,...)
#define ereport(elevel,...)
static void dlist_init(dlist_head *head)
static bool dlist_is_empty(dlist_head *head)
static void dlist_delete(dlist_node *node)
static void dlist_push_head(dlist_head *head, dlist_node *node)
static void dlist_push_tail(dlist_head *head, dlist_node *node)
void on_shmem_exit(pg_on_exit_callback function, Datum arg)
void OwnLatch(Latch *latch)
void DisownLatch(Latch *latch)
void InitSharedLatch(Latch *latch)
void SetLatch(Latch *latch)
void ResetLatch(Latch *latch)
int WaitLatch(Latch *latch, int wakeEvents, long timeout, uint32 wait_event_info)
#define WL_EXIT_ON_PM_DEATH
Assert(fmt[strlen(fmt) - 1] !='\n')
void DescribeLockTag(StringInfo buf, const LOCKTAG *tag)
VirtualTransactionId * GetLockConflicts(const LOCKTAG *locktag, LOCKMODE lockmode, int *countp)
void GrantAwaitedLock(void)
void GrantLock(LOCK *lock, PROCLOCK *proclock, LOCKMODE lockmode)
void RemoveFromWaitQueue(PGPROC *proc, uint32 hashcode)
void LockReleaseAll(LOCKMETHODID lockmethodid, bool allLocks)
void AbortStrongLockAcquire(void)
const char * GetLockmodeName(LOCKMETHODID lockmethodid, LOCKMODE mode)
uint32 LockTagHashCode(const LOCKTAG *locktag)
bool LockCheckConflicts(LockMethod lockMethodTable, LOCKMODE lockmode, LOCK *lock, PROCLOCK *proclock)
#define DEFAULT_LOCKMETHOD
#define LockHashPartitionLock(hashcode)
#define InvalidLocalTransactionId
@ DS_BLOCKED_BY_AUTOVACUUM
#define LOCKBIT_ON(lockmode)
#define LockHashPartitionLockByProc(leader_pgproc)
#define LockHashPartitionLockByIndex(i)
#define AccessExclusiveLock
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
void LWLockRelease(LWLock *lock)
void LWLockReleaseAll(void)
void LWLockInitialize(LWLock *lock, int tranche_id)
void InitLWLockAccess(void)
#define NUM_LOCK_PARTITIONS
@ LWTRANCHE_LOCK_FASTPATH
void pfree(void *pointer)
#define RESUME_INTERRUPTS()
#define CHECK_FOR_INTERRUPTS()
#define HOLD_INTERRUPTS()
void SwitchToSharedLatch(void)
void SwitchBackToLocalLatch(void)
void MarkPostmasterChildActive(void)
void MarkPostmasterChildInactive(void)
void PGSemaphoreReset(PGSemaphore sema)
PGSemaphore PGSemaphoreCreate(void)
#define NUM_AUXILIARY_PROCS
#define PROC_VACUUM_FOR_WRAPAROUND
@ PROC_WAIT_STATUS_WAITING
#define PROC_IS_AUTOVACUUM
void ProcArrayAdd(PGPROC *proc)
void ProcArrayRemove(PGPROC *proc, TransactionId latestXid)
@ PROCSIG_RECOVERY_CONFLICT_LOCK
void set_spins_per_delay(int shared_spins_per_delay)
int update_spins_per_delay(int shared_spins_per_delay)
#define DEFAULT_SPINS_PER_DELAY
void * ShmemAlloc(Size size)
Size add_size(Size s1, Size s2)
void * ShmemInitStruct(const char *name, Size size, bool *foundPtr)
Size mul_size(Size s1, Size s2)
Pointer SHMQueueNext(const SHM_QUEUE *queue, const SHM_QUEUE *curElem, Size linkOffset)
void SHMQueueDelete(SHM_QUEUE *queue)
void SHMQueueInit(SHM_QUEUE *queue)
void SHMQueueElemInit(SHM_QUEUE *queue)
bool SHMQueueEmpty(const SHM_QUEUE *queue)
void SHMQueueInsertBefore(SHM_QUEUE *queue, SHM_QUEUE *elem)
#define SpinLockInit(lock)
#define SpinLockRelease(lock)
#define SpinLockAcquire(lock)
void ProcSendSignal(int pgprocno)
Size ProcGlobalShmemSize(void)
bool IsWaitingForLock(void)
static void RemoveProcFromArray(int code, Datum arg)
void InitAuxiliaryProcess(void)
PGPROC * PreparedXactProcs
static DeadLockState deadlock_state
int IdleInTransactionSessionTimeout
NON_EXEC_STATIC PGPROC * AuxiliaryProcs
int GetStartupBufferPinWaitBufId(void)
PGPROC * ProcWakeup(PGPROC *proc, ProcWaitStatus waitStatus)
void ProcLockWakeup(LockMethod lockMethodTable, LOCK *lock)
static void CheckDeadLock(void)
NON_EXEC_STATIC slock_t * ProcStructLock
int ProcGlobalSemas(void)
void ProcReleaseLocks(bool isCommit)
void LockErrorCleanup(void)
bool BecomeLockGroupMember(PGPROC *leader, int pid)
void BecomeLockGroupLeader(void)
static LOCALLOCK * lockAwaited
PGPROC * AuxiliaryPidGetProc(int pid)
static void ProcKill(int code, Datum arg)
void CheckDeadLockAlert(void)
void InitProcessPhase2(void)
void InitProcGlobal(void)
ProcWaitStatus ProcSleep(LOCALLOCK *locallock, LockMethod lockMethodTable)
static volatile sig_atomic_t got_deadlock_timeout
void ProcQueueInit(PROC_QUEUE *queue)
bool HaveNFreeProcs(int n)
void SetStartupBufferPinWaitBufId(int bufid)
void ProcWaitForSignal(uint32 wait_event_info)
static void AuxiliaryProcKill(int code, Datum arg)
void CheckRecoveryConflictDeadlock(void)
bool log_recovery_conflict_waits
void LogRecoveryConflict(ProcSignalReason reason, TimestampTz wait_start, TimestampTz now, VirtualTransactionId *wait_list, bool still_waiting)
void ResolveRecoveryConflictWithLock(LOCKTAG locktag, bool logging_conflict)
void appendStringInfo(StringInfo str, const char *fmt,...)
void initStringInfo(StringInfo str)
uint8 locktag_lockmethodid
const LOCKMASK * conflictTab
bool procArrayGroupMember
XLogRecPtr clogGroupMemberLsn
pg_atomic_uint32 procArrayGroupNext
dlist_head lockGroupMembers
bool recoveryConflictPending
TransactionId clogGroupMemberXid
pg_atomic_uint64 waitStart
pg_atomic_uint32 clogGroupNext
XidStatus clogGroupMemberXidStatus
LocalTransactionId fpLocalTransactionId
TransactionId procArrayGroupMemberXid
ProcWaitStatus waitStatus
SHM_QUEUE myProcLocks[NUM_LOCK_PARTITIONS]
XidCacheStatus * subxidStates
PGPROC * walsenderFreeProcs
PGPROC * autovacFreeProcs
PGPROC * bgworkerFreeProcs
int startupBufferPinWaitBufId
pg_atomic_uint32 clogGroupFirst
Latch * checkpointerLatch
pg_atomic_uint32 procArrayGroupFirst
void SyncRepCleanupAtProcExit(void)
#define SYNC_REP_NOT_WAITING
void enable_timeout_after(TimeoutId id, int delay_ms)
TimestampTz get_timeout_start_time(TimeoutId id)
void disable_timeout(TimeoutId id, bool keep_indicator)
void enable_timeouts(const EnableTimeoutParams *timeouts, int count)
void disable_timeouts(const DisableTimeoutParams *timeouts, int count)
#define InvalidTransactionId
void pgstat_set_wait_event_storage(uint32 *wait_event_info)
void pgstat_reset_wait_event_storage(void)
bool RecoveryInProgress(void)
#define InvalidXLogRecPtr