#include "lib/ilist.h"
#include "storage/lockdefs.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	LOCKTAG

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	DEFAULT_LOCKMETHOD 1

#define	USER_LOCKMETHOD 2

#define	LOCKTAG_LAST_TYPE LOCKTAG_APPLY_TRANSACTION

#define	SET_LOCKTAG_RELATION(locktag, dboid, reloid)

#define	SET_LOCKTAG_RELATION_EXTEND(locktag, dboid, reloid)

#define	SET_LOCKTAG_DATABASE_FROZEN_IDS(locktag, dboid)

#define	SET_LOCKTAG_PAGE(locktag, dboid, reloid, blocknum)

#define	SET_LOCKTAG_TUPLE(locktag, dboid, reloid, blocknum, offnum)

#define	SET_LOCKTAG_TRANSACTION(locktag, xid)

#define	SET_LOCKTAG_VIRTUALTRANSACTION(locktag, vxid)

#define	SET_LOCKTAG_SPECULATIVE_INSERTION(locktag, xid, token)

#define	SET_LOCKTAG_OBJECT(locktag, dboid, classoid, objoid, objsubid)

#define	SET_LOCKTAG_ADVISORY(locktag, id1, id2, id3, id4)

#define	SET_LOCKTAG_APPLY_TRANSACTION(locktag, dboid, suboid, xid, objid)

#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 LockMethodData	LockMethodData

typedef const LockMethodData *	LockMethod

typedef uint16	LOCKMETHODID

typedef enum LockTagType	LockTagType

typedef struct LOCKTAG	LOCKTAG

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	LockTagType { LOCKTAG_RELATION , LOCKTAG_RELATION_EXTEND , LOCKTAG_DATABASE_FROZEN_IDS , LOCKTAG_PAGE , LOCKTAG_TUPLE , LOCKTAG_TRANSACTION , LOCKTAG_VIRTUALTRANSACTION , LOCKTAG_SPECULATIVE_TOKEN , LOCKTAG_OBJECT , LOCKTAG_USERLOCK , LOCKTAG_ADVISORY , LOCKTAG_APPLY_TRANSACTION }

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	LockManagerShmemInit (void)

Size	LockManagerShmemSize (void)

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 (TransactionId xid)

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 (TransactionId xid, uint16 info, void *recdata, uint32 len)

void	lock_twophase_postcommit (TransactionId xid, uint16 info, void *recdata, uint32 len)

void	lock_twophase_postabort (TransactionId xid, uint16 info, void *recdata, uint32 len)

void	lock_twophase_standby_recover (TransactionId xid, 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_failure

PGDLLIMPORT const char *const	LockTagTypeNames []

Macro Definition Documentation

◆ DEFAULT_LOCKMETHOD

#define DEFAULT_LOCKMETHOD 1

Definition at line 126 of file lock.h.

◆ 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)

Definition at line 78 of file lock.h.

◆ InvalidLocalTransactionId

#define InvalidLocalTransactionId 0

Definition at line 66 of file lock.h.

◆ LOCALLOCK_LOCKMETHOD

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

Definition at line 444 of file lock.h.

◆ LOCALLOCK_LOCKTAG

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

Definition at line 445 of file lock.h.

◆ LocalTransactionIdIsValid

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

Definition at line 67 of file lock.h.

◆ LOCK_LOCKMETHOD

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

Definition at line 325 of file lock.h.

◆ LOCK_LOCKTAG

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

Definition at line 326 of file lock.h.

◆ LOCKBIT_OFF

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

Definition at line 86 of file lock.h.

◆ LOCKBIT_ON

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

Definition at line 85 of file lock.h.

◆ LockHashPartition

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

Definition at line 525 of file lock.h.

◆ LockHashPartitionLock

#define LockHashPartitionLock ( hashcode )

Value:

(&MainLWLockArray[LOCK_MANAGER_LWLOCK_OFFSET + \

LockHashPartition(hashcode)].lock)

MainLWLockArray

LWLockPadded * MainLWLockArray

Definition: lwlock.c:202

LOCK_MANAGER_LWLOCK_OFFSET

#define LOCK_MANAGER_LWLOCK_OFFSET

Definition: lwlock.h:105

LWLockPadded::lock

LWLock lock

Definition: lwlock.h:70

Definition at line 527 of file lock.h.

◆ LockHashPartitionLockByIndex

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

Definition at line 530 of file lock.h.

◆ LockHashPartitionLockByProc

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

Definition at line 542 of file lock.h.

◆ LOCKTAG_LAST_TYPE

#define LOCKTAG_LAST_TYPE LOCKTAG_APPLY_TRANSACTION

Definition at line 153 of file lock.h.

◆ MAX_LOCKMODES

#define MAX_LOCKMODES 10

Definition at line 83 of file lock.h.

◆ PROCLOCK_LOCKMETHOD

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

Definition at line 383 of file lock.h.

◆ SET_LOCKTAG_ADVISORY

#define SET_LOCKTAG_ADVISORY	(	locktag,
		id1,
		id2,
		id3,
		id4
	)

