proc.c File Reference

#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 "access/xlogwait.h"
#include "miscadmin.h"
#include "pgstat.h"
#include "postmaster/autovacuum.h"
#include "replication/slotsync.h"
#include "replication/syncrep.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:

Go to the source code of this file.

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)
static Size	PGProcShmemSize (void)
static Size	FastPathLockShmemSize (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)
void	LockErrorCleanup (void)
void	ProcReleaseLocks (bool isCommit)
PGPROC *	AuxiliaryPidGetProc (int pid)
ProcWaitStatus	JoinWaitQueue (LOCALLOCK *locallock, LockMethod lockMethodTable, bool dontWait)
ProcWaitStatus	ProcSleep (LOCALLOCK *locallock)
void	ProcWakeup (PGPROC *proc, ProcWaitStatus waitStatus)
void	ProcLockWakeup (LockMethod lockMethodTable, LOCK *lock)
void	CheckDeadLockAlert (void)
void	GetLockHoldersAndWaiters (LOCALLOCK *locallock, StringInfo lock_holders_sbuf, StringInfo lock_waiters_sbuf, int *lockHoldersNum)
void	ProcWaitForSignal (uint32 wait_event_info)
void	ProcSendSignal (ProcNumber procNumber)
void	BecomeLockGroupLeader (void)
bool	BecomeLockGroupMember (PGPROC *leader, int pid)

Variables
int	DeadlockTimeout = 1000
int	StatementTimeout = 0
int	LockTimeout = 0
int	IdleInTransactionSessionTimeout = 0
int	TransactionTimeout = 0
int	IdleSessionTimeout = 0
bool	log_lock_waits = true
PGPROC *	MyProc = NULL
NON_EXEC_STATIC slock_t *	ProcStructLock = NULL
PROC_HDR *	ProcGlobal = NULL
NON_EXEC_STATIC PGPROC *	AuxiliaryProcs = NULL
PGPROC *	PreparedXactProcs = 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 1097 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, fb(), NUM_AUXILIARY_PROCS, and PGPROC::pid.

Referenced by pg_log_backend_memory_contexts(), pg_stat_get_activity(), pg_stat_reset_backend_stats(), and pgstat_fetch_stat_backend_by_pid().

AuxiliaryProcKill()

static void AuxiliaryProcKill ( int  code, Datum  arg  )

static

Definition at line 1046 of file proc.c.

{
    int         proctype = DatumGetInt32(arg);
    PGPROC     *auxproc PG_USED_FOR_ASSERTS_ONLY;
    PGPROC     *proc;
 
    Assert(proctype >= 0 && proctype < NUM_AUXILIARY_PROCS);
 
    /* not safe if forked by system(), etc. */
    if (MyProc->pid != (int) getpid())
        elog(PANIC, "AuxiliaryProcKill() called in child process");
 
    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;
    MyProcNumber = INVALID_PROC_NUMBER;
    DisownLatch(&proc->procLatch);
 
    SpinLockAcquire(ProcStructLock);
 
    /* Mark auxiliary proc no longer in use */
    proc->pid = 0;
    proc->vxid.procNumber = INVALID_PROC_NUMBER;
    proc->vxid.lxid = InvalidTransactionId;
 
    /* 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(), elog, fb(), INVALID_PROC_NUMBER, InvalidTransactionId, LWLockReleaseAll(), PGPROC::lxid, MyProc, MyProcNumber, NUM_AUXILIARY_PROCS, PANIC, PG_USED_FOR_ASSERTS_ONLY, pgstat_reset_wait_event_storage(), PGPROC::pid, ProcGlobal, PGPROC::procLatch, PGPROC::procNumber, ProcStructLock, SpinLockAcquire, SpinLockRelease, PROC_HDR::spins_per_delay, SwitchBackToLocalLatch(), update_spins_per_delay(), and PGPROC::vxid.

Referenced by InitAuxiliaryProcess().

BecomeLockGroupLeader()

void BecomeLockGroupLeader

(

void

)

Definition at line 2007 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(), fb(), 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 2037 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
     * calculates the proc number based on the PGPROC slot without looking at
     * its contents, 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(), fb(), 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 1793 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, fb(), 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 1879 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 fb(), got_deadlock_timeout, MyLatch, and SetLatch().

Referenced by InitPostgres(), and ProcessRecoveryConflictInterrupt().

FastPathLockShmemSize()

static Size FastPathLockShmemSize ( void  )

static

Definition at line 116 of file proc.c.

{
    Size        size = 0;
    Size        TotalProcs =
        add_size(MaxBackends, add_size(NUM_AUXILIARY_PROCS, max_prepared_xacts));
    Size        fpLockBitsSize,
                fpRelIdSize;
 
    /*
     * Memory needed for PGPROC fast-path lock arrays. Make sure the sizes are
     * nicely aligned in each backend.
     */
    fpLockBitsSize = MAXALIGN(FastPathLockGroupsPerBackend * sizeof(uint64));
    fpRelIdSize = MAXALIGN(FastPathLockSlotsPerBackend() * sizeof(Oid));
 
    size = add_size(size, mul_size(TotalProcs, (fpLockBitsSize + fpRelIdSize)));
 
    return size;
}

