#include "postgres.h"
#include <signal.h>
#include <unistd.h>
#include "access/transam.h"
#include "access/twophase.h"
#include "access/twophase_rmgr.h"
#include "access/xact.h"
#include "access/xlog.h"
#include "miscadmin.h"
#include "pg_trace.h"
#include "pgstat.h"
#include "storage/proc.h"
#include "storage/procarray.h"
#include "storage/sinvaladt.h"
#include "storage/spin.h"
#include "storage/standby.h"
#include "utils/memutils.h"
#include "utils/ps_status.h"
#include "utils/resowner_private.h"

Include dependency graph for lock.c:

Data Structures
struct	TwoPhaseLockRecord

struct	FastPathStrongRelationLockData

Macros
#define	NLOCKENTS() mul_size(max_locks_per_xact, add_size(MaxBackends, max_prepared_xacts))

#define	FAST_PATH_BITS_PER_SLOT 3

#define	FAST_PATH_LOCKNUMBER_OFFSET 1

#define	FAST_PATH_MASK ((1 << FAST_PATH_BITS_PER_SLOT) - 1)

#define	FAST_PATH_GET_BITS(proc, n) (((proc)->fpLockBits >> (FAST_PATH_BITS_PER_SLOT * n)) & FAST_PATH_MASK)

#define	FAST_PATH_BIT_POSITION(n, l)

#define	FAST_PATH_SET_LOCKMODE(proc, n, l) (proc)->fpLockBits \|= UINT64CONST(1) << FAST_PATH_BIT_POSITION(n, l)

#define	FAST_PATH_CLEAR_LOCKMODE(proc, n, l) (proc)->fpLockBits &= ~(UINT64CONST(1) << FAST_PATH_BIT_POSITION(n, l))

#define	FAST_PATH_CHECK_LOCKMODE(proc, n, l) ((proc)->fpLockBits & (UINT64CONST(1) << FAST_PATH_BIT_POSITION(n, l)))

#define	EligibleForRelationFastPath(locktag, mode)

#define	ConflictsWithRelationFastPath(locktag, mode)

#define	FAST_PATH_STRONG_LOCK_HASH_BITS 10

#define	FAST_PATH_STRONG_LOCK_HASH_PARTITIONS (1 << FAST_PATH_STRONG_LOCK_HASH_BITS)

#define	FastPathStrongLockHashPartition(hashcode) ((hashcode) % FAST_PATH_STRONG_LOCK_HASH_PARTITIONS)

#define	LOCK_PRINT(where, lock, type) ((void) 0)

#define	PROCLOCK_PRINT(where, proclockP) ((void) 0)

Typedefs
typedef struct TwoPhaseLockRecord	TwoPhaseLockRecord

Functions
static bool	FastPathGrantRelationLock (Oid relid, LOCKMODE lockmode)

static bool	FastPathUnGrantRelationLock (Oid relid, LOCKMODE lockmode)

static bool	FastPathTransferRelationLocks (LockMethod lockMethodTable, const LOCKTAG *locktag, uint32 hashcode)

static PROCLOCK *	FastPathGetRelationLockEntry (LOCALLOCK *locallock)

static uint32	proclock_hash (const void *key, Size keysize)

static void	RemoveLocalLock (LOCALLOCK *locallock)

static PROCLOCK *	SetupLockInTable (LockMethod lockMethodTable, PGPROC proc, const LOCKTAG locktag, uint32 hashcode, LOCKMODE lockmode)

static void	GrantLockLocal (LOCALLOCK *locallock, ResourceOwner owner)

static void	BeginStrongLockAcquire (LOCALLOCK *locallock, uint32 fasthashcode)

static void	FinishStrongLockAcquire (void)

static void	WaitOnLock (LOCALLOCK *locallock, ResourceOwner owner)

static void	ReleaseLockIfHeld (LOCALLOCK *locallock, bool sessionLock)

static void	LockReassignOwner (LOCALLOCK *locallock, ResourceOwner parent)

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

static void	CleanUpLock (LOCK lock, PROCLOCK proclock, LockMethod lockMethodTable, uint32 hashcode, bool wakeupNeeded)

static void	LockRefindAndRelease (LockMethod lockMethodTable, PGPROC proc, LOCKTAG locktag, LOCKMODE lockmode, bool decrement_strong_lock_count)

static void	GetSingleProcBlockerStatusData (PGPROC blocked_proc, BlockedProcsData data)

void	InitLocks (void)

LockMethod	GetLocksMethodTable (const LOCK *lock)

LockMethod	GetLockTagsMethodTable (const LOCKTAG *locktag)

uint32	LockTagHashCode (const LOCKTAG *locktag)

static uint32	ProcLockHashCode (const PROCLOCKTAG *proclocktag, uint32 hashcode)

bool	DoLockModesConflict (LOCKMODE mode1, LOCKMODE mode2)

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

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

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

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

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

void	AbortStrongLockAcquire (void)

void	GrantAwaitedLock (void)

void	RemoveFromWaitQueue (PGPROC *proc, uint32 hashcode)

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)

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

void	AtPrepare_Locks (void)

void	PostPrepare_Locks (TransactionId xid)

Size	LockShmemSize (void)

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_standby_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	VirtualXactLockTableInsert (VirtualTransactionId vxid)

void	VirtualXactLockTableCleanup (void)

bool	VirtualXactLock (VirtualTransactionId vxid, bool wait)

int	LockWaiterCount (const LOCKTAG *locktag)

Variables
int	max_locks_per_xact

static const LOCKMASK	LockConflicts []

static const char *const	lock_mode_names []

static bool	Dummy_trace = false

static const LockMethodData	default_lockmethod

static const LockMethodData	user_lockmethod

static const LockMethod	LockMethods []

static int	FastPathLocalUseCount = 0

static volatile FastPathStrongRelationLockData *	FastPathStrongRelationLocks

static HTAB *	LockMethodLockHash

static HTAB *	LockMethodProcLockHash

static HTAB *	LockMethodLocalHash

static LOCALLOCK *	StrongLockInProgress

static LOCALLOCK *	awaitedLock

static ResourceOwner	awaitedOwner

Macro Definition Documentation

#define ConflictsWithRelationFastPath	(	locktag,
		mode
	)

Value:

((locktag)->locktag_lockmethodid == DEFAULT_LOCKMETHOD && \
    (locktag)->locktag_type == LOCKTAG_RELATION && \
    (locktag)->locktag_field1 != InvalidOid && \
    (mode) > ShareUpdateExclusiveLock)

Definition at line 205 of file lock.c.

Referenced by GetLockConflicts(), lock_twophase_recover(), LockAcquireExtended(), and LockRefindAndRelease().

#define EligibleForRelationFastPath	(	locktag,
		mode
	)

Value:

((locktag)->locktag_lockmethodid == DEFAULT_LOCKMETHOD && \
    (locktag)->locktag_type == LOCKTAG_RELATION && \
    (locktag)->locktag_field1 == MyDatabaseId && \
    MyDatabaseId != InvalidOid && \
    (mode) < ShareUpdateExclusiveLock)

Definition at line 199 of file lock.c.

Referenced by LockAcquireExtended(), LockRelease(), and LockReleaseAll().

#define FAST_PATH_BIT_POSITION	(	n,
		l
	)

Value:

(AssertMacro((l) >= FAST_PATH_LOCKNUMBER_OFFSET), \
	 AssertMacro((l) < FAST_PATH_BITS_PER_SLOT+FAST_PATH_LOCKNUMBER_OFFSET), \
	 AssertMacro((n) < FP_LOCK_SLOTS_PER_BACKEND), \
     ((l) - FAST_PATH_LOCKNUMBER_OFFSET + FAST_PATH_BITS_PER_SLOT * (n)))

Definition at line 179 of file lock.c.

#define FAST_PATH_BITS_PER_SLOT 3

Definition at line 174 of file lock.c.

Referenced by FastPathTransferRelationLocks().

#define FAST_PATH_CHECK_LOCKMODE	(	proc,
		n,
		l
	)	((proc)->fpLockBits & (UINT64CONST(1) << FAST_PATH_BIT_POSITION(n, l)))

Definition at line 188 of file lock.c.

Referenced by FastPathGetRelationLockEntry(), FastPathGrantRelationLock(), FastPathTransferRelationLocks(), and FastPathUnGrantRelationLock().

#define FAST_PATH_CLEAR_LOCKMODE	(	proc,
		n,
		l
	)	(proc)->fpLockBits &= ~(UINT64CONST(1) << FAST_PATH_BIT_POSITION(n, l))

Definition at line 186 of file lock.c.

Referenced by FastPathGetRelationLockEntry(), FastPathTransferRelationLocks(), and FastPathUnGrantRelationLock().

