#include "access/transam.h"
#include "lib/ilist.h"
#include "storage/lockdefs.h"
#include "storage/locktag.h"
#include "storage/lwlock.h"
#include "storage/procnumber.h"
#include "storage/shmem.h"
#include "utils/timestamp.h"

Include dependency graph for lock.h:

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

Go to the source code of this file.

Data Structures
struct	VirtualTransactionId

struct	LockMethodData

struct	LOCK

struct	PROCLOCKTAG

struct	PROCLOCK

struct	LOCALLOCKTAG

struct	LOCALLOCKOWNER

struct	LOCALLOCK

struct	LockInstanceData

struct	LockData

struct	BlockedProcData

struct	BlockedProcsData

Macros
#define	InvalidLocalTransactionId 0

#define	LocalTransactionIdIsValid(lxid) ((lxid) != InvalidLocalTransactionId)

#define	VirtualTransactionIdIsValid(vxid) (LocalTransactionIdIsValid((vxid).localTransactionId))

#define	VirtualTransactionIdIsRecoveredPreparedXact(vxid) ((vxid).procNumber == INVALID_PROC_NUMBER)

#define	VirtualTransactionIdEquals(vxid1, vxid2)

#define	SetInvalidVirtualTransactionId(vxid)

#define	GET_VXID_FROM_PGPROC(vxid_dst, proc)

#define	MAX_LOCKMODES 10

#define	LOCKBIT_ON(lockmode) (1 << (lockmode))

#define	LOCKBIT_OFF(lockmode) (~(1 << (lockmode)))

#define	LOCK_LOCKMETHOD(lock) ((LOCKMETHODID) (lock).tag.locktag_lockmethodid)

#define	LOCK_LOCKTAG(lock) ((LockTagType) (lock).tag.locktag_type)

#define	PROCLOCK_LOCKMETHOD(proclock) LOCK_LOCKMETHOD(*((proclock).tag.myLock))

#define	LOCALLOCK_LOCKMETHOD(llock) ((llock).tag.lock.locktag_lockmethodid)

#define	LOCALLOCK_LOCKTAG(llock) ((LockTagType) (llock).tag.lock.locktag_type)

#define	LockHashPartition(hashcode) ((hashcode) % NUM_LOCK_PARTITIONS)

#define	LockHashPartitionLock(hashcode)

#define	LockHashPartitionLockByIndex(i) (&MainLWLockArray[LOCK_MANAGER_LWLOCK_OFFSET + (i)].lock)

#define	LockHashPartitionLockByProc(leader_pgproc) LockHashPartitionLock(GetNumberFromPGProc(leader_pgproc))

Typedefs
typedef struct PGPROC	PGPROC

typedef struct VirtualTransactionId	VirtualTransactionId

typedef struct LockMethodData	LockMethodData

typedef const LockMethodData *	LockMethod

typedef struct LOCK	LOCK

typedef struct PROCLOCKTAG	PROCLOCKTAG

typedef struct PROCLOCK	PROCLOCK

typedef struct LOCALLOCKTAG	LOCALLOCKTAG

typedef struct LOCALLOCKOWNER	LOCALLOCKOWNER

typedef struct LOCALLOCK	LOCALLOCK

typedef struct LockInstanceData	LockInstanceData

typedef struct LockData	LockData

typedef struct BlockedProcData	BlockedProcData

typedef struct BlockedProcsData	BlockedProcsData

Enumerations
enum	LockAcquireResult { LOCKACQUIRE_NOT_AVAIL , LOCKACQUIRE_OK , LOCKACQUIRE_ALREADY_HELD , LOCKACQUIRE_ALREADY_CLEAR }

enum	DeadLockState { DS_NOT_YET_CHECKED , DS_NO_DEADLOCK , DS_SOFT_DEADLOCK , DS_HARD_DEADLOCK , DS_BLOCKED_BY_AUTOVACUUM }

Functions
void	InitLockManagerAccess (void)

LockMethod	GetLocksMethodTable (const LOCK *lock)

LockMethod	GetLockTagsMethodTable (const LOCKTAG *locktag)

uint32	LockTagHashCode (const LOCKTAG *locktag)

bool	DoLockModesConflict (LOCKMODE mode1, LOCKMODE mode2)

LockAcquireResult	LockAcquire (const LOCKTAG *locktag, LOCKMODE lockmode, bool sessionLock, bool dontWait)

LockAcquireResult	LockAcquireExtended (const LOCKTAG locktag, LOCKMODE lockmode, bool sessionLock, bool dontWait, bool reportMemoryError, LOCALLOCK *locallockp, bool logLockFailure)

void	AbortStrongLockAcquire (void)

void	MarkLockClear (LOCALLOCK *locallock)

bool	LockRelease (const LOCKTAG *locktag, LOCKMODE lockmode, bool sessionLock)

void	LockReleaseAll (LOCKMETHODID lockmethodid, bool allLocks)

void	LockReleaseSession (LOCKMETHODID lockmethodid)

void	LockReleaseCurrentOwner (LOCALLOCK **locallocks, int nlocks)

void	LockReassignCurrentOwner (LOCALLOCK **locallocks, int nlocks)

bool	LockHeldByMe (const LOCKTAG *locktag, LOCKMODE lockmode, bool orstronger)

bool	LockHasWaiters (const LOCKTAG *locktag, LOCKMODE lockmode, bool sessionLock)

VirtualTransactionId *	GetLockConflicts (const LOCKTAG locktag, LOCKMODE lockmode, int countp)

void	AtPrepare_Locks (void)

void	PostPrepare_Locks (FullTransactionId fxid)

bool	LockCheckConflicts (LockMethod lockMethodTable, LOCKMODE lockmode, LOCK lock, PROCLOCK proclock)

void	GrantLock (LOCK lock, PROCLOCK proclock, LOCKMODE lockmode)

void	GrantAwaitedLock (void)

LOCALLOCK *	GetAwaitedLock (void)

void	ResetAwaitedLock (void)

void	RemoveFromWaitQueue (PGPROC *proc, uint32 hashcode)

LockData *	GetLockStatusData (void)

BlockedProcsData *	GetBlockerStatusData (int blocked_pid)

xl_standby_lock *	GetRunningTransactionLocks (int *nlocks)

const char *	GetLockmodeName (LOCKMETHODID lockmethodid, LOCKMODE mode)

void	lock_twophase_recover (FullTransactionId fxid, uint16 info, void *recdata, uint32 len)

void	lock_twophase_postcommit (FullTransactionId fxid, uint16 info, void *recdata, uint32 len)

void	lock_twophase_postabort (FullTransactionId fxid, uint16 info, void *recdata, uint32 len)

void	lock_twophase_standby_recover (FullTransactionId fxid, uint16 info, void *recdata, uint32 len)

DeadLockState	DeadLockCheck (PGPROC *proc)

PGPROC *	GetBlockingAutoVacuumPgproc (void)

pg_noreturn void	DeadLockReport (void)

void	RememberSimpleDeadLock (PGPROC proc1, LOCKMODE lockmode, LOCK lock, PGPROC *proc2)

void	InitDeadLockChecking (void)

int	LockWaiterCount (const LOCKTAG *locktag)

void	VirtualXactLockTableInsert (VirtualTransactionId vxid)

void	VirtualXactLockTableCleanup (void)

bool	VirtualXactLock (VirtualTransactionId vxid, bool wait)

Variables
PGDLLIMPORT int	max_locks_per_xact

PGDLLIMPORT bool	log_lock_failures

Macro Definition Documentation

◆ GET_VXID_FROM_PGPROC

#define GET_VXID_FROM_PGPROC	(	vxid_dst,
		proc
	)

Value:

((vxid_dst).procNumber = (proc).vxid.procNumber, \

(vxid_dst).localTransactionId = (proc).vxid.lxid)

fb

static int fb(int x)

Definition preproc-init.c:92

Definition at line 80 of file lock.h.

{
    int         numLockModes;
    const LOCKMASK *conflictTab;
    const char *const *lockModeNames;
    const bool *trace_flag;
} LockMethodData;
 
typedef const LockMethodData *LockMethod;
 
/*
 * Per-locked-object lock information:
 *
 * tag -- uniquely identifies the object being locked
 * grantMask -- bitmask for all lock types currently granted on this object.
 * waitMask -- bitmask for all lock types currently awaited on this object.
 * procLocks -- list of PROCLOCK objects for this lock.
 * waitProcs -- queue of processes waiting for this lock.
 * requested -- count of each lock type currently requested on the lock
 *      (includes requests already granted!!).
 * nRequested -- total requested locks of all types.
 * granted -- count of each lock type currently granted on the lock.
 * nGranted -- total granted locks of all types.
 *
 * Note: these counts count 1 for each backend.  Internally to a backend,
 * there may be multiple grabs on a particular lock, but this is not reflected
 * into shared memory.
 */
typedef struct LOCK
{
    /* hash key */
    LOCKTAG     tag;            /* unique identifier of lockable object */
 
    /* data */
    LOCKMASK    grantMask;      /* bitmask for lock types already granted */
    LOCKMASK    waitMask;       /* bitmask for lock types awaited */
    dlist_head  procLocks;      /* list of PROCLOCK objects assoc. with lock */
    dclist_head waitProcs;      /* list of PGPROC objects waiting on lock */
    int         requested[MAX_LOCKMODES];   /* counts of requested locks */
    int         nRequested;     /* total of requested[] array */
    int         granted[MAX_LOCKMODES]; /* counts of granted locks */
    int         nGranted;       /* total of granted[] array */
} LOCK;
 
#define LOCK_LOCKMETHOD(lock) ((LOCKMETHODID) (lock).tag.locktag_lockmethodid)
#define LOCK_LOCKTAG(lock) ((LockTagType) (lock).tag.locktag_type)
 
 
/*
 * We may have several different backends holding or awaiting locks
 * on the same lockable object.  We need to store some per-holder/waiter
 * information for each such holder (or would-be holder).  This is kept in
 * a PROCLOCK struct.
 *
 * PROCLOCKTAG is the key information needed to look up a PROCLOCK item in the
 * proclock hashtable.  A PROCLOCKTAG value uniquely identifies the combination
 * of a lockable object and a holder/waiter for that object.  (We can use
 * pointers here because the PROCLOCKTAG need only be unique for the lifespan
 * of the PROCLOCK, and it will never outlive the lock or the proc.)
 *
 * Internally to a backend, it is possible for the same lock to be held
 * for different purposes: the backend tracks transaction locks separately
 * from session locks.  However, this is not reflected in the shared-memory
 * state: we only track which backend(s) hold the lock.  This is OK since a
 * backend can never block itself.
 *
 * The holdMask field shows the already-granted locks represented by this
 * proclock.  Note that there will be a proclock object, possibly with
 * zero holdMask, for any lock that the process is currently waiting on.
 * Otherwise, proclock objects whose holdMasks are zero are recycled
 * as soon as convenient.
 *
 * releaseMask is workspace for LockReleaseAll(): it shows the locks due
 * to be released during the current call.  This must only be examined or
 * set by the backend owning the PROCLOCK.
 *
 * Each PROCLOCK object is linked into lists for both the associated LOCK
 * object and the owning PGPROC object.  Note that the PROCLOCK is entered
 * into these lists as soon as it is created, even if no lock has yet been
 * granted.  A PGPROC that is waiting for a lock to be granted will also be
 * linked into the lock's waitProcs queue.
 */
typedef struct PROCLOCKTAG
{
    /* NB: we assume this struct contains no padding! */
    LOCK       *myLock;         /* link to per-lockable-object information */
    PGPROC     *myProc;         /* link to PGPROC of owning backend */
} PROCLOCKTAG;
 
typedef struct PROCLOCK
{
    /* tag */
    PROCLOCKTAG tag;            /* unique identifier of proclock object */
 
    /* data */
    PGPROC     *groupLeader;    /* proc's lock group leader, or proc itself */
    LOCKMASK    holdMask;       /* bitmask for lock types currently held */
    LOCKMASK    releaseMask;    /* bitmask for lock types to be released */
    dlist_node  lockLink;       /* list link in LOCK's list of proclocks */
    dlist_node  procLink;       /* list link in PGPROC's list of proclocks */
} PROCLOCK;
 
#define PROCLOCK_LOCKMETHOD(proclock) \
    LOCK_LOCKMETHOD(*((proclock).tag.myLock))
 
/*
 * Each backend also maintains a local hash table with information about each
 * lock it is currently interested in.  In particular the local table counts
 * the number of times that lock has been acquired.  This allows multiple
 * requests for the same lock to be executed without additional accesses to
 * shared memory.  We also track the number of lock acquisitions per
 * ResourceOwner, so that we can release just those locks belonging to a
 * particular ResourceOwner.
 *
 * When holding a lock taken "normally", the lock and proclock fields always
 * point to the associated objects in shared memory.  However, if we acquired
 * the lock via the fast-path mechanism, the lock and proclock fields are set
 * to NULL, since there probably aren't any such objects in shared memory.
 * (If the lock later gets promoted to normal representation, we may eventually
 * update our locallock's lock/proclock fields after finding the shared
 * objects.)
 *
 * Caution: a locallock object can be left over from a failed lock acquisition
 * attempt.  In this case its lock/proclock fields are untrustworthy, since
 * the shared lock object is neither held nor awaited, and hence is available
 * to be reclaimed.  If nLocks > 0 then these pointers must either be valid or
 * NULL, but when nLocks == 0 they should be considered garbage.
 */
typedef struct LOCALLOCKTAG
{
    LOCKTAG     lock;           /* identifies the lockable object */
    LOCKMODE    mode;           /* lock mode for this table entry */
} LOCALLOCKTAG;
 
typedef struct LOCALLOCKOWNER
{
    /*
     * Note: if owner is NULL then the lock is held on behalf of the session;
     * otherwise it is held on behalf of my current transaction.
     *
     * Must use a forward struct reference to avoid circularity.
     */
    struct ResourceOwnerData *owner;
    int64       nLocks;         /* # of times held by this owner */
} LOCALLOCKOWNER;
 
typedef struct LOCALLOCK
{
    /* tag */
    LOCALLOCKTAG tag;           /* unique identifier of locallock entry */
 
    /* data */
    uint32      hashcode;       /* copy of LOCKTAG's hash value */
    LOCK       *lock;           /* associated LOCK object, if any */
    PROCLOCK   *proclock;       /* associated PROCLOCK object, if any */
    int64       nLocks;         /* total number of times lock is held */
    int         numLockOwners;  /* # of relevant ResourceOwners */
    int         maxLockOwners;  /* allocated size of array */
    LOCALLOCKOWNER *lockOwners; /* dynamically resizable array */
    bool        holdsStrongLockCount;   /* bumped FastPathStrongRelationLocks */
    bool        lockCleared;    /* we read all sinval msgs for lock */
} LOCALLOCK;
 
#define LOCALLOCK_LOCKMETHOD(llock) ((llock).tag.lock.locktag_lockmethodid)
#define LOCALLOCK_LOCKTAG(llock) ((LockTagType) (llock).tag.lock.locktag_type)
 
 
/*
 * These structures hold information passed from lmgr internals to the lock
 * listing user-level functions (in lockfuncs.c).
 */
 
typedef struct LockInstanceData
{
    LOCKTAG     locktag;        /* tag for locked object */
    LOCKMASK    holdMask;       /* locks held by this PGPROC */
    LOCKMODE    waitLockMode;   /* lock awaited by this PGPROC, if any */
    VirtualTransactionId vxid;  /* virtual transaction ID of this PGPROC */
    TimestampTz waitStart;      /* time at which this PGPROC started waiting
                                 * for lock */
    int         pid;            /* pid of this PGPROC */
    int         leaderPid;      /* pid of group leader; = pid if no group */
    bool        fastpath;       /* taken via fastpath? */
} LockInstanceData;
 
typedef struct LockData
{
    int         nelements;      /* The length of the array */
    LockInstanceData *locks;    /* Array of per-PROCLOCK information */
} LockData;
 
typedef struct BlockedProcData
{
    int         pid;            /* pid of a blocked PGPROC */
    /* Per-PROCLOCK information about PROCLOCKs of the lock the pid awaits */
    /* (these fields refer to indexes in BlockedProcsData.locks[]) */
    int         first_lock;     /* index of first relevant LockInstanceData */
    int         num_locks;      /* number of relevant LockInstanceDatas */
    /* PIDs of PGPROCs that are ahead of "pid" in the lock's wait queue */
    /* (these fields refer to indexes in BlockedProcsData.waiter_pids[]) */
    int         first_waiter;   /* index of first preceding waiter */
    int         num_waiters;    /* number of preceding waiters */
} BlockedProcData;
 
typedef struct BlockedProcsData
{
    BlockedProcData *procs;     /* Array of per-blocked-proc information */
    LockInstanceData *locks;    /* Array of per-PROCLOCK information */
    int        *waiter_pids;    /* Array of PIDs of other blocked PGPROCs */
    int         nprocs;         /* # of valid entries in procs[] array */
    int         maxprocs;       /* Allocated length of procs[] array */
    int         nlocks;         /* # of valid entries in locks[] array */
    int         maxlocks;       /* Allocated length of locks[] array */
    int         npids;          /* # of valid entries in waiter_pids[] array */
    int         maxpids;        /* Allocated length of waiter_pids[] array */
} BlockedProcsData;
 
 
/* Result codes for LockAcquire() */
typedef enum
{
    LOCKACQUIRE_NOT_AVAIL,      /* lock not available, and dontWait=true */
    LOCKACQUIRE_OK,             /* lock successfully acquired */
    LOCKACQUIRE_ALREADY_HELD,   /* incremented count for lock already held */
    LOCKACQUIRE_ALREADY_CLEAR,  /* incremented count for lock already clear */
} LockAcquireResult;
 
/* Deadlock states identified by DeadLockCheck() */
typedef enum
{
    DS_NOT_YET_CHECKED,         /* no deadlock check has run yet */
    DS_NO_DEADLOCK,             /* no deadlock detected */
    DS_SOFT_DEADLOCK,           /* deadlock avoided by queue rearrangement */
    DS_HARD_DEADLOCK,           /* deadlock, no way out but ERROR */
    DS_BLOCKED_BY_AUTOVACUUM,   /* no deadlock; queue blocked by autovacuum
                                 * worker */
} DeadLockState;
 
/*
 * The lockmgr's shared hash tables are partitioned to reduce contention.
 * To determine which partition a given locktag belongs to, compute the tag's
 * hash code with LockTagHashCode(), then apply one of these macros.
 * NB: NUM_LOCK_PARTITIONS must be a power of 2!
 */
#define LockHashPartition(hashcode) \
    ((hashcode) % NUM_LOCK_PARTITIONS)
#define LockHashPartitionLock(hashcode) \
    (&MainLWLockArray[LOCK_MANAGER_LWLOCK_OFFSET + \
        LockHashPartition(hashcode)].lock)
#define LockHashPartitionLockByIndex(i) \
    (&MainLWLockArray[LOCK_MANAGER_LWLOCK_OFFSET + (i)].lock)
 
/*
 * The deadlock detector needs to be able to access lockGroupLeader and
 * related fields in the PGPROC, so we arrange for those fields to be protected
 * by one of the lock hash partition locks.  Since the deadlock detector
 * acquires all such locks anyway, this makes it safe for it to access these
 * fields without doing anything extra.  To avoid contention as much as
 * possible, we map different PGPROCs to different partition locks.  The lock
 * used for a given lock group is determined by the group leader's pgprocno.
 */
#define LockHashPartitionLockByProc(leader_pgproc) \
    LockHashPartitionLock(GetNumberFromPGProc(leader_pgproc))
 
/*
 * function prototypes
 */
extern void InitLockManagerAccess(void);
extern LockMethod GetLocksMethodTable(const LOCK *lock);
extern LockMethod GetLockTagsMethodTable(const LOCKTAG *locktag);
extern uint32 LockTagHashCode(const LOCKTAG *locktag);
extern bool DoLockModesConflict(LOCKMODE mode1, LOCKMODE mode2);
extern LockAcquireResult LockAcquire(const LOCKTAG *locktag,
                                     LOCKMODE lockmode,
                                     bool sessionLock,
                                     bool dontWait);
