proc.h File Reference

#include "access/clog.h"
#include "access/xlogdefs.h"
#include "lib/ilist.h"
#include "miscadmin.h"
#include "storage/latch.h"
#include "storage/lock.h"
#include "storage/pg_sema.h"
#include "storage/proclist_types.h"
#include "storage/procnumber.h"

Include dependency graph for proc.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	XidCacheStatus
struct	XidCache
struct	PGPROC
struct	PROC_HDR

Macros
#define	PGPROC_MAX_CACHED_SUBXIDS   64 /* XXX guessed-at value */
#define	PROC_IS_AUTOVACUUM   0x01 /* is it an autovac worker? */
#define	PROC_IN_VACUUM   0x02 /* currently running lazy vacuum */
#define	PROC_IN_SAFE_IC
#define	PROC_VACUUM_FOR_WRAPAROUND   0x08 /* set by autovac only */
#define	PROC_IN_LOGICAL_DECODING
#define	PROC_AFFECTS_ALL_HORIZONS
#define	PROC_VACUUM_STATE_MASK    (PROC_IN_VACUUM | PROC_IN_SAFE_IC | PROC_VACUUM_FOR_WRAPAROUND)
#define	PROC_XMIN_FLAGS   (PROC_IN_VACUUM | PROC_IN_SAFE_IC)
#define	FP_LOCK_GROUPS_PER_BACKEND_MAX   1024
#define	FP_LOCK_SLOTS_PER_GROUP   16 /* don't change */
#define	FastPathLockSlotsPerBackend()    (FP_LOCK_SLOTS_PER_GROUP * FastPathLockGroupsPerBackend)
#define	DELAY_CHKPT_START   (1<<0)
#define	DELAY_CHKPT_COMPLETE   (1<<1)
#define	DELAY_CHKPT_IN_COMMIT   (DELAY_CHKPT_START | 1<<2)
#define	GetPGProcByNumber(n)   (&ProcGlobal->allProcs[(n)])
#define	GetNumberFromPGProc(proc)   ((proc) - &ProcGlobal->allProcs[0])
#define	NUM_SPECIAL_WORKER_PROCS   2
#define	MAX_IO_WORKERS   32
#define	NUM_AUXILIARY_PROCS   (6 + MAX_IO_WORKERS)
#define	FIRST_PREPARED_XACT_PROC_NUMBER   (MaxBackends + NUM_AUXILIARY_PROCS)

Typedefs
typedef struct XidCacheStatus	XidCacheStatus
typedef struct PGPROC	PGPROC
typedef struct PROC_HDR	PROC_HDR

Enumerations
enum	ProcWaitStatus { PROC_WAIT_STATUS_OK , PROC_WAIT_STATUS_WAITING , PROC_WAIT_STATUS_ERROR }