#define FAST_PATH_GET_BITS	(	proc,
		n
	)	(((proc)->fpLockBits >> (FAST_PATH_BITS_PER_SLOT * n)) & FAST_PATH_MASK)

Definition at line 177 of file lock.c.

Referenced by FastPathGetRelationLockEntry(), FastPathGrantRelationLock(), FastPathTransferRelationLocks(), FastPathUnGrantRelationLock(), GetLockConflicts(), and GetLockStatusData().

#define FAST_PATH_LOCKNUMBER_OFFSET 1

Definition at line 175 of file lock.c.

Referenced by FastPathTransferRelationLocks(), GetLockConflicts(), and GetLockStatusData().

#define FAST_PATH_MASK ((1 << FAST_PATH_BITS_PER_SLOT) - 1)

Definition at line 176 of file lock.c.

#define FAST_PATH_SET_LOCKMODE	(	proc,
		n,
		l
	)	(proc)->fpLockBits \|= UINT64CONST(1) << FAST_PATH_BIT_POSITION(n, l)

Definition at line 184 of file lock.c.

Referenced by FastPathGrantRelationLock().

#define FAST_PATH_STRONG_LOCK_HASH_BITS 10

Definition at line 232 of file lock.c.

#define FAST_PATH_STRONG_LOCK_HASH_PARTITIONS (1 << FAST_PATH_STRONG_LOCK_HASH_BITS)

Definition at line 233 of file lock.c.

#define FastPathStrongLockHashPartition ( hashcode ) ((hashcode) % FAST_PATH_STRONG_LOCK_HASH_PARTITIONS)

Definition at line 235 of file lock.c.

Referenced by AbortStrongLockAcquire(), lock_twophase_recover(), LockAcquireExtended(), LockRefindAndRelease(), and RemoveLocalLock().

#define LOCK_PRINT	(	where,
		lock,
		type
	)	((void) 0)

Definition at line 337 of file lock.c.

Referenced by CleanUpLock(), GrantLock(), lock_twophase_recover(), LockAcquireExtended(), LockHasWaiters(), LockRelease(), LockReleaseAll(), PostPrepare_Locks(), SetupLockInTable(), UnGrantLock(), and WaitOnLock().

#define NLOCKENTS ( ) mul_size(max_locks_per_xact, add_size(MaxBackends, max_prepared_xacts))

Definition at line 56 of file lock.c.

Referenced by InitLocks(), and LockShmemSize().

#define PROCLOCK_PRINT	(	where,
		proclockP
	)	((void) 0)

Definition at line 338 of file lock.c.

Referenced by CleanUpLock(), lock_twophase_recover(), LockAcquireExtended(), LockCheckConflicts(), LockHasWaiters(), LockRefindAndRelease(), LockRelease(), LockReleaseAll(), PostPrepare_Locks(), SetupLockInTable(), and UnGrantLock().

Typedef Documentation

typedef struct TwoPhaseLockRecord TwoPhaseLockRecord

Function Documentation

void AbortStrongLockAcquire ( void )

Definition at line 1614 of file lock.c.

References Assert, FastPathStrongRelationLockData::count, FALSE, FastPathStrongLockHashPartition, LOCALLOCK::hashcode, LOCALLOCK::holdsStrongLockCount, FastPathStrongRelationLockData::mutex, SpinLockAcquire, SpinLockRelease, StrongLockInProgress, and TRUE.

Referenced by LockAcquireExtended(), and LockErrorCleanup().

 {
     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);
 }

void AtPrepare_Locks ( void )

Definition at line 3059 of file lock.c.

References ereport, errcode(), errmsg(), ERROR, FALSE, FastPathGetRelationLockEntry(), hash_seq_init(), hash_seq_search(), LOCALLOCK::holdsStrongLockCount, i, LOCALLOCKTAG::lock, LOCALLOCK::lock, TwoPhaseLockRecord::lockmode, LOCALLOCK::lockOwners, TwoPhaseLockRecord::locktag, LOCKTAG::locktag_type, LOCKTAG_VIRTUALTRANSACTION, LOCALLOCKTAG::mode, PROCLOCKTAG::myLock, LOCALLOCK::nLocks, LOCALLOCK::numLockOwners, LOCALLOCK::proclock, RegisterTwoPhaseRecord(), status(), PROCLOCK::tag, LOCALLOCK::tag, and TWOPHASE_RM_LOCK_ID.

Referenced by PrepareTransaction().

 {
     HASH_SEQ_STATUS status;
     LOCALLOCK  *locallock;
 
     /*
      * For the most part, we don't need to touch shared memory for this ---
      * all the necessary state information is in the locallock table.
      * Fast-path locks are an exception, however: we move any such locks to
      * the main table before allowing PREPARE TRANSACTION to succeed.
      */
     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;
 
         /*
          * If we have both session- and transaction-level locks, fail.  This
          * should never happen with regular locks, since we only take those at
          * session level in some special operations like VACUUM.  It's
          * possible to hit this with advisory locks, though.
          *
          * It would be nice if we could keep the session hold and give away
          * the transactional hold to the prepared xact.  However, that would
          * require two PROCLOCK objects, and we cannot be sure that another
          * PROCLOCK will be available when it comes time for PostPrepare_Locks
          * to do the deed.  So for now, we error out while we can still do so
          * safely.
          */
         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));
     }
 }

static void BeginStrongLockAcquire	(	LOCALLOCK *	locallock,
		uint32	fasthashcode
	)

static

Definition at line 1578 of file lock.c.

References Assert, FastPathStrongRelationLockData::count, FALSE, LOCALLOCK::holdsStrongLockCount, FastPathStrongRelationLockData::mutex, SpinLockAcquire, SpinLockRelease, and TRUE.

Referenced by LockAcquireExtended().

 {
     Assert(StrongLockInProgress == NULL);
     Assert(locallock->holdsStrongLockCount == FALSE);
 
     /*
      * Adding to a memory location is not atomic, so we take a spinlock to
      * ensure we don't collide with someone else trying to bump the count at
      * the same time.
      *
      * XXX: It might be worth considering using an atomic fetch-and-add
      * instruction here, on architectures where that is supported.
      */
 
     SpinLockAcquire(&FastPathStrongRelationLocks->mutex);
     FastPathStrongRelationLocks->count[fasthashcode]++;
     locallock->holdsStrongLockCount = TRUE;
     StrongLockInProgress = locallock;
     SpinLockRelease(&FastPathStrongRelationLocks->mutex);
 }

static void CleanUpLock	(	LOCK *	lock,
		PROCLOCK *	proclock,
		LockMethod	lockMethodTable,
		uint32	hashcode,
		bool	wakeupNeeded
	)

static

Definition at line 1495 of file lock.c.

References Assert, elog, HASH_REMOVE, hash_search_with_hash_value(), PROCLOCK::holdMask, LOCK_PRINT, PROCLOCK::lockLink, LOCK::nRequested, PANIC, PROCLOCK::procLink, PROCLOCK_PRINT, ProcLockHashCode(), LOCK::procLocks, ProcLockWakeup(), SHMQueueDelete(), SHMQueueEmpty(), LOCK::tag, and PROCLOCK::tag.

Referenced by LockRefindAndRelease(), LockRelease(), LockReleaseAll(), and RemoveFromWaitQueue().

 {
     /*
      * If this was my last hold on this lock, delete my entry in the proclock
      * table.
      */
     if (proclock->holdMask == 0)
     {
         uint32      proclock_hashcode;
 
         PROCLOCK_PRINT("CleanUpLock: deleting", proclock);
         SHMQueueDelete(&proclock->lockLink);
         SHMQueueDelete(&proclock->procLink);
         proclock_hashcode = ProcLockHashCode(&proclock->tag, hashcode);
         if (!hash_search_with_hash_value(LockMethodProcLockHash,
                                          (void *) &(proclock->tag),
                                          proclock_hashcode,
                                          HASH_REMOVE,
                                          NULL))
             elog(PANIC, "proclock table corrupted");
     }
 
     if (lock->nRequested == 0)
     {
         /*
          * The caller just released the last lock, so garbage-collect the lock
          * object.
          */
         LOCK_PRINT("CleanUpLock: deleting", lock, 0);
         Assert(SHMQueueEmpty(&(lock->procLocks)));
         if (!hash_search_with_hash_value(LockMethodLockHash,
                                          (void *) &(lock->tag),
                                          hashcode,
                                          HASH_REMOVE,
                                          NULL))
             elog(PANIC, "lock table corrupted");
     }
     else if (wakeupNeeded)
     {
         /* There are waiters on this lock, so wake them up. */
         ProcLockWakeup(lockMethodTable, lock);
     }
 }

bool DoLockModesConflict	(	LOCKMODE	mode1,
		LOCKMODE	mode2
	)

Definition at line 556 of file lock.c.

