lmgr.c File Reference

#include "postgres.h"
#include "access/subtrans.h"
#include "access/transam.h"
#include "access/xact.h"
#include "catalog/catalog.h"
#include "commands/progress.h"
#include "miscadmin.h"
#include "pgstat.h"
#include "storage/lmgr.h"
#include "storage/proc.h"
#include "storage/procarray.h"
#include "storage/sinvaladt.h"
#include "utils/inval.h"

Include dependency graph for lmgr.c:

Go to the source code of this file.

Data Structures
struct	XactLockTableWaitInfo

Typedefs
typedef struct XactLockTableWaitInfo	XactLockTableWaitInfo

Functions
static void	XactLockTableWaitErrorCb (void *arg)
void	RelationInitLockInfo (Relation relation)
static void	SetLocktagRelationOid (LOCKTAG *tag, Oid relid)
void	LockRelationOid (Oid relid, LOCKMODE lockmode)
bool	ConditionalLockRelationOid (Oid relid, LOCKMODE lockmode)
void	LockRelationId (LockRelId *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)
bool	ConditionalLockRelationForExtension (Relation relation, LOCKMODE lockmode)
int	RelationExtensionLockWaiterCount (Relation relation)
void	UnlockRelationForExtension (Relation relation, LOCKMODE lockmode)
void	LockDatabaseFrozenIds (LOCKMODE lockmode)
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)
uint32	SpeculativeInsertionLockAcquire (TransactionId xid)
void	SpeculativeInsertionLockRelease (TransactionId xid)
void	SpeculativeInsertionWait (TransactionId xid, uint32 token)
void	WaitForLockersMultiple (List *locktags, LOCKMODE lockmode, bool progress)
void	WaitForLockers (LOCKTAG heaplocktag, LOCKMODE lockmode, bool progress)
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	LockApplyTransactionForSession (Oid suboid, TransactionId xid, uint16 objid, LOCKMODE lockmode)
void	UnlockApplyTransactionForSession (Oid suboid, TransactionId xid, uint16 objid, LOCKMODE lockmode)
void	DescribeLockTag (StringInfo buf, const LOCKTAG *tag)
const char *	GetLockNameFromTagType (uint16 locktag_type)

Variables
static uint32	speculativeInsertionToken = 0

Typedef Documentation

XactLockTableWaitInfo

typedef struct XactLockTableWaitInfo XactLockTableWaitInfo

Function Documentation

CheckRelationLockedByMe()

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

Definition at line 331 of file lmgr.c.

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

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(), relation_open(), and try_relation_open().

ConditionalLockPage()

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

Definition at line 533 of file lmgr.c.

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

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

Referenced by ginInsertCleanup().

ConditionalLockRelation()

bool ConditionalLockRelation	(	Relation	relation,
		LOCKMODE	lockmode
	)

Definition at line 276 of file lmgr.c.

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

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

Referenced by lazy_truncate_heap().

ConditionalLockRelationForExtension()

bool ConditionalLockRelationForExtension	(	Relation	relation,
		LOCKMODE	lockmode
	)

Definition at line 449 of file lmgr.c.

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

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

ConditionalLockRelationOid()

bool ConditionalLockRelationOid	(	Oid	relid,
		LOCKMODE	lockmode
	)

Definition at line 152 of file lmgr.c.

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

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

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

ConditionalLockTuple()

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

Definition at line 589 of file lmgr.c.

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

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

ConditionalXactLockTableWait()

bool ConditionalXactLockTableWait

(

TransactionId

xid

)

Definition at line 741 of file lmgr.c.

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

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

DescribeLockTag()

void DescribeLockTag	(	StringInfo	buf,
		const LOCKTAG *	tag
	)

Definition at line 1168 of file lmgr.c.

{
    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_DATABASE_FROZEN_IDS:
            appendStringInfo(buf,
                             _("pg_database.datfrozenxid of database %u"),
                             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;
        case LOCKTAG_APPLY_TRANSACTION:
            appendStringInfo(buf,
                             _("remote transaction %u of subscription %u of database %u"),
                             tag->locktag_field3,
                             tag->locktag_field2,
                             tag->locktag_field1);
            break;
        default:
            appendStringInfo(buf,
                             _("unrecognized locktag type %d"),
                             (int) tag->locktag_type);
            break;
    }
}

References _, appendStringInfo(), buf, LOCKTAG_ADVISORY, LOCKTAG_APPLY_TRANSACTION, LOCKTAG_DATABASE_FROZEN_IDS, 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().

