lmgr.h File Reference

#include "lib/stringinfo.h"
#include "storage/itemptr.h"
#include "storage/lock.h"
#include "utils/rel.h"

Include dependency graph for lmgr.h:

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

Go to the source code of this file.

Typedefs
typedef enum XLTW_Oper	XLTW_Oper

Enumerations
enum	XLTW_Oper {   XLTW_None, XLTW_Update, XLTW_Delete, XLTW_Lock,   XLTW_LockUpdated, XLTW_InsertIndex, XLTW_InsertIndexUnique, XLTW_FetchUpdated,   XLTW_RecheckExclusionConstr }

Functions
void	RelationInitLockInfo (Relation relation)
void	LockRelationOid (Oid relid, LOCKMODE lockmode)
bool	ConditionalLockRelationOid (Oid relid, LOCKMODE lockmode)
void	UnlockRelationId (LockRelId *relid, LOCKMODE lockmode)
void	UnlockRelationOid (Oid relid, LOCKMODE lockmode)
void	LockRelation (Relation relation, LOCKMODE lockmode)
bool	ConditionalLockRelation (Relation relation, LOCKMODE lockmode)
void	UnlockRelation (Relation relation, LOCKMODE lockmode)
bool	CheckRelationLockedByMe (Relation relation, LOCKMODE lockmode, bool orstronger)
bool	LockHasWaitersRelation (Relation relation, LOCKMODE lockmode)
void	LockRelationIdForSession (LockRelId *relid, LOCKMODE lockmode)
void	UnlockRelationIdForSession (LockRelId *relid, LOCKMODE lockmode)
void	LockRelationForExtension (Relation relation, LOCKMODE lockmode)
void	UnlockRelationForExtension (Relation relation, LOCKMODE lockmode)
bool	ConditionalLockRelationForExtension (Relation relation, LOCKMODE lockmode)
int	RelationExtensionLockWaiterCount (Relation relation)
void	LockPage (Relation relation, BlockNumber blkno, LOCKMODE lockmode)
bool	ConditionalLockPage (Relation relation, BlockNumber blkno, LOCKMODE lockmode)
void	UnlockPage (Relation relation, BlockNumber blkno, LOCKMODE lockmode)
void	LockTuple (Relation relation, ItemPointer tid, LOCKMODE lockmode)
bool	ConditionalLockTuple (Relation relation, ItemPointer tid, LOCKMODE lockmode)
void	UnlockTuple (Relation relation, ItemPointer tid, LOCKMODE lockmode)
void	XactLockTableInsert (TransactionId xid)
void	XactLockTableDelete (TransactionId xid)
void	XactLockTableWait (TransactionId xid, Relation rel, ItemPointer ctid, XLTW_Oper oper)
bool	ConditionalXactLockTableWait (TransactionId xid)
void	WaitForLockers (LOCKTAG heaplocktag, LOCKMODE lockmode, bool progress)
void	WaitForLockersMultiple (List *locktags, LOCKMODE lockmode, bool progress)
uint32	SpeculativeInsertionLockAcquire (TransactionId xid)
void	SpeculativeInsertionLockRelease (TransactionId xid)
void	SpeculativeInsertionWait (TransactionId xid, uint32 token)
void	LockDatabaseObject (Oid classid, Oid objid, uint16 objsubid, LOCKMODE lockmode)
void	UnlockDatabaseObject (Oid classid, Oid objid, uint16 objsubid, LOCKMODE lockmode)
void	LockSharedObject (Oid classid, Oid objid, uint16 objsubid, LOCKMODE lockmode)
void	UnlockSharedObject (Oid classid, Oid objid, uint16 objsubid, LOCKMODE lockmode)
void	LockSharedObjectForSession (Oid classid, Oid objid, uint16 objsubid, LOCKMODE lockmode)
void	UnlockSharedObjectForSession (Oid classid, Oid objid, uint16 objsubid, LOCKMODE lockmode)
void	DescribeLockTag (StringInfo buf, const LOCKTAG *tag)
const char *	GetLockNameFromTagType (uint16 locktag_type)

Typedef Documentation

XLTW_Oper

typedef enum XLTW_Oper XLTW_Oper

Enumeration Type Documentation

XLTW_Oper

enum XLTW_Oper

Enumerator
XLTW_None
XLTW_Update
XLTW_Delete
XLTW_Lock
XLTW_LockUpdated
XLTW_InsertIndex
XLTW_InsertIndexUnique
XLTW_FetchUpdated
XLTW_RecheckExclusionConstr

Definition at line 24 of file lmgr.h.

{
    XLTW_None,
    XLTW_Update,
    XLTW_Delete,
    XLTW_Lock,
    XLTW_LockUpdated,
    XLTW_InsertIndex,
    XLTW_InsertIndexUnique,
    XLTW_FetchUpdated,
    XLTW_RecheckExclusionConstr
} XLTW_Oper;

Function Documentation

CheckRelationLockedByMe()

bool CheckRelationLockedByMe	(	Relation	relation,
		LOCKMODE	lockmode,
		bool	orstronger
	)

Definition at line 302 of file lmgr.c.

References LockRelId::dbId, elog, GetLockmodeName(), LockHeldByMe(), LockInfoData::lockRelId, LOCKTAG::locktag_lockmethodid, MaxLockMode, RelationData::rd_lockInfo, RelationGetRelationName, LockRelId::relId, SET_LOCKTAG_RELATION, and WARNING.

Referenced by addRangeTableEntryForRelation(), ExecGetRangeTableRelation(), ExtractReplicaIdentity(), relation_open(), and try_relation_open().