References LockMethodData::conflictTab, DEFAULT_LOCKMETHOD, and LOCKBIT_ON.

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

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

static PROCLOCK * FastPathGetRelationLockEntry ( LOCALLOCK * locallock )

static

Definition at line 2644 of file lock.c.

References PGPROC::backendLock, DEFAULT_LOCKMETHOD, elog, ereport, errcode(), errhint(), errmsg(), ERROR, FAST_PATH_CHECK_LOCKMODE, FAST_PATH_CLEAR_LOCKMODE, FAST_PATH_GET_BITS, FP_LOCK_SLOTS_PER_BACKEND, PGPROC::fpRelId, GrantLock(), HASH_FIND, hash_search_with_hash_value(), LOCALLOCK::hashcode, LOCALLOCKTAG::lock, LockHashPartitionLock, LOCKTAG::locktag_field2, LW_EXCLUSIVE, LW_SHARED, LWLockAcquire(), LWLockRelease(), LOCALLOCKTAG::mode, PROCLOCKTAG::myLock, MyProc, PROCLOCKTAG::myProc, ProcLockHashCode(), SetupLockInTable(), PROCLOCK::tag, and LOCALLOCK::tag.

Referenced by AtPrepare_Locks().

 {
     LockMethod  lockMethodTable = LockMethods[DEFAULT_LOCKMETHOD];
     LOCKTAG    *locktag = &locallock->tag.lock;
     PROCLOCK   *proclock = NULL;
     LWLock     *partitionLock = LockHashPartitionLock(locallock->hashcode);
     Oid         relid = locktag->locktag_field2;
     uint32      f;
 
     LWLockAcquire(&MyProc->backendLock, LW_EXCLUSIVE);
 
     for (f = 0; f < FP_LOCK_SLOTS_PER_BACKEND; f++)
     {
         uint32      lockmode;
 
         /* Look for an allocated slot matching the given relid. */
         if (relid != MyProc->fpRelId[f] || FAST_PATH_GET_BITS(MyProc, f) == 0)
             continue;
 
         /* If we don't have a lock of the given mode, forget it! */
         lockmode = locallock->tag.mode;
         if (!FAST_PATH_CHECK_LOCKMODE(MyProc, f, lockmode))
             break;
 
         /* Find or create lock object. */
         LWLockAcquire(partitionLock, LW_EXCLUSIVE);
 
         proclock = SetupLockInTable(lockMethodTable, MyProc, locktag,
                                     locallock->hashcode, lockmode);
         if (!proclock)
         {
             LWLockRelease(partitionLock);
             LWLockRelease(&MyProc->backendLock);
             ereport(ERROR,
                     (errcode(ERRCODE_OUT_OF_MEMORY),
                      errmsg("out of shared memory"),
                      errhint("You might need to increase max_locks_per_transaction.")));
         }
         GrantLock(proclock->tag.myLock, proclock, lockmode);
         FAST_PATH_CLEAR_LOCKMODE(MyProc, f, lockmode);
 
         LWLockRelease(partitionLock);
 
         /* No need to examine remaining slots. */
         break;
     }
 
     LWLockRelease(&MyProc->backendLock);
 
     /* Lock may have already been transferred by some other backend. */
     if (proclock == NULL)
     {
         LOCK       *lock;
         PROCLOCKTAG proclocktag;
         uint32      proclock_hashcode;
 
         LWLockAcquire(partitionLock, LW_SHARED);
 
         lock = (LOCK *) hash_search_with_hash_value(LockMethodLockHash,
                                                     (void *) locktag,
                                                     locallock->hashcode,
                                                     HASH_FIND,
                                                     NULL);
         if (!lock)
             elog(ERROR, "failed to re-find shared lock object");
 
         proclocktag.myLock = lock;
         proclocktag.myProc = MyProc;
 
         proclock_hashcode = ProcLockHashCode(&proclocktag, locallock->hashcode);
         proclock = (PROCLOCK *)
             hash_search_with_hash_value(LockMethodProcLockHash,
                                         (void *) &proclocktag,
                                         proclock_hashcode,
                                         HASH_FIND,
                                         NULL);
         if (!proclock)
             elog(ERROR, "failed to re-find shared proclock object");
         LWLockRelease(partitionLock);
     }
 
     return proclock;
 }

static bool FastPathGrantRelationLock	(	Oid	relid,
		LOCKMODE	lockmode
	)

static

Definition at line 2489 of file lock.c.

References Assert, FAST_PATH_CHECK_LOCKMODE, FAST_PATH_GET_BITS, FAST_PATH_SET_LOCKMODE, FastPathLocalUseCount, FP_LOCK_SLOTS_PER_BACKEND, PGPROC::fpRelId, and MyProc.

Referenced by LockAcquireExtended().

 {
     uint32      f;
     uint32      unused_slot = FP_LOCK_SLOTS_PER_BACKEND;
 
     /* Scan for existing entry for this relid, remembering empty slot. */
     for (f = 0; f < FP_LOCK_SLOTS_PER_BACKEND; f++)
     {
         if (FAST_PATH_GET_BITS(MyProc, f) == 0)
             unused_slot = f;
         else if (MyProc->fpRelId[f] == relid)
         {
             Assert(!FAST_PATH_CHECK_LOCKMODE(MyProc, f, lockmode));
             FAST_PATH_SET_LOCKMODE(MyProc, f, lockmode);
             return true;
         }
     }
 
     /* If no existing entry, use any empty slot. */
     if (unused_slot < FP_LOCK_SLOTS_PER_BACKEND)
     {
         MyProc->fpRelId[unused_slot] = relid;
         FAST_PATH_SET_LOCKMODE(MyProc, unused_slot, lockmode);
         ++FastPathLocalUseCount;
         return true;
     }
 
     /* No existing entry, and no empty slot. */
     return false;
 }

static bool FastPathTransferRelationLocks	(	LockMethod	lockMethodTable,
		const LOCKTAG *	locktag,
		uint32	hashcode
	)

static

Definition at line 2556 of file lock.c.

References PROC_HDR::allProcCount, PROC_HDR::allProcs, PGPROC::backendLock, PGPROC::databaseId, FAST_PATH_BITS_PER_SLOT, FAST_PATH_CHECK_LOCKMODE, FAST_PATH_CLEAR_LOCKMODE, FAST_PATH_GET_BITS, FAST_PATH_LOCKNUMBER_OFFSET, FP_LOCK_SLOTS_PER_BACKEND, PGPROC::fpRelId, GrantLock(), i, LockHashPartitionLock, LOCKTAG::locktag_field1, LOCKTAG::locktag_field2, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), PROCLOCKTAG::myLock, ProcGlobal, SetupLockInTable(), and PROCLOCK::tag.

Referenced by LockAcquireExtended().

 {
     LWLock     *partitionLock = LockHashPartitionLock(hashcode);
     Oid         relid = locktag->locktag_field2;
     uint32      i;
 
     /*
      * Every PGPROC that can potentially hold a fast-path lock is present in
      * ProcGlobal->allProcs.  Prepared transactions are not, but any
      * outstanding fast-path locks held by prepared transactions are
      * transferred to the main lock table.
      */
     for (i = 0; i < ProcGlobal->allProcCount; i++)
     {
         PGPROC     *proc = &ProcGlobal->allProcs[i];
         uint32      f;
 
         LWLockAcquire(&proc->backendLock, LW_EXCLUSIVE);
 
         /*
          * 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.
          *
          * proc->databaseId is set at backend startup time and never changes
          * thereafter, so it might be safe to perform this test before
          * acquiring &proc->backendLock.  In particular, it's certainly safe
          * to assume that if the target backend holds any fast-path locks, it
          * must have performed a memory-fencing operation (in particular, an
          * LWLock acquisition) since setting proc->databaseId.  However, it's
          * less clear that our backend is certain to have performed a memory
          * fencing operation since the other backend set proc->databaseId.  So
          * for now, we test it after acquiring the LWLock just to be safe.
          */
         if (proc->databaseId != locktag->locktag_field1)
         {
             LWLockRelease(&proc->backendLock);
             continue;
         }
 
         for (f = 0; f < FP_LOCK_SLOTS_PER_BACKEND; f++)
         {
             uint32      lockmode;
 
             /* Look for an allocated slot matching the given relid. */
             if (relid != proc->fpRelId[f] || FAST_PATH_GET_BITS(proc, f) == 0)
                 continue;
 
             /* Find or create lock object. */
             LWLockAcquire(partitionLock, LW_EXCLUSIVE);
             for (lockmode = FAST_PATH_LOCKNUMBER_OFFSET;
                  lockmode < FAST_PATH_LOCKNUMBER_OFFSET + FAST_PATH_BITS_PER_SLOT;
                  ++lockmode)
             {
                 PROCLOCK   *proclock;
 
                 if (!FAST_PATH_CHECK_LOCKMODE(proc, f, lockmode))
                     continue;
                 proclock = SetupLockInTable(lockMethodTable, proc, locktag,
                                             hashcode, lockmode);
                 if (!proclock)
                 {
                     LWLockRelease(partitionLock);
                     LWLockRelease(&proc->backendLock);
                     return false;
                 }
                 GrantLock(proclock->tag.myLock, proclock, lockmode);
                 FAST_PATH_CLEAR_LOCKMODE(proc, f, lockmode);
             }
             LWLockRelease(partitionLock);
 
             /* No need to examine remaining slots. */
             break;
         }
         LWLockRelease(&proc->backendLock);
     }
     return true;
 }

