#include "postgres.h"
#include <signal.h>
#include <unistd.h>
#include <sys/time.h>
#include "access/transam.h"
#include "access/twophase.h"
#include "access/xlogutils.h"
#include "miscadmin.h"
#include "pgstat.h"
#include "postmaster/autovacuum.h"
#include "replication/slot.h"
#include "replication/syncrep.h"
#include "replication/walsender.h"
#include "storage/condition_variable.h"
#include "storage/ipc.h"
#include "storage/lmgr.h"
#include "storage/pmsignal.h"
#include "storage/proc.h"
#include "storage/procarray.h"
#include "storage/procsignal.h"
#include "storage/spin.h"
#include "storage/standby.h"
#include "utils/timeout.h"
#include "utils/timestamp.h"

Include dependency graph for proc.c:

Functions
static void	RemoveProcFromArray (int code, Datum arg)

static void	ProcKill (int code, Datum arg)

static void	AuxiliaryProcKill (int code, Datum arg)

static void	CheckDeadLock (void)

Size	ProcGlobalShmemSize (void)

int	ProcGlobalSemas (void)

void	InitProcGlobal (void)

void	InitProcess (void)

void	InitProcessPhase2 (void)

void	InitAuxiliaryProcess (void)

void	SetStartupBufferPinWaitBufId (int bufid)

int	GetStartupBufferPinWaitBufId (void)

bool	HaveNFreeProcs (int n, int *nfree)

bool	IsWaitingForLock (void)

void	LockErrorCleanup (void)

void	ProcReleaseLocks (bool isCommit)

PGPROC *	AuxiliaryPidGetProc (int pid)

ProcWaitStatus	ProcSleep (LOCALLOCK *locallock, LockMethod lockMethodTable)

void	ProcWakeup (PGPROC *proc, ProcWaitStatus waitStatus)

void	ProcLockWakeup (LockMethod lockMethodTable, LOCK *lock)

void	CheckDeadLockAlert (void)

void	ProcWaitForSignal (uint32 wait_event_info)

void	ProcSendSignal (int pgprocno)

void	BecomeLockGroupLeader (void)

bool	BecomeLockGroupMember (PGPROC *leader, int pid)

Variables
int	DeadlockTimeout = 1000

int	StatementTimeout = 0

int	LockTimeout = 0

int	IdleInTransactionSessionTimeout = 0

int	IdleSessionTimeout = 0

bool	log_lock_waits = false

PGPROC *	MyProc = NULL

NON_EXEC_STATIC slock_t *	ProcStructLock = NULL

PROC_HDR *	ProcGlobal = NULL

NON_EXEC_STATIC PGPROC *	AuxiliaryProcs = NULL

PGPROC *	PreparedXactProcs = NULL

static LOCALLOCK *	lockAwaited = NULL

static DeadLockState	deadlock_state = DS_NOT_YET_CHECKED

static volatile sig_atomic_t	got_deadlock_timeout

Function Documentation

◆ AuxiliaryPidGetProc()

PGPROC* AuxiliaryPidGetProc ( int pid )

Definition at line 965 of file proc.c.

 {
     PGPROC     *result = NULL;
     int         index;
  
     if (pid == 0)               /* never match dummy PGPROCs */
         return NULL;
  
     for (index = 0; index < NUM_AUXILIARY_PROCS; index++)
     {
         PGPROC     *proc = &AuxiliaryProcs[index];
  
         if (proc->pid == pid)
         {
             result = proc;
             break;
         }
     }
     return result;
 }

References AuxiliaryProcs, NUM_AUXILIARY_PROCS, and PGPROC::pid.

Referenced by pg_log_backend_memory_contexts(), and pg_stat_get_activity().

◆ AuxiliaryProcKill()

static void AuxiliaryProcKill	(	int	code,
		Datum	arg
	)

static

Definition at line 921 of file proc.c.

 {
     int         proctype = DatumGetInt32(arg);
     PGPROC     *auxproc PG_USED_FOR_ASSERTS_ONLY;
     PGPROC     *proc;
  
     Assert(proctype >= 0 && proctype < NUM_AUXILIARY_PROCS);
  
     auxproc = &AuxiliaryProcs[proctype];
  
     Assert(MyProc == auxproc);
  
     /* Release any LW locks I am holding (see notes above) */
     LWLockReleaseAll();
  
     /* Cancel any pending condition variable sleep, too */
     ConditionVariableCancelSleep();
  
     /* look at the equivalent ProcKill() code for comments */
     SwitchBackToLocalLatch();
     pgstat_reset_wait_event_storage();
  
     proc = MyProc;
     MyProc = NULL;
     DisownLatch(&proc->procLatch);
  
     SpinLockAcquire(ProcStructLock);
  
     /* Mark auxiliary proc no longer in use */
     proc->pid = 0;
  
     /* Update shared estimate of spins_per_delay */
     ProcGlobal->spins_per_delay = update_spins_per_delay(ProcGlobal->spins_per_delay);
  
     SpinLockRelease(ProcStructLock);
 }

References arg, Assert(), AuxiliaryProcs, ConditionVariableCancelSleep(), DatumGetInt32(), DisownLatch(), LWLockReleaseAll(), MyProc, NUM_AUXILIARY_PROCS, PG_USED_FOR_ASSERTS_ONLY, pgstat_reset_wait_event_storage(), PGPROC::pid, ProcGlobal, PGPROC::procLatch, ProcStructLock, SpinLockAcquire, SpinLockRelease, PROC_HDR::spins_per_delay, SwitchBackToLocalLatch(), and update_spins_per_delay().

Referenced by InitAuxiliaryProcess().

◆ BecomeLockGroupLeader()

void BecomeLockGroupLeader ( void )

Definition at line 1824 of file proc.c.

 {
     LWLock     *leader_lwlock;
  
     /* If we already did it, we don't need to do it again. */
     if (MyProc->lockGroupLeader == MyProc)
         return;
  
     /* We had better not be a follower. */
     Assert(MyProc->lockGroupLeader == NULL);
  
     /* Create single-member group, containing only ourselves. */
     leader_lwlock = LockHashPartitionLockByProc(MyProc);
     LWLockAcquire(leader_lwlock, LW_EXCLUSIVE);
     MyProc->lockGroupLeader = MyProc;
     dlist_push_head(&MyProc->lockGroupMembers, &MyProc->lockGroupLink);
     LWLockRelease(leader_lwlock);
 }

References Assert(), dlist_push_head(), PGPROC::lockGroupLeader, PGPROC::lockGroupLink, PGPROC::lockGroupMembers, LockHashPartitionLockByProc, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), and MyProc.

Referenced by LaunchParallelWorkers().

◆ BecomeLockGroupMember()

bool BecomeLockGroupMember	(	PGPROC *	leader,
		int	pid
	)

Definition at line 1854 of file proc.c.

 {
     LWLock     *leader_lwlock;
     bool        ok = false;
  
     /* Group leader can't become member of group */
     Assert(MyProc != leader);
  
     /* Can't already be a member of a group */
     Assert(MyProc->lockGroupLeader == NULL);
  
     /* PID must be valid. */
     Assert(pid != 0);
  
     /*
      * Get lock protecting the group fields.  Note LockHashPartitionLockByProc
      * accesses leader->pgprocno in a PGPROC that might be free.  This is safe
      * because all PGPROCs' pgprocno fields are set during shared memory
      * initialization and never change thereafter; so we will acquire the
      * correct lock even if the leader PGPROC is in process of being recycled.
      */
     leader_lwlock = LockHashPartitionLockByProc(leader);
     LWLockAcquire(leader_lwlock, LW_EXCLUSIVE);
  
     /* Is this the leader we're looking for? */
     if (leader->pid == pid && leader->lockGroupLeader == leader)
     {
         /* OK, join the group */
         ok = true;
         MyProc->lockGroupLeader = leader;
         dlist_push_tail(&leader->lockGroupMembers, &MyProc->lockGroupLink);
     }
     LWLockRelease(leader_lwlock);
  
     return ok;
 }

References Assert(), dlist_push_tail(), PGPROC::lockGroupLeader, PGPROC::lockGroupLink, PGPROC::lockGroupMembers, LockHashPartitionLockByProc, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MyProc, and PGPROC::pid.

Referenced by ParallelWorkerMain().

◆ CheckDeadLock()

static void CheckDeadLock ( void )

static

Definition at line 1685 of file proc.c.

 {
     int         i;
  
     /*
      * Acquire exclusive lock on the entire shared lock data structures. Must
      * grab LWLocks in partition-number order to avoid LWLock deadlock.
      *
      * Note that the deadlock check interrupt had better not be enabled
      * anywhere that this process itself holds lock partition locks, else this
      * will wait forever.  Also note that LWLockAcquire creates a critical
      * section, so that this routine cannot be interrupted by cancel/die
      * interrupts.
      */
     for (i = 0; i < NUM_LOCK_PARTITIONS; i++)
         LWLockAcquire(LockHashPartitionLockByIndex(i), LW_EXCLUSIVE);
  
     /*
      * Check to see if we've been awoken by anyone in the interim.
      *
      * If we have, we can return and resume our transaction -- happy day.
      * Before we are awoken the process releasing the lock grants it to us so
      * we know that we don't have to wait anymore.
      *
      * We check by looking to see if we've been unlinked from the wait queue.
      * This is safe because we hold the lock partition lock.
      */
     if (MyProc->links.prev == NULL ||
         MyProc->links.next == NULL)
         goto check_done;
  
 #ifdef LOCK_DEBUG
     if (Debug_deadlocks)
         DumpAllLocks();
 #endif
  
     /* Run the deadlock check, and set deadlock_state for use by ProcSleep */
     deadlock_state = DeadLockCheck(MyProc);
  
     if (deadlock_state == DS_HARD_DEADLOCK)
     {
         /*
          * Oops.  We have a deadlock.
          *
          * Get this process out of wait state. (Note: we could do this more
          * efficiently by relying on lockAwaited, but use this coding to
          * preserve the flexibility to kill some other transaction than the
          * one detecting the deadlock.)
          *
          * RemoveFromWaitQueue sets MyProc->waitStatus to
          * PROC_WAIT_STATUS_ERROR, so ProcSleep will report an error after we
          * return from the signal handler.
          */
         Assert(MyProc->waitLock != NULL);
         RemoveFromWaitQueue(MyProc, LockTagHashCode(&(MyProc->waitLock->tag)));
  
         /*
          * We're done here.  Transaction abort caused by the error that
          * ProcSleep will raise will cause any other locks we hold to be
          * released, thus allowing other processes to wake up; we don't need
          * to do that here.  NOTE: an exception is that releasing locks we
          * hold doesn't consider the possibility of waiters that were blocked
          * behind us on the lock we just failed to get, and might now be
          * wakable because we're not in front of them anymore.  However,
          * RemoveFromWaitQueue took care of waking up any such processes.
          */
     }
  
     /*
      * And release locks.  We do this in reverse order for two reasons: (1)
      * Anyone else who needs more than one of the locks will be trying to lock
      * them in increasing order; we don't want to release the other process
      * until it can get all the locks it needs. (2) This avoids O(N^2)
      * behavior inside LWLockRelease.
      */
 check_done:
     for (i = NUM_LOCK_PARTITIONS; --i >= 0;)
         LWLockRelease(LockHashPartitionLockByIndex(i));
 }