{
    LOCKTAG     tag;

    SET_LOCKTAG_RELATION(tag,
                         relation->rd_lockInfo.lockRelId.dbId,
                         relation->rd_lockInfo.lockRelId.relId);

    if (LockHeldByMe(&tag, lockmode))
        return true;

    if (orstronger)
    {
        LOCKMODE    slockmode;

        for (slockmode = lockmode + 1;
             slockmode <= MaxLockMode;
             slockmode++)
        {
            if (LockHeldByMe(&tag, slockmode))
            {
#ifdef NOT_USED
                /* Sometimes this might be useful for debugging purposes */
                elog(WARNING, "lock mode %s substituted for %s on relation %s",
                     GetLockmodeName(tag.locktag_lockmethodid, slockmode),
                     GetLockmodeName(tag.locktag_lockmethodid, lockmode),
                     RelationGetRelationName(relation));
#endif
                return true;
            }
        }
    }

    return false;
}

ConditionalLockPage()

bool ConditionalLockPage	(	Relation	relation,
		BlockNumber	blkno,
		LOCKMODE	lockmode
	)

Definition at line 489 of file lmgr.c.

References LockRelId::dbId, LockAcquire(), LOCKACQUIRE_NOT_AVAIL, LockInfoData::lockRelId, RelationData::rd_lockInfo, LockRelId::relId, and SET_LOCKTAG_PAGE.

Referenced by ginInsertCleanup().

{
    LOCKTAG     tag;

    SET_LOCKTAG_PAGE(tag,
                     relation->rd_lockInfo.lockRelId.dbId,
                     relation->rd_lockInfo.lockRelId.relId,
                     blkno);

    return (LockAcquire(&tag, lockmode, false, true) != LOCKACQUIRE_NOT_AVAIL);
}

ConditionalLockRelation()

bool ConditionalLockRelation	(	Relation	relation,
		LOCKMODE	lockmode
	)

Definition at line 247 of file lmgr.c.

References AcceptInvalidationMessages(), LockRelId::dbId, LOCKACQUIRE_ALREADY_CLEAR, LOCKACQUIRE_NOT_AVAIL, LockAcquireExtended(), LockInfoData::lockRelId, MarkLockClear(), RelationData::rd_lockInfo, LockRelId::relId, and SET_LOCKTAG_RELATION.

Referenced by lazy_truncate_heap().

{
    LOCKTAG     tag;
    LOCALLOCK  *locallock;
    LockAcquireResult res;

    SET_LOCKTAG_RELATION(tag,
                         relation->rd_lockInfo.lockRelId.dbId,
                         relation->rd_lockInfo.lockRelId.relId);

    res = LockAcquireExtended(&tag, lockmode, false, true, true, &locallock);

    if (res == LOCKACQUIRE_NOT_AVAIL)
        return false;

    /*
     * Now that we have the lock, check for invalidation messages; see notes
     * in LockRelationOid.
     */
    if (res != LOCKACQUIRE_ALREADY_CLEAR)
    {
        AcceptInvalidationMessages();
        MarkLockClear(locallock);
    }

    return true;
}

ConditionalLockRelationForExtension()

bool ConditionalLockRelationForExtension	(	Relation	relation,
		LOCKMODE	lockmode
	)

Definition at line 420 of file lmgr.c.

References LockRelId::dbId, LockAcquire(), LOCKACQUIRE_NOT_AVAIL, LockInfoData::lockRelId, RelationData::rd_lockInfo, LockRelId::relId, and SET_LOCKTAG_RELATION_EXTEND.

Referenced by RelationGetBufferForTuple().

{
    LOCKTAG     tag;

    SET_LOCKTAG_RELATION_EXTEND(tag,
                                relation->rd_lockInfo.lockRelId.dbId,
                                relation->rd_lockInfo.lockRelId.relId);

    return (LockAcquire(&tag, lockmode, false, true) != LOCKACQUIRE_NOT_AVAIL);
}

ConditionalLockRelationOid()

bool ConditionalLockRelationOid	(	Oid	relid,
		LOCKMODE	lockmode
	)

Definition at line 151 of file lmgr.c.

References AcceptInvalidationMessages(), LOCKACQUIRE_ALREADY_CLEAR, LOCKACQUIRE_NOT_AVAIL, LockAcquireExtended(), MarkLockClear(), and SetLocktagRelationOid().

Referenced by AlterTableMoveAll(), do_autovacuum(), LockTableRecurse(), LockViewRecurse_walker(), RangeVarGetRelidExtended(), and vacuum_open_relation().

{
    LOCKTAG     tag;
    LOCALLOCK  *locallock;
    LockAcquireResult res;

    SetLocktagRelationOid(&tag, relid);

    res = LockAcquireExtended(&tag, lockmode, false, true, true, &locallock);

    if (res == LOCKACQUIRE_NOT_AVAIL)
        return false;

    /*
     * Now that we have the lock, check for invalidation messages; see notes
     * in LockRelationOid.
     */
    if (res != LOCKACQUIRE_ALREADY_CLEAR)
    {
        AcceptInvalidationMessages();
        MarkLockClear(locallock);
    }

    return true;
}

ConditionalLockTuple()

bool ConditionalLockTuple	(	Relation	relation,
		ItemPointer	tid,
		LOCKMODE	lockmode
	)

Definition at line 545 of file lmgr.c.

References LockRelId::dbId, ItemPointerGetBlockNumber, ItemPointerGetOffsetNumber, LockAcquire(), LOCKACQUIRE_NOT_AVAIL, LockInfoData::lockRelId, RelationData::rd_lockInfo, LockRelId::relId, and SET_LOCKTAG_TUPLE.