static bool FastPathUnGrantRelationLock	(	Oid	relid,
		LOCKMODE	lockmode
	)

static

Definition at line 2526 of file lock.c.

References Assert, FAST_PATH_CHECK_LOCKMODE, FAST_PATH_CLEAR_LOCKMODE, FAST_PATH_GET_BITS, FastPathLocalUseCount, FP_LOCK_SLOTS_PER_BACKEND, PGPROC::fpRelId, and MyProc.

Referenced by LockRelease(), and LockReleaseAll().

 {
     uint32      f;
     bool        result = false;
 
     FastPathLocalUseCount = 0;
     for (f = 0; f < FP_LOCK_SLOTS_PER_BACKEND; f++)
     {
         if (MyProc->fpRelId[f] == relid
             && FAST_PATH_CHECK_LOCKMODE(MyProc, f, lockmode))
         {
             Assert(!result);
             FAST_PATH_CLEAR_LOCKMODE(MyProc, f, lockmode);
             result = true;
             /* we continue iterating so as to update FastPathLocalUseCount */
         }
         if (FAST_PATH_GET_BITS(MyProc, f) != 0)
             ++FastPathLocalUseCount;
     }
     return result;
 }

static void FinishStrongLockAcquire ( void )

static

Definition at line 1604 of file lock.c.

Referenced by LockAcquireExtended().

 {
     StrongLockInProgress = NULL;
 }

BlockedProcsData* GetBlockerStatusData ( int blocked_pid )

Definition at line 3582 of file lock.c.

Referenced by pg_blocking_pids().

 {
     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;
 }

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

Definition at line 2745 of file lock.c.

References PROC_HDR::allProcCount, PROC_HDR::allProcs, VirtualTransactionId::backendId, PGPROC::backendLock, ConflictsWithRelationFastPath, LockMethodData::conflictTab, PGPROC::databaseId, elog, ERROR, FAST_PATH_GET_BITS, FAST_PATH_LOCKNUMBER_OFFSET, FP_LOCK_SLOTS_PER_BACKEND, PGPROC::fpRelId, GET_VXID_FROM_PGPROC, HASH_FIND, hash_search_with_hash_value(), PROCLOCK::holdMask, i, InHotStandby, InvalidBackendId, InvalidLocalTransactionId, lengthof, VirtualTransactionId::localTransactionId, LockHashPartitionLock, PROCLOCK::lockLink, LOCKTAG::locktag_field1, LOCKTAG::locktag_field2, LOCKTAG::locktag_lockmethodid, LockTagHashCode(), LW_SHARED, LWLockAcquire(), LWLockRelease(), MaxBackends, MemoryContextAlloc(), MyProc, PROCLOCKTAG::myProc, LockMethodData::numLockModes, offsetof, palloc0(), PANIC, ProcGlobal, LOCK::procLocks, SHMQueueNext(), PROCLOCK::tag, TopMemoryContext, VirtualTransactionIdEquals, and VirtualTransactionIdIsValid.

Referenced by ResolveRecoveryConflictWithLock(), and WaitForLockersMultiple().

 {
     static VirtualTransactionId *vxids;
     LOCKMETHODID lockmethodid = locktag->locktag_lockmethodid;
     LockMethod  lockMethodTable;
     LOCK       *lock;
     LOCKMASK    conflictMask;
     SHM_QUEUE  *procLocks;
     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 + a terminator, since prepared xacts
      * don't count. InHotStandby allocate once in TopMemoryContext.
      */
     if (InHotStandby)
     {
         if (vxids == NULL)
             vxids = (VirtualTransactionId *)
                 MemoryContextAlloc(TopMemoryContext,
                                    sizeof(VirtualTransactionId) * (MaxBackends + 1));
     }
     else
         vxids = (VirtualTransactionId *)
             palloc0(sizeof(VirtualTransactionId) * (MaxBackends + 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;
 
         /*
          * 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      f;
 
             /* A backend never blocks itself */
             if (proc == MyProc)
                 continue;
 
             LWLockAcquire(&proc->backendLock, 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 FastPathTransferLocks() for discussion of why we do this
              * test after acquiring the lock.
              */
             if (proc->databaseId != locktag->locktag_field1)
             {
                 LWLockRelease(&proc->backendLock);
                 continue;
             }
 
             for (f = 0; f < FP_LOCK_SLOTS_PER_BACKEND; f++)
             {
                 uint32      lockmask;
 
                 /* 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 we see an invalid VXID, then either the xact has already
                  * committed (or aborted), or it's a prepared xact.  In either
                  * case we may ignore it.
                  */
                 if (VirtualTransactionIdIsValid(vxid))
                     vxids[count++] = vxid;
 
                 /* No need to examine remaining slots. */
                 break;
             }
 
             LWLockRelease(&proc->backendLock);
         }
     }
 
     /* 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,
                                                 (const void *) 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].backendId = InvalidBackendId;
         vxids[count].localTransactionId = InvalidLocalTransactionId;
         return vxids;
     }
 
     /*
      * Examine each existing holder (or awaiter) of the lock.
      */
 
     procLocks = &(lock->procLocks);
 
     proclock = (PROCLOCK *) SHMQueueNext(procLocks, procLocks,
                                          offsetof(PROCLOCK, lockLink));
 
     while (proclock)
     {
         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 we see an invalid VXID, then either the xact has already
                  * committed (or aborted), or it's a prepared xact.  In either
                  * case we may ignore it.
                  */
                 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;
                 }
             }
         }
 
         proclock = (PROCLOCK *) SHMQueueNext(procLocks, &proclock->lockLink,
                                              offsetof(PROCLOCK, lockLink));
     }
 
     LWLockRelease(partitionLock);
 
     if (count > MaxBackends)    /* should never happen */
         elog(PANIC, "too many conflicting locks found");
 
     vxids[count].backendId = InvalidBackendId;
     vxids[count].localTransactionId = InvalidLocalTransactionId;
     return vxids;
 }

const char* GetLockmodeName	(	LOCKMETHODID	lockmethodid,
		LOCKMODE	mode
	)

Definition at line 3845 of file lock.c.

References Assert, lengthof, and LockMethodData::lockModeNames.

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

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

LockMethod GetLocksMethodTable ( const LOCK * lock )

Definition at line 460 of file lock.c.

References Assert, lengthof, and LOCK_LOCKMETHOD.

Referenced by DeadLockCheck(), and FindLockCycleRecurseMember().

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

LockData* GetLockStatusData ( void )

Definition at line 3398 of file lock.c.

References PROC_HDR::allProcCount, PROC_HDR::allProcs, Assert, LockInstanceData::backend, VirtualTransactionId::backendId, PGPROC::backendId, PGPROC::backendLock, PGPROC::databaseId, ExclusiveLock, FAST_PATH_GET_BITS, FAST_PATH_LOCKNUMBER_OFFSET, LockInstanceData::fastpath, FP_LOCK_SLOTS_PER_BACKEND, PGPROC::fpLocalTransactionId, PGPROC::fpRelId, PGPROC::fpVXIDLock, PROCLOCK::groupLeader, hash_get_num_entries(), hash_seq_init(), hash_seq_search(), PROCLOCK::holdMask, LockInstanceData::holdMask, i, LockInstanceData::leaderPid, VirtualTransactionId::localTransactionId, LOCKBIT_ON, LockHashPartitionLockByIndex, LockData::locks, LockInstanceData::locktag, LW_SHARED, LWLockAcquire(), LWLockRelease(), PGPROC::lxid, LockInstanceData::lxid, MaxBackends, PROCLOCKTAG::myLock, PROCLOCKTAG::myProc, LockData::nelements, NoLock, NUM_LOCK_PARTITIONS, palloc(), PGPROC::pid, LockInstanceData::pid, ProcGlobal, repalloc(), SET_LOCKTAG_RELATION, SET_LOCKTAG_VIRTUALTRANSACTION, LOCK::tag, PROCLOCK::tag, PGPROC::waitLock, PGPROC::waitLockMode, and LockInstanceData::waitLockMode.