References add_size(), FastPathLockGroupsPerBackend, FastPathLockSlotsPerBackend, fb(), max_prepared_xacts, MAXALIGN, MaxBackends, mul_size(), and NUM_AUXILIARY_PROCS.

Referenced by InitProcGlobal(), and ProcGlobalShmemSize().

GetLockHoldersAndWaiters()

void GetLockHoldersAndWaiters	(	LOCALLOCK *	locallock,
		StringInfo	lock_holders_sbuf,
		StringInfo	lock_waiters_sbuf,
		int *	lockHoldersNum
	)

Definition at line 1906 of file proc.c.

{
    dlist_iter  proc_iter;
    PROCLOCK   *curproclock;
    LOCK       *lock = locallock->lock;
    bool        first_holder = true,
                first_waiter = true;
 
#ifdef USE_ASSERT_CHECKING
    {
        uint32      hashcode = locallock->hashcode;
        LWLock     *partitionLock = LockHashPartitionLock(hashcode);
 
        Assert(LWLockHeldByMe(partitionLock));
    }
#endif
 
    *lockHoldersNum = 0;
 
    /*
     * 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.
     */
    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)++;
        }
    }
}

References appendStringInfo(), Assert, dlist_container, dlist_foreach, fb(), LockHashPartitionLock, LWLockHeldByMe(), and LOCK::procLocks.

Referenced by LockAcquireExtended(), and ProcSleep().

GetStartupBufferPinWaitBufId()

int GetStartupBufferPinWaitBufId

(

void

)

Definition at line 771 of file proc.c.

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

References fb(), ProcGlobal, and PROC_HDR::startupBufferPinWaitBufId.

Referenced by HoldingBufferPinThatDelaysRecovery(), and ProcessRecoveryConflictInterrupt().

HaveNFreeProcs()

bool HaveNFreeProcs	(	int	n,
		int *	nfree
	)

Definition at line 787 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 620 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");
 
    if (IsUnderPostmaster)
        RegisterPostmasterChildActive();
 
    /*
     * 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;
 
    SpinLockRelease(ProcStructLock);
 
    MyProc = auxproc;
    MyProcNumber = GetNumberFromPGProc(MyProc);
 
    /*
     * Initialize all fields of MyProc, except for those previously
     * initialized by InitProcGlobal.
     */
    dlist_node_init(&MyProc->links);
    MyProc->waitStatus = PROC_WAIT_STATUS_OK;
    MyProc->fpVXIDLock = false;
    MyProc->fpLocalTransactionId = InvalidLocalTransactionId;
    MyProc->xid = InvalidTransactionId;
    MyProc->xmin = InvalidTransactionId;
    MyProc->vxid.procNumber = INVALID_PROC_NUMBER;
    MyProc->vxid.lxid = InvalidLocalTransactionId;
    MyProc->databaseId = InvalidOid;
    MyProc->roleId = InvalidOid;
    MyProc->tempNamespaceId = InvalidOid;
    MyProc->isRegularBackend = false;
    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));
 
    /*
     * Now that we have a PGPROC, we could try to acquire lightweight locks.
     * Initialize local state needed for them.  (Heavyweight locks cannot be
     * acquired in aux processes.)
     */
    InitLWLockAccess();
 
#ifdef EXEC_BACKEND
 
    /*
     * Initialize backend-local pointers to all the shared data structures.
     * (We couldn't do this until now because it needs LWLocks.)
     */
    if (IsUnderPostmaster)
        AttachSharedMemoryStructs();
#endif
}

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

Referenced by AuxiliaryProcessMainCommon().

InitProcess()

void InitProcess

(

void

)