{
    LOCKTAG     tag;

    SET_LOCKTAG_TUPLE(tag,
                      relation->rd_lockInfo.lockRelId.dbId,
                      relation->rd_lockInfo.lockRelId.relId,
                      ItemPointerGetBlockNumber(tid),
                      ItemPointerGetOffsetNumber(tid));

    return (LockAcquire(&tag, lockmode, false, true) != LOCKACQUIRE_NOT_AVAIL);
}

ConditionalXactLockTableWait()

bool ConditionalXactLockTableWait

(

TransactionId

xid

)

Definition at line 697 of file lmgr.c.

References Assert, GetTopTransactionIdIfAny(), LockAcquire(), LOCKACQUIRE_NOT_AVAIL, LockRelease(), pg_usleep(), SET_LOCKTAG_TRANSACTION, ShareLock, SubTransGetTopmostTransaction(), TransactionIdEquals, TransactionIdIsInProgress(), and TransactionIdIsValid.

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

{
    LOCKTAG     tag;
    bool        first = true;

    for (;;)
    {
        Assert(TransactionIdIsValid(xid));
        Assert(!TransactionIdEquals(xid, GetTopTransactionIdIfAny()));

        SET_LOCKTAG_TRANSACTION(tag, xid);

        if (LockAcquire(&tag, ShareLock, false, true) == LOCKACQUIRE_NOT_AVAIL)
            return false;

        LockRelease(&tag, ShareLock, false);

        if (!TransactionIdIsInProgress(xid))
            break;

        /* See XactLockTableWait about this case */
        if (!first)
            pg_usleep(1000L);
        first = false;
        xid = SubTransGetTopmostTransaction(xid);
    }

    return true;
}

DescribeLockTag()

void DescribeLockTag	(	StringInfo	buf,
		const LOCKTAG *	tag
	)

Definition at line 1087 of file lmgr.c.

References _, appendStringInfo(), LOCKTAG_ADVISORY, LOCKTAG::locktag_field1, LOCKTAG::locktag_field2, LOCKTAG::locktag_field3, LOCKTAG::locktag_field4, LOCKTAG_OBJECT, LOCKTAG_PAGE, LOCKTAG_RELATION, LOCKTAG_RELATION_EXTEND, LOCKTAG_SPECULATIVE_TOKEN, LOCKTAG_TRANSACTION, LOCKTAG_TUPLE, LOCKTAG::locktag_type, LOCKTAG_USERLOCK, and LOCKTAG_VIRTUALTRANSACTION.

Referenced by DeadLockReport(), and ProcSleep().

{
    switch ((LockTagType) tag->locktag_type)
    {
        case LOCKTAG_RELATION:
            appendStringInfo(buf,
                             _("relation %u of database %u"),
                             tag->locktag_field2,
                             tag->locktag_field1);
            break;
        case LOCKTAG_RELATION_EXTEND:
            appendStringInfo(buf,
                             _("extension of relation %u of database %u"),
                             tag->locktag_field2,
                             tag->locktag_field1);
            break;
        case LOCKTAG_PAGE:
            appendStringInfo(buf,
                             _("page %u of relation %u of database %u"),
                             tag->locktag_field3,
                             tag->locktag_field2,
                             tag->locktag_field1);
            break;
        case LOCKTAG_TUPLE:
            appendStringInfo(buf,
                             _("tuple (%u,%u) of relation %u of database %u"),
                             tag->locktag_field3,
                             tag->locktag_field4,
                             tag->locktag_field2,
                             tag->locktag_field1);
            break;
        case LOCKTAG_TRANSACTION:
            appendStringInfo(buf,
                             _("transaction %u"),
                             tag->locktag_field1);
            break;
        case LOCKTAG_VIRTUALTRANSACTION:
            appendStringInfo(buf,
                             _("virtual transaction %d/%u"),
                             tag->locktag_field1,
                             tag->locktag_field2);
            break;
        case LOCKTAG_SPECULATIVE_TOKEN:
            appendStringInfo(buf,
                             _("speculative token %u of transaction %u"),
                             tag->locktag_field2,
                             tag->locktag_field1);
            break;
        case LOCKTAG_OBJECT:
            appendStringInfo(buf,
                             _("object %u of class %u of database %u"),
                             tag->locktag_field3,
                             tag->locktag_field2,
                             tag->locktag_field1);
            break;
        case LOCKTAG_USERLOCK:
            /* reserved for old contrib code, now on pgfoundry */
            appendStringInfo(buf,
                             _("user lock [%u,%u,%u]"),
                             tag->locktag_field1,
                             tag->locktag_field2,
                             tag->locktag_field3);
            break;
        case LOCKTAG_ADVISORY:
            appendStringInfo(buf,
                             _("advisory lock [%u,%u,%u,%u]"),
                             tag->locktag_field1,
                             tag->locktag_field2,
                             tag->locktag_field3,
                             tag->locktag_field4);
            break;
        default:
            appendStringInfo(buf,
                             _("unrecognized locktag type %d"),
                             (int) tag->locktag_type);
            break;
    }
}

GetLockNameFromTagType()

const char* GetLockNameFromTagType

(

uint16

locktag_type

)

Definition at line 1172 of file lmgr.c.

References LOCKTAG_LAST_TYPE, and LockTagTypeNames.

Referenced by pgstat_get_wait_event().

{
    if (locktag_type > LOCKTAG_LAST_TYPE)
        return "???";
    return LockTagTypeNames[locktag_type];
}