Referenced by pg_lock_status().

 {
     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];
         uint32      f;
 
         LWLockAcquire(&proc->backendLock, LW_SHARED);
 
         for (f = 0; f < FP_LOCK_SLOTS_PER_BACKEND; ++f)
         {
             LockInstanceData *instance;
             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->backend = proc->backendId;
             instance->lxid = proc->lxid;
             instance->pid = proc->pid;
             instance->leaderPid = proc->pid;
             instance->fastpath = true;
 
             el++;
         }
 
         if (proc->fpVXIDLock)
         {
             VirtualTransactionId vxid;
             LockInstanceData *instance;
 
             if (el >= els)
             {
                 els += MaxBackends;
                 data->locks = (LockInstanceData *)
                     repalloc(data->locks, sizeof(LockInstanceData) * els);
             }
 
             vxid.backendId = proc->backendId;
             vxid.localTransactionId = proc->fpLocalTransactionId;
 
             instance = &data->locks[el];
             SET_LOCKTAG_VIRTUALTRANSACTION(instance->locktag, vxid);
             instance->holdMask = LOCKBIT_ON(ExclusiveLock);
             instance->waitLockMode = NoLock;
             instance->backend = proc->backendId;
             instance->lxid = proc->lxid;
             instance->pid = proc->pid;
             instance->leaderPid = proc->pid;
             instance->fastpath = true;
 
             el++;
         }
 
         LWLockRelease(&proc->backendLock);
     }
 
     /*
      * 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->backend = proc->backendId;
         instance->lxid = proc->lxid;
         instance->pid = proc->pid;
         instance->leaderPid = proclock->groupLeader->pid;
         instance->fastpath = false;
 
         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;
 }

LockMethod GetLockTagsMethodTable ( const LOCKTAG * locktag )

Definition at line 472 of file lock.c.

References Assert, lengthof, and LOCKTAG::locktag_lockmethodid.

Referenced by pg_blocking_pids().

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

xl_standby_lock* GetRunningTransactionLocks ( int * nlocks )

Definition at line 3762 of file lock.c.

References AccessExclusiveLock, PROC_HDR::allPgXact, Assert, xl_standby_lock::dbOid, hash_get_num_entries(), hash_seq_init(), hash_seq_search(), PROCLOCK::holdMask, i, LOCKBIT_ON, LockHashPartitionLockByIndex, LOCKTAG::locktag_field1, LOCKTAG::locktag_field2, LOCKTAG_RELATION, LOCKTAG::locktag_type, LW_SHARED, LWLockAcquire(), LWLockRelease(), PROCLOCKTAG::myLock, PROCLOCKTAG::myProc, NUM_LOCK_PARTITIONS, palloc(), PGPROC::pgprocno, ProcGlobal, xl_standby_lock::relOid, LOCK::tag, PROCLOCK::tag, TransactionIdIsValid, xl_standby_lock::xid, and PGXACT::xid.

Referenced by LogStandbySnapshot().

 {
     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;
             PGXACT     *pgxact = &ProcGlobal->allPgXact[proc->pgprocno];
             LOCK       *lock = proclock->tag.myLock;
             TransactionId xid = pgxact->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;
 }

static void GetSingleProcBlockerStatusData	(	PGPROC *	blocked_proc,
		BlockedProcsData *	data
	)

static

Definition at line 3662 of file lock.c.

Referenced by GetBlockerStatusData().

 {
     LOCK       *theLock = blocked_proc->waitLock;
     BlockedProcData *bproc;
     SHM_QUEUE  *procLocks;
     PROCLOCK   *proclock;
     PROC_QUEUE *waitQueue;
     PGPROC     *proc;
     int         queue_size;
     int         i;
 
     /* Nothing to do if this proc is not blocked */
     if (theLock == NULL)
         return;
 
     /* Set up a procs[] element */
     bproc = &data->procs[data->nprocs++];
     bproc->pid = blocked_proc->pid;
     bproc->first_lock = data->nlocks;
     bproc->first_waiter = data->npids;
 
     /*
      * We may ignore the proc's fast-path arrays, since nothing in those could
      * be related to a contended lock.
      */
 
     /* Collect all PROCLOCKs associated with theLock */
     procLocks = &(theLock->procLocks);
     proclock = (PROCLOCK *) SHMQueueNext(procLocks, procLocks,
                                          offsetof(PROCLOCK, lockLink));
     while (proclock)
     {
         PGPROC     *proc = proclock->tag.myProc;
         LOCK       *lock = proclock->tag.myLock;
         LockInstanceData *instance;
 
         if (data->nlocks >= data->maxlocks)
         {
             data->maxlocks += MaxBackends;
             data->locks = (LockInstanceData *)
                 repalloc(data->locks, sizeof(LockInstanceData) * data->maxlocks);
         }
 
         instance = &data->locks[data->nlocks];
         memcpy(&instance->locktag, &lock->tag, sizeof(LOCKTAG));
         instance->holdMask = proclock->holdMask;
         if (proc->waitLock == lock)
             instance->waitLockMode = proc->waitLockMode;
         else
             instance->waitLockMode = NoLock;
         instance->backend = proc->backendId;
         instance->lxid = proc->lxid;
         instance->pid = proc->pid;
         instance->leaderPid = proclock->groupLeader->pid;
         instance->fastpath = false;
         data->nlocks++;
 
         proclock = (PROCLOCK *) SHMQueueNext(procLocks, &proclock->lockLink,
                                              offsetof(PROCLOCK, lockLink));
     }
 
     /* Enlarge waiter_pids[] if it's too small to hold all wait queue PIDs */
     waitQueue = &(theLock->waitProcs);
     queue_size = waitQueue->size;
 
     if (queue_size > data->maxpids - data->npids)
     {
         data->maxpids = Max(data->maxpids + MaxBackends,
                             data->npids + queue_size);
         data->waiter_pids = (int *) repalloc(data->waiter_pids,
                                              sizeof(int) * data->maxpids);
     }
 
     /* Collect PIDs from the lock's wait queue, stopping at blocked_proc */
     proc = (PGPROC *) waitQueue->links.next;
     for (i = 0; i < queue_size; i++)
     {
         if (proc == blocked_proc)
             break;
         data->waiter_pids[data->npids++] = proc->pid;
         proc = (PGPROC *) proc->links.next;
     }
 
     bproc->num_locks = data->nlocks - bproc->first_lock;
     bproc->num_waiters = data->npids - bproc->first_waiter;
 }

void GrantAwaitedLock ( void )

Definition at line 1643 of file lock.c.

References GrantLockLocal().

Referenced by LockErrorCleanup(), and ProcSleep().

 {
     GrantLockLocal(awaitedLock, awaitedOwner);
 }

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

Definition at line 1415 of file lock.c.

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(), lock_twophase_recover(), LockAcquireExtended(), ProcLockWakeup(), ProcSleep(), and VirtualXactLock().

 {
     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);
 }

static void GrantLockLocal	(	LOCALLOCK *	locallock,
		ResourceOwner	owner
	)

static

Definition at line 1549 of file lock.c.

References Assert, i, LOCALLOCK::lockOwners, LOCALLOCK::maxLockOwners, LOCALLOCKOWNER::nLocks, LOCALLOCK::nLocks, LOCALLOCK::numLockOwners, LOCALLOCKOWNER::owner, and ResourceOwnerRememberLock().

Referenced by GrantAwaitedLock(), and LockAcquireExtended().

 {
     LOCALLOCKOWNER *lockOwners = locallock->lockOwners;
     int         i;
 
     Assert(locallock->numLockOwners < locallock->maxLockOwners);
     /* Count the total */
     locallock->nLocks++;
     /* Count the per-owner lock */
     for (i = 0; i < locallock->numLockOwners; i++)
     {
         if (lockOwners[i].owner == owner)
         {
             lockOwners[i].nLocks++;
             return;
         }
     }
     lockOwners[i].owner = owner;
     lockOwners[i].nLocks = 1;
     locallock->numLockOwners++;
     if (owner != NULL)
         ResourceOwnerRememberLock(owner, locallock);
 }

void InitLocks ( void )

Definition at line 377 of file lock.c.

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

Referenced by CreateSharedMemoryAndSemaphores().

 {
     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 LockShmemSize!
      */
     max_table_size = NLOCKENTS();
     init_table_size = max_table_size / 2;
 
     /*
      * Allocate hash table for LOCK structs.  This stores per-locked-object
      * information.
      */
     MemSet(&info, 0, sizeof(info));
     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);
 
     /*
      * Allocate non-shared hash table for LOCALLOCK structs.  This stores lock
      * counts and resource owner information.
      *
      * The non-shared table could already exist in this process (this occurs
      * when the postmaster is recreating shared memory after a backend crash).
      * If so, delete and recreate it.  (We could simply leave it, since it
      * ought to be empty in the postmaster, but for safety let's zap it.)
      */
     if (LockMethodLocalHash)
         hash_destroy(LockMethodLocalHash);
 
     info.keysize = sizeof(LOCALLOCKTAG);
     info.entrysize = sizeof(LOCALLOCK);
 
     LockMethodLocalHash = hash_create("LOCALLOCK hash",
                                       16,
                                       &info,
                                       HASH_ELEM | HASH_BLOBS);
 }

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