Functions
int	ProcGlobalSemas (void)
Size	ProcGlobalShmemSize (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	ProcReleaseLocks (bool isCommit)
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	LockErrorCleanup (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)
PGPROC *	AuxiliaryPidGetProc (int pid)
void	BecomeLockGroupLeader (void)
bool	BecomeLockGroupMember (PGPROC *leader, int pid)

Variables
PGDLLIMPORT int	FastPathLockGroupsPerBackend
PGDLLIMPORT PGPROC *	MyProc
PGDLLIMPORT PROC_HDR *	ProcGlobal
PGDLLIMPORT PGPROC *	PreparedXactProcs
PGDLLIMPORT int	DeadlockTimeout
PGDLLIMPORT int	StatementTimeout
PGDLLIMPORT int	LockTimeout
PGDLLIMPORT int	IdleInTransactionSessionTimeout
PGDLLIMPORT int	TransactionTimeout
PGDLLIMPORT int	IdleSessionTimeout
PGDLLIMPORT bool	log_lock_waits

Macro Definition Documentation

DELAY_CHKPT_COMPLETE

#define DELAY_CHKPT_COMPLETE   (1<<1)

Definition at line 137 of file proc.h.

DELAY_CHKPT_IN_COMMIT

#define DELAY_CHKPT_IN_COMMIT   (DELAY_CHKPT_START | 1<<2)

Definition at line 138 of file proc.h.

DELAY_CHKPT_START

#define DELAY_CHKPT_START   (1<<0)

Definition at line 136 of file proc.h.

FastPathLockSlotsPerBackend

#define FastPathLockSlotsPerBackend

(

)

(FP_LOCK_SLOTS_PER_GROUP * FastPathLockGroupsPerBackend)

Definition at line 94 of file proc.h.

{
    PROC_WAIT_STATUS_OK,
    PROC_WAIT_STATUS_WAITING,
    PROC_WAIT_STATUS_ERROR,
} ProcWaitStatus;
 
/*
 * Each backend has a PGPROC struct in shared memory.  There is also a list of
 * currently-unused PGPROC structs that will be reallocated to new backends.
 *
 * Note: twophase.c also sets up a dummy PGPROC struct for each currently
 * prepared transaction.  These PGPROCs appear in the ProcArray data structure
 * so that the prepared transactions appear to be still running and are
 * correctly shown as holding locks.  A prepared transaction PGPROC can be
 * distinguished from a real one at need by the fact that it has pid == 0.
 * The semaphore and lock-activity fields in a prepared-xact PGPROC are unused,
 * but its myProcLocks[] lists are valid.
 *
 * We allow many fields of this struct to be accessed without locks, such as
 * delayChkptFlags and backendType. However, keep in mind that writing
 * mirrored ones (see below) requires holding ProcArrayLock or XidGenLock in
 * at least shared mode, so that pgxactoff does not change concurrently.
 *
 * Mirrored fields:
 *
 * Some fields in PGPROC (see "mirrored in ..." comment) are mirrored into an
 * element of more densely packed ProcGlobal arrays. These arrays are indexed
 * by PGPROC->pgxactoff. Both copies need to be maintained coherently.
 *
 * NB: The pgxactoff indexed value can *never* be accessed without holding
 * locks.
 *
 * See PROC_HDR for details.
 */
typedef struct PGPROC
{
    /*
     * Align the struct at cache line boundaries.  This is just for
     * performance, to avoid false sharing.
     */
    alignas(PG_CACHE_LINE_SIZE)
    dlist_head *procgloballist; /* procglobal list that owns this PGPROC */
    dlist_node  freeProcsLink;  /* link in procgloballist, when in recycled
                                 * state */
 
    /************************************************************************
     * Backend identity
     ************************************************************************/
 
    /*
     * These fields that don't change after backend startup, or only very
     * rarely
     */
    int         pid;            /* Backend's process ID; 0 if prepared xact */
    BackendType backendType;    /* what kind of process is this? */
 
    /* These fields are zero while a backend is still starting up: */
    Oid         databaseId;     /* OID of database this backend is using */
    Oid         roleId;         /* OID of role using this backend */
 
    Oid         tempNamespaceId;    /* OID of temp schema this backend is
                                     * using */
 
    int         pgxactoff;      /* offset into various ProcGlobal->arrays with
                                 * data mirrored from this PGPROC */
 
    uint8       statusFlags;    /* this backend's status flags, see PROC_*
                                 * above. mirrored in
                                 * ProcGlobal->statusFlags[pgxactoff] */
 
    /************************************************************************
     * Transactions and snapshots
     ************************************************************************/
 
    /*
     * Currently running top-level transaction's virtual xid. Together these
     * form a VirtualTransactionId, but we don't use that struct because this
     * is not atomically assignable as whole, and we want to enforce code to
     * consider both parts separately.  See comments at VirtualTransactionId.
     */
    struct
    {
        ProcNumber  procNumber; /* For regular backends, equal to
                                 * GetNumberFromPGProc(proc).  For prepared
                                 * xacts, ID of the original backend that
                                 * processed the transaction. For unused
                                 * PGPROC entries, INVALID_PROC_NUMBER. */
        LocalTransactionId lxid;    /* local id of top-level transaction
                                     * currently * being executed by this
                                     * proc, if running; else
                                     * InvalidLocalTransactionId */
    }           vxid;
 
    TransactionId xid;          /* id of top-level transaction currently being
                                 * executed by this proc, if running and XID
                                 * is assigned; else InvalidTransactionId.
                                 * mirrored in ProcGlobal->xids[pgxactoff] */
 
    TransactionId xmin;         /* minimal running XID as it was when we were
                                 * starting our xact, excluding LAZY VACUUM:
                                 * vacuum must not remove tuples deleted by
                                 * xid >= xmin ! */
 
    XidCacheStatus subxidStatus;    /* mirrored with
                                     * ProcGlobal->subxidStates[i] */
    struct XidCache subxids;    /* cache for subtransaction XIDs */
 
 
    /************************************************************************
     * Inter-process signaling
     ************************************************************************/
 
    Latch       procLatch;      /* generic latch for process */
 
    PGSemaphore sem;            /* ONE semaphore to sleep on */
 
    int         delayChkptFlags;    /* for DELAY_CHKPT_* flags */
 
    /*
     * While in hot standby mode, shows that a conflict signal has been sent
     * for the current transaction. Set/cleared while holding ProcArrayLock,
     * though not required. Accessed without lock, if needed.
     *
     * This is a bitmask; each bit corresponds to a RecoveryConflictReason
     * enum value.
     */
    pg_atomic_uint32 pendingRecoveryConflicts;
 
    /************************************************************************
     * LWLock waiting
     ************************************************************************/
 
    /*
     * Info about LWLock the process is currently waiting for, if any.
     *
     * This is currently used both for lwlocks and buffer content locks, which
     * is acceptable, although not pretty, because a backend can't wait for
     * both types of locks at the same time.
     */
    uint8       lwWaiting;      /* see LWLockWaitState */
    uint8       lwWaitMode;     /* lwlock mode being waited for */
    proclist_node lwWaitLink;   /* position in LW lock wait list */
 
    /* Support for condition variables. */
    proclist_node cvWaitLink;   /* position in CV wait list */
 
    /************************************************************************
     * Lock manager data
     ************************************************************************/
 
    /*
     * Support for lock groups.  Use LockHashPartitionLockByProc on the group
     * leader to get the LWLock protecting these fields.
     */
    PGPROC     *lockGroupLeader;    /* lock group leader, if I'm a member */
    dlist_head  lockGroupMembers;   /* list of members, if I'm a leader */
    dlist_node  lockGroupLink;  /* my member link, if I'm a member */
 
    /* Info about lock the process is currently waiting for, if any. */
    /* waitLock and waitProcLock are NULL if not currently waiting. */
    LOCK       *waitLock;       /* Lock object we're sleeping on ... */
    dlist_node  waitLink;       /* position in waitLock->waitProcs queue */
    PROCLOCK   *waitProcLock;   /* Per-holder info for awaited lock */
    LOCKMODE    waitLockMode;   /* type of lock we're waiting for */
    LOCKMASK    heldLocks;      /* bitmask for lock types already held on this
                                 * lock object by this backend */
 
    pg_atomic_uint64 waitStart; /* time at which wait for lock acquisition
                                 * started */
 
    ProcWaitStatus waitStatus;
 
    /*
     * All PROCLOCK objects for locks held or awaited by this backend are
     * linked into one of these lists, according to the partition number of
     * their lock.
     */
    dlist_head  myProcLocks[NUM_LOCK_PARTITIONS];
 
    /*-- recording fast-path locks taken by this backend. --*/
    LWLock      fpInfoLock;     /* protects per-backend fast-path state */
    uint64     *fpLockBits;     /* lock modes held for each fast-path slot */
    Oid        *fpRelId;        /* slots for rel oids */
    bool        fpVXIDLock;     /* are we holding a fast-path VXID lock? */
    LocalTransactionId fpLocalTransactionId;    /* lxid for fast-path VXID
                                                 * lock */
 
    /************************************************************************
     * Synchronous replication waiting
     ************************************************************************/
 
    /*
     * Info to allow us to wait for synchronous replication, if needed.
     * waitLSN is InvalidXLogRecPtr if not waiting; set only by user backend.
     * syncRepState must not be touched except by owning process or WALSender.
     * syncRepLinks used only while holding SyncRepLock.
     */
    XLogRecPtr  waitLSN;        /* waiting for this LSN or higher */
    int         syncRepState;   /* wait state for sync rep */
    dlist_node  syncRepLinks;   /* list link if process is in syncrep queue */
 
    /************************************************************************
     * Support for group XID clearing
     ************************************************************************/
 
    /* true, if member of ProcArray group waiting for XID clear */
    bool        procArrayGroupMember;
    /* next ProcArray group member waiting for XID clear */
    pg_atomic_uint32 procArrayGroupNext;
 
    /*
     * latest transaction id among the transaction's main XID and
     * subtransactions
     */
    TransactionId procArrayGroupMemberXid;
 
    /************************************************************************
     * Support for group transaction status update
     ************************************************************************/
 
    bool        clogGroupMember;    /* true, if member of clog group */
    pg_atomic_uint32 clogGroupNext; /* next clog group member */
    TransactionId clogGroupMemberXid;   /* transaction id of clog group member */
    XidStatus   clogGroupMemberXidStatus;   /* transaction status of clog
                                             * group member */
    int64       clogGroupMemberPage;    /* clog page corresponding to
                                         * transaction id of clog group member */
    XLogRecPtr  clogGroupMemberLsn; /* WAL location of commit record for clog
                                     * group member */
 
    /************************************************************************
     * Status reporting
     ************************************************************************/
 
    uint32      wait_event_info;    /* proc's wait information */
}
PGPROC;
 
extern PGDLLIMPORT PGPROC *MyProc;
 
/*
 * There is one ProcGlobal struct for the whole database cluster.
 *
 * Adding/Removing an entry into the procarray requires holding *both*
 * ProcArrayLock and XidGenLock in exclusive mode (in that order). Both are
 * needed because the dense arrays (see below) are accessed from
 * GetNewTransactionId() and GetSnapshotData(), and we don't want to add
 * further contention by both using the same lock. Adding/Removing a procarray
 * entry is much less frequent.
 *
 * Some fields in PGPROC are mirrored into more densely packed arrays (e.g.
 * xids), with one entry for each backend. These arrays only contain entries
 * for PGPROCs that have been added to the shared array with ProcArrayAdd()
 * (in contrast to PGPROC array which has unused PGPROCs interspersed).
 *
 * The dense arrays are indexed by PGPROC->pgxactoff. Any concurrent
 * ProcArrayAdd() / ProcArrayRemove() can lead to pgxactoff of a procarray
 * member to change.  Therefore it is only safe to use PGPROC->pgxactoff to
 * access the dense array while holding either ProcArrayLock or XidGenLock.
 *
 * As long as a PGPROC is in the procarray, the mirrored values need to be
 * maintained in both places in a coherent manner.
 *
 * The denser separate arrays are beneficial for three main reasons: First, to
 * allow for as tight loops accessing the data as possible. Second, to prevent
 * updates of frequently changing data (e.g. xmin) from invalidating
 * cachelines also containing less frequently changing data (e.g. xid,
 * statusFlags). Third to condense frequently accessed data into as few
 * cachelines as possible.
 *
 * There are two main reasons to have the data mirrored between these dense
 * arrays and PGPROC. First, as explained above, a PGPROC's array entries can
 * only be accessed with either ProcArrayLock or XidGenLock held, whereas the
 * PGPROC entries do not require that (obviously there may still be locking
 * requirements around the individual field, separate from the concerns
 * here). That is particularly important for a backend to efficiently checks
 * it own values, which it often can safely do without locking.  Second, the
 * PGPROC fields allow to avoid unnecessary accesses and modification to the
 * dense arrays. A backend's own PGPROC is more likely to be in a local cache,
 * whereas the cachelines for the dense array will be modified by other
 * backends (often removing it from the cache for other cores/sockets). At
 * commit/abort time a check of the PGPROC value can avoid accessing/dirtying
 * the corresponding array value.
 *
 * Basically it makes sense to access the PGPROC variable when checking a
 * single backend's data, especially when already looking at the PGPROC for
 * other reasons already.  It makes sense to look at the "dense" arrays if we
 * need to look at many / most entries, because we then benefit from the
 * reduced indirection and better cross-process cache-ability.
 *
 * When entering a PGPROC for 2PC transactions with ProcArrayAdd(), the data
 * in the dense arrays is initialized from the PGPROC while it already holds
 * ProcArrayLock.
 */
typedef struct PROC_HDR
{
    /* Array of PGPROC structures (not including dummies for prepared txns) */
    PGPROC     *allProcs;
 
    /* Array mirroring PGPROC.xid for each PGPROC currently in the procarray */
    TransactionId *xids;
 
    /*
     * Array mirroring PGPROC.subxidStatus for each PGPROC currently in the
     * procarray.
     */
    XidCacheStatus *subxidStates;
 
    /*
     * Array mirroring PGPROC.statusFlags for each PGPROC currently in the
     * procarray.
     */
    uint8      *statusFlags;
 
    /* Length of allProcs array */
    uint32      allProcCount;
 
    /*
     * This spinlock protects the below freelists of PGPROC structures.  We
     * cannot use an LWLock because the LWLock manager depends on already
     * having a PGPROC and a wait semaphore!  But these structures are touched
     * relatively infrequently (only at backend startup or shutdown) and not
     * for very long, so a spinlock is okay.
     */
    slock_t     freeProcsLock;
 
    /* Head of list of free PGPROC structures */
    dlist_head  freeProcs;
    /* Head of list of autovacuum & special worker free PGPROC structures */
    dlist_head  autovacFreeProcs;
    /* Head of list of bgworker free PGPROC structures */
    dlist_head  bgworkerFreeProcs;
    /* Head of list of walsender free PGPROC structures */
    dlist_head  walsenderFreeProcs;
 
    /* First pgproc waiting for group XID clear */
    pg_atomic_uint32 procArrayGroupFirst;
    /* First pgproc waiting for group transaction status update */
    pg_atomic_uint32 clogGroupFirst;
 
    /*
     * Current slot numbers of some auxiliary processes. There can be only one
     * of each of these running at a time.
     */
    ProcNumber  walwriterProc;
    ProcNumber  checkpointerProc;
 
    /* Current shared estimate of appropriate spins_per_delay value */
    int         spins_per_delay;
    /* Buffer id of the buffer that Startup process waits for pin on, or -1 */
    int         startupBufferPinWaitBufId;
} PROC_HDR;
 
extern PGDLLIMPORT PROC_HDR *ProcGlobal;
 
extern PGDLLIMPORT PGPROC *PreparedXactProcs;
 
/*
 * Accessors for getting PGPROC given a ProcNumber and vice versa.
 */
#define GetPGProcByNumber(n) (&ProcGlobal->allProcs[(n)])
#define GetNumberFromPGProc(proc) ((proc) - &ProcGlobal->allProcs[0])
 
/*
 * We set aside some extra PGPROC structures for "special worker" processes,
 * which are full-fledged backends (they can run transactions)
 * but are unique animals that there's never more than one of.
 * Currently there are two such processes: the autovacuum launcher
 * and the slotsync worker.
 */
#define NUM_SPECIAL_WORKER_PROCS    2
 
/*
 * We set aside some extra PGPROC structures for auxiliary processes,
 * ie things that aren't full-fledged backends (they cannot run transactions
 * or take heavyweight locks) but need shmem access.
 *
 * Background writer, checkpointer, WAL writer, WAL summarizer, and archiver
 * run during normal operation.  Startup process and WAL receiver also consume
 * 2 slots, but WAL writer is launched only after startup has exited, so we
 * only need 6 slots.
 */
#define MAX_IO_WORKERS          32
#define NUM_AUXILIARY_PROCS     (6 + MAX_IO_WORKERS)
 
#define FIRST_PREPARED_XACT_PROC_NUMBER (MaxBackends + NUM_AUXILIARY_PROCS)
 
/* configurable options */
extern PGDLLIMPORT int DeadlockTimeout;
extern PGDLLIMPORT int StatementTimeout;
extern PGDLLIMPORT int LockTimeout;
extern PGDLLIMPORT int IdleInTransactionSessionTimeout;
extern PGDLLIMPORT int TransactionTimeout;
extern PGDLLIMPORT int IdleSessionTimeout;
extern PGDLLIMPORT bool log_lock_waits;
 
#ifdef EXEC_BACKEND
extern PGDLLIMPORT PGPROC *AuxiliaryProcs;
#endif
 
 
/*
 * Function Prototypes
 */
extern int  ProcGlobalSemas(void);
extern Size ProcGlobalShmemSize(void);
extern void InitProcGlobal(void);
extern void InitProcess(void);
extern void InitProcessPhase2(void);
extern void InitAuxiliaryProcess(void);
 
extern void SetStartupBufferPinWaitBufId(int bufid);
extern int  GetStartupBufferPinWaitBufId(void);
 
extern bool HaveNFreeProcs(int n, int *nfree);
extern void ProcReleaseLocks(bool isCommit);
 
extern ProcWaitStatus JoinWaitQueue(LOCALLOCK *locallock,
                                    LockMethod lockMethodTable, bool dontWait);
extern ProcWaitStatus ProcSleep(LOCALLOCK *locallock);
extern void ProcWakeup(PGPROC *proc, ProcWaitStatus waitStatus);
extern void ProcLockWakeup(LockMethod lockMethodTable, LOCK *lock);
extern void CheckDeadLockAlert(void);
extern void LockErrorCleanup(void);
extern void GetLockHoldersAndWaiters(LOCALLOCK *locallock,
                                     StringInfo lock_holders_sbuf,
                                     StringInfo lock_waiters_sbuf,
                                     int *lockHoldersNum);
 
extern void ProcWaitForSignal(uint32 wait_event_info);
extern void ProcSendSignal(ProcNumber procNumber);
 
extern PGPROC *AuxiliaryPidGetProc(int pid);
 
extern void BecomeLockGroupLeader(void);
extern bool BecomeLockGroupMember(PGPROC *leader, int pid);
 
#endif                          /* _PROC_H_ */

FIRST_PREPARED_XACT_PROC_NUMBER

#define FIRST_PREPARED_XACT_PROC_NUMBER   (MaxBackends + NUM_AUXILIARY_PROCS)

Definition at line 526 of file proc.h.

FP_LOCK_GROUPS_PER_BACKEND_MAX

#define FP_LOCK_GROUPS_PER_BACKEND_MAX   1024

Definition at line 92 of file proc.h.

FP_LOCK_SLOTS_PER_GROUP

#define FP_LOCK_SLOTS_PER_GROUP   16 /* don't change */

Definition at line 93 of file proc.h.

GetNumberFromPGProc

#define GetNumberFromPGProc

(

proc

)

((proc) - &ProcGlobal->allProcs[0])

Definition at line 502 of file proc.h.

GetPGProcByNumber

#define GetPGProcByNumber

(

n

)

(&ProcGlobal->allProcs[(n)])

Definition at line 501 of file proc.h.

MAX_IO_WORKERS

#define MAX_IO_WORKERS   32

Definition at line 523 of file proc.h.

NUM_AUXILIARY_PROCS

#define NUM_AUXILIARY_PROCS   (6 + MAX_IO_WORKERS)

Definition at line 524 of file proc.h.

NUM_SPECIAL_WORKER_PROCS

#define NUM_SPECIAL_WORKER_PROCS   2

Definition at line 511 of file proc.h.

PGPROC_MAX_CACHED_SUBXIDS

#define PGPROC_MAX_CACHED_SUBXIDS   64 /* XXX guessed-at value */

Definition at line 40 of file proc.h.

PROC_AFFECTS_ALL_HORIZONS

#define PROC_AFFECTS_ALL_HORIZONS

Value:

                                                 0x20   /* this proc's xmin must be
                                                 * included in vacuum horizons
                                                 * in all databases */

Definition at line 63 of file proc.h.

PROC_IN_LOGICAL_DECODING

#define PROC_IN_LOGICAL_DECODING

Value:

                                                 0x10   /* currently doing logical
                                                 * decoding outside xact */

Definition at line 62 of file proc.h.

PROC_IN_SAFE_IC

#define PROC_IN_SAFE_IC

Value:

                                         0x04   /* currently running CREATE INDEX
                                         * CONCURRENTLY or REINDEX
                                         * CONCURRENTLY on non-expressional,
                                         * non-partial index */

Definition at line 60 of file proc.h.

PROC_IN_VACUUM

#define PROC_IN_VACUUM   0x02 /* currently running lazy vacuum */

Definition at line 59 of file proc.h.

PROC_IS_AUTOVACUUM

#define PROC_IS_AUTOVACUUM   0x01 /* is it an autovac worker? */

Definition at line 58 of file proc.h.

PROC_VACUUM_FOR_WRAPAROUND

#define PROC_VACUUM_FOR_WRAPAROUND   0x08 /* set by autovac only */

Definition at line 61 of file proc.h.

PROC_VACUUM_STATE_MASK

#define PROC_VACUUM_STATE_MASK    (PROC_IN_VACUUM | PROC_IN_SAFE_IC | PROC_VACUUM_FOR_WRAPAROUND)

Definition at line 66 of file proc.h.

PROC_XMIN_FLAGS

#define PROC_XMIN_FLAGS   (PROC_IN_VACUUM | PROC_IN_SAFE_IC)

Definition at line 73 of file proc.h.

Typedef Documentation

PGPROC

typedef struct PGPROC PGPROC

PROC_HDR

typedef struct PROC_HDR PROC_HDR

XidCacheStatus

typedef struct XidCacheStatus XidCacheStatus

Enumeration Type Documentation

ProcWaitStatus

enum ProcWaitStatus

Enumerator
PROC_WAIT_STATUS_OK
PROC_WAIT_STATUS_WAITING
PROC_WAIT_STATUS_ERROR

Definition at line 140 of file proc.h.

Function Documentation

AuxiliaryPidGetProc()

PGPROC * AuxiliaryPidGetProc ( int  pid )

extern

Definition at line 1085 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_get_backend_wait_event(), pg_stat_get_backend_wait_event_type(), pg_stat_reset_backend_stats(), and pgstat_fetch_stat_backend_by_pid().

BecomeLockGroupLeader()

void BecomeLockGroupLeader ( void  )

extern

Definition at line 2018 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  )