Definition at line 395 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");
 
    /*
     * Before we start accessing the shared memory in a serious way, mark
     * ourselves as an active postmaster child; this is so that the postmaster
     * can detect it if we exit without cleaning up.
     */
    if (IsUnderPostmaster)
        RegisterPostmasterChildActive();
 
    /*
     * Decide which list should supply our PGPROC.  This logic must match the
     * way the freelists were constructed in InitProcGlobal().
     */
    if (AmAutoVacuumWorkerProcess() || AmSpecialWorkerProcess())
        procgloballist = &ProcGlobal->autovacFreeProcs;
    else if (AmBackgroundWorkerProcess())
        procgloballist = &ProcGlobal->bgworkerFreeProcs;
    else if (AmWalSenderProcess())
        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 = dlist_container(PGPROC, links, 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 (AmWalSenderProcess())
            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")));
    }
    MyProcNumber = GetNumberFromPGProc(MyProc);
 
    /*
     * 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);
 
    /*
     * Initialize all fields of MyProc, except for those previously
     * initialized by InitProcGlobal.
     */
    dlist_node_init(&MyProc->links);
    MyProc->waitStatus = PROC_WAIT_STATUS_OK;
    MyProc->fpVXIDLock = false;
    MyProc->fpLocalTransactionId = InvalidLocalTransactionId;
    MyProc->xid = InvalidTransactionId;
    MyProc->xmin = InvalidTransactionId;
    MyProc->pid = MyProcPid;
    MyProc->vxid.procNumber = MyProcNumber;
    MyProc->vxid.lxid = InvalidLocalTransactionId;
    /* databaseId and roleId will be filled in later */
    MyProc->databaseId = InvalidOid;
    MyProc->roleId = InvalidOid;
    MyProc->tempNamespaceId = InvalidOid;
    MyProc->isRegularBackend = AmRegularBackendProcess();
    MyProc->delayChkptFlags = 0;
    MyProc->statusFlags = 0;
    /* NB -- autovac launcher intentionally does not set IS_AUTOVACUUM */
    if (AmAutoVacuumWorkerProcess())
        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_PROC_NUMBER);
 
    /* 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_PROC_NUMBER);
 
    /*
     * 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();
 
#ifdef EXEC_BACKEND
 
    /*
     * Initialize backend-local pointers to all the shared data structures.
     * (We couldn't do this until now because it needs LWLocks.)
     */
    if (IsUnderPostmaster)
        AttachSharedMemoryStructs();
#endif
}

References AmAutoVacuumWorkerProcess, AmBackgroundWorkerProcess, AmRegularBackendProcess, AmSpecialWorkerProcess, AmWalSenderProcess, Assert, PROC_HDR::autovacFreeProcs, PROC_HDR::bgworkerFreeProcs, PGPROC::clogGroupMember, PGPROC::clogGroupMemberLsn, PGPROC::clogGroupMemberPage, PGPROC::clogGroupMemberXid, PGPROC::clogGroupMemberXidStatus, PGPROC::clogGroupNext, PGPROC::databaseId, PGPROC::delayChkptFlags, dlist_container, dlist_is_empty(), dlist_node_init(), dlist_pop_head_node(), elog, ereport, errcode(), errmsg(), ERROR, FATAL, fb(), PGPROC::fpLocalTransactionId, PGPROC::fpVXIDLock, PROC_HDR::freeProcs, GetNumberFromPGProc, i, InitDeadLockChecking(), InitLWLockAccess(), INVALID_PROC_NUMBER, InvalidLocalTransactionId, InvalidOid, InvalidTransactionId, InvalidXLogRecPtr, PGPROC::isRegularBackend, IsUnderPostmaster, PGPROC::links, links, PGPROC::lockGroupLeader, PGPROC::lockGroupMembers, LW_WS_NOT_WAITING, PGPROC::lwWaiting, PGPROC::lwWaitMode, PGPROC::lxid, max_wal_senders, MyProc, PGPROC::myProcLocks, MyProcNumber, 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, PGPROC::procNumber, ProcStructLock, PGPROC::recoveryConflictPending, RegisterPostmasterChildActive(), 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::vxid, 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(), BackendMain(), BackgroundWorkerMain(), BootstrapModeMain(), PostgresSingleUserMain(), and ReplSlotSyncWorkerMain().

InitProcessPhase2()

void InitProcessPhase2

(

void

)

Definition at line 585 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, fb(), MyProc, on_shmem_exit(), ProcArrayAdd(), and RemoveProcFromArray().

Referenced by InitPostgres().

InitProcGlobal()

void InitProcGlobal

(

void

)

Definition at line 194 of file proc.c.

