lock.c File Reference

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

Go to the source code of this file.

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	LockHeldByMe (const LOCKTAG *locktag, LOCKMODE lockmode)
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, LOCALLOCK **locallockp)
static void	CheckAndSetLockHeld (LOCALLOCK *locallock, bool acquired)
bool	LockCheckConflicts (LockMethod lockMethodTable, LOCKMODE lockmode, LOCK *lock, PROCLOCK *proclock)
void	GrantLock (LOCK *lock, PROCLOCK *proclock, LOCKMODE lockmode)
void	AbortStrongLockAcquire (void)
void	GrantAwaitedLock (void)
void	MarkLockClear (LOCALLOCK *locallock)
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, int *countp)
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 bool IsRelationExtensionLockHeld	PG_USED_FOR_ASSERTS_ONLY = false
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

ConflictsWithRelationFastPath

#define ConflictsWithRelationFastPath	(		locktag,
			mode
	)

Value:

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

Definition at line 232 of file lock.c.

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

EligibleForRelationFastPath

#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 226 of file lock.c.

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

FAST_PATH_BIT_POSITION

#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 206 of file lock.c.

FAST_PATH_BITS_PER_SLOT

#define FAST_PATH_BITS_PER_SLOT   3

Definition at line 201 of file lock.c.

Referenced by FastPathTransferRelationLocks().

FAST_PATH_CHECK_LOCKMODE

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

Definition at line 215 of file lock.c.

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

FAST_PATH_CLEAR_LOCKMODE

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

Definition at line 213 of file lock.c.

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

FAST_PATH_GET_BITS

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

Definition at line 204 of file lock.c.

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

FAST_PATH_LOCKNUMBER_OFFSET

#define FAST_PATH_LOCKNUMBER_OFFSET   1

Definition at line 202 of file lock.c.

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

FAST_PATH_MASK

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

Definition at line 203 of file lock.c.

FAST_PATH_SET_LOCKMODE

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

Definition at line 211 of file lock.c.

Referenced by FastPathGrantRelationLock().

FAST_PATH_STRONG_LOCK_HASH_BITS

#define FAST_PATH_STRONG_LOCK_HASH_BITS   10

Definition at line 259 of file lock.c.

FAST_PATH_STRONG_LOCK_HASH_PARTITIONS

#define FAST_PATH_STRONG_LOCK_HASH_PARTITIONS   (1 << FAST_PATH_STRONG_LOCK_HASH_BITS)

Definition at line 260 of file lock.c.

FastPathStrongLockHashPartition

#define FastPathStrongLockHashPartition

(

hashcode

)

((hashcode) % FAST_PATH_STRONG_LOCK_HASH_PARTITIONS)

Definition at line 262 of file lock.c.

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

LOCK_PRINT

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

Definition at line 364 of file lock.c.

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

NLOCKENTS

#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().

PROCLOCK_PRINT

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

Definition at line 365 of file lock.c.

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

Typedef Documentation

TwoPhaseLockRecord

typedef struct TwoPhaseLockRecord TwoPhaseLockRecord

Function Documentation

AbortStrongLockAcquire()

void AbortStrongLockAcquire

(

void

)

Definition at line 1757 of file lock.c.

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

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

AtPrepare_Locks()

void AtPrepare_Locks

(

void

)

Definition at line 3230 of file lock.c.

References ereport, errcode(), errmsg(), ERROR, 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));
    }
}

BeginStrongLockAcquire()

static void BeginStrongLockAcquire ( LOCALLOCK *  locallock, uint32  fasthashcode  )

static

Definition at line 1721 of file lock.c.

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

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

CheckAndSetLockHeld()

static void CheckAndSetLockHeld ( LOCALLOCK *  locallock, bool  acquired  )

inlinestatic

Definition at line 1352 of file lock.c.

References LOCALLOCK_LOCKTAG, LOCKTAG_PAGE, and LOCKTAG_RELATION_EXTEND.

Referenced by GrantLockLocal(), and RemoveLocalLock().

{
#ifdef USE_ASSERT_CHECKING
    if (LOCALLOCK_LOCKTAG(*locallock) == LOCKTAG_RELATION_EXTEND)
        IsRelationExtensionLockHeld = acquired;
    else if (LOCALLOCK_LOCKTAG(*locallock) == LOCKTAG_PAGE)
        IsPageLockHeld = acquired;

#endif
}

CleanUpLock()

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

static

Definition at line 1635 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);
    }
}

DoLockModesConflict()

bool DoLockModesConflict	(	LOCKMODE	mode1,
		LOCKMODE	mode2
	)

Definition at line 583 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;
}

FastPathGetRelationLockEntry()