LockDatabaseObject()

void LockDatabaseObject	(	Oid	classid,
		Oid	objid,
		uint16	objsubid,
		LOCKMODE	lockmode
	)

Definition at line 963 of file lmgr.c.

References AcceptInvalidationMessages(), LockAcquire(), MyDatabaseId, and SET_LOCKTAG_OBJECT.

Referenced by AcquireDeletionLock(), AddEnumLabel(), get_object_address(), RangeVarGetAndCheckCreationNamespace(), and RenameEnumLabel().

{
    LOCKTAG     tag;

    SET_LOCKTAG_OBJECT(tag,
                       MyDatabaseId,
                       classid,
                       objid,
                       objsubid);

    (void) LockAcquire(&tag, lockmode, false, false);

    /* Make sure syscaches are up-to-date with any changes we waited for */
    AcceptInvalidationMessages();
}

LockHasWaitersRelation()

bool LockHasWaitersRelation	(	Relation	relation,
		LOCKMODE	lockmode
	)

Definition at line 345 of file lmgr.c.

References LockRelId::dbId, LockHasWaiters(), LockInfoData::lockRelId, RelationData::rd_lockInfo, LockRelId::relId, and SET_LOCKTAG_RELATION.

Referenced by count_nondeletable_pages().

{
    LOCKTAG     tag;

    SET_LOCKTAG_RELATION(tag,
                         relation->rd_lockInfo.lockRelId.dbId,
                         relation->rd_lockInfo.lockRelId.relId);

    return LockHasWaiters(&tag, lockmode, false);
}

LockPage()

void LockPage	(	Relation	relation,
		BlockNumber	blkno,
		LOCKMODE	lockmode
	)

Definition at line 470 of file lmgr.c.

References LockRelId::dbId, LockAcquire(), LockInfoData::lockRelId, RelationData::rd_lockInfo, LockRelId::relId, and SET_LOCKTAG_PAGE.

Referenced by ginInsertCleanup().

{
    LOCKTAG     tag;

    SET_LOCKTAG_PAGE(tag,
                     relation->rd_lockInfo.lockRelId.dbId,
                     relation->rd_lockInfo.lockRelId.relId,
                     blkno);

    (void) LockAcquire(&tag, lockmode, false, false);
}

LockRelation()

void LockRelation	(	Relation	relation,
		LOCKMODE	lockmode
	)

Definition at line 216 of file lmgr.c.

References AcceptInvalidationMessages(), LockRelId::dbId, LOCKACQUIRE_ALREADY_CLEAR, LockAcquireExtended(), LockInfoData::lockRelId, MarkLockClear(), RelationData::rd_lockInfo, LockRelId::relId, and SET_LOCKTAG_RELATION.

Referenced by index_create().

{
    LOCKTAG     tag;
    LOCALLOCK  *locallock;
    LockAcquireResult res;

    SET_LOCKTAG_RELATION(tag,
                         relation->rd_lockInfo.lockRelId.dbId,
                         relation->rd_lockInfo.lockRelId.relId);

    res = LockAcquireExtended(&tag, lockmode, false, false, true, &locallock);

    /*
     * Now that we have the lock, check for invalidation messages; see notes
     * in LockRelationOid.
     */
    if (res != LOCKACQUIRE_ALREADY_CLEAR)
    {
        AcceptInvalidationMessages();
        MarkLockClear(locallock);
    }
}

LockRelationForExtension()

void LockRelationForExtension	(	Relation	relation,
		LOCKMODE	lockmode
	)

Definition at line 402 of file lmgr.c.

References LockRelId::dbId, LockAcquire(), LockInfoData::lockRelId, RelationData::rd_lockInfo, LockRelId::relId, and SET_LOCKTAG_RELATION_EXTEND.

Referenced by _bt_getbuf(), BloomNewBuffer(), brin_getinsertbuffer(), brin_page_cleanup(), btvacuumscan(), fsm_extend(), GinNewBuffer(), ginvacuumcleanup(), gistNewBuffer(), gistvacuumscan(), pgstat_index(), RelationGetBufferForTuple(), revmap_physical_extend(), SpGistNewBuffer(), spgvacuumscan(), and vm_extend().

{
    LOCKTAG     tag;

    SET_LOCKTAG_RELATION_EXTEND(tag,
                                relation->rd_lockInfo.lockRelId.dbId,
                                relation->rd_lockInfo.lockRelId.relId);

    (void) LockAcquire(&tag, lockmode, false, false);
}

LockRelationIdForSession()

void LockRelationIdForSession	(	LockRelId *	relid,
		LOCKMODE	lockmode
	)

Definition at line 369 of file lmgr.c.

References LockRelId::dbId, LockAcquire(), LockRelId::relId, and SET_LOCKTAG_RELATION.

Referenced by DefineIndex(), index_drop(), ReindexRelationConcurrently(), and vacuum_rel().

{
    LOCKTAG     tag;

    SET_LOCKTAG_RELATION(tag, relid->dbId, relid->relId);

    (void) LockAcquire(&tag, lockmode, true, false);
}

LockRelationOid()

void LockRelationOid	(	Oid	relid,
		LOCKMODE	lockmode
	)

Definition at line 108 of file lmgr.c.

References AcceptInvalidationMessages(), LOCKACQUIRE_ALREADY_CLEAR, LockAcquireExtended(), MarkLockClear(), and SetLocktagRelationOid().