{
    PGPROC     *procs;
    int         i,
                j;
    bool        found;
    uint32      TotalProcs = MaxBackends + NUM_AUXILIARY_PROCS + max_prepared_xacts;
 
    /* Used for setup of per-backend fast-path slots. */
    char       *fpPtr,
               *fpEndPtr PG_USED_FOR_ASSERTS_ONLY;
    Size        fpLockBitsSize,
                fpRelIdSize;
    Size        requestSize;
    char       *ptr;
 
    /* 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->walwriterProc = INVALID_PROC_NUMBER;
    ProcGlobal->checkpointerProc = INVALID_PROC_NUMBER;
    pg_atomic_init_u32(&ProcGlobal->procArrayGroupFirst, INVALID_PROC_NUMBER);
    pg_atomic_init_u32(&ProcGlobal->clogGroupFirst, INVALID_PROC_NUMBER);
 
    /*
     * Create and initialize all the PGPROC structures we'll need.  There are
     * six separate consumers: (1) normal backends, (2) autovacuum workers and
     * special workers, (3) background workers, (4) walsenders, (5) auxiliary
     * processes, and (6) prepared transactions.  (For largely-historical
     * reasons, we combine autovacuum and special workers into one category
     * with a single freelist.)  Each PGPROC structure is dedicated to exactly
     * one of these purposes, and they do not move between groups.
     */
    requestSize = PGProcShmemSize();
 
    ptr = ShmemInitStruct("PGPROC structures",
                          requestSize,
                          &found);
 
    MemSet(ptr, 0, requestSize);
 
    procs = (PGPROC *) ptr;
    ptr = ptr + 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 *) ptr;
    ptr = ptr + (TotalProcs * sizeof(*ProcGlobal->xids));
 
    ProcGlobal->subxidStates = (XidCacheStatus *) ptr;
    ptr = ptr + (TotalProcs * sizeof(*ProcGlobal->subxidStates));
 
    ProcGlobal->statusFlags = (uint8 *) ptr;
    ptr = ptr + (TotalProcs * sizeof(*ProcGlobal->statusFlags));
 
    /* make sure wer didn't overflow */
    Assert((ptr > (char *) procs) && (ptr <= (char *) procs + requestSize));
 
    /*
     * Allocate arrays for fast-path locks. Those are variable-length, so
     * can't be included in PGPROC directly. We allocate a separate piece of
     * shared memory and then divide that between backends.
     */
    fpLockBitsSize = MAXALIGN(FastPathLockGroupsPerBackend * sizeof(uint64));
    fpRelIdSize = MAXALIGN(FastPathLockSlotsPerBackend() * sizeof(Oid));
 
    requestSize = FastPathLockShmemSize();
 
    fpPtr = ShmemInitStruct("Fast-Path Lock Array",
                            requestSize,
                            &found);
 
    MemSet(fpPtr, 0, requestSize);
 
    /* For asserts checking we did not overflow. */
    fpEndPtr = fpPtr + requestSize;
 
    /* Reserve space for semaphores. */
    PGReserveSemaphores(ProcGlobalSemas());
 
    for (i = 0; i < TotalProcs; i++)
    {
        PGPROC     *proc = &procs[i];
 
        /* Common initialization for all PGPROCs, regardless of type. */
 
        /*
         * Set the fast-path lock arrays, and move the pointer. We interleave
         * the two arrays, to (hopefully) get some locality for each backend.
         */
        proc->fpLockBits = (uint64 *) fpPtr;
        fpPtr += fpLockBitsSize;
 
        proc->fpRelId = (Oid *) fpPtr;
        fpPtr += fpRelIdSize;
 
        Assert(fpPtr <= fpEndPtr);
 
        /*
         * 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);
        }
 
        /*
         * Newly created PGPROCs for normal backends, autovacuum workers,
         * special workers, bgworkers, and walsenders 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_tail(&ProcGlobal->freeProcs, &proc->links);
            proc->procgloballist = &ProcGlobal->freeProcs;
        }
        else if (i < MaxConnections + autovacuum_worker_slots + NUM_SPECIAL_WORKER_PROCS)
        {
            /* PGPROC for AV or special worker, add to autovacFreeProcs list */
            dlist_push_tail(&ProcGlobal->autovacFreeProcs, &proc->links);
            proc->procgloballist = &ProcGlobal->autovacFreeProcs;
        }
        else if (i < MaxConnections + autovacuum_worker_slots + NUM_SPECIAL_WORKER_PROCS + max_worker_processes)
        {
            /* PGPROC for bgworker, add to bgworkerFreeProcs list */
            dlist_push_tail(&ProcGlobal->bgworkerFreeProcs, &proc->links);
            proc->procgloballist = &ProcGlobal->bgworkerFreeProcs;
        }
        else if (i < MaxBackends)
        {
            /* PGPROC for walsender, add to walsenderFreeProcs list */
            dlist_push_tail(&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_PROC_NUMBER);
        pg_atomic_init_u32(&(proc->clogGroupNext), INVALID_PROC_NUMBER);
        pg_atomic_init_u64(&(proc->waitStart), 0);
    }
 
    /* Should have consumed exactly the expected amount of fast-path memory. */
    Assert(fpPtr == fpEndPtr);
 
    /*
     * 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 *) ShmemInitStruct("ProcStructLock spinlock",
                                                 sizeof(slock_t),
                                                 &found);
    SpinLockInit(ProcStructLock);
}

References PROC_HDR::allProcCount, PROC_HDR::allProcs, Assert, PROC_HDR::autovacFreeProcs, autovacuum_worker_slots, AuxiliaryProcs, PROC_HDR::bgworkerFreeProcs, PROC_HDR::checkpointerProc, PROC_HDR::clogGroupFirst, PGPROC::clogGroupNext, DEFAULT_SPINS_PER_DELAY, dlist_init(), dlist_push_tail(), FastPathLockGroupsPerBackend, FastPathLockShmemSize(), FastPathLockSlotsPerBackend, fb(), PGPROC::fpInfoLock, PGPROC::fpLockBits, PGPROC::fpRelId, PROC_HDR::freeProcs, i, InitSharedLatch(), INVALID_PROC_NUMBER, j, PGPROC::links, PGPROC::lockGroupMembers, LWLockInitialize(), max_prepared_xacts, max_worker_processes, MAXALIGN, MaxBackends, MaxConnections, MemSet, PGPROC::myProcLocks, NUM_AUXILIARY_PROCS, NUM_LOCK_PARTITIONS, NUM_SPECIAL_WORKER_PROCS, pg_atomic_init_u32(), pg_atomic_init_u64(), PG_USED_FOR_ASSERTS_ONLY, PGProcShmemSize(), PGReserveSemaphores(), PGSemaphoreCreate(), PreparedXactProcs, PROC_HDR::procArrayGroupFirst, PGPROC::procArrayGroupNext, ProcGlobal, PGPROC::procgloballist, ProcGlobalSemas(), PGPROC::procLatch, ProcStructLock, PGPROC::sem, ShmemInitStruct(), SpinLockInit, PROC_HDR::spins_per_delay, PROC_HDR::startupBufferPinWaitBufId, PROC_HDR::statusFlags, PROC_HDR::subxidStates, PGPROC::waitStart, PROC_HDR::walsenderFreeProcs, PROC_HDR::walwriterProc, and PROC_HDR::xids.

Referenced by CreateOrAttachShmemStructs().

JoinWaitQueue()

ProcWaitStatus JoinWaitQueue	(	LOCALLOCK *	locallock,
		LockMethod	lockMethodTable,
		bool	dontWait
	)

Definition at line 1146 of file proc.c.

{
    LOCKMODE    lockmode = locallock->tag.mode;
    LOCK       *lock = locallock->lock;
    PROCLOCK   *proclock = locallock->proclock;
    uint32      hashcode = locallock->hashcode;
    LWLock     *partitionLock PG_USED_FOR_ASSERTS_ONLY = LockHashPartitionLock(hashcode);
    dclist_head *waitQueue = &lock->waitProcs;
    PGPROC     *insert_before = NULL;
    LOCKMASK    myProcHeldLocks;
    LOCKMASK    myHeldLocks;
    bool        early_deadlock = false;
    PGPROC     *leader = MyProc->lockGroupLeader;
 
    Assert(LWLockHeldByMeInMode(partitionLock, LW_EXCLUSIVE));
 
    /*
     * Set bitmask of locks this process already holds on this object.
     */
    myHeldLocks = MyProc->heldLocks = proclock->holdMask;
 
    /*
     * Determine which locks we're already holding.
     *
     * 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.
     */
    myProcHeldLocks = proclock->holdMask;
    myHeldLocks = myProcHeldLocks;
    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);
                    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);
        }
    }
 
    /*
     * If we detected deadlock, give up without waiting.  This must agree with
     * CheckDeadLock's recovery code.
     */
    if (early_deadlock)
        return PROC_WAIT_STATUS_ERROR;
 
    /*
     * At this point we know that we'd really need to sleep. If we've been
     * commanded not to do that, bail out.
     */
    if (dontWait)
        return PROC_WAIT_STATUS_ERROR;
 
    /*
     * 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->heldLocks = myProcHeldLocks;
    MyProc->waitLock = lock;
    MyProc->waitProcLock = proclock;
    MyProc->waitLockMode = lockmode;
 
    MyProc->waitStatus = PROC_WAIT_STATUS_WAITING;
 
    return PROC_WAIT_STATUS_WAITING;
}

References Assert, dlist_iter::cur, dclist_foreach, dclist_insert_before(), dclist_is_empty(), dclist_push_tail(), dlist_container, dlist_foreach, fb(), GrantLock(), PGPROC::heldLocks, PROCLOCK::holdMask, PGPROC::links, links, LOCKBIT_ON, LockCheckConflicts(), PGPROC::lockGroupLeader, LockHashPartitionLock, LW_EXCLUSIVE, LWLockHeldByMeInMode(), MyProc, PG_USED_FOR_ASSERTS_ONLY, PROC_WAIT_STATUS_ERROR, PROC_WAIT_STATUS_OK, PROC_WAIT_STATUS_WAITING, LOCK::procLocks, RememberSimpleDeadLock(), PGPROC::waitLock, PGPROC::waitLockMode, LOCK::waitMask, PGPROC::waitProcLock, LOCK::waitProcs, and PGPROC::waitStatus.

Referenced by LockAcquireExtended().

LockErrorCleanup()

void LockErrorCleanup

(

void

)

Definition at line 818 of file proc.c.

{
    LOCALLOCK  *lockAwaited;
    LWLock     *partitionLock;
    DisableTimeoutParams timeouts[2];
 
    HOLD_INTERRUPTS();
 
    AbortStrongLockAcquire();
 
    /* Nothing to do if we weren't waiting for a lock */
    lockAwaited = GetAwaitedLock();
    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();
    }
 
    ResetAwaitedLock();
 
    LWLockRelease(partitionLock);
 
    RESUME_INTERRUPTS();
}