static PROCLOCK * FastPathGetRelationLockEntry ( LOCALLOCK *  locallock )

static

Definition at line 2810 of file lock.c.

References 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::fpInfoLock, PGPROC::fpRelId, GrantLock(), HASH_FIND, hash_search_with_hash_value(), LOCALLOCK::hashcode, LOCALLOCKTAG::lock, LockHashPartitionLock, TwoPhaseLockRecord::lockmode, TwoPhaseLockRecord::locktag, 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->fpInfoLock, 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->fpInfoLock);
            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->fpInfoLock);

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

FastPathGrantRelationLock()

static bool FastPathGrantRelationLock ( Oid  relid, LOCKMODE  lockmode  )

static

Definition at line 2655 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;
}

FastPathTransferRelationLocks()

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

static

Definition at line 2722 of file lock.c.

References PROC_HDR::allProcCount, PROC_HDR::allProcs, 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::fpInfoLock, PGPROC::fpRelId, GrantLock(), i, LockHashPartitionLock, TwoPhaseLockRecord::lockmode, 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->fpInfoLock, 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->fpInfoLock.  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->fpInfoLock);
            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->fpInfoLock);
                    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->fpInfoLock);
    }
    return true;
}

FastPathUnGrantRelationLock()

static bool FastPathUnGrantRelationLock ( Oid  relid, LOCKMODE  lockmode  )

static

Definition at line 2692 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;
}

FinishStrongLockAcquire()

static void FinishStrongLockAcquire ( void  )

static

Definition at line 1747 of file lock.c.

Referenced by LockAcquireExtended().

{
    StrongLockInProgress = NULL;
}

GetBlockerStatusData()

BlockedProcsData* GetBlockerStatusData

(

int

blocked_pid

)

Definition at line 3753 of file lock.c.

References Assert, BackendPidGetProcWithLock(), dlist_iter::cur, dlist_container, dlist_foreach, GetSingleProcBlockerStatusData(), i, PGPROC::lockGroupLeader, PGPROC::lockGroupMembers, LockHashPartitionLockByIndex, BlockedProcsData::locks, LW_SHARED, LWLockAcquire(), LWLockRelease(), MaxBackends, BlockedProcsData::maxlocks, BlockedProcsData::maxpids, BlockedProcsData::maxprocs, BlockedProcsData::nlocks, BlockedProcsData::npids, BlockedProcsData::nprocs, NUM_LOCK_PARTITIONS, palloc(), BlockedProcsData::procs, and BlockedProcsData::waiter_pids.

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

GetLockConflicts()

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

Definition at line 2912 of file lock.c.

References PROC_HDR::allProcCount, PROC_HDR::allProcs, VirtualTransactionId::backendId, ConflictsWithRelationFastPath, LockMethodData::conflictTab, PGPROC::databaseId, elog, ERROR, FAST_PATH_GET_BITS, FAST_PATH_LOCKNUMBER_OFFSET, FP_LOCK_SLOTS_PER_BACKEND, PGPROC::fpInfoLock, 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, TwoPhaseLockRecord::lockmode, TwoPhaseLockRecord::locktag, 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->fpInfoLock, LW_SHARED);

            /*
             * If the target backend isn't referencing the same database as
             * the lock, then we needn't examine the individual relation IDs
             * at all; none of them can be relevant.
             *
             * See FastPathTransferRelationLocks() for discussion of why we do
             * this test after acquiring the lock.
             */
            if (proc->databaseId != locktag->locktag_field1)
            {
                LWLockRelease(&proc->fpInfoLock);
                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->fpInfoLock);
        }
    }

    /* Remember how many fast-path conflicts we found. */
    fast_count = count;

    /*
     * Look up the lock object matching the tag.
     */
    LWLockAcquire(partitionLock, LW_SHARED);

    lock = (LOCK *) hash_search_with_hash_value(LockMethodLockHash,
                                                (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;
        if (countp)
            *countp = count;
        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;
    if (countp)
        *countp = count;
    return vxids;
}

GetLockmodeName()

const char* GetLockmodeName	(	LOCKMETHODID	lockmethodid,
		LOCKMODE	mode
	)

Definition at line 4016 of file lock.c.

References Assert, elog, hash_seq_init(), hash_seq_search(), i, lengthof, LOCK_PRINT, LockMethodData::lockModeNames, LOG, mode, PROCLOCKTAG::myLock, MyProc, PROCLOCKTAG::myProc, PGPROC::myProcLocks, NUM_LOCK_PARTITIONS, offsetof, PROCLOCK::procLink, PROCLOCK_PRINT, SHMQueueNext(), status(), PROCLOCK::tag, and PGPROC::waitLock.

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

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

GetLocksMethodTable()

LockMethod GetLocksMethodTable

(

const LOCK *

lock

)

Definition at line 487 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];
}