extern LockAcquireResult LockAcquireExtended(const LOCKTAG *locktag,
                                             LOCKMODE lockmode,
                                             bool sessionLock,
                                             bool dontWait,
                                             bool reportMemoryError,
                                             LOCALLOCK **locallockp,
                                             bool logLockFailure);
extern void AbortStrongLockAcquire(void);
extern void MarkLockClear(LOCALLOCK *locallock);
extern bool LockRelease(const LOCKTAG *locktag,
                        LOCKMODE lockmode, bool sessionLock);
extern void LockReleaseAll(LOCKMETHODID lockmethodid, bool allLocks);
extern void LockReleaseSession(LOCKMETHODID lockmethodid);
extern void LockReleaseCurrentOwner(LOCALLOCK **locallocks, int nlocks);
extern void LockReassignCurrentOwner(LOCALLOCK **locallocks, int nlocks);
extern bool LockHeldByMe(const LOCKTAG *locktag,
                         LOCKMODE lockmode, bool orstronger);
#ifdef USE_ASSERT_CHECKING
extern HTAB *GetLockMethodLocalHash(void);
#endif
extern bool LockHasWaiters(const LOCKTAG *locktag,
                           LOCKMODE lockmode, bool sessionLock);
extern VirtualTransactionId *GetLockConflicts(const LOCKTAG *locktag,
                                              LOCKMODE lockmode, int *countp);
extern void AtPrepare_Locks(void);
extern void PostPrepare_Locks(FullTransactionId fxid);
extern bool LockCheckConflicts(LockMethod lockMethodTable,
                               LOCKMODE lockmode,
                               LOCK *lock, PROCLOCK *proclock);
extern void GrantLock(LOCK *lock, PROCLOCK *proclock, LOCKMODE lockmode);
extern void GrantAwaitedLock(void);
extern LOCALLOCK *GetAwaitedLock(void);
extern void ResetAwaitedLock(void);
 
extern void RemoveFromWaitQueue(PGPROC *proc, uint32 hashcode);
extern LockData *GetLockStatusData(void);
extern BlockedProcsData *GetBlockerStatusData(int blocked_pid);
 
extern xl_standby_lock *GetRunningTransactionLocks(int *nlocks);
extern const char *GetLockmodeName(LOCKMETHODID lockmethodid, LOCKMODE mode);
 
extern void lock_twophase_recover(FullTransactionId fxid, uint16 info,
                                  void *recdata, uint32 len);
extern void lock_twophase_postcommit(FullTransactionId fxid, uint16 info,
                                     void *recdata, uint32 len);
extern void lock_twophase_postabort(FullTransactionId fxid, uint16 info,
                                    void *recdata, uint32 len);
extern void lock_twophase_standby_recover(FullTransactionId fxid, uint16 info,
                                          void *recdata, uint32 len);
 
extern DeadLockState DeadLockCheck(PGPROC *proc);
extern PGPROC *GetBlockingAutoVacuumPgproc(void);
pg_noreturn extern void DeadLockReport(void);
extern void RememberSimpleDeadLock(PGPROC *proc1,
                                   LOCKMODE lockmode,
                                   LOCK *lock,
                                   PGPROC *proc2);
extern void InitDeadLockChecking(void);
 
extern int  LockWaiterCount(const LOCKTAG *locktag);
 
#ifdef LOCK_DEBUG
extern void DumpLocks(PGPROC *proc);
extern void DumpAllLocks(void);
#endif
 
/* Lock a VXID (used to wait for a transaction to finish) */
extern void VirtualXactLockTableInsert(VirtualTransactionId vxid);
extern void VirtualXactLockTableCleanup(void);
extern bool VirtualXactLock(VirtualTransactionId vxid, bool wait);
 
#endif                          /* LOCK_H_ */

◆ InvalidLocalTransactionId

#define InvalidLocalTransactionId 0

Definition at line 68 of file lock.h.

◆ LOCALLOCK_LOCKMETHOD

#define LOCALLOCK_LOCKMETHOD ( llock ) ((llock).tag.lock.locktag_lockmethodid)

Definition at line 274 of file lock.h.

◆ LOCALLOCK_LOCKTAG

#define LOCALLOCK_LOCKTAG ( llock ) ((LockTagType) (llock).tag.lock.locktag_type)

Definition at line 275 of file lock.h.

◆ LocalTransactionIdIsValid

#define LocalTransactionIdIsValid ( lxid ) ((lxid) != InvalidLocalTransactionId)

Definition at line 69 of file lock.h.

◆ LOCK_LOCKMETHOD

#define LOCK_LOCKMETHOD ( lock ) ((LOCKMETHODID) (lock).tag.locktag_lockmethodid)

Definition at line 155 of file lock.h.

◆ LOCK_LOCKTAG

#define LOCK_LOCKTAG ( lock ) ((LockTagType) (lock).tag.locktag_type)

Definition at line 156 of file lock.h.

◆ LOCKBIT_OFF

#define LOCKBIT_OFF ( lockmode ) (~(1 << (lockmode)))

Definition at line 88 of file lock.h.

◆ LOCKBIT_ON

#define LOCKBIT_ON ( lockmode ) (1 << (lockmode))

Definition at line 87 of file lock.h.

◆ LockHashPartition

#define LockHashPartition ( hashcode ) ((hashcode) % NUM_LOCK_PARTITIONS)

Definition at line 355 of file lock.h.

◆ LockHashPartitionLock

#define LockHashPartitionLock ( hashcode )

Value:

(&MainLWLockArray[LOCK_MANAGER_LWLOCK_OFFSET + \

LockHashPartition(hashcode)].lock)

MainLWLockArray

LWLockPadded * MainLWLockArray

Definition lwlock.c:150

LOCK_MANAGER_LWLOCK_OFFSET

#define LOCK_MANAGER_LWLOCK_OFFSET

Definition lwlock.h:95

LWLockPadded::lock

LWLock lock

Definition lwlock.h:70

Definition at line 357 of file lock.h.

◆ LockHashPartitionLockByIndex

#define LockHashPartitionLockByIndex ( i ) (&MainLWLockArray[LOCK_MANAGER_LWLOCK_OFFSET + (i)].lock)

Definition at line 360 of file lock.h.

◆ LockHashPartitionLockByProc

#define LockHashPartitionLockByProc ( leader_pgproc ) LockHashPartitionLock(GetNumberFromPGProc(leader_pgproc))

Definition at line 372 of file lock.h.

◆ MAX_LOCKMODES

#define MAX_LOCKMODES 10

Definition at line 85 of file lock.h.

◆ PROCLOCK_LOCKMETHOD

#define PROCLOCK_LOCKMETHOD ( proclock ) LOCK_LOCKMETHOD(*((proclock).tag.myLock))

Definition at line 213 of file lock.h.

◆ SetInvalidVirtualTransactionId

#define SetInvalidVirtualTransactionId ( vxid )

Value:

((vxid).procNumber = INVALID_PROC_NUMBER, \

(vxid).localTransactionId = InvalidLocalTransactionId)

InvalidLocalTransactionId

#define InvalidLocalTransactionId

Definition lock.h:68

INVALID_PROC_NUMBER

#define INVALID_PROC_NUMBER

Definition procnumber.h:26

Definition at line 77 of file lock.h.

◆ VirtualTransactionIdEquals

#define VirtualTransactionIdEquals	(	vxid1,
		vxid2
	)

Value:

((vxid1).procNumber == (vxid2).procNumber && \

(vxid1).localTransactionId == (vxid2).localTransactionId)

Definition at line 74 of file lock.h.

◆ VirtualTransactionIdIsRecoveredPreparedXact

#define VirtualTransactionIdIsRecoveredPreparedXact ( vxid ) ((vxid).procNumber == INVALID_PROC_NUMBER)

Definition at line 72 of file lock.h.

◆ VirtualTransactionIdIsValid

#define VirtualTransactionIdIsValid ( vxid ) (LocalTransactionIdIsValid((vxid).localTransactionId))

Definition at line 70 of file lock.h.

Typedef Documentation

◆ BlockedProcData

typedef struct BlockedProcData BlockedProcData

◆ BlockedProcsData

typedef struct BlockedProcsData BlockedProcsData

◆ LOCALLOCK

typedef struct LOCALLOCK LOCALLOCK

◆ LOCALLOCKOWNER

typedef struct LOCALLOCKOWNER LOCALLOCKOWNER

◆ LOCALLOCKTAG

typedef struct LOCALLOCKTAG LOCALLOCKTAG

◆ LOCK

typedef struct LOCK LOCK

◆ LockData

typedef struct LockData LockData

◆ LockInstanceData

typedef struct LockInstanceData LockInstanceData

◆ LockMethod

typedef const LockMethodData* LockMethod

Definition at line 119 of file lock.h.

◆ LockMethodData

typedef struct LockMethodData LockMethodData

◆ PGPROC

typedef struct PGPROC PGPROC

Definition at line 31 of file lock.h.

◆ PROCLOCK

typedef struct PROCLOCK PROCLOCK

◆ PROCLOCKTAG

typedef struct PROCLOCKTAG PROCLOCKTAG

◆ VirtualTransactionId

typedef struct VirtualTransactionId VirtualTransactionId

Enumeration Type Documentation

◆ DeadLockState

enum DeadLockState

Enumerator
DS_NOT_YET_CHECKED
DS_NO_DEADLOCK
DS_SOFT_DEADLOCK
DS_HARD_DEADLOCK
DS_BLOCKED_BY_AUTOVACUUM

Definition at line 339 of file lock.h.

{
    DS_NOT_YET_CHECKED,         /* no deadlock check has run yet */
    DS_NO_DEADLOCK,             /* no deadlock detected */
    DS_SOFT_DEADLOCK,           /* deadlock avoided by queue rearrangement */
    DS_HARD_DEADLOCK,           /* deadlock, no way out but ERROR */
    DS_BLOCKED_BY_AUTOVACUUM,   /* no deadlock; queue blocked by autovacuum
                                 * worker */
} DeadLockState;

◆ LockAcquireResult

enum LockAcquireResult

Enumerator
LOCKACQUIRE_NOT_AVAIL
LOCKACQUIRE_OK
LOCKACQUIRE_ALREADY_HELD
LOCKACQUIRE_ALREADY_CLEAR

Definition at line 330 of file lock.h.

{
    LOCKACQUIRE_NOT_AVAIL,      /* lock not available, and dontWait=true */
    LOCKACQUIRE_OK,             /* lock successfully acquired */
    LOCKACQUIRE_ALREADY_HELD,   /* incremented count for lock already held */
    LOCKACQUIRE_ALREADY_CLEAR,  /* incremented count for lock already clear */
} LockAcquireResult;

Function Documentation

◆ AbortStrongLockAcquire()

void AbortStrongLockAcquire ( void )

extern

Definition at line 1869 of file lock.c.

{
    uint32      fasthashcode;
    LOCALLOCK  *locallock = StrongLockInProgress;
 
    if (locallock == NULL)
        return;
 
    fasthashcode = FastPathStrongLockHashPartition(locallock->hashcode);
    Assert(locallock->holdsStrongLockCount == true);
    SpinLockAcquire(&FastPathStrongRelationLocks->mutex);
    Assert(FastPathStrongRelationLocks->count[fasthashcode] > 0);
    FastPathStrongRelationLocks->count[fasthashcode]--;
    locallock->holdsStrongLockCount = false;
    StrongLockInProgress = NULL;
    SpinLockRelease(&FastPathStrongRelationLocks->mutex);
}

References Assert, FastPathStrongRelationLockData::count, FastPathStrongLockHashPartition, FastPathStrongRelationLocks, fb(), FastPathStrongRelationLockData::mutex, SpinLockAcquire(), SpinLockRelease(), and StrongLockInProgress.

Referenced by LockAcquireExtended(), and LockErrorCleanup().

◆ AtPrepare_Locks()

void AtPrepare_Locks ( void )

extern

Definition at line 3485 of file lock.c.

{
    HASH_SEQ_STATUS status;
    LOCALLOCK  *locallock;
 
    /* First, verify there aren't locks of both xact and session level */
    CheckForSessionAndXactLocks();
 
    /* Now do the per-locallock cleanup work */
    hash_seq_init(&status, LockMethodLocalHash);
 
    while ((locallock = (LOCALLOCK *) hash_seq_search(&status)) != NULL)
    {
        TwoPhaseLockRecord record;
        LOCALLOCKOWNER *lockOwners = locallock->lockOwners;
        bool        haveSessionLock;
        bool        haveXactLock;
        int         i;
 
        /*
         * Ignore VXID locks.  We don't want those to be held by prepared
         * transactions, since they aren't meaningful after a restart.
         */
        if (locallock->tag.lock.locktag_type == LOCKTAG_VIRTUALTRANSACTION)
            continue;
 
        /* Ignore it if we don't actually hold the lock */
        if (locallock->nLocks <= 0)
            continue;
 
        /* Scan to see whether we hold it at session or transaction level */
        haveSessionLock = haveXactLock = false;
        for (i = locallock->numLockOwners - 1; i >= 0; i--)
        {
            if (lockOwners[i].owner == NULL)
                haveSessionLock = true;
            else
                haveXactLock = true;
        }
 
        /* Ignore it if we have only session lock */
        if (!haveXactLock)
            continue;
 
        /* This can't happen, because we already checked it */
        if (haveSessionLock)
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("cannot PREPARE while holding both session-level and transaction-level locks on the same object")));
 
        /*
         * If the local lock was taken via the fast-path, we need to move it
         * to the primary lock table, or just get a pointer to the existing
         * primary lock table entry if by chance it's already been
         * transferred.
         */
        if (locallock->proclock == NULL)
        {
            locallock->proclock = FastPathGetRelationLockEntry(locallock);
            locallock->lock = locallock->proclock->tag.myLock;
        }
 
        /*
         * Arrange to not release any strong lock count held by this lock
         * entry.  We must retain the count until the prepared transaction is
         * committed or rolled back.
         */
        locallock->holdsStrongLockCount = false;
 
        /*
         * Create a 2PC record.
         */
        memcpy(&(record.locktag), &(locallock->tag.lock), sizeof(LOCKTAG));
        record.lockmode = locallock->tag.mode;
 
        RegisterTwoPhaseRecord(TWOPHASE_RM_LOCK_ID, 0,
                               &record, sizeof(TwoPhaseLockRecord));
    }
}

References CheckForSessionAndXactLocks(), ereport, errcode(), errmsg, ERROR, FastPathGetRelationLockEntry(), fb(), hash_seq_init(), hash_seq_search(), i, LockMethodLocalHash, TwoPhaseLockRecord::lockmode, TwoPhaseLockRecord::locktag, LOCKTAG_VIRTUALTRANSACTION, memcpy(), RegisterTwoPhaseRecord(), and TWOPHASE_RM_LOCK_ID.

Referenced by PrepareTransaction().

◆ DeadLockCheck()

DeadLockState DeadLockCheck ( PGPROC * proc )

extern

Definition at line 220 of file deadlock.c.

{
    /* Initialize to "no constraints" */
    nCurConstraints = 0;
    nPossibleConstraints = 0;
    nWaitOrders = 0;
 
    /* Initialize to not blocked by an autovacuum worker */
    blocking_autovacuum_proc = NULL;
 
    /* Search for deadlocks and possible fixes */
    if (DeadLockCheckRecurse(proc))
    {
        /*
         * Call FindLockCycle one more time, to record the correct
         * deadlockDetails[] for the basic state with no rearrangements.
         */
        int         nSoftEdges;
 
        TRACE_POSTGRESQL_DEADLOCK_FOUND();
 
        nWaitOrders = 0;
        if (!FindLockCycle(proc, possibleConstraints, &nSoftEdges))
            elog(FATAL, "deadlock seems to have disappeared");
 
        return DS_HARD_DEADLOCK;    /* cannot find a non-deadlocked state */
    }
 
    /* Apply any needed rearrangements of wait queues */
    for (int i = 0; i < nWaitOrders; i++)
    {
        LOCK       *lock = waitOrders[i].lock;
        PGPROC    **procs = waitOrders[i].procs;
        int         nProcs = waitOrders[i].nProcs;
        dclist_head *waitQueue = &lock->waitProcs;
 
        Assert(nProcs == dclist_count(waitQueue));
 
#ifdef DEBUG_DEADLOCK
        PrintLockQueue(lock, "DeadLockCheck:");
#endif
 
        /* Reset the queue and re-add procs in the desired order */
        dclist_init(waitQueue);
        for (int j = 0; j < nProcs; j++)
            dclist_push_tail(waitQueue, &procs[j]->waitLink);
 
#ifdef DEBUG_DEADLOCK
        PrintLockQueue(lock, "rearranged to:");
#endif
 
        /* See if any waiters for the lock can be woken up now */
        ProcLockWakeup(GetLocksMethodTable(lock), lock);
    }
 
    /* Return code tells caller if we had to escape a deadlock or not */
    if (nWaitOrders > 0)
        return DS_SOFT_DEADLOCK;
    else if (blocking_autovacuum_proc != NULL)
        return DS_BLOCKED_BY_AUTOVACUUM;
    else
        return DS_NO_DEADLOCK;
}

References Assert, blocking_autovacuum_proc, dclist_count(), dclist_init(), dclist_push_tail(), DeadLockCheckRecurse(), DS_BLOCKED_BY_AUTOVACUUM, DS_HARD_DEADLOCK, DS_NO_DEADLOCK, DS_SOFT_DEADLOCK, elog, FATAL, fb(), FindLockCycle(), GetLocksMethodTable(), i, j, WAIT_ORDER::lock, nCurConstraints, nPossibleConstraints, WAIT_ORDER::nProcs, nWaitOrders, possibleConstraints, ProcLockWakeup(), WAIT_ORDER::procs, waitOrders, and LOCK::waitProcs.

Referenced by CheckDeadLock().

◆ DeadLockReport()

pg_noreturn void DeadLockReport ( void )

extern

Definition at line 1075 of file deadlock.c.

{
    StringInfoData clientbuf;   /* errdetail for client */
    StringInfoData logbuf;      /* errdetail for server log */
    StringInfoData locktagbuf;
    int         i;
 
    initStringInfo(&clientbuf);
    initStringInfo(&logbuf);
    initStringInfo(&locktagbuf);
 
    /* Generate the "waits for" lines sent to the client */
    for (i = 0; i < nDeadlockDetails; i++)
    {
        DEADLOCK_INFO *info = &deadlockDetails[i];
        int         nextpid;
 
        /* The last proc waits for the first one... */
        if (i < nDeadlockDetails - 1)
            nextpid = info[1].pid;
        else
            nextpid = deadlockDetails[0].pid;
 
        /* reset locktagbuf to hold next object description */
        resetStringInfo(&locktagbuf);
 
        DescribeLockTag(&locktagbuf, &info->locktag);
 
        if (i > 0)
            appendStringInfoChar(&clientbuf, '\n');
 
        appendStringInfo(&clientbuf,
                         _("Process %d waits for %s on %s; blocked by process %d."),
                         info->pid,
                         GetLockmodeName(info->locktag.locktag_lockmethodid,
                                         info->lockmode),
                         locktagbuf.data,
                         nextpid);
    }
 
    /* Duplicate all the above for the server ... */
    appendBinaryStringInfo(&logbuf, clientbuf.data, clientbuf.len);
 
    /* ... and add info about query strings */
    for (i = 0; i < nDeadlockDetails; i++)
    {
        DEADLOCK_INFO *info = &deadlockDetails[i];
 
        appendStringInfoChar(&logbuf, '\n');
 
        appendStringInfo(&logbuf,
                         _("Process %d: %s"),
                         info->pid,
                         pgstat_get_backend_current_activity(info->pid, false));
    }
 
    pgstat_report_deadlock();
 
    ereport(ERROR,
            (errcode(ERRCODE_T_R_DEADLOCK_DETECTED),
             errmsg("deadlock detected"),
             errdetail_internal("%s", clientbuf.data),
             errdetail_log("%s", logbuf.data),
             errhint("See server log for query details.")));
}