References Assert(), deadlock_state, DeadLockCheck(), DS_HARD_DEADLOCK, i, PGPROC::links, LockHashPartitionLockByIndex, LockTagHashCode(), LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MyProc, dlist_node::next, NUM_LOCK_PARTITIONS, dlist_node::prev, RemoveFromWaitQueue(), LOCK::tag, and PGPROC::waitLock.

Referenced by ProcSleep().

◆ CheckDeadLockAlert()

void CheckDeadLockAlert ( void )

Definition at line 1771 of file proc.c.

 {
     int         save_errno = errno;
  
     got_deadlock_timeout = true;
  
     /*
      * Have to set the latch again, even if handle_sig_alarm already did. Back
      * then got_deadlock_timeout wasn't yet set... It's unlikely that this
      * ever would be a problem, but setting a set latch again is cheap.
      *
      * Note that, when this function runs inside procsignal_sigusr1_handler(),
      * the handler function sets the latch again after the latch is set here.
      */
     SetLatch(MyLatch);
     errno = save_errno;
 }

References got_deadlock_timeout, MyLatch, and SetLatch().

Referenced by InitPostgres(), and ProcessRecoveryConflictInterrupt().

◆ GetStartupBufferPinWaitBufId()

int GetStartupBufferPinWaitBufId ( void )

Definition at line 639 of file proc.c.

 {
     /* use volatile pointer to prevent code rearrangement */
     volatile PROC_HDR *procglobal = ProcGlobal;
  
     return procglobal->startupBufferPinWaitBufId;
 }

References ProcGlobal, and PROC_HDR::startupBufferPinWaitBufId.

Referenced by HoldingBufferPinThatDelaysRecovery(), and ProcessRecoveryConflictInterrupt().

◆ HaveNFreeProcs()

bool HaveNFreeProcs	(	int	n,
		int *	nfree
	)

Definition at line 655 of file proc.c.

 {
     dlist_iter  iter;
  
     Assert(n > 0);
     Assert(nfree);
  
     SpinLockAcquire(ProcStructLock);
  
     *nfree = 0;
     dlist_foreach(iter, &ProcGlobal->freeProcs)
     {
         (*nfree)++;
         if (*nfree == n)
             break;
     }
  
     SpinLockRelease(ProcStructLock);
  
     return (*nfree == n);
 }

References Assert(), dlist_foreach, PROC_HDR::freeProcs, ProcGlobal, ProcStructLock, SpinLockAcquire, and SpinLockRelease.

Referenced by InitPostgres().

◆ InitAuxiliaryProcess()

void InitAuxiliaryProcess ( void )

Definition at line 509 of file proc.c.

 {
     PGPROC     *auxproc;
     int         proctype;
  
     /*
      * ProcGlobal should be set up already (if we are a backend, we inherit
      * this by fork() or EXEC_BACKEND mechanism from the postmaster).
      */
     if (ProcGlobal == NULL || AuxiliaryProcs == NULL)
         elog(PANIC, "proc header uninitialized");
  
     if (MyProc != NULL)
         elog(ERROR, "you already exist");
  
     /*
      * We use the ProcStructLock to protect assignment and releasing of
      * AuxiliaryProcs entries.
      *
      * While we are holding the ProcStructLock, also copy the current shared
      * estimate of spins_per_delay to local storage.
      */
     SpinLockAcquire(ProcStructLock);
  
     set_spins_per_delay(ProcGlobal->spins_per_delay);
  
     /*
      * Find a free auxproc ... *big* trouble if there isn't one ...
      */
     for (proctype = 0; proctype < NUM_AUXILIARY_PROCS; proctype++)
     {
         auxproc = &AuxiliaryProcs[proctype];
         if (auxproc->pid == 0)
             break;
     }
     if (proctype >= NUM_AUXILIARY_PROCS)
     {
         SpinLockRelease(ProcStructLock);
         elog(FATAL, "all AuxiliaryProcs are in use");
     }
  
     /* Mark auxiliary proc as in use by me */
     /* use volatile pointer to prevent code rearrangement */
     ((volatile PGPROC *) auxproc)->pid = MyProcPid;
  
     MyProc = auxproc;
  
     SpinLockRelease(ProcStructLock);
  
     /*
      * Initialize all fields of MyProc, except for those previously
      * initialized by InitProcGlobal.
      */
     dlist_node_init(&MyProc->links);
     MyProc->waitStatus = PROC_WAIT_STATUS_OK;
     MyProc->lxid = InvalidLocalTransactionId;
     MyProc->fpVXIDLock = false;
     MyProc->fpLocalTransactionId = InvalidLocalTransactionId;
     MyProc->xid = InvalidTransactionId;
     MyProc->xmin = InvalidTransactionId;
     MyProc->backendId = InvalidBackendId;
     MyProc->databaseId = InvalidOid;
     MyProc->roleId = InvalidOid;
     MyProc->tempNamespaceId = InvalidOid;
     MyProc->isBackgroundWorker = IsBackgroundWorker;
     MyProc->delayChkptFlags = 0;
     MyProc->statusFlags = 0;
     MyProc->lwWaiting = LW_WS_NOT_WAITING;
     MyProc->lwWaitMode = 0;
     MyProc->waitLock = NULL;
     MyProc->waitProcLock = NULL;
     pg_atomic_write_u64(&MyProc->waitStart, 0);
 #ifdef USE_ASSERT_CHECKING
     {
         int         i;
  
         /* Last process should have released all locks. */
         for (i = 0; i < NUM_LOCK_PARTITIONS; i++)
             Assert(dlist_is_empty(&(MyProc->myProcLocks[i])));
     }
 #endif
  
     /*
      * Acquire ownership of the PGPROC's latch, so that we can use WaitLatch
      * on it.  That allows us to repoint the process latch, which so far
      * points to process local one, to the shared one.
      */
     OwnLatch(&MyProc->procLatch);
     SwitchToSharedLatch();
  
     /* now that we have a proc, report wait events to shared memory */
     pgstat_set_wait_event_storage(&MyProc->wait_event_info);
  
     /* Check that group locking fields are in a proper initial state. */
     Assert(MyProc->lockGroupLeader == NULL);
     Assert(dlist_is_empty(&MyProc->lockGroupMembers));
  
     /*
      * We might be reusing a semaphore that belonged to a failed process. So
      * be careful and reinitialize its value here.  (This is not strictly
      * necessary anymore, but seems like a good idea for cleanliness.)
      */
     PGSemaphoreReset(MyProc->sem);
  
     /*
      * Arrange to clean up at process exit.
      */
     on_shmem_exit(AuxiliaryProcKill, Int32GetDatum(proctype));
 }

References Assert(), AuxiliaryProcKill(), AuxiliaryProcs, PGPROC::backendId, PGPROC::databaseId, PGPROC::delayChkptFlags, dlist_is_empty(), dlist_node_init(), elog(), ERROR, FATAL, PGPROC::fpLocalTransactionId, PGPROC::fpVXIDLock, i, Int32GetDatum(), InvalidBackendId, InvalidLocalTransactionId, InvalidOid, InvalidTransactionId, IsBackgroundWorker, PGPROC::isBackgroundWorker, PGPROC::links, PGPROC::lockGroupLeader, PGPROC::lockGroupMembers, LW_WS_NOT_WAITING, PGPROC::lwWaiting, PGPROC::lwWaitMode, PGPROC::lxid, MyProc, PGPROC::myProcLocks, MyProcPid, NUM_AUXILIARY_PROCS, NUM_LOCK_PARTITIONS, on_shmem_exit(), OwnLatch(), PANIC, pg_atomic_write_u64(), PGSemaphoreReset(), pgstat_set_wait_event_storage(), PGPROC::pid, PROC_WAIT_STATUS_OK, ProcGlobal, PGPROC::procLatch, ProcStructLock, PGPROC::roleId, PGPROC::sem, set_spins_per_delay(), SpinLockAcquire, SpinLockRelease, PROC_HDR::spins_per_delay, PGPROC::statusFlags, SwitchToSharedLatch(), PGPROC::tempNamespaceId, PGPROC::wait_event_info, PGPROC::waitLock, PGPROC::waitProcLock, PGPROC::waitStart, PGPROC::waitStatus, PGPROC::xid, and PGPROC::xmin.

Referenced by AuxiliaryProcessMain().

◆ InitProcess()

void InitProcess ( void )