Referenced by AcquireDeletionLock(), AcquireExecutorLocks(), AlterTableMoveAll(), ATExecAttachPartition(), ATExecDetachPartition(), ATPostAlterTypeCleanup(), copy_table_data(), CreateTrigger(), ExecRefreshMatView(), find_inheritance_children(), heap_drop_with_catalog(), InitCatCachePhase2(), load_critical_index(), lock_and_open_sequence(), LockTableRecurse(), LockViewRecurse_walker(), pg_replication_origin_advance(), RangeVarCallbackForAttachIndex(), RangeVarCallbackForDropRelation(), RangeVarCallbackForReindexIndex(), RangeVarGetAndCheckCreationNamespace(), RangeVarGetRelidExtended(), relation_open(), ScanQueryForLocks(), and try_relation_open().

{
    LOCKTAG     tag;
    LOCALLOCK  *locallock;
    LockAcquireResult res;

    SetLocktagRelationOid(&tag, relid);

    res = LockAcquireExtended(&tag, lockmode, false, false, true, &locallock);

    /*
     * Now that we have the lock, check for invalidation messages, so that we
     * will update or flush any stale relcache entry before we try to use it.
     * RangeVarGetRelid() specifically relies on us for this.  We can skip
     * this in the not-uncommon case that we already had the same type of lock
     * being requested, since then no one else could have modified the
     * relcache entry in an undesirable way.  (In the case where our own xact
     * modifies the rel, the relcache update happens via
     * CommandCounterIncrement, not here.)
     *
     * However, in corner cases where code acts on tables (usually catalogs)
     * recursively, we might get here while still processing invalidation
     * messages in some outer execution of this function or a sibling.  The
     * "cleared" status of the lock tells us whether we really are done
     * absorbing relevant inval messages.
     */
    if (res != LOCKACQUIRE_ALREADY_CLEAR)
    {
        AcceptInvalidationMessages();
        MarkLockClear(locallock);
    }
}

LockSharedObject()

void LockSharedObject	(	Oid	classid,
		Oid	objid,
		uint16	objsubid,
		LOCKMODE	lockmode
	)

Definition at line 1004 of file lmgr.c.

References AcceptInvalidationMessages(), InvalidOid, LockAcquire(), and SET_LOCKTAG_OBJECT.

Referenced by AddSubscriptionRelState(), AlterSubscription(), DropRole(), DropSubscription(), get_db_info(), get_object_address(), InitPostgres(), PreCommit_Notify(), shdepLockAndCheckObject(), and UpdateSubscriptionRelState().

{
    LOCKTAG     tag;

    SET_LOCKTAG_OBJECT(tag,
                       InvalidOid,
                       classid,
                       objid,
                       objsubid);

    (void) LockAcquire(&tag, lockmode, false, false);

    /* Make sure syscaches are up-to-date with any changes we waited for */
    AcceptInvalidationMessages();
}

LockSharedObjectForSession()

void LockSharedObjectForSession	(	Oid	classid,
		Oid	objid,
		uint16	objsubid,
		LOCKMODE	lockmode
	)

Definition at line 1046 of file lmgr.c.

References InvalidOid, LockAcquire(), and SET_LOCKTAG_OBJECT.

Referenced by dbase_redo(), and movedb().

{
    LOCKTAG     tag;

    SET_LOCKTAG_OBJECT(tag,
                       InvalidOid,
                       classid,
                       objid,
                       objsubid);

    (void) LockAcquire(&tag, lockmode, true, false);
}

LockTuple()

void LockTuple	(	Relation	relation,
		ItemPointer	tid,
		LOCKMODE	lockmode
	)

Definition at line 525 of file lmgr.c.

References LockRelId::dbId, ItemPointerGetBlockNumber, ItemPointerGetOffsetNumber, LockAcquire(), LockInfoData::lockRelId, RelationData::rd_lockInfo, LockRelId::relId, and SET_LOCKTAG_TUPLE.

{
    LOCKTAG     tag;

    SET_LOCKTAG_TUPLE(tag,
                      relation->rd_lockInfo.lockRelId.dbId,
                      relation->rd_lockInfo.lockRelId.relId,
                      ItemPointerGetBlockNumber(tid),
                      ItemPointerGetOffsetNumber(tid));

    (void) LockAcquire(&tag, lockmode, false, false);
}

RelationExtensionLockWaiterCount()

int RelationExtensionLockWaiterCount

(

Relation

relation

)

Definition at line 437 of file lmgr.c.

References LockRelId::dbId, LockInfoData::lockRelId, LockWaiterCount(), RelationData::rd_lockInfo, LockRelId::relId, and SET_LOCKTAG_RELATION_EXTEND.

Referenced by RelationAddExtraBlocks().

{
    LOCKTAG     tag;

    SET_LOCKTAG_RELATION_EXTEND(tag,
                                relation->rd_lockInfo.lockRelId.dbId,
                                relation->rd_lockInfo.lockRelId.relId);

    return LockWaiterCount(&tag);
}

RelationInitLockInfo()

void RelationInitLockInfo

(

Relation

relation

)

Definition at line 71 of file lmgr.c.

References Assert, LockRelId::dbId, InvalidOid, LockInfoData::lockRelId, MyDatabaseId, OidIsValid, RelationData::rd_lockInfo, RelationData::rd_rel, RelationGetRelid, RelationIsValid, and LockRelId::relId.

Referenced by formrdesc(), load_relcache_init_file(), RelationBuildDesc(), and RelationBuildLocalRelation().