GetLockNameFromTagType()

const char* GetLockNameFromTagType

(

uint16

locktag_type

)

Definition at line 1265 of file lmgr.c.

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

References LOCKTAG_LAST_TYPE, and LockTagTypeNames.

Referenced by pgstat_get_wait_event().

LockApplyTransactionForSession()

void LockApplyTransactionForSession	(	Oid	suboid,
		TransactionId	xid,
		uint16	objid,
		LOCKMODE	lockmode
	)

Definition at line 1128 of file lmgr.c.

{
    LOCKTAG     tag;
 
    SET_LOCKTAG_APPLY_TRANSACTION(tag,
                                  MyDatabaseId,
                                  suboid,
                                  xid,
                                  objid);
 
    (void) LockAcquire(&tag, lockmode, true, false);
}

References LockAcquire(), MyDatabaseId, and SET_LOCKTAG_APPLY_TRANSACTION.

Referenced by pa_lock_stream(), and pa_lock_transaction().

LockDatabaseFrozenIds()

void LockDatabaseFrozenIds

(

LOCKMODE

lockmode

)

Definition at line 498 of file lmgr.c.

{
    LOCKTAG     tag;
 
    SET_LOCKTAG_DATABASE_FROZEN_IDS(tag, MyDatabaseId);
 
    (void) LockAcquire(&tag, lockmode, false, false);
}

References LockAcquire(), MyDatabaseId, and SET_LOCKTAG_DATABASE_FROZEN_IDS.

Referenced by vac_update_datfrozenxid().

LockDatabaseObject()

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

Definition at line 1005 of file lmgr.c.

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

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

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

LockHasWaitersRelation()

bool LockHasWaitersRelation	(	Relation	relation,
		LOCKMODE	lockmode
	)

Definition at line 374 of file lmgr.c.

{
    LOCKTAG     tag;
 
    SET_LOCKTAG_RELATION(tag,
                         relation->rd_lockInfo.lockRelId.dbId,
                         relation->rd_lockInfo.lockRelId.relId);
 
    return LockHasWaiters(&tag, lockmode, false);
}

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

Referenced by count_nondeletable_pages().

LockPage()

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

Definition at line 514 of file lmgr.c.

{
    LOCKTAG     tag;
 
    SET_LOCKTAG_PAGE(tag,
                     relation->rd_lockInfo.lockRelId.dbId,
                     relation->rd_lockInfo.lockRelId.relId,
                     blkno);
 
    (void) LockAcquire(&tag, lockmode, false, false);
}

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

Referenced by ginInsertCleanup().

LockRelation()

void LockRelation	(	Relation	relation,
		LOCKMODE	lockmode
	)

Definition at line 245 of file lmgr.c.

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

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

Referenced by index_create().

LockRelationForExtension()

void LockRelationForExtension	(	Relation	relation,
		LOCKMODE	lockmode
	)

Definition at line 431 of file lmgr.c.

{
    LOCKTAG     tag;
 
    SET_LOCKTAG_RELATION_EXTEND(tag,
                                relation->rd_lockInfo.lockRelId.dbId,
                                relation->rd_lockInfo.lockRelId.relId);
 
    (void) LockAcquire(&tag, lockmode, false, false);
}

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

Referenced by brin_getinsertbuffer(), brin_page_cleanup(), btvacuumscan(), ExtendBufferedRelShared(), ExtendBufferedRelTo(), ginvacuumcleanup(), gistvacuumscan(), pgstat_index(), and spgvacuumscan().

LockRelationId()

void LockRelationId	(	LockRelId *	relid,
		LOCKMODE	lockmode
	)

Definition at line 185 of file lmgr.c.

{
    LOCKTAG     tag;
    LOCALLOCK  *locallock;
    LockAcquireResult res;
 
    SET_LOCKTAG_RELATION(tag, relid->dbId, relid->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);
    }
}

References AcceptInvalidationMessages(), LockRelId::dbId, LOCKACQUIRE_ALREADY_CLEAR, LockAcquireExtended(), MarkLockClear(), LockRelId::relId, res, and SET_LOCKTAG_RELATION.

Referenced by CreateDatabaseUsingWalLog(), and ScanSourceDatabasePgClass().

LockRelationIdForSession()

void LockRelationIdForSession	(	LockRelId *	relid,
		LOCKMODE	lockmode
	)

Definition at line 398 of file lmgr.c.

{
    LOCKTAG     tag;
 
    SET_LOCKTAG_RELATION(tag, relid->dbId, relid->relId);
 
    (void) LockAcquire(&tag, lockmode, true, false);
}

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

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