Definition at line 4197 of file lock.c.

References lock_twophase_postcommit().

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

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

Definition at line 4171 of file lock.c.

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

Referenced by lock_twophase_postabort().

 {
     TwoPhaseLockRecord *rec = (TwoPhaseLockRecord *) recdata;
     PGPROC     *proc = TwoPhaseGetDummyProc(xid);
     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);
 }

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

Definition at line 3958 of file lock.c.

References Assert, ConflictsWithRelationFastPath, FastPathStrongRelationLockData::count, elog, ereport, errcode(), errhint(), errmsg(), ERROR, FastPathStrongLockHashPartition, LOCK::granted, GrantLock(), LOCK::grantMask, PROCLOCK::groupLeader, HASH_ENTER_NULL, HASH_REMOVE, hash_search_with_hash_value(), PROCLOCK::holdMask, lengthof, LOCK_PRINT, LOCKBIT_ON, PGPROC::lockGroupLeader, LockHashPartition, LockHashPartitionLock, PROCLOCK::lockLink, 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, ProcQueueInit(), PROCLOCK::releaseMask, LOCK::requested, SHMQueueEmpty(), SHMQueueInit(), SHMQueueInsertBefore(), SpinLockAcquire, SpinLockRelease, LOCK::tag, TwoPhaseGetDummyProc(), LOCK::waitMask, and LOCK::waitProcs.

 {
     TwoPhaseLockRecord *rec = (TwoPhaseLockRecord *) recdata;
     PGPROC     *proc = TwoPhaseGetDummyProc(xid);
     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,
                                                 (void *) 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 max_locks_per_transaction.")));
     }
 
     /*
      * if it's a new lock object, initialize it
      */
     if (!found)
     {
         lock->grantMask = 0;
         lock->waitMask = 0;
         SHMQueueInit(&(lock->procLocks));
         ProcQueueInit(&(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,
                                                         (void *) &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(SHMQueueEmpty(&(lock->procLocks)));
             if (!hash_search_with_hash_value(LockMethodLockHash,
                                              (void *) &(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 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 */
         SHMQueueInsertBefore(&lock->procLocks, &proclock->lockLink);
         SHMQueueInsertBefore(&(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);
 }

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

Definition at line 4139 of file lock.c.

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

 {
     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 */ );
     }
 }

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

Definition at line 683 of file lock.c.

References LockAcquireExtended().

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

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

Definition at line 701 of file lock.c.

References AbortStrongLockAcquire(), AccessExclusiveLock, Assert, PGPROC::backendLock, BeginStrongLockAcquire(), ConflictsWithRelationFastPath, LockMethodData::conflictTab, FastPathStrongRelationLockData::count, CurrentResourceOwner, EligibleForRelationFastPath, elog, ereport, errcode(), errhint(), errmsg(), ERROR, FALSE, FastPathGrantRelationLock(), FastPathLocalUseCount, FastPathStrongLockHashPartition, FastPathTransferRelationLocks(), FinishStrongLockAcquire(), FP_LOCK_SLOTS_PER_BACKEND, GrantLock(), GrantLockLocal(), HASH_ENTER, HASH_REMOVE, hash_search(), hash_search_with_hash_value(), LOCALLOCK::hashcode, PGPROC::heldLocks, PROCLOCK::holdMask, LOCALLOCK::holdsStrongLockCount, InRecovery, lengthof, LOCALLOCKTAG::lock, LOCALLOCK::lock, LOCK_PRINT, LOCKACQUIRE_ALREADY_HELD, LOCKACQUIRE_NOT_AVAIL, LOCKACQUIRE_OK, LOCKBIT_ON, LockCheckConflicts(), LockHashPartitionLock, PROCLOCK::lockLink, LockMethodData::lockModeNames, LOCALLOCK::lockOwners, LOCKTAG::locktag_field1, LOCKTAG::locktag_field2, LOCKTAG::locktag_field3, LOCKTAG::locktag_field4, LOCKTAG::locktag_lockmethodid, LOCKTAG_OBJECT, LOCKTAG_RELATION, LOCKTAG::locktag_type, LockTagHashCode(), LOG, LogAccessExclusiveLock(), LogAccessExclusiveLockPrepare(), LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), LOCALLOCK::maxLockOwners, MemoryContextAlloc(), MemSet, LOCALLOCKTAG::mode, PROCLOCKTAG::myLock, MyProc, LOCK::nGranted, LOCALLOCK::nLocks, LOCK::nRequested, LockMethodData::numLockModes, LOCALLOCK::numLockOwners, PANIC, PROCLOCK::procLink, LOCALLOCK::proclock, PROCLOCK_PRINT, ProcLockHashCode(), RecoveryInProgress(), RemoveLocalLock(), repalloc(), LOCK::requested, RowExclusiveLock, SetupLockInTable(), SHMQueueDelete(), status(), STATUS_FOUND, STATUS_OK, PROCLOCK::tag, TopMemoryContext, LOCK::waitMask, WaitOnLock(), and XLogStandbyInfoActive.

Referenced by LockAcquire(), and StandbyAcquireAccessExclusiveLock().

 {
     LOCKMETHODID lockmethodid = locktag->locktag_lockmethodid;
     LockMethod  lockMethodTable;
     LOCALLOCKTAG localtag;
     LOCALLOCK  *locallock;
     LOCK       *lock;
     PROCLOCK   *proclock;
     bool        found;
     ResourceOwner owner;
     uint32      hashcode;
     LWLock     *partitionLock;
     int         status;
     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,
                                           (void *) &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->numLockOwners = 0;
         locallock->maxLockOwners = 8;
         locallock->holdsStrongLockCount = FALSE;
         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 we already hold the lock, we can just increase the count locally.
      */
     if (locallock->nLocks > 0)
     {
         GrantLockLocal(locallock, owner);
         return LOCKACQUIRE_ALREADY_HELD;
     }
 
     /*
      * 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) &&
         FastPathLocalUseCount < FP_LOCK_SLOTS_PER_BACKEND)
     {
         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->backendLock, LW_EXCLUSIVE);
         if (FastPathStrongRelationLocks->count[fasthashcode] != 0)
             acquired = false;
         else
             acquired = FastPathGrantRelationLock(locktag->locktag_field2,
                                                  lockmode);
         LWLockRelease(&MyProc->backendLock);
         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 (reportMemoryError)
                 ereport(ERROR,
                         (errcode(ERRCODE_OUT_OF_MEMORY),
                          errmsg("out of shared memory"),
                          errhint("You might need to increase 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 (reportMemoryError)
             ereport(ERROR,
                     (errcode(ERRCODE_OUT_OF_MEMORY),
                      errmsg("out of shared memory"),
                      errhint("You might need to increase 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)
         status = STATUS_FOUND;
     else
         status = LockCheckConflicts(lockMethodTable, lockmode,
                                     lock, proclock);
 
     if (status == STATUS_OK)
     {
         /* No conflict with held or previously requested locks */
         GrantLock(lock, proclock, lockmode);
         GrantLockLocal(locallock, owner);
     }
     else
     {
         Assert(status == STATUS_FOUND);
 
         /*
          * We can't acquire the lock immediately.  If caller specified no
          * blocking, remove useless table entries and return NOT_AVAIL without
          * waiting.
          */
         if (dontWait)
         {
             AbortStrongLockAcquire();
             if (proclock->holdMask == 0)
             {
                 uint32      proclock_hashcode;
 
                 proclock_hashcode = ProcLockHashCode(&proclock->tag, hashcode);
                 SHMQueueDelete(&proclock->lockLink);
                 SHMQueueDelete(&proclock->procLink);
                 if (!hash_search_with_hash_value(LockMethodProcLockHash,
                                                  (void *) &(proclock->tag),
                                                  proclock_hashcode,
                                                  HASH_REMOVE,
                                                  NULL))
                     elog(PANIC, "proclock table corrupted");
             }
             else
                 PROCLOCK_PRINT("LockAcquire: NOWAIT", proclock);
             lock->nRequested--;
             lock->requested[lockmode]--;
             LOCK_PRINT("LockAcquire: conditional lock failed", lock, lockmode);
             Assert((lock->nRequested > 0) && (lock->requested[lockmode] >= 0));
             Assert(lock->nGranted <= lock->nRequested);
             LWLockRelease(partitionLock);
             if (locallock->nLocks == 0)
                 RemoveLocalLock(locallock);
             return LOCKACQUIRE_NOT_AVAIL;
         }
 
         /*
          * Set bitmask of locks this process already holds on this object.
          */
         MyProc->heldLocks = proclock->holdMask;
 
         /*
          * Sleep till someone wakes me up.
          */
 
         TRACE_POSTGRESQL_LOCK_WAIT_START(locktag->locktag_field1,
                                          locktag->locktag_field2,
                                          locktag->locktag_field3,
                                          locktag->locktag_field4,
                                          locktag->locktag_type,
                                          lockmode);
 
         WaitOnLock(locallock, owner);
 
         TRACE_POSTGRESQL_LOCK_WAIT_DONE(locktag->locktag_field1,
                                         locktag->locktag_field2,
                                         locktag->locktag_field3,
                                         locktag->locktag_field4,
                                         locktag->locktag_type,
                                         lockmode);
 
         /*
          * 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.
          */
 
         /*
          * Check the proclock entry status, in case something in the ipc
          * communication doesn't work correctly.
          */
         if (!(proclock->holdMask & LOCKBIT_ON(lockmode)))
         {
             AbortStrongLockAcquire();
             PROCLOCK_PRINT("LockAcquire: INCONSISTENT", proclock);
             LOCK_PRINT("LockAcquire: INCONSISTENT", lock, lockmode);
             /* Should we retry ? */
             LWLockRelease(partitionLock);
             elog(ERROR, "LockAcquire failed");
         }
         PROCLOCK_PRINT("LockAcquire: granted", proclock);
         LOCK_PRINT("LockAcquire: granted", lock, lockmode);
     }
 
     /*
      * Lock state is fully up-to-date now; if we error out after this, no
      * special error cleanup is required.
      */
     FinishStrongLockAcquire();
 
     LWLockRelease(partitionLock);
 
     /*
      * 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;
 }

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

Definition at line 1292 of file lock.c.

References Assert, LockMethodData::conflictTab, elog, LOCK::granted, LOCK::grantMask, PROCLOCK::groupLeader, PROCLOCK::holdMask, i, LOCKBIT_ON, PGPROC::lockGroupLeader, PROCLOCK::lockLink, MAX_LOCKMODES, MyProc, PROCLOCKTAG::myProc, LockMethodData::numLockModes, offsetof, PANIC, PROCLOCK_PRINT, LOCK::procLocks, SHMQueueNext(), STATUS_FOUND, STATUS_OK, and PROCLOCK::tag.

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

 {
     int         numLockModes = lockMethodTable->numLockModes;
     LOCKMASK    myLocks;
     int         conflictMask = lockMethodTable->conflictTab[lockmode];
     int         conflictsRemaining[MAX_LOCKMODES];
     int         totalConflictsRemaining = 0;
     int         i;
     SHM_QUEUE  *procLocks;
     PROCLOCK   *otherproclock;
 
     /*
      * 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 STATUS_OK;
     }
 
     /*
      * 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 STATUS_OK;
     }
 
     /* 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 STATUS_FOUND;
     }
 
     /*
      * 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.
      */
     procLocks = &(lock->procLocks);
     otherproclock = (PROCLOCK *)
         SHMQueueNext(procLocks, procLocks, offsetof(PROCLOCK, lockLink));
     while (otherproclock != NULL)
     {
         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 STATUS_OK;
             }
         }
         otherproclock = (PROCLOCK *)
             SHMQueueNext(procLocks, &otherproclock->lockLink,
                          offsetof(PROCLOCK, lockLink));
     }
 
     /* Nope, it's a real conflict. */
     PROCLOCK_PRINT("LockCheckConflicts: conflicting (group)", proclock);
     return STATUS_FOUND;
 }

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