GetLockStatusData()

LockData* GetLockStatusData

(

void

)

Definition at line 3569 of file lock.c.

References PROC_HDR::allProcCount, PROC_HDR::allProcs, Assert, LockInstanceData::backend, VirtualTransactionId::backendId, PGPROC::backendId, PGPROC::databaseId, ExclusiveLock, FAST_PATH_GET_BITS, FAST_PATH_LOCKNUMBER_OFFSET, LockInstanceData::fastpath, FP_LOCK_SLOTS_PER_BACKEND, PGPROC::fpInfoLock, 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->fpInfoLock, 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->fpInfoLock);
    }

    /*
     * Next, acquire lock on the entire shared lock data structure.  We do
     * this so that, at least for locks in the primary lock table, the state
     * will be self-consistent.
     *
     * Since this is a read-only operation, we take shared instead of
     * exclusive lock.  There's not a whole lot of point to this, because all
     * the normal operations require exclusive lock, but it doesn't hurt
     * anything either. It will at least allow two backends to do
     * GetLockStatusData in parallel.
     *
     * Must grab LWLocks in partition-number order to avoid LWLock deadlock.
     */
    for (i = 0; i < NUM_LOCK_PARTITIONS; i++)
        LWLockAcquire(LockHashPartitionLockByIndex(i), LW_SHARED);

    /* Now we can safely count the number of proclocks */
    data->nelements = el + hash_get_num_entries(LockMethodProcLockHash);
    if (data->nelements > els)
    {
        els = data->nelements;
        data->locks = (LockInstanceData *)
            repalloc(data->locks, sizeof(LockInstanceData) * els);
    }

    /* Now scan the tables to copy the data */
    hash_seq_init(&seqstat, LockMethodProcLockHash);

    while ((proclock = (PROCLOCK *) hash_seq_search(&seqstat)))
    {
        PGPROC     *proc = proclock->tag.myProc;
        LOCK       *lock = proclock->tag.myLock;
        LockInstanceData *instance = &data->locks[el];

        memcpy(&instance->locktag, &lock->tag, sizeof(LOCKTAG));
        instance->holdMask = proclock->holdMask;
        if (proc->waitLock == proclock->tag.myLock)
            instance->waitLockMode = proc->waitLockMode;
        else
            instance->waitLockMode = NoLock;
        instance->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;
}

GetLockTagsMethodTable()

LockMethod GetLockTagsMethodTable

(

const LOCKTAG *

locktag

)

Definition at line 499 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];
}

GetRunningTransactionLocks()

xl_standby_lock* GetRunningTransactionLocks

(

int *

nlocks

)

Definition at line 3933 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;
}

GetSingleProcBlockerStatusData()

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

static

Definition at line 3833 of file lock.c.

References LockInstanceData::backend, PGPROC::backendId, LockInstanceData::fastpath, BlockedProcData::first_lock, BlockedProcData::first_waiter, PROCLOCK::groupLeader, PROCLOCK::holdMask, LockInstanceData::holdMask, i, LockInstanceData::leaderPid, PROC_QUEUE::links, PGPROC::links, PROCLOCK::lockLink, BlockedProcsData::locks, LockInstanceData::locktag, PGPROC::lxid, LockInstanceData::lxid, Max, MaxBackends, BlockedProcsData::maxlocks, BlockedProcsData::maxpids, PROCLOCKTAG::myLock, PROCLOCKTAG::myProc, SHM_QUEUE::next, BlockedProcsData::nlocks, NoLock, BlockedProcsData::npids, BlockedProcsData::nprocs, BlockedProcData::num_locks, BlockedProcData::num_waiters, offsetof, PGPROC::pid, LockInstanceData::pid, BlockedProcData::pid, LOCK::procLocks, BlockedProcsData::procs, repalloc(), SHMQueueNext(), PROC_QUEUE::size, LOCK::tag, PROCLOCK::tag, BlockedProcsData::waiter_pids, PGPROC::waitLock, PGPROC::waitLockMode, LockInstanceData::waitLockMode, and LOCK::waitProcs.

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

GrantAwaitedLock()

void GrantAwaitedLock

(

void

)

Definition at line 1786 of file lock.c.

References GrantLockLocal().

Referenced by LockErrorCleanup(), and ProcSleep().

{
    GrantLockLocal(awaitedLock, awaitedOwner);
}

GrantLock()

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

Definition at line 1555 of file lock.c.

References Assert, LOCK::granted, LOCK::grantMask, PROCLOCK::holdMask, LOCK_PRINT, LOCKBIT_OFF, LOCKBIT_ON, TwoPhaseLockRecord::lockmode, 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);
}