LockRelationOid()

void LockRelationOid	(	Oid	relid,
		LOCKMODE	lockmode
	)

Definition at line 109 of file lmgr.c.

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

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

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

LockSharedObject()

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

Definition at line 1046 of file lmgr.c.

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

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

Referenced by AcquireDeletionLock(), AddRoleMems(), AddSubscriptionRelState(), AlterSubscription(), clear_subscription_skip_lsn(), createdb(), DelRoleMems(), DisableSubscription(), DropRole(), DropSubscription(), get_db_info(), get_object_address(), InitPostgres(), PreCommit_Notify(), replorigin_drop_by_name(), shdepLockAndCheckObject(), and UpdateSubscriptionRelState().

LockSharedObjectForSession()

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

Definition at line 1088 of file lmgr.c.

{
    LOCKTAG     tag;
 
    SET_LOCKTAG_OBJECT(tag,
                       InvalidOid,
                       classid,
                       objid,
                       objsubid);
 
    (void) LockAcquire(&tag, lockmode, true, false);
}

References InvalidOid, LockAcquire(), and SET_LOCKTAG_OBJECT.

Referenced by dbase_redo(), and movedb().

LockTuple()

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

Definition at line 569 of file lmgr.c.

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

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

RelationExtensionLockWaiterCount()

int RelationExtensionLockWaiterCount

(

Relation

relation

)

Definition at line 466 of file lmgr.c.

{
    LOCKTAG     tag;
 
    SET_LOCKTAG_RELATION_EXTEND(tag,
                                relation->rd_lockInfo.lockRelId.dbId,
                                relation->rd_lockInfo.lockRelId.relId);
 
    return LockWaiterCount(&tag);
}

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

Referenced by RelationAddBlocks().

RelationInitLockInfo()

void RelationInitLockInfo

(

Relation

relation

)

Definition at line 72 of file lmgr.c.

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

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

SetLocktagRelationOid()

static void SetLocktagRelationOid ( LOCKTAG *  tag, Oid  relid  )

inlinestatic

Definition at line 90 of file lmgr.c.

{
    Oid         dbid;
 
    if (IsSharedRelation(relid))
        dbid = InvalidOid;
    else
        dbid = MyDatabaseId;
 
    SET_LOCKTAG_RELATION(*tag, dbid, relid);
}

References InvalidOid, IsSharedRelation(), MyDatabaseId, and SET_LOCKTAG_RELATION.

Referenced by ConditionalLockRelationOid(), LockRelationOid(), and UnlockRelationOid().

SpeculativeInsertionLockAcquire()

uint32 SpeculativeInsertionLockAcquire

(

TransactionId

xid

)

Definition at line 783 of file lmgr.c.

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

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

Referenced by ExecInsert().

SpeculativeInsertionLockRelease()

void SpeculativeInsertionLockRelease

(

TransactionId

xid

)

Definition at line 809 of file lmgr.c.

{
    LOCKTAG     tag;
 
    SET_LOCKTAG_SPECULATIVE_INSERTION(tag, xid, speculativeInsertionToken);
 
    LockRelease(&tag, ExclusiveLock, false);
}

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

Referenced by ExecInsert().

SpeculativeInsertionWait()

void SpeculativeInsertionWait	(	TransactionId	xid,
		uint32	token
	)

Definition at line 825 of file lmgr.c.

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

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

Referenced by _bt_doinsert(), and check_exclusion_or_unique_constraint().

UnlockApplyTransactionForSession()

void UnlockApplyTransactionForSession	(	Oid	suboid,
		TransactionId	xid,
		uint16	objid,
		LOCKMODE	lockmode
	)

Definition at line 1146 of file lmgr.c.

{
    LOCKTAG     tag;
 
    SET_LOCKTAG_APPLY_TRANSACTION(tag,
                                  MyDatabaseId,
                                  suboid,
                                  xid,
                                  objid);
 
    LockRelease(&tag, lockmode, true);
}

References LockRelease(), MyDatabaseId, and SET_LOCKTAG_APPLY_TRANSACTION.

Referenced by pa_unlock_stream(), and pa_unlock_transaction().

UnlockDatabaseObject()

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

Definition at line 1026 of file lmgr.c.

{
    LOCKTAG     tag;
 
    SET_LOCKTAG_OBJECT(tag,
                       MyDatabaseId,
                       classid,
                       objid,
                       objsubid);
 
    LockRelease(&tag, lockmode, false);
}