Value:

    ((locktag).locktag_field1 = (id1), \
     (locktag).locktag_field2 = (id2), \
     (locktag).locktag_field3 = (id3), \
     (locktag).locktag_field4 = (id4), \
     (locktag).locktag_type = LOCKTAG_ADVISORY, \
     (locktag).locktag_lockmethodid = USER_LOCKMETHOD)

Definition at line 271 of file lock.h.

◆ SET_LOCKTAG_APPLY_TRANSACTION

#define SET_LOCKTAG_APPLY_TRANSACTION	(	locktag,
		dboid,
		suboid,
		xid,
		objid
	)

Value:

    ((locktag).locktag_field1 = (dboid), \
     (locktag).locktag_field2 = (suboid), \
     (locktag).locktag_field3 = (xid), \
     (locktag).locktag_field4 = (objid), \
     (locktag).locktag_type = LOCKTAG_APPLY_TRANSACTION, \
     (locktag).locktag_lockmethodid = DEFAULT_LOCKMETHOD)

Definition at line 283 of file lock.h.

◆ SET_LOCKTAG_DATABASE_FROZEN_IDS

#define SET_LOCKTAG_DATABASE_FROZEN_IDS	(	locktag,
		dboid
	)

Value:

    ((locktag).locktag_field1 = (dboid), \
     (locktag).locktag_field2 = 0, \
     (locktag).locktag_field3 = 0, \
     (locktag).locktag_field4 = 0, \
     (locktag).locktag_type = LOCKTAG_DATABASE_FROZEN_IDS, \
     (locktag).locktag_lockmethodid = DEFAULT_LOCKMETHOD)

Definition at line 200 of file lock.h.

◆ SET_LOCKTAG_OBJECT

#define SET_LOCKTAG_OBJECT	(	locktag,
		dboid,
		classoid,
		objoid,
		objsubid
	)

Value:

    ((locktag).locktag_field1 = (dboid), \
     (locktag).locktag_field2 = (classoid), \
     (locktag).locktag_field3 = (objoid), \
     (locktag).locktag_field4 = (objsubid), \
     (locktag).locktag_type = LOCKTAG_OBJECT, \
     (locktag).locktag_lockmethodid = DEFAULT_LOCKMETHOD)

Definition at line 263 of file lock.h.

◆ SET_LOCKTAG_PAGE

#define SET_LOCKTAG_PAGE	(	locktag,
		dboid,
		reloid,
		blocknum
	)

Value:

    ((locktag).locktag_field1 = (dboid), \
     (locktag).locktag_field2 = (reloid), \
     (locktag).locktag_field3 = (blocknum), \
     (locktag).locktag_field4 = 0, \
     (locktag).locktag_type = LOCKTAG_PAGE, \
     (locktag).locktag_lockmethodid = DEFAULT_LOCKMETHOD)

Definition at line 209 of file lock.h.

◆ SET_LOCKTAG_RELATION

#define SET_LOCKTAG_RELATION	(	locktag,
		dboid,
		reloid
	)

Value:

    ((locktag).locktag_field1 = (dboid), \
     (locktag).locktag_field2 = (reloid), \
     (locktag).locktag_field3 = 0, \
     (locktag).locktag_field4 = 0, \
     (locktag).locktag_type = LOCKTAG_RELATION, \
     (locktag).locktag_lockmethodid = DEFAULT_LOCKMETHOD)

Definition at line 182 of file lock.h.

◆ SET_LOCKTAG_RELATION_EXTEND

#define SET_LOCKTAG_RELATION_EXTEND	(	locktag,
		dboid,
		reloid
	)

Value:

    ((locktag).locktag_field1 = (dboid), \
     (locktag).locktag_field2 = (reloid), \
     (locktag).locktag_field3 = 0, \
     (locktag).locktag_field4 = 0, \
     (locktag).locktag_type = LOCKTAG_RELATION_EXTEND, \
     (locktag).locktag_lockmethodid = DEFAULT_LOCKMETHOD)

Definition at line 191 of file lock.h.

◆ SET_LOCKTAG_SPECULATIVE_INSERTION

#define SET_LOCKTAG_SPECULATIVE_INSERTION	(	locktag,
		xid,
		token
	)

Value:

    ((locktag).locktag_field1 = (xid), \
     (locktag).locktag_field2 = (token),        \
     (locktag).locktag_field3 = 0, \
     (locktag).locktag_field4 = 0, \
     (locktag).locktag_type = LOCKTAG_SPECULATIVE_TOKEN, \
     (locktag).locktag_lockmethodid = DEFAULT_LOCKMETHOD)

Definition at line 248 of file lock.h.

◆ SET_LOCKTAG_TRANSACTION

#define SET_LOCKTAG_TRANSACTION	(	locktag,
		xid
	)

Value:

    ((locktag).locktag_field1 = (xid), \
     (locktag).locktag_field2 = 0, \
     (locktag).locktag_field3 = 0, \
     (locktag).locktag_field4 = 0, \
     (locktag).locktag_type = LOCKTAG_TRANSACTION, \
     (locktag).locktag_lockmethodid = DEFAULT_LOCKMETHOD)

Definition at line 227 of file lock.h.

◆ SET_LOCKTAG_TUPLE

#define SET_LOCKTAG_TUPLE	(	locktag,
		dboid,
		reloid,
		blocknum,
		offnum
	)