extern

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

CheckDeadLockAlert()

void CheckDeadLockAlert ( void  )

extern

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

GetLockHoldersAndWaiters()

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

extern

Definition at line 1917 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  )

extern

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

HaveNFreeProcs()

bool HaveNFreeProcs ( int  n, int *  nfree  )

extern

Definition at line 775 of file proc.c.

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

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

Referenced by InitPostgres().

InitAuxiliaryProcess()

void InitAuxiliaryProcess ( void  )

extern

Definition at line 606 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 freeProcsLock to protect assignment and releasing of
     * AuxiliaryProcs entries.
     *
     * While we are holding the spinlock, also copy the current shared
     * estimate of spins_per_delay to local storage.
     */
    SpinLockAcquire(&ProcGlobal->freeProcsLock);
 
    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(&ProcGlobal->freeProcsLock);
        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(&ProcGlobal->freeProcsLock);
 
    MyProc = auxproc;
    MyProcNumber = GetNumberFromPGProc(MyProc);
 
    /*
     * Initialize all fields of MyProc, except for those previously
     * initialized by InitProcGlobal.
     */
    dlist_node_init(&MyProc->freeProcsLink);
    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->backendType = MyBackendType;
    MyProc->delayChkptFlags = 0;
    MyProc->statusFlags = 0;
    MyProc->lwWaiting = LW_WS_NOT_WAITING;
    MyProc->lwWaitMode = 0;
    MyProc->waitLock = NULL;
    dlist_node_init(&MyProc->waitLink);
    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
    pg_atomic_write_u32(&MyProc->pendingRecoveryConflicts, 0);
 
    /*
     * 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::backendType, PGPROC::databaseId, PGPROC::delayChkptFlags, dlist_is_empty(), dlist_node_init(), elog, ERROR, FATAL, fb(), PGPROC::fpLocalTransactionId, PGPROC::fpVXIDLock, PGPROC::freeProcsLink, PROC_HDR::freeProcsLock, GetNumberFromPGProc, i, InitLWLockAccess(), Int32GetDatum(), INVALID_PROC_NUMBER, InvalidLocalTransactionId, InvalidOid, InvalidTransactionId, IsUnderPostmaster, PGPROC::lockGroupLeader, PGPROC::lockGroupMembers, LW_WS_NOT_WAITING, PGPROC::lwWaiting, PGPROC::lwWaitMode, PGPROC::lxid, MyBackendType, MyProc, PGPROC::myProcLocks, MyProcNumber, MyProcPid, NUM_AUXILIARY_PROCS, NUM_LOCK_PARTITIONS, on_shmem_exit(), OwnLatch(), PANIC, PGPROC::pendingRecoveryConflicts, pg_atomic_write_u32(), pg_atomic_write_u64(), PGSemaphoreReset(), pgstat_set_wait_event_storage(), PROC_WAIT_STATUS_OK, ProcGlobal, PGPROC::procLatch, PGPROC::procNumber, 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::waitLink, PGPROC::waitLock, PGPROC::waitProcLock, PGPROC::waitStart, PGPROC::waitStatus, PGPROC::xid, and PGPROC::xmin.

Referenced by AuxiliaryProcessMainCommon().

InitProcess()

void InitProcess ( void  )

extern

Definition at line 380 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 spinlock, also copy the current shared
     * estimate of spins_per_delay to local storage.
     */
    SpinLockAcquire(&ProcGlobal->freeProcsLock);
 
    set_spins_per_delay(ProcGlobal->spins_per_delay);
 
    if (!dlist_is_empty(procgloballist))
    {
        MyProc = dlist_container(PGPROC, freeProcsLink, dlist_pop_head_node(procgloballist));
        SpinLockRelease(&ProcGlobal->freeProcsLock);
    }
    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(&ProcGlobal->freeProcsLock);
        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->freeProcsLink);
    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->backendType = MyBackendType;
    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;
    dlist_node_init(&MyProc->waitLink);
    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
    pg_atomic_write_u32(&MyProc->pendingRecoveryConflicts, 0);
 
    /* Initialize fields for sync rep */
    MyProc->waitLSN = InvalidXLogRecPtr;
    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, AmSpecialWorkerProcess, AmWalSenderProcess, Assert, PROC_HDR::autovacFreeProcs, PGPROC::backendType, 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, PGPROC::freeProcsLink, PROC_HDR::freeProcsLock, GetNumberFromPGProc, i, InitDeadLockChecking(), InitLWLockAccess(), INVALID_PROC_NUMBER, InvalidLocalTransactionId, InvalidOid, InvalidTransactionId, InvalidXLogRecPtr, IsUnderPostmaster, PGPROC::lockGroupLeader, PGPROC::lockGroupMembers, LW_WS_NOT_WAITING, PGPROC::lwWaiting, PGPROC::lwWaitMode, PGPROC::lxid, max_wal_senders, MyBackendType, MyProc, PGPROC::myProcLocks, MyProcNumber, MyProcPid, NUM_LOCK_PARTITIONS, on_shmem_exit(), OwnLatch(), PANIC, PGPROC::pendingRecoveryConflicts, pg_atomic_read_u32(), pg_atomic_write_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, 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::waitLink, 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  )