References LockRelease(), MyDatabaseId, and SET_LOCKTAG_OBJECT.

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

UnlockPage()

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

Definition at line 549 of file lmgr.c.

{
    LOCKTAG     tag;
 
    SET_LOCKTAG_PAGE(tag,
                     relation->rd_lockInfo.lockRelId.dbId,
                     relation->rd_lockInfo.lockRelId.relId,
                     blkno);
 
    LockRelease(&tag, lockmode, false);
}

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

Referenced by ginInsertCleanup().

UnlockRelation()

void UnlockRelation	(	Relation	relation,
		LOCKMODE	lockmode
	)

Definition at line 311 of file lmgr.c.

{
    LOCKTAG     tag;
 
    SET_LOCKTAG_RELATION(tag,
                         relation->rd_lockInfo.lockRelId.dbId,
                         relation->rd_lockInfo.lockRelId.relId);
 
    LockRelease(&tag, lockmode, false);
}

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

Referenced by lazy_truncate_heap().

UnlockRelationForExtension()

void UnlockRelationForExtension	(	Relation	relation,
		LOCKMODE	lockmode
	)

Definition at line 481 of file lmgr.c.

{
    LOCKTAG     tag;
 
    SET_LOCKTAG_RELATION_EXTEND(tag,
                                relation->rd_lockInfo.lockRelId.dbId,
                                relation->rd_lockInfo.lockRelId.relId);
 
    LockRelease(&tag, lockmode, false);
}

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

Referenced by brin_getinsertbuffer(), brin_page_cleanup(), btvacuumscan(), ExtendBufferedRelShared(), ExtendBufferedRelTo(), ginvacuumcleanup(), gistvacuumscan(), pgstat_index(), and spgvacuumscan().

UnlockRelationId()

void UnlockRelationId	(	LockRelId *	relid,
		LOCKMODE	lockmode
	)

Definition at line 213 of file lmgr.c.

{
    LOCKTAG     tag;
 
    SET_LOCKTAG_RELATION(tag, relid->dbId, relid->relId);
 
    LockRelease(&tag, lockmode, false);
}

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

Referenced by CreateDatabaseUsingWalLog(), index_close(), relation_close(), and ScanSourceDatabasePgClass().

UnlockRelationIdForSession()

void UnlockRelationIdForSession	(	LockRelId *	relid,
		LOCKMODE	lockmode
	)

Definition at line 411 of file lmgr.c.

{
    LOCKTAG     tag;
 
    SET_LOCKTAG_RELATION(tag, relid->dbId, relid->relId);
 
    LockRelease(&tag, lockmode, true);
}

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

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

UnlockRelationOid()

void UnlockRelationOid	(	Oid	relid,
		LOCKMODE	lockmode
	)

Definition at line 228 of file lmgr.c.

{
    LOCKTAG     tag;
 
    SetLocktagRelationOid(&tag, relid);
 
    LockRelease(&tag, lockmode, false);
}

References LockRelease(), and SetLocktagRelationOid().

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

UnlockSharedObject()

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

Definition at line 1067 of file lmgr.c.

{
    LOCKTAG     tag;
 
    SET_LOCKTAG_OBJECT(tag,
                       InvalidOid,
                       classid,
                       objid,
                       objsubid);
 
    LockRelease(&tag, lockmode, false);
}

References InvalidOid, LockRelease(), and SET_LOCKTAG_OBJECT.

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

UnlockSharedObjectForSession()

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

Definition at line 1106 of file lmgr.c.

{
    LOCKTAG     tag;
 
    SET_LOCKTAG_OBJECT(tag,
                       InvalidOid,
                       classid,
                       objid,
                       objsubid);
 
    LockRelease(&tag, lockmode, true);
}

References InvalidOid, LockRelease(), and SET_LOCKTAG_OBJECT.

Referenced by dbase_redo(), and movedb().

UnlockTuple()

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

Definition at line 606 of file lmgr.c.

{
    LOCKTAG     tag;
 
    SET_LOCKTAG_TUPLE(tag,
                      relation->rd_lockInfo.lockRelId.dbId,
                      relation->rd_lockInfo.lockRelId.relId,
                      ItemPointerGetBlockNumber(tid),
                      ItemPointerGetOffsetNumber(tid));
 
    LockRelease(&tag, lockmode, false);
}

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

WaitForLockers()

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

Definition at line 986 of file lmgr.c.

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

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

Referenced by DefineIndex(), and index_drop().

WaitForLockersMultiple()

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

Definition at line 908 of file lmgr.c.