GrantLockLocal()

static void GrantLockLocal ( LOCALLOCK *  locallock, ResourceOwner  owner  )

static

Definition at line 1689 of file lock.c.

References Assert, CheckAndSetLockHeld(), 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);

    /* Indicate that the lock is acquired for certain types of locks. */
    CheckAndSetLockHeld(locallock, true);
}

InitLocks()

void InitLocks

(

void

)

Definition at line 404 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);
}

lock_twophase_postabort()

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

Definition at line 4368 of file lock.c.

References lock_twophase_postcommit().

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

lock_twophase_postcommit()

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

Definition at line 4342 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, true);
    LOCKTAG    *locktag;
    LOCKMETHODID lockmethodid;
    LockMethod  lockMethodTable;

    Assert(len == sizeof(TwoPhaseLockRecord));
    locktag = &rec->locktag;
    lockmethodid = locktag->locktag_lockmethodid;

    if (lockmethodid <= 0 || lockmethodid >= lengthof(LockMethods))
        elog(ERROR, "unrecognized lock method: %d", lockmethodid);
    lockMethodTable = LockMethods[lockmethodid];

    LockRefindAndRelease(lockMethodTable, proc, locktag, rec->lockmode, true);
}

lock_twophase_recover()

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

Definition at line 4129 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, false);
    LOCKTAG    *locktag;
    LOCKMODE    lockmode;
    LOCKMETHODID lockmethodid;
    LOCK       *lock;
    PROCLOCK   *proclock;
    PROCLOCKTAG proclocktag;
    bool        found;
    uint32      hashcode;
    uint32      proclock_hashcode;
    int         partition;
    LWLock     *partitionLock;
    LockMethod  lockMethodTable;

    Assert(len == sizeof(TwoPhaseLockRecord));
    locktag = &rec->locktag;
    lockmode = rec->lockmode;
    lockmethodid = locktag->locktag_lockmethodid;

    if (lockmethodid <= 0 || lockmethodid >= lengthof(LockMethods))
        elog(ERROR, "unrecognized lock method: %d", lockmethodid);
    lockMethodTable = LockMethods[lockmethodid];

    hashcode = LockTagHashCode(locktag);
    partition = LockHashPartition(hashcode);
    partitionLock = LockHashPartitionLock(hashcode);

    LWLockAcquire(partitionLock, LW_EXCLUSIVE);

    /*
     * Find or create a lock with this tag.
     */
    lock = (LOCK *) hash_search_with_hash_value(LockMethodLockHash,
                                                (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);
}

lock_twophase_standby_recover()

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

Definition at line 4310 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 */ );
    }
}

LockAcquire()

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

Definition at line 747 of file lock.c.

References LockAcquireExtended().

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

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

LockAcquireExtended()

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

Definition at line 771 of file lock.c.

References AbortStrongLockAcquire(), AccessExclusiveLock, Assert, BeginStrongLockAcquire(), ConflictsWithRelationFastPath, LockMethodData::conflictTab, FastPathStrongRelationLockData::count, CurrentResourceOwner, EligibleForRelationFastPath, elog, ereport, errcode(), errhint(), errmsg(), ERROR, FastPathGrantRelationLock(), FastPathLocalUseCount, FastPathStrongLockHashPartition, FastPathTransferRelationLocks(), FinishStrongLockAcquire(), FP_LOCK_SLOTS_PER_BACKEND, PGPROC::fpInfoLock, 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_CLEAR, LOCKACQUIRE_ALREADY_HELD, LOCKACQUIRE_NOT_AVAIL, LOCKACQUIRE_OK, LOCKBIT_ON, LockCheckConflicts(), LOCALLOCK::lockCleared, LockHashPartitionLock, PROCLOCK::lockLink, TwoPhaseLockRecord::lockmode, LockMethodData::lockModeNames, LOCALLOCK::lockOwners, TwoPhaseLockRecord::locktag, LOCKTAG::locktag_field1, LOCKTAG::locktag_field2, LOCKTAG::locktag_field3, LOCKTAG::locktag_field4, LOCKTAG::locktag_lockmethodid, LOCKTAG_OBJECT, LOCKTAG_RELATION, LOCKTAG_RELATION_EXTEND, 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(), PROCLOCK::tag, TopMemoryContext, LOCK::waitMask, WaitOnLock(), and XLogStandbyInfoActive.

Referenced by ConditionalLockRelation(), ConditionalLockRelationOid(), LockAcquire(), LockRelation(), and LockRelationOid().