References _, appendBinaryStringInfo(), appendStringInfo(), appendStringInfoChar(), deadlockDetails, DescribeLockTag(), ereport, errcode(), ERRCODE_T_R_DEADLOCK_DETECTED, errdetail_internal(), errdetail_log(), errhint(), errmsg, ERROR, fb(), GetLockmodeName(), i, initStringInfo(), DEADLOCK_INFO::lockmode, DEADLOCK_INFO::locktag, LOCKTAG::locktag_lockmethodid, nDeadlockDetails, pgstat_get_backend_current_activity(), pgstat_report_deadlock(), DEADLOCK_INFO::pid, and resetStringInfo().

Referenced by LockAcquireExtended().

◆ DoLockModesConflict()

bool DoLockModesConflict	(	LOCKMODE	mode1,
		LOCKMODE	mode2
	)

extern

Definition at line 621 of file lock.c.

{
    LockMethod  lockMethodTable = LockMethods[DEFAULT_LOCKMETHOD];
 
    if (lockMethodTable->conflictTab[mode1] & LOCKBIT_ON(mode2))
        return true;
 
    return false;
}

References DEFAULT_LOCKMETHOD, fb(), LOCKBIT_ON, and LockMethods.

Referenced by Do_MultiXactIdWait(), DoesMultiXactIdConflict(), initialize_reloptions(), and test_lockmode_for_conflict().

◆ GetAwaitedLock()

LOCALLOCK * GetAwaitedLock ( void )

extern

Definition at line 1907 of file lock.c.

{
    return awaitedLock;
}

References awaitedLock.

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

◆ GetBlockerStatusData()

BlockedProcsData * GetBlockerStatusData ( int blocked_pid )

extern

Definition at line 3980 of file lock.c.

{
    BlockedProcsData *data;
    PGPROC     *proc;
    int         i;
 
    data = palloc_object(BlockedProcsData);
 
    /*
     * Guess how much space we'll need, and preallocate.  Most of the time
     * this will avoid needing to do repalloc while holding the LWLocks.  (We
     * assume, but check with an Assert, that MaxBackends is enough entries
     * for the procs[] array; the other two could need enlargement, though.)
     */
    data->nprocs = data->nlocks = data->npids = 0;
    data->maxprocs = data->maxlocks = data->maxpids = MaxBackends;
    data->procs = palloc_array(BlockedProcData, data->maxprocs);
    data->locks = palloc_array(LockInstanceData, data->maxlocks);
    data->waiter_pids = palloc_array(int, data->maxpids);
 
    /*
     * In order to search the ProcArray for blocked_pid and assume that that
     * entry won't immediately disappear under us, we must hold ProcArrayLock.
     * In addition, to examine the lock grouping fields of any other backend,
     * we must hold all the hash partition locks.  (Only one of those locks is
     * actually relevant for any one lock group, but we can't know which one
     * ahead of time.)  It's fairly annoying to hold all those locks
     * throughout this, but it's no worse than GetLockStatusData(), and it
     * does have the advantage that we're guaranteed to return a
     * self-consistent instantaneous state.
     */
    LWLockAcquire(ProcArrayLock, LW_SHARED);
 
    proc = BackendPidGetProcWithLock(blocked_pid);
 
    /* Nothing to do if it's gone */
    if (proc != NULL)
    {
        /*
         * Acquire lock on the entire shared lock data structure.  See notes
         * in GetLockStatusData().
         */
        for (i = 0; i < NUM_LOCK_PARTITIONS; i++)
            LWLockAcquire(LockHashPartitionLockByIndex(i), LW_SHARED);
 
        if (proc->lockGroupLeader == NULL)
        {
            /* Easy case, proc is not a lock group member */
            GetSingleProcBlockerStatusData(proc, data);
        }
        else
        {
            /* Examine all procs in proc's lock group */
            dlist_iter  iter;
 
            dlist_foreach(iter, &proc->lockGroupLeader->lockGroupMembers)
            {
                PGPROC     *memberProc;
 
                memberProc = dlist_container(PGPROC, lockGroupLink, iter.cur);
                GetSingleProcBlockerStatusData(memberProc, data);
            }
        }
 
        /*
         * And release locks.  See notes in GetLockStatusData().
         */
        for (i = NUM_LOCK_PARTITIONS; --i >= 0;)
            LWLockRelease(LockHashPartitionLockByIndex(i));
 
        Assert(data->nprocs <= data->maxprocs);
    }
 
    LWLockRelease(ProcArrayLock);
 
    return data;
}

References Assert, BackendPidGetProcWithLock(), dlist_iter::cur, data, dlist_container, dlist_foreach, fb(), GetSingleProcBlockerStatusData(), i, PGPROC::lockGroupLeader, PGPROC::lockGroupMembers, LockHashPartitionLockByIndex, LW_SHARED, LWLockAcquire(), LWLockRelease(), MaxBackends, NUM_LOCK_PARTITIONS, palloc_array, and palloc_object.

Referenced by pg_blocking_pids().

◆ GetBlockingAutoVacuumPgproc()

PGPROC * GetBlockingAutoVacuumPgproc ( void )

extern

Definition at line 290 of file deadlock.c.

{
    PGPROC     *ptr;
 
    ptr = blocking_autovacuum_proc;
    blocking_autovacuum_proc = NULL;
 
    return ptr;
}

References blocking_autovacuum_proc, and fb().

Referenced by ProcSleep().

◆ GetLockConflicts()

VirtualTransactionId * GetLockConflicts	(	const LOCKTAG *	locktag,
		LOCKMODE	lockmode,
		int *	countp
	)

extern

Definition at line 3078 of file lock.c.

{
    static VirtualTransactionId *vxids;
    LOCKMETHODID lockmethodid = locktag->locktag_lockmethodid;
    LockMethod  lockMethodTable;
    LOCK       *lock;
    LOCKMASK    conflictMask;
    dlist_iter  proclock_iter;
    PROCLOCK   *proclock;
    uint32      hashcode;
    LWLock     *partitionLock;
    int         count = 0;
    int         fast_count = 0;
 
    if (lockmethodid <= 0 || lockmethodid >= lengthof(LockMethods))
        elog(ERROR, "unrecognized lock method: %d", lockmethodid);
    lockMethodTable = LockMethods[lockmethodid];
    if (lockmode <= 0 || lockmode > lockMethodTable->numLockModes)
        elog(ERROR, "unrecognized lock mode: %d", lockmode);
 
    /*
     * Allocate memory to store results, and fill with InvalidVXID.  We only
     * need enough space for MaxBackends + max_prepared_xacts + a terminator.
     * InHotStandby allocate once in TopMemoryContext.
     */
    if (InHotStandby)
    {
        if (vxids == NULL)
            vxids = (VirtualTransactionId *)
                MemoryContextAlloc(TopMemoryContext,
                                   sizeof(VirtualTransactionId) *
                                   (MaxBackends + max_prepared_xacts + 1));
    }
    else
        vxids = palloc0_array(VirtualTransactionId, (MaxBackends + max_prepared_xacts + 1));
 
    /* Compute hash code and partition lock, and look up conflicting modes. */
    hashcode = LockTagHashCode(locktag);
    partitionLock = LockHashPartitionLock(hashcode);
    conflictMask = lockMethodTable->conflictTab[lockmode];
 
    /*
     * Fast path locks might not have been entered in the primary lock table.
     * If the lock we're dealing with could conflict with such a lock, we must
     * examine each backend's fast-path array for conflicts.
     */
    if (ConflictsWithRelationFastPath(locktag, lockmode))
    {
        int         i;
        Oid         relid = locktag->locktag_field2;
        VirtualTransactionId vxid;
 
        /* fast-path group the lock belongs to */
        uint32      group = FAST_PATH_REL_GROUP(relid);
 
        /*
         * Iterate over relevant PGPROCs.  Anything held by a prepared
         * transaction will have been transferred to the primary lock table,
         * so we need not worry about those.  This is all a bit fuzzy, because
         * new locks could be taken after we've visited a particular
         * partition, but the callers had better be prepared to deal with that
         * anyway, since the locks could equally well be taken between the
         * time we return the value and the time the caller does something
         * with it.
         */
        for (i = 0; i < ProcGlobal->allProcCount; i++)
        {
            PGPROC     *proc = GetPGProcByNumber(i);
            uint32      j;
 
            /* A backend never blocks itself */
            if (proc == MyProc)
                continue;
 
            LWLockAcquire(&proc->fpInfoLock, LW_SHARED);
 
            /*
             * If the target backend isn't referencing the same database as
             * the lock, then we needn't examine the individual relation IDs
             * at all; none of them can be relevant.
             *
             * See FastPathTransferRelationLocks() for discussion of why we do
             * this test after acquiring the lock.
             *
             * Also skip groups without any registered fast-path locks.
             */
            if (proc->databaseId != locktag->locktag_field1 ||
                proc->fpLockBits[group] == 0)
            {
                LWLockRelease(&proc->fpInfoLock);
                continue;
            }
 
            for (j = 0; j < FP_LOCK_SLOTS_PER_GROUP; j++)
            {
                uint32      lockmask;
 
                /* index into the whole per-backend array */
                uint32      f = FAST_PATH_SLOT(group, j);
 
                /* Look for an allocated slot matching the given relid. */
                if (relid != proc->fpRelId[f])
                    continue;
                lockmask = FAST_PATH_GET_BITS(proc, f);
                if (!lockmask)
                    continue;
                lockmask <<= FAST_PATH_LOCKNUMBER_OFFSET;
 
                /*
                 * There can only be one entry per relation, so if we found it
                 * and it doesn't conflict, we can skip the rest of the slots.
                 */
                if ((lockmask & conflictMask) == 0)
                    break;
 
                /* Conflict! */
                GET_VXID_FROM_PGPROC(vxid, *proc);
 
                if (VirtualTransactionIdIsValid(vxid))
                    vxids[count++] = vxid;
                /* else, xact already committed or aborted */
 
                /* No need to examine remaining slots. */
                break;
            }
 
            LWLockRelease(&proc->fpInfoLock);
        }
    }
 
    /* Remember how many fast-path conflicts we found. */
    fast_count = count;
 
    /*
     * Look up the lock object matching the tag.
     */
    LWLockAcquire(partitionLock, LW_SHARED);
 
    lock = (LOCK *) hash_search_with_hash_value(LockMethodLockHash,
                                                locktag,
                                                hashcode,
                                                HASH_FIND,
                                                NULL);
    if (!lock)
    {
        /*
         * If the lock object doesn't exist, there is nothing holding a lock
         * on this lockable object.
         */
        LWLockRelease(partitionLock);
        vxids[count].procNumber = INVALID_PROC_NUMBER;
        vxids[count].localTransactionId = InvalidLocalTransactionId;
        if (countp)
            *countp = count;
        return vxids;
    }
 
    /*
     * Examine each existing holder (or awaiter) of the lock.
     */
    dlist_foreach(proclock_iter, &lock->procLocks)
    {
        proclock = dlist_container(PROCLOCK, lockLink, proclock_iter.cur);
 
        if (conflictMask & proclock->holdMask)
        {
            PGPROC     *proc = proclock->tag.myProc;
 
            /* A backend never blocks itself */
            if (proc != MyProc)
            {
                VirtualTransactionId vxid;
 
                GET_VXID_FROM_PGPROC(vxid, *proc);
 
                if (VirtualTransactionIdIsValid(vxid))
                {
                    int         i;
 
                    /* Avoid duplicate entries. */
                    for (i = 0; i < fast_count; ++i)
                        if (VirtualTransactionIdEquals(vxids[i], vxid))
                            break;
                    if (i >= fast_count)
                        vxids[count++] = vxid;
                }
                /* else, xact already committed or aborted */
            }
        }
    }
 
    LWLockRelease(partitionLock);
 
    if (count > MaxBackends + max_prepared_xacts)   /* should never happen */
        elog(PANIC, "too many conflicting locks found");
 
    vxids[count].procNumber = INVALID_PROC_NUMBER;
    vxids[count].localTransactionId = InvalidLocalTransactionId;
    if (countp)
        *countp = count;
    return vxids;
}

References PROC_HDR::allProcCount, ConflictsWithRelationFastPath, PGPROC::databaseId, dlist_container, dlist_foreach, elog, ERROR, FAST_PATH_GET_BITS, FAST_PATH_LOCKNUMBER_OFFSET, FAST_PATH_REL_GROUP, FAST_PATH_SLOT, fb(), FP_LOCK_SLOTS_PER_GROUP, PGPROC::fpInfoLock, PGPROC::fpLockBits, PGPROC::fpRelId, GET_VXID_FROM_PGPROC, GetPGProcByNumber, HASH_FIND, hash_search_with_hash_value(), PROCLOCK::holdMask, i, InHotStandby, INVALID_PROC_NUMBER, InvalidLocalTransactionId, j, lengthof, LockHashPartitionLock, LockMethodLockHash, LockMethods, LOCKTAG::locktag_field1, LOCKTAG::locktag_field2, LOCKTAG::locktag_lockmethodid, LockTagHashCode(), LW_SHARED, LWLockAcquire(), LWLockRelease(), max_prepared_xacts, MaxBackends, MemoryContextAlloc(), MyProc, PROCLOCKTAG::myProc, palloc0_array, PANIC, ProcGlobal, LOCK::procLocks, PROCLOCK::tag, TopMemoryContext, VirtualTransactionIdEquals, and VirtualTransactionIdIsValid.

Referenced by ProcSleep(), ResolveRecoveryConflictWithLock(), and WaitForLockersMultiple().

◆ GetLockmodeName()

const char * GetLockmodeName	(	LOCKMETHODID	lockmethodid,
		LOCKMODE	mode
	)

extern

Definition at line 4236 of file lock.c.

{
    Assert(lockmethodid > 0 && lockmethodid < lengthof(LockMethods));
    Assert(mode > 0 && mode <= LockMethods[lockmethodid]->numLockModes);
    return LockMethods[lockmethodid]->lockModeNames[mode];
}

References Assert, fb(), lengthof, LockMethods, LockMethodData::lockModeNames, and mode.

Referenced by DeadLockReport(), LockAcquireExtended(), overexplain_range_table(), pg_lock_status(), ProcSleep(), and waitonlock_error_callback().

◆ GetLocksMethodTable()

LockMethod GetLocksMethodTable ( const LOCK * lock )

extern

Definition at line 525 of file lock.c.

{
    LOCKMETHODID lockmethodid = LOCK_LOCKMETHOD(*lock);
 
    Assert(0 < lockmethodid && lockmethodid < lengthof(LockMethods));
    return LockMethods[lockmethodid];
}

References Assert, fb(), lengthof, LOCK_LOCKMETHOD, and LockMethods.

Referenced by DeadLockCheck(), and FindLockCycleRecurseMember().

◆ GetLockStatusData()

LockData * GetLockStatusData ( void )

extern

Definition at line 3777 of file lock.c.

{
    LockData   *data;
    PROCLOCK   *proclock;
    HASH_SEQ_STATUS seqstat;
    int         els;
    int         el;
    int         i;
 
    data = palloc_object(LockData);
 
    /* Guess how much space we'll need. */
    els = MaxBackends;
    el = 0;
    data->locks = palloc_array(LockInstanceData, els);
 
    /*
     * First, we iterate through the per-backend fast-path arrays, locking
     * them one at a time.  This might produce an inconsistent picture of the
     * system state, but taking all of those LWLocks at the same time seems
     * impractical (in particular, note MAX_SIMUL_LWLOCKS).  It shouldn't
     * matter too much, because none of these locks can be involved in lock
     * conflicts anyway - anything that might must be present in the main lock
     * table.  (For the same reason, we don't sweat about making leaderPid
     * completely valid.  We cannot safely dereference another backend's
     * lockGroupLeader field without holding all lock partition locks, and
     * it's not worth that.)
     */
    for (i = 0; i < ProcGlobal->allProcCount; ++i)
    {
        PGPROC     *proc = GetPGProcByNumber(i);
 
        /* Skip backends with pid=0, as they don't hold fast-path locks */
        if (proc->pid == 0)
            continue;
 
        LWLockAcquire(&proc->fpInfoLock, LW_SHARED);
 
        for (uint32 g = 0; g < FastPathLockGroupsPerBackend; g++)
        {
            /* Skip groups without registered fast-path locks */
            if (proc->fpLockBits[g] == 0)
                continue;
 
            for (int j = 0; j < FP_LOCK_SLOTS_PER_GROUP; j++)
            {
                LockInstanceData *instance;
                uint32      f = FAST_PATH_SLOT(g, j);
                uint32      lockbits = FAST_PATH_GET_BITS(proc, f);
 
                /* Skip unallocated slots */
                if (!lockbits)
                    continue;
 
                if (el >= els)
                {
                    els += MaxBackends;
                    data->locks = (LockInstanceData *)
                        repalloc(data->locks, sizeof(LockInstanceData) * els);
                }
 
                instance = &data->locks[el];
                SET_LOCKTAG_RELATION(instance->locktag, proc->databaseId,
                                     proc->fpRelId[f]);
                instance->holdMask = lockbits << FAST_PATH_LOCKNUMBER_OFFSET;
                instance->waitLockMode = NoLock;
                instance->vxid.procNumber = proc->vxid.procNumber;
                instance->vxid.localTransactionId = proc->vxid.lxid;
                instance->pid = proc->pid;
                instance->leaderPid = proc->pid;
                instance->fastpath = true;
 
                /*
                 * Successfully taking fast path lock means there were no
                 * conflicting locks.
                 */
                instance->waitStart = 0;
 
                el++;
            }
        }
 
        if (proc->fpVXIDLock)
        {
            VirtualTransactionId vxid;
            LockInstanceData *instance;
 
            if (el >= els)
            {
                els += MaxBackends;
                data->locks = (LockInstanceData *)
                    repalloc(data->locks, sizeof(LockInstanceData) * els);
            }
 
            vxid.procNumber = proc->vxid.procNumber;
            vxid.localTransactionId = proc->fpLocalTransactionId;
 
            instance = &data->locks[el];
            SET_LOCKTAG_VIRTUALTRANSACTION(instance->locktag, vxid);
            instance->holdMask = LOCKBIT_ON(ExclusiveLock);
            instance->waitLockMode = NoLock;
            instance->vxid.procNumber = proc->vxid.procNumber;
            instance->vxid.localTransactionId = proc->vxid.lxid;
            instance->pid = proc->pid;
            instance->leaderPid = proc->pid;
            instance->fastpath = true;
            instance->waitStart = 0;
 
            el++;
        }
 
        LWLockRelease(&proc->fpInfoLock);
    }
 
    /*
     * Next, acquire lock on the entire shared lock data structure.  We do
     * this so that, at least for locks in the primary lock table, the state
     * will be self-consistent.
     *
     * Since this is a read-only operation, we take shared instead of
     * exclusive lock.  There's not a whole lot of point to this, because all
     * the normal operations require exclusive lock, but it doesn't hurt
     * anything either. It will at least allow two backends to do
     * GetLockStatusData in parallel.
     *
     * Must grab LWLocks in partition-number order to avoid LWLock deadlock.
     */
    for (i = 0; i < NUM_LOCK_PARTITIONS; i++)
        LWLockAcquire(LockHashPartitionLockByIndex(i), LW_SHARED);
 
    /* Now we can safely count the number of proclocks */
    data->nelements = el + hash_get_num_entries(LockMethodProcLockHash);
    if (data->nelements > els)
    {
        els = data->nelements;
        data->locks = (LockInstanceData *)
            repalloc(data->locks, sizeof(LockInstanceData) * els);
    }
 
    /* Now scan the tables to copy the data */
    hash_seq_init(&seqstat, LockMethodProcLockHash);
 
    while ((proclock = (PROCLOCK *) hash_seq_search(&seqstat)))
    {
        PGPROC     *proc = proclock->tag.myProc;
        LOCK       *lock = proclock->tag.myLock;
        LockInstanceData *instance = &data->locks[el];
 
        memcpy(&instance->locktag, &lock->tag, sizeof(LOCKTAG));
        instance->holdMask = proclock->holdMask;
        if (proc->waitLock == proclock->tag.myLock)
            instance->waitLockMode = proc->waitLockMode;
        else
            instance->waitLockMode = NoLock;
        instance->vxid.procNumber = proc->vxid.procNumber;
        instance->vxid.localTransactionId = proc->vxid.lxid;
        instance->pid = proc->pid;
        instance->leaderPid = proclock->groupLeader->pid;
        instance->fastpath = false;
        instance->waitStart = (TimestampTz) pg_atomic_read_u64(&proc->waitStart);
 
        el++;
    }
 
    /*
     * And release locks.  We do this in reverse order for two reasons: (1)
     * Anyone else who needs more than one of the locks will be trying to lock
     * them in increasing order; we don't want to release the other process
     * until it can get all the locks it needs. (2) This avoids O(N^2)
     * behavior inside LWLockRelease.
     */
    for (i = NUM_LOCK_PARTITIONS; --i >= 0;)
        LWLockRelease(LockHashPartitionLockByIndex(i));
 
    Assert(el == data->nelements);
 
    return data;
}