extern

Definition at line 571 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  )

extern

Definition at line 184 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;
    SpinLockInit(&ProcGlobal->freeProcsLock);
    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 < FIRST_PREPARED_XACT_PROC_NUMBER)
        {
            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->freeProcsLink);
            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->freeProcsLink);
            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->freeProcsLink);
            proc->procgloballist = &ProcGlobal->bgworkerFreeProcs;
        }
        else if (i < MaxBackends)
        {
            /* PGPROC for walsender, add to walsenderFreeProcs list */
            dlist_push_tail(&ProcGlobal->walsenderFreeProcs, &proc->freeProcsLink);
            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[FIRST_PREPARED_XACT_PROC_NUMBER];
}

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(), FIRST_PREPARED_XACT_PROC_NUMBER, PGPROC::fpInfoLock, PGPROC::fpLockBits, PGPROC::fpRelId, PROC_HDR::freeProcs, PGPROC::freeProcsLink, PROC_HDR::freeProcsLock, i, InitSharedLatch(), INVALID_PROC_NUMBER, j, 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, 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  )

extern

Definition at line 1134 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, waitLink, 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->waitLink, &MyProc->waitLink);
    else
        dclist_push_tail(waitQueue, &MyProc->waitLink);
 
    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, 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::waitLink, PGPROC::waitLock, PGPROC::waitLockMode, LOCK::waitMask, PGPROC::waitProcLock, LOCK::waitProcs, and PGPROC::waitStatus.