{
    LOCKMETHODID lockmethodid = locktag->locktag_lockmethodid;
    LockMethod  lockMethodTable;
    LOCALLOCKTAG localtag;
    LOCALLOCK  *locallock;
    LOCK       *lock;
    PROCLOCK   *proclock;
    bool        found;
    ResourceOwner owner;
    uint32      hashcode;
    LWLock     *partitionLock;
    bool        found_conflict;
    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->holdsStrongLockCount = false;
        locallock->lockCleared = false;
        locallock->numLockOwners = 0;
        locallock->maxLockOwners = 8;
        locallock->lockOwners = NULL;   /* in case next line fails */
        locallock->lockOwners = (LOCALLOCKOWNER *)
            MemoryContextAlloc(TopMemoryContext,
                               locallock->maxLockOwners * sizeof(LOCALLOCKOWNER));
    }
    else
    {
        /* Make sure there will be room to remember the lock */
        if (locallock->numLockOwners >= locallock->maxLockOwners)
        {
            int         newsize = locallock->maxLockOwners * 2;

            locallock->lockOwners = (LOCALLOCKOWNER *)
                repalloc(locallock->lockOwners,
                         newsize * sizeof(LOCALLOCKOWNER));
            locallock->maxLockOwners = newsize;
        }
    }
    hashcode = locallock->hashcode;

    if (locallockp)
        *locallockp = locallock;

    /*
     * If we already hold the lock, we can just increase the count locally.
     *
     * If lockCleared is already set, caller need not worry about absorbing
     * sinval messages related to the lock's object.
     */
    if (locallock->nLocks > 0)
    {
        GrantLockLocal(locallock, owner);
        if (locallock->lockCleared)
            return LOCKACQUIRE_ALREADY_CLEAR;
        else
            return LOCKACQUIRE_ALREADY_HELD;
    }

    /*
     * We don't acquire any other heavyweight lock while holding the relation
     * extension lock.  We do allow to acquire the same relation extension
     * lock more than once but that case won't reach here.
     */
    Assert(!IsRelationExtensionLockHeld);

    /*
     * We don't acquire any other heavyweight lock while holding the page lock
     * except for relation extension.
     */
    Assert(!IsPageLockHeld ||
           (locktag->locktag_type == LOCKTAG_RELATION_EXTEND));

    /*
     * 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->fpInfoLock, LW_EXCLUSIVE);
        if (FastPathStrongRelationLocks->count[fasthashcode] != 0)
            acquired = false;
        else
            acquired = FastPathGrantRelationLock(locktag->locktag_field2,
                                                 lockmode);
        LWLockRelease(&MyProc->fpInfoLock);
        if (acquired)
        {
            /*
             * The locallock might contain stale pointers to some old shared
             * objects; we MUST reset these to null before considering the
             * lock to be acquired via fast-path.
             */
            locallock->lock = NULL;
            locallock->proclock = NULL;
            GrantLockLocal(locallock, owner);
            return LOCKACQUIRE_OK;
        }
    }

    /*
     * If this lock could potentially have been taken via the fast-path by
     * some other backend, we must (temporarily) disable further use of the
     * fast-path for this lock tag, and migrate any locks already taken via
     * this method to the main lock table.
     */
    if (ConflictsWithRelationFastPath(locktag, lockmode))
    {
        uint32      fasthashcode = FastPathStrongLockHashPartition(hashcode);

        BeginStrongLockAcquire(locallock, fasthashcode);
        if (!FastPathTransferRelationLocks(lockMethodTable, locktag,
                                           hashcode))
        {
            AbortStrongLockAcquire();
            if (locallock->nLocks == 0)
                RemoveLocalLock(locallock);
            if (locallockp)
                *locallockp = NULL;
            if (reportMemoryError)
                ereport(ERROR,
                        (errcode(ERRCODE_OUT_OF_MEMORY),
                         errmsg("out of shared memory"),
                         errhint("You might need to increase max_locks_per_transaction.")));
            else
                return LOCKACQUIRE_NOT_AVAIL;
        }
    }

    /*
     * We didn't find the lock in our LOCALLOCK table, and we didn't manage to
     * take it via the fast-path, either, so we've got to mess with the shared
     * lock table.
     */
    partitionLock = LockHashPartitionLock(hashcode);

    LWLockAcquire(partitionLock, LW_EXCLUSIVE);

    /*
     * Find or create lock and proclock entries with this tag
     *
     * Note: if the locallock object already existed, it might have a pointer
     * to the lock already ... but we should not assume that that pointer is
     * valid, since a lock object with zero hold and request counts can go
     * away anytime.  So we have to use SetupLockInTable() to recompute the
     * lock and proclock pointers, even if they're already set.
     */
    proclock = SetupLockInTable(lockMethodTable, MyProc, locktag,
                                hashcode, lockmode);
    if (!proclock)
    {
        AbortStrongLockAcquire();
        LWLockRelease(partitionLock);
        if (locallock->nLocks == 0)
            RemoveLocalLock(locallock);
        if (locallockp)
            *locallockp = NULL;
        if (reportMemoryError)
            ereport(ERROR,
                    (errcode(ERRCODE_OUT_OF_MEMORY),
                     errmsg("out of shared memory"),
                     errhint("You might need to increase max_locks_per_transaction.")));
        else
            return LOCKACQUIRE_NOT_AVAIL;
    }
    locallock->proclock = proclock;
    lock = proclock->tag.myLock;
    locallock->lock = lock;

    /*
     * If lock requested conflicts with locks requested by waiters, must join
     * wait queue.  Otherwise, check for conflict with already-held locks.
     * (That's last because most complex check.)
     */
    if (lockMethodTable->conflictTab[lockmode] & lock->waitMask)
        found_conflict = true;
    else
        found_conflict = LockCheckConflicts(lockMethodTable, lockmode,
                                            lock, proclock);

    if (!found_conflict)
    {
        /* No conflict with held or previously requested locks */
        GrantLock(lock, proclock, lockmode);
        GrantLockLocal(locallock, owner);
    }
    else
    {
        /*
         * We can't acquire the lock immediately.  If caller specified no
         * blocking, remove useless table entries and return
         * LOCKACQUIRE_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);
            if (locallockp)
                *locallockp = NULL;
            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;
}

LockCheckConflicts()

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

Definition at line 1420 of file lock.c.

References Assert, LockMethodData::conflictTab, elog, LOCK::granted, LOCK::grantMask, PROCLOCK::groupLeader, PROCLOCK::holdMask, i, LOCK_LOCKTAG, LOCKBIT_ON, PGPROC::lockGroupLeader, PROCLOCK::lockLink, TwoPhaseLockRecord::lockmode, LOCKTAG_PAGE, LOCKTAG_RELATION_EXTEND, MAX_LOCKMODES, MyProc, PROCLOCKTAG::myProc, LockMethodData::numLockModes, offsetof, PANIC, PROCLOCK_PRINT, LOCK::procLocks, SHMQueueNext(), 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 false;
    }

    /*
     * Rats.  Something conflicts.  But it could still be my own lock, or a
     * lock held by another member of my locking group.  First, figure out how
     * many conflicts remain after subtracting out any locks I hold myself.
     */
    myLocks = proclock->holdMask;
    for (i = 1; i <= numLockModes; i++)
    {
        if ((conflictMask & LOCKBIT_ON(i)) == 0)
        {
            conflictsRemaining[i] = 0;
            continue;
        }
        conflictsRemaining[i] = lock->granted[i];
        if (myLocks & LOCKBIT_ON(i))
            --conflictsRemaining[i];
        totalConflictsRemaining += conflictsRemaining[i];
    }

    /* If no conflicts remain, we get the lock. */
    if (totalConflictsRemaining == 0)
    {
        PROCLOCK_PRINT("LockCheckConflicts: resolved (simple)", proclock);
        return false;
    }

    /* If no group locking, it's definitely a conflict. */
    if (proclock->groupLeader == MyProc && MyProc->lockGroupLeader == NULL)
    {
        Assert(proclock->tag.myProc == MyProc);
        PROCLOCK_PRINT("LockCheckConflicts: conflicting (simple)",
                       proclock);
        return true;
    }

    /*
     * The relation extension or page lock conflict even between the group
     * members.
     */
    if (LOCK_LOCKTAG(*lock) == LOCKTAG_RELATION_EXTEND ||
        (LOCK_LOCKTAG(*lock) == LOCKTAG_PAGE))
    {
        PROCLOCK_PRINT("LockCheckConflicts: conflicting (group)",
                       proclock);
        return true;
    }

    /*
     * Locks held in conflicting modes by members of our own lock group are
     * not real conflicts; we can subtract those out and see if we still have
     * a conflict.  This is O(N) in the number of processes holding or
     * awaiting locks on this object.  We could improve that by making the
     * shared memory state more complex (and larger) but it doesn't seem worth
     * it.
     */
    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 false;
            }
        }
        otherproclock = (PROCLOCK *)
            SHMQueueNext(procLocks, &otherproclock->lockLink,
                         offsetof(PROCLOCK, lockLink));
    }

    /* Nope, it's a real conflict. */
    PROCLOCK_PRINT("LockCheckConflicts: conflicting (group)", proclock);
    return true;
}