References PROC_HDR::allProcCount, Assert, data, PGPROC::databaseId, ExclusiveLock, FAST_PATH_GET_BITS, FAST_PATH_LOCKNUMBER_OFFSET, FAST_PATH_SLOT, FastPathLockGroupsPerBackend, fb(), FP_LOCK_SLOTS_PER_GROUP, PGPROC::fpInfoLock, PGPROC::fpLocalTransactionId, PGPROC::fpLockBits, PGPROC::fpRelId, PGPROC::fpVXIDLock, GetPGProcByNumber, PROCLOCK::groupLeader, hash_get_num_entries(), hash_seq_init(), hash_seq_search(), PROCLOCK::holdMask, i, j, VirtualTransactionId::localTransactionId, LOCKBIT_ON, LockHashPartitionLockByIndex, LockMethodProcLockHash, LW_SHARED, LWLockAcquire(), LWLockRelease(), PGPROC::lxid, MaxBackends, memcpy(), PROCLOCKTAG::myLock, PROCLOCKTAG::myProc, NoLock, NUM_LOCK_PARTITIONS, palloc_array, palloc_object, pg_atomic_read_u64(), PGPROC::pid, ProcGlobal, VirtualTransactionId::procNumber, PGPROC::procNumber, repalloc(), SET_LOCKTAG_RELATION, SET_LOCKTAG_VIRTUALTRANSACTION, LOCK::tag, PROCLOCK::tag, PGPROC::vxid, PGPROC::waitLock, PGPROC::waitLockMode, and PGPROC::waitStart.

Referenced by pg_lock_status().

◆ GetLockTagsMethodTable()

LockMethod GetLockTagsMethodTable ( const LOCKTAG * locktag )

extern

Definition at line 537 of file lock.c.

{
    LOCKMETHODID lockmethodid = (LOCKMETHODID) locktag->locktag_lockmethodid;
 
    Assert(0 < lockmethodid && lockmethodid < lengthof(LockMethods));
    return LockMethods[lockmethodid];
}

References Assert, fb(), lengthof, LockMethods, and LOCKTAG::locktag_lockmethodid.

Referenced by pg_blocking_pids().

◆ GetRunningTransactionLocks()

xl_standby_lock * GetRunningTransactionLocks ( int * nlocks )

extern

Definition at line 4154 of file lock.c.

{
    xl_standby_lock *accessExclusiveLocks;
    PROCLOCK   *proclock;
    HASH_SEQ_STATUS seqstat;
    int         i;
    int         index;
    int         els;
 
    /*
     * Acquire lock on the entire shared lock data structure.
     *
     * Must grab LWLocks in partition-number order to avoid LWLock deadlock.
     */
    for (i = 0; i < NUM_LOCK_PARTITIONS; i++)
        LWLockAcquire(LockHashPartitionLockByIndex(i), LW_SHARED);
 
    /* Now we can safely count the number of proclocks */
    els = hash_get_num_entries(LockMethodProcLockHash);
 
    /*
     * Allocating enough space for all locks in the lock table is overkill,
     * but it's more convenient and faster than having to enlarge the array.
     */
    accessExclusiveLocks = palloc(els * sizeof(xl_standby_lock));
 
    /* Now scan the tables to copy the data */
    hash_seq_init(&seqstat, LockMethodProcLockHash);
 
    /*
     * If lock is a currently granted AccessExclusiveLock then it will have
     * just one proclock holder, so locks are never accessed twice in this
     * particular case. Don't copy this code for use elsewhere because in the
     * general case this will give you duplicate locks when looking at
     * non-exclusive lock types.
     */
    index = 0;
    while ((proclock = (PROCLOCK *) hash_seq_search(&seqstat)))
    {
        /* make sure this definition matches the one used in LockAcquire */
        if ((proclock->holdMask & LOCKBIT_ON(AccessExclusiveLock)) &&
            proclock->tag.myLock->tag.locktag_type == LOCKTAG_RELATION)
        {
            PGPROC     *proc = proclock->tag.myProc;
            LOCK       *lock = proclock->tag.myLock;
            TransactionId xid = proc->xid;
 
            /*
             * Don't record locks for transactions if we know they have
             * already issued their WAL record for commit but not yet released
             * lock. It is still possible that we see locks held by already
             * complete transactions, if they haven't yet zeroed their xids.
             */
            if (!TransactionIdIsValid(xid))
                continue;
 
            accessExclusiveLocks[index].xid = xid;
            accessExclusiveLocks[index].dbOid = lock->tag.locktag_field1;
            accessExclusiveLocks[index].relOid = lock->tag.locktag_field2;
 
            index++;
        }
    }
 
    Assert(index <= els);
 
    /*
     * And release locks.  We do this in reverse order for two reasons: (1)
     * Anyone else who needs more than one of the locks will be trying to lock
     * them in increasing order; we don't want to release the other process
     * until it can get all the locks it needs. (2) This avoids O(N^2)
     * behavior inside LWLockRelease.
     */
    for (i = NUM_LOCK_PARTITIONS; --i >= 0;)
        LWLockRelease(LockHashPartitionLockByIndex(i));
 
    *nlocks = index;
    return accessExclusiveLocks;
}

References AccessExclusiveLock, Assert, fb(), hash_get_num_entries(), hash_seq_init(), hash_seq_search(), PROCLOCK::holdMask, i, LOCKBIT_ON, LockHashPartitionLockByIndex, LockMethodProcLockHash, LOCKTAG::locktag_field1, LOCKTAG::locktag_field2, LOCKTAG_RELATION, LOCKTAG::locktag_type, LW_SHARED, LWLockAcquire(), LWLockRelease(), PROCLOCKTAG::myLock, PROCLOCKTAG::myProc, NUM_LOCK_PARTITIONS, palloc(), LOCK::tag, PROCLOCK::tag, TransactionIdIsValid, and PGPROC::xid.

Referenced by LogStandbySnapshot().

◆ GrantAwaitedLock()

void GrantAwaitedLock ( void )

extern

Definition at line 1898 of file lock.c.

{
    GrantLockLocal(awaitedLock, awaitedOwner);
}

References awaitedLock, awaitedOwner, and GrantLockLocal().

Referenced by LockErrorCleanup().

◆ GrantLock()

void GrantLock	(	LOCK *	lock,
		PROCLOCK *	proclock,
		LOCKMODE	lockmode
	)

extern

Definition at line 1667 of file lock.c.

{
    lock->nGranted++;
    lock->granted[lockmode]++;
    lock->grantMask |= LOCKBIT_ON(lockmode);
    if (lock->granted[lockmode] == lock->requested[lockmode])
        lock->waitMask &= LOCKBIT_OFF(lockmode);
    proclock->holdMask |= LOCKBIT_ON(lockmode);
    LOCK_PRINT("GrantLock", lock, lockmode);
    Assert((lock->nGranted > 0) && (lock->granted[lockmode] > 0));
    Assert(lock->nGranted <= lock->nRequested);
}

References Assert, LOCK::granted, LOCK::grantMask, PROCLOCK::holdMask, LOCK_PRINT, LOCKBIT_OFF, LOCKBIT_ON, LOCK::nGranted, LOCK::nRequested, LOCK::requested, and LOCK::waitMask.

Referenced by FastPathGetRelationLockEntry(), FastPathTransferRelationLocks(), JoinWaitQueue(), lock_twophase_recover(), LockAcquireExtended(), ProcLockWakeup(), and VirtualXactLock().

◆ InitDeadLockChecking()

void InitDeadLockChecking ( void )

extern

Definition at line 143 of file deadlock.c.

{
    MemoryContext oldcxt;
 
    /* Make sure allocations are permanent */
    oldcxt = MemoryContextSwitchTo(TopMemoryContext);
 
    /*
     * FindLockCycle needs at most MaxBackends entries in visitedProcs[] and
     * deadlockDetails[].
     */
    visitedProcs = (PGPROC **) palloc(MaxBackends * sizeof(PGPROC *));
    deadlockDetails = (DEADLOCK_INFO *) palloc(MaxBackends * sizeof(DEADLOCK_INFO));
 
    /*
     * TopoSort needs to consider at most MaxBackends wait-queue entries, and
     * it needn't run concurrently with FindLockCycle.
     */
    topoProcs = visitedProcs;   /* re-use this space */
    beforeConstraints = (int *) palloc(MaxBackends * sizeof(int));
    afterConstraints = (int *) palloc(MaxBackends * sizeof(int));
 
    /*
     * We need to consider rearranging at most MaxBackends/2 wait queues
     * (since it takes at least two waiters in a queue to create a soft edge),
     * and the expanded form of the wait queues can't involve more than
     * MaxBackends total waiters.
     */
    waitOrders = (WAIT_ORDER *)
        palloc((MaxBackends / 2) * sizeof(WAIT_ORDER));
    waitOrderProcs = (PGPROC **) palloc(MaxBackends * sizeof(PGPROC *));
 
    /*
     * Allow at most MaxBackends distinct constraints in a configuration. (Is
     * this enough?  In practice it seems it should be, but I don't quite see
     * how to prove it.  If we run out, we might fail to find a workable wait
     * queue rearrangement even though one exists.)  NOTE that this number
     * limits the maximum recursion depth of DeadLockCheckRecurse. Making it
     * really big might potentially allow a stack-overflow problem.
     */
    maxCurConstraints = MaxBackends;
    curConstraints = (EDGE *) palloc(maxCurConstraints * sizeof(EDGE));
 
    /*
     * Allow up to 3*MaxBackends constraints to be saved without having to
     * re-run TestConfiguration.  (This is probably more than enough, but we
     * can survive if we run low on space by doing excess runs of
     * TestConfiguration to re-compute constraint lists each time needed.) The
     * last MaxBackends entries in possibleConstraints[] are reserved as
     * output workspace for FindLockCycle.
     */
    {
        StaticAssertDecl(MAX_BACKENDS_BITS <= (32 - 3),
                         "MAX_BACKENDS_BITS too big for * 4");
        maxPossibleConstraints = MaxBackends * 4;
        possibleConstraints =
            (EDGE *) palloc(maxPossibleConstraints * sizeof(EDGE));
    }
 
    MemoryContextSwitchTo(oldcxt);
}

References afterConstraints, beforeConstraints, curConstraints, deadlockDetails, fb(), MAX_BACKENDS_BITS, MaxBackends, maxCurConstraints, maxPossibleConstraints, MemoryContextSwitchTo(), palloc(), possibleConstraints, StaticAssertDecl, TopMemoryContext, topoProcs, visitedProcs, waitOrderProcs, and waitOrders.

Referenced by InitProcess().

◆ InitLockManagerAccess()

void InitLockManagerAccess ( void )

extern

Definition at line 503 of file lock.c.

{
    /*
     * Allocate non-shared hash table for LOCALLOCK structs.  This stores lock
     * counts and resource owner information.
     */
    HASHCTL     info;
 
    info.keysize = sizeof(LOCALLOCKTAG);
    info.entrysize = sizeof(LOCALLOCK);
 
    LockMethodLocalHash = hash_create("LOCALLOCK hash",
                                      16,
                                      &info,
                                      HASH_ELEM | HASH_BLOBS);
}

References HASHCTL::entrysize, HASH_BLOBS, hash_create(), HASH_ELEM, HASHCTL::keysize, and LockMethodLocalHash.

Referenced by BaseInit().

◆ lock_twophase_postabort()

void lock_twophase_postabort	(	FullTransactionId	fxid,
		uint16	info,
		void *	recdata,
		uint32	len
	)

extern

Definition at line 4579 of file lock.c.

{
    lock_twophase_postcommit(fxid, info, recdata, len);
}

References fb(), len, and lock_twophase_postcommit().

◆ lock_twophase_postcommit()

void lock_twophase_postcommit	(	FullTransactionId	fxid,
		uint16	info,
		void *	recdata,
		uint32	len
	)

extern

Definition at line 4553 of file lock.c.

{
    TwoPhaseLockRecord *rec = (TwoPhaseLockRecord *) recdata;
    PGPROC     *proc = TwoPhaseGetDummyProc(fxid, true);
    LOCKTAG    *locktag;
    LOCKMETHODID lockmethodid;
    LockMethod  lockMethodTable;
 
    Assert(len == sizeof(TwoPhaseLockRecord));
    locktag = &rec->locktag;
    lockmethodid = locktag->locktag_lockmethodid;
 
    if (lockmethodid <= 0 || lockmethodid >= lengthof(LockMethods))
        elog(ERROR, "unrecognized lock method: %d", lockmethodid);
    lockMethodTable = LockMethods[lockmethodid];
 
    LockRefindAndRelease(lockMethodTable, proc, locktag, rec->lockmode, true);
}

References Assert, elog, ERROR, fb(), len, lengthof, LockMethods, TwoPhaseLockRecord::lockmode, LockRefindAndRelease(), TwoPhaseLockRecord::locktag, LOCKTAG::locktag_lockmethodid, and TwoPhaseGetDummyProc().

Referenced by lock_twophase_postabort().

◆ lock_twophase_recover()

void lock_twophase_recover	(	FullTransactionId	fxid,
		uint16	info,
		void *	recdata,
		uint32	len
	)

extern

Definition at line 4340 of file lock.c.

{
    TwoPhaseLockRecord *rec = (TwoPhaseLockRecord *) recdata;
    PGPROC     *proc = TwoPhaseGetDummyProc(fxid, false);
    LOCKTAG    *locktag;
    LOCKMODE    lockmode;
    LOCKMETHODID lockmethodid;
    LOCK       *lock;
    PROCLOCK   *proclock;
    PROCLOCKTAG proclocktag;
    bool        found;
    uint32      hashcode;
    uint32      proclock_hashcode;
    int         partition;
    LWLock     *partitionLock;
    LockMethod  lockMethodTable;
 
    Assert(len == sizeof(TwoPhaseLockRecord));
    locktag = &rec->locktag;
    lockmode = rec->lockmode;
    lockmethodid = locktag->locktag_lockmethodid;
 
    if (lockmethodid <= 0 || lockmethodid >= lengthof(LockMethods))
        elog(ERROR, "unrecognized lock method: %d", lockmethodid);
    lockMethodTable = LockMethods[lockmethodid];
 
    hashcode = LockTagHashCode(locktag);
    partition = LockHashPartition(hashcode);
    partitionLock = LockHashPartitionLock(hashcode);
 
    LWLockAcquire(partitionLock, LW_EXCLUSIVE);
 
    /*
     * Find or create a lock with this tag.
     */
    lock = (LOCK *) hash_search_with_hash_value(LockMethodLockHash,
                                                locktag,
                                                hashcode,
                                                HASH_ENTER_NULL,
                                                &found);
    if (!lock)
    {
        LWLockRelease(partitionLock);
        ereport(ERROR,
                (errcode(ERRCODE_OUT_OF_MEMORY),
                 errmsg("out of shared memory"),
                 errhint("You might need to increase \"%s\".", "max_locks_per_transaction")));
    }
 
    /*
     * if it's a new lock object, initialize it
     */
    if (!found)
    {
        lock->grantMask = 0;
        lock->waitMask = 0;
        dlist_init(&lock->procLocks);
        dclist_init(&lock->waitProcs);
        lock->nRequested = 0;
        lock->nGranted = 0;
        MemSet(lock->requested, 0, sizeof(int) * MAX_LOCKMODES);
        MemSet(lock->granted, 0, sizeof(int) * MAX_LOCKMODES);
        LOCK_PRINT("lock_twophase_recover: new", lock, lockmode);
    }
    else
    {
        LOCK_PRINT("lock_twophase_recover: found", lock, lockmode);
        Assert((lock->nRequested >= 0) && (lock->requested[lockmode] >= 0));
        Assert((lock->nGranted >= 0) && (lock->granted[lockmode] >= 0));
        Assert(lock->nGranted <= lock->nRequested);
    }
 
    /*
     * Create the hash key for the proclock table.
     */
    proclocktag.myLock = lock;
    proclocktag.myProc = proc;
 
    proclock_hashcode = ProcLockHashCode(&proclocktag, hashcode);
 
    /*
     * Find or create a proclock entry with this tag
     */
    proclock = (PROCLOCK *) hash_search_with_hash_value(LockMethodProcLockHash,
                                                        &proclocktag,
                                                        proclock_hashcode,
                                                        HASH_ENTER_NULL,
                                                        &found);
    if (!proclock)
    {
        /* Oops, not enough shmem for the proclock */
        if (lock->nRequested == 0)
        {
            /*
             * There are no other requestors of this lock, so garbage-collect
             * the lock object.  We *must* do this to avoid a permanent leak
             * of shared memory, because there won't be anything to cause
             * anyone to release the lock object later.
             */
            Assert(dlist_is_empty(&lock->procLocks));
            if (!hash_search_with_hash_value(LockMethodLockHash,
                                             &(lock->tag),
                                             hashcode,
                                             HASH_REMOVE,
                                             NULL))
                elog(PANIC, "lock table corrupted");
        }
        LWLockRelease(partitionLock);
        ereport(ERROR,
                (errcode(ERRCODE_OUT_OF_MEMORY),
                 errmsg("out of shared memory"),
                 errhint("You might need to increase \"%s\".", "max_locks_per_transaction")));
    }
 
    /*
     * If new, initialize the new entry
     */
    if (!found)
    {
        Assert(proc->lockGroupLeader == NULL);
        proclock->groupLeader = proc;
        proclock->holdMask = 0;
        proclock->releaseMask = 0;
        /* Add proclock to appropriate lists */
        dlist_push_tail(&lock->procLocks, &proclock->lockLink);
        dlist_push_tail(&proc->myProcLocks[partition],
                        &proclock->procLink);
        PROCLOCK_PRINT("lock_twophase_recover: new", proclock);
    }
    else
    {
        PROCLOCK_PRINT("lock_twophase_recover: found", proclock);
        Assert((proclock->holdMask & ~lock->grantMask) == 0);
    }
 
    /*
     * lock->nRequested and lock->requested[] count the total number of
     * requests, whether granted or waiting, so increment those immediately.
     */
    lock->nRequested++;
    lock->requested[lockmode]++;
    Assert((lock->nRequested > 0) && (lock->requested[lockmode] > 0));
 
    /*
     * We shouldn't already hold the desired lock.
     */
    if (proclock->holdMask & LOCKBIT_ON(lockmode))
        elog(ERROR, "lock %s on object %u/%u/%u is already held",
             lockMethodTable->lockModeNames[lockmode],
             lock->tag.locktag_field1, lock->tag.locktag_field2,
             lock->tag.locktag_field3);
 
    /*
     * We ignore any possible conflicts and just grant ourselves the lock. Not
     * only because we don't bother, but also to avoid deadlocks when
     * switching from standby to normal mode. See function comment.
     */
    GrantLock(lock, proclock, lockmode);
 
    /*
     * Bump strong lock count, to make sure any fast-path lock requests won't
     * be granted without consulting the primary lock table.
     */
    if (ConflictsWithRelationFastPath(&lock->tag, lockmode))
    {
        uint32      fasthashcode = FastPathStrongLockHashPartition(hashcode);
 
        SpinLockAcquire(&FastPathStrongRelationLocks->mutex);
        FastPathStrongRelationLocks->count[fasthashcode]++;
        SpinLockRelease(&FastPathStrongRelationLocks->mutex);
    }
 
    LWLockRelease(partitionLock);
}