{
    Assert(RelationIsValid(relation));
    Assert(OidIsValid(RelationGetRelid(relation)));

    relation->rd_lockInfo.lockRelId.relId = RelationGetRelid(relation);

    if (relation->rd_rel->relisshared)
        relation->rd_lockInfo.lockRelId.dbId = InvalidOid;
    else
        relation->rd_lockInfo.lockRelId.dbId = MyDatabaseId;
}

SpeculativeInsertionLockAcquire()

uint32 SpeculativeInsertionLockAcquire

(

TransactionId

xid

)

Definition at line 739 of file lmgr.c.

References ExclusiveLock, LockAcquire(), SET_LOCKTAG_SPECULATIVE_INSERTION, and speculativeInsertionToken.

Referenced by ExecInsert().

{
    LOCKTAG     tag;

    speculativeInsertionToken++;

    /*
     * Check for wrap-around. Zero means no token is held, so don't use that.
     */
    if (speculativeInsertionToken == 0)
        speculativeInsertionToken = 1;

    SET_LOCKTAG_SPECULATIVE_INSERTION(tag, xid, speculativeInsertionToken);

    (void) LockAcquire(&tag, ExclusiveLock, false, false);

    return speculativeInsertionToken;
}

SpeculativeInsertionLockRelease()

void SpeculativeInsertionLockRelease

(

TransactionId

xid

)

Definition at line 765 of file lmgr.c.

References ExclusiveLock, LockRelease(), SET_LOCKTAG_SPECULATIVE_INSERTION, and speculativeInsertionToken.

Referenced by ExecInsert().

{
    LOCKTAG     tag;

    SET_LOCKTAG_SPECULATIVE_INSERTION(tag, xid, speculativeInsertionToken);

    LockRelease(&tag, ExclusiveLock, false);
}

SpeculativeInsertionWait()

void SpeculativeInsertionWait	(	TransactionId	xid,
		uint32	token
	)

Definition at line 781 of file lmgr.c.

References Assert, LockAcquire(), LockRelease(), SET_LOCKTAG_SPECULATIVE_INSERTION, ShareLock, and TransactionIdIsValid.

Referenced by _bt_doinsert(), and check_exclusion_or_unique_constraint().

{
    LOCKTAG     tag;

    SET_LOCKTAG_SPECULATIVE_INSERTION(tag, xid, token);

    Assert(TransactionIdIsValid(xid));
    Assert(token != 0);

    (void) LockAcquire(&tag, ShareLock, false, false);
    LockRelease(&tag, ShareLock, false);
}

UnlockDatabaseObject()

void UnlockDatabaseObject	(	Oid	classid,
		Oid	objid,
		uint16	objsubid,
		LOCKMODE	lockmode
	)

Definition at line 984 of file lmgr.c.

References LockRelease(), MyDatabaseId, and SET_LOCKTAG_OBJECT.

Referenced by get_object_address(), RangeVarGetAndCheckCreationNamespace(), and ReleaseDeletionLock().

{
    LOCKTAG     tag;

    SET_LOCKTAG_OBJECT(tag,
                       MyDatabaseId,
                       classid,
                       objid,
                       objsubid);

    LockRelease(&tag, lockmode, false);
}

UnlockPage()

void UnlockPage	(	Relation	relation,
		BlockNumber	blkno,
		LOCKMODE	lockmode
	)

Definition at line 505 of file lmgr.c.

References LockRelId::dbId, LockRelease(), LockInfoData::lockRelId, RelationData::rd_lockInfo, LockRelId::relId, and SET_LOCKTAG_PAGE.

Referenced by ginInsertCleanup().

{
    LOCKTAG     tag;

    SET_LOCKTAG_PAGE(tag,
                     relation->rd_lockInfo.lockRelId.dbId,
                     relation->rd_lockInfo.lockRelId.relId,
                     blkno);

    LockRelease(&tag, lockmode, false);
}

UnlockRelation()

void UnlockRelation	(	Relation	relation,
		LOCKMODE	lockmode
	)

Definition at line 282 of file lmgr.c.

References LockRelId::dbId, LockRelease(), LockInfoData::lockRelId, RelationData::rd_lockInfo, LockRelId::relId, and SET_LOCKTAG_RELATION.

Referenced by lazy_truncate_heap().

{
    LOCKTAG     tag;

    SET_LOCKTAG_RELATION(tag,
                         relation->rd_lockInfo.lockRelId.dbId,
                         relation->rd_lockInfo.lockRelId.relId);

    LockRelease(&tag, lockmode, false);
}

UnlockRelationForExtension()

void UnlockRelationForExtension	(	Relation	relation,
		LOCKMODE	lockmode
	)

Definition at line 452 of file lmgr.c.

References LockRelId::dbId, LockRelease(), LockInfoData::lockRelId, RelationData::rd_lockInfo, LockRelId::relId, and SET_LOCKTAG_RELATION_EXTEND.

Referenced by _bt_getbuf(), BloomNewBuffer(), brin_getinsertbuffer(), brin_page_cleanup(), btvacuumscan(), fsm_extend(), GinNewBuffer(), ginvacuumcleanup(), gistNewBuffer(), gistvacuumscan(), pgstat_index(), RelationGetBufferForTuple(), revmap_physical_extend(), SpGistNewBuffer(), spgvacuumscan(), and vm_extend().

{
    LOCKTAG     tag;

    SET_LOCKTAG_RELATION_EXTEND(tag,
                                relation->rd_lockInfo.lockRelId.dbId,
                                relation->rd_lockInfo.lockRelId.relId);

    LockRelease(&tag, lockmode, false);
}

UnlockRelationId()

void UnlockRelationId	(	LockRelId *	relid,
		LOCKMODE	lockmode
	)

Definition at line 184 of file lmgr.c.