LockHasWaiters()

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

Definition at line 634 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, TwoPhaseLockRecord::lockmode, LockMethodData::lockModeNames, TwoPhaseLockRecord::locktag, 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;
}

LockHeldByMe()

bool LockHeldByMe	(	const LOCKTAG *	locktag,
		LOCKMODE	lockmode
	)

Definition at line 598 of file lock.c.

References HASH_FIND, hash_search(), LOCALLOCKTAG::lock, LockMethodLocalHash, TwoPhaseLockRecord::lockmode, TwoPhaseLockRecord::locktag, MemSet, LOCALLOCKTAG::mode, and LOCALLOCK::nLocks.

Referenced by CheckRelationLockedByMe().

{
    LOCALLOCKTAG localtag;
    LOCALLOCK  *locallock;

    /*
     * See if there is a LOCALLOCK entry for this lock and lockmode
     */
    MemSet(&localtag, 0, sizeof(localtag)); /* must clear padding */
    localtag.lock = *locktag;
    localtag.mode = lockmode;

    locallock = (LOCALLOCK *) hash_search(LockMethodLocalHash,
                                          (void *) &localtag,
                                          HASH_FIND, NULL);

    return (locallock && locallock->nLocks > 0);
}

LockReassignCurrentOwner()

void LockReassignCurrentOwner	(	LOCALLOCK **	locallocks,
		int	nlocks
	)