References AbortStrongLockAcquire(), DEADLOCK_TIMEOUT, disable_timeouts(), dlist_node_is_detached(), fb(), GetAwaitedLock(), GrantAwaitedLock(), HOLD_INTERRUPTS, PGPROC::links, LOCK_TIMEOUT, LockHashPartitionLock, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MyProc, PROC_WAIT_STATUS_OK, RemoveFromWaitQueue(), ResetAwaitedLock(), RESUME_INTERRUPTS, and PGPROC::waitStatus.

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

PGProcShmemSize()

static Size PGProcShmemSize ( void  )

static

Definition at line 98 of file proc.c.

{
    Size        size = 0;
    Size        TotalProcs =
        add_size(MaxBackends, add_size(NUM_AUXILIARY_PROCS, max_prepared_xacts));
 
    size = add_size(size, mul_size(TotalProcs, sizeof(PGPROC)));
    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(), fb(), max_prepared_xacts, MaxBackends, mul_size(), NUM_AUXILIARY_PROCS, ProcGlobal, PROC_HDR::statusFlags, PROC_HDR::subxidStates, and PROC_HDR::xids.

Referenced by InitProcGlobal(), and ProcGlobalShmemSize().

ProcGlobalSemas()

int ProcGlobalSemas

(

void

)

Definition at line 159 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 InitializeShmemGUCs(), InitProcGlobal(), and ProcGlobalShmemSize().

ProcGlobalShmemSize()

Size ProcGlobalShmemSize

(

void

)

Definition at line 140 of file proc.c.

{
    Size        size = 0;
 
    /* ProcGlobal */
    size = add_size(size, sizeof(PROC_HDR));
    size = add_size(size, sizeof(slock_t));
 
    size = add_size(size, PGSemaphoreShmemSize(ProcGlobalSemas()));
    size = add_size(size, PGProcShmemSize());
    size = add_size(size, FastPathLockShmemSize());
 
    return size;
}

References add_size(), FastPathLockShmemSize(), fb(), PGProcShmemSize(), PGSemaphoreShmemSize(), and ProcGlobalSemas().

Referenced by CalculateShmemSize().

ProcKill()

static void ProcKill ( int  code, Datum  arg  )

static

Definition at line 924 of file proc.c.

{
    PGPROC     *proc;
    dlist_head *procgloballist;
 
    Assert(MyProc != NULL);
 
    /* not safe if forked by system(), etc. */
    if (MyProc->pid != (int) getpid())
        elog(PANIC, "ProcKill() called in child process");
 
    /* 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();
 
    /*
     * Cleanup waiting for LSN if any.
     */
    WaitLSNCleanup();
 
    /* 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;
    MyProcNumber = INVALID_PROC_NUMBER;
    DisownLatch(&proc->procLatch);
 
    /* Mark the proc no longer in use */
    proc->pid = 0;
    proc->vxid.procNumber = INVALID_PROC_NUMBER;
    proc->vxid.lxid = InvalidTransactionId;
 
    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);
}