References LockRelId::dbId, LockRelease(), LockRelId::relId, and SET_LOCKTAG_RELATION.

Referenced by index_close(), and relation_close().

{
    LOCKTAG     tag;

    SET_LOCKTAG_RELATION(tag, relid->dbId, relid->relId);

    LockRelease(&tag, lockmode, false);
}

UnlockRelationIdForSession()

void UnlockRelationIdForSession	(	LockRelId *	relid,
		LOCKMODE	lockmode
	)

Definition at line 382 of file lmgr.c.

References LockRelId::dbId, LockRelease(), LockRelId::relId, and SET_LOCKTAG_RELATION.

Referenced by DefineIndex(), index_drop(), ReindexRelationConcurrently(), and vacuum_rel().

{
    LOCKTAG     tag;

    SET_LOCKTAG_RELATION(tag, relid->dbId, relid->relId);

    LockRelease(&tag, lockmode, true);
}

UnlockRelationOid()

void UnlockRelationOid	(	Oid	relid,
		LOCKMODE	lockmode
	)

Definition at line 199 of file lmgr.c.

References LockRelease(), and SetLocktagRelationOid().

Referenced by AcquireExecutorLocks(), do_autovacuum(), expand_vacuum_rel(), find_inheritance_children(), InitCatCachePhase2(), load_critical_index(), LockTableRecurse(), pg_replication_origin_advance(), RangeVarCallbackForAttachIndex(), RangeVarCallbackForDropRelation(), RangeVarCallbackForReindexIndex(), RangeVarGetAndCheckCreationNamespace(), RangeVarGetRelidExtended(), ReleaseDeletionLock(), ScanQueryForLocks(), and try_relation_open().

{
    LOCKTAG     tag;

    SetLocktagRelationOid(&tag, relid);

    LockRelease(&tag, lockmode, false);
}

UnlockSharedObject()

void UnlockSharedObject	(	Oid	classid,
		Oid	objid,
		uint16	objsubid,
		LOCKMODE	lockmode
	)

Definition at line 1025 of file lmgr.c.

References InvalidOid, LockRelease(), and SET_LOCKTAG_OBJECT.

Referenced by AlterDatabaseSet(), createdb_failure_callback(), get_db_info(), and get_object_address().

{
    LOCKTAG     tag;

    SET_LOCKTAG_OBJECT(tag,
                       InvalidOid,
                       classid,
                       objid,
                       objsubid);

    LockRelease(&tag, lockmode, false);
}

UnlockSharedObjectForSession()

void UnlockSharedObjectForSession	(	Oid	classid,
		Oid	objid,
		uint16	objsubid,
		LOCKMODE	lockmode
	)

Definition at line 1064 of file lmgr.c.

References InvalidOid, LockRelease(), and SET_LOCKTAG_OBJECT.

Referenced by dbase_redo(), and movedb().

{
    LOCKTAG     tag;

    SET_LOCKTAG_OBJECT(tag,
                       InvalidOid,
                       classid,
                       objid,
                       objsubid);

    LockRelease(&tag, lockmode, true);
}

UnlockTuple()

void UnlockTuple	(	Relation	relation,
		ItemPointer	tid,
		LOCKMODE	lockmode
	)

Definition at line 562 of file lmgr.c.

References LockRelId::dbId, ItemPointerGetBlockNumber, ItemPointerGetOffsetNumber, LockRelease(), LockInfoData::lockRelId, RelationData::rd_lockInfo, LockRelId::relId, and SET_LOCKTAG_TUPLE.

{
    LOCKTAG     tag;

    SET_LOCKTAG_TUPLE(tag,
                      relation->rd_lockInfo.lockRelId.dbId,
                      relation->rd_lockInfo.lockRelId.relId,
                      ItemPointerGetBlockNumber(tid),
                      ItemPointerGetOffsetNumber(tid));

    LockRelease(&tag, lockmode, false);
}

WaitForLockers()

void WaitForLockers	(	LOCKTAG	heaplocktag,
		LOCKMODE	lockmode,
		bool	progress
	)

Definition at line 944 of file lmgr.c.

References list_free(), list_make1, and WaitForLockersMultiple().

Referenced by DefineIndex(), and index_drop().

{
    List       *l;

    l = list_make1(&heaplocktag);
    WaitForLockersMultiple(l, lockmode, progress);
    list_free(l);
}

WaitForLockersMultiple()

void WaitForLockersMultiple	(	List *	locktags,
		LOCKMODE	lockmode,
		bool	progress
	)

Definition at line 863 of file lmgr.c.

References VirtualTransactionId::backendId, BackendIdGetProc(), GetLockConflicts(), lappend(), lfirst, list_free_deep(), list_length(), NIL, pgstat_progress_update_multi_param(), pgstat_progress_update_param(), PGPROC::pid, PROGRESS_WAITFOR_CURRENT_PID, PROGRESS_WAITFOR_DONE, PROGRESS_WAITFOR_TOTAL, values, VirtualTransactionIdIsValid, and VirtualXactLock().

Referenced by ReindexRelationConcurrently(), and WaitForLockers().