Definition at line 2579 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);
    }
}

LockReassignOwner()

static void LockReassignOwner ( LOCALLOCK *  locallock, ResourceOwner  parent  )

static

Definition at line 2609 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);
}

LockRefindAndRelease()

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

static

Definition at line 3133 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, TwoPhaseLockRecord::locktag, 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);
    }
}

LockRelease()

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

Definition at line 1975 of file lock.c.

References Assert, CleanUpLock(), CurrentResourceOwner, EligibleForRelationFastPath, elog, ERROR, FastPathLocalUseCount, FastPathUnGrantRelationLock(), PGPROC::fpInfoLock, HASH_FIND, hash_search(), hash_search_with_hash_value(), LOCALLOCK::hashcode, PROCLOCK::holdMask, i, lengthof, LOCALLOCKTAG::lock, LOCALLOCK::lock, LOCK_PRINT, LOCKBIT_ON, LOCALLOCK::lockCleared, LockHashPartitionLock, TwoPhaseLockRecord::lockmode, LockMethodData::lockModeNames, LOCALLOCK::lockOwners, TwoPhaseLockRecord::locktag, LOCKTAG::locktag_field1, LOCKTAG::locktag_field2, LOCKTAG::locktag_lockmethodid, LOG, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MemSet, LOCALLOCKTAG::mode, PROCLOCKTAG::myLock, MyProc, PROCLOCKTAG::myProc, LOCALLOCK::nLocks, LockMethodData::numLockModes, LOCALLOCK::numLockOwners, LOCALLOCK::proclock, PROCLOCK_PRINT, RemoveLocalLock(), ResourceOwnerForgetLock(), UnGrantLock(), and WARNING.