Value:

    ((locktag).locktag_field1 = (dboid), \
     (locktag).locktag_field2 = (reloid), \
     (locktag).locktag_field3 = (blocknum), \
     (locktag).locktag_field4 = (offnum), \
     (locktag).locktag_type = LOCKTAG_TUPLE, \
     (locktag).locktag_lockmethodid = DEFAULT_LOCKMETHOD)

Definition at line 218 of file lock.h.

◆ SET_LOCKTAG_VIRTUALTRANSACTION

#define SET_LOCKTAG_VIRTUALTRANSACTION	(	locktag,
		vxid
	)

Value:

    ((locktag).locktag_field1 = (vxid).procNumber, \
     (locktag).locktag_field2 = (vxid).localTransactionId, \
     (locktag).locktag_field3 = 0, \
     (locktag).locktag_field4 = 0, \
     (locktag).locktag_type = LOCKTAG_VIRTUALTRANSACTION, \
     (locktag).locktag_lockmethodid = DEFAULT_LOCKMETHOD)

Definition at line 236 of file lock.h.

◆ SetInvalidVirtualTransactionId

#define SetInvalidVirtualTransactionId ( vxid )

Value:

((vxid).procNumber = INVALID_PROC_NUMBER, \

(vxid).localTransactionId = InvalidLocalTransactionId)

InvalidLocalTransactionId

#define InvalidLocalTransactionId

Definition: lock.h:66

INVALID_PROC_NUMBER

#define INVALID_PROC_NUMBER

Definition: procnumber.h:26

Definition at line 75 of file lock.h.

◆ USER_LOCKMETHOD

#define USER_LOCKMETHOD 2

Definition at line 127 of file lock.h.

◆ VirtualTransactionIdEquals

#define VirtualTransactionIdEquals	(	vxid1,
		vxid2
	)

Value:

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

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

Definition at line 72 of file lock.h.

◆ VirtualTransactionIdIsRecoveredPreparedXact

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

Definition at line 70 of file lock.h.

◆ VirtualTransactionIdIsValid

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

Definition at line 68 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 117 of file lock.h.

◆ LockMethodData

typedef struct LockMethodData LockMethodData

◆ LOCKMETHODID

typedef uint16 LOCKMETHODID

Definition at line 123 of file lock.h.

◆ LOCKTAG

typedef struct LOCKTAG LOCKTAG

◆ LockTagType

typedef enum LockTagType LockTagType

◆ PGPROC

typedef struct PGPROC PGPROC

Definition at line 29 of file lock.h.

◆ PROCLOCK

typedef struct PROCLOCK PROCLOCK

◆ PROCLOCKTAG

typedef struct PROCLOCKTAG PROCLOCKTAG

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 509 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 500 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;

◆ LockTagType

enum LockTagType

Enumerator
LOCKTAG_RELATION
LOCKTAG_RELATION_EXTEND
LOCKTAG_DATABASE_FROZEN_IDS
LOCKTAG_PAGE
LOCKTAG_TUPLE
LOCKTAG_TRANSACTION
LOCKTAG_VIRTUALTRANSACTION
LOCKTAG_SPECULATIVE_TOKEN
LOCKTAG_OBJECT
LOCKTAG_USERLOCK
LOCKTAG_ADVISORY
LOCKTAG_APPLY_TRANSACTION

Definition at line 136 of file lock.h.

{
    LOCKTAG_RELATION,           /* whole relation */
    LOCKTAG_RELATION_EXTEND,    /* the right to extend a relation */
    LOCKTAG_DATABASE_FROZEN_IDS,    /* pg_database.datfrozenxid */
    LOCKTAG_PAGE,               /* one page of a relation */
    LOCKTAG_TUPLE,              /* one physical tuple */
    LOCKTAG_TRANSACTION,        /* transaction (for waiting for xact done) */
    LOCKTAG_VIRTUALTRANSACTION, /* virtual transaction (ditto) */
    LOCKTAG_SPECULATIVE_TOKEN,  /* speculative insertion Xid and token */
    LOCKTAG_OBJECT,             /* non-relation database object */
    LOCKTAG_USERLOCK,           /* reserved for old contrib/userlock code */
    LOCKTAG_ADVISORY,           /* advisory user locks */
    LOCKTAG_APPLY_TRANSACTION,  /* transaction being applied on a logical
                                 * replication subscriber */
} LockTagType;

Function Documentation

◆ AbortStrongLockAcquire()

void AbortStrongLockAcquire ( void )

Definition at line 1859 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, LOCALLOCK::hashcode, LOCALLOCK::holdsStrongLockCount, FastPathStrongRelationLockData::mutex, SpinLockAcquire, SpinLockRelease, and StrongLockInProgress.

Referenced by LockAcquireExtended(), and LockErrorCleanup().

◆ AtPrepare_Locks()

void AtPrepare_Locks ( void )