Definition at line 297 of file proc.c.

 {
     dlist_head *procgloballist;
  
     /*
      * ProcGlobal should be set up already (if we are a backend, we inherit
      * this by fork() or EXEC_BACKEND mechanism from the postmaster).
      */
     if (ProcGlobal == NULL)
         elog(PANIC, "proc header uninitialized");
  
     if (MyProc != NULL)
         elog(ERROR, "you already exist");
  
     /* Decide which list should supply our PGPROC. */
     if (IsAnyAutoVacuumProcess())
         procgloballist = &ProcGlobal->autovacFreeProcs;
     else if (IsBackgroundWorker)
         procgloballist = &ProcGlobal->bgworkerFreeProcs;
     else if (am_walsender)
         procgloballist = &ProcGlobal->walsenderFreeProcs;
     else
         procgloballist = &ProcGlobal->freeProcs;
  
     /*
      * Try to get a proc struct from the appropriate free list.  If this
      * fails, we must be out of PGPROC structures (not to mention semaphores).
      *
      * While we are holding the ProcStructLock, also copy the current shared
      * estimate of spins_per_delay to local storage.
      */
     SpinLockAcquire(ProcStructLock);
  
     set_spins_per_delay(ProcGlobal->spins_per_delay);
  
     if (!dlist_is_empty(procgloballist))
     {
         MyProc = (PGPROC *) dlist_pop_head_node(procgloballist);
         SpinLockRelease(ProcStructLock);
     }
     else
     {
         /*
          * If we reach here, all the PGPROCs are in use.  This is one of the
          * possible places to detect "too many backends", so give the standard
          * error message.  XXX do we need to give a different failure message
          * in the autovacuum case?
          */
         SpinLockRelease(ProcStructLock);
         if (am_walsender)
             ereport(FATAL,
                     (errcode(ERRCODE_TOO_MANY_CONNECTIONS),
                      errmsg("number of requested standby connections exceeds max_wal_senders (currently %d)",
                             max_wal_senders)));
         ereport(FATAL,
                 (errcode(ERRCODE_TOO_MANY_CONNECTIONS),
                  errmsg("sorry, too many clients already")));
     }
  
     /*
      * Cross-check that the PGPROC is of the type we expect; if this were not
      * the case, it would get returned to the wrong list.
      */
     Assert(MyProc->procgloballist == procgloballist);
  
     /*
      * Now that we have a PGPROC, mark ourselves as an active postmaster
      * child; this is so that the postmaster can detect it if we exit without
      * cleaning up.  (XXX autovac launcher currently doesn't participate in
      * this; it probably should.)
      */
     if (IsUnderPostmaster && !IsAutoVacuumLauncherProcess())
         MarkPostmasterChildActive();
  
     /*
      * Initialize all fields of MyProc, except for those previously
      * initialized by InitProcGlobal.
      */
     dlist_node_init(&MyProc->links);
     MyProc->waitStatus = PROC_WAIT_STATUS_OK;
     MyProc->lxid = InvalidLocalTransactionId;
     MyProc->fpVXIDLock = false;
     MyProc->fpLocalTransactionId = InvalidLocalTransactionId;
     MyProc->xid = InvalidTransactionId;
     MyProc->xmin = InvalidTransactionId;
     MyProc->pid = MyProcPid;
     /* backendId, databaseId and roleId will be filled in later */
     MyProc->backendId = InvalidBackendId;
     MyProc->databaseId = InvalidOid;
     MyProc->roleId = InvalidOid;
     MyProc->tempNamespaceId = InvalidOid;
     MyProc->isBackgroundWorker = IsBackgroundWorker;
     MyProc->delayChkptFlags = 0;
     MyProc->statusFlags = 0;
     /* NB -- autovac launcher intentionally does not set IS_AUTOVACUUM */
     if (IsAutoVacuumWorkerProcess())
         MyProc->statusFlags |= PROC_IS_AUTOVACUUM;
     MyProc->lwWaiting = LW_WS_NOT_WAITING;
     MyProc->lwWaitMode = 0;
     MyProc->waitLock = NULL;
     MyProc->waitProcLock = NULL;
     pg_atomic_write_u64(&MyProc->waitStart, 0);
 #ifdef USE_ASSERT_CHECKING
     {
         int         i;
  
         /* Last process should have released all locks. */
         for (i = 0; i < NUM_LOCK_PARTITIONS; i++)
             Assert(dlist_is_empty(&(MyProc->myProcLocks[i])));
     }
 #endif
     MyProc->recoveryConflictPending = false;
  
     /* Initialize fields for sync rep */
     MyProc->waitLSN = 0;
     MyProc->syncRepState = SYNC_REP_NOT_WAITING;
     dlist_node_init(&MyProc->syncRepLinks);
  
     /* Initialize fields for group XID clearing. */
     MyProc->procArrayGroupMember = false;
     MyProc->procArrayGroupMemberXid = InvalidTransactionId;
     Assert(pg_atomic_read_u32(&MyProc->procArrayGroupNext) == INVALID_PGPROCNO);
  
     /* Check that group locking fields are in a proper initial state. */
     Assert(MyProc->lockGroupLeader == NULL);
     Assert(dlist_is_empty(&MyProc->lockGroupMembers));
  
     /* Initialize wait event information. */
     MyProc->wait_event_info = 0;
  
     /* Initialize fields for group transaction status update. */
     MyProc->clogGroupMember = false;
     MyProc->clogGroupMemberXid = InvalidTransactionId;
     MyProc->clogGroupMemberXidStatus = TRANSACTION_STATUS_IN_PROGRESS;
     MyProc->clogGroupMemberPage = -1;
     MyProc->clogGroupMemberLsn = InvalidXLogRecPtr;
     Assert(pg_atomic_read_u32(&MyProc->clogGroupNext) == INVALID_PGPROCNO);
  
     /*
      * Acquire ownership of the PGPROC's latch, so that we can use WaitLatch
      * on it.  That allows us to repoint the process latch, which so far
      * points to process local one, to the shared one.
      */
     OwnLatch(&MyProc->procLatch);
     SwitchToSharedLatch();
  
     /* now that we have a proc, report wait events to shared memory */
     pgstat_set_wait_event_storage(&MyProc->wait_event_info);
  
     /*
      * We might be reusing a semaphore that belonged to a failed process. So
      * be careful and reinitialize its value here.  (This is not strictly
      * necessary anymore, but seems like a good idea for cleanliness.)
      */
     PGSemaphoreReset(MyProc->sem);
  
     /*
      * Arrange to clean up at backend exit.
      */
     on_shmem_exit(ProcKill, 0);
  
     /*
      * Now that we have a PGPROC, we could try to acquire locks, so initialize
      * local state needed for LWLocks, and the deadlock checker.
      */
     InitLWLockAccess();
     InitDeadLockChecking();
 }

References am_walsender, Assert(), PROC_HDR::autovacFreeProcs, PGPROC::backendId, PROC_HDR::bgworkerFreeProcs, PGPROC::clogGroupMember, PGPROC::clogGroupMemberLsn, PGPROC::clogGroupMemberPage, PGPROC::clogGroupMemberXid, PGPROC::clogGroupMemberXidStatus, PGPROC::clogGroupNext, PGPROC::databaseId, PGPROC::delayChkptFlags, dlist_is_empty(), dlist_node_init(), dlist_pop_head_node(), elog(), ereport, errcode(), errmsg(), ERROR, FATAL, PGPROC::fpLocalTransactionId, PGPROC::fpVXIDLock, PROC_HDR::freeProcs, i, InitDeadLockChecking(), InitLWLockAccess(), INVALID_PGPROCNO, InvalidBackendId, InvalidLocalTransactionId, InvalidOid, InvalidTransactionId, InvalidXLogRecPtr, IsAnyAutoVacuumProcess, IsAutoVacuumLauncherProcess(), IsAutoVacuumWorkerProcess(), IsBackgroundWorker, PGPROC::isBackgroundWorker, IsUnderPostmaster, PGPROC::links, PGPROC::lockGroupLeader, PGPROC::lockGroupMembers, LW_WS_NOT_WAITING, PGPROC::lwWaiting, PGPROC::lwWaitMode, PGPROC::lxid, MarkPostmasterChildActive(), max_wal_senders, MyProc, PGPROC::myProcLocks, MyProcPid, NUM_LOCK_PARTITIONS, on_shmem_exit(), OwnLatch(), PANIC, pg_atomic_read_u32(), pg_atomic_write_u64(), PGSemaphoreReset(), pgstat_set_wait_event_storage(), PGPROC::pid, PROC_IS_AUTOVACUUM, PROC_WAIT_STATUS_OK, PGPROC::procArrayGroupMember, PGPROC::procArrayGroupMemberXid, PGPROC::procArrayGroupNext, ProcGlobal, PGPROC::procgloballist, ProcKill(), PGPROC::procLatch, ProcStructLock, PGPROC::recoveryConflictPending, PGPROC::roleId, PGPROC::sem, set_spins_per_delay(), SpinLockAcquire, SpinLockRelease, PROC_HDR::spins_per_delay, PGPROC::statusFlags, SwitchToSharedLatch(), SYNC_REP_NOT_WAITING, PGPROC::syncRepLinks, PGPROC::syncRepState, PGPROC::tempNamespaceId, TRANSACTION_STATUS_IN_PROGRESS, PGPROC::wait_event_info, PGPROC::waitLock, PGPROC::waitLSN, PGPROC::waitProcLock, PGPROC::waitStart, PGPROC::waitStatus, PROC_HDR::walsenderFreeProcs, PGPROC::xid, and PGPROC::xmin.

Referenced by AutoVacLauncherMain(), AutoVacWorkerMain(), BackendStartup(), BootstrapModeMain(), PostgresSingleUserMain(), and StartBackgroundWorker().

◆ InitProcessPhase2()

void InitProcessPhase2 ( void )

Definition at line 474 of file proc.c.

 {
     Assert(MyProc != NULL);
  
     /*
      * Add our PGPROC to the PGPROC array in shared memory.
      */
     ProcArrayAdd(MyProc);
  
     /*
      * Arrange to clean that up at backend exit.
      */
     on_shmem_exit(RemoveProcFromArray, 0);
 }

References Assert(), MyProc, on_shmem_exit(), ProcArrayAdd(), and RemoveProcFromArray().

Referenced by InitPostgres().

◆ InitProcGlobal()

void InitProcGlobal ( void )