Definition at line 571 of file lock.c.

References LockMethodData::conflictTab, elog, ERROR, HASH_FIND, hash_search(), LOCALLOCK::hashcode, PROCLOCK::holdMask, lengthof, LOCALLOCKTAG::lock, LOCALLOCK::lock, LOCK_PRINT, LOCKBIT_ON, LockHashPartitionLock, 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().

 {
     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,
                                           (void *) &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;
 }

void LockReassignCurrentOwner	(	LOCALLOCK **	locallocks,
		int	nlocks
	)

Definition at line 2413 of file lock.c.

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

Referenced by ResourceOwnerReleaseInternal().

 {
     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);
     }
 }

static void LockReassignOwner	(	LOCALLOCK *	locallock,
		ResourceOwner	parent
	)

static

Definition at line 2443 of file lock.c.

References CurrentResourceOwner, i, LOCALLOCK::lockOwners, LOCALLOCKOWNER::nLocks, LOCALLOCK::numLockOwners, LOCALLOCKOWNER::owner, ResourceOwnerForgetLock(), and ResourceOwnerRememberLock().

Referenced by LockReassignCurrentOwner().

 {
     LOCALLOCKOWNER *lockOwners;
     int         i;
     int         ic = -1;
     int         ip = -1;
 
     /*
      * Scan to see if there are any locks belonging to current owner or its
      * parent
      */
     lockOwners = locallock->lockOwners;
     for (i = locallock->numLockOwners - 1; i >= 0; i--)
     {
         if (lockOwners[i].owner == CurrentResourceOwner)
             ic = i;
         else if (lockOwners[i].owner == parent)
             ip = i;
     }
 
     if (ic < 0)
         return;                 /* no current locks */
 
     if (ip < 0)
     {
         /* Parent has no slot, so just give it the child's slot */
         lockOwners[ic].owner = parent;
         ResourceOwnerRememberLock(parent, locallock);
     }
     else
     {
         /* Merge child's count with parent's */
         lockOwners[ip].nLocks += lockOwners[ic].nLocks;
         /* compact out unused slot */
         locallock->numLockOwners--;
         if (ic < locallock->numLockOwners)
             lockOwners[ic] = lockOwners[locallock->numLockOwners];
     }
     ResourceOwnerForgetLock(CurrentResourceOwner, locallock);
 }

static void LockRefindAndRelease	(	LockMethod	lockMethodTable,
		PGPROC *	proc,
		LOCKTAG *	locktag,
		LOCKMODE	lockmode,
		bool	decrement_strong_lock_count
	)

static

Definition at line 2962 of file lock.c.

References Assert, CleanUpLock(), ConflictsWithRelationFastPath, FastPathStrongRelationLockData::count, elog, FastPathStrongLockHashPartition, HASH_FIND, hash_search_with_hash_value(), PROCLOCK::holdMask, LOCKBIT_ON, LockHashPartitionLock, LockMethodData::lockModeNames, LockTagHashCode(), LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), FastPathStrongRelationLockData::mutex, PROCLOCKTAG::myLock, PROCLOCKTAG::myProc, PANIC, PROCLOCK_PRINT, ProcLockHashCode(), SpinLockAcquire, SpinLockRelease, UnGrantLock(), and WARNING.

Referenced by lock_twophase_postcommit(), LockReleaseAll(), and VirtualXactLockTableCleanup().

 {
     LOCK       *lock;
     PROCLOCK   *proclock;
     PROCLOCKTAG proclocktag;
     uint32      hashcode;
     uint32      proclock_hashcode;
     LWLock     *partitionLock;
     bool        wakeupNeeded;
 
     hashcode = LockTagHashCode(locktag);
     partitionLock = LockHashPartitionLock(hashcode);
 
     LWLockAcquire(partitionLock, LW_EXCLUSIVE);
 
     /*
      * Re-find the lock object (it had better be there).
      */
     lock = (LOCK *) hash_search_with_hash_value(LockMethodLockHash,
                                                 (void *) locktag,
                                                 hashcode,
                                                 HASH_FIND,
                                                 NULL);
     if (!lock)
         elog(PANIC, "failed to re-find shared lock object");
 
     /*
      * Re-find the proclock object (ditto).
      */
     proclocktag.myLock = lock;
     proclocktag.myProc = proc;
 
     proclock_hashcode = ProcLockHashCode(&proclocktag, hashcode);
 
     proclock = (PROCLOCK *) hash_search_with_hash_value(LockMethodProcLockHash,
                                                         (void *) &proclocktag,
                                                         proclock_hashcode,
                                                         HASH_FIND,
                                                         NULL);
     if (!proclock)
         elog(PANIC, "failed to re-find shared proclock object");
 
     /*
      * Double-check that we are actually holding a lock of the type we want to
      * release.
      */
     if (!(proclock->holdMask & LOCKBIT_ON(lockmode)))
     {
         PROCLOCK_PRINT("lock_twophase_postcommit: WRONGTYPE", proclock);
         LWLockRelease(partitionLock);
         elog(WARNING, "you don't own a lock of type %s",
              lockMethodTable->lockModeNames[lockmode]);
         return;
     }
 
     /*
      * Do the releasing.  CleanUpLock will waken any now-wakable waiters.
      */
     wakeupNeeded = UnGrantLock(lock, lockmode, proclock, lockMethodTable);
 
     CleanUpLock(lock, proclock,
                 lockMethodTable, hashcode,
                 wakeupNeeded);
 
     LWLockRelease(partitionLock);
 
     /*
      * Decrement strong lock count.  This logic is needed only for 2PC.
      */
     if (decrement_strong_lock_count
         && ConflictsWithRelationFastPath(locktag, lockmode))
     {
         uint32      fasthashcode = FastPathStrongLockHashPartition(hashcode);
 
         SpinLockAcquire(&FastPathStrongRelationLocks->mutex);
         Assert(FastPathStrongRelationLocks->count[fasthashcode] > 0);
         FastPathStrongRelationLocks->count[fasthashcode]--;
         SpinLockRelease(&FastPathStrongRelationLocks->mutex);
     }
 }

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