References Assert, ConditionVariableCancelSleep(), DisownLatch(), dlist_delete(), dlist_is_empty(), dlist_push_head(), dlist_push_tail(), elog, fb(), i, INVALID_PROC_NUMBER, InvalidTransactionId, PGPROC::links, PGPROC::lockGroupLeader, PGPROC::lockGroupLink, PGPROC::lockGroupMembers, LockHashPartitionLockByProc, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), LWLockReleaseAll(), PGPROC::lxid, MyProc, PGPROC::myProcLocks, MyProcNumber, NUM_LOCK_PARTITIONS, PANIC, pgstat_reset_wait_event_storage(), PGPROC::pid, ProcGlobal, PGPROC::procgloballist, PGPROC::procLatch, PGPROC::procNumber, ProcStructLock, SpinLockAcquire, SpinLockRelease, PROC_HDR::spins_per_delay, SwitchBackToLocalLatch(), SyncRepCleanupAtProcExit(), update_spins_per_delay(), PGPROC::vxid, and WaitLSNCleanup().

Referenced by InitProcess().

ProcLockWakeup()

void ProcLockWakeup	(	LockMethod	lockMethodTable,
		LOCK *	lock
	)

Definition at line 1745 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 dclist_foreach_modify, dclist_is_empty(), dlist_container, fb(), 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 896 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, fb(), LockErrorCleanup(), LockReleaseAll(), MyProc, and USER_LOCKMETHOD.

Referenced by ResourceOwnerReleaseInternal().

ProcSendSignal()

void ProcSendSignal

(

ProcNumber

procNumber

)

Definition at line 1992 of file proc.c.