Definition at line 157 of file proc.c.

 {
     PGPROC     *procs;
     int         i,
                 j;
     bool        found;
     uint32      TotalProcs = MaxBackends + NUM_AUXILIARY_PROCS + max_prepared_xacts;
  
     /* Create the ProcGlobal shared structure */
     ProcGlobal = (PROC_HDR *)
         ShmemInitStruct("Proc Header", sizeof(PROC_HDR), &found);
     Assert(!found);
  
     /*
      * Initialize the data structures.
      */
     ProcGlobal->spins_per_delay = DEFAULT_SPINS_PER_DELAY;
     dlist_init(&ProcGlobal->freeProcs);
     dlist_init(&ProcGlobal->autovacFreeProcs);
     dlist_init(&ProcGlobal->bgworkerFreeProcs);
     dlist_init(&ProcGlobal->walsenderFreeProcs);
     ProcGlobal->startupBufferPinWaitBufId = -1;
     ProcGlobal->walwriterLatch = NULL;
     ProcGlobal->checkpointerLatch = NULL;
     pg_atomic_init_u32(&ProcGlobal->procArrayGroupFirst, INVALID_PGPROCNO);
     pg_atomic_init_u32(&ProcGlobal->clogGroupFirst, INVALID_PGPROCNO);
  
     /*
      * Create and initialize all the PGPROC structures we'll need.  There are
      * five separate consumers: (1) normal backends, (2) autovacuum workers
      * and the autovacuum launcher, (3) background workers, (4) auxiliary
      * processes, and (5) prepared transactions.  Each PGPROC structure is
      * dedicated to exactly one of these purposes, and they do not move
      * between groups.
      */
     procs = (PGPROC *) ShmemAlloc(TotalProcs * sizeof(PGPROC));
     MemSet(procs, 0, TotalProcs * sizeof(PGPROC));
     ProcGlobal->allProcs = procs;
     /* XXX allProcCount isn't really all of them; it excludes prepared xacts */
     ProcGlobal->allProcCount = MaxBackends + NUM_AUXILIARY_PROCS;
  
     /*
      * Allocate arrays mirroring PGPROC fields in a dense manner. See
      * PROC_HDR.
      *
      * XXX: It might make sense to increase padding for these arrays, given
      * how hotly they are accessed.
      */
     ProcGlobal->xids =
         (TransactionId *) ShmemAlloc(TotalProcs * sizeof(*ProcGlobal->xids));
     MemSet(ProcGlobal->xids, 0, TotalProcs * sizeof(*ProcGlobal->xids));
     ProcGlobal->subxidStates = (XidCacheStatus *) ShmemAlloc(TotalProcs * sizeof(*ProcGlobal->subxidStates));
     MemSet(ProcGlobal->subxidStates, 0, TotalProcs * sizeof(*ProcGlobal->subxidStates));
     ProcGlobal->statusFlags = (uint8 *) ShmemAlloc(TotalProcs * sizeof(*ProcGlobal->statusFlags));
     MemSet(ProcGlobal->statusFlags, 0, TotalProcs * sizeof(*ProcGlobal->statusFlags));
  
     for (i = 0; i < TotalProcs; i++)
     {
         PGPROC     *proc = &procs[i];
  
         /* Common initialization for all PGPROCs, regardless of type. */
  
         /*
          * Set up per-PGPROC semaphore, latch, and fpInfoLock.  Prepared xact
          * dummy PGPROCs don't need these though - they're never associated
          * with a real process
          */
         if (i < MaxBackends + NUM_AUXILIARY_PROCS)
         {
             proc->sem = PGSemaphoreCreate();
             InitSharedLatch(&(proc->procLatch));
             LWLockInitialize(&(proc->fpInfoLock), LWTRANCHE_LOCK_FASTPATH);
         }
         proc->pgprocno = i;
  
         /*
          * Newly created PGPROCs for normal backends, autovacuum and bgworkers
          * must be queued up on the appropriate free list.  Because there can
          * only ever be a small, fixed number of auxiliary processes, no free
          * list is used in that case; InitAuxiliaryProcess() instead uses a
          * linear search.   PGPROCs for prepared transactions are added to a
          * free list by TwoPhaseShmemInit().
          */
         if (i < MaxConnections)
         {
             /* PGPROC for normal backend, add to freeProcs list */
             dlist_push_head(&ProcGlobal->freeProcs, &proc->links);
             proc->procgloballist = &ProcGlobal->freeProcs;
         }
         else if (i < MaxConnections + autovacuum_max_workers + 1)
         {
             /* PGPROC for AV launcher/worker, add to autovacFreeProcs list */
             dlist_push_head(&ProcGlobal->autovacFreeProcs, &proc->links);
             proc->procgloballist = &ProcGlobal->autovacFreeProcs;
         }
         else if (i < MaxConnections + autovacuum_max_workers + 1 + max_worker_processes)
         {
             /* PGPROC for bgworker, add to bgworkerFreeProcs list */
             dlist_push_head(&ProcGlobal->bgworkerFreeProcs, &proc->links);
             proc->procgloballist = &ProcGlobal->bgworkerFreeProcs;
         }
         else if (i < MaxBackends)
         {
             /* PGPROC for walsender, add to walsenderFreeProcs list */
             dlist_push_head(&ProcGlobal->walsenderFreeProcs, &proc->links);
             proc->procgloballist = &ProcGlobal->walsenderFreeProcs;
         }
  
         /* Initialize myProcLocks[] shared memory queues. */
         for (j = 0; j < NUM_LOCK_PARTITIONS; j++)
             dlist_init(&(proc->myProcLocks[j]));
  
         /* Initialize lockGroupMembers list. */
         dlist_init(&proc->lockGroupMembers);
  
         /*
          * Initialize the atomic variables, otherwise, it won't be safe to
          * access them for backends that aren't currently in use.
          */
         pg_atomic_init_u32(&(proc->procArrayGroupNext), INVALID_PGPROCNO);
         pg_atomic_init_u32(&(proc->clogGroupNext), INVALID_PGPROCNO);
         pg_atomic_init_u64(&(proc->waitStart), 0);
     }
  
     /*
      * Save pointers to the blocks of PGPROC structures reserved for auxiliary
      * processes and prepared transactions.
      */
     AuxiliaryProcs = &procs[MaxBackends];
     PreparedXactProcs = &procs[MaxBackends + NUM_AUXILIARY_PROCS];
  
     /* Create ProcStructLock spinlock, too */
     ProcStructLock = (slock_t *) ShmemAlloc(sizeof(slock_t));
     SpinLockInit(ProcStructLock);
 }

References PROC_HDR::allProcCount, PROC_HDR::allProcs, Assert(), PROC_HDR::autovacFreeProcs, autovacuum_max_workers, AuxiliaryProcs, PROC_HDR::bgworkerFreeProcs, PROC_HDR::checkpointerLatch, PROC_HDR::clogGroupFirst, PGPROC::clogGroupNext, DEFAULT_SPINS_PER_DELAY, dlist_init(), dlist_push_head(), PGPROC::fpInfoLock, PROC_HDR::freeProcs, i, InitSharedLatch(), INVALID_PGPROCNO, j, PGPROC::links, PGPROC::lockGroupMembers, LWLockInitialize(), LWTRANCHE_LOCK_FASTPATH, max_prepared_xacts, max_worker_processes, MaxBackends, MaxConnections, MemSet, PGPROC::myProcLocks, NUM_AUXILIARY_PROCS, NUM_LOCK_PARTITIONS, pg_atomic_init_u32(), pg_atomic_init_u64(), PGPROC::pgprocno, PGSemaphoreCreate(), PreparedXactProcs, PROC_HDR::procArrayGroupFirst, PGPROC::procArrayGroupNext, ProcGlobal, PGPROC::procgloballist, PGPROC::procLatch, ProcStructLock, PGPROC::sem, ShmemAlloc(), ShmemInitStruct(), SpinLockInit, PROC_HDR::spins_per_delay, PROC_HDR::startupBufferPinWaitBufId, PROC_HDR::statusFlags, PROC_HDR::subxidStates, PGPROC::waitStart, PROC_HDR::walsenderFreeProcs, PROC_HDR::walwriterLatch, and PROC_HDR::xids.

Referenced by CreateSharedMemoryAndSemaphores().

◆ IsWaitingForLock()

bool IsWaitingForLock ( void )

Definition at line 681 of file proc.c.

 {
     if (lockAwaited == NULL)
         return false;
  
     return true;
 }

References lockAwaited.

Referenced by ProcessRecoveryConflictInterrupt().

◆ LockErrorCleanup()

void LockErrorCleanup ( void )

Definition at line 698 of file proc.c.

 {
     LWLock     *partitionLock;
     DisableTimeoutParams timeouts[2];
  
     HOLD_INTERRUPTS();
  
     AbortStrongLockAcquire();
  
     /* Nothing to do if we weren't waiting for a lock */
     if (lockAwaited == NULL)
     {
         RESUME_INTERRUPTS();
         return;
     }
  
     /*
      * Turn off the deadlock and lock timeout timers, if they are still
      * running (see ProcSleep).  Note we must preserve the LOCK_TIMEOUT
      * indicator flag, since this function is executed before
      * ProcessInterrupts when responding to SIGINT; else we'd lose the
      * knowledge that the SIGINT came from a lock timeout and not an external
      * source.
      */
     timeouts[0].id = DEADLOCK_TIMEOUT;
     timeouts[0].keep_indicator = false;
     timeouts[1].id = LOCK_TIMEOUT;
     timeouts[1].keep_indicator = true;
     disable_timeouts(timeouts, 2);
  
     /* Unlink myself from the wait queue, if on it (might not be anymore!) */
     partitionLock = LockHashPartitionLock(lockAwaited->hashcode);
     LWLockAcquire(partitionLock, LW_EXCLUSIVE);
  
     if (!dlist_node_is_detached(&MyProc->links))
     {
         /* We could not have been granted the lock yet */
         RemoveFromWaitQueue(MyProc, lockAwaited->hashcode);
     }
     else
     {
         /*
          * Somebody kicked us off the lock queue already.  Perhaps they
          * granted us the lock, or perhaps they detected a deadlock. If they
          * did grant us the lock, we'd better remember it in our local lock
          * table.
          */
         if (MyProc->waitStatus == PROC_WAIT_STATUS_OK)
             GrantAwaitedLock();
     }
  
     lockAwaited = NULL;
  
     LWLockRelease(partitionLock);
  
     RESUME_INTERRUPTS();
 }

References AbortStrongLockAcquire(), DEADLOCK_TIMEOUT, disable_timeouts(), dlist_node_is_detached(), GrantAwaitedLock(), LOCALLOCK::hashcode, HOLD_INTERRUPTS, DisableTimeoutParams::id, DisableTimeoutParams::keep_indicator, PGPROC::links, LOCK_TIMEOUT, lockAwaited, LockHashPartitionLock, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MyProc, PROC_WAIT_STATUS_OK, RemoveFromWaitQueue(), RESUME_INTERRUPTS, and PGPROC::waitStatus.

Referenced by AbortSubTransaction(), AbortTransaction(), ProcessInterrupts(), ProcessRecoveryConflictInterrupt(), and ProcReleaseLocks().

◆ ProcGlobalSemas()

int ProcGlobalSemas ( void )

Definition at line 122 of file proc.c.

 {
     /*
      * We need a sema per backend (including autovacuum), plus one for each
      * auxiliary process.
      */
     return MaxBackends + NUM_AUXILIARY_PROCS;
 }

References MaxBackends, and NUM_AUXILIARY_PROCS.

Referenced by CalculateShmemSize().

◆ ProcGlobalShmemSize()

Size ProcGlobalShmemSize ( void )

Definition at line 100 of file proc.c.

 {
     Size        size = 0;
     Size        TotalProcs =
         add_size(MaxBackends, add_size(NUM_AUXILIARY_PROCS, max_prepared_xacts));
  
     /* ProcGlobal */
     size = add_size(size, sizeof(PROC_HDR));
     size = add_size(size, mul_size(TotalProcs, sizeof(PGPROC)));
     size = add_size(size, sizeof(slock_t));
  
     size = add_size(size, mul_size(TotalProcs, sizeof(*ProcGlobal->xids)));
     size = add_size(size, mul_size(TotalProcs, sizeof(*ProcGlobal->subxidStates)));
     size = add_size(size, mul_size(TotalProcs, sizeof(*ProcGlobal->statusFlags)));
  
     return size;
 }

References add_size(), max_prepared_xacts, MaxBackends, mul_size(), NUM_AUXILIARY_PROCS, ProcGlobal, PROC_HDR::statusFlags, PROC_HDR::subxidStates, and PROC_HDR::xids.

Referenced by CalculateShmemSize().

◆ ProcKill()

static void ProcKill	(	int	code,
		Datum	arg
	)

static