References Assert, ConflictsWithRelationFastPath, FastPathStrongRelationLockData::count, dclist_init(), dlist_init(), dlist_is_empty(), dlist_push_tail(), elog, ereport, errcode(), errhint(), errmsg, ERROR, FastPathStrongLockHashPartition, FastPathStrongRelationLocks, fb(), LOCK::granted, GrantLock(), LOCK::grantMask, PROCLOCK::groupLeader, HASH_ENTER_NULL, HASH_REMOVE, hash_search_with_hash_value(), PROCLOCK::holdMask, len, lengthof, LOCK_PRINT, LOCKBIT_ON, PGPROC::lockGroupLeader, LockHashPartition, LockHashPartitionLock, PROCLOCK::lockLink, LockMethodLockHash, LockMethodProcLockHash, LockMethods, TwoPhaseLockRecord::lockmode, TwoPhaseLockRecord::locktag, LOCKTAG::locktag_field1, LOCKTAG::locktag_field2, LOCKTAG::locktag_field3, LOCKTAG::locktag_lockmethodid, LockTagHashCode(), LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MAX_LOCKMODES, MemSet, FastPathStrongRelationLockData::mutex, PGPROC::myProcLocks, LOCK::nGranted, LOCK::nRequested, PANIC, PROCLOCK::procLink, PROCLOCK_PRINT, ProcLockHashCode(), LOCK::procLocks, PROCLOCK::releaseMask, LOCK::requested, SpinLockAcquire(), SpinLockRelease(), LOCK::tag, TwoPhaseGetDummyProc(), LOCK::waitMask, and LOCK::waitProcs.

◆ lock_twophase_standby_recover()

void lock_twophase_standby_recover	(	FullTransactionId	fxid,
		uint16	info,
		void *	recdata,
		uint32	len
	)

extern

Definition at line 4521 of file lock.c.

{
    TwoPhaseLockRecord *rec = (TwoPhaseLockRecord *) recdata;
    LOCKTAG    *locktag;
    LOCKMODE    lockmode;
    LOCKMETHODID lockmethodid;
 
    Assert(len == sizeof(TwoPhaseLockRecord));
    locktag = &rec->locktag;
    lockmode = rec->lockmode;
    lockmethodid = locktag->locktag_lockmethodid;
 
    if (lockmethodid <= 0 || lockmethodid >= lengthof(LockMethods))
        elog(ERROR, "unrecognized lock method: %d", lockmethodid);
 
    if (lockmode == AccessExclusiveLock &&
        locktag->locktag_type == LOCKTAG_RELATION)
    {
        StandbyAcquireAccessExclusiveLock(XidFromFullTransactionId(fxid),
                                          locktag->locktag_field1 /* dboid */ ,
                                          locktag->locktag_field2 /* reloid */ );
    }
}

References AccessExclusiveLock, Assert, elog, ERROR, fb(), len, lengthof, LockMethods, TwoPhaseLockRecord::lockmode, TwoPhaseLockRecord::locktag, LOCKTAG::locktag_field1, LOCKTAG::locktag_field2, LOCKTAG::locktag_lockmethodid, LOCKTAG_RELATION, LOCKTAG::locktag_type, StandbyAcquireAccessExclusiveLock(), and XidFromFullTransactionId.

◆ LockAcquire()

LockAcquireResult LockAcquire	(	const LOCKTAG *	locktag,
		LOCKMODE	lockmode,
		bool	sessionLock,
		bool	dontWait
	)

extern

Definition at line 807 of file lock.c.

{
    return LockAcquireExtended(locktag, lockmode, sessionLock, dontWait,
                               true, NULL, false);
}

References fb(), and LockAcquireExtended().

Referenced by ConditionalLockPage(), ConditionalLockRelationForExtension(), LockApplyTransactionForSession(), LockDatabaseFrozenIds(), LockDatabaseObject(), LockPage(), LockRelationForExtension(), LockRelationIdForSession(), LockSharedObject(), LockSharedObjectForSession(), LockTuple(), pg_advisory_lock_int4(), pg_advisory_lock_int8(), pg_advisory_lock_shared_int4(), pg_advisory_lock_shared_int8(), pg_advisory_xact_lock_int4(), pg_advisory_xact_lock_int8(), pg_advisory_xact_lock_shared_int4(), pg_advisory_xact_lock_shared_int8(), pg_try_advisory_lock_int4(), pg_try_advisory_lock_int8(), pg_try_advisory_lock_shared_int4(), pg_try_advisory_lock_shared_int8(), pg_try_advisory_xact_lock_int4(), pg_try_advisory_xact_lock_int8(), pg_try_advisory_xact_lock_shared_int4(), pg_try_advisory_xact_lock_shared_int8(), SearchSysCacheLocked1(), SpeculativeInsertionLockAcquire(), SpeculativeInsertionWait(), StandbyAcquireAccessExclusiveLock(), VirtualXactLock(), XactLockForVirtualXact(), XactLockTableInsert(), and XactLockTableWait().

◆ LockAcquireExtended()

LockAcquireResult LockAcquireExtended	(	const LOCKTAG *	locktag,
		LOCKMODE	lockmode,
		bool	sessionLock,
		bool	dontWait,
		bool	reportMemoryError,
		LOCALLOCK **	locallockp,
		bool	logLockFailure
	)

extern

Definition at line 834 of file lock.c.

{
    LOCKMETHODID lockmethodid = locktag->locktag_lockmethodid;
    LockMethod  lockMethodTable;
    LOCALLOCKTAG localtag;
    LOCALLOCK  *locallock;
    LOCK       *lock;
    PROCLOCK   *proclock;
    bool        found;
    ResourceOwner owner;
    uint32      hashcode;
    LWLock     *partitionLock;
    bool        found_conflict;
    ProcWaitStatus waitResult;
    bool        log_lock = false;
 
    if (lockmethodid <= 0 || lockmethodid >= lengthof(LockMethods))
        elog(ERROR, "unrecognized lock method: %d", lockmethodid);
    lockMethodTable = LockMethods[lockmethodid];
    if (lockmode <= 0 || lockmode > lockMethodTable->numLockModes)
        elog(ERROR, "unrecognized lock mode: %d", lockmode);
 
    if (RecoveryInProgress() && !InRecovery &&
        (locktag->locktag_type == LOCKTAG_OBJECT ||
         locktag->locktag_type == LOCKTAG_RELATION) &&
        lockmode > RowExclusiveLock)
        ereport(ERROR,
                (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                 errmsg("cannot acquire lock mode %s on database objects while recovery is in progress",
                        lockMethodTable->lockModeNames[lockmode]),
                 errhint("Only RowExclusiveLock or less can be acquired on database objects during recovery.")));
 
#ifdef LOCK_DEBUG
    if (LOCK_DEBUG_ENABLED(locktag))
        elog(LOG, "LockAcquire: lock [%u,%u] %s",
             locktag->locktag_field1, locktag->locktag_field2,
             lockMethodTable->lockModeNames[lockmode]);
#endif
 
    /* Identify owner for lock */
    if (sessionLock)
        owner = NULL;
    else
        owner = CurrentResourceOwner;
 
    /*
     * Find or create a LOCALLOCK entry for this lock and lockmode
     */
    MemSet(&localtag, 0, sizeof(localtag)); /* must clear padding */
    localtag.lock = *locktag;
    localtag.mode = lockmode;
 
    locallock = (LOCALLOCK *) hash_search(LockMethodLocalHash,
                                          &localtag,
                                          HASH_ENTER, &found);
 
    /*
     * if it's a new locallock object, initialize it
     */
    if (!found)
    {
        locallock->lock = NULL;
        locallock->proclock = NULL;
        locallock->hashcode = LockTagHashCode(&(localtag.lock));
        locallock->nLocks = 0;
        locallock->holdsStrongLockCount = false;
        locallock->lockCleared = false;
        locallock->numLockOwners = 0;
        locallock->maxLockOwners = 8;
        locallock->lockOwners = NULL;   /* in case next line fails */
        locallock->lockOwners = (LOCALLOCKOWNER *)
            MemoryContextAlloc(TopMemoryContext,
                               locallock->maxLockOwners * sizeof(LOCALLOCKOWNER));
    }
    else
    {
        /* Make sure there will be room to remember the lock */
        if (locallock->numLockOwners >= locallock->maxLockOwners)
        {
            int         newsize = locallock->maxLockOwners * 2;
 
            locallock->lockOwners = (LOCALLOCKOWNER *)
                repalloc(locallock->lockOwners,
                         newsize * sizeof(LOCALLOCKOWNER));
            locallock->maxLockOwners = newsize;
        }
    }
    hashcode = locallock->hashcode;
 
    if (locallockp)
        *locallockp = locallock;
 
    /*
     * If we already hold the lock, we can just increase the count locally.
     *
     * If lockCleared is already set, caller need not worry about absorbing
     * sinval messages related to the lock's object.
     */
    if (locallock->nLocks > 0)
    {
        GrantLockLocal(locallock, owner);
        if (locallock->lockCleared)
            return LOCKACQUIRE_ALREADY_CLEAR;
        else
            return LOCKACQUIRE_ALREADY_HELD;
    }
 
    /*
     * We don't acquire any other heavyweight lock while holding the relation
     * extension lock.  We do allow to acquire the same relation extension
     * lock more than once but that case won't reach here.
     */
    Assert(!IsRelationExtensionLockHeld);
 
    /*
     * Prepare to emit a WAL record if acquisition of this lock needs to be
     * replayed in a standby server.
     *
     * Here we prepare to log; after lock is acquired we'll issue log record.
     * This arrangement simplifies error recovery in case the preparation step
     * fails.
     *
     * Only AccessExclusiveLocks can conflict with lock types that read-only
     * transactions can acquire in a standby server. Make sure this definition
     * matches the one in GetRunningTransactionLocks().
     */
    if (lockmode >= AccessExclusiveLock &&
        locktag->locktag_type == LOCKTAG_RELATION &&
        !RecoveryInProgress() &&
        XLogStandbyInfoActive())
    {
        LogAccessExclusiveLockPrepare();
        log_lock = true;
    }
 
    /*
     * Attempt to take lock via fast path, if eligible.  But if we remember
     * having filled up the fast path array, we don't attempt to make any
     * further use of it until we release some locks.  It's possible that some
     * other backend has transferred some of those locks to the shared hash
     * table, leaving space free, but it's not worth acquiring the LWLock just
     * to check.  It's also possible that we're acquiring a second or third
     * lock type on a relation we have already locked using the fast-path, but
     * for now we don't worry about that case either.
     */
    if (EligibleForRelationFastPath(locktag, lockmode))
    {
        if (FastPathLocalUseCounts[FAST_PATH_REL_GROUP(locktag->locktag_field2)] <
            FP_LOCK_SLOTS_PER_GROUP)
        {
            uint32      fasthashcode = FastPathStrongLockHashPartition(hashcode);
            bool        acquired;
 
            /*
             * LWLockAcquire acts as a memory sequencing point, so it's safe
             * to assume that any strong locker whose increment to
             * FastPathStrongRelationLocks->counts becomes visible after we
             * test it has yet to begin to transfer fast-path locks.
             */
            LWLockAcquire(&MyProc->fpInfoLock, LW_EXCLUSIVE);
            if (FastPathStrongRelationLocks->count[fasthashcode] != 0)
                acquired = false;
            else
                acquired = FastPathGrantRelationLock(locktag->locktag_field2,
                                                     lockmode);
            LWLockRelease(&MyProc->fpInfoLock);
            if (acquired)
            {
                /*
                 * The locallock might contain stale pointers to some old
                 * shared objects; we MUST reset these to null before
                 * considering the lock to be acquired via fast-path.
                 */
                locallock->lock = NULL;
                locallock->proclock = NULL;
                GrantLockLocal(locallock, owner);
                return LOCKACQUIRE_OK;
            }
        }
        else
        {
            /*
             * Increment the lock statistics counter if lock could not be
             * acquired via the fast-path.
             */
            pgstat_count_lock_fastpath_exceeded(locallock->tag.lock.locktag_type);
        }
    }
 
    /*
     * If this lock could potentially have been taken via the fast-path by
     * some other backend, we must (temporarily) disable further use of the
     * fast-path for this lock tag, and migrate any locks already taken via
     * this method to the main lock table.
     */
    if (ConflictsWithRelationFastPath(locktag, lockmode))
    {
        uint32      fasthashcode = FastPathStrongLockHashPartition(hashcode);
 
        BeginStrongLockAcquire(locallock, fasthashcode);
        if (!FastPathTransferRelationLocks(lockMethodTable, locktag,
                                           hashcode))
        {
            AbortStrongLockAcquire();
            if (locallock->nLocks == 0)
                RemoveLocalLock(locallock);
            if (locallockp)
                *locallockp = NULL;
            if (reportMemoryError)
                ereport(ERROR,
                        (errcode(ERRCODE_OUT_OF_MEMORY),
                         errmsg("out of shared memory"),
                         errhint("You might need to increase \"%s\".", "max_locks_per_transaction")));
            else
                return LOCKACQUIRE_NOT_AVAIL;
        }
    }
 
    /*
     * We didn't find the lock in our LOCALLOCK table, and we didn't manage to
     * take it via the fast-path, either, so we've got to mess with the shared
     * lock table.
     */
    partitionLock = LockHashPartitionLock(hashcode);
 
    LWLockAcquire(partitionLock, LW_EXCLUSIVE);
 
    /*
     * Find or create lock and proclock entries with this tag
     *
     * Note: if the locallock object already existed, it might have a pointer
     * to the lock already ... but we should not assume that that pointer is
     * valid, since a lock object with zero hold and request counts can go
     * away anytime.  So we have to use SetupLockInTable() to recompute the
     * lock and proclock pointers, even if they're already set.
     */
    proclock = SetupLockInTable(lockMethodTable, MyProc, locktag,
                                hashcode, lockmode);
    if (!proclock)
    {
        AbortStrongLockAcquire();
        LWLockRelease(partitionLock);
        if (locallock->nLocks == 0)
            RemoveLocalLock(locallock);
        if (locallockp)
            *locallockp = NULL;
        if (reportMemoryError)
            ereport(ERROR,
                    (errcode(ERRCODE_OUT_OF_MEMORY),
                     errmsg("out of shared memory"),
                     errhint("You might need to increase \"%s\".", "max_locks_per_transaction")));
        else
            return LOCKACQUIRE_NOT_AVAIL;
    }
    locallock->proclock = proclock;
    lock = proclock->tag.myLock;
    locallock->lock = lock;
 
    /*
     * If lock requested conflicts with locks requested by waiters, must join
     * wait queue.  Otherwise, check for conflict with already-held locks.
     * (That's last because most complex check.)
     */
    if (lockMethodTable->conflictTab[lockmode] & lock->waitMask)
        found_conflict = true;
    else
        found_conflict = LockCheckConflicts(lockMethodTable, lockmode,
                                            lock, proclock);
 
    if (!found_conflict)
    {
        /* No conflict with held or previously requested locks */
        GrantLock(lock, proclock, lockmode);
        waitResult = PROC_WAIT_STATUS_OK;
    }
    else
    {
        /*
         * Join the lock's wait queue.  We call this even in the dontWait
         * case, because JoinWaitQueue() may discover that we can acquire the
         * lock immediately after all.
         */
        waitResult = JoinWaitQueue(locallock, lockMethodTable, dontWait);
    }
 
    if (waitResult == PROC_WAIT_STATUS_ERROR)
    {
        /*
         * We're not getting the lock because a deadlock was detected already
         * while trying to join the wait queue, or because we would have to
         * wait but the caller requested no blocking.
         *
         * Undo the changes to shared entries before releasing the partition
         * lock.
         */
        AbortStrongLockAcquire();
 
        if (proclock->holdMask == 0)
        {
            uint32      proclock_hashcode;
 
            proclock_hashcode = ProcLockHashCode(&proclock->tag,
                                                 hashcode);
            dlist_delete(&proclock->lockLink);
            dlist_delete(&proclock->procLink);
            if (!hash_search_with_hash_value(LockMethodProcLockHash,
                                             &(proclock->tag),
                                             proclock_hashcode,
                                             HASH_REMOVE,
                                             NULL))
                elog(PANIC, "proclock table corrupted");
        }
        else
            PROCLOCK_PRINT("LockAcquire: did not join wait queue", proclock);
        lock->nRequested--;
        lock->requested[lockmode]--;
        LOCK_PRINT("LockAcquire: did not join wait queue",
                   lock, lockmode);
        Assert((lock->nRequested > 0) &&
               (lock->requested[lockmode] >= 0));
        Assert(lock->nGranted <= lock->nRequested);
        LWLockRelease(partitionLock);
        if (locallock->nLocks == 0)
            RemoveLocalLock(locallock);
 
        if (dontWait)
        {
            /*
             * Log lock holders and waiters as a detail log message if
             * logLockFailure = true and lock acquisition fails with dontWait
             * = true
             */
            if (logLockFailure)
            {
                StringInfoData buf,
                            lock_waiters_sbuf,
                            lock_holders_sbuf;
                const char *modename;
                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);
 
                /* Gather a list of all lock holders and waiters */
                LWLockAcquire(partitionLock, LW_SHARED);
                GetLockHoldersAndWaiters(locallock, &lock_holders_sbuf,
                                         &lock_waiters_sbuf, &lockHoldersNum);
                LWLockRelease(partitionLock);
 
                ereport(LOG,
                        (errmsg("process %d could not obtain %s on %s",
                                MyProcPid, modename, buf.data),
                         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)));
 
                pfree(buf.data);
                pfree(lock_holders_sbuf.data);
                pfree(lock_waiters_sbuf.data);
            }
            if (locallockp)
                *locallockp = NULL;
            return LOCKACQUIRE_NOT_AVAIL;
        }
        else
        {
            DeadLockReport();
            /* DeadLockReport() will not return */
        }
    }
 
    /*
     * We are now in the lock queue, or the lock was already granted.  If
     * queued, go to sleep.
     */
    if (waitResult == PROC_WAIT_STATUS_WAITING)
    {
        Assert(!dontWait);
        PROCLOCK_PRINT("LockAcquire: sleeping on lock", proclock);
        LOCK_PRINT("LockAcquire: sleeping on lock", lock, lockmode);
        LWLockRelease(partitionLock);
 
        waitResult = WaitOnLock(locallock, owner);
 
        /*
         * NOTE: do not do any material change of state between here and
         * return.  All required changes in locktable state must have been
         * done when the lock was granted to us --- see notes in WaitOnLock.
         */
 
        if (waitResult == PROC_WAIT_STATUS_ERROR)
        {
            /*
             * We failed as a result of a deadlock, see CheckDeadLock(). Quit
             * now.
             */
            Assert(!dontWait);
            DeadLockReport();
            /* DeadLockReport() will not return */
        }
    }
    else
        LWLockRelease(partitionLock);
    Assert(waitResult == PROC_WAIT_STATUS_OK);
 
    /* The lock was granted to us.  Update the local lock entry accordingly */
    Assert((proclock->holdMask & LOCKBIT_ON(lockmode)) != 0);
    GrantLockLocal(locallock, owner);
 
    /*
     * Lock state is fully up-to-date now; if we error out after this, no
     * special error cleanup is required.
     */
    FinishStrongLockAcquire();
 
    /*
     * Emit a WAL record if acquisition of this lock needs to be replayed in a
     * standby server.
     */
    if (log_lock)
    {
        /*
         * Decode the locktag back to the original values, to avoid sending
         * lots of empty bytes with every message.  See lock.h to check how a
         * locktag is defined for LOCKTAG_RELATION
         */
        LogAccessExclusiveLock(locktag->locktag_field1,
                               locktag->locktag_field2);
    }
 
    return LOCKACQUIRE_OK;
}