{
    if (procNumber < 0 || procNumber >= ProcGlobal->allProcCount)
        elog(ERROR, "procNumber out of range");
 
    SetLatch(&GetPGProcByNumber(procNumber)->procLatch);
}

References PROC_HDR::allProcCount, elog, ERROR, fb(), GetPGProcByNumber, ProcGlobal, and SetLatch().

Referenced by ReleasePredicateLocks(), and WakePinCountWaiter().

ProcSleep()

ProcWaitStatus ProcSleep

(

LOCALLOCK *

locallock

)

Definition at line 1315 of file proc.c.

{
    LOCKMODE    lockmode = locallock->tag.mode;
    LOCK       *lock = locallock->lock;
    uint32      hashcode = locallock->hashcode;
    LWLock     *partitionLock = LockHashPartitionLock(hashcode);
    TimestampTz standbyWaitStart = 0;
    bool        allow_autovacuum_cancel = true;
    bool        logged_recovery_conflict = false;
    ProcWaitStatus myWaitStatus;
 
    /* The caller must've armed the on-error cleanup mechanism */
    Assert(GetAwaitedLock() == locallock);
    Assert(!LWLockHeldByMe(partitionLock));
 
    /*
     * 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 canceled.  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;
            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;
 
            /* Gather a list of all lock holders and waiters */
            LWLockAcquire(partitionLock, LW_SHARED);
            GetLockHoldersAndWaiters(locallock, &lock_holders_sbuf,
                                     &lock_waiters_sbuf, &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);
 
    /*
     * We don't have to do anything else, because the awaker did all the
     * necessary updates of the lock table and MyProc. (The caller is
     * responsible for updating the local lock table.)
     */
    return myWaitStatus;
}

References AccessExclusiveLock, appendStringInfo(), Assert, buf, CHECK_FOR_INTERRUPTS, CheckDeadLock(), CheckRecoveryConflictDeadlock(), deadlock_state, DEADLOCK_TIMEOUT, DeadlockTimeout, DEBUG1, DescribeLockTag(), disable_timeout(), disable_timeouts(), 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(), fb(), get_timeout_start_time(), GetAwaitedLock(), GetBlockingAutoVacuumPgproc(), GetCurrentTimestamp(), GetLockConflicts(), GetLockHoldersAndWaiters(), GetLockmodeName(), got_deadlock_timeout, EnableTimeoutParams::id, DisableTimeoutParams::id, InHotStandby, initStringInfo(), InRecovery, kill, LOCK_TIMEOUT, LockHashPartitionLock, LOCKTAG::locktag_lockmethodid, LockTimeout, LOG, log_lock_waits, log_recovery_conflict_waits, LogRecoveryConflict(), LW_EXCLUSIVE, LW_SHARED, LWLockAcquire(), LWLockHeldByMe(), LWLockRelease(), message_level_is_interesting(), MyLatch, MyProc, MyProcPid, now(), pfree(), pg_atomic_write_u64(), PG_WAIT_LOCK, PROC_IS_AUTOVACUUM, PROC_VACUUM_FOR_WRAPAROUND, PROC_WAIT_STATUS_ERROR, PROC_WAIT_STATUS_OK, PROC_WAIT_STATUS_WAITING, ProcGlobal, PROCSIG_RECOVERY_CONFLICT_LOCK, RecoveryInProgress(), ResetLatch(), ResolveRecoveryConflictWithLock(), PROC_HDR::statusFlags, LOCK::tag, TimestampDifference(), TimestampDifferenceExceeds(), TMPARAM_AFTER, WaitLatch(), 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 1980 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, fb(), 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 1717 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(), fb(), 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 913 of file proc.c.

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

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

Referenced by InitProcessPhase2().

SetStartupBufferPinWaitBufId()

void SetStartupBufferPinWaitBufId

(

int

bufid

)

Definition at line 759 of file proc.c.

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

References fb(), ProcGlobal, and PROC_HDR::startupBufferPinWaitBufId.

Referenced by LockBufferForCleanup().

Variable Documentation

AuxiliaryProcs

NON_EXEC_STATIC PGPROC* AuxiliaryProcs = NULL

Definition at line 80 of file proc.c.

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

deadlock_state

DeadLockState deadlock_state = DS_NOT_YET_CHECKED

static

Definition at line 83 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 86 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 63 of file proc.c.

Referenced by PostgresMain(), and ProcessInterrupts().

LockTimeout

int LockTimeout = 0

Definition at line 60 of file proc.c.

Referenced by ProcSleep().

log_lock_waits

bool log_lock_waits = true

Definition at line 64 of file proc.c.

Referenced by ProcSleep().

MyProc

PGPROC* MyProc = NULL

Definition at line 67 of file proc.c.