Definition at line 802 of file proc.c.

 {
     PGPROC     *proc;
     dlist_head *procgloballist;
  
     Assert(MyProc != NULL);
  
     /* Make sure we're out of the sync rep lists */
     SyncRepCleanupAtProcExit();
  
 #ifdef USE_ASSERT_CHECKING
     {
         int         i;
  
         /* Last process should have released all locks. */
         for (i = 0; i < NUM_LOCK_PARTITIONS; i++)
             Assert(dlist_is_empty(&(MyProc->myProcLocks[i])));
     }
 #endif
  
     /*
      * Release any LW locks I am holding.  There really shouldn't be any, but
      * it's cheap to check again before we cut the knees off the LWLock
      * facility by releasing our PGPROC ...
      */
     LWLockReleaseAll();
  
     /* Cancel any pending condition variable sleep, too */
     ConditionVariableCancelSleep();
  
     /*
      * Detach from any lock group of which we are a member.  If the leader
      * exits before all other group members, its PGPROC will remain allocated
      * until the last group process exits; that process must return the
      * leader's PGPROC to the appropriate list.
      */
     if (MyProc->lockGroupLeader != NULL)
     {
         PGPROC     *leader = MyProc->lockGroupLeader;
         LWLock     *leader_lwlock = LockHashPartitionLockByProc(leader);
  
         LWLockAcquire(leader_lwlock, LW_EXCLUSIVE);
         Assert(!dlist_is_empty(&leader->lockGroupMembers));
         dlist_delete(&MyProc->lockGroupLink);
         if (dlist_is_empty(&leader->lockGroupMembers))
         {
             leader->lockGroupLeader = NULL;
             if (leader != MyProc)
             {
                 procgloballist = leader->procgloballist;
  
                 /* Leader exited first; return its PGPROC. */
                 SpinLockAcquire(ProcStructLock);
                 dlist_push_head(procgloballist, &leader->links);
                 SpinLockRelease(ProcStructLock);
             }
         }
         else if (leader != MyProc)
             MyProc->lockGroupLeader = NULL;
         LWLockRelease(leader_lwlock);
     }
  
     /*
      * Reset MyLatch to the process local one.  This is so that signal
      * handlers et al can continue using the latch after the shared latch
      * isn't ours anymore.
      *
      * Similarly, stop reporting wait events to MyProc->wait_event_info.
      *
      * After that clear MyProc and disown the shared latch.
      */
     SwitchBackToLocalLatch();
     pgstat_reset_wait_event_storage();
  
     proc = MyProc;
     MyProc = NULL;
     DisownLatch(&proc->procLatch);
  
     procgloballist = proc->procgloballist;
     SpinLockAcquire(ProcStructLock);
  
     /*
      * If we're still a member of a locking group, that means we're a leader
      * which has somehow exited before its children.  The last remaining child
      * will release our PGPROC.  Otherwise, release it now.
      */
     if (proc->lockGroupLeader == NULL)
     {
         /* Since lockGroupLeader is NULL, lockGroupMembers should be empty. */
         Assert(dlist_is_empty(&proc->lockGroupMembers));
  
         /* Return PGPROC structure (and semaphore) to appropriate freelist */
         dlist_push_tail(procgloballist, &proc->links);
     }
  
     /* Update shared estimate of spins_per_delay */
     ProcGlobal->spins_per_delay = update_spins_per_delay(ProcGlobal->spins_per_delay);
  
     SpinLockRelease(ProcStructLock);
  
     /*
      * This process is no longer present in shared memory in any meaningful
      * way, so tell the postmaster we've cleaned up acceptably well. (XXX
      * autovac launcher should be included here someday)
      */
     if (IsUnderPostmaster && !IsAutoVacuumLauncherProcess())
         MarkPostmasterChildInactive();
  
     /* wake autovac launcher if needed -- see comments in FreeWorkerInfo */
     if (AutovacuumLauncherPid != 0)
         kill(AutovacuumLauncherPid, SIGUSR2);
 }

References Assert(), AutovacuumLauncherPid, ConditionVariableCancelSleep(), DisownLatch(), dlist_delete(), dlist_is_empty(), dlist_push_head(), dlist_push_tail(), i, IsAutoVacuumLauncherProcess(), IsUnderPostmaster, kill, PGPROC::links, PGPROC::lockGroupLeader, PGPROC::lockGroupLink, PGPROC::lockGroupMembers, LockHashPartitionLockByProc, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), LWLockReleaseAll(), MarkPostmasterChildInactive(), MyProc, PGPROC::myProcLocks, NUM_LOCK_PARTITIONS, pgstat_reset_wait_event_storage(), ProcGlobal, PGPROC::procgloballist, PGPROC::procLatch, ProcStructLock, SIGUSR2, SpinLockAcquire, SpinLockRelease, PROC_HDR::spins_per_delay, SwitchBackToLocalLatch(), SyncRepCleanupAtProcExit(), and update_spins_per_delay().

Referenced by InitProcess().

◆ ProcLockWakeup()

void ProcLockWakeup	(	LockMethod	lockMethodTable,
		LOCK *	lock
	)

Definition at line 1637 of file proc.c.

 {
     dclist_head *waitQueue = &lock->waitProcs;
     LOCKMASK    aheadRequests = 0;
     dlist_mutable_iter miter;
  
     if (dclist_is_empty(waitQueue))
         return;
  
     dclist_foreach_modify(miter, waitQueue)
     {
         PGPROC     *proc = dlist_container(PGPROC, links, miter.cur);
         LOCKMODE    lockmode = proc->waitLockMode;
  
         /*
          * Waken if (a) doesn't conflict with requests of earlier waiters, and
          * (b) doesn't conflict with already-held locks.
          */
         if ((lockMethodTable->conflictTab[lockmode] & aheadRequests) == 0 &&
             !LockCheckConflicts(lockMethodTable, lockmode, lock,
                                 proc->waitProcLock))
         {
             /* OK to waken */
             GrantLock(lock, proc->waitProcLock, lockmode);
             /* removes proc from the lock's waiting process queue */
             ProcWakeup(proc, PROC_WAIT_STATUS_OK);
         }
         else
         {
             /*
              * Lock conflicts: Don't wake, but remember requested mode for
              * later checks.
              */
             aheadRequests |= LOCKBIT_ON(lockmode);
         }
     }
 }

References LockMethodData::conflictTab, dlist_mutable_iter::cur, dclist_foreach_modify, dclist_is_empty(), dlist_container, GrantLock(), links, LOCKBIT_ON, LockCheckConflicts(), PROC_WAIT_STATUS_OK, ProcWakeup(), PGPROC::waitLockMode, PGPROC::waitProcLock, and LOCK::waitProcs.

Referenced by CleanUpLock(), and DeadLockCheck().

◆ ProcReleaseLocks()

void ProcReleaseLocks ( bool isCommit )

Definition at line 774 of file proc.c.

 {
     if (!MyProc)
         return;
     /* If waiting, get off wait queue (should only be needed after error) */
     LockErrorCleanup();
     /* Release standard locks, including session-level if aborting */
     LockReleaseAll(DEFAULT_LOCKMETHOD, !isCommit);
     /* Release transaction-level advisory locks */
     LockReleaseAll(USER_LOCKMETHOD, false);
 }

References DEFAULT_LOCKMETHOD, LockErrorCleanup(), LockReleaseAll(), MyProc, and USER_LOCKMETHOD.

Referenced by ResourceOwnerReleaseInternal().

◆ ProcSendSignal()

void ProcSendSignal ( int pgprocno )

Definition at line 1809 of file proc.c.

 {
     if (pgprocno < 0 || pgprocno >= ProcGlobal->allProcCount)
         elog(ERROR, "pgprocno out of range");
  
     SetLatch(&ProcGlobal->allProcs[pgprocno].procLatch);
 }

References PROC_HDR::allProcCount, PROC_HDR::allProcs, elog(), ERROR, ProcGlobal, PGPROC::procLatch, and SetLatch().

Referenced by ReleasePredicateLocks(), and UnpinBuffer().

◆ ProcSleep()

ProcWaitStatus ProcSleep	(	LOCALLOCK *	locallock,
		LockMethod	lockMethodTable
	)