{
    List       *holders = NIL;
    ListCell   *lc;
    int         total = 0;
    int         done = 0;

    /* Done if no locks to wait for */
    if (list_length(locktags) == 0)
        return;

    /* Collect the transactions we need to wait on */
    foreach(lc, locktags)
    {
        LOCKTAG    *locktag = lfirst(lc);
        int         count;

        holders = lappend(holders,
                          GetLockConflicts(locktag, lockmode,
                                           progress ? &count : NULL));
        if (progress)
            total += count;
    }

    if (progress)
        pgstat_progress_update_param(PROGRESS_WAITFOR_TOTAL, total);

    /*
     * Note: GetLockConflicts() never reports our own xid, hence we need not
     * check for that.  Also, prepared xacts are not reported, which is fine
     * since they certainly aren't going to do anything anymore.
     */

    /* Finally wait for each such transaction to complete */
    foreach(lc, holders)
    {
        VirtualTransactionId *lockholders = lfirst(lc);

        while (VirtualTransactionIdIsValid(*lockholders))
        {
            /*
             * If requested, publish who we're going to wait for.  This is not
             * 100% accurate if they're already gone, but we don't care.
             */
            if (progress)
            {
                PGPROC     *holder = BackendIdGetProc(lockholders->backendId);

                pgstat_progress_update_param(PROGRESS_WAITFOR_CURRENT_PID,
                                             holder->pid);
            }
            VirtualXactLock(*lockholders, true);
            lockholders++;

            if (progress)
                pgstat_progress_update_param(PROGRESS_WAITFOR_DONE, ++done);
        }
    }
    if (progress)
    {
        const int   index[] = {
            PROGRESS_WAITFOR_TOTAL,
            PROGRESS_WAITFOR_DONE,
            PROGRESS_WAITFOR_CURRENT_PID
        };
        const int64 values[] = {
            0, 0, 0
        };

        pgstat_progress_update_multi_param(3, index, values);
    }

    list_free_deep(holders);
}

XactLockTableDelete()

void XactLockTableDelete

(

TransactionId

xid

)

Definition at line 600 of file lmgr.c.

References ExclusiveLock, LockRelease(), and SET_LOCKTAG_TRANSACTION.

Referenced by CommitSubTransaction().

{
    LOCKTAG     tag;

    SET_LOCKTAG_TRANSACTION(tag, xid);

    LockRelease(&tag, ExclusiveLock, false);
}

XactLockTableInsert()

void XactLockTableInsert

(

TransactionId

xid

)

Definition at line 583 of file lmgr.c.

References ExclusiveLock, LockAcquire(), and SET_LOCKTAG_TRANSACTION.

Referenced by AssignTransactionId().

{
    LOCKTAG     tag;

    SET_LOCKTAG_TRANSACTION(tag, xid);

    (void) LockAcquire(&tag, ExclusiveLock, false, false);
}

XactLockTableWait()

void XactLockTableWait	(	TransactionId	xid,
		Relation	rel,
		ItemPointer	ctid,
		XLTW_Oper	oper
	)

Definition at line 624 of file lmgr.c.

References ErrorContextCallback::arg, Assert, callback(), ErrorContextCallback::callback, XactLockTableWaitInfo::ctid, error_context_stack, GetTopTransactionIdIfAny(), ItemPointerIsValid, LockAcquire(), LockRelease(), XactLockTableWaitInfo::oper, pg_usleep(), ErrorContextCallback::previous, XactLockTableWaitInfo::rel, RelationIsValid, SET_LOCKTAG_TRANSACTION, ShareLock, SubTransGetTopmostTransaction(), TransactionIdEquals, TransactionIdIsInProgress(), TransactionIdIsValid, XactLockTableWaitErrorCb(), and XLTW_None.

Referenced by _bt_doinsert(), check_exclusion_or_unique_constraint(), Do_MultiXactIdWait(), heap_delete(), heap_lock_tuple(), heap_lock_updated_tuple_rec(), heap_update(), heapam_index_build_range_scan(), heapam_tuple_lock(), RelationFindReplTupleByIndex(), RelationFindReplTupleSeq(), and SnapBuildWaitSnapshot().

{
    LOCKTAG     tag;
    XactLockTableWaitInfo info;
    ErrorContextCallback callback;
    bool        first = true;

    /*
     * If an operation is specified, set up our verbose error context
     * callback.
     */
    if (oper != XLTW_None)
    {
        Assert(RelationIsValid(rel));
        Assert(ItemPointerIsValid(ctid));

        info.rel = rel;
        info.ctid = ctid;
        info.oper = oper;

        callback.callback = XactLockTableWaitErrorCb;
        callback.arg = &info;
        callback.previous = error_context_stack;
        error_context_stack = &callback;
    }

    for (;;)
    {
        Assert(TransactionIdIsValid(xid));
        Assert(!TransactionIdEquals(xid, GetTopTransactionIdIfAny()));

        SET_LOCKTAG_TRANSACTION(tag, xid);

        (void) LockAcquire(&tag, ShareLock, false, false);

        LockRelease(&tag, ShareLock, false);

        if (!TransactionIdIsInProgress(xid))
            break;

        /*
         * If the Xid belonged to a subtransaction, then the lock would have
         * gone away as soon as it was finished; for correct tuple visibility,
         * the right action is to wait on its parent transaction to go away.
         * But instead of going levels up one by one, we can just wait for the
         * topmost transaction to finish with the same end result, which also
         * incurs less locktable traffic.
         *
         * Some uses of this function don't involve tuple visibility -- such
         * as when building snapshots for logical decoding.  It is possible to
         * see a transaction in ProcArray before it registers itself in the
         * locktable.  The topmost transaction in that case is the same xid,
         * so we try again after a short sleep.  (Don't sleep the first time
         * through, to avoid slowing down the normal case.)
         */
        if (!first)
            pg_usleep(1000L);
        first = false;
        xid = SubTransGetTopmostTransaction(xid);
    }

    if (oper != XLTW_None)
        error_context_stack = callback.previous;
}