Definition at line 1818 of file lock.c.

References Assert, PGPROC::backendLock, CleanUpLock(), CurrentResourceOwner, EligibleForRelationFastPath, elog, ERROR, FALSE, FastPathLocalUseCount, FastPathUnGrantRelationLock(), HASH_FIND, hash_search(), hash_search_with_hash_value(), LOCALLOCK::hashcode, PROCLOCK::holdMask, i, lengthof, LOCALLOCKTAG::lock, LOCALLOCK::lock, LOCK_PRINT, LOCKBIT_ON, LockHashPartitionLock, 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(), TRUE, 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(), SpeculativeInsertionLockRelease(), SpeculativeInsertionWait(), StandbyReleaseAllLocks(), StandbyReleaseLocks(), StandbyReleaseOldLocks(), UnlockDatabaseObject(), UnlockPage(), UnlockRelation(), UnlockRelationForExtension(), UnlockRelationId(), UnlockRelationIdForSession(), UnlockRelationOid(), UnlockSharedObject(), UnlockSharedObjectForSession(), UnlockTuple(), VirtualXactLock(), XactLockTableDelete(), and XactLockTableWait().

 {
     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,
                                           (void *) &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;
 
     /* Attempt fast release of any lock eligible for the fast path. */
     if (EligibleForRelationFastPath(locktag, lockmode) &&
         FastPathLocalUseCount > 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->backendLock, LW_EXCLUSIVE);
         released = FastPathUnGrantRelationLock(locktag->locktag_field2,
                                                lockmode);
         LWLockRelease(&MyProc->backendLock);
         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,
                                                     (const void *) 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,
                                                        (void *) &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;
 }

void LockReleaseAll	(	LOCKMETHODID	lockmethodid,
		bool	allLocks
	)

Definition at line 2014 of file lock.c.

References Assert, PGPROC::backendLock, CleanUpLock(), DEFAULT_LOCKMETHOD, EligibleForRelationFastPath, elog, ERROR, FastPathUnGrantRelationLock(), LOCK::grantMask, hash_seq_init(), hash_seq_search(), PROCLOCK::holdMask, i, lengthof, LOCALLOCK_LOCKMETHOD, LOCALLOCKTAG::lock, LOCALLOCK::lock, LOCK_LOCKMETHOD, LOCK_PRINT, LOCKBIT_ON, LockHashPartitionLockByIndex, LOCALLOCK::lockOwners, LockRefindAndRelease(), LOCKTAG::locktag_field2, 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, offsetof, LOCALLOCKOWNER::owner, PANIC, PROCLOCK::procLink, LOCALLOCK::proclock, PROCLOCK_PRINT, PROCLOCK::releaseMask, RemoveLocalLock(), ResourceOwnerForgetLock(), SHMQueueNext(), status(), LOCK::tag, PROCLOCK::tag, LOCALLOCK::tag, LockMethodData::trace_flag, UnGrantLock(), and VirtualXactLockTableCleanup().

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

 {
     HASH_SEQ_STATUS status;
     LockMethod  lockMethodTable;
     int         i,
                 numLockModes;
     LOCALLOCK  *locallock;
     LOCK       *lock;
     PROCLOCK   *proclock;
     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, we must've run out of shared
          * memory while trying to set up 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;
         }
 
         /*
          * 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->backendLock, 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->backendLock);
             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->backendLock);
 
     /*
      * Now, scan each lock partition separately.
      */
     for (partition = 0; partition < NUM_LOCK_PARTITIONS; partition++)
     {
         LWLock     *partitionLock;
         SHM_QUEUE  *procLocks = &(MyProc->myProcLocks[partition]);
         PROCLOCK   *nextplock;
 
         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 (SHMQueueNext(procLocks, procLocks,
                          offsetof(PROCLOCK, procLink)) == NULL)
             continue;           /* needn't examine this partition */
 
         LWLockAcquire(partitionLock, LW_EXCLUSIVE);
 
         for (proclock = (PROCLOCK *) SHMQueueNext(procLocks, procLocks,
                                                   offsetof(PROCLOCK, procLink));
              proclock;
              proclock = nextplock)
         {
             bool        wakeupNeeded = false;
 
             /* Get link first, since we may unlink/delete this proclock */
             nextplock = (PROCLOCK *)
                 SHMQueueNext(procLocks, &proclock->procLink,
                              offsetof(PROCLOCK, procLink));
 
             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
 }

void LockReleaseCurrentOwner	(	LOCALLOCK **	locallocks,
		int	nlocks
	)

Definition at line 2318 of file lock.c.

References hash_seq_init(), hash_seq_search(), i, ReleaseLockIfHeld(), and status().

Referenced by ResourceOwnerReleaseInternal().

 {
     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);
     }
 }

void LockReleaseSession ( LOCKMETHODID lockmethodid )

Definition at line 2288 of file lock.c.

References elog, ERROR, hash_seq_init(), hash_seq_search(), lengthof, LOCALLOCK_LOCKMETHOD, ReleaseLockIfHeld(), and status().

Referenced by pg_advisory_unlock_all().

 {
     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);
     }
 }

Size LockShmemSize ( void )

Definition at line 3361 of file lock.c.

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

Referenced by CreateSharedMemoryAndSemaphores().

 {
     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;
 }

uint32 LockTagHashCode ( const LOCKTAG * locktag )

Definition at line 490 of file lock.c.

References get_hash_value().

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

 {
     return get_hash_value(LockMethodLockHash, (const void *) locktag);
 }

int LockWaiterCount ( const LOCKTAG * locktag )

Definition at line 4387 of file lock.c.

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

Referenced by RelationExtensionLockWaiterCount().

 {
     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,
                                                 (const void *) locktag,
                                                 hashcode,
                                                 HASH_FIND,
                                                 &found);
     if (found)
     {
         Assert(lock != NULL);
         waiters = lock->nRequested;
     }
     LWLockRelease(partitionLock);
 
     return waiters;
 }

void PostPrepare_Locks ( TransactionId xid )

Definition at line 3169 of file lock.c.

References Assert, 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, 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, offsetof, PANIC, PROCLOCK::procLink, LOCALLOCK::proclock, PROCLOCK_PRINT, PROCLOCK::releaseMask, RemoveLocalLock(), SHMQueueDelete(), SHMQueueInsertBefore(), SHMQueueNext(), START_CRIT_SECTION, status(), LOCK::tag, PROCLOCK::tag, LOCALLOCK::tag, and TwoPhaseGetDummyProc().

Referenced by PrepareTransaction().

 {
     PGPROC     *newproc = TwoPhaseGetDummyProc(xid);
     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;
         SHM_QUEUE  *procLocks = &(MyProc->myProcLocks[partition]);
         PROCLOCK   *nextplock;
 
         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 (SHMQueueNext(procLocks, procLocks,
                          offsetof(PROCLOCK, procLink)) == NULL)
             continue;           /* needn't examine this partition */
 
         LWLockAcquire(partitionLock, LW_EXCLUSIVE);
 
         for (proclock = (PROCLOCK *) SHMQueueNext(procLocks, procLocks,
                                                   offsetof(PROCLOCK, procLink));
              proclock;
              proclock = nextplock)
         {
             /* Get link first, since we may unlink/relink this proclock */
             nextplock = (PROCLOCK *)
                 SHMQueueNext(procLocks, &proclock->procLink,
                              offsetof(PROCLOCK, procLink));
 
             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.
              */
             SHMQueueDelete(&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,
                                       (void *) proclock,
                                       (void *) &proclocktag))
                 elog(PANIC, "duplicate entry found while reassigning a prepared transaction's locks");
 
             /* Re-link into the new proc's proclock list */
             SHMQueueInsertBefore(&(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();
 }

Data Structures

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

Typedef Documentation

Function Documentation