References AbortStrongLockAcquire(), AccessExclusiveLock, Assert, BeginStrongLockAcquire(), buf, ConflictsWithRelationFastPath, FastPathStrongRelationLockData::count, CurrentResourceOwner, DeadLockReport(), DescribeLockTag(), dlist_delete(), EligibleForRelationFastPath, elog, ereport, errcode(), errdetail_log_plural(), errhint(), errmsg, ERROR, FAST_PATH_REL_GROUP, FastPathGrantRelationLock(), FastPathLocalUseCounts, FastPathStrongLockHashPartition, FastPathStrongRelationLocks, FastPathTransferRelationLocks(), fb(), FinishStrongLockAcquire(), FP_LOCK_SLOTS_PER_GROUP, PGPROC::fpInfoLock, GetLockHoldersAndWaiters(), GetLockmodeName(), GrantLock(), GrantLockLocal(), HASH_ENTER, HASH_REMOVE, hash_search(), hash_search_with_hash_value(), PROCLOCK::holdMask, initStringInfo(), InRecovery, JoinWaitQueue(), lengthof, LOCK_PRINT, LOCKACQUIRE_ALREADY_CLEAR, LOCKACQUIRE_ALREADY_HELD, LOCKACQUIRE_NOT_AVAIL, LOCKACQUIRE_OK, LOCKBIT_ON, LockCheckConflicts(), LockHashPartitionLock, PROCLOCK::lockLink, LockMethodLocalHash, LockMethodProcLockHash, LockMethods, LOCKTAG::locktag_field1, LOCKTAG::locktag_field2, LOCKTAG::locktag_lockmethodid, LOCKTAG_OBJECT, LOCKTAG_RELATION, LOCKTAG::locktag_type, LockTagHashCode(), LOG, LogAccessExclusiveLock(), LogAccessExclusiveLockPrepare(), LW_EXCLUSIVE, LW_SHARED, LWLockAcquire(), LWLockRelease(), MemoryContextAlloc(), MemSet, PROCLOCKTAG::myLock, MyProc, MyProcPid, LOCK::nGranted, LOCK::nRequested, PANIC, pfree(), pgstat_count_lock_fastpath_exceeded(), PROC_WAIT_STATUS_ERROR, PROC_WAIT_STATUS_OK, PROC_WAIT_STATUS_WAITING, PROCLOCK::procLink, PROCLOCK_PRINT, ProcLockHashCode(), RecoveryInProgress(), RemoveLocalLock(), repalloc(), LOCK::requested, RowExclusiveLock, SetupLockInTable(), PROCLOCK::tag, TopMemoryContext, LOCK::waitMask, WaitOnLock(), and XLogStandbyInfoActive.

Referenced by ConditionalLockDatabaseObject(), ConditionalLockRelation(), ConditionalLockRelationOid(), ConditionalLockSharedObject(), ConditionalLockTuple(), ConditionalXactLockTableWait(), LockAcquire(), LockRelation(), LockRelationId(), and LockRelationOid().

◆ LockCheckConflicts()

bool LockCheckConflicts	(	LockMethod	lockMethodTable,
		LOCKMODE	lockmode,
		LOCK *	lock,
		PROCLOCK *	proclock
	)

extern

Definition at line 1538 of file lock.c.

{
    int         numLockModes = lockMethodTable->numLockModes;
    LOCKMASK    myLocks;
    int         conflictMask = lockMethodTable->conflictTab[lockmode];
    int         conflictsRemaining[MAX_LOCKMODES];
    int         totalConflictsRemaining = 0;
    dlist_iter  proclock_iter;
    int         i;
 
    /*
     * first check for global conflicts: If no locks conflict with my request,
     * then I get the lock.
     *
     * Checking for conflict: lock->grantMask represents the types of
     * currently held locks.  conflictTable[lockmode] has a bit set for each
     * type of lock that conflicts with request.   Bitwise compare tells if
     * there is a conflict.
     */
    if (!(conflictMask & lock->grantMask))
    {
        PROCLOCK_PRINT("LockCheckConflicts: no conflict", proclock);
        return false;
    }
 
    /*
     * Rats.  Something conflicts.  But it could still be my own lock, or a
     * lock held by another member of my locking group.  First, figure out how
     * many conflicts remain after subtracting out any locks I hold myself.
     */
    myLocks = proclock->holdMask;
    for (i = 1; i <= numLockModes; i++)
    {
        if ((conflictMask & LOCKBIT_ON(i)) == 0)
        {
            conflictsRemaining[i] = 0;
            continue;
        }
        conflictsRemaining[i] = lock->granted[i];
        if (myLocks & LOCKBIT_ON(i))
            --conflictsRemaining[i];
        totalConflictsRemaining += conflictsRemaining[i];
    }
 
    /* If no conflicts remain, we get the lock. */
    if (totalConflictsRemaining == 0)
    {
        PROCLOCK_PRINT("LockCheckConflicts: resolved (simple)", proclock);
        return false;
    }
 
    /* If no group locking, it's definitely a conflict. */
    if (proclock->groupLeader == MyProc && MyProc->lockGroupLeader == NULL)
    {
        Assert(proclock->tag.myProc == MyProc);
        PROCLOCK_PRINT("LockCheckConflicts: conflicting (simple)",
                       proclock);
        return true;
    }
 
    /*
     * The relation extension lock conflict even between the group members.
     */
    if (LOCK_LOCKTAG(*lock) == LOCKTAG_RELATION_EXTEND)
    {
        PROCLOCK_PRINT("LockCheckConflicts: conflicting (group)",
                       proclock);
        return true;
    }
 
    /*
     * Locks held in conflicting modes by members of our own lock group are
     * not real conflicts; we can subtract those out and see if we still have
     * a conflict.  This is O(N) in the number of processes holding or
     * awaiting locks on this object.  We could improve that by making the
     * shared memory state more complex (and larger) but it doesn't seem worth
     * it.
     */
    dlist_foreach(proclock_iter, &lock->procLocks)
    {
        PROCLOCK   *otherproclock =
            dlist_container(PROCLOCK, lockLink, proclock_iter.cur);
 
        if (proclock != otherproclock &&
            proclock->groupLeader == otherproclock->groupLeader &&
            (otherproclock->holdMask & conflictMask) != 0)
        {
            int         intersectMask = otherproclock->holdMask & conflictMask;
 
            for (i = 1; i <= numLockModes; i++)
            {
                if ((intersectMask & LOCKBIT_ON(i)) != 0)
                {
                    if (conflictsRemaining[i] <= 0)
                        elog(PANIC, "proclocks held do not match lock");
                    conflictsRemaining[i]--;
                    totalConflictsRemaining--;
                }
            }
 
            if (totalConflictsRemaining == 0)
            {
                PROCLOCK_PRINT("LockCheckConflicts: resolved (group)",
                               proclock);
                return false;
            }
        }
    }
 
    /* Nope, it's a real conflict. */
    PROCLOCK_PRINT("LockCheckConflicts: conflicting (group)", proclock);
    return true;
}

References Assert, dlist_container, dlist_foreach, elog, fb(), LOCK::granted, LOCK::grantMask, PROCLOCK::groupLeader, PROCLOCK::holdMask, i, LOCK_LOCKTAG, LOCKBIT_ON, PGPROC::lockGroupLeader, LOCKTAG_RELATION_EXTEND, MAX_LOCKMODES, MyProc, PROCLOCKTAG::myProc, PANIC, PROCLOCK_PRINT, LOCK::procLocks, and PROCLOCK::tag.

Referenced by JoinWaitQueue(), LockAcquireExtended(), and ProcLockWakeup().

◆ LockHasWaiters()

bool LockHasWaiters	(	const LOCKTAG *	locktag,
		LOCKMODE	lockmode,
		bool	sessionLock
	)

extern

Definition at line 694 of file lock.c.

{
    LOCKMETHODID lockmethodid = locktag->locktag_lockmethodid;
    LockMethod  lockMethodTable;
    LOCALLOCKTAG localtag;
    LOCALLOCK  *locallock;
    LOCK       *lock;
    PROCLOCK   *proclock;
    LWLock     *partitionLock;
    bool        hasWaiters = false;
 
    if (lockmethodid <= 0 || lockmethodid >= lengthof(LockMethods))
        elog(ERROR, "unrecognized lock method: %d", lockmethodid);
    lockMethodTable = LockMethods[lockmethodid];
    if (lockmode <= 0 || lockmode > lockMethodTable->numLockModes)
        elog(ERROR, "unrecognized lock mode: %d", lockmode);
 
#ifdef LOCK_DEBUG
    if (LOCK_DEBUG_ENABLED(locktag))
        elog(LOG, "LockHasWaiters: lock [%u,%u] %s",
             locktag->locktag_field1, locktag->locktag_field2,
             lockMethodTable->lockModeNames[lockmode]);
#endif
 
    /*
     * Find the LOCALLOCK entry for this lock and lockmode
     */
    MemSet(&localtag, 0, sizeof(localtag)); /* must clear padding */
    localtag.lock = *locktag;
    localtag.mode = lockmode;
 
    locallock = (LOCALLOCK *) hash_search(LockMethodLocalHash,
                                          &localtag,
                                          HASH_FIND, NULL);
 
    /*
     * let the caller print its own error message, too. Do not ereport(ERROR).
     */
    if (!locallock || locallock->nLocks <= 0)
    {
        elog(WARNING, "you don't own a lock of type %s",
             lockMethodTable->lockModeNames[lockmode]);
        return false;
    }
 
    /*
     * Check the shared lock table.
     */
    partitionLock = LockHashPartitionLock(locallock->hashcode);
 
    LWLockAcquire(partitionLock, LW_SHARED);
 
    /*
     * We don't need to re-find the lock or proclock, since we kept their
     * addresses in the locallock table, and they couldn't have been removed
     * while we were holding a lock on them.
     */
    lock = locallock->lock;
    LOCK_PRINT("LockHasWaiters: found", lock, lockmode);
    proclock = locallock->proclock;
    PROCLOCK_PRINT("LockHasWaiters: found", proclock);
 
    /*
     * Double-check that we are actually holding a lock of the type we want to
     * release.
     */
    if (!(proclock->holdMask & LOCKBIT_ON(lockmode)))
    {
        PROCLOCK_PRINT("LockHasWaiters: WRONGTYPE", proclock);
        LWLockRelease(partitionLock);
        elog(WARNING, "you don't own a lock of type %s",
             lockMethodTable->lockModeNames[lockmode]);
        RemoveLocalLock(locallock);
        return false;
    }
 
    /*
     * Do the checking.
     */
    if ((lockMethodTable->conflictTab[lockmode] & lock->waitMask) != 0)
        hasWaiters = true;
 
    LWLockRelease(partitionLock);
 
    return hasWaiters;
}

References elog, ERROR, fb(), HASH_FIND, hash_search(), PROCLOCK::holdMask, lengthof, LOCK_PRINT, LOCKBIT_ON, LockHashPartitionLock, LockMethodLocalHash, LockMethods, LOCKTAG::locktag_field1, LOCKTAG::locktag_field2, LOCKTAG::locktag_lockmethodid, LOG, LW_SHARED, LWLockAcquire(), LWLockRelease(), MemSet, PROCLOCK_PRINT, RemoveLocalLock(), LOCK::waitMask, and WARNING.

Referenced by LockHasWaitersRelation().

◆ LockHeldByMe()

bool LockHeldByMe	(	const LOCKTAG *	locktag,
		LOCKMODE	lockmode,
		bool	orstronger
	)

extern

Definition at line 641 of file lock.c.

{
    LOCALLOCKTAG localtag;
    LOCALLOCK  *locallock;
 
    /*
     * See if there is a LOCALLOCK entry for this lock and lockmode
     */
    MemSet(&localtag, 0, sizeof(localtag)); /* must clear padding */
    localtag.lock = *locktag;
    localtag.mode = lockmode;
 
    locallock = (LOCALLOCK *) hash_search(LockMethodLocalHash,
                                          &localtag,
                                          HASH_FIND, NULL);
 
    if (locallock && locallock->nLocks > 0)
        return true;
 
    if (orstronger)
    {
        LOCKMODE    slockmode;
 
        for (slockmode = lockmode + 1;
             slockmode <= MaxLockMode;
             slockmode++)
        {
            if (LockHeldByMe(locktag, slockmode, false))
                return true;
        }
    }
 
    return false;
}

References fb(), HASH_FIND, hash_search(), LockHeldByMe(), LockMethodLocalHash, MaxLockMode, and MemSet.

Referenced by CheckRelationLockedByMe(), CheckRelationOidLockedByMe(), LockHeldByMe(), and UpdateSubscriptionRelState().

◆ LockReassignCurrentOwner()

void LockReassignCurrentOwner	(	LOCALLOCK **	locallocks,
		int	nlocks
	)

extern

Definition at line 2715 of file lock.c.

{
    ResourceOwner parent = ResourceOwnerGetParent(CurrentResourceOwner);
 
    Assert(parent != NULL);
 
    if (locallocks == NULL)
    {
        HASH_SEQ_STATUS status;
        LOCALLOCK  *locallock;
 
        hash_seq_init(&status, LockMethodLocalHash);
 
        while ((locallock = (LOCALLOCK *) hash_seq_search(&status)) != NULL)
            LockReassignOwner(locallock, parent);
    }
    else
    {
        int         i;
 
        for (i = nlocks - 1; i >= 0; i--)
            LockReassignOwner(locallocks[i], parent);
    }
}

References Assert, CurrentResourceOwner, fb(), hash_seq_init(), hash_seq_search(), i, LockMethodLocalHash, LockReassignOwner(), and ResourceOwnerGetParent().

Referenced by ResourceOwnerReleaseInternal().

◆ LockRelease()

bool LockRelease	(	const LOCKTAG *	locktag,
		LOCKMODE	lockmode,
		bool	sessionLock
	)

extern

Definition at line 2111 of file lock.c.

{
    LOCKMETHODID lockmethodid = locktag->locktag_lockmethodid;
    LockMethod  lockMethodTable;
    LOCALLOCKTAG localtag;
    LOCALLOCK  *locallock;
    LOCK       *lock;
    PROCLOCK   *proclock;
    LWLock     *partitionLock;
    bool        wakeupNeeded;
 
    if (lockmethodid <= 0 || lockmethodid >= lengthof(LockMethods))
        elog(ERROR, "unrecognized lock method: %d", lockmethodid);
    lockMethodTable = LockMethods[lockmethodid];
    if (lockmode <= 0 || lockmode > lockMethodTable->numLockModes)
        elog(ERROR, "unrecognized lock mode: %d", lockmode);
 
#ifdef LOCK_DEBUG
    if (LOCK_DEBUG_ENABLED(locktag))
        elog(LOG, "LockRelease: lock [%u,%u] %s",
             locktag->locktag_field1, locktag->locktag_field2,
             lockMethodTable->lockModeNames[lockmode]);
#endif
 
    /*
     * Find the LOCALLOCK entry for this lock and lockmode
     */
    MemSet(&localtag, 0, sizeof(localtag)); /* must clear padding */
    localtag.lock = *locktag;
    localtag.mode = lockmode;
 
    locallock = (LOCALLOCK *) hash_search(LockMethodLocalHash,
                                          &localtag,
                                          HASH_FIND, NULL);
 
    /*
     * let the caller print its own error message, too. Do not ereport(ERROR).
     */
    if (!locallock || locallock->nLocks <= 0)
    {
        elog(WARNING, "you don't own a lock of type %s",
             lockMethodTable->lockModeNames[lockmode]);
        return false;
    }
 
    /*
     * Decrease the count for the resource owner.
     */
    {
        LOCALLOCKOWNER *lockOwners = locallock->lockOwners;
        ResourceOwner owner;
        int         i;
 
        /* Identify owner for lock */
        if (sessionLock)
            owner = NULL;
        else
            owner = CurrentResourceOwner;
 
        for (i = locallock->numLockOwners - 1; i >= 0; i--)
        {
            if (lockOwners[i].owner == owner)
            {
                Assert(lockOwners[i].nLocks > 0);
                if (--lockOwners[i].nLocks == 0)
                {
                    if (owner != NULL)
                        ResourceOwnerForgetLock(owner, locallock);
                    /* compact out unused slot */
                    locallock->numLockOwners--;
                    if (i < locallock->numLockOwners)
                        lockOwners[i] = lockOwners[locallock->numLockOwners];
                }
                break;
            }
        }
        if (i < 0)
        {
            /* don't release a lock belonging to another owner */
            elog(WARNING, "you don't own a lock of type %s",
                 lockMethodTable->lockModeNames[lockmode]);
            return false;
        }
    }
 
    /*
     * Decrease the total local count.  If we're still holding the lock, we're
     * done.
     */
    locallock->nLocks--;
 
    if (locallock->nLocks > 0)
        return true;
 
    /*
     * At this point we can no longer suppose we are clear of invalidation
     * messages related to this lock.  Although we'll delete the LOCALLOCK
     * object before any intentional return from this routine, it seems worth
     * the trouble to explicitly reset lockCleared right now, just in case
     * some error prevents us from deleting the LOCALLOCK.
     */
    locallock->lockCleared = false;
 
    /* Attempt fast release of any lock eligible for the fast path. */
    if (EligibleForRelationFastPath(locktag, lockmode) &&
        FastPathLocalUseCounts[FAST_PATH_REL_GROUP(locktag->locktag_field2)] > 0)
    {
        bool        released;
 
        /*
         * We might not find the lock here, even if we originally entered it
         * here.  Another backend may have moved it to the main table.
         */
        LWLockAcquire(&MyProc->fpInfoLock, LW_EXCLUSIVE);
        released = FastPathUnGrantRelationLock(locktag->locktag_field2,
                                               lockmode);
        LWLockRelease(&MyProc->fpInfoLock);
        if (released)
        {
            RemoveLocalLock(locallock);
            return true;
        }
    }
 
    /*
     * Otherwise we've got to mess with the shared lock table.
     */
    partitionLock = LockHashPartitionLock(locallock->hashcode);
 
    LWLockAcquire(partitionLock, LW_EXCLUSIVE);
 
    /*
     * Normally, we don't need to re-find the lock or proclock, since we kept
     * their addresses in the locallock table, and they couldn't have been
     * removed while we were holding a lock on them.  But it's possible that
     * the lock was taken fast-path and has since been moved to the main hash
     * table by another backend, in which case we will need to look up the
     * objects here.  We assume the lock field is NULL if so.
     */
    lock = locallock->lock;
    if (!lock)
    {
        PROCLOCKTAG proclocktag;
 
        Assert(EligibleForRelationFastPath(locktag, lockmode));
        lock = (LOCK *) hash_search_with_hash_value(LockMethodLockHash,
                                                    locktag,
                                                    locallock->hashcode,
                                                    HASH_FIND,
                                                    NULL);
        if (!lock)
            elog(ERROR, "failed to re-find shared lock object");
        locallock->lock = lock;
 
        proclocktag.myLock = lock;
        proclocktag.myProc = MyProc;
        locallock->proclock = (PROCLOCK *) hash_search(LockMethodProcLockHash,
                                                       &proclocktag,
                                                       HASH_FIND,
                                                       NULL);
        if (!locallock->proclock)
            elog(ERROR, "failed to re-find shared proclock object");
    }
    LOCK_PRINT("LockRelease: found", lock, lockmode);
    proclock = locallock->proclock;
    PROCLOCK_PRINT("LockRelease: found", proclock);
 
    /*
     * Double-check that we are actually holding a lock of the type we want to
     * release.
     */
    if (!(proclock->holdMask & LOCKBIT_ON(lockmode)))
    {
        PROCLOCK_PRINT("LockRelease: WRONGTYPE", proclock);
        LWLockRelease(partitionLock);
        elog(WARNING, "you don't own a lock of type %s",
             lockMethodTable->lockModeNames[lockmode]);
        RemoveLocalLock(locallock);
        return false;
    }
 
    /*
     * Do the releasing.  CleanUpLock will waken any now-wakable waiters.
     */
    wakeupNeeded = UnGrantLock(lock, lockmode, proclock, lockMethodTable);
 
    CleanUpLock(lock, proclock,
                lockMethodTable, locallock->hashcode,
                wakeupNeeded);
 
    LWLockRelease(partitionLock);
 
    RemoveLocalLock(locallock);
    return true;
}