Definition at line 3446 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(), hash_seq_init(), hash_seq_search(), LOCALLOCK::holdsStrongLockCount, i, LOCALLOCKTAG::lock, LOCALLOCK::lock, LockMethodLocalHash, TwoPhaseLockRecord::lockmode, LOCALLOCK::lockOwners, TwoPhaseLockRecord::locktag, LOCKTAG::locktag_type, LOCKTAG_VIRTUALTRANSACTION, LOCALLOCKTAG::mode, PROCLOCKTAG::myLock, LOCALLOCK::nLocks, LOCALLOCK::numLockOwners, LOCALLOCK::proclock, RegisterTwoPhaseRecord(), PROCLOCK::tag, LOCALLOCK::tag, and TWOPHASE_RM_LOCK_ID.

Referenced by PrepareTransaction().

◆ DeadLockCheck()

DeadLockState DeadLockCheck ( PGPROC * proc )

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]->links);
 
#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, FindLockCycle(), GetLocksMethodTable(), i, j, links, 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 )

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(), StringInfoData::data, deadlockDetails, DescribeLockTag(), ereport, errcode(), ERRCODE_T_R_DEADLOCK_DETECTED, errdetail_internal(), errdetail_log(), errhint(), errmsg(), ERROR, GetLockmodeName(), i, initStringInfo(), StringInfoData::len, 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
	)

Definition at line 622 of file lock.c.

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

References LockMethodData::conflictTab, DEFAULT_LOCKMETHOD, LOCKBIT_ON, and LockMethods.

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

◆ GetAwaitedLock()

LOCALLOCK * GetAwaitedLock ( void )

Definition at line 1897 of file lock.c.

{
    return awaitedLock;
}

References awaitedLock.

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

◆ GetBlockerStatusData()

BlockedProcsData * GetBlockerStatusData ( int blocked_pid )

Definition at line 3966 of file lock.c.