Referenced by ConditionalXactLockTableWait(), pg_advisory_unlock_int4(), pg_advisory_unlock_int8(), pg_advisory_unlock_shared_int4(), pg_advisory_unlock_shared_int8(), ReleaseLockIfHeld(), SpeculativeInsertionLockRelease(), SpeculativeInsertionWait(), StandbyReleaseLockList(), 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;

    /*
     * At this point we can no longer suppose we are clear of invalidation
     * messages related to this lock.  Although we'll delete the LOCALLOCK
     * object before any intentional return from this routine, it seems worth
     * the trouble to explicitly reset lockCleared right now, just in case
     * some error prevents us from deleting the LOCALLOCK.
     */
    locallock->lockCleared = false;

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

    /*
     * Otherwise we've got to mess with the shared lock table.
     */
    partitionLock = LockHashPartitionLock(locallock->hashcode);

    LWLockAcquire(partitionLock, LW_EXCLUSIVE);

    /*
     * Normally, we don't need to re-find the lock or proclock, since we kept
     * their addresses in the locallock table, and they couldn't have been
     * removed while we were holding a lock on them.  But it's possible that
     * the lock was taken fast-path and has since been moved to the main hash
     * table by another backend, in which case we will need to look up the
     * objects here.  We assume the lock field is NULL if so.
     */
    lock = locallock->lock;
    if (!lock)
    {
        PROCLOCKTAG proclocktag;

        Assert(EligibleForRelationFastPath(locktag, lockmode));
        lock = (LOCK *) hash_search_with_hash_value(LockMethodLockHash,
                                                    (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;
}

LockReleaseAll()

void LockReleaseAll	(	LOCKMETHODID	lockmethodid,
		bool	allLocks
	)

Definition at line 2180 of file lock.c.

References Assert, CleanUpLock(), DEFAULT_LOCKMETHOD, EligibleForRelationFastPath, elog, ERROR, FastPathUnGrantRelationLock(), PGPROC::fpInfoLock, 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, TwoPhaseLockRecord::lockmode, 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->fpInfoLock, LW_EXCLUSIVE);
                have_fast_path_lwlock = true;
            }

            /* Attempt fast-path release. */
            relid = locallock->tag.lock.locktag_field2;
            if (FastPathUnGrantRelationLock(relid, lockmode))
            {
                RemoveLocalLock(locallock);
                continue;
            }

            /*
             * Our lock, originally taken via the fast path, has been
             * transferred to the main lock table.  That's going to require
             * some extra work, so release our fast-path lock before starting.
             */
            LWLockRelease(&MyProc->fpInfoLock);
            have_fast_path_lwlock = false;

            /*
             * Now dump the lock.  We haven't got a pointer to the LOCK or
             * PROCLOCK in this case, so we have to handle this a bit
             * differently than a normal lock release.  Unfortunately, this
             * requires an extra LWLock acquire-and-release cycle on the
             * partitionLock, but hopefully it shouldn't happen often.
             */
            LockRefindAndRelease(lockMethodTable, MyProc,
                                 &locallock->tag.lock, lockmode, false);
            RemoveLocalLock(locallock);
            continue;
        }

        /* Mark the proclock to show we need to release this lockmode */
        if (locallock->nLocks > 0)
            locallock->proclock->releaseMask |= LOCKBIT_ON(locallock->tag.mode);

        /* And remove the locallock hashtable entry */
        RemoveLocalLock(locallock);
    }

    /* Done with the fast-path data structures */
    if (have_fast_path_lwlock)
        LWLockRelease(&MyProc->fpInfoLock);

    /*
     * Now, scan each lock partition separately.
     */
    for (partition = 0; partition < NUM_LOCK_PARTITIONS; partition++)
    {
        LWLock     *partitionLock;
        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
}

LockReleaseCurrentOwner()

void LockReleaseCurrentOwner	(	LOCALLOCK **	locallocks,
		int	nlocks
	)

Definition at line 2484 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);
    }
}

LockReleaseSession()

void LockReleaseSession

(

LOCKMETHODID

lockmethodid

)

Definition at line 2454 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);
    }
}

LockShmemSize()

Size LockShmemSize

(

void

)

Definition at line 3532 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;
}

LockTagHashCode()

uint32 LockTagHashCode

(

const LOCKTAG *

locktag

)

Definition at line 517 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);
}

LockWaiterCount()

int LockWaiterCount

(

const LOCKTAG *

locktag

)

Definition at line 4558 of file lock.c.

References Assert, elog, ERROR, HASH_FIND, hash_search_with_hash_value(), lengthof, LockHashPartitionLock, TwoPhaseLockRecord::locktag, 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;
}

MarkLockClear()

void MarkLockClear

(

LOCALLOCK *

locallock

)

Definition at line 1799 of file lock.c.

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

Referenced by ConditionalLockRelation(), ConditionalLockRelationOid(), LockRelation(), and LockRelationOid().

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

PostPrepare_Locks()

void PostPrepare_Locks

(

TransactionId

xid

)

Definition at line 3340 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, false);
    HASH_SEQ_STATUS status;
    LOCALLOCK  *locallock;
    LOCK       *lock;
    PROCLOCK   *proclock;
    PROCLOCKTAG proclocktag;
    int         partition;

    /* Can't prepare a lock group follower. */
    Assert(MyProc->lockGroupLeader == NULL ||
           MyProc->lockGroupLeader == MyProc);

    /* This is a critical section: any error means big trouble */
    START_CRIT_SECTION();

    /*
     * First we run through the locallock table and get rid of unwanted
     * entries, then we scan the process's proclocks and transfer them to the
     * target proc.
     *
     * We do this separately because we may have multiple locallock entries
     * pointing to the same proclock, and we daren't end up with any dangling
     * pointers.
     */
    hash_seq_init(&status, LockMethodLocalHash);

    while ((locallock = (LOCALLOCK *) hash_seq_search(&status)) != NULL)
    {
        LOCALLOCKOWNER *lockOwners = locallock->lockOwners;
        bool        haveSessionLock;
        bool        haveXactLock;
        int         i;

        if (locallock->proclock == NULL || locallock->lock == NULL)
        {
            /*
             * We must've run out of shared memory while trying to set up this
             * lock.  Just forget the local entry.
             */
            Assert(locallock->nLocks == 0);
            RemoveLocalLock(locallock);
            continue;
        }

        /* Ignore VXID locks */
        if (locallock->tag.lock.locktag_type == LOCKTAG_VIRTUALTRANSACTION)