Referenced by LockAcquireExtended().

LockErrorCleanup()

void LockErrorCleanup ( void  )

extern

Definition at line 806 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->waitLink))
    {
        /* 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, LOCK_TIMEOUT, LockHashPartitionLock, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MyProc, PROC_WAIT_STATUS_OK, RemoveFromWaitQueue(), ResetAwaitedLock(), RESUME_INTERRUPTS, PGPROC::waitLink, and PGPROC::waitStatus.

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

ProcGlobalSemas()

int ProcGlobalSemas ( void  )

extern

Definition at line 149 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  )

extern

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

ProcLockWakeup()

void ProcLockWakeup ( LockMethod  lockMethodTable, LOCK *  lock  )

extern

Definition at line 1752 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, waitLink, 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(), 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 )

extern

Definition at line 884 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 )

extern

Definition at line 2003 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 )

extern

Definition at line 1303 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;
    bool        logged_lock_wait = false;
    ProcWaitStatus myWaitStatus;
    DeadLockState deadlock_state;
 
    /* 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(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)
            {
                deadlock_state = 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)
            {
                /*
                 * Guard the "still waiting on lock" log message so it is
                 * reported at most once while waiting for the lock.
                 *
                 * Without this guard, the message can be emitted whenever the
                 * lock-wait sleep is interrupted (for example by SIGHUP for
                 * config reload or by client_connection_check_interval). For
                 * example, if client_connection_check_interval is set very
                 * low (e.g., 100 ms), the message could be logged repeatedly,
                 * flooding the log and making it difficult to use.
                 */
                if (!logged_lock_wait)
                {
                    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))));
                    logged_lock_wait = true;
                }
            }
            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(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_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, 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 )

