/*------------------------------------------------------------------------- * * lockfuncs . c * Functions for SQL access to various lock - manager capabilities . * * Copyright ( c ) 2002 - 2025 , PostgreSQL Global Development Group * * IDENTIFICATION * src / backend / utils / adt / lockfuncs . c * * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #include "postgres.h" #include "access/htup_details.h" #include "funcapi.h" #include "miscadmin.h" #include "storage/predicate_internals.h" #include "utils/array.h" #include "utils/builtins.h" /* * This must match enum LockTagType ! Also , be sure to document any changes * in the docs for the pg_locks view and update the WaitEventLOCK section in * src / backend / utils / activity / wait_event_names . txt . const char *const LockTagTypeNames[] = {"relation" ,"extend" ,"frozenid" ,"page" ,"tuple" ,"transactionid" ,"virtualxid" ,"spectoken" ,"object" ,"userlock" ,"advisory" ,"applytransaction" 1 ),"array length mismatch" );/* This must match enum PredicateLockTargetType (predicate_internals.h) */ static const char *const PredicateLockTagTypeNames[] = {"relation" ,"page" ,"tuple" 1 ),"array length mismatch" );/* Working status for pg_lock_status */ typedef struct /* state data from lmgr */ int currIdx; /* current PROCLOCK index */ /* state data for pred locks */ int predLockIdx; /* current index for pred lock */ /* Number of columns in pg_locks output */ #define NUM_LOCK_STATUS_COLUMNS 16 /* * VXIDGetDatum - Construct a text representation of a VXID * * This is currently only used in pg_lock_status , so we put it here . static Datum/* * The representation is " < procNumber > / < lxid > " , decimal and unsigned * decimal respectively . Note that elog . c also knows how to format a * vxid . char vxidstr[32 ];sizeof (vxidstr), "%d/%u" , procNumber, lxid);return CStringGetTextDatum(vxidstr);/* * pg_lock_status - produce a view with one row per held or awaited lock mode if (SRF_IS_FIRSTCALL())/* create a function context for cross-call persistence */ /* * switch to memory context appropriate for multiple function calls /* build tupdesc for result tuples */ /* this had better match function's declaration in pg_proc.h */ 1 , "locktype" ,1 , 0 );2 , "database" ,1 , 0 );3 , "relation" ,1 , 0 );4 , "page" ,1 , 0 );5 , "tuple" ,1 , 0 );6 , "virtualxid" ,1 , 0 );7 , "transactionid" ,1 , 0 );8 , "classid" ,1 , 0 );9 , "objid" ,1 , 0 );10 , "objsubid" ,1 , 0 );11 , "virtualtransaction" ,1 , 0 );12 , "pid" ,1 , 0 );13 , "mode" ,1 , 0 );14 , "granted" ,1 , 0 );15 , "fastpath" ,1 , 0 );16 , "waitstart" ,1 , 0 );/* * Collect all the locking information that we will format and send * out as a result set . sizeof (PG_Lock_Status));0 ;0 ;while (mystatus->currIdx < lockData->nelements)bool granted;0 ;const char *locktypename;char tnbuf[32 ];0 };bool nulls[NUM_LOCK_STATUS_COLUMNS] = {0 };/* * Look to see if there are any held lock modes in this PROCLOCK . If * so , report , and destructively modify lockData so we don ' t report * again . false ;if (instance->holdMask)for (mode = 0 ; mode < MAX_LOCKMODES; mode++)if (instance->holdMask & LOCKBIT_ON(mode))true ;break ;/* * If no ( more ) held modes to report , see if PROC is waiting for a * lock on this lock . if (!granted)if (instance->waitLockMode != NoLock)/* Yes, so report it with proper mode */ /* * We are now done with this PROCLOCK , so advance pointer to * continue with next one on next call . else /* * Okay , we ' ve displayed all the locks associated with this * PROCLOCK , proceed to the next one . continue ;/* * Form tuple with appropriate data . if (instance->locktag.locktag_type <= LOCKTAG_LAST_TYPE)else sizeof (tnbuf), "unknown %d" ,int ) instance->locktag.locktag_type);0 ] = CStringGetTextDatum(locktypename);switch ((LockTagType) instance->locktag.locktag_type)case LOCKTAG_RELATION:case LOCKTAG_RELATION_EXTEND:1 ] = ObjectIdGetDatum(instance->locktag.locktag_field1);2 ] = ObjectIdGetDatum(instance->locktag.locktag_field2);3 ] = true ;4 ] = true ;5 ] = true ;6 ] = true ;7 ] = true ;8 ] = true ;9 ] = true ;break ;case LOCKTAG_DATABASE_FROZEN_IDS:1 ] = ObjectIdGetDatum(instance->locktag.locktag_field1);2 ] = true ;3 ] = true ;4 ] = true ;5 ] = true ;6 ] = true ;7 ] = true ;8 ] = true ;9 ] = true ;break ;case LOCKTAG_PAGE:1 ] = ObjectIdGetDatum(instance->locktag.locktag_field1);2 ] = ObjectIdGetDatum(instance->locktag.locktag_field2);3 ] = UInt32GetDatum(instance->locktag.locktag_field3);4 ] = true ;5 ] = true ;6 ] = true ;7 ] = true ;8 ] = true ;9 ] = true ;break ;case LOCKTAG_TUPLE:1 ] = ObjectIdGetDatum(instance->locktag.locktag_field1);2 ] = ObjectIdGetDatum(instance->locktag.locktag_field2);3 ] = UInt32GetDatum(instance->locktag.locktag_field3);4 ] = UInt16GetDatum(instance->locktag.locktag_field4);5 ] = true ;6 ] = true ;7 ] = true ;8 ] = true ;9 ] = true ;break ;case LOCKTAG_TRANSACTION:6 ] =1 ] = true ;2 ] = true ;3 ] = true ;4 ] = true ;5 ] = true ;7 ] = true ;8 ] = true ;9 ] = true ;break ;case LOCKTAG_VIRTUALTRANSACTION:5 ] = VXIDGetDatum(instance->locktag.locktag_field1,1 ] = true ;2 ] = true ;3 ] = true ;4 ] = true ;6 ] = true ;7 ] = true ;8 ] = true ;9 ] = true ;break ;case LOCKTAG_SPECULATIVE_TOKEN:6 ] =8 ] = ObjectIdGetDatum(instance->locktag.locktag_field2);1 ] = true ;2 ] = true ;3 ] = true ;4 ] = true ;5 ] = true ;7 ] = true ;9 ] = true ;break ;case LOCKTAG_APPLY_TRANSACTION:1 ] = ObjectIdGetDatum(instance->locktag.locktag_field1);8 ] = ObjectIdGetDatum(instance->locktag.locktag_field2);6 ] = ObjectIdGetDatum(instance->locktag.locktag_field3);9 ] = Int16GetDatum(instance->locktag.locktag_field4);2 ] = true ;3 ] = true ;4 ] = true ;5 ] = true ;7 ] = true ;break ;case LOCKTAG_OBJECT:case LOCKTAG_USERLOCK:case LOCKTAG_ADVISORY:default : /* treat unknown locktags like OBJECT */ 1 ] = ObjectIdGetDatum(instance->locktag.locktag_field1);7 ] = ObjectIdGetDatum(instance->locktag.locktag_field2);8 ] = ObjectIdGetDatum(instance->locktag.locktag_field3);9 ] = Int16GetDatum(instance->locktag.locktag_field4);2 ] = true ;3 ] = true ;4 ] = true ;5 ] = true ;6 ] = true ;break ;10 ] = VXIDGetDatum(instance->vxid.procNumber, instance->vxid.localTransactionId);if (instance->pid != 0 )11 ] = Int32GetDatum(instance->pid);else 11 ] = true ;12 ] = CStringGetTextDatum(GetLockmodeName(instance->locktag.locktag_lockmethodid, mode));13 ] = BoolGetDatum(granted);14 ] = BoolGetDatum(instance->fastpath);if (!granted && instance->waitStart != 0 )15 ] = TimestampTzGetDatum(instance->waitStart);else 15 ] = true ;/* * Have returned all regular locks . Now start on the SIREAD predicate * locks . if (mystatus->predLockIdx < predLockData->nelements)0 };bool nulls[NUM_LOCK_STATUS_COLUMNS] = {0 };/* * Form tuple with appropriate data . /* lock type */ 0 ] = CStringGetTextDatum(PredicateLockTagTypeNames[lockType]);/* lock target */ 1 ] = GET_PREDICATELOCKTARGETTAG_DB(*predTag);2 ] = GET_PREDICATELOCKTARGETTAG_RELATION(*predTag);if (lockType == PREDLOCKTAG_TUPLE)4 ] = GET_PREDICATELOCKTARGETTAG_OFFSET(*predTag);else 4 ] = true ;if ((lockType == PREDLOCKTAG_TUPLE) ||3 ] = GET_PREDICATELOCKTARGETTAG_PAGE(*predTag);else 3 ] = true ;/* these fields are targets for other types of locks */ 5 ] = true ; /* virtualxid */ 6 ] = true ; /* transactionid */ 7 ] = true ; /* classid */ 8 ] = true ; /* objid */ 9 ] = true ; /* objsubid */ /* lock holder */ 10 ] = VXIDGetDatum(xact->vxid.procNumber,if (xact->pid != 0 )11 ] = Int32GetDatum(xact->pid);else 11 ] = true ;/* * Lock mode . Currently all predicate locks are SIReadLocks , which are * always held ( never waiting ) and have no fast path 12 ] = CStringGetTextDatum("SIReadLock" );13 ] = BoolGetDatum(true );14 ] = BoolGetDatum(false );15 ] = true ;/* * pg_blocking_pids - produce an array of the PIDs blocking given PID * * The reported PIDs are those that hold a lock conflicting with blocked_pid ' s * current request ( hard block ) , or are requesting such a lock and are ahead * of blocked_pid in the lock ' s wait queue ( soft block ) . * * In parallel - query cases , we report all PIDs blocking any member of the * given PID ' s lock group , and the reported PIDs are those of the blocking * PIDs ' lock group leaders . This allows callers to compare the result to * lists of clients ' pg_backend_pid ( ) results even during a parallel query . * * Parallel query makes it possible for there to be duplicate PIDs in the * result ( either because multiple waiters are blocked by same PID , or * because multiple blockers have same group leader PID ) . We do not bother * to eliminate such duplicates from the result . * * We need not consider predicate locks here , since those don ' t block anything . int blocked_pid = PG_GETARG_INT32(0 );int narrayelems;/* state data from lmgr */ int i,/* Collect a snapshot of lock manager state */ /* We can't need more output entries than there are reported PROCLOCKs */ sizeof (Datum));0 ;/* For each blocked proc in the lock group ... */ for (i = 0 ; i < lockData->nprocs; i++)int *preceding_waiters = &lockData->waiter_pids[bproc->first_waiter];int conflictMask;/* * Locate the blocked proc ' s own entry in the LockInstanceData array . * There should be exactly one matching entry . for (j = 0 ; j < bproc->num_locks; j++)if (instance->pid == bproc->pid)/* Now scan the PROCLOCK data for conflicting procs */ for (j = 0 ; j < bproc->num_locks; j++)/* A proc never blocks itself, so ignore that entry */ if (instance == blocked_instance)continue ;/* Members of same lock group never block each other, either */ if (instance->leaderPid == blocked_instance->leaderPid)continue ;if (conflictMask & instance->holdMask)/* hard block: blocked by lock already held by this entry */ else if (instance->waitLockMode != NoLock &&/* conflict in lock requests; who's in front in wait queue? */ bool ahead = false ;int k;for (k = 0 ; k < bproc->num_waiters; k++)if (preceding_waiters[k] == instance->pid)/* soft block: this entry is ahead of blocked proc */ true ;break ;if (!ahead)continue ; /* not blocked by this entry */ else /* not blocked by this entry */ continue ;/* blocked by this entry, so emit a record */ /* Assert we didn't overrun arrayelems[] */ /* * pg_safe_snapshot_blocking_pids - produce an array of the PIDs blocking * given PID from getting a safe snapshot * * XXX this does not consider parallel - query cases ; not clear how big a * problem that is in practice int blocked_pid = PG_GETARG_INT32(0 );int *blockers;int num_blockers;/* A buffer big enough for any possible blocker list without truncation */ int *) palloc(MaxBackends * sizeof (int ));/* Collect a snapshot of processes waited for by GetSafeSnapshot */ /* Convert int array to Datum array */ if (num_blockers > 0 )int i;sizeof (Datum));for (i = 0 ; i < num_blockers; ++i)else D));/* * Functions for manipulating advisory locks * * We make use of the locktag fields as follows : * * field1 : MyDatabaseId . . . ensures locks are local to each database * field2 : first of 2 int4 keys , or high - order half of an int8 key * field3 : second of 2 int4 keys , or low - order half of an int8 key * field4 : 1 if using an int8 key , 2 if using 2 int4 keys #define SET_LOCKTAG_INT64(tag, key64) \32 ), \1 )#define SET_LOCKTAG_INT32(tag, key1, key2) \2 )/* * pg_advisory_lock ( int8 ) - acquire exclusive lock on an int8 key 0 );void ) LockAcquire(&tag, ExclusiveLock, true , false );/* * pg_advisory_xact_lock ( int8 ) - acquire xact scoped * exclusive lock on an int8 key 0 );void ) LockAcquire(&tag, ExclusiveLock, false , false );/* * pg_advisory_lock_shared ( int8 ) - acquire share lock on an int8 key 0 );void ) LockAcquire(&tag, ShareLock, true , false );/* * pg_advisory_xact_lock_shared ( int8 ) - acquire xact scoped * share lock on an int8 key 0 );void ) LockAcquire(&tag, ShareLock, false , false );/* * pg_try_advisory_lock ( int8 ) - acquire exclusive lock on an int8 key , no wait * * Returns true if successful , false if lock not available 0 );true , true );/* * pg_try_advisory_xact_lock ( int8 ) - acquire xact scoped * exclusive lock on an int8 key , no wait * * Returns true if successful , false if lock not available 0 );false , true );/* * pg_try_advisory_lock_shared ( int8 ) - acquire share lock on an int8 key , no wait * * Returns true if successful , false if lock not available 0 );true , true );/* * pg_try_advisory_xact_lock_shared ( int8 ) - acquire xact scoped * share lock on an int8 key , no wait * * Returns true if successful , false if lock not available 0 );false , true );/* * pg_advisory_unlock ( int8 ) - release exclusive lock on an int8 key * * Returns true if successful , false if lock was not held 0 );bool res;true );/* * pg_advisory_unlock_shared ( int8 ) - release share lock on an int8 key * * Returns true if successful , false if lock was not held 0 );bool res;true );/* * pg_advisory_lock ( int4 , int4 ) - acquire exclusive lock on 2 int4 keys 0 );1 );void ) LockAcquire(&tag, ExclusiveLock, true , false );/* * pg_advisory_xact_lock ( int4 , int4 ) - acquire xact scoped * exclusive lock on 2 int4 keys 0 );1 );void ) LockAcquire(&tag, ExclusiveLock, false , false );/* * pg_advisory_lock_shared ( int4 , int4 ) - acquire share lock on 2 int4 keys 0 );1 );void ) LockAcquire(&tag, ShareLock, true , false );/* * pg_advisory_xact_lock_shared ( int4 , int4 ) - acquire xact scoped * share lock on 2 int4 keys 0 );1 );void ) LockAcquire(&tag, ShareLock, false , false );/* * pg_try_advisory_lock ( int4 , int4 ) - acquire exclusive lock on 2 int4 keys , no wait * * Returns true if successful , false if lock not available 0 );1 );true , true );/* * pg_try_advisory_xact_lock ( int4 , int4 ) - acquire xact scoped * exclusive lock on 2 int4 keys , no wait * * Returns true if successful , false if lock not available 0 );1 );false , true );/* * pg_try_advisory_lock_shared ( int4 , int4 ) - acquire share lock on 2 int4 keys , no wait * * Returns true if successful , false if lock not available 0 );1 );true , true );/* * pg_try_advisory_xact_lock_shared ( int4 , int4 ) - acquire xact scoped * share lock on 2 int4 keys , no wait * * Returns true if successful , false if lock not available 0 );1 );false , true );/* * pg_advisory_unlock ( int4 , int4 ) - release exclusive lock on 2 int4 keys * * Returns true if successful , false if lock was not held 0 );1 );bool res;true );/* * pg_advisory_unlock_shared ( int4 , int4 ) - release share lock on 2 int4 keys * * Returns true if successful , false if lock was not held 0 );1 );bool res;true );/* * pg_advisory_unlock_all ( ) - release all advisory locks
Messung V0.5 in Prozent C=94 H=93 G=93
¤ Dauer der Verarbeitung: 0.18 Sekunden
(vorverarbeitet am 2026-08-08)
¤ *© Formatika GbR, Deutschland