Referenced by _brin_parallel_build_main(), _bt_parallel_build_main(), _gin_parallel_build_main(), AbortTransaction(), AtEOSubXact_Namespace(), AtEOXact_Namespace(), AtEOXact_Snapshot(), attach_to_queues(), AutoVacWorkerMain(), AuxiliaryProcKill(), BaseInit(), BecomeLockGroupLeader(), BecomeLockGroupMember(), BufferLockAcquire(), BufferLockDequeueSelf(), BufferLockQueueSelf(), CheckDeadLock(), CommitTransaction(), ComputeXidHorizons(), ConditionVariableBroadcast(), consume_xids_common(), CountOtherDBBackends(), CreateReplicationSlot(), DefineIndex(), EndPrepare(), errdetail_abort(), exec_eval_simple_expr(), exec_simple_check_plan(), exec_stmt_call(), ExecParallelGetReceiver(), ExecParallelSetupTupleQueues(), ExecWaitStmt(), ExportSnapshot(), FastPathGetRelationLockEntry(), FastPathGrantRelationLock(), FastPathUnGrantRelationLock(), FindLockCycleRecurseMember(), get_cast_hashentry(), GetCurrentVirtualXIDs(), GetLockConflicts(), GetNewTransactionId(), GetSerializableTransactionSnapshotInt(), GetSnapshotData(), GetSnapshotDataReuse(), GetStableLatestTransactionId(), heap_inplace_update_and_unlock(), InitAuxiliaryProcess(), InitBufferManagerAccess(), InitializeParallelDSM(), InitPostgres(), InitProcess(), InitProcessPhase2(), InitRecoveryTransactionEnvironment(), InitTempTableNamespace(), InitWalSender(), JoinWaitQueue(), lock_and_open_sequence(), LockAcquireExtended(), LockBufferInternal(), 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(), pg_truncate_visibility_map(), pgaio_init_backend(), 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(), SetAuthenticatedUserId(), setup_dynamic_shared_memory(), shm_mq_attach(), shm_mq_detach_internal(), shm_mq_receive(), shm_mq_sendv(), shm_mq_wait_for_attach(), smgr_bulk_finish(), SnapBuildInitialSnapshot(), SnapshotResetXmin(), StartTransaction(), StartupDecodingContext(), SwitchBackToLocalLatch(), SwitchToSharedLatch(), SyncRepCancelWait(), SyncRepCleanupAtProcExit(), SyncRepQueueInsert(), SyncRepWaitForLSN(), TerminateOtherDBBackends(), TransactionGroupUpdateXidStatus(), TransactionIdIsInProgress(), TransactionIdSetPageStatus(), TruncateMultiXact(), vacuum_rel(), VirtualXactLockTableCleanup(), VirtualXactLockTableInsert(), WaitXLogInsertionsToFinish(), write_csvlog(), write_jsonlog(), XidCacheRemoveRunningXids(), and XLogSaveBufferForHint().

PreparedXactProcs

PGPROC* PreparedXactProcs = NULL

Definition at line 81 of file proc.c.

Referenced by InitProcGlobal(), and TwoPhaseShmemInit().

ProcGlobal

PROC_HDR* ProcGlobal = NULL

Definition at line 79 of file proc.c.

Referenced by AuxiliaryProcKill(), BackendXidGetPid(), CheckpointerMain(), ComputeXidHorizons(), CountOtherDBBackends(), FastPathTransferRelationLocks(), ForwardSyncRequest(), GetCurrentVirtualXIDs(), GetLockConflicts(), GetLockStatusData(), GetNewTransactionId(), GetOldestActiveTransactionId(), GetOldestSafeDecodingTransactionId(), GetRunningTransactionData(), GetSnapshotData(), GetStartupBufferPinWaitBufId(), HaveNFreeProcs(), InitAuxiliaryProcess(), InitProcess(), InitProcGlobal(), InitWalSender(), PGProcShmemSize(), ProcArrayAdd(), ProcArrayClearTransaction(), ProcArrayEndTransaction(), ProcArrayEndTransactionInternal(), ProcArrayGroupClearXid(), ProcArrayInstallImportedXmin(), ProcArrayInstallRestoredXmin(), ProcArrayRemove(), ProcArrayShmemInit(), ProcKill(), ProcNumberGetProc(), ProcNumberGetTransactionIds(), ProcSendSignal(), ProcSleep(), ReplicationSlotRelease(), RequestCheckpoint(), set_indexsafe_procflags(), SetStartupBufferPinWaitBufId(), StartupDecodingContext(), TransactionGroupUpdateXidStatus(), TransactionIdIsInProgress(), vacuum_rel(), WakeupCheckpointer(), WalWriterMain(), XidCacheRemoveRunningXids(), and XLogSetAsyncXactLSN().

ProcStructLock

NON_EXEC_STATIC slock_t* ProcStructLock = NULL

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

TransactionTimeout

int TransactionTimeout = 0

Definition at line 62 of file proc.c.

Referenced by AbortTransaction(), CommitTransaction(), enable_statement_timeout(), PostgresMain(), PrepareTransaction(), ProcessInterrupts(), and StartTransaction().