extern

Definition at line 1991 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  )

extern

Definition at line 1724 of file proc.c.

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

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

Referenced by ProcLockWakeup().

SetStartupBufferPinWaitBufId()

void SetStartupBufferPinWaitBufId ( int  bufid )

extern

Definition at line 747 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

DeadlockTimeout

PGDLLIMPORT int DeadlockTimeout

extern

Definition at line 59 of file proc.c.

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

FastPathLockGroupsPerBackend

PGDLLIMPORT int FastPathLockGroupsPerBackend

extern

Definition at line 202 of file lock.c.

Referenced by FastPathLockShmemSize(), GetLockStatusData(), InitializeFastPathLocks(), and InitProcGlobal().

IdleInTransactionSessionTimeout

PGDLLIMPORT int IdleInTransactionSessionTimeout

extern

Definition at line 62 of file proc.c.

Referenced by PostgresMain(), and ProcessInterrupts().

IdleSessionTimeout

PGDLLIMPORT int IdleSessionTimeout

extern

Definition at line 64 of file proc.c.

Referenced by PostgresMain(), and ProcessInterrupts().

LockTimeout

PGDLLIMPORT int LockTimeout

extern

Definition at line 61 of file proc.c.

Referenced by ProcSleep().

log_lock_waits

PGDLLIMPORT bool log_lock_waits