References Assert, CleanUpLock(), CurrentResourceOwner, EligibleForRelationFastPath, elog, ERROR, FAST_PATH_REL_GROUP, FastPathLocalUseCounts, FastPathUnGrantRelationLock(), fb(), PGPROC::fpInfoLock, HASH_FIND, hash_search(), hash_search_with_hash_value(), PROCLOCK::holdMask, i, lengthof, LOCK_PRINT, LOCKBIT_ON, LockHashPartitionLock, LockMethodLocalHash, LockMethodLockHash, LockMethodProcLockHash, LockMethods, LOCKTAG::locktag_field1, LOCKTAG::locktag_field2, LOCKTAG::locktag_lockmethodid, LOG, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MemSet, MyProc, PROCLOCK_PRINT, RemoveLocalLock(), ResourceOwnerForgetLock(), UnGrantLock(), and WARNING.

Referenced by ConditionalXactLockTableWait(), pg_advisory_unlock_int4(), pg_advisory_unlock_int8(), pg_advisory_unlock_shared_int4(), pg_advisory_unlock_shared_int8(), ReleaseLockIfHeld(), SearchSysCacheLocked1(), SpeculativeInsertionLockRelease(), SpeculativeInsertionWait(), StandbyReleaseXidEntryLocks(), UnlockApplyTransactionForSession(), UnlockDatabaseObject(), UnlockPage(), UnlockRelation(), UnlockRelationForExtension(), UnlockRelationId(), UnlockRelationIdForSession(), UnlockRelationOid(), UnlockSharedObject(), UnlockSharedObjectForSession(), UnlockTuple(), VirtualXactLock(), XactLockForVirtualXact(), XactLockTableDelete(), and XactLockTableWait().

◆ LockReleaseAll()

void LockReleaseAll	(	LOCKMETHODID	lockmethodid,
		bool	allLocks
	)

extern

Definition at line 2316 of file lock.c.

{
    HASH_SEQ_STATUS status;
    LockMethod  lockMethodTable;
    int         i,
                numLockModes;
    LOCALLOCK  *locallock;
    LOCK       *lock;
    int         partition;
    bool        have_fast_path_lwlock = false;
 
    if (lockmethodid <= 0 || lockmethodid >= lengthof(LockMethods))
        elog(ERROR, "unrecognized lock method: %d", lockmethodid);
    lockMethodTable = LockMethods[lockmethodid];
 
#ifdef LOCK_DEBUG
    if (*(lockMethodTable->trace_flag))
        elog(LOG, "LockReleaseAll: lockmethod=%d", lockmethodid);
#endif
 
    /*
     * Get rid of our fast-path VXID lock, if appropriate.  Note that this is
     * the only way that the lock we hold on our own VXID can ever get
     * released: it is always and only released when a toplevel transaction
     * ends.
     */
    if (lockmethodid == DEFAULT_LOCKMETHOD)
        VirtualXactLockTableCleanup();
 
    numLockModes = lockMethodTable->numLockModes;
 
    /*
     * First we run through the locallock table and get rid of unwanted
     * entries, then we scan the process's proclocks and get rid of those. We
     * do this separately because we may have multiple locallock entries
     * pointing to the same proclock, and we daren't end up with any dangling
     * pointers.  Fast-path locks are cleaned up during the locallock table
     * scan, though.
     */
    hash_seq_init(&status, LockMethodLocalHash);
 
    while ((locallock = (LOCALLOCK *) hash_seq_search(&status)) != NULL)
    {
        /*
         * If the LOCALLOCK entry is unused, something must've gone wrong
         * while trying to acquire this lock.  Just forget the local entry.
         */
        if (locallock->nLocks == 0)
        {
            RemoveLocalLock(locallock);
            continue;
        }
 
        /* Ignore items that are not of the lockmethod to be removed */
        if (LOCALLOCK_LOCKMETHOD(*locallock) != lockmethodid)
            continue;
 
        /*
         * If we are asked to release all locks, we can just zap the entry.
         * Otherwise, must scan to see if there are session locks. We assume
         * there is at most one lockOwners entry for session locks.
         */
        if (!allLocks)
        {
            LOCALLOCKOWNER *lockOwners = locallock->lockOwners;
 
            /* If session lock is above array position 0, move it down to 0 */
            for (i = 0; i < locallock->numLockOwners; i++)
            {
                if (lockOwners[i].owner == NULL)
                    lockOwners[0] = lockOwners[i];
                else
                    ResourceOwnerForgetLock(lockOwners[i].owner, locallock);
            }
 
            if (locallock->numLockOwners > 0 &&
                lockOwners[0].owner == NULL &&
                lockOwners[0].nLocks > 0)
            {
                /* Fix the locallock to show just the session locks */
                locallock->nLocks = lockOwners[0].nLocks;
                locallock->numLockOwners = 1;
                /* We aren't deleting this locallock, so done */
                continue;
            }
            else
                locallock->numLockOwners = 0;
        }
 
#ifdef USE_ASSERT_CHECKING
 
        /*
         * Tuple locks are currently held only for short durations within a
         * transaction. Check that we didn't forget to release one.
         */
        if (LOCALLOCK_LOCKTAG(*locallock) == LOCKTAG_TUPLE && !allLocks)
            elog(WARNING, "tuple lock held at commit");
#endif
 
        /*
         * If the lock or proclock pointers are NULL, this lock was taken via
         * the relation fast-path (and is not known to have been transferred).
         */
        if (locallock->proclock == NULL || locallock->lock == NULL)
        {
            LOCKMODE    lockmode = locallock->tag.mode;
            Oid         relid;
 
            /* Verify that a fast-path lock is what we've got. */
            if (!EligibleForRelationFastPath(&locallock->tag.lock, lockmode))
                elog(PANIC, "locallock table corrupted");
 
            /*
             * If we don't currently hold the LWLock that protects our
             * fast-path data structures, we must acquire it before attempting
             * to release the lock via the fast-path.  We will continue to
             * hold the LWLock until we're done scanning the locallock table,
             * unless we hit a transferred fast-path lock.  (XXX is this
             * really such a good idea?  There could be a lot of entries ...)
             */
            if (!have_fast_path_lwlock)
            {
                LWLockAcquire(&MyProc->fpInfoLock, LW_EXCLUSIVE);
                have_fast_path_lwlock = true;
            }
 
            /* Attempt fast-path release. */
            relid = locallock->tag.lock.locktag_field2;
            if (FastPathUnGrantRelationLock(relid, lockmode))
            {
                RemoveLocalLock(locallock);
                continue;
            }
 
            /*
             * Our lock, originally taken via the fast path, has been
             * transferred to the main lock table.  That's going to require
             * some extra work, so release our fast-path lock before starting.
             */
            LWLockRelease(&MyProc->fpInfoLock);
            have_fast_path_lwlock = false;
 
            /*
             * Now dump the lock.  We haven't got a pointer to the LOCK or
             * PROCLOCK in this case, so we have to handle this a bit
             * differently than a normal lock release.  Unfortunately, this
             * requires an extra LWLock acquire-and-release cycle on the
             * partitionLock, but hopefully it shouldn't happen often.
             */
            LockRefindAndRelease(lockMethodTable, MyProc,
                                 &locallock->tag.lock, lockmode, false);
            RemoveLocalLock(locallock);
            continue;
        }
 
        /* Mark the proclock to show we need to release this lockmode */
        if (locallock->nLocks > 0)
            locallock->proclock->releaseMask |= LOCKBIT_ON(locallock->tag.mode);
 
        /* And remove the locallock hashtable entry */
        RemoveLocalLock(locallock);
    }
 
    /* Done with the fast-path data structures */
    if (have_fast_path_lwlock)
        LWLockRelease(&MyProc->fpInfoLock);
 
    /*
     * Now, scan each lock partition separately.
     */
    for (partition = 0; partition < NUM_LOCK_PARTITIONS; partition++)
    {
        LWLock     *partitionLock;
        dlist_head *procLocks = &MyProc->myProcLocks[partition];
        dlist_mutable_iter proclock_iter;
 
        partitionLock = LockHashPartitionLockByIndex(partition);
 
        /*
         * If the proclock list for this partition is empty, we can skip
         * acquiring the partition lock.  This optimization is trickier than
         * it looks, because another backend could be in process of adding
         * something to our proclock list due to promoting one of our
         * fast-path locks.  However, any such lock must be one that we
         * decided not to delete above, so it's okay to skip it again now;
         * we'd just decide not to delete it again.  We must, however, be
         * careful to re-fetch the list header once we've acquired the
         * partition lock, to be sure we have a valid, up-to-date pointer.
         * (There is probably no significant risk if pointer fetch/store is
         * atomic, but we don't wish to assume that.)
         *
         * XXX This argument assumes that the locallock table correctly
         * represents all of our fast-path locks.  While allLocks mode
         * guarantees to clean up all of our normal locks regardless of the
         * locallock situation, we lose that guarantee for fast-path locks.
         * This is not ideal.
         */
        if (dlist_is_empty(procLocks))
            continue;           /* needn't examine this partition */
 
        LWLockAcquire(partitionLock, LW_EXCLUSIVE);
 
        dlist_foreach_modify(proclock_iter, procLocks)
        {
            PROCLOCK   *proclock = dlist_container(PROCLOCK, procLink, proclock_iter.cur);
            bool        wakeupNeeded = false;
 
            Assert(proclock->tag.myProc == MyProc);
 
            lock = proclock->tag.myLock;
 
            /* Ignore items that are not of the lockmethod to be removed */
            if (LOCK_LOCKMETHOD(*lock) != lockmethodid)
                continue;
 
            /*
             * In allLocks mode, force release of all locks even if locallock
             * table had problems
             */
            if (allLocks)
                proclock->releaseMask = proclock->holdMask;
            else
                Assert((proclock->releaseMask & ~proclock->holdMask) == 0);
 
            /*
             * Ignore items that have nothing to be released, unless they have
             * holdMask == 0 and are therefore recyclable
             */
            if (proclock->releaseMask == 0 && proclock->holdMask != 0)
                continue;
 
            PROCLOCK_PRINT("LockReleaseAll", proclock);
            LOCK_PRINT("LockReleaseAll", lock, 0);
            Assert(lock->nRequested >= 0);
            Assert(lock->nGranted >= 0);
            Assert(lock->nGranted <= lock->nRequested);
            Assert((proclock->holdMask & ~lock->grantMask) == 0);
 
            /*
             * Release the previously-marked lock modes
             */
            for (i = 1; i <= numLockModes; i++)
            {
                if (proclock->releaseMask & LOCKBIT_ON(i))
                    wakeupNeeded |= UnGrantLock(lock, i, proclock,
                                                lockMethodTable);
            }
            Assert((lock->nRequested >= 0) && (lock->nGranted >= 0));
            Assert(lock->nGranted <= lock->nRequested);
            LOCK_PRINT("LockReleaseAll: updated", lock, 0);
 
            proclock->releaseMask = 0;
 
            /* CleanUpLock will wake up waiters if needed. */
            CleanUpLock(lock, proclock,
                        lockMethodTable,
                        LockTagHashCode(&lock->tag),
                        wakeupNeeded);
        }                       /* loop over PROCLOCKs within this partition */
 
        LWLockRelease(partitionLock);
    }                           /* loop over partitions */
 
#ifdef LOCK_DEBUG
    if (*(lockMethodTable->trace_flag))
        elog(LOG, "LockReleaseAll done");
#endif
}

References Assert, CleanUpLock(), DEFAULT_LOCKMETHOD, dlist_container, dlist_foreach_modify, dlist_is_empty(), EligibleForRelationFastPath, elog, ERROR, FastPathUnGrantRelationLock(), fb(), PGPROC::fpInfoLock, LOCK::grantMask, hash_seq_init(), hash_seq_search(), PROCLOCK::holdMask, i, lengthof, LOCALLOCK_LOCKMETHOD, LOCALLOCK_LOCKTAG, LOCK_LOCKMETHOD, LOCK_PRINT, LOCKBIT_ON, LockHashPartitionLockByIndex, LockMethodLocalHash, LockMethods, LockRefindAndRelease(), LOCKTAG_TUPLE, LockTagHashCode(), LOG, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), PROCLOCKTAG::myLock, MyProc, PROCLOCKTAG::myProc, PGPROC::myProcLocks, LOCK::nGranted, LOCALLOCKOWNER::nLocks, LOCK::nRequested, NUM_LOCK_PARTITIONS, LOCALLOCKOWNER::owner, PANIC, PROCLOCK_PRINT, PROCLOCK::releaseMask, RemoveLocalLock(), ResourceOwnerForgetLock(), LOCK::tag, PROCLOCK::tag, UnGrantLock(), VirtualXactLockTableCleanup(), and WARNING.

Referenced by DiscardAll(), logicalrep_worker_onexit(), ProcReleaseLocks(), and ShutdownPostgres().

◆ LockReleaseCurrentOwner()

void LockReleaseCurrentOwner	(	LOCALLOCK **	locallocks,
		int	nlocks
	)

extern

Definition at line 2620 of file lock.c.

{
    if (locallocks == NULL)
    {
        HASH_SEQ_STATUS status;
        LOCALLOCK  *locallock;
 
        hash_seq_init(&status, LockMethodLocalHash);
 
        while ((locallock = (LOCALLOCK *) hash_seq_search(&status)) != NULL)
            ReleaseLockIfHeld(locallock, false);
    }
    else
    {
        int         i;
 
        for (i = nlocks - 1; i >= 0; i--)
            ReleaseLockIfHeld(locallocks[i], false);
    }
}

References fb(), hash_seq_init(), hash_seq_search(), i, LockMethodLocalHash, and ReleaseLockIfHeld().

Referenced by ResourceOwnerReleaseInternal().

◆ LockReleaseSession()

void LockReleaseSession ( LOCKMETHODID lockmethodid )

extern

Definition at line 2590 of file lock.c.

{
    HASH_SEQ_STATUS status;
    LOCALLOCK  *locallock;
 
    if (lockmethodid <= 0 || lockmethodid >= lengthof(LockMethods))
        elog(ERROR, "unrecognized lock method: %d", lockmethodid);
 
    hash_seq_init(&status, LockMethodLocalHash);
 
    while ((locallock = (LOCALLOCK *) hash_seq_search(&status)) != NULL)
    {
        /* Ignore items that are not of the specified lock method */
        if (LOCALLOCK_LOCKMETHOD(*locallock) != lockmethodid)
            continue;
 
        ReleaseLockIfHeld(locallock, true);
    }
}

References elog, ERROR, fb(), hash_seq_init(), hash_seq_search(), lengthof, LOCALLOCK_LOCKMETHOD, LockMethodLocalHash, LockMethods, and ReleaseLockIfHeld().

Referenced by pg_advisory_unlock_all().

◆ LockTagHashCode()

uint32 LockTagHashCode ( const LOCKTAG * locktag )

extern

Definition at line 555 of file lock.c.

{
    return get_hash_value(LockMethodLockHash, locktag);
}

References get_hash_value(), and LockMethodLockHash.

Referenced by CheckDeadLock(), GetLockConflicts(), lock_twophase_recover(), LockAcquireExtended(), LockRefindAndRelease(), LockReleaseAll(), LockWaiterCount(), proclock_hash(), and VirtualXactLock().

◆ LockWaiterCount()

int LockWaiterCount ( const LOCKTAG * locktag )

extern

Definition at line 4837 of file lock.c.

{
    LOCKMETHODID lockmethodid = locktag->locktag_lockmethodid;
    LOCK       *lock;
    bool        found;
    uint32      hashcode;
    LWLock     *partitionLock;
    int         waiters = 0;
 
    if (lockmethodid <= 0 || lockmethodid >= lengthof(LockMethods))
        elog(ERROR, "unrecognized lock method: %d", lockmethodid);
 
    hashcode = LockTagHashCode(locktag);
    partitionLock = LockHashPartitionLock(hashcode);
    LWLockAcquire(partitionLock, LW_EXCLUSIVE);
 
    lock = (LOCK *) hash_search_with_hash_value(LockMethodLockHash,
                                                locktag,
                                                hashcode,
                                                HASH_FIND,
                                                &found);
    if (found)
    {
        Assert(lock != NULL);
        waiters = lock->nRequested;
    }
    LWLockRelease(partitionLock);
 
    return waiters;
}

References Assert, elog, ERROR, fb(), HASH_FIND, hash_search_with_hash_value(), lengthof, LockHashPartitionLock, LockMethodLockHash, LockMethods, LOCKTAG::locktag_lockmethodid, LockTagHashCode(), LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), and LOCK::nRequested.

Referenced by RelationExtensionLockWaiterCount().

◆ MarkLockClear()

void MarkLockClear ( LOCALLOCK * locallock )

extern

Definition at line 1929 of file lock.c.

{
    Assert(locallock->nLocks > 0);
    locallock->lockCleared = true;
}

References Assert, and fb().

Referenced by ConditionalLockDatabaseObject(), ConditionalLockRelation(), ConditionalLockRelationOid(), ConditionalLockSharedObject(), LockRelation(), LockRelationId(), and LockRelationOid().

◆ PostPrepare_Locks()

void PostPrepare_Locks ( FullTransactionId fxid )

extern

Definition at line 3581 of file lock.c.