Definition at line 1004 of file proc.c.

 {
     LOCKMODE    lockmode = locallock->tag.mode;
     LOCK       *lock = locallock->lock;
     PROCLOCK   *proclock = locallock->proclock;
     uint32      hashcode = locallock->hashcode;
     LWLock     *partitionLock = LockHashPartitionLock(hashcode);
     dclist_head *waitQueue = &lock->waitProcs;
     PGPROC     *insert_before = NULL;
     LOCKMASK    myHeldLocks = MyProc->heldLocks;
     TimestampTz standbyWaitStart = 0;
     bool        early_deadlock = false;
     bool        allow_autovacuum_cancel = true;
     bool        logged_recovery_conflict = false;
     ProcWaitStatus myWaitStatus;
     PGPROC     *leader = MyProc->lockGroupLeader;
  
     /*
      * If group locking is in use, locks held by members of my locking group
      * need to be included in myHeldLocks.  This is not required for relation
      * extension lock which conflict among group members. However, including
      * them in myHeldLocks will give group members the priority to get those
      * locks as compared to other backends which are also trying to acquire
      * those locks.  OTOH, we can avoid giving priority to group members for
      * that kind of locks, but there doesn't appear to be a clear advantage of
      * the same.
      */
     if (leader != NULL)
     {
         dlist_iter  iter;
  
         dlist_foreach(iter, &lock->procLocks)
         {
             PROCLOCK   *otherproclock;
  
             otherproclock = dlist_container(PROCLOCK, lockLink, iter.cur);
  
             if (otherproclock->groupLeader == leader)
                 myHeldLocks |= otherproclock->holdMask;
         }
     }
  
     /*
      * Determine where to add myself in the wait queue.
      *
      * Normally I should go at the end of the queue.  However, if I already
      * hold locks that conflict with the request of any previous waiter, put
      * myself in the queue just in front of the first such waiter. This is not
      * a necessary step, since deadlock detection would move me to before that
      * waiter anyway; but it's relatively cheap to detect such a conflict
      * immediately, and avoid delaying till deadlock timeout.
      *
      * Special case: if I find I should go in front of some waiter, check to
      * see if I conflict with already-held locks or the requests before that
      * waiter.  If not, then just grant myself the requested lock immediately.
      * This is the same as the test for immediate grant in LockAcquire, except
      * we are only considering the part of the wait queue before my insertion
      * point.
      */
     if (myHeldLocks != 0 && !dclist_is_empty(waitQueue))
     {
         LOCKMASK    aheadRequests = 0;
         dlist_iter  iter;
  
         dclist_foreach(iter, waitQueue)
         {
             PGPROC     *proc = dlist_container(PGPROC, links, iter.cur);
  
             /*
              * If we're part of the same locking group as this waiter, its
              * locks neither conflict with ours nor contribute to
              * aheadRequests.
              */
             if (leader != NULL && leader == proc->lockGroupLeader)
                 continue;
  
             /* Must he wait for me? */
             if (lockMethodTable->conflictTab[proc->waitLockMode] & myHeldLocks)
             {
                 /* Must I wait for him ? */
                 if (lockMethodTable->conflictTab[lockmode] & proc->heldLocks)
                 {
                     /*
                      * Yes, so we have a deadlock.  Easiest way to clean up
                      * correctly is to call RemoveFromWaitQueue(), but we
                      * can't do that until we are *on* the wait queue. So, set
                      * a flag to check below, and break out of loop.  Also,
                      * record deadlock info for later message.
                      */
                     RememberSimpleDeadLock(MyProc, lockmode, lock, proc);
                     early_deadlock = true;
                     break;
                 }
                 /* I must go before this waiter.  Check special case. */
                 if ((lockMethodTable->conflictTab[lockmode] & aheadRequests) == 0 &&
                     !LockCheckConflicts(lockMethodTable, lockmode, lock,
                                         proclock))
                 {
                     /* Skip the wait and just grant myself the lock. */
                     GrantLock(lock, proclock, lockmode);
                     GrantAwaitedLock();
                     return PROC_WAIT_STATUS_OK;
                 }
  
                 /* Put myself into wait queue before conflicting process */
                 insert_before = proc;
                 break;
             }
             /* Nope, so advance to next waiter */
             aheadRequests |= LOCKBIT_ON(proc->waitLockMode);
         }
     }
  
     /*
      * Insert self into queue, at the position determined above.
      */
     if (insert_before)
         dclist_insert_before(waitQueue, &insert_before->links, &MyProc->links);
     else
         dclist_push_tail(waitQueue, &MyProc->links);
  
     lock->waitMask |= LOCKBIT_ON(lockmode);
  
     /* Set up wait information in PGPROC object, too */
     MyProc->waitLock = lock;
     MyProc->waitProcLock = proclock;
     MyProc->waitLockMode = lockmode;
  
     MyProc->waitStatus = PROC_WAIT_STATUS_WAITING;
  
     /*
      * If we detected deadlock, give up without waiting.  This must agree with
      * CheckDeadLock's recovery code.
      */
     if (early_deadlock)
     {
         RemoveFromWaitQueue(MyProc, hashcode);
         return PROC_WAIT_STATUS_ERROR;
     }
  
     /* mark that we are waiting for a lock */
     lockAwaited = locallock;
  
     /*
      * Release the lock table's partition lock.
      *
      * NOTE: this may also cause us to exit critical-section state, possibly
      * allowing a cancel/die interrupt to be accepted. This is OK because we
      * have recorded the fact that we are waiting for a lock, and so
      * LockErrorCleanup will clean up if cancel/die happens.
      */
     LWLockRelease(partitionLock);
  
     /*
      * Also, now that we will successfully clean up after an ereport, it's
      * safe to check to see if there's a buffer pin deadlock against the
      * Startup process.  Of course, that's only necessary if we're doing Hot
      * Standby and are not the Startup process ourselves.
      */
     if (RecoveryInProgress() && !InRecovery)
         CheckRecoveryConflictDeadlock();
  
     /* Reset deadlock_state before enabling the timeout handler */
     deadlock_state = DS_NOT_YET_CHECKED;
     got_deadlock_timeout = false;
  
     /*
      * Set timer so we can wake up after awhile and check for a deadlock. If a
      * deadlock is detected, the handler sets MyProc->waitStatus =
      * PROC_WAIT_STATUS_ERROR, allowing us to know that we must report failure
      * rather than success.
      *
      * By delaying the check until we've waited for a bit, we can avoid
      * running the rather expensive deadlock-check code in most cases.
      *
      * If LockTimeout is set, also enable the timeout for that.  We can save a
      * few cycles by enabling both timeout sources in one call.
      *
      * If InHotStandby we set lock waits slightly later for clarity with other
      * code.
      */
     if (!InHotStandby)
     {
         if (LockTimeout > 0)
         {
             EnableTimeoutParams timeouts[2];
  
             timeouts[0].id = DEADLOCK_TIMEOUT;
             timeouts[0].type = TMPARAM_AFTER;
             timeouts[0].delay_ms = DeadlockTimeout;
             timeouts[1].id = LOCK_TIMEOUT;
             timeouts[1].type = TMPARAM_AFTER;
             timeouts[1].delay_ms = LockTimeout;
             enable_timeouts(timeouts, 2);
         }
         else
             enable_timeout_after(DEADLOCK_TIMEOUT, DeadlockTimeout);
  
         /*
          * Use the current time obtained for the deadlock timeout timer 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.
          */
         pg_atomic_write_u64(&MyProc->waitStart,
                             get_timeout_start_time(DEADLOCK_TIMEOUT));
     }
     else if (log_recovery_conflict_waits)
     {
         /*
          * Set the wait start timestamp if logging is enabled and in hot
          * standby.
          */
         standbyWaitStart = GetCurrentTimestamp();
     }
  
     /*
      * If somebody wakes us between LWLockRelease and WaitLatch, the latch
      * will not wait. But a set latch does not necessarily mean that the lock
      * is free now, as there are many other sources for latch sets than
      * somebody releasing the lock.
      *
      * We process interrupts whenever the latch has been set, so cancel/die
      * interrupts are processed quickly. This means we must not mind losing
      * control to a cancel/die interrupt here.  We don't, because we have no
      * shared-state-change work to do after being granted the lock (the
      * grantor did it all).  We do have to worry about canceling the deadlock
      * timeout and updating the locallock table, but if we lose control to an
      * error, LockErrorCleanup will fix that up.
      */
     do
     {
         if (InHotStandby)
         {
             bool        maybe_log_conflict =
                 (standbyWaitStart != 0 && !logged_recovery_conflict);
  
             /* Set a timer and wait for that or for the lock to be granted */
             ResolveRecoveryConflictWithLock(locallock->tag.lock,
                                             maybe_log_conflict);
  
             /*
              * Emit the log message if the startup process is waiting longer
              * than deadlock_timeout for recovery conflict on lock.
              */
             if (maybe_log_conflict)
             {
                 TimestampTz now = GetCurrentTimestamp();
  
                 if (TimestampDifferenceExceeds(standbyWaitStart, now,
                                                DeadlockTimeout))
                 {
                     VirtualTransactionId *vxids;
                     int         cnt;
  
                     vxids = GetLockConflicts(&locallock->tag.lock,
                                              AccessExclusiveLock, &cnt);
  
                     /*
                      * Log the recovery conflict and the list of PIDs of
                      * backends holding the conflicting lock. Note that we do
                      * logging even if there are no such backends right now
                      * because the startup process here has already waited
                      * longer than deadlock_timeout.
                      */
                     LogRecoveryConflict(PROCSIG_RECOVERY_CONFLICT_LOCK,
                                         standbyWaitStart, now,
                                         cnt > 0 ? vxids : NULL, true);
                     logged_recovery_conflict = true;
                 }
             }
         }
         else
         {
             (void) WaitLatch(MyLatch, WL_LATCH_SET | WL_EXIT_ON_PM_DEATH, 0,
                              PG_WAIT_LOCK | locallock->tag.lock.locktag_type);
             ResetLatch(MyLatch);
             /* check for deadlocks first, as that's probably log-worthy */
             if (got_deadlock_timeout)
             {
                 CheckDeadLock();
                 got_deadlock_timeout = false;
             }
             CHECK_FOR_INTERRUPTS();
         }
  
         /*
          * waitStatus could change from PROC_WAIT_STATUS_WAITING to something
          * else asynchronously.  Read it just once per loop to prevent
          * surprising behavior (such as missing log messages).
          */
         myWaitStatus = *((volatile ProcWaitStatus *) &MyProc->waitStatus);
  
         /*
          * If we are not deadlocked, but are waiting on an autovacuum-induced
          * task, send a signal to interrupt it.
          */
         if (deadlock_state == DS_BLOCKED_BY_AUTOVACUUM && allow_autovacuum_cancel)
         {
             PGPROC     *autovac = GetBlockingAutoVacuumPgproc();
             uint8       statusFlags;
             uint8       lockmethod_copy;
             LOCKTAG     locktag_copy;
  
             /*
              * Grab info we need, then release lock immediately.  Note this
              * coding means that there is a tiny chance that the process
              * terminates its current transaction and starts a different one
              * before we have a change to send the signal; the worst possible
              * consequence is that a for-wraparound vacuum is cancelled.  But
              * that could happen in any case unless we were to do kill() with
              * the lock held, which is much more undesirable.
              */
             LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
             statusFlags = ProcGlobal->statusFlags[autovac->pgxactoff];
             lockmethod_copy = lock->tag.locktag_lockmethodid;
             locktag_copy = lock->tag;
             LWLockRelease(ProcArrayLock);
  
             /*
              * Only do it if the worker is not working to protect against Xid
              * wraparound.
              */
             if ((statusFlags & PROC_IS_AUTOVACUUM) &&
                 !(statusFlags & PROC_VACUUM_FOR_WRAPAROUND))
             {
                 int         pid = autovac->pid;
  
                 /* report the case, if configured to do so */
                 if (message_level_is_interesting(DEBUG1))
                 {
                     StringInfoData locktagbuf;
                     StringInfoData logbuf;  /* errdetail for server log */
  
                     initStringInfo(&locktagbuf);
                     initStringInfo(&logbuf);
                     DescribeLockTag(&locktagbuf, &locktag_copy);
                     appendStringInfo(&logbuf,
                                      "Process %d waits for %s on %s.",
                                      MyProcPid,
                                      GetLockmodeName(lockmethod_copy, lockmode),
                                      locktagbuf.data);
  
                     ereport(DEBUG1,
                             (errmsg_internal("sending cancel to blocking autovacuum PID %d",
                                              pid),
                              errdetail_log("%s", logbuf.data)));
  
                     pfree(locktagbuf.data);
                     pfree(logbuf.data);
                 }
  
                 /* send the autovacuum worker Back to Old Kent Road */
                 if (kill(pid, SIGINT) < 0)
                 {
                     /*
                      * There's a race condition here: once we release the
                      * ProcArrayLock, it's possible for the autovac worker to
                      * close up shop and exit before we can do the kill().
                      * Therefore, we do not whinge about no-such-process.
                      * Other errors such as EPERM could conceivably happen if
                      * the kernel recycles the PID fast enough, but such cases
                      * seem improbable enough that it's probably best to issue
                      * a warning if we see some other errno.
                      */
                     if (errno != ESRCH)
                         ereport(WARNING,
                                 (errmsg("could not send signal to process %d: %m",
                                         pid)));
                 }
             }
  
             /* prevent signal from being sent again more than once */
             allow_autovacuum_cancel = false;
         }
  
         /*
          * If awoken after the deadlock check interrupt has run, and
          * log_lock_waits is on, then report about the wait.
          */
         if (log_lock_waits && deadlock_state != DS_NOT_YET_CHECKED)
         {
             StringInfoData buf,
                         lock_waiters_sbuf,
                         lock_holders_sbuf;
             const char *modename;
             long        secs;
             int         usecs;
             long        msecs;
             dlist_iter  proc_iter;
             PROCLOCK   *curproclock;
             bool        first_holder = true,
                         first_waiter = true;
             int         lockHoldersNum = 0;
  
             initStringInfo(&buf);
             initStringInfo(&lock_waiters_sbuf);
             initStringInfo(&lock_holders_sbuf);
  
             DescribeLockTag(&buf, &locallock->tag.lock);
             modename = GetLockmodeName(locallock->tag.lock.locktag_lockmethodid,
                                        lockmode);
             TimestampDifference(get_timeout_start_time(DEADLOCK_TIMEOUT),
                                 GetCurrentTimestamp(),
                                 &secs, &usecs);
             msecs = secs * 1000 + usecs / 1000;
             usecs = usecs % 1000;
  
             /*
              * we loop over the lock's procLocks to gather a list of all
              * holders and waiters. Thus we will be able to provide more
              * detailed information for lock debugging purposes.
              *
              * lock->procLocks contains all processes which hold or wait for
              * this lock.
              */
  
             LWLockAcquire(partitionLock, LW_SHARED);
  
             dlist_foreach(proc_iter, &lock->procLocks)
             {
                 curproclock =
                     dlist_container(PROCLOCK, lockLink, proc_iter.cur);
  
                 /*
                  * we are a waiter if myProc->waitProcLock == curproclock; we
                  * are a holder if it is NULL or something different
                  */
                 if (curproclock->tag.myProc->waitProcLock == curproclock)
                 {
                     if (first_waiter)
                     {
                         appendStringInfo(&lock_waiters_sbuf, "%d",
                                          curproclock->tag.myProc->pid);
                         first_waiter = false;
                     }
                     else
                         appendStringInfo(&lock_waiters_sbuf, ", %d",
                                          curproclock->tag.myProc->pid);
                 }
                 else
                 {
                     if (first_holder)
                     {
                         appendStringInfo(&lock_holders_sbuf, "%d",
                                          curproclock->tag.myProc->pid);
                         first_holder = false;
                     }
                     else
                         appendStringInfo(&lock_holders_sbuf, ", %d",
                                          curproclock->tag.myProc->pid);
  
                     lockHoldersNum++;
                 }
             }
  
             LWLockRelease(partitionLock);
  
             if (deadlock_state == DS_SOFT_DEADLOCK)
                 ereport(LOG,
                         (errmsg("process %d avoided deadlock for %s on %s by rearranging queue order after %ld.%03d ms",
                                 MyProcPid, modename, buf.data, msecs, usecs),
                          (errdetail_log_plural("Process holding the lock: %s. Wait queue: %s.",
                                                "Processes holding the lock: %s. Wait queue: %s.",
                                                lockHoldersNum, lock_holders_sbuf.data, lock_waiters_sbuf.data))));
             else if (deadlock_state == DS_HARD_DEADLOCK)
             {
                 /*
                  * This message is a bit redundant with the error that will be
                  * reported subsequently, but in some cases the error report
                  * might not make it to the log (eg, if it's caught by an
                  * exception handler), and we want to ensure all long-wait
                  * events get logged.
                  */
                 ereport(LOG,
                         (errmsg("process %d detected deadlock while waiting for %s on %s after %ld.%03d ms",
                                 MyProcPid, modename, buf.data, msecs, usecs),
                          (errdetail_log_plural("Process holding the lock: %s. Wait queue: %s.",
                                                "Processes holding the lock: %s. Wait queue: %s.",
                                                lockHoldersNum, lock_holders_sbuf.data, lock_waiters_sbuf.data))));
             }
  
             if (myWaitStatus == PROC_WAIT_STATUS_WAITING)
                 ereport(LOG,
                         (errmsg("process %d still waiting for %s on %s after %ld.%03d ms",
                                 MyProcPid, modename, buf.data, msecs, usecs),
                          (errdetail_log_plural("Process holding the lock: %s. Wait queue: %s.",
                                                "Processes holding the lock: %s. Wait queue: %s.",
                                                lockHoldersNum, lock_holders_sbuf.data, lock_waiters_sbuf.data))));
             else if (myWaitStatus == PROC_WAIT_STATUS_OK)
                 ereport(LOG,
                         (errmsg("process %d acquired %s on %s after %ld.%03d ms",
                                 MyProcPid, modename, buf.data, msecs, usecs)));
             else
             {
                 Assert(myWaitStatus == PROC_WAIT_STATUS_ERROR);
  
                 /*
                  * Currently, the deadlock checker always kicks its own
                  * process, which means that we'll only see
                  * PROC_WAIT_STATUS_ERROR when deadlock_state ==
                  * DS_HARD_DEADLOCK, and there's no need to print redundant
                  * messages.  But for completeness and future-proofing, print
                  * a message if it looks like someone else kicked us off the
                  * lock.
                  */
                 if (deadlock_state != DS_HARD_DEADLOCK)
                     ereport(LOG,
                             (errmsg("process %d failed to acquire %s on %s after %ld.%03d ms",
                                     MyProcPid, modename, buf.data, msecs, usecs),
                              (errdetail_log_plural("Process holding the lock: %s. Wait queue: %s.",
                                                    "Processes holding the lock: %s. Wait queue: %s.",
                                                    lockHoldersNum, lock_holders_sbuf.data, lock_waiters_sbuf.data))));
             }
  
             /*
              * At this point we might still need to wait for the lock. Reset
              * state so we don't print the above messages again.
              */
             deadlock_state = DS_NO_DEADLOCK;
  
             pfree(buf.data);
             pfree(lock_holders_sbuf.data);
             pfree(lock_waiters_sbuf.data);
         }
     } while (myWaitStatus == PROC_WAIT_STATUS_WAITING);
  
     /*
      * Disable the timers, if they are still running.  As in LockErrorCleanup,
      * we must preserve the LOCK_TIMEOUT indicator flag: if a lock timeout has
      * already caused QueryCancelPending to become set, we want the cancel to
      * be reported as a lock timeout, not a user cancel.
      */
     if (!InHotStandby)
     {
         if (LockTimeout > 0)
         {
             DisableTimeoutParams timeouts[2];
  
             timeouts[0].id = DEADLOCK_TIMEOUT;
             timeouts[0].keep_indicator = false;
             timeouts[1].id = LOCK_TIMEOUT;
             timeouts[1].keep_indicator = true;
             disable_timeouts(timeouts, 2);
         }
         else
             disable_timeout(DEADLOCK_TIMEOUT, false);
     }
  
     /*
      * Emit the log message if recovery conflict on lock was resolved but the
      * startup process waited longer than deadlock_timeout for it.
      */
     if (InHotStandby && logged_recovery_conflict)
         LogRecoveryConflict(PROCSIG_RECOVERY_CONFLICT_LOCK,
                             standbyWaitStart, GetCurrentTimestamp(),
                             NULL, false);
  
     /*
      * Re-acquire the lock table's partition lock.  We have to do this to hold
      * off cancel/die interrupts before we can mess with lockAwaited (else we
      * might have a missed or duplicated locallock update).
      */
     LWLockAcquire(partitionLock, LW_EXCLUSIVE);
  
     /*
      * We no longer want LockErrorCleanup to do anything.
      */
     lockAwaited = NULL;
  
     /*
      * If we got the lock, be sure to remember it in the locallock table.
      */
     if (MyProc->waitStatus == PROC_WAIT_STATUS_OK)
         GrantAwaitedLock();
  
     /*
      * We don't have to do anything else, because the awaker did all the
      * necessary update of the lock table and MyProc.
      */
     return MyProc->waitStatus;
 }