extern

Definition at line 65 of file proc.c.

Referenced by ProcSleep().

MyProc

PGDLLIMPORT PGPROC* MyProc

extern

Definition at line 68 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(), 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(), HandleRecoveryConflictInterrupt(), 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(), 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(), ProcessInterrupts(), ProcessRecoveryConflictInterrupts(), ProcessStandbyHSFeedbackMessage(), ProcKill(), ProcReleaseLocks(), ProcSleep(), RecordTransactionCommit(), RecordTransactionCommitPrepared(), ReinitializeParallelDSM(), RelationTruncate(), RemoveProcFromArray(), ReplicationSlotRelease(), report_recovery_conflict(), 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(), and XidCacheRemoveRunningXids().

PreparedXactProcs

PGDLLIMPORT PGPROC* PreparedXactProcs

extern

Definition at line 73 of file proc.c.

Referenced by InitProcGlobal(), and TwoPhaseShmemInit().

ProcGlobal

PGDLLIMPORT PROC_HDR* ProcGlobal

extern

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

StatementTimeout

PGDLLIMPORT int StatementTimeout

extern

Definition at line 60 of file proc.c.

Referenced by enable_statement_timeout().

TransactionTimeout

PGDLLIMPORT int TransactionTimeout

extern

Definition at line 63 of file proc.c.

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