{
    PGPROC     *newproc = TwoPhaseGetDummyProc(fxid, false);
    HASH_SEQ_STATUS status;
    LOCALLOCK  *locallock;
    LOCK       *lock;
    PROCLOCK   *proclock;
    PROCLOCKTAG proclocktag;
    int         partition;
 
    /* Can't prepare a lock group follower. */
    Assert(MyProc->lockGroupLeader == NULL ||
           MyProc->lockGroupLeader == MyProc);
 
    /* This is a critical section: any error means big trouble */
    START_CRIT_SECTION();
 
    /*
     * First we run through the locallock table and get rid of unwanted
     * entries, then we scan the process's proclocks and transfer them to the
     * target proc.
     *
     * We do this separately because we may have multiple locallock entries
     * pointing to the same proclock, and we daren't end up with any dangling
     * pointers.
     */
    hash_seq_init(&status, LockMethodLocalHash);
 
    while ((locallock = (LOCALLOCK *) hash_seq_search(&status)) != NULL)
    {
        LOCALLOCKOWNER *lockOwners = locallock->lockOwners;
        bool        haveSessionLock;
        bool        haveXactLock;
        int         i;
 
        if (locallock->proclock == NULL || locallock->lock == NULL)
        {
            /*
             * We must've run out of shared memory while trying to set up this
             * lock.  Just forget the local entry.
             */
            Assert(locallock->nLocks == 0);
            RemoveLocalLock(locallock);
            continue;
        }
 
        /* Ignore VXID locks */
        if (locallock->tag.lock.locktag_type == LOCKTAG_VIRTUALTRANSACTION)
            continue;
 
        /* Scan to see whether we hold it at session or transaction level */
        haveSessionLock = haveXactLock = false;
        for (i = locallock->numLockOwners - 1; i >= 0; i--)
        {
            if (lockOwners[i].owner == NULL)
                haveSessionLock = true;
            else
                haveXactLock = true;
        }
 
        /* Ignore it if we have only session lock */
        if (!haveXactLock)
            continue;
 
        /* This can't happen, because we already checked it */
        if (haveSessionLock)
            ereport(PANIC,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("cannot PREPARE while holding both session-level and transaction-level locks on the same object")));
 
        /* Mark the proclock to show we need to release this lockmode */
        if (locallock->nLocks > 0)
            locallock->proclock->releaseMask |= LOCKBIT_ON(locallock->tag.mode);
 
        /* And remove the locallock hashtable entry */
        RemoveLocalLock(locallock);
    }
 
    /*
     * Now, scan each lock partition separately.
     */
    for (partition = 0; partition < NUM_LOCK_PARTITIONS; partition++)
    {
        LWLock     *partitionLock;
        dlist_head *procLocks = &(MyProc->myProcLocks[partition]);
        dlist_mutable_iter proclock_iter;
 
        partitionLock = LockHashPartitionLockByIndex(partition);
 
        /*
         * If the proclock list for this partition is empty, we can skip
         * acquiring the partition lock.  This optimization is safer than the
         * situation in LockReleaseAll, because we got rid of any fast-path
         * locks during AtPrepare_Locks, so there cannot be any case where
         * another backend is adding something to our lists now.  For safety,
         * though, we code this the same way as in LockReleaseAll.
         */
        if (dlist_is_empty(procLocks))
            continue;           /* needn't examine this partition */
 
        LWLockAcquire(partitionLock, LW_EXCLUSIVE);
 
        dlist_foreach_modify(proclock_iter, procLocks)
        {
            proclock = dlist_container(PROCLOCK, procLink, proclock_iter.cur);
 
            Assert(proclock->tag.myProc == MyProc);
 
            lock = proclock->tag.myLock;
 
            /* Ignore VXID locks */
            if (lock->tag.locktag_type == LOCKTAG_VIRTUALTRANSACTION)
                continue;
 
            PROCLOCK_PRINT("PostPrepare_Locks", proclock);
            LOCK_PRINT("PostPrepare_Locks", lock, 0);
            Assert(lock->nRequested >= 0);
            Assert(lock->nGranted >= 0);
            Assert(lock->nGranted <= lock->nRequested);
            Assert((proclock->holdMask & ~lock->grantMask) == 0);
 
            /* Ignore it if nothing to release (must be a session lock) */
            if (proclock->releaseMask == 0)
                continue;
 
            /* Else we should be releasing all locks */
            if (proclock->releaseMask != proclock->holdMask)
                elog(PANIC, "we seem to have dropped a bit somewhere");
 
            /*
             * We cannot simply modify proclock->tag.myProc to reassign
             * ownership of the lock, because that's part of the hash key and
             * the proclock would then be in the wrong hash chain.  Instead
             * use hash_update_hash_key.  (We used to create a new hash entry,
             * but that risks out-of-memory failure if other processes are
             * busy making proclocks too.)  We must unlink the proclock from
             * our procLink chain and put it into the new proc's chain, too.
             *
             * Note: the updated proclock hash key will still belong to the
             * same hash partition, cf proclock_hash().  So the partition lock
             * we already hold is sufficient for this.
             */
            dlist_delete(&proclock->procLink);
 
            /*
             * Create the new hash key for the proclock.
             */
            proclocktag.myLock = lock;
            proclocktag.myProc = newproc;
 
            /*
             * Update groupLeader pointer to point to the new proc.  (We'd
             * better not be a member of somebody else's lock group!)
             */
            Assert(proclock->groupLeader == proclock->tag.myProc);
            proclock->groupLeader = newproc;
 
            /*
             * Update the proclock.  We should not find any existing entry for
             * the same hash key, since there can be only one entry for any
             * given lock with my own proc.
             */
            if (!hash_update_hash_key(LockMethodProcLockHash,
                                      proclock,
                                      &proclocktag))
                elog(PANIC, "duplicate entry found while reassigning a prepared transaction's locks");
 
            /* Re-link into the new proc's proclock list */
            dlist_push_tail(&newproc->myProcLocks[partition], &proclock->procLink);
 
            PROCLOCK_PRINT("PostPrepare_Locks: updated", proclock);
        }                       /* loop over PROCLOCKs within this partition */
 
        LWLockRelease(partitionLock);
    }                           /* loop over partitions */
 
    END_CRIT_SECTION();
}

References Assert, dlist_container, dlist_delete(), dlist_foreach_modify, dlist_is_empty(), dlist_push_tail(), elog, END_CRIT_SECTION, ereport, errcode(), errmsg, fb(), LOCK::grantMask, PROCLOCK::groupLeader, hash_seq_init(), hash_seq_search(), hash_update_hash_key(), PROCLOCK::holdMask, i, LOCK_PRINT, LOCKBIT_ON, PGPROC::lockGroupLeader, LockHashPartitionLockByIndex, LockMethodLocalHash, LockMethodProcLockHash, LOCKTAG::locktag_type, LOCKTAG_VIRTUALTRANSACTION, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), PROCLOCKTAG::myLock, MyProc, PROCLOCKTAG::myProc, PGPROC::myProcLocks, LOCK::nGranted, LOCK::nRequested, NUM_LOCK_PARTITIONS, PANIC, PROCLOCK::procLink, PROCLOCK_PRINT, PROCLOCK::releaseMask, RemoveLocalLock(), START_CRIT_SECTION, LOCK::tag, PROCLOCK::tag, and TwoPhaseGetDummyProc().

Referenced by PrepareTransaction().

◆ RememberSimpleDeadLock()

void RememberSimpleDeadLock	(	PGPROC *	proc1,
		LOCKMODE	lockmode,
		LOCK *	lock,
		PGPROC *	proc2
	)

extern

Definition at line 1147 of file deadlock.c.

{
    DEADLOCK_INFO *info = &deadlockDetails[0];
 
    info->locktag = lock->tag;
    info->lockmode = lockmode;
    info->pid = proc1->pid;
    info++;
    info->locktag = proc2->waitLock->tag;
    info->lockmode = proc2->waitLockMode;
    info->pid = proc2->pid;
    nDeadlockDetails = 2;
}

References deadlockDetails, fb(), DEADLOCK_INFO::lockmode, DEADLOCK_INFO::locktag, nDeadlockDetails, DEADLOCK_INFO::pid, and LOCK::tag.

Referenced by JoinWaitQueue().

◆ RemoveFromWaitQueue()

void RemoveFromWaitQueue	(	PGPROC *	proc,
		uint32	hashcode
	)

extern

Definition at line 2055 of file lock.c.

{
    LOCK       *waitLock = proc->waitLock;
    PROCLOCK   *proclock = proc->waitProcLock;
    LOCKMODE    lockmode = proc->waitLockMode;
    LOCKMETHODID lockmethodid = LOCK_LOCKMETHOD(*waitLock);
 
    /* Make sure proc is waiting */
    Assert(proc->waitStatus == PROC_WAIT_STATUS_WAITING);
    Assert(!dlist_node_is_detached(&proc->waitLink));
    Assert(waitLock);
    Assert(!dclist_is_empty(&waitLock->waitProcs));
    Assert(0 < lockmethodid && lockmethodid < lengthof(LockMethods));
 
    /* Remove proc from lock's wait queue */
    dclist_delete_from_thoroughly(&waitLock->waitProcs, &proc->waitLink);
 
    /* Undo increments of request counts by waiting process */
    Assert(waitLock->nRequested > 0);
    Assert(waitLock->nRequested > proc->waitLock->nGranted);
    waitLock->nRequested--;
    Assert(waitLock->requested[lockmode] > 0);
    waitLock->requested[lockmode]--;
    /* don't forget to clear waitMask bit if appropriate */
    if (waitLock->granted[lockmode] == waitLock->requested[lockmode])
        waitLock->waitMask &= LOCKBIT_OFF(lockmode);
 
    /* Clean up the proc's own state, and pass it the ok/fail signal */
    proc->waitLock = NULL;
    proc->waitProcLock = NULL;
    proc->waitStatus = PROC_WAIT_STATUS_ERROR;
 
    /*
     * Delete the proclock immediately if it represents no already-held locks.
     * (This must happen now because if the owner of the lock decides to
     * release it, and the requested/granted counts then go to zero,
     * LockRelease expects there to be no remaining proclocks.) Then see if
     * any other waiters for the lock can be woken up now.
     */
    CleanUpLock(waitLock, proclock,
                LockMethods[lockmethodid], hashcode,
                true);
}

References Assert, CleanUpLock(), dclist_delete_from_thoroughly(), dclist_is_empty(), dlist_node_is_detached(), fb(), LOCK::granted, lengthof, LOCK_LOCKMETHOD, LOCKBIT_OFF, LockMethods, LOCK::nGranted, LOCK::nRequested, PROC_WAIT_STATUS_ERROR, PROC_WAIT_STATUS_WAITING, LOCK::requested, PGPROC::waitLink, PGPROC::waitLock, PGPROC::waitLockMode, LOCK::waitMask, PGPROC::waitProcLock, LOCK::waitProcs, and PGPROC::waitStatus.

Referenced by CheckDeadLock(), and LockErrorCleanup().

◆ ResetAwaitedLock()

void ResetAwaitedLock ( void )

extern

Definition at line 1916 of file lock.c.

{
    awaitedLock = NULL;
}

References awaitedLock, and fb().

Referenced by LockErrorCleanup().

◆ VirtualXactLock()

bool VirtualXactLock	(	VirtualTransactionId	vxid,
		bool	wait
	)

extern

Definition at line 4726 of file lock.c.

{
    LOCKTAG     tag;
    PGPROC     *proc;
    TransactionId xid = InvalidTransactionId;
 
    Assert(VirtualTransactionIdIsValid(vxid));
 
    if (VirtualTransactionIdIsRecoveredPreparedXact(vxid))
        /* no vxid lock; localTransactionId is a normal, locked XID */
        return XactLockForVirtualXact(vxid, vxid.localTransactionId, wait);
 
    SET_LOCKTAG_VIRTUALTRANSACTION(tag, vxid);
 
    /*
     * If a lock table entry must be made, this is the PGPROC on whose behalf
     * it must be done.  Note that the transaction might end or the PGPROC
     * might be reassigned to a new backend before we get around to examining
     * it, but it doesn't matter.  If we find upon examination that the
     * relevant lxid is no longer running here, that's enough to prove that
     * it's no longer running anywhere.
     */
    proc = ProcNumberGetProc(vxid.procNumber);
    if (proc == NULL)
        return XactLockForVirtualXact(vxid, InvalidTransactionId, wait);
 
    /*
     * We must acquire this lock before checking the procNumber and lxid
     * against the ones we're waiting for.  The target backend will only set
     * or clear lxid while holding this lock.
     */
    LWLockAcquire(&proc->fpInfoLock, LW_EXCLUSIVE);
 
    if (proc->vxid.procNumber != vxid.procNumber
        || proc->fpLocalTransactionId != vxid.localTransactionId)
    {
        /* VXID ended */
        LWLockRelease(&proc->fpInfoLock);
        return XactLockForVirtualXact(vxid, InvalidTransactionId, wait);
    }
 
    /*
     * If we aren't asked to wait, there's no need to set up a lock table
     * entry.  The transaction is still in progress, so just return false.
     */
    if (!wait)
    {
        LWLockRelease(&proc->fpInfoLock);
        return false;
    }
 
    /*
     * OK, we're going to need to sleep on the VXID.  But first, we must set
     * up the primary lock table entry, if needed (ie, convert the proc's
     * fast-path lock on its VXID to a regular lock).
     */
    if (proc->fpVXIDLock)
    {
        PROCLOCK   *proclock;
        uint32      hashcode;
        LWLock     *partitionLock;
 
        hashcode = LockTagHashCode(&tag);
 
        partitionLock = LockHashPartitionLock(hashcode);
        LWLockAcquire(partitionLock, LW_EXCLUSIVE);
 
        proclock = SetupLockInTable(LockMethods[DEFAULT_LOCKMETHOD], proc,
                                    &tag, hashcode, ExclusiveLock);
        if (!proclock)
        {
            LWLockRelease(partitionLock);
            LWLockRelease(&proc->fpInfoLock);
            ereport(ERROR,
                    (errcode(ERRCODE_OUT_OF_MEMORY),
                     errmsg("out of shared memory"),
                     errhint("You might need to increase \"%s\".", "max_locks_per_transaction")));
        }
        GrantLock(proclock->tag.myLock, proclock, ExclusiveLock);
 
        LWLockRelease(partitionLock);
 
        proc->fpVXIDLock = false;
    }
 
    /*
     * If the proc has an XID now, we'll avoid a TwoPhaseGetXidByVirtualXID()
     * search.  The proc might have assigned this XID but not yet locked it,
     * in which case the proc will lock this XID before releasing the VXID.
     * The fpInfoLock critical section excludes VirtualXactLockTableCleanup(),
     * so we won't save an XID of a different VXID.  It doesn't matter whether
     * we save this before or after setting up the primary lock table entry.
     */
    xid = proc->xid;
 
    /* Done with proc->fpLockBits */
    LWLockRelease(&proc->fpInfoLock);
 
    /* Time to wait. */
    (void) LockAcquire(&tag, ShareLock, false, false);
 
    LockRelease(&tag, ShareLock, false);
    return XactLockForVirtualXact(vxid, xid, wait);
}

References Assert, DEFAULT_LOCKMETHOD, ereport, errcode(), errhint(), errmsg, ERROR, ExclusiveLock, fb(), PGPROC::fpInfoLock, PGPROC::fpLocalTransactionId, PGPROC::fpVXIDLock, GrantLock(), InvalidTransactionId, VirtualTransactionId::localTransactionId, LockAcquire(), LockHashPartitionLock, LockMethods, LockRelease(), LockTagHashCode(), LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), PROCLOCKTAG::myLock, VirtualTransactionId::procNumber, PGPROC::procNumber, ProcNumberGetProc(), SET_LOCKTAG_VIRTUALTRANSACTION, SetupLockInTable(), ShareLock, PROCLOCK::tag, VirtualTransactionIdIsRecoveredPreparedXact, VirtualTransactionIdIsValid, PGPROC::vxid, XactLockForVirtualXact(), and PGPROC::xid.

Referenced by ResolveRecoveryConflictWithVirtualXIDs(), WaitForLockersMultiple(), and WaitForOlderSnapshots().

◆ VirtualXactLockTableCleanup()

void VirtualXactLockTableCleanup ( void )

extern

Definition at line 4626 of file lock.c.

{
    bool        fastpath;
    LocalTransactionId lxid;
 
    Assert(MyProc->vxid.procNumber != INVALID_PROC_NUMBER);
 
    /*
     * Clean up shared memory state.
     */
    LWLockAcquire(&MyProc->fpInfoLock, LW_EXCLUSIVE);
 
    fastpath = MyProc->fpVXIDLock;
    lxid = MyProc->fpLocalTransactionId;
    MyProc->fpVXIDLock = false;
    MyProc->fpLocalTransactionId = InvalidLocalTransactionId;
 
    LWLockRelease(&MyProc->fpInfoLock);
 
    /*
     * If fpVXIDLock has been cleared without touching fpLocalTransactionId,
     * that means someone transferred the lock to the main lock table.
     */
    if (!fastpath && LocalTransactionIdIsValid(lxid))
    {
        VirtualTransactionId vxid;
        LOCKTAG     locktag;
 
        vxid.procNumber = MyProcNumber;
        vxid.localTransactionId = lxid;
        SET_LOCKTAG_VIRTUALTRANSACTION(locktag, vxid);
 
        LockRefindAndRelease(LockMethods[DEFAULT_LOCKMETHOD], MyProc,
                             &locktag, ExclusiveLock, false);
    }
}

References Assert, DEFAULT_LOCKMETHOD, ExclusiveLock, PGPROC::fpInfoLock, PGPROC::fpLocalTransactionId, PGPROC::fpVXIDLock, INVALID_PROC_NUMBER, InvalidLocalTransactionId, VirtualTransactionId::localTransactionId, LocalTransactionIdIsValid, LockMethods, LockRefindAndRelease(), LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MyProc, MyProcNumber, VirtualTransactionId::procNumber, PGPROC::procNumber, SET_LOCKTAG_VIRTUALTRANSACTION, and PGPROC::vxid.

Referenced by LockReleaseAll(), and ShutdownRecoveryTransactionEnvironment().

◆ VirtualXactLockTableInsert()

void VirtualXactLockTableInsert ( VirtualTransactionId vxid )

extern

Definition at line 4603 of file lock.c.

{
    Assert(VirtualTransactionIdIsValid(vxid));
 
    LWLockAcquire(&MyProc->fpInfoLock, LW_EXCLUSIVE);
 
    Assert(MyProc->vxid.procNumber == vxid.procNumber);
    Assert(MyProc->fpLocalTransactionId == InvalidLocalTransactionId);
    Assert(MyProc->fpVXIDLock == false);
 
    MyProc->fpVXIDLock = true;
    MyProc->fpLocalTransactionId = vxid.localTransactionId;
 
    LWLockRelease(&MyProc->fpInfoLock);
}

References Assert, PGPROC::fpInfoLock, PGPROC::fpLocalTransactionId, PGPROC::fpVXIDLock, InvalidLocalTransactionId, VirtualTransactionId::localTransactionId, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MyProc, VirtualTransactionId::procNumber, PGPROC::procNumber, VirtualTransactionIdIsValid, and PGPROC::vxid.

Referenced by InitRecoveryTransactionEnvironment(), and StartTransaction().

Variable Documentation

◆ log_lock_failures

PGDLLIMPORT bool log_lock_failures

extern

Definition at line 57 of file lock.c.

Referenced by heap_acquire_tuplock(), heap_lock_tuple(), and heapam_tuple_lock().

◆ max_locks_per_xact

PGDLLIMPORT int max_locks_per_xact

extern

Definition at line 56 of file lock.c.

Referenced by CheckRequiredParameterValues(), InitControlFile(), InitializeFastPathLocks(), and XLogReportParameters().

Data Structures

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ GET_VXID_FROM_PGPROC

◆ InvalidLocalTransactionId

◆ LOCALLOCK_LOCKMETHOD

◆ LOCALLOCK_LOCKTAG

◆ LocalTransactionIdIsValid

◆ LOCK_LOCKMETHOD

◆ LOCK_LOCKTAG

◆ LOCKBIT_OFF

◆ LOCKBIT_ON

◆ LockHashPartition

◆ LockHashPartitionLock

◆ LockHashPartitionLockByIndex

◆ LockHashPartitionLockByProc

◆ MAX_LOCKMODES

◆ PROCLOCK_LOCKMETHOD

◆ SetInvalidVirtualTransactionId

◆ VirtualTransactionIdEquals

◆ VirtualTransactionIdIsRecoveredPreparedXact

◆ VirtualTransactionIdIsValid

Typedef Documentation

◆ BlockedProcData

◆ BlockedProcsData

◆ LOCALLOCK

◆ LOCALLOCKOWNER

◆ LOCALLOCKTAG

◆ LOCK

◆ LockData

◆ LockInstanceData

◆ LockMethod

◆ LockMethodData

◆ PGPROC

◆ PROCLOCK

◆ PROCLOCKTAG

◆ VirtualTransactionId

Enumeration Type Documentation

◆ DeadLockState

◆ LockAcquireResult

Function Documentation

◆ AbortStrongLockAcquire()

◆ AtPrepare_Locks()

◆ DeadLockCheck()

◆ DeadLockReport()

◆ DoLockModesConflict()

◆ GetAwaitedLock()

◆ GetBlockerStatusData()

◆ GetBlockingAutoVacuumPgproc()

◆ GetLockConflicts()

◆ GetLockmodeName()

◆ GetLocksMethodTable()

◆ GetLockStatusData()

◆ GetLockTagsMethodTable()

◆ GetRunningTransactionLocks()

◆ GrantAwaitedLock()

◆ GrantLock()

◆ InitDeadLockChecking()

◆ InitLockManagerAccess()

◆ lock_twophase_postabort()

◆ lock_twophase_postcommit()

◆ lock_twophase_recover()

◆ lock_twophase_standby_recover()

◆ LockAcquire()

◆ LockAcquireExtended()

◆ LockCheckConflicts()

◆ LockHasWaiters()

◆ LockHeldByMe()

◆ LockReassignCurrentOwner()

◆ LockRelease()

◆ LockReleaseAll()

◆ LockReleaseCurrentOwner()

◆ LockReleaseSession()

◆ LockTagHashCode()

◆ LockWaiterCount()

◆ MarkLockClear()