{
    List       *holders = NIL;
    ListCell   *lc;
    int         total = 0;
    int         done = 0;
 
    /* Done if no locks to wait for */
    if (locktags == NIL)
        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 reported and awaited.
     */
 
    /* 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. */
            if (progress)
            {
                PGPROC     *holder = BackendIdGetProc(lockholders->backendId);
 
                if (holder)
                    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);
}

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

Referenced by ATExecDetachPartition(), ReindexRelationConcurrently(), and WaitForLockers().

XactLockTableDelete()

void XactLockTableDelete

(

TransactionId

xid

)

Definition at line 644 of file lmgr.c.

{
    LOCKTAG     tag;
 
    SET_LOCKTAG_TRANSACTION(tag, xid);
 
    LockRelease(&tag, ExclusiveLock, false);
}

References ExclusiveLock, LockRelease(), and SET_LOCKTAG_TRANSACTION.

Referenced by CommitSubTransaction().

XactLockTableInsert()

void XactLockTableInsert

(

TransactionId

xid

)

Definition at line 627 of file lmgr.c.

{
    LOCKTAG     tag;
 
    SET_LOCKTAG_TRANSACTION(tag, xid);
 
    (void) LockAcquire(&tag, ExclusiveLock, false, false);
}

References ExclusiveLock, LockAcquire(), and SET_LOCKTAG_TRANSACTION.

Referenced by AssignTransactionId().

XactLockTableWait()

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

Definition at line 668 of file lmgr.c.

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

References Assert(), callback(), XactLockTableWaitInfo::ctid, error_context_stack, GetTopTransactionIdIfAny(), ItemPointerIsValid(), LockAcquire(), LockRelease(), oper(), XactLockTableWaitInfo::oper, pg_usleep(), 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().

XactLockTableWaitErrorCb()

static void XactLockTableWaitErrorCb ( void *  arg )

static

Definition at line 843 of file lmgr.c.

{
    XactLockTableWaitInfo *info = (XactLockTableWaitInfo *) arg;
 
    /*
     * We would like to print schema name too, but that would require a
     * syscache lookup.
     */
    if (info->oper != XLTW_None &&
        ItemPointerIsValid(info->ctid) && RelationIsValid(info->rel))
    {
        const char *cxt;
 
        switch (info->oper)
        {
            case XLTW_Update:
                cxt = gettext_noop("while updating tuple (%u,%u) in relation \"%s\"");
                break;
            case XLTW_Delete:
                cxt = gettext_noop("while deleting tuple (%u,%u) in relation \"%s\"");
                break;
            case XLTW_Lock:
                cxt = gettext_noop("while locking tuple (%u,%u) in relation \"%s\"");
                break;
            case XLTW_LockUpdated:
                cxt = gettext_noop("while locking updated version (%u,%u) of tuple in relation \"%s\"");
                break;
            case XLTW_InsertIndex:
                cxt = gettext_noop("while inserting index tuple (%u,%u) in relation \"%s\"");
                break;
            case XLTW_InsertIndexUnique:
                cxt = gettext_noop("while checking uniqueness of tuple (%u,%u) in relation \"%s\"");
                break;
            case XLTW_FetchUpdated:
                cxt = gettext_noop("while rechecking updated tuple (%u,%u) in relation \"%s\"");
                break;
            case XLTW_RecheckExclusionConstr:
                cxt = gettext_noop("while checking exclusion constraint on tuple (%u,%u) in relation \"%s\"");
                break;
 
            default:
                return;
        }
 
        errcontext(cxt,
                   ItemPointerGetBlockNumber(info->ctid),
                   ItemPointerGetOffsetNumber(info->ctid),
                   RelationGetRelationName(info->rel));
    }
}

References arg, XactLockTableWaitInfo::ctid, errcontext, gettext_noop, ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), ItemPointerIsValid(), XactLockTableWaitInfo::oper, XactLockTableWaitInfo::rel, RelationGetRelationName, RelationIsValid, XLTW_Delete, XLTW_FetchUpdated, XLTW_InsertIndex, XLTW_InsertIndexUnique, XLTW_Lock, XLTW_LockUpdated, XLTW_None, XLTW_RecheckExclusionConstr, and XLTW_Update.

Referenced by XactLockTableWait().

Variable Documentation

speculativeInsertionToken

uint32 speculativeInsertionToken = 0

static

Definition at line 47 of file lmgr.c.

Referenced by SpeculativeInsertionLockAcquire(), and SpeculativeInsertionLockRelease().