{
    BlockedProcsData *data;
    PGPROC     *proc;
    int         i;
 
    data = (BlockedProcsData *) palloc(sizeof(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 = (BlockedProcData *) palloc(sizeof(BlockedProcData) * data->maxprocs);
    data->locks = (LockInstanceData *) palloc(sizeof(LockInstanceData) * data->maxlocks);
    data->waiter_pids = (int *) palloc(sizeof(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, GetSingleProcBlockerStatusData(), i, PGPROC::lockGroupLeader, PGPROC::lockGroupMembers, LockHashPartitionLockByIndex, LW_SHARED, LWLockAcquire(), LWLockRelease(), MaxBackends, NUM_LOCK_PARTITIONS, and palloc().

Referenced by pg_blocking_pids().

◆ GetBlockingAutoVacuumPgproc()

PGPROC * GetBlockingAutoVacuumPgproc ( void )

Definition at line 290 of file deadlock.c.

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

References blocking_autovacuum_proc.

Referenced by ProcSleep().

◆ GetLockConflicts()

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

Definition at line 3037 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 = (VirtualTransactionId *)
            palloc0(sizeof(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 = &ProcGlobal->allProcs[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, PROC_HDR::allProcs, ConflictsWithRelationFastPath, LockMethodData::conflictTab, dlist_iter::cur, PGPROC::databaseId, dlist_container, dlist_foreach, elog, ERROR, FAST_PATH_GET_BITS, FAST_PATH_LOCKNUMBER_OFFSET, FAST_PATH_REL_GROUP, FAST_PATH_SLOT, FP_LOCK_SLOTS_PER_GROUP, PGPROC::fpInfoLock, PGPROC::fpLockBits, PGPROC::fpRelId, GET_VXID_FROM_PGPROC, HASH_FIND, hash_search_with_hash_value(), PROCLOCK::holdMask, i, InHotStandby, INVALID_PROC_NUMBER, InvalidLocalTransactionId, j, lengthof, VirtualTransactionId::localTransactionId, 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, LockMethodData::numLockModes, palloc0(), PANIC, ProcGlobal, LOCK::procLocks, VirtualTransactionId::procNumber, PROCLOCK::tag, TopMemoryContext, VirtualTransactionIdEquals, and VirtualTransactionIdIsValid.

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

◆ GetLockmodeName()

const char * GetLockmodeName	(	LOCKMETHODID	lockmethodid,
		LOCKMODE	mode
	)

Definition at line 4223 of file lock.c.

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

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

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

◆ GetLocksMethodTable()

LockMethod GetLocksMethodTable ( const LOCK * lock )

Definition at line 526 of file lock.c.

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

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

Referenced by DeadLockCheck(), and FindLockCycleRecurseMember().

◆ GetLockStatusData()

LockData * GetLockStatusData ( void )

Definition at line 3763 of file lock.c.

{
    LockData   *data;
    PROCLOCK   *proclock;
    HASH_SEQ_STATUS seqstat;
    int         els;
    int         el;
    int         i;
 
    data = (LockData *) palloc(sizeof(LockData));
 
    /* Guess how much space we'll need. */
    els = MaxBackends;
    el = 0;
    data->locks = (LockInstanceData *) palloc(sizeof(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 = &ProcGlobal->allProcs[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;
}

Referenced by pg_lock_status().

◆ GetLockTagsMethodTable()

LockMethod GetLockTagsMethodTable ( const LOCKTAG * locktag )

Definition at line 538 of file lock.c.

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

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

Referenced by pg_blocking_pids().

◆ GetRunningTransactionLocks()

xl_standby_lock * GetRunningTransactionLocks ( int * nlocks )

Definition at line 4141 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(), xl_standby_lock::dbOid, 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(), xl_standby_lock::relOid, LOCK::tag, PROCLOCK::tag, TransactionIdIsValid, xl_standby_lock::xid, and PGPROC::xid.

Referenced by LogStandbySnapshot().

◆ GrantAwaitedLock()

void GrantAwaitedLock ( void )

Definition at line 1888 of file lock.c.

{
    GrantLockLocal(awaitedLock, awaitedOwner);
}

References awaitedLock, awaitedOwner, and GrantLockLocal().

Referenced by LockErrorCleanup().

◆ GrantLock()

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

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

Definition at line 144 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.
     */
    StaticAssertStmt(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, MAX_BACKENDS_BITS, MaxBackends, maxCurConstraints, maxPossibleConstraints, MemoryContextSwitchTo(), palloc(), possibleConstraints, StaticAssertStmt, TopMemoryContext, topoProcs, visitedProcs, waitOrderProcs, and waitOrders.

Referenced by InitProcess().

◆ InitLockManagerAccess()

void InitLockManagerAccess ( void )

Definition at line 504 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	(	TransactionId	xid,
		uint16	info,
		void *	recdata,
		uint32	len
	)

Definition at line 4566 of file lock.c.

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

References len, and lock_twophase_postcommit().

◆ lock_twophase_postcommit()

void lock_twophase_postcommit	(	TransactionId	xid,
		uint16	info,
		void *	recdata,
		uint32	len
	)

Definition at line 4540 of file lock.c.

{
    TwoPhaseLockRecord *rec = (TwoPhaseLockRecord *) recdata;
    PGPROC     *proc = TwoPhaseGetDummyProc(xid, 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, 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	(	TransactionId	xid,
		uint16	info,
		void *	recdata,
		uint32	len
	)

Definition at line 4327 of file lock.c.

{
    TwoPhaseLockRecord *rec = (TwoPhaseLockRecord *) recdata;
    PGPROC     *proc = TwoPhaseGetDummyProc(xid, 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, 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, LockMethodData::lockModeNames, TwoPhaseLockRecord::locktag, LOCKTAG::locktag_field1, LOCKTAG::locktag_field2, LOCKTAG::locktag_field3, LOCKTAG::locktag_lockmethodid, LockTagHashCode(), LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MAX_LOCKMODES, MemSet, FastPathStrongRelationLockData::mutex, PROCLOCKTAG::myLock, PROCLOCKTAG::myProc, 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	(	TransactionId	xid,
		uint16	info,
		void *	recdata,
		uint32	len
	)

Definition at line 4508 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(xid,
                                          locktag->locktag_field1 /* dboid */ ,
                                          locktag->locktag_field2 /* reloid */ );
    }
}

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

◆ LockAcquire()

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

Definition at line 808 of file lock.c.

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

References 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
	)

Definition at line 835 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) &&
        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;
        }
    }
 
    /*
     * 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, LockMethodData::conflictTab, FastPathStrongRelationLockData::count, CurrentResourceOwner, StringInfoData::data, DeadLockReport(), DescribeLockTag(), dlist_delete(), EligibleForRelationFastPath, elog, ereport, errcode(), errdetail_log_plural(), errhint(), errmsg(), ERROR, FAST_PATH_REL_GROUP, FastPathGrantRelationLock(), FastPathLocalUseCounts, FastPathStrongLockHashPartition, FastPathStrongRelationLocks, FastPathTransferRelationLocks(), FinishStrongLockAcquire(), FP_LOCK_SLOTS_PER_GROUP, PGPROC::fpInfoLock, GetLockHoldersAndWaiters(), GetLockmodeName(), GrantLock(), GrantLockLocal(), HASH_ENTER, HASH_REMOVE, hash_search(), hash_search_with_hash_value(), LOCALLOCK::hashcode, PROCLOCK::holdMask, LOCALLOCK::holdsStrongLockCount, initStringInfo(), InRecovery, JoinWaitQueue(), lengthof, LOCALLOCKTAG::lock, LOCALLOCK::lock, LOCK_PRINT, LOCKACQUIRE_ALREADY_CLEAR, LOCKACQUIRE_ALREADY_HELD, LOCKACQUIRE_NOT_AVAIL, LOCKACQUIRE_OK, LOCKBIT_ON, LockCheckConflicts(), LOCALLOCK::lockCleared, LockHashPartitionLock, PROCLOCK::lockLink, LockMethodLocalHash, LockMethodProcLockHash, LockMethods, LockMethodData::lockModeNames, LOCALLOCK::lockOwners, 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(), LOCALLOCK::maxLockOwners, MemoryContextAlloc(), MemSet, LOCALLOCKTAG::mode, PROCLOCKTAG::myLock, MyProc, MyProcPid, LOCK::nGranted, LOCALLOCK::nLocks, LOCK::nRequested, LockMethodData::numLockModes, LOCALLOCK::numLockOwners, PANIC, pfree(), PROC_WAIT_STATUS_ERROR, PROC_WAIT_STATUS_OK, PROC_WAIT_STATUS_WAITING, PROCLOCK::procLink, LOCALLOCK::proclock, PROCLOCK_PRINT, ProcLockHashCode(), RecoveryInProgress(), RemoveLocalLock(), repalloc(), LOCK::requested, RowExclusiveLock, SetupLockInTable(), PROCLOCK::tag, LOCALLOCK::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
	)

Definition at line 1528 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(), LockMethodData::conflictTab, dlist_iter::cur, dlist_container, dlist_foreach, elog, LOCK::granted, LOCK::grantMask, PROCLOCK::groupLeader, PROCLOCK::holdMask, i, LOCK_LOCKTAG, LOCKBIT_ON, PGPROC::lockGroupLeader, LOCKTAG_RELATION_EXTEND, MAX_LOCKMODES, MyProc, PROCLOCKTAG::myProc, LockMethodData::numLockModes, PANIC, PROCLOCK_PRINT, LOCK::procLocks, and PROCLOCK::tag.

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

◆ LockHasWaiters()

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

Definition at line 695 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 LockMethodData::conflictTab, elog, ERROR, HASH_FIND, hash_search(), LOCALLOCK::hashcode, PROCLOCK::holdMask, lengthof, LOCALLOCKTAG::lock, LOCALLOCK::lock, LOCK_PRINT, LOCKBIT_ON, LockHashPartitionLock, LockMethodLocalHash, LockMethods, LockMethodData::lockModeNames, LOCKTAG::locktag_field1, LOCKTAG::locktag_field2, LOCKTAG::locktag_lockmethodid, LOG, LW_SHARED, LWLockAcquire(), LWLockRelease(), MemSet, LOCALLOCKTAG::mode, LOCALLOCK::nLocks, LockMethodData::numLockModes, LOCALLOCK::proclock, PROCLOCK_PRINT, RemoveLocalLock(), LOCK::waitMask, and WARNING.

Referenced by LockHasWaitersRelation().

◆ LockHeldByMe()

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

Definition at line 642 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 HASH_FIND, hash_search(), LOCALLOCKTAG::lock, LockHeldByMe(), LockMethodLocalHash, MaxLockMode, MemSet, LOCALLOCKTAG::mode, and LOCALLOCK::nLocks.

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

◆ LockManagerShmemInit()

void LockManagerShmemInit ( void )

Definition at line 443 of file lock.c.

{
    HASHCTL     info;
    long        init_table_size,
                max_table_size;
    bool        found;
 
    /*
     * Compute init/max size to request for lock hashtables.  Note these
     * calculations must agree with LockManagerShmemSize!
     */
    max_table_size = NLOCKENTS();
    init_table_size = max_table_size / 2;
 
    /*
     * Allocate hash table for LOCK structs.  This stores per-locked-object
     * information.
     */
    info.keysize = sizeof(LOCKTAG);
    info.entrysize = sizeof(LOCK);
    info.num_partitions = NUM_LOCK_PARTITIONS;
 
    LockMethodLockHash = ShmemInitHash("LOCK hash",
                                       init_table_size,
                                       max_table_size,
                                       &info,
                                       HASH_ELEM | HASH_BLOBS | HASH_PARTITION);
 
    /* Assume an average of 2 holders per lock */
    max_table_size *= 2;
    init_table_size *= 2;
 
    /*
     * Allocate hash table for PROCLOCK structs.  This stores
     * per-lock-per-holder information.
     */
    info.keysize = sizeof(PROCLOCKTAG);
    info.entrysize = sizeof(PROCLOCK);
    info.hash = proclock_hash;
    info.num_partitions = NUM_LOCK_PARTITIONS;
 
    LockMethodProcLockHash = ShmemInitHash("PROCLOCK hash",
                                           init_table_size,
                                           max_table_size,
                                           &info,
                                           HASH_ELEM | HASH_FUNCTION | HASH_PARTITION);
 
    /*
     * Allocate fast-path structures.
     */
    FastPathStrongRelationLocks =
        ShmemInitStruct("Fast Path Strong Relation Lock Data",
                        sizeof(FastPathStrongRelationLockData), &found);
    if (!found)
        SpinLockInit(&FastPathStrongRelationLocks->mutex);
}

References HASHCTL::entrysize, FastPathStrongRelationLocks, HASHCTL::hash, HASH_BLOBS, HASH_ELEM, HASH_FUNCTION, HASH_PARTITION, HASHCTL::keysize, LockMethodLockHash, LockMethodProcLockHash, FastPathStrongRelationLockData::mutex, NLOCKENTS, NUM_LOCK_PARTITIONS, HASHCTL::num_partitions, proclock_hash(), ShmemInitHash(), ShmemInitStruct(), and SpinLockInit.

Referenced by CreateOrAttachShmemStructs().

◆ LockManagerShmemSize()

Size LockManagerShmemSize ( void )

Definition at line 3726 of file lock.c.

{
    Size        size = 0;
    long        max_table_size;
 
    /* lock hash table */
    max_table_size = NLOCKENTS();
    size = add_size(size, hash_estimate_size(max_table_size, sizeof(LOCK)));
 
    /* proclock hash table */
    max_table_size *= 2;
    size = add_size(size, hash_estimate_size(max_table_size, sizeof(PROCLOCK)));
 
    /*
     * Since NLOCKENTS is only an estimate, add 10% safety margin.
     */
    size = add_size(size, size / 10);
 
    return size;
}

References add_size(), hash_estimate_size(), and NLOCKENTS.

Referenced by CalculateShmemSize().

◆ LockReassignCurrentOwner()

void LockReassignCurrentOwner	(	LOCALLOCK **	locallocks,
		int	nlocks
	)

Definition at line 2674 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, hash_seq_init(), hash_seq_search(), i, LockMethodLocalHash, LockReassignOwner(), and ResourceOwnerGetParent().

Referenced by ResourceOwnerReleaseInternal().

◆ LockRelease()

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

Definition at line 2070 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(), PGPROC::fpInfoLock, HASH_FIND, hash_search(), hash_search_with_hash_value(), LOCALLOCK::hashcode, PROCLOCK::holdMask, i, lengthof, LOCALLOCKTAG::lock, LOCALLOCK::lock, LOCK_PRINT, LOCKBIT_ON, LOCALLOCK::lockCleared, LockHashPartitionLock, LockMethodLocalHash, LockMethodLockHash, LockMethodProcLockHash, LockMethods, LockMethodData::lockModeNames, LOCALLOCK::lockOwners, LOCKTAG::locktag_field1, LOCKTAG::locktag_field2, LOCKTAG::locktag_lockmethodid, LOG, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MemSet, LOCALLOCKTAG::mode, PROCLOCKTAG::myLock, MyProc, PROCLOCKTAG::myProc, LOCALLOCK::nLocks, LockMethodData::numLockModes, LOCALLOCK::numLockOwners, LOCALLOCK::proclock, 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
	)

Definition at line 2275 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(), dlist_mutable_iter::cur, DEFAULT_LOCKMETHOD, dlist_container, dlist_foreach_modify, dlist_is_empty(), EligibleForRelationFastPath, elog, ERROR, FastPathUnGrantRelationLock(), PGPROC::fpInfoLock, LOCK::grantMask, hash_seq_init(), hash_seq_search(), PROCLOCK::holdMask, i, lengthof, LOCALLOCK_LOCKMETHOD, LOCALLOCK_LOCKTAG, LOCALLOCKTAG::lock, LOCALLOCK::lock, LOCK_LOCKMETHOD, LOCK_PRINT, LOCKBIT_ON, LockHashPartitionLockByIndex, LockMethodLocalHash, LockMethods, LOCALLOCK::lockOwners, LockRefindAndRelease(), LOCKTAG::locktag_field2, LOCKTAG_TUPLE, LockTagHashCode(), LOG, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), LOCALLOCKTAG::mode, PROCLOCKTAG::myLock, MyProc, PROCLOCKTAG::myProc, PGPROC::myProcLocks, LOCK::nGranted, LOCALLOCKOWNER::nLocks, LOCALLOCK::nLocks, LOCK::nRequested, NUM_LOCK_PARTITIONS, LockMethodData::numLockModes, LOCALLOCK::numLockOwners, LOCALLOCKOWNER::owner, PANIC, LOCALLOCK::proclock, PROCLOCK_PRINT, PROCLOCK::releaseMask, RemoveLocalLock(), ResourceOwnerForgetLock(), LOCK::tag, PROCLOCK::tag, LOCALLOCK::tag, LockMethodData::trace_flag, UnGrantLock(), VirtualXactLockTableCleanup(), and WARNING.

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

◆ LockReleaseCurrentOwner()

void LockReleaseCurrentOwner	(	LOCALLOCK **	locallocks,
		int	nlocks
	)

Definition at line 2579 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 hash_seq_init(), hash_seq_search(), i, LockMethodLocalHash, and ReleaseLockIfHeld().

Referenced by ResourceOwnerReleaseInternal().

◆ LockReleaseSession()

void LockReleaseSession ( LOCKMETHODID lockmethodid )

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

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

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

Definition at line 1919 of file lock.c.

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

References Assert(), LOCALLOCK::lockCleared, and LOCALLOCK::nLocks.

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

◆ PostPrepare_Locks()

void PostPrepare_Locks ( TransactionId xid )

Definition at line 3542 of file lock.c.

{
    PGPROC     *newproc = TwoPhaseGetDummyProc(xid, 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_mutable_iter::cur, dlist_container, dlist_delete(), dlist_foreach_modify, dlist_is_empty(), dlist_push_tail(), elog, END_CRIT_SECTION, ereport, errcode(), errmsg(), LOCK::grantMask, PROCLOCK::groupLeader, hash_seq_init(), hash_seq_search(), hash_update_hash_key(), PROCLOCK::holdMask, i, LOCALLOCKTAG::lock, LOCALLOCK::lock, LOCK_PRINT, LOCKBIT_ON, PGPROC::lockGroupLeader, LockHashPartitionLockByIndex, LockMethodLocalHash, LockMethodProcLockHash, LOCALLOCK::lockOwners, LOCKTAG::locktag_type, LOCKTAG_VIRTUALTRANSACTION, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), LOCALLOCKTAG::mode, PROCLOCKTAG::myLock, MyProc, PROCLOCKTAG::myProc, PGPROC::myProcLocks, LOCK::nGranted, LOCALLOCK::nLocks, LOCK::nRequested, NUM_LOCK_PARTITIONS, LOCALLOCK::numLockOwners, PANIC, PROCLOCK::procLink, LOCALLOCK::proclock, PROCLOCK_PRINT, PROCLOCK::releaseMask, RemoveLocalLock(), START_CRIT_SECTION, LOCK::tag, PROCLOCK::tag, LOCALLOCK::tag, and TwoPhaseGetDummyProc().

Referenced by PrepareTransaction().

◆ RememberSimpleDeadLock()

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

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, DEADLOCK_INFO::lockmode, DEADLOCK_INFO::locktag, nDeadlockDetails, DEADLOCK_INFO::pid, PGPROC::pid, LOCK::tag, PGPROC::waitLock, and PGPROC::waitLockMode.

Referenced by JoinWaitQueue().

◆ RemoveFromWaitQueue()

void RemoveFromWaitQueue	(	PGPROC *	proc,
		uint32	hashcode
	)

Definition at line 2014 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(proc->links.next != NULL);
    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->links);
 
    /* 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(), LOCK::granted, lengthof, PGPROC::links, LOCK_LOCKMETHOD, LOCKBIT_OFF, LockMethods, dlist_node::next, LOCK::nGranted, LOCK::nRequested, PROC_WAIT_STATUS_ERROR, PROC_WAIT_STATUS_WAITING, LOCK::requested, PGPROC::waitLock, PGPROC::waitLockMode, LOCK::waitMask, PGPROC::waitProcLock, LOCK::waitProcs, and PGPROC::waitStatus.

Referenced by CheckDeadLock(), and LockErrorCleanup().

◆ ResetAwaitedLock()

void ResetAwaitedLock ( void )

Definition at line 1906 of file lock.c.

{
    awaitedLock = NULL;
}

References awaitedLock.

Referenced by LockErrorCleanup().

◆ VirtualXactLock()

bool VirtualXactLock	(	VirtualTransactionId	vxid,
		bool	wait
	)

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

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

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

◆ LockTagTypeNames

PGDLLIMPORT const char* const LockTagTypeNames[]

extern

Definition at line 28 of file lockfuncs.c.

Referenced by GetLockNameFromTagType(), and pg_lock_status().

◆ log_lock_failure

PGDLLIMPORT bool log_lock_failure

extern

Definition at line 54 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 53 of file lock.c.

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

Data Structures

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ DEFAULT_LOCKMETHOD

◆ GET_VXID_FROM_PGPROC

◆ InvalidLocalTransactionId

◆ LOCALLOCK_LOCKMETHOD

◆ LOCALLOCK_LOCKTAG

◆ LocalTransactionIdIsValid

◆ LOCK_LOCKMETHOD

◆ LOCK_LOCKTAG

◆ LOCKBIT_OFF

◆ LOCKBIT_ON

◆ LockHashPartition

◆ LockHashPartitionLock

◆ LockHashPartitionLockByIndex

◆ LockHashPartitionLockByProc

◆ LOCKTAG_LAST_TYPE

◆ MAX_LOCKMODES

◆ PROCLOCK_LOCKMETHOD

◆ SET_LOCKTAG_ADVISORY

◆ SET_LOCKTAG_APPLY_TRANSACTION

◆ SET_LOCKTAG_DATABASE_FROZEN_IDS

◆ SET_LOCKTAG_OBJECT

◆ SET_LOCKTAG_PAGE

◆ SET_LOCKTAG_RELATION

◆ SET_LOCKTAG_RELATION_EXTEND

◆ SET_LOCKTAG_SPECULATIVE_INSERTION

◆ SET_LOCKTAG_TRANSACTION

◆ SET_LOCKTAG_TUPLE

◆ SET_LOCKTAG_VIRTUALTRANSACTION

◆ SetInvalidVirtualTransactionId

◆ USER_LOCKMETHOD

◆ VirtualTransactionIdEquals

◆ VirtualTransactionIdIsRecoveredPreparedXact

◆ VirtualTransactionIdIsValid

Typedef Documentation

◆ BlockedProcData

◆ BlockedProcsData

◆ LOCALLOCK

◆ LOCALLOCKOWNER

◆ LOCALLOCKTAG

◆ LOCK

◆ LockData

◆ LockInstanceData

◆ LockMethod

◆ LockMethodData

◆ LOCKMETHODID

◆ LOCKTAG

◆ LockTagType

◆ PGPROC

◆ PROCLOCK

◆ PROCLOCKTAG

Enumeration Type Documentation

◆ DeadLockState

◆ LockAcquireResult

◆ LockTagType

Function Documentation

◆ AbortStrongLockAcquire()

◆ AtPrepare_Locks()

◆ DeadLockCheck()

◆ DeadLockReport()

◆ DoLockModesConflict()

◆ GetAwaitedLock()

◆ GetBlockerStatusData()

◆ GetBlockingAutoVacuumPgproc()

◆ GetLockConflicts()

◆ GetLockmodeName()

◆ GetLocksMethodTable()

◆ GetLockStatusData()

◆ GetLockTagsMethodTable()

◆ GetRunningTransactionLocks()

◆ GrantAwaitedLock()

◆ GrantLock()

◆ InitDeadLockChecking()

◆ InitLockManagerAccess()