References AccessExclusiveLock, appendStringInfo(), Assert(), buf, CHECK_FOR_INTERRUPTS, CheckDeadLock(), CheckRecoveryConflictDeadlock(), LockMethodData::conflictTab, dlist_iter::cur, StringInfoData::data, dclist_foreach, dclist_insert_before(), dclist_is_empty(), dclist_push_tail(), deadlock_state, DEADLOCK_TIMEOUT, DeadlockTimeout, DEBUG1, EnableTimeoutParams::delay_ms, DescribeLockTag(), disable_timeout(), disable_timeouts(), dlist_container, dlist_foreach, DS_BLOCKED_BY_AUTOVACUUM, DS_HARD_DEADLOCK, DS_NO_DEADLOCK, DS_NOT_YET_CHECKED, DS_SOFT_DEADLOCK, enable_timeout_after(), enable_timeouts(), ereport, errdetail_log(), errdetail_log_plural(), errmsg(), errmsg_internal(), get_timeout_start_time(), GetBlockingAutoVacuumPgproc(), GetCurrentTimestamp(), GetLockConflicts(), GetLockmodeName(), got_deadlock_timeout, GrantAwaitedLock(), GrantLock(), PROCLOCK::groupLeader, LOCALLOCK::hashcode, PGPROC::heldLocks, PROCLOCK::holdMask, EnableTimeoutParams::id, DisableTimeoutParams::id, InHotStandby, initStringInfo(), InRecovery, DisableTimeoutParams::keep_indicator, kill, PGPROC::links, links, LOCALLOCKTAG::lock, LOCALLOCK::lock, LOCK_TIMEOUT, lockAwaited, LOCKBIT_ON, LockCheckConflicts(), PGPROC::lockGroupLeader, LockHashPartitionLock, LOCKTAG::locktag_lockmethodid, LOCKTAG::locktag_type, LockTimeout, LOG, log_lock_waits, log_recovery_conflict_waits, LogRecoveryConflict(), LW_EXCLUSIVE, LW_SHARED, LWLockAcquire(), LWLockRelease(), message_level_is_interesting(), LOCALLOCKTAG::mode, MyLatch, MyProc, PROCLOCKTAG::myProc, MyProcPid, now(), pfree(), pg_atomic_write_u64(), PG_WAIT_LOCK, PGPROC::pgxactoff, PGPROC::pid, PROC_IS_AUTOVACUUM, PROC_VACUUM_FOR_WRAPAROUND, PROC_WAIT_STATUS_ERROR, PROC_WAIT_STATUS_OK, PROC_WAIT_STATUS_WAITING, ProcGlobal, LOCALLOCK::proclock, LOCK::procLocks, PROCSIG_RECOVERY_CONFLICT_LOCK, RecoveryInProgress(), RememberSimpleDeadLock(), RemoveFromWaitQueue(), ResetLatch(), ResolveRecoveryConflictWithLock(), PROC_HDR::statusFlags, LOCK::tag, PROCLOCK::tag, LOCALLOCK::tag, TimestampDifference(), TimestampDifferenceExceeds(), TMPARAM_AFTER, EnableTimeoutParams::type, WaitLatch(), PGPROC::waitLock, PGPROC::waitLockMode, LOCK::waitMask, PGPROC::waitProcLock, LOCK::waitProcs, PGPROC::waitStart, PGPROC::waitStatus, WARNING, WL_EXIT_ON_PM_DEATH, and WL_LATCH_SET.

Referenced by WaitOnLock().

◆ ProcWaitForSignal()

void ProcWaitForSignal ( uint32 wait_event_info )

Definition at line 1797 of file proc.c.

 {
     (void) WaitLatch(MyLatch, WL_LATCH_SET | WL_EXIT_ON_PM_DEATH, 0,
                      wait_event_info);
     ResetLatch(MyLatch);
     CHECK_FOR_INTERRUPTS();
 }

References CHECK_FOR_INTERRUPTS, MyLatch, ResetLatch(), WaitLatch(), WL_EXIT_ON_PM_DEATH, and WL_LATCH_SET.

Referenced by GetSafeSnapshot(), LockBufferForCleanup(), ResolveRecoveryConflictWithBufferPin(), and ResolveRecoveryConflictWithLock().

◆ ProcWakeup()

void ProcWakeup	(	PGPROC *	proc,
		ProcWaitStatus	waitStatus
	)

Definition at line 1609 of file proc.c.

 {
     if (dlist_node_is_detached(&proc->links))
         return;
  
     Assert(proc->waitStatus == PROC_WAIT_STATUS_WAITING);
  
     /* Remove process from wait queue */
     dclist_delete_from_thoroughly(&proc->waitLock->waitProcs, &proc->links);
  
     /* Clean up process' state and pass it the ok/fail signal */
     proc->waitLock = NULL;
     proc->waitProcLock = NULL;
     proc->waitStatus = waitStatus;
     pg_atomic_write_u64(&MyProc->waitStart, 0);
  
     /* And awaken it */
     SetLatch(&proc->procLatch);
 }

