/*------------------------------------------------------------------------- * * lmgr . c * POSTGRES lock manager code * * Portions Copyright ( c ) 1996 - 2025 , PostgreSQL Global Development Group * Portions Copyright ( c ) 1994 , Regents of the University of California * * * IDENTIFICATION * src / backend / storage / lmgr / lmgr . c * * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #include "postgres.h" #include "access/subtrans.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 "utils/inval.h" /* * Per - backend counter for generating speculative insertion tokens . * * This may wrap around , but that ' s OK as it ' s only used for the short * duration between inserting a tuple and checking that there are no ( unique ) * constraint violations . It ' s theoretically possible that a backend sees a * tuple that was speculatively inserted by another backend , but before it has * started waiting on the token , the other backend completes its insertion , * and then performs 2 ^ 32 unrelated insertions . And after all that , the * first backend finally calls SpeculativeInsertionLockAcquire ( ) , with the * intention of waiting for the first insertion to complete , but ends up * waiting for the latest unrelated insertion instead . Even then , nothing * particularly bad happens : in the worst case they deadlock , causing one of * the transactions to abort . static uint32 speculativeInsertionToken = 0 ;/* * Struct to hold context info for transaction lock waits . * * ' oper ' is the operation that needs to wait for the other transaction ; ' rel ' * and ' ctid ' specify the address of the tuple being waited for . typedef struct XactLockTableWaitInfostatic void XactLockTableWaitErrorCb(void *arg);/* * RelationInitLockInfo * Initializes the lock information in a relation descriptor . * * relcache . c must call this during creation of any reldesc . void if (relation->rd_rel->relisshared)else /* * SetLocktagRelationOid * Set up a locktag for a relation , given only relation OID static inline void if (IsSharedRelation(relid))else /* * LockRelationOid * * Lock a relation given only its OID . This should generally be used * before attempting to open the relation ' s relcache entry . void false , false , true , &locallock,false );/* * 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)/* * ConditionalLockRelationOid * * As above , but only lock if we can get the lock without blocking . * Returns true iff the lock was acquired . * * NOTE : we do not currently need conditional versions of all the * LockXXX routines in this file , but they could easily be added if needed . bool false , true , true , &locallock,false );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)return true ;/* * LockRelationId * * Lock , given a LockRelId . Same as LockRelationOid but take LockRelId as an * input . void false , false , true , &locallock,false );/* * Now that we have the lock , check for invalidation messages ; see notes * in LockRelationOid . if (res != LOCKACQUIRE_ALREADY_CLEAR)/* * UnlockRelationId * * Unlock , given a LockRelId . This is preferred over UnlockRelationOid * for speed reasons . void false );/* * UnlockRelationOid * * Unlock , given only a relation Oid . Use UnlockRelationId if you can . void false );/* * LockRelation * * This is a convenience routine for acquiring an additional lock on an * already - open relation . Never try to do " relation_open ( foo , NoLock ) " * and then lock with this . void false , false , true , &locallock,false );/* * Now that we have the lock , check for invalidation messages ; see notes * in LockRelationOid . if (res != LOCKACQUIRE_ALREADY_CLEAR)/* * ConditionalLockRelation * * This is a convenience routine for acquiring an additional lock on an * already - open relation . Never try to do " relation_open ( foo , NoLock ) " * and then lock with this . bool false , true , true , &locallock,false );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)return true ;/* * UnlockRelation * * This is a convenience routine for unlocking a relation without also * closing it . void false );/* * CheckRelationLockedByMe * * Returns true if current transaction holds a lock on ' relation ' of mode * ' lockmode ' . If ' orstronger ' is true , a stronger lockmode is also OK . * ( " Stronger " is defined as " numerically higher " , which is a bit * semantically dubious but is OK for the purposes we use this for . ) bool bool orstronger)return LockHeldByMe(&tag, lockmode, orstronger);/* * CheckRelationOidLockedByMe * * Like the above , but takes an OID as argument . bool bool orstronger)return LockHeldByMe(&tag, lockmode, orstronger);/* * LockHasWaitersRelation * * This is a function to check whether someone else is waiting for a * lock which we are currently holding . bool return LockHasWaiters(&tag, lockmode, false );/* * LockRelationIdForSession * * This routine grabs a session - level lock on the target relation . The * session lock persists across transaction boundaries . It will be removed * when UnlockRelationIdForSession ( ) is called , or if an ereport ( ERROR ) occurs , * or if the backend exits . * * Note that one should also grab a transaction - level lock on the rel * in any transaction that actually uses the rel , to ensure that the * relcache entry is up to date . void void ) LockAcquire(&tag, lockmode, true , false );/* * UnlockRelationIdForSession void true );/* * LockRelationForExtension * * This lock tag is used to interlock addition of pages to relations . * We need such locking because bufmgr / smgr definition of P_NEW is not * race - condition - proof . * * We assume the caller is already holding some type of regular lock on * the relation , so no AcceptInvalidationMessages call is needed here . void void ) LockAcquire(&tag, lockmode, false , false );/* * ConditionalLockRelationForExtension * * As above , but only lock if we can get the lock without blocking . * Returns true iff the lock was acquired . bool return (LockAcquire(&tag, lockmode, false , true ) != LOCKACQUIRE_NOT_AVAIL);/* * RelationExtensionLockWaiterCount * * Count the number of processes waiting for the given relation extension lock . int return LockWaiterCount(&tag);/* * UnlockRelationForExtension void false );/* * LockDatabaseFrozenIds * * This allows one backend per database to execute vac_update_datfrozenxid ( ) . void void ) LockAcquire(&tag, lockmode, false , false );/* * LockPage * * Obtain a page - level lock . This is currently used by some index access * methods to lock individual index pages . void void ) LockAcquire(&tag, lockmode, false , false );/* * ConditionalLockPage * * As above , but only lock if we can get the lock without blocking . * Returns true iff the lock was acquired . bool return (LockAcquire(&tag, lockmode, false , true ) != LOCKACQUIRE_NOT_AVAIL);/* * UnlockPage void false );/* * LockTuple * * Obtain a tuple - level lock . This is used in a less - than - intuitive fashion * because we can ' t afford to keep a separate lock in shared memory for every * tuple . See heap_lock_tuple before using this ! void void ) LockAcquire(&tag, lockmode, false , false );/* * ConditionalLockTuple * * As above , but only lock if we can get the lock without blocking . * Returns true iff the lock was acquired . bool bool logLockFailure)return (LockAcquireExtended(&tag, lockmode, false , true , true , NULL,/* * UnlockTuple void false );/* * XactLockTableInsert * * Insert a lock showing that the given transaction ID is running - - - * this is done when an XID is acquired by a transaction or subtransaction . * The lock can then be used to wait for the transaction to finish . void void ) LockAcquire(&tag, ExclusiveLock, false , false );/* * XactLockTableDelete * * Delete the lock showing that the given transaction ID is running . * ( This is never used for main transaction IDs ; those locks are only * released implicitly at transaction end . But we do use it for subtrans IDs . ) void false );/* * XactLockTableWait * * Wait for the specified transaction to commit or abort . If an operation * is specified , an error context callback is set up . If ' oper ' is passed as * None , no error context callback is set up . * * Note that this does the right thing for subtransactions : if we wait on a * subtransaction , we will exit as soon as it aborts or its top parent commits . * It takes some extra work to ensure this , because to save on shared memory * the XID lock of a subtransaction is released when it ends , whether * successfully or unsuccessfully . So we have to check if it ' s " still running " * and if so wait for its parent . void bool first = true ;/* * If an operation is specified , set up our verbose error context * callback . if (oper != XLTW_None)for (;;)void ) LockAcquire(&tag, ShareLock, false , false );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)1000 L);false ;if (oper != XLTW_None)/* * ConditionalXactLockTableWait * * As above , but only lock if we can get the lock without blocking . * Returns true if the lock was acquired . bool bool logLockFailure)bool first = true ;for (;;)if (LockAcquireExtended(&tag, ShareLock, false , true , true , NULL,return false ;false );if (!TransactionIdIsInProgress(xid))break ;/* See XactLockTableWait about this case */ if (!first)1000 L);false ;return true ;/* * SpeculativeInsertionLockAcquire * * Insert a lock showing that the given transaction ID is inserting a tuple , * but hasn ' t yet decided whether it ' s going to keep it . The lock can then be * used to wait for the decision to go ahead with the insertion , or aborting * it . * * The token is used to distinguish multiple insertions by the same * transaction . It is returned to caller . /* * Check for wrap - around . Zero means no token is held , so don ' t use that . if (speculativeInsertionToken == 0 )1 ;void ) LockAcquire(&tag, ExclusiveLock, false , false );return speculativeInsertionToken;/* * SpeculativeInsertionLockRelease * * Delete the lock showing that the given transaction is speculatively * inserting a tuple . void false );/* * SpeculativeInsertionWait * * Wait for the specified transaction to finish or abort the insertion of a * tuple . void 0 );void ) LockAcquire(&tag, ShareLock, false , false );false );/* * XactLockTableWaitErrorCb * Error context callback for transaction lock waits . static void void *arg)/* * We would like to print schema name too , but that would require a * syscache lookup . if (info->oper != XLTW_None &&const char *cxt;switch (info->oper)case XLTW_Update:"while updating tuple (%u,%u) in relation \" %s\"" );break ;case XLTW_Delete:"while deleting tuple (%u,%u) in relation \" %s\"" );break ;case XLTW_Lock:"while locking tuple (%u,%u) in relation \" %s\"" );break ;case XLTW_LockUpdated:"while locking updated version (%u,%u) of tuple in relation \" %s\"" );break ;case XLTW_InsertIndex:"while inserting index tuple (%u,%u) in relation \" %s\"" );break ;case XLTW_InsertIndexUnique:"while checking uniqueness of tuple (%u,%u) in relation \" %s\"" );break ;case XLTW_FetchUpdated:"while rechecking updated tuple (%u,%u) in relation \" %s\"" );break ;case XLTW_RecheckExclusionConstr:"while checking exclusion constraint on tuple (%u,%u) in relation \" %s\"" );break ;default :return ;/* * WaitForLockersMultiple * Wait until no transaction holds locks that conflict with the given * locktags at the given lockmode . * * To do this , obtain the current list of lockers , and wait on their VXIDs * until they are finished . * * Note we don ' t try to acquire the locks on the given locktags , only the * VXIDs and XIDs of their lock holders ; if somebody grabs a conflicting lock * on the objects after we obtained our initial list of lockers , we will not * wait for them . void bool progress)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 */ int count;if (progress)if (progress)/* * 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 */ while (VirtualTransactionIdIsValid(*lockholders))/* If requested, publish who we're going to wait for. */ if (progress)if (holder)true );if (progress)if (progress)const int index[] = {const int64 values[] = {0 , 0 , 0 3 , index, values);/* * WaitForLockers * * Same as WaitForLockersMultiple , for a single lock tag . void bool progress)/* * LockDatabaseObject * * Obtain a lock on a general object of the current database . Don ' t use * this for shared objects ( such as tablespaces ) . It ' s unwise to apply it * to relations , also , since a lock taken this way will NOT conflict with * locks taken via LockRelation and friends . void void ) LockAcquire(&tag, lockmode, false , false );/* Make sure syscaches are up-to-date with any changes we waited for */ /* * ConditionalLockDatabaseObject * * As above , but only lock if we can get the lock without blocking . * Returns true iff the lock was acquired . bool false , true , true , &locallock,false );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)return true ;/* * UnlockDatabaseObject void false );/* * LockSharedObject * * Obtain a lock on a shared - across - databases object . void void ) LockAcquire(&tag, lockmode, false , false );/* Make sure syscaches are up-to-date with any changes we waited for */ /* * ConditionalLockSharedObject * * As above , but only lock if we can get the lock without blocking . * Returns true iff the lock was acquired . bool false , true , true , &locallock,false );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)return true ;/* * UnlockSharedObject void false );/* * LockSharedObjectForSession * * Obtain a session - level lock on a shared - across - databases object . * See LockRelationIdForSession for notes about session - level locks . void void ) LockAcquire(&tag, lockmode, true , false );/* * UnlockSharedObjectForSession void true );/* * LockApplyTransactionForSession * * Obtain a session - level lock on a transaction being applied on a logical * replication subscriber . See LockRelationIdForSession for notes about * session - level locks . void void ) LockAcquire(&tag, lockmode, true , false );/* * UnlockApplyTransactionForSession void true );/* * Append a description of a lockable object to buf . * * Ideally we would print names for the numeric values , but that requires * getting locks on system tables , which might cause problems since this is * typically used to report deadlock situations . void const LOCKTAG *tag)switch ((LockTagType) tag->locktag_type)case LOCKTAG_RELATION:"relation %u of database %u" ),break ;case LOCKTAG_RELATION_EXTEND:"extension of relation %u of database %u" ),break ;case LOCKTAG_DATABASE_FROZEN_IDS:"pg_database.datfrozenxid of database %u" ),break ;case LOCKTAG_PAGE:"page %u of relation %u of database %u" ),break ;case LOCKTAG_TUPLE:"tuple (%u,%u) of relation %u of database %u" ),break ;case LOCKTAG_TRANSACTION:"transaction %u" ),break ;case LOCKTAG_VIRTUALTRANSACTION:"virtual transaction %d/%u" ),break ;case LOCKTAG_SPECULATIVE_TOKEN:"speculative token %u of transaction %u" ),break ;case LOCKTAG_OBJECT:"object %u of class %u of database %u" ),break ;case LOCKTAG_USERLOCK:/* reserved for old contrib code, now on pgfoundry */ "user lock [%u,%u,%u]" ),break ;case LOCKTAG_ADVISORY:"advisory lock [%u,%u,%u,%u]" ),break ;case LOCKTAG_APPLY_TRANSACTION:"remote transaction %u of subscription %u of database %u" ),break ;default :"unrecognized locktag type %d" ),int ) tag->locktag_type);break ;/* * GetLockNameFromTagType * * Given locktag type , return the corresponding lock name . const char *if (locktag_type > LOCKTAG_LAST_TYPE)return "???" ;return LockTagTypeNames[locktag_type];
Messung V0.5 in Prozent C=92 H=95 G=93
¤ Dauer der Verarbeitung: 0.23 Sekunden
(vorverarbeitet am 2026-09-28)
¤ *© Formatika GbR, Deutschland