References Assert(), dclist_delete_from_thoroughly(), dlist_node_is_detached(), PGPROC::links, MyProc, pg_atomic_write_u64(), PROC_WAIT_STATUS_WAITING, PGPROC::procLatch, SetLatch(), PGPROC::waitLock, PGPROC::waitProcLock, LOCK::waitProcs, PGPROC::waitStart, and PGPROC::waitStatus.

Referenced by ProcLockWakeup().

◆ RemoveProcFromArray()

static void RemoveProcFromArray	(	int	code,
		Datum	arg
	)

static

Definition at line 791 of file proc.c.

 {
     Assert(MyProc != NULL);
     ProcArrayRemove(MyProc, InvalidTransactionId);
 }

References Assert(), InvalidTransactionId, MyProc, and ProcArrayRemove().

Referenced by InitProcessPhase2().

◆ SetStartupBufferPinWaitBufId()

void SetStartupBufferPinWaitBufId ( int bufid )

Definition at line 627 of file proc.c.

 {
     /* use volatile pointer to prevent code rearrangement */
     volatile PROC_HDR *procglobal = ProcGlobal;
  
     procglobal->startupBufferPinWaitBufId = bufid;
 }

References ProcGlobal, and PROC_HDR::startupBufferPinWaitBufId.

Referenced by LockBufferForCleanup().

Variable Documentation

◆ AuxiliaryProcs

NON_EXEC_STATIC PGPROC* AuxiliaryProcs = NULL

Definition at line 79 of file proc.c.

Referenced by AuxiliaryPidGetProc(), AuxiliaryProcKill(), InitAuxiliaryProcess(), and InitProcGlobal().

◆ deadlock_state

DeadLockState deadlock_state = DS_NOT_YET_CHECKED

static

Definition at line 85 of file proc.c.

Referenced by CheckDeadLock(), and ProcSleep().

◆ DeadlockTimeout

int DeadlockTimeout = 1000

Definition at line 58 of file proc.c.

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

◆ got_deadlock_timeout

volatile sig_atomic_t got_deadlock_timeout

static

Definition at line 88 of file proc.c.

Referenced by CheckDeadLockAlert(), and ProcSleep().

◆ IdleInTransactionSessionTimeout

int IdleInTransactionSessionTimeout = 0

Definition at line 61 of file proc.c.

Referenced by PostgresMain(), and ProcessInterrupts().

◆ IdleSessionTimeout

int IdleSessionTimeout = 0

Definition at line 62 of file proc.c.

Referenced by PostgresMain(), and ProcessInterrupts().

◆ lockAwaited

LOCALLOCK* lockAwaited = NULL

static

Definition at line 83 of file proc.c.

Referenced by IsWaitingForLock(), LockErrorCleanup(), and ProcSleep().

◆ LockTimeout

int LockTimeout = 0

Definition at line 60 of file proc.c.

Referenced by ProcSleep().

◆ log_lock_waits

bool log_lock_waits = false

Definition at line 63 of file proc.c.

Referenced by ProcSleep().

◆ MyProc

PGPROC* MyProc = NULL

Definition at line 66 of file proc.c.

Referenced by _bt_parallel_build_main(), AbortTransaction(), AtEOSubXact_Namespace(), AtEOXact_Namespace(), AtEOXact_Snapshot(), attach_to_queues(), AutoVacWorkerMain(), AuxiliaryProcKill(), BackgroundWriterMain(), BaseInit(), BecomeLockGroupLeader(), BecomeLockGroupMember(), CheckDeadLock(), CheckpointerMain(), CommitTransaction(), ComputeXidHorizons(), ConditionVariableBroadcast(), ConditionVariableCancelSleep(), ConditionVariablePrepareToSleep(), ConditionVariableTimedSleep(), CountOtherDBBackends(), CreateReplicationSlot(), DefineIndex(), EndPrepare(), errdetail_abort(), exec_eval_simple_expr(), exec_simple_check_plan(), exec_stmt_call(), ExecParallelGetReceiver(), ExecParallelSetupTupleQueues(), ExportSnapshot(), FastPathGetRelationLockEntry(), FastPathGrantRelationLock(), FastPathUnGrantRelationLock(), FindLockCycleRecurseMember(), fmgr_sql(), get_cast_hashentry(), GetCurrentVirtualXIDs(), GetLockConflicts(), GetNewTransactionId(), GetSerializableTransactionSnapshotInt(), GetSnapshotData(), GetSnapshotDataReuse(), GetStableLatestTransactionId(), init_sql_fcache(), InitAuxiliaryProcess(), InitBufferPoolAccess(), InitializeParallelDSM(), InitializeSessionUserId(), InitPostgres(), InitProcess(), InitProcessPhase2(), InitTempTableNamespace(), InitWalSenderSlot(), lock_and_open_sequence(), LockAcquireExtended(), LockBufferForCleanup(), LockCheckConflicts(), LockErrorCleanup(), LockRelease(), LockReleaseAll(), log_status_format(), logicalrep_worker_attach(), LWLockAcquire(), LWLockAcquireOrWait(), LWLockAttemptLock(), LWLockDequeueSelf(), LWLockQueueSelf(), LWLockWaitForVar(), MarkAsPreparingGuts(), MarkBufferDirtyHint(), MinimumActiveBackends(), pa_setup_dsm(), parallel_vacuum_main(), ParallelApplyWorkerMain(), ParallelWorkerMain(), PgArchiverMain(), pgstat_report_activity(), PhysicalReplicationSlotNewXmin(), PostPrepare_Locks(), PrepareTransaction(), ProcArrayGroupClearXid(), ProcArrayInstallImportedXmin(), ProcArrayInstallRestoredXmin(), ProcessRecoveryConflictInterrupt(), ProcessStandbyHSFeedbackMessage(), ProcKill(), ProcReleaseLocks(), ProcSleep(), ProcWakeup(), RecordTransactionCommit(), RecordTransactionCommitPrepared(), ReinitializeParallelDSM(), RelationTruncate(), RemoveProcFromArray(), ReplicationSlotRelease(), ResolveRecoveryConflictWithLock(), set_indexsafe_procflags(), setup_dynamic_shared_memory(), SharedInvalBackendInit(), shm_mq_attach(), shm_mq_detach_internal(), shm_mq_receive(), shm_mq_sendv(), shm_mq_wait_for_attach(), SnapBuildInitialSnapshot(), SnapshotResetXmin(), StartTransaction(), StartupDecodingContext(), SwitchBackToLocalLatch(), SwitchToSharedLatch(), SyncRepCancelWait(), SyncRepCleanupAtProcExit(), SyncRepQueueInsert(), SyncRepWaitForLSN(), TerminateOtherDBBackends(), TransactionGroupUpdateXidStatus(), TransactionIdIsInProgress(), TransactionIdSetPageStatus(), TruncateMultiXact(), UnlockBuffers(), vacuum_rel(), VirtualXactLockTableCleanup(), VirtualXactLockTableInsert(), WaitXLogInsertionsToFinish(), WALInsertLockAcquire(), WalReceiverMain(), WalWriterMain(), write_csvlog(), write_jsonlog(), XidCacheRemoveRunningXids(), and XLogSaveBufferForHint().

◆ PreparedXactProcs

PGPROC* PreparedXactProcs = NULL

Definition at line 80 of file proc.c.

Referenced by InitProcGlobal(), and TwoPhaseShmemInit().

◆ ProcGlobal

PROC_HDR* ProcGlobal = NULL

Definition at line 78 of file proc.c.

Referenced by AuxiliaryProcKill(), BackendXidGetPid(), CheckpointerMain(), ComputeXidHorizons(), CountOtherDBBackends(), CreateSharedProcArray(), FastPathTransferRelationLocks(), FinishPreparedTransaction(), ForwardSyncRequest(), GetCurrentVirtualXIDs(), GetLockConflicts(), GetLockStatusData(), GetNewTransactionId(), GetOldestActiveTransactionId(), GetOldestSafeDecodingTransactionId(), GetRunningTransactionData(), GetSnapshotData(), GetStartupBufferPinWaitBufId(), GXactLoadSubxactData(), HaveNFreeProcs(), InitAuxiliaryProcess(), InitProcess(), InitProcGlobal(), LockGXact(), MarkAsPrepared(), MarkAsPreparingGuts(), pg_prepared_xact(), PgArchWakeup(), ProcArrayAdd(), ProcArrayClearTransaction(), ProcArrayEndTransaction(), ProcArrayEndTransactionInternal(), ProcArrayGroupClearXid(), ProcArrayInstallImportedXmin(), ProcArrayInstallRestoredXmin(), ProcArrayRemove(), ProcGlobalShmemSize(), ProcKill(), ProcSendSignal(), ProcSleep(), ReplicationSlotRelease(), set_indexsafe_procflags(), SetStartupBufferPinWaitBufId(), StartPrepare(), StartupDecodingContext(), StrategyGetBuffer(), TransactionGroupUpdateXidStatus(), TransactionIdIsActive(), TransactionIdIsInProgress(), TwoPhaseGetDummyProc(), TwoPhaseGetXidByVirtualXID(), vacuum_rel(), WalWriterMain(), XidCacheRemoveRunningXids(), and XLogSetAsyncXactLSN().

◆ ProcStructLock

NON_EXEC_STATIC slock_t* ProcStructLock = NULL

Definition at line 75 of file proc.c.

Referenced by AuxiliaryProcKill(), HaveNFreeProcs(), InitAuxiliaryProcess(), InitProcess(), InitProcGlobal(), and ProcKill().

◆ StatementTimeout

int StatementTimeout = 0

Definition at line 59 of file proc.c.

Referenced by enable_statement_timeout().

Functions

Variables

Function Documentation

◆ AuxiliaryPidGetProc()

◆ AuxiliaryProcKill()

◆ BecomeLockGroupLeader()

◆ BecomeLockGroupMember()

◆ CheckDeadLock()

◆ CheckDeadLockAlert()

◆ GetStartupBufferPinWaitBufId()

◆ HaveNFreeProcs()

◆ InitAuxiliaryProcess()

◆ InitProcess()

◆ InitProcessPhase2()

◆ InitProcGlobal()

◆ IsWaitingForLock()

◆ LockErrorCleanup()

◆ ProcGlobalSemas()

◆ ProcGlobalShmemSize()

◆ ProcKill()

◆ ProcLockWakeup()

◆ ProcReleaseLocks()

◆ ProcSendSignal()

◆ ProcSleep()

◆ ProcWaitForSignal()

◆ ProcWakeup()

◆ RemoveProcFromArray()

◆ SetStartupBufferPinWaitBufId()

Variable Documentation

◆ AuxiliaryProcs

◆ deadlock_state

◆ DeadlockTimeout

◆ got_deadlock_timeout

◆ IdleInTransactionSessionTimeout

◆ IdleSessionTimeout

◆ lockAwaited

◆ LockTimeout

◆ log_lock_waits

◆ MyProc

◆ PreparedXactProcs

◆ ProcGlobal

◆ ProcStructLock

◆ StatementTimeout