Loading...
Searching...
No Matches
lock.c File Reference
#include "postgres.h"#include <signal.h>#include <unistd.h>#include "access/transam.h"#include "access/twophase.h"#include "access/twophase_rmgr.h"#include "access/xlog.h"#include "access/xlogutils.h"#include "miscadmin.h"#include "pg_trace.h"#include "pgstat.h"#include "storage/lmgr.h"#include "storage/proc.h"#include "storage/procarray.h"#include "storage/shmem.h"#include "storage/spin.h"#include "storage/standby.h"#include "storage/subsystems.h"#include "utils/memutils.h"#include "utils/ps_status.h"#include "utils/resowner.h"
Include dependency graph for lock.c:
Go to the source code of this file.
Data Structures | |
| struct | TwoPhaseLockRecord |
| struct | FastPathStrongRelationLockData |
Typedefs | |
| typedef struct TwoPhaseLockRecord | TwoPhaseLockRecord |
Macro Definition Documentation
◆ ConflictsWithRelationFastPath
Value:
((locktag)->locktag_lockmethodid == DEFAULT_LOCKMETHOD && \
(locktag)->locktag_type == LOCKTAG_RELATION && \
(locktag)->locktag_field1 != InvalidOid && \
Definition at line 276 of file lock.c.
309{
310 slock_t mutex;
313
315
318
321 .init_fn = LockManagerShmemInit,
322};
323
324
325/*
326 * Pointers to hash tables containing lock state
327 *
328 * The LockMethodLockHash and LockMethodProcLockHash hash tables are in
329 * shared memory; LockMethodLocalHash is local to each backend.
330 */
334
335
336/* private state for error cleanup */
340
341
342#ifdef LOCK_DEBUG
343
344/*------
345 * The following configuration options are available for lock debugging:
346 *
347 * TRACE_LOCKS -- give a bunch of output what's going on in this file
348 * TRACE_USERLOCKS -- same but for user locks
349 * TRACE_LOCK_OIDMIN-- do not trace locks for tables below this oid
350 * (use to avoid output on system tables)
351 * TRACE_LOCK_TABLE -- trace locks on this table (oid) unconditionally
352 * DEBUG_DEADLOCKS -- currently dumps locks at untimely occasions ;)
353 *
354 * Furthermore, but in storage/lmgr/lwlock.c:
355 * TRACE_LWLOCKS -- trace lightweight locks (pretty useless)
356 *
357 * Define LOCK_DEBUG at compile time to get all these enabled.
358 * --------
359 */
360
366
367
368inline static bool
370{
371 return
374 || (Trace_lock_table &&
376}
377
378
379inline static void
381{
384 "%s: lock(%p) id(%u,%u,%u,%u,%u,%u) grantMask(%x) "
385 "req(%d,%d,%d,%d,%d,%d,%d)=%d "
386 "grant(%d,%d,%d,%d,%d,%d,%d)=%d wait(%d) type(%s)",
387 where, lock,
391 lock->grantMask,
400}
401
402
403inline static void
405{
408 "%s: proclock(%p) lock(%p) method(%u) proc(%p) hold(%x)",
412}
413#else /* not LOCK_DEBUG */
414
415#define LOCK_PRINT(where, lock, type) ((void) 0)
416#define PROCLOCK_PRINT(where, proclockP) ((void) 0)
417#endif /* not LOCK_DEBUG */
418
419
441
442
443/*
444 * Register the lock manager's shmem data structures.
445 *
446 * In addition to this, each backend must also call InitLockManagerAccess() to
447 * create the locallock hash table.
448 */
449static void
451{
453
454 /*
455 * Compute sizes for lock hashtables.
456 */
458
459 /*
460 * Hash table for LOCK structs. This stores per-locked-object
461 * information.
462 */
464 .nelems = max_table_size,
465 .ptr = &LockMethodLockHash,
468 .hash_info.num_partitions = NUM_LOCK_PARTITIONS,
470 );
471
472 /* Assume an average of 2 holders per lock */
473 max_table_size *= 2;
474
476 .nelems = max_table_size,
477 .ptr = &LockMethodProcLockHash,
480 .hash_info.hash = proclock_hash,
481 .hash_info.num_partitions = NUM_LOCK_PARTITIONS,
483 );
484
488 );
489}
490
491static void
493{
495}
496
497/*
498 * Initialize the lock manager's backend-private data structures.
499 */
500void
502{
503 /*
504 * Allocate non-shared hash table for LOCALLOCK structs. This stores lock
505 * counts and resource owner information.
506 */
507 HASHCTL info;
508
511
513 16,
514 &info,
516}
517
518
519/*
520 * Fetch the lock method table associated with a given lock
521 */
522LockMethod
524{
526
529}
530
531/*
532 * Fetch the lock method table associated with a given locktag
533 */
534LockMethod
536{
538
541}
542
543
544/*
545 * Compute the hash code associated with a LOCKTAG.
546 *
547 * To avoid unnecessary recomputations of the hash code, we try to do this
548 * just once per function, and then pass it around as needed. Aside from
549 * passing the hashcode to hash_search_with_hash_value(), we can extract
550 * the lock partition number from the hashcode.
551 */
552uint32
554{
556}
557
558/*
559 * Compute the hash code associated with a PROCLOCKTAG.
560 *
561 * Because we want to use just one set of partition locks for both the
562 * LOCK and PROCLOCK hash tables, we have to make sure that PROCLOCKs
563 * fall into the same partition number as their associated LOCKs.
564 * dynahash.c expects the partition number to be the low-order bits of
565 * the hash code, and therefore a PROCLOCKTAG's hash code must have the
566 * same low-order bits as the associated LOCKTAG's hash code. We achieve
567 * this with this specialized hash function.
568 */
571{
575
577
578 /* Look into the associated LOCK object, and compute its hash code */
580
581 /*
582 * To make the hash code also depend on the PGPROC, we xor the proc
583 * struct's address into the hash code, left-shifted so that the
584 * partition-number bits don't change. Since this is only a hash, we
585 * don't care if we lose high-order bits of the address; use an
586 * intermediate variable to suppress cast-pointer-to-int warnings.
587 */
590
592}
593
594/*
595 * Compute the hash code associated with a PROCLOCKTAG, given the hashcode
596 * for its underlying LOCK.
597 *
598 * We use this just to avoid redundant calls of LockTagHashCode().
599 */
602{
605
606 /*
607 * This must match proclock_hash()!
608 */
611
613}
614
615/*
616 * Given two lock modes, return whether they would conflict.
617 */
618bool
620{
622
624 return true;
625
626 return false;
627}
628
629/*
630 * LockHeldByMe -- test whether lock 'locktag' is held by the current
631 * transaction
632 *
633 * Returns true if current transaction holds a lock on 'tag' of mode
634 * 'lockmode'. If 'orstronger' is true, a stronger lockmode is also OK.
635 * ("Stronger" is defined as "numerically higher", which is a bit
636 * semantically dubious but is OK for the purposes we use this for.)
637 */
638bool
641{
644
645 /*
646 * See if there is a LOCALLOCK entry for this lock and lockmode
647 */
649 localtag.lock = *locktag;
650 localtag.mode = lockmode;
651
653 &localtag,
655
657 return true;
658
660 {
662
665 slockmode++)
666 {
668 return true;
669 }
670 }
671
672 return false;
673}
674
675#ifdef USE_ASSERT_CHECKING
676/*
677 * GetLockMethodLocalHash -- return the hash of local locks, for modules that
678 * evaluate assertions based on all locks held.
679 */
680HTAB *
682{
684}
685#endif
686
687/*
688 * LockHasWaiters -- look up 'locktag' and check if releasing this
689 * lock would wake up other processes waiting for it.
690 */
691bool
693{
698 LOCK *lock;
699 PROCLOCK *proclock;
702
708
709#ifdef LOCK_DEBUG
713 lockMethodTable->lockModeNames[lockmode]);
714#endif
715
716 /*
717 * Find the LOCALLOCK entry for this lock and lockmode
718 */
720 localtag.lock = *locktag;
721 localtag.mode = lockmode;
722
724 &localtag,
726
727 /*
728 * let the caller print its own error message, too. Do not ereport(ERROR).
729 */
731 {
733 lockMethodTable->lockModeNames[lockmode]);
734 return false;
735 }
736
737 /*
738 * Check the shared lock table.
739 */
741
743
744 /*
745 * We don't need to re-find the lock or proclock, since we kept their
746 * addresses in the locallock table, and they couldn't have been removed
747 * while we were holding a lock on them.
748 */
749 lock = locallock->lock;
751 proclock = locallock->proclock;
753
754 /*
755 * Double-check that we are actually holding a lock of the type we want to
756 * release.
757 */
759 {
763 lockMethodTable->lockModeNames[lockmode]);
765 return false;
766 }
767
768 /*
769 * Do the checking.
770 */
773
775
777}
778
779/*
780 * LockAcquire -- Check for lock conflicts, sleep if conflict found,
781 * set lock if/when no conflicts.
782 *
783 * Inputs:
784 * locktag: unique identifier for the lockable object
785 * lockmode: lock mode to acquire
786 * sessionLock: if true, acquire lock for session not current transaction
787 * dontWait: if true, don't wait to acquire lock
788 *
789 * Returns one of:
790 * LOCKACQUIRE_NOT_AVAIL lock not available, and dontWait=true
791 * LOCKACQUIRE_OK lock successfully acquired
792 * LOCKACQUIRE_ALREADY_HELD incremented count for lock already held
793 * LOCKACQUIRE_ALREADY_CLEAR incremented count for lock already clear
794 *
795 * In the normal case where dontWait=false and the caller doesn't need to
796 * distinguish a freshly acquired lock from one already taken earlier in
797 * this same transaction, there is no need to examine the return value.
798 *
799 * Side Effects: The lock is acquired and recorded in lock tables.
800 *
801 * NOTE: if we wait for the lock, there is no way to abort the wait
802 * short of aborting the transaction.
803 */
806 LOCKMODE lockmode,
809{
812}
813
814/*
815 * LockAcquireExtended - allows us to specify additional options
816 *
817 * reportMemoryError specifies whether a lock request that fills the lock
818 * table should generate an ERROR or not. Passing "false" allows the caller
819 * to attempt to recover from lock-table-full situations, perhaps by forcibly
820 * canceling other lock holders and then retrying. Note, however, that the
821 * return code for that is LOCKACQUIRE_NOT_AVAIL, so that it's unsafe to use
822 * in combination with dontWait = true, as the cause of failure couldn't be
823 * distinguished.
824 *
825 * If locallockp isn't NULL, *locallockp receives a pointer to the LOCALLOCK
826 * table entry if a lock is successfully acquired, or NULL if not.
827 *
828 * logLockFailure indicates whether to log details when a lock acquisition
829 * fails with dontWait = true.
830 */
833 LOCKMODE lockmode,
839{
844 LOCK *lock;
845 PROCLOCK *proclock;
846 bool found;
847 ResourceOwner owner;
848 uint32 hashcode;
853
859
863 lockmode > RowExclusiveLock)
867 lockMethodTable->lockModeNames[lockmode]),
868 errhint("Only RowExclusiveLock or less can be acquired on database objects during recovery.")));
869
870#ifdef LOCK_DEBUG
874 lockMethodTable->lockModeNames[lockmode]);
875#endif
876
877 /* Identify owner for lock */
879 owner = NULL;
880 else
881 owner = CurrentResourceOwner;
882
883 /*
884 * Find or create a LOCALLOCK entry for this lock and lockmode
885 */
887 localtag.lock = *locktag;
888 localtag.mode = lockmode;
889
891 &localtag,
892 HASH_ENTER, &found);
893
894 /*
895 * if it's a new locallock object, initialize it
896 */
897 if (!found)
898 {
902 locallock->nLocks = 0;
905 locallock->numLockOwners = 0;
906 locallock->maxLockOwners = 8;
911 }
912 else
913 {
914 /* Make sure there will be room to remember the lock */
916 {
918
923 }
924 }
925 hashcode = locallock->hashcode;
926
929
930 /*
931 * If we already hold the lock, we can just increase the count locally.
932 *
933 * If lockCleared is already set, caller need not worry about absorbing
934 * sinval messages related to the lock's object.
935 */
937 {
941 else
943 }
944
945 /*
946 * We don't acquire any other heavyweight lock while holding the relation
947 * extension lock. We do allow to acquire the same relation extension
948 * lock more than once but that case won't reach here.
949 */
951
952 /*
953 * Prepare to emit a WAL record if acquisition of this lock needs to be
954 * replayed in a standby server.
955 *
956 * Here we prepare to log; after lock is acquired we'll issue log record.
957 * This arrangement simplifies error recovery in case the preparation step
958 * fails.
959 *
960 * Only AccessExclusiveLocks can conflict with lock types that read-only
961 * transactions can acquire in a standby server. Make sure this definition
962 * matches the one in GetRunningTransactionLocks().
963 */
966 !RecoveryInProgress() &&
967 XLogStandbyInfoActive())
968 {
971 }
972
973 /*
974 * Attempt to take lock via fast path, if eligible. But if we remember
975 * having filled up the fast path array, we don't attempt to make any
976 * further use of it until we release some locks. It's possible that some
977 * other backend has transferred some of those locks to the shared hash
978 * table, leaving space free, but it's not worth acquiring the LWLock just
979 * to check. It's also possible that we're acquiring a second or third
980 * lock type on a relation we have already locked using the fast-path, but
981 * for now we don't worry about that case either.
982 */
984 {
987 {
990
991 /*
992 * LWLockAcquire acts as a memory sequencing point, so it's safe
993 * to assume that any strong locker whose increment to
994 * FastPathStrongRelationLocks->counts becomes visible after we
995 * test it has yet to begin to transfer fast-path locks.
996 */
1000 else
1002 lockmode);
1005 {
1006 /*
1007 * The locallock might contain stale pointers to some old
1008 * shared objects; we MUST reset these to null before
1009 * considering the lock to be acquired via fast-path.
1010 */
1015 }
1016 }
1017 else
1018 {
1019 /*
1020 * Increment the lock statistics counter if lock could not be
1021 * acquired via the fast-path.
1022 */
1024 }
1025 }
1026
1027 /*
1028 * If this lock could potentially have been taken via the fast-path by
1029 * some other backend, we must (temporarily) disable further use of the
1030 * fast-path for this lock tag, and migrate any locks already taken via
1031 * this method to the main lock table.
1032 */
1034 {
1036
1039 hashcode))
1040 {
1041 AbortStrongLockAcquire();
1051 else
1053 }
1054 }
1055
1056 /*
1057 * We didn't find the lock in our LOCALLOCK table, and we didn't manage to
1058 * take it via the fast-path, either, so we've got to mess with the shared
1059 * lock table.
1060 */
1062
1064
1065 /*
1066 * Find or create lock and proclock entries with this tag
1067 *
1068 * Note: if the locallock object already existed, it might have a pointer
1069 * to the lock already ... but we should not assume that that pointer is
1070 * valid, since a lock object with zero hold and request counts can go
1071 * away anytime. So we have to use SetupLockInTable() to recompute the
1072 * lock and proclock pointers, even if they're already set.
1073 */
1075 hashcode, lockmode);
1076 if (!proclock)
1077 {
1078 AbortStrongLockAcquire();
1089 else
1091 }
1092 locallock->proclock = proclock;
1094 locallock->lock = lock;
1095
1096 /*
1097 * If lock requested conflicts with locks requested by waiters, must join
1098 * wait queue. Otherwise, check for conflict with already-held locks.
1099 * (That's last because most complex check.)
1100 */
1103 else
1105 lock, proclock);
1106
1108 {
1109 /* No conflict with held or previously requested locks */
1110 GrantLock(lock, proclock, lockmode);
1112 }
1113 else
1114 {
1115 /*
1116 * Join the lock's wait queue. We call this even in the dontWait
1117 * case, because JoinWaitQueue() may discover that we can acquire the
1118 * lock immediately after all.
1119 */
1121 }
1122
1124 {
1125 /*
1126 * We're not getting the lock because a deadlock was detected already
1127 * while trying to join the wait queue, or because we would have to
1128 * wait but the caller requested no blocking.
1129 *
1130 * Undo the changes to shared entries before releasing the partition
1131 * lock.
1132 */
1133 AbortStrongLockAcquire();
1134
1136 {
1138
1140 hashcode);
1144 &(proclock->tag),
1145 proclock_hashcode,
1146 HASH_REMOVE,
1147 NULL))
1149 }
1150 else
1152 lock->nRequested--;
1153 lock->requested[lockmode]--;
1155 lock, lockmode);
1157 (lock->requested[lockmode] >= 0));
1162
1164 {
1165 /*
1166 * Log lock holders and waiters as a detail log message if
1167 * logLockFailure = true and lock acquisition fails with dontWait
1168 * = true
1169 */
1171 {
1173 lock_waiters_sbuf,
1174 lock_holders_sbuf;
1177
1181
1184 lockmode);
1185
1186 /* Gather a list of all lock holders and waiters */
1191
1195 errdetail_log_plural(
1196 "Process holding the lock: %s, Wait queue: %s.",
1197 "Processes holding the lock: %s, Wait queue: %s.",
1198 lockHoldersNum,
1199 lock_holders_sbuf.data,
1200 lock_waiters_sbuf.data)));
1201
1205 }
1209 }
1210 else
1211 {
1212 DeadLockReport();
1213 /* DeadLockReport() will not return */
1214 }
1215 }
1216
1217 /*
1218 * We are now in the lock queue, or the lock was already granted. If
1219 * queued, go to sleep.
1220 */
1222 {
1227
1229
1230 /*
1231 * NOTE: do not do any material change of state between here and
1232 * return. All required changes in locktable state must have been
1233 * done when the lock was granted to us --- see notes in WaitOnLock.
1234 */
1235
1237 {
1238 /*
1239 * We failed as a result of a deadlock, see CheckDeadLock(). Quit
1240 * now.
1241 */
1243 DeadLockReport();
1244 /* DeadLockReport() will not return */
1245 }
1246 }
1247 else
1250
1251 /* The lock was granted to us. Update the local lock entry accordingly */
1254
1255 /*
1256 * Lock state is fully up-to-date now; if we error out after this, no
1257 * special error cleanup is required.
1258 */
1259 FinishStrongLockAcquire();
1260
1261 /*
1262 * Emit a WAL record if acquisition of this lock needs to be replayed in a
1263 * standby server.
1264 */
1266 {
1267 /*
1268 * Decode the locktag back to the original values, to avoid sending
1269 * lots of empty bytes with every message. See lock.h to check how a
1270 * locktag is defined for LOCKTAG_RELATION
1271 */
1273 locktag->locktag_field2);
1274 }
1275
1277}
1278
1279/*
1280 * Find or create LOCK and PROCLOCK objects as needed for a new lock
1281 * request.
1282 *
1283 * Returns the PROCLOCK object, or NULL if we failed to create the objects
1284 * for lack of shared memory.
1285 *
1286 * The appropriate partition lock must be held at entry, and will be
1287 * held at exit.
1288 */
1292{
1293 LOCK *lock;
1294 PROCLOCK *proclock;
1297 bool found;
1298
1299 /*
1300 * Find or create a lock with this tag.
1301 */
1303 locktag,
1304 hashcode,
1305 HASH_ENTER_NULL,
1306 &found);
1307 if (!lock)
1309
1310 /*
1311 * if it's a new lock object, initialize it
1312 */
1313 if (!found)
1314 {
1315 lock->grantMask = 0;
1316 lock->waitMask = 0;
1319 lock->nRequested = 0;
1320 lock->nGranted = 0;
1324 }
1325 else
1326 {
1331 }
1332
1333 /*
1334 * Create the hash key for the proclock table.
1335 */
1336 proclocktag.myLock = lock;
1337 proclocktag.myProc = proc;
1338
1340
1341 /*
1342 * Find or create a proclock entry with this tag
1343 */
1345 &proclocktag,
1346 proclock_hashcode,
1347 HASH_ENTER_NULL,
1348 &found);
1349 if (!proclock)
1350 {
1351 /* Oops, not enough shmem for the proclock */
1353 {
1354 /*
1355 * There are no other requestors of this lock, so garbage-collect
1356 * the lock object. We *must* do this to avoid a permanent leak
1357 * of shared memory, because there won't be anything to cause
1358 * anyone to release the lock object later.
1359 */
1362 &(lock->tag),
1363 hashcode,
1364 HASH_REMOVE,
1365 NULL))
1367 }
1369 }
1370
1371 /*
1372 * If new, initialize the new entry
1373 */
1374 if (!found)
1375 {
1377
1378 /*
1379 * It might seem unsafe to access proclock->groupLeader without a
1380 * lock, but it's not really. Either we are initializing a proclock
1381 * on our own behalf, in which case our group leader isn't changing
1382 * because the group leader for a process can only ever be changed by
1383 * the process itself; or else we are transferring a fast-path lock to
1384 * the main lock table, in which case that process can't change its
1385 * lock group leader without first releasing all of its locks (and in
1386 * particular the one we are currently transferring).
1387 */
1389 proc->lockGroupLeader : proc;
1390 proclock->holdMask = 0;
1391 proclock->releaseMask = 0;
1392 /* Add proclock to appropriate lists */
1396 }
1397 else
1398 {
1401
1402#ifdef CHECK_DEADLOCK_RISK
1403
1404 /*
1405 * Issue warning if we already hold a lower-level lock on this object
1406 * and do not hold a lock of the requested level or higher. This
1407 * indicates a deadlock-prone coding practice (eg, we'd have a
1408 * deadlock if another backend were following the same code path at
1409 * about the same time).
1410 *
1411 * This is not enabled by default, because it may generate log entries
1412 * about user-level coding practices that are in fact safe in context.
1413 * It can be enabled to help find system-level problems.
1414 *
1415 * XXX Doing numeric comparison on the lockmodes is a hack; it'd be
1416 * better to use a table. For now, though, this works.
1417 */
1418 {
1420
1422 {
1424 {
1426 break; /* safe: we have a lock >= req level */
1428 " from %s to %s on object %u/%u/%u",
1430 lockMethodTable->lockModeNames[lockmode],
1433 break;
1434 }
1435 }
1436 }
1437#endif /* CHECK_DEADLOCK_RISK */
1438 }
1439
1440 /*
1441 * lock->nRequested and lock->requested[] count the total number of
1442 * requests, whether granted or waiting, so increment those immediately.
1443 * The other counts don't increment till we get the lock.
1444 */
1445 lock->nRequested++;
1446 lock->requested[lockmode]++;
1448
1449 /*
1450 * We shouldn't already hold the desired lock; else locallock table is
1451 * broken.
1452 */
1455 lockMethodTable->lockModeNames[lockmode],
1458
1459 return proclock;
1460}
1461
1462/*
1463 * Check and set/reset the flag that we hold the relation extension lock.
1464 *
1465 * It is callers responsibility that this function is called after
1466 * acquiring/releasing the relation extension lock.
1467 *
1468 * Pass acquired as true if lock is acquired, false otherwise.
1469 */
1470static inline void
1472{
1473#ifdef USE_ASSERT_CHECKING
1476#endif
1477}
1478
1479/*
1480 * Subroutine to free a locallock entry
1481 */
1482static void
1484{
1486
1488 {
1491 }
1492 locallock->numLockOwners = 0;
1496
1498 {
1500
1502
1508 }
1509
1511 &(locallock->tag),
1514
1515 /*
1516 * Indicate that the lock is released for certain types of locks
1517 */
1519}
1520
1521/*
1522 * LockCheckConflicts -- test whether requested lock conflicts
1523 * with those already granted
1524 *
1525 * Returns true if conflict, false if no conflict.
1526 *
1527 * NOTES:
1528 * Here's what makes this complicated: one process's locks don't
1529 * conflict with one another, no matter what purpose they are held for
1530 * (eg, session and transaction locks do not conflict). Nor do the locks
1531 * of one process in a lock group conflict with those of another process in
1532 * the same group. So, we must subtract off these locks when determining
1533 * whether the requested new lock conflicts with those already held.
1534 */
1535bool
1537 LOCKMODE lockmode,
1538 LOCK *lock,
1539 PROCLOCK *proclock)
1540{
1548
1549 /*
1550 * first check for global conflicts: If no locks conflict with my request,
1551 * then I get the lock.
1552 *
1553 * Checking for conflict: lock->grantMask represents the types of
1554 * currently held locks. conflictTable[lockmode] has a bit set for each
1555 * type of lock that conflicts with request. Bitwise compare tells if
1556 * there is a conflict.
1557 */
1559 {
1561 return false;
1562 }
1563
1564 /*
1565 * Rats. Something conflicts. But it could still be my own lock, or a
1566 * lock held by another member of my locking group. First, figure out how
1567 * many conflicts remain after subtracting out any locks I hold myself.
1568 */
1571 {
1573 {
1575 continue;
1576 }
1581 }
1582
1583 /* If no conflicts remain, we get the lock. */
1585 {
1587 return false;
1588 }
1589
1590 /* If no group locking, it's definitely a conflict. */
1592 {
1595 proclock);
1596 return true;
1597 }
1598
1599 /*
1600 * The relation extension lock conflict even between the group members.
1601 */
1603 {
1605 proclock);
1606 return true;
1607 }
1608
1609 /*
1610 * Locks held in conflicting modes by members of our own lock group are
1611 * not real conflicts; we can subtract those out and see if we still have
1612 * a conflict. This is O(N) in the number of processes holding or
1613 * awaiting locks on this object. We could improve that by making the
1614 * shared memory state more complex (and larger) but it doesn't seem worth
1615 * it.
1616 */
1618 {
1621
1625 {
1627
1629 {
1631 {
1635 totalConflictsRemaining--;
1636 }
1637 }
1638
1640 {
1642 proclock);
1643 return false;
1644 }
1645 }
1646 }
1647
1648 /* Nope, it's a real conflict. */
1650 return true;
1651}
1652
1653/*
1654 * GrantLock -- update the lock and proclock data structures to show
1655 * the lock request has been granted.
1656 *
1657 * NOTE: if proc was blocked, it also needs to be removed from the wait list
1658 * and have its waitLock/waitProcLock fields cleared. That's not done here.
1659 *
1660 * NOTE: the lock grant also has to be recorded in the associated LOCALLOCK
1661 * table entry; but since we may be awaking some other process, we can't do
1662 * that here; it's done by GrantLockLocal, instead.
1663 */
1664void
1666{
1667 lock->nGranted++;
1668 lock->granted[lockmode]++;
1676}
1677
1678/*
1679 * UnGrantLock -- opposite of GrantLock.
1680 *
1681 * Updates the lock and proclock data structures to show that the lock
1682 * is no longer held nor requested by the current holder.
1683 *
1684 * Returns true if there were any waiters waiting on the lock that
1685 * should now be woken up with ProcLockWakeup.
1686 */
1687static bool
1690{
1692
1696
1697 /*
1698 * fix the general lock stats
1699 */
1700 lock->nRequested--;
1701 lock->requested[lockmode]--;
1702 lock->nGranted--;
1703 lock->granted[lockmode]--;
1704
1706 {
1707 /* change the conflict mask. No more of this lock type. */
1709 }
1710
1712
1713 /*
1714 * We need only run ProcLockWakeup if the released lock conflicts with at
1715 * least one of the lock types requested by waiter(s). Otherwise whatever
1716 * conflict made them wait must still exist. NOTE: before MVCC, we could
1717 * skip wakeup if lock->granted[lockmode] was still positive. But that's
1718 * not true anymore, because the remaining granted locks might belong to
1719 * some waiter, who could now be awakened because he doesn't conflict with
1720 * his own locks.
1721 */
1724
1725 /*
1726 * Now fix the per-proclock state.
1727 */
1730
1732}
1733
1734/*
1735 * CleanUpLock -- clean up after releasing a lock. We garbage-collect the
1736 * proclock and lock objects if possible, and call ProcLockWakeup if there
1737 * are remaining requests and the caller says it's OK. (Normally, this
1738 * should be called after UnGrantLock, and wakeupNeeded is the result from
1739 * UnGrantLock.)
1740 *
1741 * The appropriate partition lock must be held at entry, and will be
1742 * held at exit.
1743 */
1744static void
1748{
1749 /*
1750 * If this was my last hold on this lock, delete my entry in the proclock
1751 * table.
1752 */
1754 {
1756
1762 &(proclock->tag),
1763 proclock_hashcode,
1764 HASH_REMOVE,
1765 NULL))
1767 }
1768
1770 {
1771 /*
1772 * The caller just released the last lock, so garbage-collect the lock
1773 * object.
1774 */
1778 &(lock->tag),
1779 hashcode,
1780 HASH_REMOVE,
1781 NULL))
1783 }
1785 {
1786 /* There are waiters on this lock, so wake them up. */
1788 }
1789}
1790
1791/*
1792 * GrantLockLocal -- update the locallock data structures to show
1793 * the lock request has been granted.
1794 *
1795 * We expect that LockAcquire made sure there is room to add a new
1796 * ResourceOwner entry.
1797 */
1798static void
1800{
1803
1805 /* Count the total */
1806 locallock->nLocks++;
1807 /* Count the per-owner lock */
1809 {
1811 {
1813 return;
1814 }
1815 }
1818 locallock->numLockOwners++;
1821
1822 /* Indicate that the lock is acquired for certain types of locks. */
1824}
1825
1826/*
1827 * BeginStrongLockAcquire - inhibit use of fastpath for a given LOCALLOCK,
1828 * and arrange for error cleanup if it fails
1829 */
1830static void
1832{
1835
1836 /*
1837 * Adding to a memory location is not atomic, so we take a spinlock to
1838 * ensure we don't collide with someone else trying to bump the count at
1839 * the same time.
1840 *
1841 * XXX: It might be worth considering using an atomic fetch-and-add
1842 * instruction here, on architectures where that is supported.
1843 */
1844
1850}
1851
1852/*
1853 * FinishStrongLockAcquire - cancel pending cleanup for a strong lock
1854 * acquisition once it's no longer needed
1855 */
1856static void
1858{
1860}
1861
1862/*
1863 * AbortStrongLockAcquire - undo strong lock state changes performed by
1864 * BeginStrongLockAcquire.
1865 */
1866void
1868{
1871
1873 return;
1874
1883}
1884
1885/*
1886 * GrantAwaitedLock -- call GrantLockLocal for the lock we are doing
1887 * WaitOnLock on.
1888 *
1889 * proc.c needs this for the case where we are booted off the lock by
1890 * timeout, but discover that someone granted us the lock anyway.
1891 *
1892 * We could just export GrantLockLocal, but that would require including
1893 * resowner.h in lock.h, which creates circularity.
1894 */
1895void
1897{
1899}
1900
1901/*
1902 * GetAwaitedLock -- Return the lock we're currently doing WaitOnLock on.
1903 */
1904LOCALLOCK *
1906{
1908}
1909
1910/*
1911 * ResetAwaitedLock -- Forget that we are waiting on a lock.
1912 */
1913void
1915{
1917}
1918
1919/*
1920 * MarkLockClear -- mark an acquired lock as "clear"
1921 *
1922 * This means that we know we have absorbed all sinval messages that other
1923 * sessions generated before we acquired this lock, and so we can confidently
1924 * assume we know about any catalog changes protected by this lock.
1925 */
1926void
1928{
1931}
1932
1933/*
1934 * WaitOnLock -- wait to acquire a lock
1935 *
1936 * This is a wrapper around ProcSleep, with extra tracing and bookkeeping.
1937 */
1940{
1943
1945 locallock->tag.lock.locktag_field2,
1946 locallock->tag.lock.locktag_field3,
1947 locallock->tag.lock.locktag_field4,
1948 locallock->tag.lock.locktag_type,
1949 locallock->tag.mode);
1950
1951 /* Setup error traceback support for ereport() */
1956
1957 /* adjust the process title to indicate that it's waiting */
1959
1960 /*
1961 * Record the fact that we are waiting for a lock, so that
1962 * LockErrorCleanup will clean up if cancel/die happens.
1963 */
1965 awaitedOwner = owner;
1966
1967 /*
1968 * NOTE: Think not to put any shared-state cleanup after the call to
1969 * ProcSleep, in either the normal or failure path. The lock state must
1970 * be fully set by the lock grantor, or by CheckDeadLock if we give up
1971 * waiting for the lock. This is necessary because of the possibility
1972 * that a cancel/die interrupt will interrupt ProcSleep after someone else
1973 * grants us the lock, but before we've noticed it. Hence, after granting,
1974 * the locktable state must fully reflect the fact that we own the lock;
1975 * we can't do additional work on return.
1976 *
1977 * We can and do use a PG_TRY block to try to clean up after failure, but
1978 * this still has a major limitation: elog(FATAL) can occur while waiting
1979 * (eg, a "die" interrupt), and then control won't come back here. So all
1980 * cleanup of essential state should happen in LockErrorCleanup, not here.
1981 * We can use PG_TRY to clear the "waiting" status flags, since doing that
1982 * is unimportant if the process exits.
1983 */
1984 PG_TRY();
1985 {
1987 }
1988 PG_CATCH();
1989 {
1990 /* In this path, awaitedLock remains set until LockErrorCleanup */
1991
1992 /* reset ps display to remove the suffix */
1993 set_ps_display_remove_suffix();
1994
1995 /* and propagate the error */
1996 PG_RE_THROW();
1997 }
1998 PG_END_TRY();
1999
2000 /*
2001 * We no longer want LockErrorCleanup to do anything.
2002 */
2004
2005 /* reset ps display to remove the suffix */
2006 set_ps_display_remove_suffix();
2007
2009
2011 locallock->tag.lock.locktag_field2,
2012 locallock->tag.lock.locktag_field3,
2013 locallock->tag.lock.locktag_field4,
2014 locallock->tag.lock.locktag_type,
2015 locallock->tag.mode);
2016
2018}
2019
2020/*
2021 * error context callback for failures in WaitOnLock
2022 *
2023 * We report which lock was being waited on, in the same style used in
2024 * deadlock reports. This helps with lock timeout errors in particular.
2025 */
2026static void
2028{
2033
2036
2039 locktagbuf.data);
2040}
2041
2042/*
2043 * Remove a proc from the wait-queue it is on (caller must know it is on one).
2044 * This is only used when the proc has failed to get the lock, so we set its
2045 * waitStatus to PROC_WAIT_STATUS_ERROR.
2046 *
2047 * Appropriate partition lock must be held by caller. Also, caller is
2048 * responsible for signaling the proc if needed.
2049 *
2050 * NB: this does not clean up any locallock object that may exist for the lock.
2051 */
2052void
2054{
2059
2060 /* Make sure proc is waiting */
2063 Assert(waitLock);
2066
2067 /* Remove proc from lock's wait queue */
2069
2070 /* Undo increments of request counts by waiting process */
2073 waitLock->nRequested--;
2075 waitLock->requested[lockmode]--;
2076 /* don't forget to clear waitMask bit if appropriate */
2079
2080 /* Clean up the proc's own state, and pass it the ok/fail signal */
2084
2085 /*
2086 * Delete the proclock immediately if it represents no already-held locks.
2087 * (This must happen now because if the owner of the lock decides to
2088 * release it, and the requested/granted counts then go to zero,
2089 * LockRelease expects there to be no remaining proclocks.) Then see if
2090 * any other waiters for the lock can be woken up now.
2091 */
2092 CleanUpLock(waitLock, proclock,
2094 true);
2095}
2096
2097/*
2098 * LockRelease -- look up 'locktag' and release one 'lockmode' lock on it.
2099 * Release a session lock if 'sessionLock' is true, else release a
2100 * regular transaction lock.
2101 *
2102 * Side Effects: find any waiting processes that are now wakable,
2103 * grant them their requested locks and awaken them.
2104 * (We have to grant the lock here to avoid a race between
2105 * the waking process and any new process to
2106 * come along and request the lock.)
2107 */
2108bool
2110{
2115 LOCK *lock;
2116 PROCLOCK *proclock;
2119
2125
2126#ifdef LOCK_DEBUG
2130 lockMethodTable->lockModeNames[lockmode]);
2131#endif
2132
2133 /*
2134 * Find the LOCALLOCK entry for this lock and lockmode
2135 */
2137 localtag.lock = *locktag;
2138 localtag.mode = lockmode;
2139
2141 &localtag,
2143
2144 /*
2145 * let the caller print its own error message, too. Do not ereport(ERROR).
2146 */
2148 {
2150 lockMethodTable->lockModeNames[lockmode]);
2151 return false;
2152 }
2153
2154 /*
2155 * Decrease the count for the resource owner.
2156 */
2157 {
2159 ResourceOwner owner;
2161
2162 /* Identify owner for lock */
2164 owner = NULL;
2165 else
2166 owner = CurrentResourceOwner;
2167
2169 {
2171 {
2174 {
2177 /* compact out unused slot */
2178 locallock->numLockOwners--;
2181 }
2182 break;
2183 }
2184 }
2186 {
2187 /* don't release a lock belonging to another owner */
2189 lockMethodTable->lockModeNames[lockmode]);
2190 return false;
2191 }
2192 }
2193
2194 /*
2195 * Decrease the total local count. If we're still holding the lock, we're
2196 * done.
2197 */
2198 locallock->nLocks--;
2199
2201 return true;
2202
2203 /*
2204 * At this point we can no longer suppose we are clear of invalidation
2205 * messages related to this lock. Although we'll delete the LOCALLOCK
2206 * object before any intentional return from this routine, it seems worth
2207 * the trouble to explicitly reset lockCleared right now, just in case
2208 * some error prevents us from deleting the LOCALLOCK.
2209 */
2211
2212 /* Attempt fast release of any lock eligible for the fast path. */
2215 {
2217
2218 /*
2219 * We might not find the lock here, even if we originally entered it
2220 * here. Another backend may have moved it to the main table.
2221 */
2224 lockmode);
2227 {
2229 return true;
2230 }
2231 }
2232
2233 /*
2234 * Otherwise we've got to mess with the shared lock table.
2235 */
2237
2239
2240 /*
2241 * Normally, we don't need to re-find the lock or proclock, since we kept
2242 * their addresses in the locallock table, and they couldn't have been
2243 * removed while we were holding a lock on them. But it's possible that
2244 * the lock was taken fast-path and has since been moved to the main hash
2245 * table by another backend, in which case we will need to look up the
2246 * objects here. We assume the lock field is NULL if so.
2247 */
2248 lock = locallock->lock;
2249 if (!lock)
2250 {
2252
2255 locktag,
2256 locallock->hashcode,
2257 HASH_FIND,
2258 NULL);
2259 if (!lock)
2261 locallock->lock = lock;
2262
2263 proclocktag.myLock = lock;
2266 &proclocktag,
2267 HASH_FIND,
2268 NULL);
2271 }
2273 proclock = locallock->proclock;
2275
2276 /*
2277 * Double-check that we are actually holding a lock of the type we want to
2278 * release.
2279 */
2281 {
2285 lockMethodTable->lockModeNames[lockmode]);
2287 return false;
2288 }
2289
2290 /*
2291 * Do the releasing. CleanUpLock will waken any now-wakable waiters.
2292 */
2294
2295 CleanUpLock(lock, proclock,
2297 wakeupNeeded);
2298
2300
2302 return true;
2303}
2304
2305/*
2306 * LockReleaseAll -- Release all locks of the specified lock method that
2307 * are held by the current process.
2308 *
2309 * Well, not necessarily *all* locks. The available behaviors are:
2310 * allLocks == true: release all locks including session locks.
2311 * allLocks == false: release all non-session locks.
2312 */
2313void
2315{
2316 HASH_SEQ_STATUS status;
2319 numLockModes;
2321 LOCK *lock;
2324
2328
2329#ifdef LOCK_DEBUG
2332#endif
2333
2334 /*
2335 * Get rid of our fast-path VXID lock, if appropriate. Note that this is
2336 * the only way that the lock we hold on our own VXID can ever get
2337 * released: it is always and only released when a toplevel transaction
2338 * ends.
2339 */
2341 VirtualXactLockTableCleanup();
2342
2343 numLockModes = lockMethodTable->numLockModes;
2344
2345 /*
2346 * First we run through the locallock table and get rid of unwanted
2347 * entries, then we scan the process's proclocks and get rid of those. We
2348 * do this separately because we may have multiple locallock entries
2349 * pointing to the same proclock, and we daren't end up with any dangling
2350 * pointers. Fast-path locks are cleaned up during the locallock table
2351 * scan, though.
2352 */
2354
2356 {
2357 /*
2358 * If the LOCALLOCK entry is unused, something must've gone wrong
2359 * while trying to acquire this lock. Just forget the local entry.
2360 */
2362 {
2364 continue;
2365 }
2366
2367 /* Ignore items that are not of the lockmethod to be removed */
2369 continue;
2370
2371 /*
2372 * If we are asked to release all locks, we can just zap the entry.
2373 * Otherwise, must scan to see if there are session locks. We assume
2374 * there is at most one lockOwners entry for session locks.
2375 */
2377 {
2379
2380 /* If session lock is above array position 0, move it down to 0 */
2382 {
2384 lockOwners[0] = lockOwners[i];
2385 else
2387 }
2388
2390 lockOwners[0].owner == NULL &&
2391 lockOwners[0].nLocks > 0)
2392 {
2393 /* Fix the locallock to show just the session locks */
2395 locallock->numLockOwners = 1;
2396 /* We aren't deleting this locallock, so done */
2397 continue;
2398 }
2399 else
2400 locallock->numLockOwners = 0;
2401 }
2402
2403#ifdef USE_ASSERT_CHECKING
2404
2405 /*
2406 * Tuple locks are currently held only for short durations within a
2407 * transaction. Check that we didn't forget to release one.
2408 */
2411#endif
2412
2413 /*
2414 * If the lock or proclock pointers are NULL, this lock was taken via
2415 * the relation fast-path (and is not known to have been transferred).
2416 */
2418 {
2420 Oid relid;
2421
2422 /* Verify that a fast-path lock is what we've got. */
2425
2426 /*
2427 * If we don't currently hold the LWLock that protects our
2428 * fast-path data structures, we must acquire it before attempting
2429 * to release the lock via the fast-path. We will continue to
2430 * hold the LWLock until we're done scanning the locallock table,
2431 * unless we hit a transferred fast-path lock. (XXX is this
2432 * really such a good idea? There could be a lot of entries ...)
2433 */
2435 {
2438 }
2439
2440 /* Attempt fast-path release. */
2441 relid = locallock->tag.lock.locktag_field2;
2443 {
2445 continue;
2446 }
2447
2448 /*
2449 * Our lock, originally taken via the fast path, has been
2450 * transferred to the main lock table. That's going to require
2451 * some extra work, so release our fast-path lock before starting.
2452 */
2455
2456 /*
2457 * Now dump the lock. We haven't got a pointer to the LOCK or
2458 * PROCLOCK in this case, so we have to handle this a bit
2459 * differently than a normal lock release. Unfortunately, this
2460 * requires an extra LWLock acquire-and-release cycle on the
2461 * partitionLock, but hopefully it shouldn't happen often.
2462 */
2466 continue;
2467 }
2468
2469 /* Mark the proclock to show we need to release this lockmode */
2472
2473 /* And remove the locallock hashtable entry */
2475 }
2476
2477 /* Done with the fast-path data structures */
2480
2481 /*
2482 * Now, scan each lock partition separately.
2483 */
2485 {
2489
2491
2492 /*
2493 * If the proclock list for this partition is empty, we can skip
2494 * acquiring the partition lock. This optimization is trickier than
2495 * it looks, because another backend could be in process of adding
2496 * something to our proclock list due to promoting one of our
2497 * fast-path locks. However, any such lock must be one that we
2498 * decided not to delete above, so it's okay to skip it again now;
2499 * we'd just decide not to delete it again. We must, however, be
2500 * careful to re-fetch the list header once we've acquired the
2501 * partition lock, to be sure we have a valid, up-to-date pointer.
2502 * (There is probably no significant risk if pointer fetch/store is
2503 * atomic, but we don't wish to assume that.)
2504 *
2505 * XXX This argument assumes that the locallock table correctly
2506 * represents all of our fast-path locks. While allLocks mode
2507 * guarantees to clean up all of our normal locks regardless of the
2508 * locallock situation, we lose that guarantee for fast-path locks.
2509 * This is not ideal.
2510 */
2512 continue; /* needn't examine this partition */
2513
2515
2517 {
2520
2522
2524
2525 /* Ignore items that are not of the lockmethod to be removed */
2527 continue;
2528
2529 /*
2530 * In allLocks mode, force release of all locks even if locallock
2531 * table had problems
2532 */
2535 else
2537
2538 /*
2539 * Ignore items that have nothing to be released, unless they have
2540 * holdMask == 0 and are therefore recyclable
2541 */
2543 continue;
2544
2551
2552 /*
2553 * Release the previously-marked lock modes
2554 */
2556 {
2559 lockMethodTable);
2560 }
2564
2565 proclock->releaseMask = 0;
2566
2567 /* CleanUpLock will wake up waiters if needed. */
2568 CleanUpLock(lock, proclock,
2569 lockMethodTable,
2571 wakeupNeeded);
2572 } /* loop over PROCLOCKs within this partition */
2573
2575 } /* loop over partitions */
2576
2577#ifdef LOCK_DEBUG
2580#endif
2581}
2582
2583/*
2584 * LockReleaseSession -- Release all session locks of the specified lock method
2585 * that are held by the current process.
2586 */
2587void
2589{
2590 HASH_SEQ_STATUS status;
2592
2595
2597
2599 {
2600 /* Ignore items that are not of the specified lock method */
2602 continue;
2603
2605 }
2606}
2607
2608/*
2609 * LockReleaseCurrentOwner
2610 * Release all locks belonging to CurrentResourceOwner
2611 *
2612 * If the caller knows what those locks are, it can pass them as an array.
2613 * That speeds up the call significantly, when a lot of locks are held.
2614 * Otherwise, pass NULL for locallocks, and we'll traverse through our hash
2615 * table to find them.
2616 */
2617void
2619{
2621 {
2622 HASH_SEQ_STATUS status;
2624
2626
2629 }
2630 else
2631 {
2633
2636 }
2637}
2638
2639/*
2640 * ReleaseLockIfHeld
2641 * Release any session-level locks on this lockable object if sessionLock
2642 * is true; else, release any locks held by CurrentResourceOwner.
2643 *
2644 * It is tempting to pass this a ResourceOwner pointer (or NULL for session
2645 * locks), but without refactoring LockRelease() we cannot support releasing
2646 * locks belonging to resource owners other than CurrentResourceOwner.
2647 * If we were to refactor, it'd be a good idea to fix it so we don't have to
2648 * do a hashtable lookup of the locallock, too. However, currently this
2649 * function isn't used heavily enough to justify refactoring for its
2650 * convenience.
2651 */
2652static void
2654{
2655 ResourceOwner owner;
2656 LOCALLOCKOWNER *lockOwners;
2658
2659 /* Identify owner for lock (must match LockRelease!) */
2661 owner = NULL;
2662 else
2663 owner = CurrentResourceOwner;
2664
2665 /* Scan to see if there are any locks belonging to the target owner */
2666 lockOwners = locallock->lockOwners;
2668 {
2670 {
2673 {
2674 /*
2675 * We will still hold this lock after forgetting this
2676 * ResourceOwner.
2677 */
2679 /* compact out unused slot */
2680 locallock->numLockOwners--;
2685 }
2686 else
2687 {
2689 /* We want to call LockRelease just once */
2691 locallock->nLocks = 1;
2693 locallock->tag.mode,
2694 sessionLock))
2696 }
2697 break;
2698 }
2699 }
2700}
2701
2702/*
2703 * LockReassignCurrentOwner
2704 * Reassign all locks belonging to CurrentResourceOwner to belong
2705 * to its parent resource owner.
2706 *
2707 * If the caller knows what those locks are, it can pass them as an array.
2708 * That speeds up the call significantly, when a lot of locks are held
2709 * (e.g pg_dump with a large schema). Otherwise, pass NULL for locallocks,
2710 * and we'll traverse through our hash table to find them.
2711 */
2712void
2714{
2716
2718
2720 {
2721 HASH_SEQ_STATUS status;
2723
2725
2728 }
2729 else
2730 {
2732
2735 }
2736}
2737
2738/*
2739 * Subroutine of LockReassignCurrentOwner. Reassigns a given lock belonging to
2740 * CurrentResourceOwner to its parent.
2741 */
2742static void
2744{
2745 LOCALLOCKOWNER *lockOwners;
2749
2750 /*
2751 * Scan to see if there are any locks belonging to current owner or its
2752 * parent
2753 */
2754 lockOwners = locallock->lockOwners;
2756 {
2761 }
2762
2764 return; /* no current locks */
2765
2767 {
2768 /* Parent has no slot, so just give it the child's slot */
2771 }
2772 else
2773 {
2774 /* Merge child's count with parent's */
2776 /* compact out unused slot */
2777 locallock->numLockOwners--;
2780 }
2782}
2783
2784/*
2785 * FastPathGrantRelationLock
2786 * Grant lock using per-backend fast-path array, if there is space.
2787 */
2788static bool
2790{
2793
2794 /* fast-path group the lock belongs to */
2796
2797 /* Scan for existing entry for this relid, remembering empty slot. */
2799 {
2800 /* index into the whole per-backend array */
2802
2804 unused_slot = f;
2806 {
2809 return true;
2810 }
2811 }
2812
2813 /* If no existing entry, use any empty slot. */
2815 {
2818 ++FastPathLocalUseCounts[group];
2819 return true;
2820 }
2821
2822 /* No existing entry, and no empty slot. */
2823 return false;
2824}
2825
2826/*
2827 * FastPathUnGrantRelationLock
2828 * Release fast-path lock, if present. Update backend-private local
2829 * use count, while we're at it.
2830 */
2831static bool
2833{
2836
2837 /* fast-path group the lock belongs to */
2839
2840 FastPathLocalUseCounts[group] = 0;
2842 {
2843 /* index into the whole per-backend array */
2845
2848 {
2852 /* we continue iterating so as to update FastPathLocalUseCount */
2853 }
2855 ++FastPathLocalUseCounts[group];
2856 }
2858}
2859
2860/*
2861 * FastPathTransferRelationLocks
2862 * Transfer locks matching the given lock tag from per-backend fast-path
2863 * arrays to the shared hash table.
2864 *
2865 * Returns true if successful, false if ran out of shared memory.
2866 */
2867static bool
2869 uint32 hashcode)
2870{
2874
2875 /* fast-path group the lock belongs to */
2877
2878 /*
2879 * Every PGPROC that can potentially hold a fast-path lock is present in
2880 * ProcGlobal->allProcs. Prepared transactions are not, but any
2881 * outstanding fast-path locks held by prepared transactions are
2882 * transferred to the main lock table.
2883 */
2885 {
2888
2890
2891 /*
2892 * If the target backend isn't referencing the same database as the
2893 * lock, then we needn't examine the individual relation IDs at all;
2894 * none of them can be relevant.
2895 *
2896 * proc->databaseId is set at backend startup time and never changes
2897 * thereafter, so it might be safe to perform this test before
2898 * acquiring &proc->fpInfoLock. In particular, it's certainly safe to
2899 * assume that if the target backend holds any fast-path locks, it
2900 * must have performed a memory-fencing operation (in particular, an
2901 * LWLock acquisition) since setting proc->databaseId. However, it's
2902 * less clear that our backend is certain to have performed a memory
2903 * fencing operation since the other backend set proc->databaseId. So
2904 * for now, we test it after acquiring the LWLock just to be safe.
2905 *
2906 * Also skip groups without any registered fast-path locks.
2907 */
2909 proc->fpLockBits[group] == 0)
2910 {
2912 continue;
2913 }
2914
2916 {
2917 uint32 lockmode;
2918
2919 /* index into the whole per-backend array */
2921
2922 /* Look for an allocated slot matching the given relid. */
2924 continue;
2925
2926 /* Find or create lock object. */
2930 ++lockmode)
2931 {
2932 PROCLOCK *proclock;
2933
2935 continue;
2937 hashcode, lockmode);
2938 if (!proclock)
2939 {
2942 return false;
2943 }
2945 FAST_PATH_CLEAR_LOCKMODE(proc, f, lockmode);
2946 }
2948
2949 /* No need to examine remaining slots. */
2950 break;
2951 }
2953 }
2954 return true;
2955}
2956
2957/*
2958 * FastPathGetRelationLockEntry
2959 * Return the PROCLOCK for a lock originally taken via the fast-path,
2960 * transferring it to the primary lock table if necessary.
2961 *
2962 * Note: caller takes care of updating the locallock object.
2963 */
2966{
2973 group;
2974
2975 /* fast-path group the lock belongs to */
2976 group = FAST_PATH_REL_GROUP(relid);
2977
2979
2981 {
2982 uint32 lockmode;
2983
2984 /* index into the whole per-backend array */
2986
2987 /* Look for an allocated slot matching the given relid. */
2989 continue;
2990
2991 /* If we don't have a lock of the given mode, forget it! */
2992 lockmode = locallock->tag.mode;
2994 break;
2995
2996 /* Find or create lock object. */
2998
3000 locallock->hashcode, lockmode);
3001 if (!proclock)
3002 {
3009 }
3012
3014
3015 /* No need to examine remaining slots. */
3016 break;
3017 }
3018
3020
3021 /* Lock may have already been transferred by some other backend. */
3023 {
3024 LOCK *lock;
3027
3029
3031 locktag,
3032 locallock->hashcode,
3033 HASH_FIND,
3034 NULL);
3035 if (!lock)
3037
3038 proclocktag.myLock = lock;
3040
3042 proclock = (PROCLOCK *)
3044 &proclocktag,
3045 proclock_hashcode,
3046 HASH_FIND,
3047 NULL);
3048 if (!proclock)
3051 }
3052
3053 return proclock;
3054}
3055
3056/*
3057 * GetLockConflicts
3058 * Get an array of VirtualTransactionIds of xacts currently holding locks
3059 * that would conflict with the specified lock/lockmode.
3060 * xacts merely awaiting such a lock are NOT reported.
3061 *
3062 * The result array is palloc'd and is terminated with an invalid VXID.
3063 * *countp, if not null, is updated to the number of items set.
3064 *
3065 * Of course, the result could be out of date by the time it's returned, so
3066 * use of this function has to be thought about carefully. Similarly, a
3067 * PGPROC with no "lxid" will be considered non-conflicting regardless of any
3068 * lock it holds. Existing callers don't care about a locker after that
3069 * locker's pg_xact updates complete. CommitTransaction() clears "lxid" after
3070 * pg_xact updates and before releasing locks.
3071 *
3072 * Note we never include the current xact's vxid in the result array,
3073 * since an xact never blocks itself.
3074 */
3075VirtualTransactionId *
3077{
3081 LOCK *lock;
3084 PROCLOCK *proclock;
3085 uint32 hashcode;
3087 int count = 0;
3089
3095
3096 /*
3097 * Allocate memory to store results, and fill with InvalidVXID. We only
3098 * need enough space for MaxBackends + max_prepared_xacts + a terminator.
3099 * InHotStandby allocate once in TopMemoryContext.
3100 */
3102 {
3108 }
3109 else
3111
3112 /* Compute hash code and partition lock, and look up conflicting modes. */
3113 hashcode = LockTagHashCode(locktag);
3116
3117 /*
3118 * Fast path locks might not have been entered in the primary lock table.
3119 * If the lock we're dealing with could conflict with such a lock, we must
3120 * examine each backend's fast-path array for conflicts.
3121 */
3123 {
3126 VirtualTransactionId vxid;
3127
3128 /* fast-path group the lock belongs to */
3130
3131 /*
3132 * Iterate over relevant PGPROCs. Anything held by a prepared
3133 * transaction will have been transferred to the primary lock table,
3134 * so we need not worry about those. This is all a bit fuzzy, because
3135 * new locks could be taken after we've visited a particular
3136 * partition, but the callers had better be prepared to deal with that
3137 * anyway, since the locks could equally well be taken between the
3138 * time we return the value and the time the caller does something
3139 * with it.
3140 */
3142 {
3145
3146 /* A backend never blocks itself */
3148 continue;
3149
3151
3152 /*
3153 * If the target backend isn't referencing the same database as
3154 * the lock, then we needn't examine the individual relation IDs
3155 * at all; none of them can be relevant.
3156 *
3157 * See FastPathTransferRelationLocks() for discussion of why we do
3158 * this test after acquiring the lock.
3159 *
3160 * Also skip groups without any registered fast-path locks.
3161 */
3163 proc->fpLockBits[group] == 0)
3164 {
3166 continue;
3167 }
3168
3170 {
3172
3173 /* index into the whole per-backend array */
3175
3176 /* Look for an allocated slot matching the given relid. */
3178 continue;
3181 continue;
3183
3184 /*
3185 * There can only be one entry per relation, so if we found it
3186 * and it doesn't conflict, we can skip the rest of the slots.
3187 */
3189 break;
3190
3191 /* Conflict! */
3192 GET_VXID_FROM_PGPROC(vxid, *proc);
3193
3195 vxids[count++] = vxid;
3196 /* else, xact already committed or aborted */
3197
3198 /* No need to examine remaining slots. */
3199 break;
3200 }
3201
3203 }
3204 }
3205
3206 /* Remember how many fast-path conflicts we found. */
3207 fast_count = count;
3208
3209 /*
3210 * Look up the lock object matching the tag.
3211 */
3213
3215 locktag,
3216 hashcode,
3217 HASH_FIND,
3218 NULL);
3219 if (!lock)
3220 {
3221 /*
3222 * If the lock object doesn't exist, there is nothing holding a lock
3223 * on this lockable object.
3224 */
3229 *countp = count;
3231 }
3232
3233 /*
3234 * Examine each existing holder (or awaiter) of the lock.
3235 */
3237 {
3239
3241 {
3243
3244 /* A backend never blocks itself */
3246 {
3247 VirtualTransactionId vxid;
3248
3249 GET_VXID_FROM_PGPROC(vxid, *proc);
3250
3252 {
3254
3255 /* Avoid duplicate entries. */
3258 break;
3260 vxids[count++] = vxid;
3261 }
3262 /* else, xact already committed or aborted */
3263 }
3264 }
3265 }
3266
3268
3271
3275 *countp = count;
3277}
3278
3279/*
3280 * Find a lock in the shared lock table and release it. It is the caller's
3281 * responsibility to verify that this is a sane thing to do. (For example, it
3282 * would be bad to release a lock here if there might still be a LOCALLOCK
3283 * object with pointers to it.)
3284 *
3285 * We currently use this in two situations: first, to release locks held by
3286 * prepared transactions on commit (see lock_twophase_postcommit); and second,
3287 * to release locks taken via the fast-path, transferred to the main hash
3288 * table, and then released (see LockReleaseAll).
3289 */
3290static void
3294{
3295 LOCK *lock;
3296 PROCLOCK *proclock;
3298 uint32 hashcode;
3302
3303 hashcode = LockTagHashCode(locktag);
3305
3307
3308 /*
3309 * Re-find the lock object (it had better be there).
3310 */
3312 locktag,
3313 hashcode,
3314 HASH_FIND,
3315 NULL);
3316 if (!lock)
3318
3319 /*
3320 * Re-find the proclock object (ditto).
3321 */
3322 proclocktag.myLock = lock;
3323 proclocktag.myProc = proc;
3324
3326
3328 &proclocktag,
3329 proclock_hashcode,
3330 HASH_FIND,
3331 NULL);
3332 if (!proclock)
3334
3335 /*
3336 * Double-check that we are actually holding a lock of the type we want to
3337 * release.
3338 */
3340 {
3344 lockMethodTable->lockModeNames[lockmode]);
3345 return;
3346 }
3347
3348 /*
3349 * Do the releasing. CleanUpLock will waken any now-wakable waiters.
3350 */
3352
3353 CleanUpLock(lock, proclock,
3354 lockMethodTable, hashcode,
3355 wakeupNeeded);
3356
3358
3359 /*
3360 * Decrement strong lock count. This logic is needed only for 2PC.
3361 */
3363 && ConflictsWithRelationFastPath(locktag, lockmode))
3364 {
3366
3371 }
3372}
3373
3374/*
3375 * CheckForSessionAndXactLocks
3376 * Check to see if transaction holds both session-level and xact-level
3377 * locks on the same object; if so, throw an error.
3378 *
3379 * If we have both session- and transaction-level locks on the same object,
3380 * PREPARE TRANSACTION must fail. This should never happen with regular
3381 * locks, since we only take those at session level in some special operations
3382 * like VACUUM. It's possible to hit this with advisory locks, though.
3383 *
3384 * It would be nice if we could keep the session hold and give away the
3385 * transactional hold to the prepared xact. However, that would require two
3386 * PROCLOCK objects, and we cannot be sure that another PROCLOCK will be
3387 * available when it comes time for PostPrepare_Locks to do the deed.
3388 * So for now, we error out while we can still do so safely.
3389 *
3390 * Since the LOCALLOCK table stores a separate entry for each lockmode,
3391 * we can't implement this check by examining LOCALLOCK entries in isolation.
3392 * We must build a transient hashtable that is indexed by locktag only.
3393 */
3394static void
3396{
3397 typedef struct
3398 {
3402 } PerLockTagEntry;
3403
3406 HASH_SEQ_STATUS status;
3408
3409 /* Create a local hash table keyed by LOCKTAG only */
3413
3415 256, /* arbitrary initial size */
3416 &hash_ctl,
3418
3419 /* Scan local lock table to find entries for each LOCKTAG */
3421
3423 {
3426 bool found;
3428
3429 /*
3430 * Ignore VXID locks. We don't want those to be held by prepared
3431 * transactions, since they aren't meaningful after a restart.
3432 */
3434 continue;
3435
3436 /* Ignore it if we don't actually hold the lock */
3438 continue;
3439
3440 /* Otherwise, find or make an entry in lockhtab */
3442 &locallock->tag.lock,
3443 HASH_ENTER, &found);
3444 if (!found) /* initialize, if newly created */
3446
3447 /* Scan to see if we hold lock at session or xact level or both */
3449 {
3452 else
3454 }
3455
3456 /*
3457 * We can throw error immediately when we see both types of locks; no
3458 * need to wait around to see if there are more violations.
3459 */
3463 errmsg("cannot PREPARE while holding both session-level and transaction-level locks on the same object")));
3464 }
3465
3466 /* Success, so clean up */
3468}
3469
3470/*
3471 * AtPrepare_Locks
3472 * Do the preparatory work for a PREPARE: make 2PC state file records
3473 * for all locks currently held.
3474 *
3475 * Session-level locks are ignored, as are VXID locks.
3476 *
3477 * For the most part, we don't need to touch shared memory for this ---
3478 * all the necessary state information is in the locallock table.
3479 * Fast-path locks are an exception, however: we move any such locks to
3480 * the main table before allowing PREPARE TRANSACTION to succeed.
3481 */
3482void
3484{
3485 HASH_SEQ_STATUS status;
3487
3488 /* First, verify there aren't locks of both xact and session level */
3489 CheckForSessionAndXactLocks();
3490
3491 /* Now do the per-locallock cleanup work */
3493
3495 {
3496 TwoPhaseLockRecord record;
3501
3502 /*
3503 * Ignore VXID locks. We don't want those to be held by prepared
3504 * transactions, since they aren't meaningful after a restart.
3505 */
3507 continue;
3508
3509 /* Ignore it if we don't actually hold the lock */
3511 continue;
3512
3513 /* Scan to see whether we hold it at session or transaction level */
3516 {
3519 else
3521 }
3522
3523 /* Ignore it if we have only session lock */
3525 continue;
3526
3527 /* This can't happen, because we already checked it */
3531 errmsg("cannot PREPARE while holding both session-level and transaction-level locks on the same object")));
3532
3533 /*
3534 * If the local lock was taken via the fast-path, we need to move it
3535 * to the primary lock table, or just get a pointer to the existing
3536 * primary lock table entry if by chance it's already been
3537 * transferred.
3538 */
3540 {
3543 }
3544
3545 /*
3546 * Arrange to not release any strong lock count held by this lock
3547 * entry. We must retain the count until the prepared transaction is
3548 * committed or rolled back.
3549 */
3551
3552 /*
3553 * Create a 2PC record.
3554 */
3557
3560 }
3561}
3562
3563/*
3564 * PostPrepare_Locks
3565 * Clean up after successful PREPARE
3566 *
3567 * Here, we want to transfer ownership of our locks to a dummy PGPROC
3568 * that's now associated with the prepared transaction, and we want to
3569 * clean out the corresponding entries in the LOCALLOCK table.
3570 *
3571 * Note: by removing the LOCALLOCK entries, we are leaving dangling
3572 * pointers in the transaction's resource owner. This is OK at the
3573 * moment since resowner.c doesn't try to free locks retail at a toplevel
3574 * transaction commit or abort. We could alternatively zero out nLocks
3575 * and leave the LOCALLOCK entries to be garbage-collected by LockReleaseAll,
3576 * but that probably costs more cycles.
3577 */
3578void
3580{
3582 HASH_SEQ_STATUS status;
3584 LOCK *lock;
3585 PROCLOCK *proclock;
3588
3589 /* Can't prepare a lock group follower. */
3592
3593 /* This is a critical section: any error means big trouble */
3594 START_CRIT_SECTION();
3595
3596 /*
3597 * First we run through the locallock table and get rid of unwanted
3598 * entries, then we scan the process's proclocks and transfer them to the
3599 * target proc.
3600 *
3601 * We do this separately because we may have multiple locallock entries
3602 * pointing to the same proclock, and we daren't end up with any dangling
3603 * pointers.
3604 */
3606
3608 {
3613
3615 {
3616 /*
3617 * We must've run out of shared memory while trying to set up this
3618 * lock. Just forget the local entry.
3619 */
3622 continue;
3623 }
3624
3625 /* Ignore VXID locks */
3627 continue;
3628
3629 /* Scan to see whether we hold it at session or transaction level */
3632 {
3635 else
3637 }
3638
3639 /* Ignore it if we have only session lock */
3641 continue;
3642
3643 /* This can't happen, because we already checked it */
3647 errmsg("cannot PREPARE while holding both session-level and transaction-level locks on the same object")));
3648
3649 /* Mark the proclock to show we need to release this lockmode */
3652
3653 /* And remove the locallock hashtable entry */
3655 }
3656
3657 /*
3658 * Now, scan each lock partition separately.
3659 */
3661 {
3665
3667
3668 /*
3669 * If the proclock list for this partition is empty, we can skip
3670 * acquiring the partition lock. This optimization is safer than the
3671 * situation in LockReleaseAll, because we got rid of any fast-path
3672 * locks during AtPrepare_Locks, so there cannot be any case where
3673 * another backend is adding something to our lists now. For safety,
3674 * though, we code this the same way as in LockReleaseAll.
3675 */
3677 continue; /* needn't examine this partition */
3678
3680
3682 {
3684
3686
3688
3689 /* Ignore VXID locks */
3691 continue;
3692
3699
3700 /* Ignore it if nothing to release (must be a session lock) */
3702 continue;
3703
3704 /* Else we should be releasing all locks */
3707
3708 /*
3709 * We cannot simply modify proclock->tag.myProc to reassign
3710 * ownership of the lock, because that's part of the hash key and
3711 * the proclock would then be in the wrong hash chain. Instead
3712 * use hash_update_hash_key. (We used to create a new hash entry,
3713 * but that risks out-of-memory failure if other processes are
3714 * busy making proclocks too.) We must unlink the proclock from
3715 * our procLink chain and put it into the new proc's chain, too.
3716 *
3717 * Note: the updated proclock hash key will still belong to the
3718 * same hash partition, cf proclock_hash(). So the partition lock
3719 * we already hold is sufficient for this.
3720 */
3722
3723 /*
3724 * Create the new hash key for the proclock.
3725 */
3726 proclocktag.myLock = lock;
3728
3729 /*
3730 * Update groupLeader pointer to point to the new proc. (We'd
3731 * better not be a member of somebody else's lock group!)
3732 */
3735
3736 /*
3737 * Update the proclock. We should not find any existing entry for
3738 * the same hash key, since there can be only one entry for any
3739 * given lock with my own proc.
3740 */
3742 proclock,
3743 &proclocktag))
3745
3746 /* Re-link into the new proc's proclock list */
3748
3750 } /* loop over PROCLOCKs within this partition */
3751
3753 } /* loop over partitions */
3754
3755 END_CRIT_SECTION();
3756}
3757
3758
3759/*
3760 * GetLockStatusData - Return a summary of the lock manager's internal
3761 * status, for use in a user-level reporting function.
3762 *
3763 * The return data consists of an array of LockInstanceData objects,
3764 * which are a lightly abstracted version of the PROCLOCK data structures,
3765 * i.e. there is one entry for each unique lock and interested PGPROC.
3766 * It is the caller's responsibility to match up related items (such as
3767 * references to the same lockable object or PGPROC) if wanted.
3768 *
3769 * The design goal is to hold the LWLocks for as short a time as possible;
3770 * thus, this function simply makes a copy of the necessary data and releases
3771 * the locks, allowing the caller to contemplate and format the data for as
3772 * long as it pleases.
3773 */
3774LockData *
3776{
3778 PROCLOCK *proclock;
3783
3785
3786 /* Guess how much space we'll need. */
3788 el = 0;
3790
3791 /*
3792 * First, we iterate through the per-backend fast-path arrays, locking
3793 * them one at a time. This might produce an inconsistent picture of the
3794 * system state, but taking all of those LWLocks at the same time seems
3795 * impractical (in particular, note MAX_SIMUL_LWLOCKS). It shouldn't
3796 * matter too much, because none of these locks can be involved in lock
3797 * conflicts anyway - anything that might must be present in the main lock
3798 * table. (For the same reason, we don't sweat about making leaderPid
3799 * completely valid. We cannot safely dereference another backend's
3800 * lockGroupLeader field without holding all lock partition locks, and
3801 * it's not worth that.)
3802 */
3804 {
3806
3807 /* Skip backends with pid=0, as they don't hold fast-path locks */
3809 continue;
3810
3812
3814 {
3815 /* Skip groups without registered fast-path locks */
3817 continue;
3818
3820 {
3824
3825 /* Skip unallocated slots */
3827 continue;
3828
3830 {
3834 }
3835
3838 proc->fpRelId[f]);
3846
3847 /*
3848 * Successfully taking fast path lock means there were no
3849 * conflicting locks.
3850 */
3851 instance->waitStart = 0;
3852
3853 el++;
3854 }
3855 }
3856
3858 {
3859 VirtualTransactionId vxid;
3861
3863 {
3867 }
3868
3871
3881 instance->waitStart = 0;
3882
3883 el++;
3884 }
3885
3887 }
3888
3889 /*
3890 * Next, acquire lock on the entire shared lock data structure. We do
3891 * this so that, at least for locks in the primary lock table, the state
3892 * will be self-consistent.
3893 *
3894 * Since this is a read-only operation, we take shared instead of
3895 * exclusive lock. There's not a whole lot of point to this, because all
3896 * the normal operations require exclusive lock, but it doesn't hurt
3897 * anything either. It will at least allow two backends to do
3898 * GetLockStatusData in parallel.
3899 *
3900 * Must grab LWLocks in partition-number order to avoid LWLock deadlock.
3901 */
3904
3905 /* Now we can safely count the number of proclocks */
3908 {
3912 }
3913
3914 /* Now scan the tables to copy the data */
3916
3918 {
3922
3927 else
3935
3936 el++;
3937 }
3938
3939 /*
3940 * And release locks. We do this in reverse order for two reasons: (1)
3941 * Anyone else who needs more than one of the locks will be trying to lock
3942 * them in increasing order; we don't want to release the other process
3943 * until it can get all the locks it needs. (2) This avoids O(N^2)
3944 * behavior inside LWLockRelease.
3945 */
3948
3950
3952}
3953
3954/*
3955 * GetBlockerStatusData - Return a summary of the lock manager's state
3956 * concerning locks that are blocking the specified PID or any member of
3957 * the PID's lock group, for use in a user-level reporting function.
3958 *
3959 * For each PID within the lock group that is awaiting some heavyweight lock,
3960 * the return data includes an array of LockInstanceData objects, which are
3961 * the same data structure used by GetLockStatusData; but unlike that function,
3962 * this one reports only the PROCLOCKs associated with the lock that that PID
3963 * is blocked on. (Hence, all the locktags should be the same for any one
3964 * blocked PID.) In addition, we return an array of the PIDs of those backends
3965 * that are ahead of the blocked PID in the lock's wait queue. These can be
3966 * compared with the PIDs in the LockInstanceData objects to determine which
3967 * waiters are ahead of or behind the blocked PID in the queue.
3968 *
3969 * If blocked_pid isn't a valid backend PID or nothing in its lock group is
3970 * waiting on any heavyweight lock, return empty arrays.
3971 *
3972 * The design goal is to hold the LWLocks for as short a time as possible;
3973 * thus, this function simply makes a copy of the necessary data and releases
3974 * the locks, allowing the caller to contemplate and format the data for as
3975 * long as it pleases.
3976 */
3977BlockedProcsData *
3979{
3981 PGPROC *proc;
3983
3985
3986 /*
3987 * Guess how much space we'll need, and preallocate. Most of the time
3988 * this will avoid needing to do repalloc while holding the LWLocks. (We
3989 * assume, but check with an Assert, that MaxBackends is enough entries
3990 * for the procs[] array; the other two could need enlargement, though.)
3991 */
3997
3998 /*
3999 * In order to search the ProcArray for blocked_pid and assume that that
4000 * entry won't immediately disappear under us, we must hold ProcArrayLock.
4001 * In addition, to examine the lock grouping fields of any other backend,
4002 * we must hold all the hash partition locks. (Only one of those locks is
4003 * actually relevant for any one lock group, but we can't know which one
4004 * ahead of time.) It's fairly annoying to hold all those locks
4005 * throughout this, but it's no worse than GetLockStatusData(), and it
4006 * does have the advantage that we're guaranteed to return a
4007 * self-consistent instantaneous state.
4008 */
4010
4012
4013 /* Nothing to do if it's gone */
4015 {
4016 /*
4017 * Acquire lock on the entire shared lock data structure. See notes
4018 * in GetLockStatusData().
4019 */
4022
4024 {
4025 /* Easy case, proc is not a lock group member */
4027 }
4028 else
4029 {
4030 /* Examine all procs in proc's lock group */
4031 dlist_iter iter;
4032
4034 {
4036
4039 }
4040 }
4041
4042 /*
4043 * And release locks. See notes in GetLockStatusData().
4044 */
4047
4049 }
4050
4052
4054}
4055
4056/* Accumulate data about one possibly-blocked proc for GetBlockerStatusData */
4057static void
4059{
4065 int queue_size;
4066
4067 /* Nothing to do if this proc is not blocked */
4069 return;
4070
4071 /* Set up a procs[] element */
4076
4077 /*
4078 * We may ignore the proc's fast-path arrays, since nothing in those could
4079 * be related to a contended lock.
4080 */
4081
4082 /* Collect all PROCLOCKs associated with theLock */
4084 {
4085 PROCLOCK *proclock =
4090
4092 {
4096 }
4097
4103 else
4110 data->nlocks++;
4111 }
4112
4113 /* Enlarge waiter_pids[] if it's too small to hold all wait queue PIDs */
4116
4118 {
4120 data->npids + queue_size);
4123 }
4124
4125 /* Collect PIDs from the lock's wait queue, stopping at blocked_proc */
4127 {
4129
4131 break;
4133 }
4134
4137}
4138
4139/*
4140 * Returns a list of currently held AccessExclusiveLocks, for use by
4141 * LogStandbySnapshot(). The result is a palloc'd array,
4142 * with the number of elements returned into *nlocks.
4143 *
4144 * XXX This currently takes a lock on all partitions of the lock table,
4145 * but it's possible to do better. By reference counting locks and storing
4146 * the value in the ProcArray entry for each backend we could tell if any
4147 * locks need recording without having to acquire the partition locks and
4148 * scan the lock table. Whether that's worth the additional overhead
4149 * is pretty dubious though.
4150 */
4151xl_standby_lock *
4153{
4155 PROCLOCK *proclock;
4160
4161 /*
4162 * Acquire lock on the entire shared lock data structure.
4163 *
4164 * Must grab LWLocks in partition-number order to avoid LWLock deadlock.
4165 */
4168
4169 /* Now we can safely count the number of proclocks */
4171
4172 /*
4173 * Allocating enough space for all locks in the lock table is overkill,
4174 * but it's more convenient and faster than having to enlarge the array.
4175 */
4177
4178 /* Now scan the tables to copy the data */
4180
4181 /*
4182 * If lock is a currently granted AccessExclusiveLock then it will have
4183 * just one proclock holder, so locks are never accessed twice in this
4184 * particular case. Don't copy this code for use elsewhere because in the
4185 * general case this will give you duplicate locks when looking at
4186 * non-exclusive lock types.
4187 */
4188 index = 0;
4190 {
4191 /* make sure this definition matches the one used in LockAcquire */
4194 {
4198
4199 /*
4200 * Don't record locks for transactions if we know they have
4201 * already issued their WAL record for commit but not yet released
4202 * lock. It is still possible that we see locks held by already
4203 * complete transactions, if they haven't yet zeroed their xids.
4204 */
4206 continue;
4207
4211
4212 index++;
4213 }
4214 }
4215
4217
4218 /*
4219 * And release locks. We do this in reverse order for two reasons: (1)
4220 * Anyone else who needs more than one of the locks will be trying to lock
4221 * them in increasing order; we don't want to release the other process
4222 * until it can get all the locks it needs. (2) This avoids O(N^2)
4223 * behavior inside LWLockRelease.
4224 */
4227
4228 *nlocks = index;
4230}
4231
4232/* Provide the textual name of any lock mode */
4233const char *
4235{
4239}
4240
4241#ifdef LOCK_DEBUG
4242/*
4243 * Dump all locks in the given proc's myProcLocks lists.
4244 *
4245 * Caller is responsible for having acquired appropriate LWLocks.
4246 */
4247void
4249{
4251
4253 return;
4254
4257
4259 {
4261 dlist_iter iter;
4262
4263 dlist_foreach(iter, procLocks)
4264 {
4267
4271 }
4272 }
4273}
4274
4275/*
4276 * Dump all lmgr locks.
4277 *
4278 * Caller is responsible for having acquired appropriate LWLocks.
4279 */
4280void
4282{
4283 PGPROC *proc;
4284 PROCLOCK *proclock;
4285 LOCK *lock;
4286 HASH_SEQ_STATUS status;
4287
4288 proc = MyProc;
4289
4292
4294
4296 {
4298
4300 if (lock)
4302 else
4304 }
4305}
4306#endif /* LOCK_DEBUG */
4307
4308/*
4309 * LOCK 2PC resource manager's routines
4310 */
4311
4312/*
4313 * Re-acquire a lock belonging to a transaction that was prepared.
4314 *
4315 * Because this function is run at db startup, re-acquiring the locks should
4316 * never conflict with running transactions because there are none. We
4317 * assume that the lock state represented by the stored 2PC files is legal.
4318 *
4319 * When switching from Hot Standby mode to normal operation, the locks will
4320 * be already held by the startup process. The locks are acquired for the new
4321 * procs without checking for conflicts, so we don't get a conflict between the
4322 * startup process and the dummy procs, even though we will momentarily have
4323 * a situation where two procs are holding the same AccessExclusiveLock,
4324 * which isn't normally possible because the conflict. If we're in standby
4325 * mode, but a recovery snapshot hasn't been established yet, it's possible
4326 * that some but not all of the locks are already held by the startup process.
4327 *
4328 * This approach is simple, but also a bit dangerous, because if there isn't
4329 * enough shared memory to acquire the locks, an error will be thrown, which
4330 * is promoted to FATAL and recovery will abort, bringing down postmaster.
4331 * A safer approach would be to transfer the locks like we do in
4332 * AtPrepare_Locks, but then again, in hot standby mode it's possible for
4333 * read-only backends to use up all the shared lock memory anyway, so that
4334 * replaying the WAL record that needs to acquire a lock will throw an error
4335 * and PANIC anyway.
4336 */
4337void
4340{
4343 LOCKTAG *locktag;
4344 LOCKMODE lockmode;
4346 LOCK *lock;
4347 PROCLOCK *proclock;
4349 bool found;
4350 uint32 hashcode;
4355
4357 locktag = &rec->locktag;
4358 lockmode = rec->lockmode;
4360
4364
4365 hashcode = LockTagHashCode(locktag);
4368
4370
4371 /*
4372 * Find or create a lock with this tag.
4373 */
4375 locktag,
4376 hashcode,
4377 HASH_ENTER_NULL,
4378 &found);
4379 if (!lock)
4380 {
4386 }
4387
4388 /*
4389 * if it's a new lock object, initialize it
4390 */
4391 if (!found)
4392 {
4393 lock->grantMask = 0;
4394 lock->waitMask = 0;
4397 lock->nRequested = 0;
4398 lock->nGranted = 0;
4402 }
4403 else
4404 {
4409 }
4410
4411 /*
4412 * Create the hash key for the proclock table.
4413 */
4414 proclocktag.myLock = lock;
4415 proclocktag.myProc = proc;
4416
4418
4419 /*
4420 * Find or create a proclock entry with this tag
4421 */
4423 &proclocktag,
4424 proclock_hashcode,
4425 HASH_ENTER_NULL,
4426 &found);
4427 if (!proclock)
4428 {
4429 /* Oops, not enough shmem for the proclock */
4431 {
4432 /*
4433 * There are no other requestors of this lock, so garbage-collect
4434 * the lock object. We *must* do this to avoid a permanent leak
4435 * of shared memory, because there won't be anything to cause
4436 * anyone to release the lock object later.
4437 */
4440 &(lock->tag),
4441 hashcode,
4442 HASH_REMOVE,
4443 NULL))
4445 }
4451 }
4452
4453 /*
4454 * If new, initialize the new entry
4455 */
4456 if (!found)
4457 {
4459 proclock->groupLeader = proc;
4460 proclock->holdMask = 0;
4461 proclock->releaseMask = 0;
4462 /* Add proclock to appropriate lists */
4465 &proclock->procLink);
4467 }
4468 else
4469 {
4472 }
4473
4474 /*
4475 * lock->nRequested and lock->requested[] count the total number of
4476 * requests, whether granted or waiting, so increment those immediately.
4477 */
4478 lock->nRequested++;
4479 lock->requested[lockmode]++;
4481
4482 /*
4483 * We shouldn't already hold the desired lock.
4484 */
4487 lockMethodTable->lockModeNames[lockmode],
4490
4491 /*
4492 * We ignore any possible conflicts and just grant ourselves the lock. Not
4493 * only because we don't bother, but also to avoid deadlocks when
4494 * switching from standby to normal mode. See function comment.
4495 */
4496 GrantLock(lock, proclock, lockmode);
4497
4498 /*
4499 * Bump strong lock count, to make sure any fast-path lock requests won't
4500 * be granted without consulting the primary lock table.
4501 */
4503 {
4505
4509 }
4510
4512}
4513
4514/*
4515 * Re-acquire a lock belonging to a transaction that was prepared, when
4516 * starting up into hot standby mode.
4517 */
4518void
4521{
4523 LOCKTAG *locktag;
4524 LOCKMODE lockmode;
4526
4528 locktag = &rec->locktag;
4529 lockmode = rec->lockmode;
4531
4534
4537 {
4541 }
4542}
4543
4544
4545/*
4546 * 2PC processing routine for COMMIT PREPARED case.
4547 *
4548 * Find and release the lock indicated by the 2PC record.
4549 */
4550void
4553{
4556 LOCKTAG *locktag;
4559
4561 locktag = &rec->locktag;
4563
4567
4569}
4570
4571/*
4572 * 2PC processing routine for ROLLBACK PREPARED case.
4573 *
4574 * This is actually just the same as the COMMIT case.
4575 */
4576void
4579{
4581}
4582
4583/*
4584 * VirtualXactLockTableInsert
4585 *
4586 * Take vxid lock via the fast-path. There can't be any pre-existing
4587 * lockers, as we haven't advertised this vxid via the ProcArray yet.
4588 *
4589 * Since MyProc->fpLocalTransactionId will normally contain the same data
4590 * as MyProc->vxid.lxid, you might wonder if we really need both. The
4591 * difference is that MyProc->vxid.lxid is set and cleared unlocked, and
4592 * examined by procarray.c, while fpLocalTransactionId is protected by
4593 * fpInfoLock and is used only by the locking subsystem. Doing it this
4594 * way makes it easier to verify that there are no funny race conditions.
4595 *
4596 * We don't bother recording this lock in the local lock table, since it's
4597 * only ever released at the end of a transaction. Instead,
4598 * LockReleaseAll() calls VirtualXactLockTableCleanup().
4599 */
4600void
4602{
4604
4606
4610
4613
4615}
4616
4617/*
4618 * VirtualXactLockTableCleanup
4619 *
4620 * Check whether a VXID lock has been materialized; if so, release it,
4621 * unblocking waiters.
4622 */
4623void
4625{
4626 bool fastpath;
4627 LocalTransactionId lxid;
4628
4630
4631 /*
4632 * Clean up shared memory state.
4633 */
4635
4640
4642
4643 /*
4644 * If fpVXIDLock has been cleared without touching fpLocalTransactionId,
4645 * that means someone transferred the lock to the main lock table.
4646 */
4648 {
4649 VirtualTransactionId vxid;
4650 LOCKTAG locktag;
4651
4653 vxid.localTransactionId = lxid;
4654 SET_LOCKTAG_VIRTUALTRANSACTION(locktag, vxid);
4655
4658 }
4659}
4660
4661/*
4662 * XactLockForVirtualXact
4663 *
4664 * If TransactionIdIsValid(xid), this is essentially XactLockTableWait(xid,
4665 * NULL, NULL, XLTW_None) or ConditionalXactLockTableWait(xid). Unlike those
4666 * functions, it assumes "xid" is never a subtransaction and that "xid" is
4667 * prepared, committed, or aborted.
4668 *
4669 * If !TransactionIdIsValid(xid), this locks every prepared XID having been
4670 * known as "vxid" before its PREPARE TRANSACTION.
4671 */
4672static bool
4675{
4677
4678 /* There is no point to wait for 2PCs if you have no 2PCs. */
4680 return true;
4681
4682 do
4683 {
4685 LOCKTAG tag;
4686
4687 /* Clear state from previous iterations. */
4689 {
4690 xid = InvalidTransactionId;
4692 }
4693
4694 /* If we have no xid, try to find one. */
4698 {
4700 return true;
4701 }
4702
4703 /* Check or wait for XID completion. */
4704 SET_LOCKTAG_TRANSACTION(tag, xid);
4707 return false;
4710
4711 return true;
4712}
4713
4714/*
4715 * VirtualXactLock
4716 *
4717 * If wait = true, wait as long as the given VXID or any XID acquired by the
4718 * same transaction is still running. Then, return true.
4719 *
4720 * If wait = false, just check whether that VXID or one of those XIDs is still
4721 * running, and return true or false.
4722 */
4723bool
4725{
4726 LOCKTAG tag;
4727 PGPROC *proc;
4729
4731
4733 /* no vxid lock; localTransactionId is a normal, locked XID */
4735
4736 SET_LOCKTAG_VIRTUALTRANSACTION(tag, vxid);
4737
4738 /*
4739 * If a lock table entry must be made, this is the PGPROC on whose behalf
4740 * it must be done. Note that the transaction might end or the PGPROC
4741 * might be reassigned to a new backend before we get around to examining
4742 * it, but it doesn't matter. If we find upon examination that the
4743 * relevant lxid is no longer running here, that's enough to prove that
4744 * it's no longer running anywhere.
4745 */
4749
4750 /*
4751 * We must acquire this lock before checking the procNumber and lxid
4752 * against the ones we're waiting for. The target backend will only set
4753 * or clear lxid while holding this lock.
4754 */
4756
4759 {
4760 /* VXID ended */
4763 }
4764
4765 /*
4766 * If we aren't asked to wait, there's no need to set up a lock table
4767 * entry. The transaction is still in progress, so just return false.
4768 */
4769 if (!wait)
4770 {
4772 return false;
4773 }
4774
4775 /*
4776 * OK, we're going to need to sleep on the VXID. But first, we must set
4777 * up the primary lock table entry, if needed (ie, convert the proc's
4778 * fast-path lock on its VXID to a regular lock).
4779 */
4781 {
4782 PROCLOCK *proclock;
4783 uint32 hashcode;
4785
4786 hashcode = LockTagHashCode(&tag);
4787
4790
4792 &tag, hashcode, ExclusiveLock);
4793 if (!proclock)
4794 {
4801 }
4803
4805
4807 }
4808
4809 /*
4810 * If the proc has an XID now, we'll avoid a TwoPhaseGetXidByVirtualXID()
4811 * search. The proc might have assigned this XID but not yet locked it,
4812 * in which case the proc will lock this XID before releasing the VXID.
4813 * The fpInfoLock critical section excludes VirtualXactLockTableCleanup(),
4814 * so we won't save an XID of a different VXID. It doesn't matter whether
4815 * we save this before or after setting up the primary lock table entry.
4816 */
4817 xid = proc->xid;
4818
4819 /* Done with proc->fpLockBits */
4821
4822 /* Time to wait. */
4824
4827}
4828
4829/*
4830 * LockWaiterCount
4831 *
4832 * Find the number of lock requester on this locktag
4833 */
4834int
4836{
4838 LOCK *lock;
4839 bool found;
4840 uint32 hashcode;
4842 int waiters = 0;
4843
4846
4847 hashcode = LockTagHashCode(locktag);
4850
4852 locktag,
4853 hashcode,
4854 HASH_FIND,
4855 &found);
4856 if (found)
4857 {
4859 waiters = lock->nRequested;
4860 }
4862
4863 return waiters;
4864}
static uint64 pg_atomic_read_u64(volatile pg_atomic_uint64 *ptr)
Definition atomics.h:467
memcpy(sums, checksumBaseOffsets, sizeof(checksumBaseOffsets))
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition dynahash.c:889
HTAB * hash_create(const char *tabname, int64 nelem, const HASHCTL *info, int flags)
Definition dynahash.c:360
void * hash_search_with_hash_value(HTAB *hashp, const void *keyPtr, uint32 hashvalue, HASHACTION action, bool *foundPtr)
Definition dynahash.c:902
bool hash_update_hash_key(HTAB *hashp, void *existingEntry, const void *newKeyPtr)
Definition dynahash.c:1077
int errhint(const char *fmt,...) pg_attribute_printf(1
int int int int errdetail_log_plural(const char *fmt_singular, const char *fmt_plural, unsigned long n,...) pg_attribute_printf(1
static bool dlist_node_is_detached(const dlist_node *node)
Definition ilist.h:525
static void dlist_push_tail(dlist_head *head, dlist_node *node)
Definition ilist.h:364
static void dclist_delete_from_thoroughly(dclist_head *head, dlist_node *node)
Definition ilist.h:776
static bool XactLockForVirtualXact(VirtualTransactionId vxid, TransactionId xid, bool wait)
Definition lock.c:4674
LockAcquireResult LockAcquire(const LOCKTAG *locktag, LOCKMODE lockmode, bool sessionLock, bool dontWait)
Definition lock.c:806
static void LockReassignOwner(LOCALLOCK *locallock, ResourceOwner parent)
Definition lock.c:2744
bool LockHeldByMe(const LOCKTAG *locktag, LOCKMODE lockmode, bool orstronger)
Definition lock.c:640
void lock_twophase_postabort(FullTransactionId fxid, uint16 info, void *recdata, uint32 len)
Definition lock.c:4578
void lock_twophase_standby_recover(FullTransactionId fxid, uint16 info, void *recdata, uint32 len)
Definition lock.c:4520
static PROCLOCK * SetupLockInTable(LockMethod lockMethodTable, PGPROC *proc, const LOCKTAG *locktag, uint32 hashcode, LOCKMODE lockmode)
Definition lock.c:1291
static PROCLOCK * FastPathGetRelationLockEntry(LOCALLOCK *locallock)
Definition lock.c:2966
void VirtualXactLockTableInsert(VirtualTransactionId vxid)
Definition lock.c:4602
#define FastPathStrongLockHashPartition(hashcode)
Definition lock.c:306
static uint32 ProcLockHashCode(const PROCLOCKTAG *proclocktag, uint32 hashcode)
Definition lock.c:602
bool LockRelease(const LOCKTAG *locktag, LOCKMODE lockmode, bool sessionLock)
Definition lock.c:2110
VirtualTransactionId * GetLockConflicts(const LOCKTAG *locktag, LOCKMODE lockmode, int *countp)
Definition lock.c:3077
static volatile FastPathStrongRelationLockData * FastPathStrongRelationLocks
Definition lock.c:315
LockAcquireResult LockAcquireExtended(const LOCKTAG *locktag, LOCKMODE lockmode, bool sessionLock, bool dontWait, bool reportMemoryError, LOCALLOCK **locallockp, bool logLockFailure)
Definition lock.c:833
static void CheckAndSetLockHeld(LOCALLOCK *locallock, bool acquired)
Definition lock.c:1472
#define ConflictsWithRelationFastPath(locktag, mode)
Definition lock.c:276
static bool FastPathTransferRelationLocks(LockMethod lockMethodTable, const LOCKTAG *locktag, uint32 hashcode)
Definition lock.c:2869
void LockReassignCurrentOwner(LOCALLOCK **locallocks, int nlocks)
Definition lock.c:2714
static bool UnGrantLock(LOCK *lock, LOCKMODE lockmode, PROCLOCK *proclock, LockMethod lockMethodTable)
Definition lock.c:1689
static void CleanUpLock(LOCK *lock, PROCLOCK *proclock, LockMethod lockMethodTable, uint32 hashcode, bool wakeupNeeded)
Definition lock.c:1746
static bool FastPathUnGrantRelationLock(Oid relid, LOCKMODE lockmode)
Definition lock.c:2833
static bool FastPathGrantRelationLock(Oid relid, LOCKMODE lockmode)
Definition lock.c:2790
static int FastPathLocalUseCounts[FP_LOCK_GROUPS_PER_BACKEND_MAX]
Definition lock.c:179
static ProcWaitStatus WaitOnLock(LOCALLOCK *locallock, ResourceOwner owner)
Definition lock.c:1940
bool LockHasWaiters(const LOCKTAG *locktag, LOCKMODE lockmode, bool sessionLock)
Definition lock.c:693
const char * GetLockmodeName(LOCKMETHODID lockmethodid, LOCKMODE mode)
Definition lock.c:4235
static void GetSingleProcBlockerStatusData(PGPROC *blocked_proc, BlockedProcsData *data)
Definition lock.c:4059
void lock_twophase_postcommit(FullTransactionId fxid, uint16 info, void *recdata, uint32 len)
Definition lock.c:4552
void LockReleaseCurrentOwner(LOCALLOCK **locallocks, int nlocks)
Definition lock.c:2619
static void BeginStrongLockAcquire(LOCALLOCK *locallock, uint32 fasthashcode)
Definition lock.c:1832
bool LockCheckConflicts(LockMethod lockMethodTable, LOCKMODE lockmode, LOCK *lock, PROCLOCK *proclock)
Definition lock.c:1537
void lock_twophase_recover(FullTransactionId fxid, uint16 info, void *recdata, uint32 len)
Definition lock.c:4339
static void GrantLockLocal(LOCALLOCK *locallock, ResourceOwner owner)
Definition lock.c:1800
static void ReleaseLockIfHeld(LOCALLOCK *locallock, bool sessionLock)
Definition lock.c:2654
#define FAST_PATH_STRONG_LOCK_HASH_PARTITIONS
Definition lock.c:304
xl_standby_lock * GetRunningTransactionLocks(int *nlocks)
Definition lock.c:4153
static void LockRefindAndRelease(LockMethod lockMethodTable, PGPROC *proc, LOCKTAG *locktag, LOCKMODE lockmode, bool decrement_strong_lock_count)
Definition lock.c:3292
LockMethod GetLockTagsMethodTable(const LOCKTAG *locktag)
Definition lock.c:536
#define VirtualTransactionIdIsRecoveredPreparedXact(vxid)
Definition lock.h:72
#define SET_LOCKTAG_VIRTUALTRANSACTION(locktag, vxid)
Definition locktag.h:135
void pgstat_count_lock_fastpath_exceeded(uint8 locktag_type)
Definition pgstat_lock.c:128
void ResourceOwnerRememberLock(ResourceOwner owner, LOCALLOCK *locallock)
Definition resowner.c:1059
ResourceOwner ResourceOwnerGetParent(ResourceOwner owner)
Definition resowner.c:902
void ResourceOwnerForgetLock(ResourceOwner owner, LOCALLOCK *locallock)
Definition resowner.c:1079
ProcWaitStatus JoinWaitQueue(LOCALLOCK *locallock, LockMethod lockMethodTable, bool dontWait)
Definition proc.c:1146
void GetLockHoldersAndWaiters(LOCALLOCK *locallock, StringInfo lock_holders_sbuf, StringInfo lock_waiters_sbuf, int *lockHoldersNum)
Definition proc.c:1941
void StandbyAcquireAccessExclusiveLock(TransactionId xid, Oid dbOid, Oid relOid)
Definition standby.c:988
Definition lock.h:303
Definition lock.h:316
Definition elog.h:298
Definition lock.c:310
uint32 count[FAST_PATH_STRONG_LOCK_HASH_PARTITIONS]
Definition lock.c:312
Definition transam.h:66
Definition hsearch.h:65
Definition hsearch.h:116
Definition dynahash.c:225
Definition lock.h:246
Definition lock.h:240
Definition lock.h:258
Definition locktag.h:65
Definition lock.h:140
Definition lwlock.h:42
Definition lock.h:297
Definition lock.h:284
Definition lock.h:112
Definition proc.h:179
struct PGPROC::@136 vxid
Definition lock.h:194
Definition lock.h:201
Definition resowner.c:113
Definition shmem.h:123
Definition stringinfo.h:47
Definition lock.c:162
Definition lock.h:63
Definition ilist.h:213
Definition ilist.h:152
Definition ilist.h:178
Definition ilist.h:199
Definition lockdefs.h:52
void RegisterTwoPhaseRecord(TwoPhaseRmgrId rmid, uint16 info, const void *data, uint32 len)
Definition twophase.c:1277
TransactionId TwoPhaseGetXidByVirtualXID(VirtualTransactionId vxid, bool *have_more)
Definition twophase.c:862
PGPROC * TwoPhaseGetDummyProc(FullTransactionId fxid, bool lock_held)
Definition twophase.c:929
◆ EligibleForRelationFastPath
Value:
((locktag)->locktag_lockmethodid == DEFAULT_LOCKMETHOD && \
(locktag)->locktag_type == LOCKTAG_RELATION && \
(locktag)->locktag_field1 == MyDatabaseId && \
MyDatabaseId != InvalidOid && \
◆ FAST_PATH_BIT_POSITION
| #define FAST_PATH_BIT_POSITION | ( | n, | |
| l | |||
| ) |
Value:
AssertMacro((n) < FastPathLockSlotsPerBackend()), \
◆ FAST_PATH_BITS
| #define FAST_PATH_BITS | ( | proc, | |
| n | |||
| ) | (proc)->fpLockBits[FAST_PATH_GROUP(n)] |
◆ FAST_PATH_BITS_PER_SLOT
◆ FAST_PATH_CHECK_LOCKMODE
| #define FAST_PATH_CHECK_LOCKMODE | ( | proc, | |
| n, | |||
| l | |||
| ) | (FAST_PATH_BITS(proc, n) & (UINT64CONST(1) << FAST_PATH_BIT_POSITION(n, l))) |
◆ FAST_PATH_CLEAR_LOCKMODE
| #define FAST_PATH_CLEAR_LOCKMODE | ( | proc, | |
| n, | |||
| l | |||
| ) | FAST_PATH_BITS(proc, n) &= ~(UINT64CONST(1) << FAST_PATH_BIT_POSITION(n, l)) |
◆ FAST_PATH_GET_BITS
| #define FAST_PATH_GET_BITS | ( | proc, | |
| n | |||
| ) | ((FAST_PATH_BITS(proc, n) >> (FAST_PATH_BITS_PER_SLOT * FAST_PATH_INDEX(n))) & FAST_PATH_MASK) |
◆ FAST_PATH_GROUP
Value:
((index) / FP_LOCK_SLOTS_PER_GROUP))
◆ FAST_PATH_INDEX
Value:
((index) % FP_LOCK_SLOTS_PER_GROUP))
◆ FAST_PATH_LOCKNUMBER_OFFSET
◆ FAST_PATH_MASK
| #define FAST_PATH_MASK ((1 << FAST_PATH_BITS_PER_SLOT) - 1) |
◆ FAST_PATH_REL_GROUP
| #define FAST_PATH_REL_GROUP | ( | rel | ) | (((uint64) (rel) * 49157) & (FastPathLockGroupsPerBackend - 1)) |
◆ FAST_PATH_SET_LOCKMODE
| #define FAST_PATH_SET_LOCKMODE | ( | proc, | |
| n, | |||
| l | |||
| ) | FAST_PATH_BITS(proc, n) |= UINT64CONST(1) << FAST_PATH_BIT_POSITION(n, l) |
◆ FAST_PATH_SLOT
Value:
((group) * FP_LOCK_SLOTS_PER_GROUP + (index)))
◆ FAST_PATH_STRONG_LOCK_HASH_BITS
◆ FAST_PATH_STRONG_LOCK_HASH_PARTITIONS
| #define FAST_PATH_STRONG_LOCK_HASH_PARTITIONS (1 << FAST_PATH_STRONG_LOCK_HASH_BITS) |
◆ FastPathStrongLockHashPartition
| #define FastPathStrongLockHashPartition | ( | hashcode | ) | ((hashcode) % FAST_PATH_STRONG_LOCK_HASH_PARTITIONS) |
◆ LOCK_PRINT
◆ NLOCKENTS
| #define NLOCKENTS | ( | ) | mul_size(max_locks_per_xact, add_size(MaxBackends, max_prepared_xacts)) |
◆ PROCLOCK_PRINT
Typedef Documentation
◆ TwoPhaseLockRecord
Function Documentation
◆ AbortStrongLockAcquire()
Definition at line 1868 of file lock.c.
1869{
1872
1874 return;
1875
1884}
References Assert, FastPathStrongRelationLockData::count, FastPathStrongLockHashPartition, FastPathStrongRelationLocks, fb(), FastPathStrongRelationLockData::mutex, SpinLockAcquire(), SpinLockRelease(), and StrongLockInProgress.
Referenced by LockAcquireExtended(), and LockErrorCleanup().
◆ AtPrepare_Locks()
Definition at line 3484 of file lock.c.
3485{
3486 HASH_SEQ_STATUS status;
3488
3489 /* First, verify there aren't locks of both xact and session level */
3490 CheckForSessionAndXactLocks();
3491
3492 /* Now do the per-locallock cleanup work */
3494
3496 {
3497 TwoPhaseLockRecord record;
3502
3503 /*
3504 * Ignore VXID locks. We don't want those to be held by prepared
3505 * transactions, since they aren't meaningful after a restart.
3506 */
3508 continue;
3509
3510 /* Ignore it if we don't actually hold the lock */
3512 continue;
3513
3514 /* Scan to see whether we hold it at session or transaction level */
3517 {
3520 else
3522 }
3523
3524 /* Ignore it if we have only session lock */
3526 continue;
3527
3528 /* This can't happen, because we already checked it */
3532 errmsg("cannot PREPARE while holding both session-level and transaction-level locks on the same object")));
3533
3534 /*
3535 * If the local lock was taken via the fast-path, we need to move it
3536 * to the primary lock table, or just get a pointer to the existing
3537 * primary lock table entry if by chance it's already been
3538 * transferred.
3539 */
3541 {
3544 }
3545
3546 /*
3547 * Arrange to not release any strong lock count held by this lock
3548 * entry. We must retain the count until the prepared transaction is
3549 * committed or rolled back.
3550 */
3552
3553 /*
3554 * Create a 2PC record.
3555 */
3558
3561 }
3562}
References CheckForSessionAndXactLocks(), ereport, errcode(), errmsg, ERROR, FastPathGetRelationLockEntry(), fb(), hash_seq_init(), hash_seq_search(), i, LockMethodLocalHash, TwoPhaseLockRecord::lockmode, TwoPhaseLockRecord::locktag, LOCKTAG_VIRTUALTRANSACTION, memcpy(), RegisterTwoPhaseRecord(), and TWOPHASE_RM_LOCK_ID.
Referenced by PrepareTransaction().
◆ BeginStrongLockAcquire()
Definition at line 1832 of file lock.c.
1833{
1836
1837 /*
1838 * Adding to a memory location is not atomic, so we take a spinlock to
1839 * ensure we don't collide with someone else trying to bump the count at
1840 * the same time.
1841 *
1842 * XXX: It might be worth considering using an atomic fetch-and-add
1843 * instruction here, on architectures where that is supported.
1844 */
1845
1851}
References Assert, FastPathStrongRelationLockData::count, FastPathStrongRelationLocks, fb(), FastPathStrongRelationLockData::mutex, SpinLockAcquire(), SpinLockRelease(), and StrongLockInProgress.
Referenced by LockAcquireExtended().
◆ CheckAndSetLockHeld()
Definition at line 1472 of file lock.c.
1473{
1474#ifdef USE_ASSERT_CHECKING
1477#endif
1478}
References fb(), LOCALLOCK_LOCKTAG, and LOCKTAG_RELATION_EXTEND.
Referenced by GrantLockLocal(), and RemoveLocalLock().
◆ CheckForSessionAndXactLocks()
Definition at line 3396 of file lock.c.
3397{
3398 typedef struct
3399 {
3403 } PerLockTagEntry;
3404
3407 HASH_SEQ_STATUS status;
3409
3410 /* Create a local hash table keyed by LOCKTAG only */
3414
3416 256, /* arbitrary initial size */
3417 &hash_ctl,
3419
3420 /* Scan local lock table to find entries for each LOCKTAG */
3422
3424 {
3427 bool found;
3429
3430 /*
3431 * Ignore VXID locks. We don't want those to be held by prepared
3432 * transactions, since they aren't meaningful after a restart.
3433 */
3435 continue;
3436
3437 /* Ignore it if we don't actually hold the lock */
3439 continue;
3440
3441 /* Otherwise, find or make an entry in lockhtab */
3443 &locallock->tag.lock,
3444 HASH_ENTER, &found);
3445 if (!found) /* initialize, if newly created */
3447
3448 /* Scan to see if we hold lock at session or xact level or both */
3450 {
3453 else
3455 }
3456
3457 /*
3458 * We can throw error immediately when we see both types of locks; no
3459 * need to wait around to see if there are more violations.
3460 */
3464 errmsg("cannot PREPARE while holding both session-level and transaction-level locks on the same object")));
3465 }
3466
3467 /* Success, so clean up */
3469}
References CurrentMemoryContext, ereport, errcode(), errmsg, ERROR, fb(), HASH_BLOBS, HASH_CONTEXT, hash_create(), hash_destroy(), HASH_ELEM, HASH_ENTER, hash_search(), hash_seq_init(), hash_seq_search(), i, LockMethodLocalHash, and LOCKTAG_VIRTUALTRANSACTION.
Referenced by AtPrepare_Locks().
◆ CleanUpLock()
|
static |
Definition at line 1746 of file lock.c.
1749{
1750 /*
1751 * If this was my last hold on this lock, delete my entry in the proclock
1752 * table.
1753 */
1755 {
1757
1763 &(proclock->tag),
1764 proclock_hashcode,
1765 HASH_REMOVE,
1766 NULL))
1768 }
1769
1771 {
1772 /*
1773 * The caller just released the last lock, so garbage-collect the lock
1774 * object.
1775 */
1779 &(lock->tag),
1780 hashcode,
1781 HASH_REMOVE,
1782 NULL))
1784 }
1786 {
1787 /* There are waiters on this lock, so wake them up. */
1789 }
1790}
References Assert, dlist_delete(), dlist_is_empty(), elog, fb(), HASH_REMOVE, hash_search_with_hash_value(), PROCLOCK::holdMask, LOCK_PRINT, PROCLOCK::lockLink, LockMethodLockHash, LockMethodProcLockHash, LOCK::nRequested, PANIC, PROCLOCK::procLink, PROCLOCK_PRINT, ProcLockHashCode(), LOCK::procLocks, ProcLockWakeup(), LOCK::tag, and PROCLOCK::tag.
Referenced by LockRefindAndRelease(), LockRelease(), LockReleaseAll(), and RemoveFromWaitQueue().
◆ DoLockModesConflict()
Definition at line 620 of file lock.c.
621{
623
625 return true;
626
627 return false;
628}
References DEFAULT_LOCKMETHOD, fb(), LOCKBIT_ON, and LockMethods.
Referenced by Do_MultiXactIdWait(), DoesMultiXactIdConflict(), initialize_reloptions(), and test_lockmode_for_conflict().
◆ FastPathGetRelationLockEntry()
Definition at line 2966 of file lock.c.
2967{
2974 group;
2975
2976 /* fast-path group the lock belongs to */
2977 group = FAST_PATH_REL_GROUP(relid);
2978
2980
2982 {
2983 uint32 lockmode;
2984
2985 /* index into the whole per-backend array */
2987
2988 /* Look for an allocated slot matching the given relid. */
2990 continue;
2991
2992 /* If we don't have a lock of the given mode, forget it! */
2993 lockmode = locallock->tag.mode;
2995 break;
2996
2997 /* Find or create lock object. */
2999
3001 locallock->hashcode, lockmode);
3002 if (!proclock)
3003 {
3010 }
3013
3015
3016 /* No need to examine remaining slots. */
3017 break;
3018 }
3019
3021
3022 /* Lock may have already been transferred by some other backend. */
3024 {
3025 LOCK *lock;
3028
3030
3032 locktag,
3033 locallock->hashcode,
3034 HASH_FIND,
3035 NULL);
3036 if (!lock)
3038
3039 proclocktag.myLock = lock;
3041
3043 proclock = (PROCLOCK *)
3045 &proclocktag,
3046 proclock_hashcode,
3047 HASH_FIND,
3048 NULL);
3049 if (!proclock)
3052 }
3053
3054 return proclock;
3055}
References DEFAULT_LOCKMETHOD, elog, ereport, errcode(), errhint(), errmsg, ERROR, FAST_PATH_CHECK_LOCKMODE, FAST_PATH_CLEAR_LOCKMODE, FAST_PATH_GET_BITS, FAST_PATH_REL_GROUP, FAST_PATH_SLOT, fb(), FP_LOCK_SLOTS_PER_GROUP, PGPROC::fpInfoLock, PGPROC::fpRelId, GrantLock(), HASH_FIND, hash_search_with_hash_value(), i, LockHashPartitionLock, LockMethodLockHash, LockMethodProcLockHash, LockMethods, LOCKTAG::locktag_field2, LW_EXCLUSIVE, LW_SHARED, LWLockAcquire(), LWLockRelease(), PROCLOCKTAG::myLock, MyProc, ProcLockHashCode(), SetupLockInTable(), and PROCLOCK::tag.
Referenced by AtPrepare_Locks().
◆ FastPathGrantRelationLock()
Definition at line 2790 of file lock.c.
2791{
2794
2795 /* fast-path group the lock belongs to */
2797
2798 /* Scan for existing entry for this relid, remembering empty slot. */
2800 {
2801 /* index into the whole per-backend array */
2803
2805 unused_slot = f;
2807 {
2810 return true;
2811 }
2812 }
2813
2814 /* If no existing entry, use any empty slot. */
2816 {
2819 ++FastPathLocalUseCounts[group];
2820 return true;
2821 }
2822
2823 /* No existing entry, and no empty slot. */
2824 return false;
2825}
References Assert, FAST_PATH_CHECK_LOCKMODE, FAST_PATH_GET_BITS, FAST_PATH_REL_GROUP, FAST_PATH_SET_LOCKMODE, FAST_PATH_SLOT, FastPathLocalUseCounts, FastPathLockSlotsPerBackend, fb(), FP_LOCK_SLOTS_PER_GROUP, PGPROC::fpRelId, i, and MyProc.
Referenced by LockAcquireExtended().
◆ FastPathTransferRelationLocks()
|
static |
Definition at line 2869 of file lock.c.
2871{
2875
2876 /* fast-path group the lock belongs to */
2878
2879 /*
2880 * Every PGPROC that can potentially hold a fast-path lock is present in
2881 * ProcGlobal->allProcs. Prepared transactions are not, but any
2882 * outstanding fast-path locks held by prepared transactions are
2883 * transferred to the main lock table.
2884 */
2886 {
2889
2891
2892 /*
2893 * If the target backend isn't referencing the same database as the
2894 * lock, then we needn't examine the individual relation IDs at all;
2895 * none of them can be relevant.
2896 *
2897 * proc->databaseId is set at backend startup time and never changes
2898 * thereafter, so it might be safe to perform this test before
2899 * acquiring &proc->fpInfoLock. In particular, it's certainly safe to
2900 * assume that if the target backend holds any fast-path locks, it
2901 * must have performed a memory-fencing operation (in particular, an
2902 * LWLock acquisition) since setting proc->databaseId. However, it's
2903 * less clear that our backend is certain to have performed a memory
2904 * fencing operation since the other backend set proc->databaseId. So
2905 * for now, we test it after acquiring the LWLock just to be safe.
2906 *
2907 * Also skip groups without any registered fast-path locks.
2908 */
2910 proc->fpLockBits[group] == 0)
2911 {
2913 continue;
2914 }
2915
2917 {
2918 uint32 lockmode;
2919
2920 /* index into the whole per-backend array */
2922
2923 /* Look for an allocated slot matching the given relid. */
2925 continue;
2926
2927 /* Find or create lock object. */
2931 ++lockmode)
2932 {
2933 PROCLOCK *proclock;
2934
2936 continue;
2938 hashcode, lockmode);
2939 if (!proclock)
2940 {
2943 return false;
2944 }
2946 FAST_PATH_CLEAR_LOCKMODE(proc, f, lockmode);
2947 }
2949
2950 /* No need to examine remaining slots. */
2951 break;
2952 }
2954 }
2955 return true;
2956}
References PROC_HDR::allProcCount, PGPROC::databaseId, FAST_PATH_BITS_PER_SLOT, FAST_PATH_CHECK_LOCKMODE, FAST_PATH_CLEAR_LOCKMODE, FAST_PATH_GET_BITS, FAST_PATH_LOCKNUMBER_OFFSET, FAST_PATH_REL_GROUP, FAST_PATH_SLOT, fb(), FP_LOCK_SLOTS_PER_GROUP, PGPROC::fpInfoLock, PGPROC::fpLockBits, PGPROC::fpRelId, GetPGProcByNumber, GrantLock(), i, j, LockHashPartitionLock, LOCKTAG::locktag_field1, LOCKTAG::locktag_field2, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), PROCLOCKTAG::myLock, ProcGlobal, SetupLockInTable(), and PROCLOCK::tag.
Referenced by LockAcquireExtended().
◆ FastPathUnGrantRelationLock()
Definition at line 2833 of file lock.c.
2834{
2837
2838 /* fast-path group the lock belongs to */
2840
2841 FastPathLocalUseCounts[group] = 0;
2843 {
2844 /* index into the whole per-backend array */
2846
2849 {
2853 /* we continue iterating so as to update FastPathLocalUseCount */
2854 }
2856 ++FastPathLocalUseCounts[group];
2857 }
2859}
References Assert, FAST_PATH_CHECK_LOCKMODE, FAST_PATH_CLEAR_LOCKMODE, FAST_PATH_GET_BITS, FAST_PATH_REL_GROUP, FAST_PATH_SLOT, FastPathLocalUseCounts, FP_LOCK_SLOTS_PER_GROUP, PGPROC::fpRelId, i, MyProc, and result.
Referenced by LockRelease(), and LockReleaseAll().
◆ FinishStrongLockAcquire()
Definition at line 1858 of file lock.c.
References fb(), and StrongLockInProgress.
Referenced by LockAcquireExtended().
◆ GetAwaitedLock()
Definition at line 1906 of file lock.c.
References awaitedLock.
Referenced by LockErrorCleanup(), ProcessRecoveryConflictInterrupt(), and ProcSleep().
◆ GetBlockerStatusData()
| BlockedProcsData * GetBlockerStatusData | ( | int | blocked_pid | ) |
Definition at line 3979 of file lock.c.
3980{
3982 PGPROC *proc;
3984
3986
3987 /*
3988 * Guess how much space we'll need, and preallocate. Most of the time
3989 * this will avoid needing to do repalloc while holding the LWLocks. (We
3990 * assume, but check with an Assert, that MaxBackends is enough entries
3991 * for the procs[] array; the other two could need enlargement, though.)
3992 */
3998
3999 /*
4000 * In order to search the ProcArray for blocked_pid and assume that that
4001 * entry won't immediately disappear under us, we must hold ProcArrayLock.
4002 * In addition, to examine the lock grouping fields of any other backend,
4003 * we must hold all the hash partition locks. (Only one of those locks is
4004 * actually relevant for any one lock group, but we can't know which one
4005 * ahead of time.) It's fairly annoying to hold all those locks
4006 * throughout this, but it's no worse than GetLockStatusData(), and it
4007 * does have the advantage that we're guaranteed to return a
4008 * self-consistent instantaneous state.
4009 */
4011
4013
4014 /* Nothing to do if it's gone */
4016 {
4017 /*
4018 * Acquire lock on the entire shared lock data structure. See notes
4019 * in GetLockStatusData().
4020 */
4023
4025 {
4026 /* Easy case, proc is not a lock group member */
4028 }
4029 else
4030 {
4031 /* Examine all procs in proc's lock group */
4032 dlist_iter iter;
4033
4035 {
4037
4040 }
4041 }
4042
4043 /*
4044 * And release locks. See notes in GetLockStatusData().
4045 */
4048
4050 }
4051
4053
4055}
References Assert, BackendPidGetProcWithLock(), dlist_iter::cur, data, dlist_container, dlist_foreach, fb(), GetSingleProcBlockerStatusData(), i, PGPROC::lockGroupLeader, PGPROC::lockGroupMembers, LockHashPartitionLockByIndex, LW_SHARED, LWLockAcquire(), LWLockRelease(), MaxBackends, NUM_LOCK_PARTITIONS, palloc_array, and palloc_object.
Referenced by pg_blocking_pids().
◆ GetLockConflicts()
| VirtualTransactionId * GetLockConflicts | ( | const LOCKTAG * | locktag, |
| LOCKMODE | lockmode, | ||
| int * | countp | ||
| ) |
Definition at line 3077 of file lock.c.
3078{
3082 LOCK *lock;
3085 PROCLOCK *proclock;
3086 uint32 hashcode;
3088 int count = 0;
3090
3096
3097 /*
3098 * Allocate memory to store results, and fill with InvalidVXID. We only
3099 * need enough space for MaxBackends + max_prepared_xacts + a terminator.
3100 * InHotStandby allocate once in TopMemoryContext.
3101 */
3103 {
3109 }
3110 else
3112
3113 /* Compute hash code and partition lock, and look up conflicting modes. */
3114 hashcode = LockTagHashCode(locktag);
3117
3118 /*
3119 * Fast path locks might not have been entered in the primary lock table.
3120 * If the lock we're dealing with could conflict with such a lock, we must
3121 * examine each backend's fast-path array for conflicts.
3122 */
3124 {
3127 VirtualTransactionId vxid;
3128
3129 /* fast-path group the lock belongs to */
3131
3132 /*
3133 * Iterate over relevant PGPROCs. Anything held by a prepared
3134 * transaction will have been transferred to the primary lock table,
3135 * so we need not worry about those. This is all a bit fuzzy, because
3136 * new locks could be taken after we've visited a particular
3137 * partition, but the callers had better be prepared to deal with that
3138 * anyway, since the locks could equally well be taken between the
3139 * time we return the value and the time the caller does something
3140 * with it.
3141 */
3143 {
3146
3147 /* A backend never blocks itself */
3149 continue;
3150
3152
3153 /*
3154 * If the target backend isn't referencing the same database as
3155 * the lock, then we needn't examine the individual relation IDs
3156 * at all; none of them can be relevant.
3157 *
3158 * See FastPathTransferRelationLocks() for discussion of why we do
3159 * this test after acquiring the lock.
3160 *
3161 * Also skip groups without any registered fast-path locks.
3162 */
3164 proc->fpLockBits[group] == 0)
3165 {
3167 continue;
3168 }
3169
3171 {
3173
3174 /* index into the whole per-backend array */
3176
3177 /* Look for an allocated slot matching the given relid. */
3179 continue;
3182 continue;
3184
3185 /*
3186 * There can only be one entry per relation, so if we found it
3187 * and it doesn't conflict, we can skip the rest of the slots.
3188 */
3190 break;
3191
3192 /* Conflict! */
3193 GET_VXID_FROM_PGPROC(vxid, *proc);
3194
3196 vxids[count++] = vxid;
3197 /* else, xact already committed or aborted */
3198
3199 /* No need to examine remaining slots. */
3200 break;
3201 }
3202
3204 }
3205 }
3206
3207 /* Remember how many fast-path conflicts we found. */
3208 fast_count = count;
3209
3210 /*
3211 * Look up the lock object matching the tag.
3212 */
3214
3216 locktag,
3217 hashcode,
3218 HASH_FIND,
3219 NULL);
3220 if (!lock)
3221 {
3222 /*
3223 * If the lock object doesn't exist, there is nothing holding a lock
3224 * on this lockable object.
3225 */
3230 *countp = count;
3232 }
3233
3234 /*
3235 * Examine each existing holder (or awaiter) of the lock.
3236 */
3238 {
3240
3242 {
3244
3245 /* A backend never blocks itself */
3247 {
3248 VirtualTransactionId vxid;
3249
3250 GET_VXID_FROM_PGPROC(vxid, *proc);
3251
3253 {
3255
3256 /* Avoid duplicate entries. */
3259 break;
3261 vxids[count++] = vxid;
3262 }
3263 /* else, xact already committed or aborted */
3264 }
3265 }
3266 }
3267
3269
3272
3276 *countp = count;
3278}
References PROC_HDR::allProcCount, ConflictsWithRelationFastPath, PGPROC::databaseId, dlist_container, dlist_foreach, elog, ERROR, FAST_PATH_GET_BITS, FAST_PATH_LOCKNUMBER_OFFSET, FAST_PATH_REL_GROUP, FAST_PATH_SLOT, fb(), FP_LOCK_SLOTS_PER_GROUP, PGPROC::fpInfoLock, PGPROC::fpLockBits, PGPROC::fpRelId, GET_VXID_FROM_PGPROC, GetPGProcByNumber, HASH_FIND, hash_search_with_hash_value(), PROCLOCK::holdMask, i, InHotStandby, INVALID_PROC_NUMBER, InvalidLocalTransactionId, j, lengthof, LockHashPartitionLock, LockMethodLockHash, LockMethods, LOCKTAG::locktag_field1, LOCKTAG::locktag_field2, LOCKTAG::locktag_lockmethodid, LockTagHashCode(), LW_SHARED, LWLockAcquire(), LWLockRelease(), max_prepared_xacts, MaxBackends, MemoryContextAlloc(), MyProc, PROCLOCKTAG::myProc, palloc0_array, PANIC, ProcGlobal, LOCK::procLocks, PROCLOCK::tag, TopMemoryContext, VirtualTransactionIdEquals, and VirtualTransactionIdIsValid.
Referenced by ProcSleep(), ResolveRecoveryConflictWithLock(), and WaitForLockersMultiple().
◆ GetLockmodeName()
| const char * GetLockmodeName | ( | LOCKMETHODID | lockmethodid, |
| LOCKMODE | mode | ||
| ) |
Definition at line 4235 of file lock.c.
4236{
4240}
References Assert, fb(), lengthof, LockMethods, LockMethodData::lockModeNames, and mode.
Referenced by DeadLockReport(), LockAcquireExtended(), overexplain_range_table(), pg_lock_status(), ProcSleep(), and waitonlock_error_callback().
◆ GetLocksMethodTable()
| LockMethod GetLocksMethodTable | ( | const LOCK * | lock | ) |
Definition at line 524 of file lock.c.
525{
527
530}
References Assert, fb(), lengthof, LOCK_LOCKMETHOD, and LockMethods.
Referenced by DeadLockCheck(), and FindLockCycleRecurseMember().
◆ GetLockStatusData()
Definition at line 3776 of file lock.c.
3777{
3779 PROCLOCK *proclock;
3784
3786
3787 /* Guess how much space we'll need. */
3789 el = 0;
3791
3792 /*
3793 * First, we iterate through the per-backend fast-path arrays, locking
3794 * them one at a time. This might produce an inconsistent picture of the
3795 * system state, but taking all of those LWLocks at the same time seems
3796 * impractical (in particular, note MAX_SIMUL_LWLOCKS). It shouldn't
3797 * matter too much, because none of these locks can be involved in lock
3798 * conflicts anyway - anything that might must be present in the main lock
3799 * table. (For the same reason, we don't sweat about making leaderPid
3800 * completely valid. We cannot safely dereference another backend's
3801 * lockGroupLeader field without holding all lock partition locks, and
3802 * it's not worth that.)
3803 */
3805 {
3807
3808 /* Skip backends with pid=0, as they don't hold fast-path locks */
3810 continue;
3811
3813
3815 {
3816 /* Skip groups without registered fast-path locks */
3818 continue;
3819
3821 {
3825
3826 /* Skip unallocated slots */
3828 continue;
3829
3831 {
3835 }
3836
3839 proc->fpRelId[f]);
3847
3848 /*
3849 * Successfully taking fast path lock means there were no
3850 * conflicting locks.
3851 */
3852 instance->waitStart = 0;
3853
3854 el++;
3855 }
3856 }
3857
3859 {
3860 VirtualTransactionId vxid;
3862
3864 {
3868 }
3869
3872
3882 instance->waitStart = 0;
3883
3884 el++;
3885 }
3886
3888 }
3889
3890 /*
3891 * Next, acquire lock on the entire shared lock data structure. We do
3892 * this so that, at least for locks in the primary lock table, the state
3893 * will be self-consistent.
3894 *
3895 * Since this is a read-only operation, we take shared instead of
3896 * exclusive lock. There's not a whole lot of point to this, because all
3897 * the normal operations require exclusive lock, but it doesn't hurt
3898 * anything either. It will at least allow two backends to do
3899 * GetLockStatusData in parallel.
3900 *
3901 * Must grab LWLocks in partition-number order to avoid LWLock deadlock.
3902 */
3905
3906 /* Now we can safely count the number of proclocks */
3909 {
3913 }
3914
3915 /* Now scan the tables to copy the data */
3917
3919 {
3923
3928 else
3936
3937 el++;
3938 }
3939
3940 /*
3941 * And release locks. We do this in reverse order for two reasons: (1)
3942 * Anyone else who needs more than one of the locks will be trying to lock
3943 * them in increasing order; we don't want to release the other process
3944 * until it can get all the locks it needs. (2) This avoids O(N^2)
3945 * behavior inside LWLockRelease.
3946 */
3949
3951
3953}
References PROC_HDR::allProcCount, Assert, data, PGPROC::databaseId, ExclusiveLock, FAST_PATH_GET_BITS, FAST_PATH_LOCKNUMBER_OFFSET, FAST_PATH_SLOT, FastPathLockGroupsPerBackend, fb(), FP_LOCK_SLOTS_PER_GROUP, PGPROC::fpInfoLock, PGPROC::fpLocalTransactionId, PGPROC::fpLockBits, PGPROC::fpRelId, PGPROC::fpVXIDLock, GetPGProcByNumber, PROCLOCK::groupLeader, hash_get_num_entries(), hash_seq_init(), hash_seq_search(), PROCLOCK::holdMask, i, j, VirtualTransactionId::localTransactionId, LOCKBIT_ON, LockHashPartitionLockByIndex, LockMethodProcLockHash, LW_SHARED, LWLockAcquire(), LWLockRelease(), PGPROC::lxid, MaxBackends, memcpy(), PROCLOCKTAG::myLock, PROCLOCKTAG::myProc, NoLock, NUM_LOCK_PARTITIONS, palloc_array, palloc_object, pg_atomic_read_u64(), PGPROC::pid, ProcGlobal, VirtualTransactionId::procNumber, PGPROC::procNumber, repalloc(), SET_LOCKTAG_RELATION, SET_LOCKTAG_VIRTUALTRANSACTION, LOCK::tag, PROCLOCK::tag, PGPROC::vxid, PGPROC::waitLock, PGPROC::waitLockMode, and PGPROC::waitStart.
Referenced by pg_lock_status().
◆ GetLockTagsMethodTable()
| LockMethod GetLockTagsMethodTable | ( | const LOCKTAG * | locktag | ) |
Definition at line 536 of file lock.c.
537{
539
542}
References Assert, fb(), lengthof, LockMethods, and LOCKTAG::locktag_lockmethodid.
Referenced by pg_blocking_pids().
◆ GetRunningTransactionLocks()
| xl_standby_lock * GetRunningTransactionLocks | ( | int * | nlocks | ) |
Definition at line 4153 of file lock.c.
4154{
4156 PROCLOCK *proclock;
4161
4162 /*
4163 * Acquire lock on the entire shared lock data structure.
4164 *
4165 * Must grab LWLocks in partition-number order to avoid LWLock deadlock.
4166 */
4169
4170 /* Now we can safely count the number of proclocks */
4172
4173 /*
4174 * Allocating enough space for all locks in the lock table is overkill,
4175 * but it's more convenient and faster than having to enlarge the array.
4176 */
4178
4179 /* Now scan the tables to copy the data */
4181
4182 /*
4183 * If lock is a currently granted AccessExclusiveLock then it will have
4184 * just one proclock holder, so locks are never accessed twice in this
4185 * particular case. Don't copy this code for use elsewhere because in the
4186 * general case this will give you duplicate locks when looking at
4187 * non-exclusive lock types.
4188 */
4189 index = 0;
4191 {
4192 /* make sure this definition matches the one used in LockAcquire */
4195 {
4199
4200 /*
4201 * Don't record locks for transactions if we know they have
4202 * already issued their WAL record for commit but not yet released
4203 * lock. It is still possible that we see locks held by already
4204 * complete transactions, if they haven't yet zeroed their xids.
4205 */
4207 continue;
4208
4212
4213 index++;
4214 }
4215 }
4216
4218
4219 /*
4220 * And release locks. We do this in reverse order for two reasons: (1)
4221 * Anyone else who needs more than one of the locks will be trying to lock
4222 * them in increasing order; we don't want to release the other process
4223 * until it can get all the locks it needs. (2) This avoids O(N^2)
4224 * behavior inside LWLockRelease.
4225 */
4228
4229 *nlocks = index;
4231}
References AccessExclusiveLock, Assert, fb(), hash_get_num_entries(), hash_seq_init(), hash_seq_search(), PROCLOCK::holdMask, i, LOCKBIT_ON, LockHashPartitionLockByIndex, LockMethodProcLockHash, LOCKTAG::locktag_field1, LOCKTAG::locktag_field2, LOCKTAG_RELATION, LOCKTAG::locktag_type, LW_SHARED, LWLockAcquire(), LWLockRelease(), PROCLOCKTAG::myLock, PROCLOCKTAG::myProc, NUM_LOCK_PARTITIONS, palloc(), LOCK::tag, PROCLOCK::tag, TransactionIdIsValid, and PGPROC::xid.
Referenced by LogStandbySnapshot().
◆ GetSingleProcBlockerStatusData()
|
static |
Definition at line 4059 of file lock.c.
4060{
4066 int queue_size;
4067
4068 /* Nothing to do if this proc is not blocked */
4070 return;
4071
4072 /* Set up a procs[] element */
4077
4078 /*
4079 * We may ignore the proc's fast-path arrays, since nothing in those could
4080 * be related to a contended lock.
4081 */
4082
4083 /* Collect all PROCLOCKs associated with theLock */
4085 {
4086 PROCLOCK *proclock =
4091
4093 {
4097 }
4098
4104 else
4111 data->nlocks++;
4112 }
4113
4114 /* Enlarge waiter_pids[] if it's too small to hold all wait queue PIDs */
4117
4119 {
4121 data->npids + queue_size);
4124 }
4125
4126 /* Collect PIDs from the lock's wait queue, stopping at blocked_proc */
4128 {
4130
4132 break;
4134 }
4135
4138}
References data, dclist_count(), dclist_foreach, dlist_container, dlist_foreach, fb(), PROCLOCK::groupLeader, PROCLOCK::holdMask, PGPROC::lxid, Max, MaxBackends, memcpy(), PROCLOCKTAG::myLock, PROCLOCKTAG::myProc, NoLock, PGPROC::pid, PGPROC::procNumber, repalloc(), LOCK::tag, PROCLOCK::tag, PGPROC::vxid, PGPROC::waitLock, and PGPROC::waitLockMode.
Referenced by GetBlockerStatusData().
◆ GrantAwaitedLock()
Definition at line 1897 of file lock.c.
References awaitedLock, awaitedOwner, and GrantLockLocal().
Referenced by LockErrorCleanup().
◆ GrantLock()
Definition at line 1666 of file lock.c.
References Assert, LOCK::granted, LOCK::grantMask, PROCLOCK::holdMask, LOCK_PRINT, LOCKBIT_OFF, LOCKBIT_ON, LOCK::nGranted, LOCK::nRequested, LOCK::requested, and LOCK::waitMask.
Referenced by FastPathGetRelationLockEntry(), FastPathTransferRelationLocks(), JoinWaitQueue(), lock_twophase_recover(), LockAcquireExtended(), ProcLockWakeup(), and VirtualXactLock().
◆ GrantLockLocal()
|
static |
Definition at line 1800 of file lock.c.
1801{
1804
1806 /* Count the total */
1807 locallock->nLocks++;
1808 /* Count the per-owner lock */
1810 {
1812 {
1814 return;
1815 }
1816 }
1819 locallock->numLockOwners++;
1822
1823 /* Indicate that the lock is acquired for certain types of locks. */
1825}
References Assert, CheckAndSetLockHeld(), fb(), i, LOCALLOCKOWNER::nLocks, LOCALLOCKOWNER::owner, and ResourceOwnerRememberLock().
Referenced by GrantAwaitedLock(), and LockAcquireExtended().
◆ InitLockManagerAccess()
Definition at line 502 of file lock.c.
503{
504 /*
505 * Allocate non-shared hash table for LOCALLOCK structs. This stores lock
506 * counts and resource owner information.
507 */
508 HASHCTL info;
509
512
514 16,
515 &info,
517}
References HASHCTL::entrysize, HASH_BLOBS, hash_create(), HASH_ELEM, HASHCTL::keysize, and LockMethodLocalHash.
Referenced by BaseInit().
◆ lock_twophase_postabort()
| void lock_twophase_postabort | ( | FullTransactionId | fxid, |
| uint16 | info, | ||
| void * | recdata, | ||
| uint32 | len | ||
| ) |
Definition at line 4578 of file lock.c.
References fb(), len, and lock_twophase_postcommit().
◆ lock_twophase_postcommit()
| void lock_twophase_postcommit | ( | FullTransactionId | fxid, |
| uint16 | info, | ||
| void * | recdata, | ||
| uint32 | len | ||
| ) |
Definition at line 4552 of file lock.c.
References Assert, elog, ERROR, fb(), len, lengthof, LockMethods, TwoPhaseLockRecord::lockmode, LockRefindAndRelease(), TwoPhaseLockRecord::locktag, LOCKTAG::locktag_lockmethodid, and TwoPhaseGetDummyProc().
Referenced by lock_twophase_postabort().
◆ lock_twophase_recover()
| void lock_twophase_recover | ( | FullTransactionId | fxid, |
| uint16 | info, | ||
| void * | recdata, | ||
| uint32 | len | ||
| ) |
Definition at line 4339 of file lock.c.
4341{
4344 LOCKTAG *locktag;
4345 LOCKMODE lockmode;
4347 LOCK *lock;
4348 PROCLOCK *proclock;
4350 bool found;
4351 uint32 hashcode;
4356
4358 locktag = &rec->locktag;
4359 lockmode = rec->lockmode;
4361
4365
4366 hashcode = LockTagHashCode(locktag);
4369
4371
4372 /*
4373 * Find or create a lock with this tag.
4374 */
4376 locktag,
4377 hashcode,
4378 HASH_ENTER_NULL,
4379 &found);
4380 if (!lock)
4381 {
4387 }
4388
4389 /*
4390 * if it's a new lock object, initialize it
4391 */
4392 if (!found)
4393 {
4394 lock->grantMask = 0;
4395 lock->waitMask = 0;
4398 lock->nRequested = 0;
4399 lock->nGranted = 0;
4403 }
4404 else
4405 {
4410 }
4411
4412 /*
4413 * Create the hash key for the proclock table.
4414 */
4415 proclocktag.myLock = lock;
4416 proclocktag.myProc = proc;
4417
4419
4420 /*
4421 * Find or create a proclock entry with this tag
4422 */
4424 &proclocktag,
4425 proclock_hashcode,
4426 HASH_ENTER_NULL,
4427 &found);
4428 if (!proclock)
4429 {
4430 /* Oops, not enough shmem for the proclock */
4432 {
4433 /*
4434 * There are no other requestors of this lock, so garbage-collect
4435 * the lock object. We *must* do this to avoid a permanent leak
4436 * of shared memory, because there won't be anything to cause
4437 * anyone to release the lock object later.
4438 */
4441 &(lock->tag),
4442 hashcode,
4443 HASH_REMOVE,
4444 NULL))
4446 }
4452 }
4453
4454 /*
4455 * If new, initialize the new entry
4456 */
4457 if (!found)
4458 {
4460 proclock->groupLeader = proc;
4461 proclock->holdMask = 0;
4462 proclock->releaseMask = 0;
4463 /* Add proclock to appropriate lists */
4466 &proclock->procLink);
4468 }
4469 else
4470 {
4473 }
4474
4475 /*
4476 * lock->nRequested and lock->requested[] count the total number of
4477 * requests, whether granted or waiting, so increment those immediately.
4478 */
4479 lock->nRequested++;
4480 lock->requested[lockmode]++;
4482
4483 /*
4484 * We shouldn't already hold the desired lock.
4485 */
4488 lockMethodTable->lockModeNames[lockmode],
4491
4492 /*
4493 * We ignore any possible conflicts and just grant ourselves the lock. Not
4494 * only because we don't bother, but also to avoid deadlocks when
4495 * switching from standby to normal mode. See function comment.
4496 */
4497 GrantLock(lock, proclock, lockmode);
4498
4499 /*
4500 * Bump strong lock count, to make sure any fast-path lock requests won't
4501 * be granted without consulting the primary lock table.
4502 */
4504 {
4506
4510 }
4511
4513}
References Assert, ConflictsWithRelationFastPath, FastPathStrongRelationLockData::count, dclist_init(), dlist_init(), dlist_is_empty(), dlist_push_tail(), elog, ereport, errcode(), errhint(), errmsg, ERROR, FastPathStrongLockHashPartition, FastPathStrongRelationLocks, fb(), LOCK::granted, GrantLock(), LOCK::grantMask, PROCLOCK::groupLeader, HASH_ENTER_NULL, HASH_REMOVE, hash_search_with_hash_value(), PROCLOCK::holdMask, len, lengthof, LOCK_PRINT, LOCKBIT_ON, PGPROC::lockGroupLeader, LockHashPartition, LockHashPartitionLock, PROCLOCK::lockLink, LockMethodLockHash, LockMethodProcLockHash, LockMethods, TwoPhaseLockRecord::lockmode, TwoPhaseLockRecord::locktag, LOCKTAG::locktag_field1, LOCKTAG::locktag_field2, LOCKTAG::locktag_field3, LOCKTAG::locktag_lockmethodid, LockTagHashCode(), LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MAX_LOCKMODES, MemSet, FastPathStrongRelationLockData::mutex, PGPROC::myProcLocks, LOCK::nGranted, LOCK::nRequested, PANIC, PROCLOCK::procLink, PROCLOCK_PRINT, ProcLockHashCode(), LOCK::procLocks, PROCLOCK::releaseMask, LOCK::requested, SpinLockAcquire(), SpinLockRelease(), LOCK::tag, TwoPhaseGetDummyProc(), LOCK::waitMask, and LOCK::waitProcs.
◆ lock_twophase_standby_recover()
| void lock_twophase_standby_recover | ( | FullTransactionId | fxid, |
| uint16 | info, | ||
| void * | recdata, | ||
| uint32 | len | ||
| ) |
Definition at line 4520 of file lock.c.
4522{
4524 LOCKTAG *locktag;
4525 LOCKMODE lockmode;
4527
4529 locktag = &rec->locktag;
4530 lockmode = rec->lockmode;
4532
4535
4538 {
4542 }
4543}
References AccessExclusiveLock, Assert, elog, ERROR, fb(), len, lengthof, LockMethods, TwoPhaseLockRecord::lockmode, TwoPhaseLockRecord::locktag, LOCKTAG::locktag_field1, LOCKTAG::locktag_field2, LOCKTAG::locktag_lockmethodid, LOCKTAG_RELATION, LOCKTAG::locktag_type, StandbyAcquireAccessExclusiveLock(), and XidFromFullTransactionId.
◆ LockAcquire()
| LockAcquireResult LockAcquire | ( | const LOCKTAG * | locktag, |
| LOCKMODE | lockmode, | ||
| bool | sessionLock, | ||
| bool | dontWait | ||
| ) |
Definition at line 806 of file lock.c.
810{
813}
References fb(), and LockAcquireExtended().
Referenced by ConditionalLockPage(), ConditionalLockRelationForExtension(), LockApplyTransactionForSession(), LockDatabaseFrozenIds(), LockDatabaseObject(), LockPage(), LockRelationForExtension(), LockRelationIdForSession(), LockSharedObject(), LockSharedObjectForSession(), LockTuple(), pg_advisory_lock_int4(), pg_advisory_lock_int8(), pg_advisory_lock_shared_int4(), pg_advisory_lock_shared_int8(), pg_advisory_xact_lock_int4(), pg_advisory_xact_lock_int8(), pg_advisory_xact_lock_shared_int4(), pg_advisory_xact_lock_shared_int8(), pg_try_advisory_lock_int4(), pg_try_advisory_lock_int8(), pg_try_advisory_lock_shared_int4(), pg_try_advisory_lock_shared_int8(), pg_try_advisory_xact_lock_int4(), pg_try_advisory_xact_lock_int8(), pg_try_advisory_xact_lock_shared_int4(), pg_try_advisory_xact_lock_shared_int8(), SearchSysCacheLocked1(), SpeculativeInsertionLockAcquire(), SpeculativeInsertionWait(), StandbyAcquireAccessExclusiveLock(), VirtualXactLock(), XactLockForVirtualXact(), XactLockTableInsert(), and XactLockTableWait().
◆ LockAcquireExtended()
| LockAcquireResult LockAcquireExtended | ( | const LOCKTAG * | locktag, |
| LOCKMODE | lockmode, | ||
| bool | sessionLock, | ||
| bool | dontWait, | ||
| bool | reportMemoryError, | ||
| LOCALLOCK ** | locallockp, | ||
| bool | logLockFailure | ||
| ) |
Definition at line 833 of file lock.c.
840{
845 LOCK *lock;
846 PROCLOCK *proclock;
847 bool found;
848 ResourceOwner owner;
849 uint32 hashcode;
854
860
864 lockmode > RowExclusiveLock)
868 lockMethodTable->lockModeNames[lockmode]),
869 errhint("Only RowExclusiveLock or less can be acquired on database objects during recovery.")));
870
871#ifdef LOCK_DEBUG
875 lockMethodTable->lockModeNames[lockmode]);
876#endif
877
878 /* Identify owner for lock */
880 owner = NULL;
881 else
882 owner = CurrentResourceOwner;
883
884 /*
885 * Find or create a LOCALLOCK entry for this lock and lockmode
886 */
888 localtag.lock = *locktag;
889 localtag.mode = lockmode;
890
892 &localtag,
893 HASH_ENTER, &found);
894
895 /*
896 * if it's a new locallock object, initialize it
897 */
898 if (!found)
899 {
903 locallock->nLocks = 0;
906 locallock->numLockOwners = 0;
907 locallock->maxLockOwners = 8;
912 }
913 else
914 {
915 /* Make sure there will be room to remember the lock */
917 {
919
924 }
925 }
926 hashcode = locallock->hashcode;
927
930
931 /*
932 * If we already hold the lock, we can just increase the count locally.
933 *
934 * If lockCleared is already set, caller need not worry about absorbing
935 * sinval messages related to the lock's object.
936 */
938 {
942 else
944 }
945
946 /*
947 * We don't acquire any other heavyweight lock while holding the relation
948 * extension lock. We do allow to acquire the same relation extension
949 * lock more than once but that case won't reach here.
950 */
952
953 /*
954 * Prepare to emit a WAL record if acquisition of this lock needs to be
955 * replayed in a standby server.
956 *
957 * Here we prepare to log; after lock is acquired we'll issue log record.
958 * This arrangement simplifies error recovery in case the preparation step
959 * fails.
960 *
961 * Only AccessExclusiveLocks can conflict with lock types that read-only
962 * transactions can acquire in a standby server. Make sure this definition
963 * matches the one in GetRunningTransactionLocks().
964 */
967 !RecoveryInProgress() &&
968 XLogStandbyInfoActive())
969 {
972 }
973
974 /*
975 * Attempt to take lock via fast path, if eligible. But if we remember
976 * having filled up the fast path array, we don't attempt to make any
977 * further use of it until we release some locks. It's possible that some
978 * other backend has transferred some of those locks to the shared hash
979 * table, leaving space free, but it's not worth acquiring the LWLock just
980 * to check. It's also possible that we're acquiring a second or third
981 * lock type on a relation we have already locked using the fast-path, but
982 * for now we don't worry about that case either.
983 */
985 {
988 {
991
992 /*
993 * LWLockAcquire acts as a memory sequencing point, so it's safe
994 * to assume that any strong locker whose increment to
995 * FastPathStrongRelationLocks->counts becomes visible after we
996 * test it has yet to begin to transfer fast-path locks.
997 */
1001 else
1003 lockmode);
1006 {
1007 /*
1008 * The locallock might contain stale pointers to some old
1009 * shared objects; we MUST reset these to null before
1010 * considering the lock to be acquired via fast-path.
1011 */
1016 }
1017 }
1018 else
1019 {
1020 /*
1021 * Increment the lock statistics counter if lock could not be
1022 * acquired via the fast-path.
1023 */
1025 }
1026 }
1027
1028 /*
1029 * If this lock could potentially have been taken via the fast-path by
1030 * some other backend, we must (temporarily) disable further use of the
1031 * fast-path for this lock tag, and migrate any locks already taken via
1032 * this method to the main lock table.
1033 */
1035 {
1037
1040 hashcode))
1041 {
1042 AbortStrongLockAcquire();
1052 else
1054 }
1055 }
1056
1057 /*
1058 * We didn't find the lock in our LOCALLOCK table, and we didn't manage to
1059 * take it via the fast-path, either, so we've got to mess with the shared
1060 * lock table.
1061 */
1063
1065
1066 /*
1067 * Find or create lock and proclock entries with this tag
1068 *
1069 * Note: if the locallock object already existed, it might have a pointer
1070 * to the lock already ... but we should not assume that that pointer is
1071 * valid, since a lock object with zero hold and request counts can go
1072 * away anytime. So we have to use SetupLockInTable() to recompute the
1073 * lock and proclock pointers, even if they're already set.
1074 */
1076 hashcode, lockmode);
1077 if (!proclock)
1078 {
1079 AbortStrongLockAcquire();
1090 else
1092 }
1093 locallock->proclock = proclock;
1095 locallock->lock = lock;
1096
1097 /*
1098 * If lock requested conflicts with locks requested by waiters, must join
1099 * wait queue. Otherwise, check for conflict with already-held locks.
1100 * (That's last because most complex check.)
1101 */
1104 else
1106 lock, proclock);
1107
1109 {
1110 /* No conflict with held or previously requested locks */
1111 GrantLock(lock, proclock, lockmode);
1113 }
1114 else
1115 {
1116 /*
1117 * Join the lock's wait queue. We call this even in the dontWait
1118 * case, because JoinWaitQueue() may discover that we can acquire the
1119 * lock immediately after all.
1120 */
1122 }
1123
1125 {
1126 /*
1127 * We're not getting the lock because a deadlock was detected already
1128 * while trying to join the wait queue, or because we would have to
1129 * wait but the caller requested no blocking.
1130 *
1131 * Undo the changes to shared entries before releasing the partition
1132 * lock.
1133 */
1134 AbortStrongLockAcquire();
1135
1137 {
1139
1141 hashcode);
1145 &(proclock->tag),
1146 proclock_hashcode,
1147 HASH_REMOVE,
1148 NULL))
1150 }
1151 else
1153 lock->nRequested--;
1154 lock->requested[lockmode]--;
1156 lock, lockmode);
1158 (lock->requested[lockmode] >= 0));
1163
1165 {
1166 /*
1167 * Log lock holders and waiters as a detail log message if
1168 * logLockFailure = true and lock acquisition fails with dontWait
1169 * = true
1170 */
1172 {
1174 lock_waiters_sbuf,
1175 lock_holders_sbuf;
1178
1182
1185 lockmode);
1186
1187 /* Gather a list of all lock holders and waiters */
1192
1196 errdetail_log_plural(
1197 "Process holding the lock: %s, Wait queue: %s.",
1198 "Processes holding the lock: %s, Wait queue: %s.",
1199 lockHoldersNum,
1200 lock_holders_sbuf.data,
1201 lock_waiters_sbuf.data)));
1202
1206 }
1210 }
1211 else
1212 {
1213 DeadLockReport();
1214 /* DeadLockReport() will not return */
1215 }
1216 }
1217
1218 /*
1219 * We are now in the lock queue, or the lock was already granted. If
1220 * queued, go to sleep.
1221 */
1223 {
1228
1230
1231 /*
1232 * NOTE: do not do any material change of state between here and
1233 * return. All required changes in locktable state must have been
1234 * done when the lock was granted to us --- see notes in WaitOnLock.
1235 */
1236
1238 {
1239 /*
1240 * We failed as a result of a deadlock, see CheckDeadLock(). Quit
1241 * now.
1242 */
1244 DeadLockReport();
1245 /* DeadLockReport() will not return */
1246 }
1247 }
1248 else
1251
1252 /* The lock was granted to us. Update the local lock entry accordingly */
1255
1256 /*
1257 * Lock state is fully up-to-date now; if we error out after this, no
1258 * special error cleanup is required.
1259 */
1260 FinishStrongLockAcquire();
1261
1262 /*
1263 * Emit a WAL record if acquisition of this lock needs to be replayed in a
1264 * standby server.
1265 */
1267 {
1268 /*
1269 * Decode the locktag back to the original values, to avoid sending
1270 * lots of empty bytes with every message. See lock.h to check how a
1271 * locktag is defined for LOCKTAG_RELATION
1272 */
1274 locktag->locktag_field2);
1275 }
1276
1278}
References AbortStrongLockAcquire(), AccessExclusiveLock, Assert, BeginStrongLockAcquire(), buf, ConflictsWithRelationFastPath, FastPathStrongRelationLockData::count, CurrentResourceOwner, DeadLockReport(), DescribeLockTag(), dlist_delete(), EligibleForRelationFastPath, elog, ereport, errcode(), errdetail_log_plural(), errhint(), errmsg, ERROR, FAST_PATH_REL_GROUP, FastPathGrantRelationLock(), FastPathLocalUseCounts, FastPathStrongLockHashPartition, FastPathStrongRelationLocks, FastPathTransferRelationLocks(), fb(), FinishStrongLockAcquire(), FP_LOCK_SLOTS_PER_GROUP, PGPROC::fpInfoLock, GetLockHoldersAndWaiters(), GetLockmodeName(), GrantLock(), GrantLockLocal(), HASH_ENTER, HASH_REMOVE, hash_search(), hash_search_with_hash_value(), PROCLOCK::holdMask, initStringInfo(), InRecovery, JoinWaitQueue(), lengthof, LOCK_PRINT, LOCKACQUIRE_ALREADY_CLEAR, LOCKACQUIRE_ALREADY_HELD, LOCKACQUIRE_NOT_AVAIL, LOCKACQUIRE_OK, LOCKBIT_ON, LockCheckConflicts(), LockHashPartitionLock, PROCLOCK::lockLink, LockMethodLocalHash, LockMethodProcLockHash, LockMethods, LOCKTAG::locktag_field1, LOCKTAG::locktag_field2, LOCKTAG::locktag_lockmethodid, LOCKTAG_OBJECT, LOCKTAG_RELATION, LOCKTAG::locktag_type, LockTagHashCode(), LOG, LogAccessExclusiveLock(), LogAccessExclusiveLockPrepare(), LW_EXCLUSIVE, LW_SHARED, LWLockAcquire(), LWLockRelease(), MemoryContextAlloc(), MemSet, PROCLOCKTAG::myLock, MyProc, MyProcPid, LOCK::nGranted, LOCK::nRequested, PANIC, pfree(), pgstat_count_lock_fastpath_exceeded(), PROC_WAIT_STATUS_ERROR, PROC_WAIT_STATUS_OK, PROC_WAIT_STATUS_WAITING, PROCLOCK::procLink, PROCLOCK_PRINT, ProcLockHashCode(), RecoveryInProgress(), RemoveLocalLock(), repalloc(), LOCK::requested, RowExclusiveLock, SetupLockInTable(), PROCLOCK::tag, TopMemoryContext, LOCK::waitMask, WaitOnLock(), and XLogStandbyInfoActive.
Referenced by ConditionalLockDatabaseObject(), ConditionalLockRelation(), ConditionalLockRelationOid(), ConditionalLockSharedObject(), ConditionalLockTuple(), ConditionalXactLockTableWait(), LockAcquire(), LockRelation(), LockRelationId(), and LockRelationOid().
◆ LockCheckConflicts()
| bool LockCheckConflicts | ( | LockMethod | lockMethodTable, |
| LOCKMODE | lockmode, | ||
| LOCK * | lock, | ||
| PROCLOCK * | proclock | ||
| ) |
Definition at line 1537 of file lock.c.
1541{
1549
1550 /*
1551 * first check for global conflicts: If no locks conflict with my request,
1552 * then I get the lock.
1553 *
1554 * Checking for conflict: lock->grantMask represents the types of
1555 * currently held locks. conflictTable[lockmode] has a bit set for each
1556 * type of lock that conflicts with request. Bitwise compare tells if
1557 * there is a conflict.
1558 */
1560 {
1562 return false;
1563 }
1564
1565 /*
1566 * Rats. Something conflicts. But it could still be my own lock, or a
1567 * lock held by another member of my locking group. First, figure out how
1568 * many conflicts remain after subtracting out any locks I hold myself.
1569 */
1572 {
1574 {
1576 continue;
1577 }
1582 }
1583
1584 /* If no conflicts remain, we get the lock. */
1586 {
1588 return false;
1589 }
1590
1591 /* If no group locking, it's definitely a conflict. */
1593 {
1596 proclock);
1597 return true;
1598 }
1599
1600 /*
1601 * The relation extension lock conflict even between the group members.
1602 */
1604 {
1606 proclock);
1607 return true;
1608 }
1609
1610 /*
1611 * Locks held in conflicting modes by members of our own lock group are
1612 * not real conflicts; we can subtract those out and see if we still have
1613 * a conflict. This is O(N) in the number of processes holding or
1614 * awaiting locks on this object. We could improve that by making the
1615 * shared memory state more complex (and larger) but it doesn't seem worth
1616 * it.
1617 */
1619 {
1622
1626 {
1628
1630 {
1632 {
1636 totalConflictsRemaining--;
1637 }
1638 }
1639
1641 {
1643 proclock);
1644 return false;
1645 }
1646 }
1647 }
1648
1649 /* Nope, it's a real conflict. */
1651 return true;
1652}
References Assert, dlist_container, dlist_foreach, elog, fb(), LOCK::granted, LOCK::grantMask, PROCLOCK::groupLeader, PROCLOCK::holdMask, i, LOCK_LOCKTAG, LOCKBIT_ON, PGPROC::lockGroupLeader, LOCKTAG_RELATION_EXTEND, MAX_LOCKMODES, MyProc, PROCLOCKTAG::myProc, PANIC, PROCLOCK_PRINT, LOCK::procLocks, and PROCLOCK::tag.
Referenced by JoinWaitQueue(), LockAcquireExtended(), and ProcLockWakeup().
◆ LockHasWaiters()
Definition at line 693 of file lock.c.
694{
699 LOCK *lock;
700 PROCLOCK *proclock;
703
709
710#ifdef LOCK_DEBUG
714 lockMethodTable->lockModeNames[lockmode]);
715#endif
716
717 /*
718 * Find the LOCALLOCK entry for this lock and lockmode
719 */
721 localtag.lock = *locktag;
722 localtag.mode = lockmode;
723
725 &localtag,
727
728 /*
729 * let the caller print its own error message, too. Do not ereport(ERROR).
730 */
732 {
734 lockMethodTable->lockModeNames[lockmode]);
735 return false;
736 }
737
738 /*
739 * Check the shared lock table.
740 */
742
744
745 /*
746 * We don't need to re-find the lock or proclock, since we kept their
747 * addresses in the locallock table, and they couldn't have been removed
748 * while we were holding a lock on them.
749 */
750 lock = locallock->lock;
752 proclock = locallock->proclock;
754
755 /*
756 * Double-check that we are actually holding a lock of the type we want to
757 * release.
758 */
760 {
764 lockMethodTable->lockModeNames[lockmode]);
766 return false;
767 }
768
769 /*
770 * Do the checking.
771 */
774
776
778}
References elog, ERROR, fb(), HASH_FIND, hash_search(), PROCLOCK::holdMask, lengthof, LOCK_PRINT, LOCKBIT_ON, LockHashPartitionLock, LockMethodLocalHash, LockMethods, LOCKTAG::locktag_field1, LOCKTAG::locktag_field2, LOCKTAG::locktag_lockmethodid, LOG, LW_SHARED, LWLockAcquire(), LWLockRelease(), MemSet, PROCLOCK_PRINT, RemoveLocalLock(), LOCK::waitMask, and WARNING.
Referenced by LockHasWaitersRelation().
◆ LockHeldByMe()
Definition at line 640 of file lock.c.
642{
645
646 /*
647 * See if there is a LOCALLOCK entry for this lock and lockmode
648 */
650 localtag.lock = *locktag;
651 localtag.mode = lockmode;
652
654 &localtag,
656
658 return true;
659
661 {
663
666 slockmode++)
667 {
669 return true;
670 }
671 }
672
673 return false;
674}
References fb(), HASH_FIND, hash_search(), LockHeldByMe(), LockMethodLocalHash, MaxLockMode, and MemSet.
Referenced by CheckRelationLockedByMe(), CheckRelationOidLockedByMe(), LockHeldByMe(), and UpdateSubscriptionRelState().
◆ LockManagerShmemInit()
Definition at line 493 of file lock.c.
References FastPathStrongRelationLocks, FastPathStrongRelationLockData::mutex, and SpinLockInit().
◆ LockManagerShmemRequest()
Definition at line 451 of file lock.c.
452{
454
455 /*
456 * Compute sizes for lock hashtables.
457 */
459
460 /*
461 * Hash table for LOCK structs. This stores per-locked-object
462 * information.
463 */
465 .nelems = max_table_size,
466 .ptr = &LockMethodLockHash,
469 .hash_info.num_partitions = NUM_LOCK_PARTITIONS,
471 );
472
473 /* Assume an average of 2 holders per lock */
474 max_table_size *= 2;
475
477 .nelems = max_table_size,
478 .ptr = &LockMethodProcLockHash,
481 .hash_info.hash = proclock_hash,
482 .hash_info.num_partitions = NUM_LOCK_PARTITIONS,
484 );
485
489 );
490}
References FastPathStrongRelationLocks, fb(), HASH_BLOBS, HASH_ELEM, HASH_FUNCTION, HASH_PARTITION, HTAB::keysize, LockMethodLockHash, LockMethodProcLockHash, name, NLOCKENTS, NUM_LOCK_PARTITIONS, proclock_hash(), ShmemRequestHash, and ShmemRequestStruct.
◆ LockReassignCurrentOwner()
Definition at line 2714 of file lock.c.
2715{
2717
2719
2721 {
2722 HASH_SEQ_STATUS status;
2724
2726
2729 }
2730 else
2731 {
2733
2736 }
2737}
References Assert, CurrentResourceOwner, fb(), hash_seq_init(), hash_seq_search(), i, LockMethodLocalHash, LockReassignOwner(), and ResourceOwnerGetParent().
Referenced by ResourceOwnerReleaseInternal().
◆ LockReassignOwner()
|
static |
Definition at line 2744 of file lock.c.
2745{
2746 LOCALLOCKOWNER *lockOwners;
2750
2751 /*
2752 * Scan to see if there are any locks belonging to current owner or its
2753 * parent
2754 */
2755 lockOwners = locallock->lockOwners;
2757 {
2762 }
2763
2765 return; /* no current locks */
2766
2768 {
2769 /* Parent has no slot, so just give it the child's slot */
2772 }
2773 else
2774 {
2775 /* Merge child's count with parent's */
2777 /* compact out unused slot */
2778 locallock->numLockOwners--;
2781 }
2783}
References CurrentResourceOwner, fb(), i, LOCALLOCKOWNER::nLocks, LOCALLOCKOWNER::owner, ResourceOwnerForgetLock(), and ResourceOwnerRememberLock().
Referenced by LockReassignCurrentOwner().
◆ LockRefindAndRelease()
|
static |
Definition at line 3292 of file lock.c.
3295{
3296 LOCK *lock;
3297 PROCLOCK *proclock;
3299 uint32 hashcode;
3303
3304 hashcode = LockTagHashCode(locktag);
3306
3308
3309 /*
3310 * Re-find the lock object (it had better be there).
3311 */
3313 locktag,
3314 hashcode,
3315 HASH_FIND,
3316 NULL);
3317 if (!lock)
3319
3320 /*
3321 * Re-find the proclock object (ditto).
3322 */
3323 proclocktag.myLock = lock;
3324 proclocktag.myProc = proc;
3325
3327
3329 &proclocktag,
3330 proclock_hashcode,
3331 HASH_FIND,
3332 NULL);
3333 if (!proclock)
3335
3336 /*
3337 * Double-check that we are actually holding a lock of the type we want to
3338 * release.
3339 */
3341 {
3345 lockMethodTable->lockModeNames[lockmode]);
3346 return;
3347 }
3348
3349 /*
3350 * Do the releasing. CleanUpLock will waken any now-wakable waiters.
3351 */
3353
3354 CleanUpLock(lock, proclock,
3355 lockMethodTable, hashcode,
3356 wakeupNeeded);
3357
3359
3360 /*
3361 * Decrement strong lock count. This logic is needed only for 2PC.
3362 */
3364 && ConflictsWithRelationFastPath(locktag, lockmode))
3365 {
3367
3372 }
3373}
References Assert, CleanUpLock(), ConflictsWithRelationFastPath, FastPathStrongRelationLockData::count, elog, FastPathStrongLockHashPartition, FastPathStrongRelationLocks, fb(), HASH_FIND, hash_search_with_hash_value(), PROCLOCK::holdMask, LOCKBIT_ON, LockHashPartitionLock, LockMethodLockHash, LockMethodProcLockHash, LockTagHashCode(), LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), FastPathStrongRelationLockData::mutex, PANIC, PROCLOCK_PRINT, ProcLockHashCode(), SpinLockAcquire(), SpinLockRelease(), UnGrantLock(), and WARNING.
Referenced by lock_twophase_postcommit(), LockReleaseAll(), and VirtualXactLockTableCleanup().
◆ LockRelease()
Definition at line 2110 of file lock.c.
2111{
2116 LOCK *lock;
2117 PROCLOCK *proclock;
2120
2126
2127#ifdef LOCK_DEBUG
2131 lockMethodTable->lockModeNames[lockmode]);
2132#endif
2133
2134 /*
2135 * Find the LOCALLOCK entry for this lock and lockmode
2136 */
2138 localtag.lock = *locktag;
2139 localtag.mode = lockmode;
2140
2142 &localtag,
2144
2145 /*
2146 * let the caller print its own error message, too. Do not ereport(ERROR).
2147 */
2149 {
2151 lockMethodTable->lockModeNames[lockmode]);
2152 return false;
2153 }
2154
2155 /*
2156 * Decrease the count for the resource owner.
2157 */
2158 {
2160 ResourceOwner owner;
2162
2163 /* Identify owner for lock */
2165 owner = NULL;
2166 else
2167 owner = CurrentResourceOwner;
2168
2170 {
2172 {
2175 {
2178 /* compact out unused slot */
2179 locallock->numLockOwners--;
2182 }
2183 break;
2184 }
2185 }
2187 {
2188 /* don't release a lock belonging to another owner */
2190 lockMethodTable->lockModeNames[lockmode]);
2191 return false;
2192 }
2193 }
2194
2195 /*
2196 * Decrease the total local count. If we're still holding the lock, we're
2197 * done.
2198 */
2199 locallock->nLocks--;
2200
2202 return true;
2203
2204 /*
2205 * At this point we can no longer suppose we are clear of invalidation
2206 * messages related to this lock. Although we'll delete the LOCALLOCK
2207 * object before any intentional return from this routine, it seems worth
2208 * the trouble to explicitly reset lockCleared right now, just in case
2209 * some error prevents us from deleting the LOCALLOCK.
2210 */
2212
2213 /* Attempt fast release of any lock eligible for the fast path. */
2216 {
2218
2219 /*
2220 * We might not find the lock here, even if we originally entered it
2221 * here. Another backend may have moved it to the main table.
2222 */
2225 lockmode);
2228 {
2230 return true;
2231 }
2232 }
2233
2234 /*
2235 * Otherwise we've got to mess with the shared lock table.
2236 */
2238
2240
2241 /*
2242 * Normally, we don't need to re-find the lock or proclock, since we kept
2243 * their addresses in the locallock table, and they couldn't have been
2244 * removed while we were holding a lock on them. But it's possible that
2245 * the lock was taken fast-path and has since been moved to the main hash
2246 * table by another backend, in which case we will need to look up the
2247 * objects here. We assume the lock field is NULL if so.
2248 */
2249 lock = locallock->lock;
2250 if (!lock)
2251 {
2253
2256 locktag,
2257 locallock->hashcode,
2258 HASH_FIND,
2259 NULL);
2260 if (!lock)
2262 locallock->lock = lock;
2263
2264 proclocktag.myLock = lock;
2267 &proclocktag,
2268 HASH_FIND,
2269 NULL);
2272 }
2274 proclock = locallock->proclock;
2276
2277 /*
2278 * Double-check that we are actually holding a lock of the type we want to
2279 * release.
2280 */
2282 {
2286 lockMethodTable->lockModeNames[lockmode]);
2288 return false;
2289 }
2290
2291 /*
2292 * Do the releasing. CleanUpLock will waken any now-wakable waiters.
2293 */
2295
2296 CleanUpLock(lock, proclock,
2298 wakeupNeeded);
2299
2301
2303 return true;
2304}
References Assert, CleanUpLock(), CurrentResourceOwner, EligibleForRelationFastPath, elog, ERROR, FAST_PATH_REL_GROUP, FastPathLocalUseCounts, FastPathUnGrantRelationLock(), fb(), PGPROC::fpInfoLock, HASH_FIND, hash_search(), hash_search_with_hash_value(), PROCLOCK::holdMask, i, lengthof, LOCK_PRINT, LOCKBIT_ON, LockHashPartitionLock, LockMethodLocalHash, LockMethodLockHash, LockMethodProcLockHash, LockMethods, LOCKTAG::locktag_field1, LOCKTAG::locktag_field2, LOCKTAG::locktag_lockmethodid, LOG, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MemSet, MyProc, PROCLOCK_PRINT, RemoveLocalLock(), ResourceOwnerForgetLock(), UnGrantLock(), and WARNING.
Referenced by ConditionalXactLockTableWait(), pg_advisory_unlock_int4(), pg_advisory_unlock_int8(), pg_advisory_unlock_shared_int4(), pg_advisory_unlock_shared_int8(), ReleaseLockIfHeld(), SearchSysCacheLocked1(), SpeculativeInsertionLockRelease(), SpeculativeInsertionWait(), StandbyReleaseXidEntryLocks(), UnlockApplyTransactionForSession(), UnlockDatabaseObject(), UnlockPage(), UnlockRelation(), UnlockRelationForExtension(), UnlockRelationId(), UnlockRelationIdForSession(), UnlockRelationOid(), UnlockSharedObject(), UnlockSharedObjectForSession(), UnlockTuple(), VirtualXactLock(), XactLockForVirtualXact(), XactLockTableDelete(), and XactLockTableWait().
◆ LockReleaseAll()
| void LockReleaseAll | ( | LOCKMETHODID | lockmethodid, |
| bool | allLocks | ||
| ) |
Definition at line 2315 of file lock.c.
2316{
2317 HASH_SEQ_STATUS status;
2320 numLockModes;
2322 LOCK *lock;
2325
2329
2330#ifdef LOCK_DEBUG
2333#endif
2334
2335 /*
2336 * Get rid of our fast-path VXID lock, if appropriate. Note that this is
2337 * the only way that the lock we hold on our own VXID can ever get
2338 * released: it is always and only released when a toplevel transaction
2339 * ends.
2340 */
2342 VirtualXactLockTableCleanup();
2343
2344 numLockModes = lockMethodTable->numLockModes;
2345
2346 /*
2347 * First we run through the locallock table and get rid of unwanted
2348 * entries, then we scan the process's proclocks and get rid of those. We
2349 * do this separately because we may have multiple locallock entries
2350 * pointing to the same proclock, and we daren't end up with any dangling
2351 * pointers. Fast-path locks are cleaned up during the locallock table
2352 * scan, though.
2353 */
2355
2357 {
2358 /*
2359 * If the LOCALLOCK entry is unused, something must've gone wrong
2360 * while trying to acquire this lock. Just forget the local entry.
2361 */
2363 {
2365 continue;
2366 }
2367
2368 /* Ignore items that are not of the lockmethod to be removed */
2370 continue;
2371
2372 /*
2373 * If we are asked to release all locks, we can just zap the entry.
2374 * Otherwise, must scan to see if there are session locks. We assume
2375 * there is at most one lockOwners entry for session locks.
2376 */
2378 {
2380
2381 /* If session lock is above array position 0, move it down to 0 */
2383 {
2385 lockOwners[0] = lockOwners[i];
2386 else
2388 }
2389
2391 lockOwners[0].owner == NULL &&
2392 lockOwners[0].nLocks > 0)
2393 {
2394 /* Fix the locallock to show just the session locks */
2396 locallock->numLockOwners = 1;
2397 /* We aren't deleting this locallock, so done */
2398 continue;
2399 }
2400 else
2401 locallock->numLockOwners = 0;
2402 }
2403
2404#ifdef USE_ASSERT_CHECKING
2405
2406 /*
2407 * Tuple locks are currently held only for short durations within a
2408 * transaction. Check that we didn't forget to release one.
2409 */
2412#endif
2413
2414 /*
2415 * If the lock or proclock pointers are NULL, this lock was taken via
2416 * the relation fast-path (and is not known to have been transferred).
2417 */
2419 {
2421 Oid relid;
2422
2423 /* Verify that a fast-path lock is what we've got. */
2426
2427 /*
2428 * If we don't currently hold the LWLock that protects our
2429 * fast-path data structures, we must acquire it before attempting
2430 * to release the lock via the fast-path. We will continue to
2431 * hold the LWLock until we're done scanning the locallock table,
2432 * unless we hit a transferred fast-path lock. (XXX is this
2433 * really such a good idea? There could be a lot of entries ...)
2434 */
2436 {
2439 }
2440
2441 /* Attempt fast-path release. */
2442 relid = locallock->tag.lock.locktag_field2;
2444 {
2446 continue;
2447 }
2448
2449 /*
2450 * Our lock, originally taken via the fast path, has been
2451 * transferred to the main lock table. That's going to require
2452 * some extra work, so release our fast-path lock before starting.
2453 */
2456
2457 /*
2458 * Now dump the lock. We haven't got a pointer to the LOCK or
2459 * PROCLOCK in this case, so we have to handle this a bit
2460 * differently than a normal lock release. Unfortunately, this
2461 * requires an extra LWLock acquire-and-release cycle on the
2462 * partitionLock, but hopefully it shouldn't happen often.
2463 */
2467 continue;
2468 }
2469
2470 /* Mark the proclock to show we need to release this lockmode */
2473
2474 /* And remove the locallock hashtable entry */
2476 }
2477
2478 /* Done with the fast-path data structures */
2481
2482 /*
2483 * Now, scan each lock partition separately.
2484 */
2486 {
2490
2492
2493 /*
2494 * If the proclock list for this partition is empty, we can skip
2495 * acquiring the partition lock. This optimization is trickier than
2496 * it looks, because another backend could be in process of adding
2497 * something to our proclock list due to promoting one of our
2498 * fast-path locks. However, any such lock must be one that we
2499 * decided not to delete above, so it's okay to skip it again now;
2500 * we'd just decide not to delete it again. We must, however, be
2501 * careful to re-fetch the list header once we've acquired the
2502 * partition lock, to be sure we have a valid, up-to-date pointer.
2503 * (There is probably no significant risk if pointer fetch/store is
2504 * atomic, but we don't wish to assume that.)
2505 *
2506 * XXX This argument assumes that the locallock table correctly
2507 * represents all of our fast-path locks. While allLocks mode
2508 * guarantees to clean up all of our normal locks regardless of the
2509 * locallock situation, we lose that guarantee for fast-path locks.
2510 * This is not ideal.
2511 */
2513 continue; /* needn't examine this partition */
2514
2516
2518 {
2521
2523
2525
2526 /* Ignore items that are not of the lockmethod to be removed */
2528 continue;
2529
2530 /*
2531 * In allLocks mode, force release of all locks even if locallock
2532 * table had problems
2533 */
2536 else
2538
2539 /*
2540 * Ignore items that have nothing to be released, unless they have
2541 * holdMask == 0 and are therefore recyclable
2542 */
2544 continue;
2545
2552
2553 /*
2554 * Release the previously-marked lock modes
2555 */
2557 {
2560 lockMethodTable);
2561 }
2565
2566 proclock->releaseMask = 0;
2567
2568 /* CleanUpLock will wake up waiters if needed. */
2569 CleanUpLock(lock, proclock,
2570 lockMethodTable,
2572 wakeupNeeded);
2573 } /* loop over PROCLOCKs within this partition */
2574
2576 } /* loop over partitions */
2577
2578#ifdef LOCK_DEBUG
2581#endif
2582}
References Assert, CleanUpLock(), DEFAULT_LOCKMETHOD, dlist_container, dlist_foreach_modify, dlist_is_empty(), EligibleForRelationFastPath, elog, ERROR, FastPathUnGrantRelationLock(), fb(), PGPROC::fpInfoLock, LOCK::grantMask, hash_seq_init(), hash_seq_search(), PROCLOCK::holdMask, i, lengthof, LOCALLOCK_LOCKMETHOD, LOCALLOCK_LOCKTAG, LOCK_LOCKMETHOD, LOCK_PRINT, LOCKBIT_ON, LockHashPartitionLockByIndex, LockMethodLocalHash, LockMethods, LockRefindAndRelease(), LOCKTAG_TUPLE, LockTagHashCode(), LOG, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), PROCLOCKTAG::myLock, MyProc, PROCLOCKTAG::myProc, PGPROC::myProcLocks, LOCK::nGranted, LOCALLOCKOWNER::nLocks, LOCK::nRequested, NUM_LOCK_PARTITIONS, LOCALLOCKOWNER::owner, PANIC, PROCLOCK_PRINT, PROCLOCK::releaseMask, RemoveLocalLock(), ResourceOwnerForgetLock(), LOCK::tag, PROCLOCK::tag, UnGrantLock(), VirtualXactLockTableCleanup(), and WARNING.
Referenced by DiscardAll(), logicalrep_worker_onexit(), ProcReleaseLocks(), and ShutdownPostgres().
◆ LockReleaseCurrentOwner()
Definition at line 2619 of file lock.c.
References fb(), hash_seq_init(), hash_seq_search(), i, LockMethodLocalHash, and ReleaseLockIfHeld().
Referenced by ResourceOwnerReleaseInternal().
◆ LockReleaseSession()
| void LockReleaseSession | ( | LOCKMETHODID | lockmethodid | ) |
Definition at line 2589 of file lock.c.
2590{
2591 HASH_SEQ_STATUS status;
2593
2596
2598
2600 {
2601 /* Ignore items that are not of the specified lock method */
2603 continue;
2604
2606 }
2607}
References elog, ERROR, fb(), hash_seq_init(), hash_seq_search(), lengthof, LOCALLOCK_LOCKMETHOD, LockMethodLocalHash, LockMethods, and ReleaseLockIfHeld().
Referenced by pg_advisory_unlock_all().
◆ LockTagHashCode()
Definition at line 554 of file lock.c.
References get_hash_value(), and LockMethodLockHash.
Referenced by CheckDeadLock(), GetLockConflicts(), lock_twophase_recover(), LockAcquireExtended(), LockRefindAndRelease(), LockReleaseAll(), LockWaiterCount(), proclock_hash(), and VirtualXactLock().
◆ LockWaiterCount()
Definition at line 4836 of file lock.c.
4837{
4839 LOCK *lock;
4840 bool found;
4841 uint32 hashcode;
4843 int waiters = 0;
4844
4847
4848 hashcode = LockTagHashCode(locktag);
4851
4853 locktag,
4854 hashcode,
4855 HASH_FIND,
4856 &found);
4857 if (found)
4858 {
4860 waiters = lock->nRequested;
4861 }
4863
4864 return waiters;
4865}
References Assert, elog, ERROR, fb(), HASH_FIND, hash_search_with_hash_value(), lengthof, LockHashPartitionLock, LockMethodLockHash, LockMethods, LOCKTAG::locktag_lockmethodid, LockTagHashCode(), LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), and LOCK::nRequested.
Referenced by RelationExtensionLockWaiterCount().
◆ MarkLockClear()
Definition at line 1928 of file lock.c.
Referenced by ConditionalLockDatabaseObject(), ConditionalLockRelation(), ConditionalLockRelationOid(), ConditionalLockSharedObject(), LockRelation(), LockRelationId(), and LockRelationOid().
◆ PostPrepare_Locks()
| void PostPrepare_Locks | ( | FullTransactionId | fxid | ) |
Definition at line 3580 of file lock.c.
3581{
3583 HASH_SEQ_STATUS status;
3585 LOCK *lock;
3586 PROCLOCK *proclock;
3589
3590 /* Can't prepare a lock group follower. */
3593
3594 /* This is a critical section: any error means big trouble */
3595 START_CRIT_SECTION();
3596
3597 /*
3598 * First we run through the locallock table and get rid of unwanted
3599 * entries, then we scan the process's proclocks and transfer them to the
3600 * target proc.
3601 *
3602 * We do this separately because we may have multiple locallock entries
3603 * pointing to the same proclock, and we daren't end up with any dangling
3604 * pointers.
3605 */
3607
3609 {
3614
3616 {
3617 /*
3618 * We must've run out of shared memory while trying to set up this
3619 * lock. Just forget the local entry.
3620 */
3623 continue;
3624 }
3625
3626 /* Ignore VXID locks */
3628 continue;
3629
3630 /* Scan to see whether we hold it at session or transaction level */
3633 {
3636 else
3638 }
3639
3640 /* Ignore it if we have only session lock */
3642 continue;
3643
3644 /* This can't happen, because we already checked it */
3648 errmsg("cannot PREPARE while holding both session-level and transaction-level locks on the same object")));
3649
3650 /* Mark the proclock to show we need to release this lockmode */
3653
3654 /* And remove the locallock hashtable entry */
3656 }
3657
3658 /*
3659 * Now, scan each lock partition separately.
3660 */
3662 {
3666
3668
3669 /*
3670 * If the proclock list for this partition is empty, we can skip
3671 * acquiring the partition lock. This optimization is safer than the
3672 * situation in LockReleaseAll, because we got rid of any fast-path
3673 * locks during AtPrepare_Locks, so there cannot be any case where
3674 * another backend is adding something to our lists now. For safety,
3675 * though, we code this the same way as in LockReleaseAll.
3676 */
3678 continue; /* needn't examine this partition */
3679
3681
3683 {
3685
3687
3689
3690 /* Ignore VXID locks */
3692 continue;
3693
3700
3701 /* Ignore it if nothing to release (must be a session lock) */
3703 continue;
3704
3705 /* Else we should be releasing all locks */
3708
3709 /*
3710 * We cannot simply modify proclock->tag.myProc to reassign
3711 * ownership of the lock, because that's part of the hash key and
3712 * the proclock would then be in the wrong hash chain. Instead
3713 * use hash_update_hash_key. (We used to create a new hash entry,
3714 * but that risks out-of-memory failure if other processes are
3715 * busy making proclocks too.) We must unlink the proclock from
3716 * our procLink chain and put it into the new proc's chain, too.
3717 *
3718 * Note: the updated proclock hash key will still belong to the
3719 * same hash partition, cf proclock_hash(). So the partition lock
3720 * we already hold is sufficient for this.
3721 */
3723
3724 /*
3725 * Create the new hash key for the proclock.
3726 */
3727 proclocktag.myLock = lock;
3729
3730 /*
3731 * Update groupLeader pointer to point to the new proc. (We'd
3732 * better not be a member of somebody else's lock group!)
3733 */
3736
3737 /*
3738 * Update the proclock. We should not find any existing entry for
3739 * the same hash key, since there can be only one entry for any
3740 * given lock with my own proc.
3741 */
3743 proclock,
3744 &proclocktag))
3746
3747 /* Re-link into the new proc's proclock list */
3749
3751 } /* loop over PROCLOCKs within this partition */
3752
3754 } /* loop over partitions */
3755
3756 END_CRIT_SECTION();
3757}
References Assert, dlist_container, dlist_delete(), dlist_foreach_modify, dlist_is_empty(), dlist_push_tail(), elog, END_CRIT_SECTION, ereport, errcode(), errmsg, fb(), LOCK::grantMask, PROCLOCK::groupLeader, hash_seq_init(), hash_seq_search(), hash_update_hash_key(), PROCLOCK::holdMask, i, LOCK_PRINT, LOCKBIT_ON, PGPROC::lockGroupLeader, LockHashPartitionLockByIndex, LockMethodLocalHash, LockMethodProcLockHash, LOCKTAG::locktag_type, LOCKTAG_VIRTUALTRANSACTION, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), PROCLOCKTAG::myLock, MyProc, PROCLOCKTAG::myProc, PGPROC::myProcLocks, LOCK::nGranted, LOCK::nRequested, NUM_LOCK_PARTITIONS, PANIC, PROCLOCK::procLink, PROCLOCK_PRINT, PROCLOCK::releaseMask, RemoveLocalLock(), START_CRIT_SECTION, LOCK::tag, PROCLOCK::tag, and TwoPhaseGetDummyProc().
Referenced by PrepareTransaction().
◆ proclock_hash()
Definition at line 571 of file lock.c.
572{
576
578
579 /* Look into the associated LOCK object, and compute its hash code */
581
582 /*
583 * To make the hash code also depend on the PGPROC, we xor the proc
584 * struct's address into the hash code, left-shifted so that the
585 * partition-number bits don't change. Since this is only a hash, we
586 * don't care if we lose high-order bits of the address; use an
587 * intermediate variable to suppress cast-pointer-to-int warnings.
588 */
591
593}
References Assert, DatumGetUInt32(), fb(), LockTagHashCode(), LOG2_NUM_LOCK_PARTITIONS, and PointerGetDatum.
Referenced by LockManagerShmemRequest().
◆ ProcLockHashCode()
|
inlinestatic |
Definition at line 602 of file lock.c.
603{
606
607 /*
608 * This must match proclock_hash()!
609 */
612
614}
References DatumGetUInt32(), fb(), LOG2_NUM_LOCK_PARTITIONS, and PointerGetDatum.
Referenced by CleanUpLock(), FastPathGetRelationLockEntry(), lock_twophase_recover(), LockAcquireExtended(), LockRefindAndRelease(), and SetupLockInTable().
◆ ReleaseLockIfHeld()
Definition at line 2654 of file lock.c.
2655{
2656 ResourceOwner owner;
2657 LOCALLOCKOWNER *lockOwners;
2659
2660 /* Identify owner for lock (must match LockRelease!) */
2662 owner = NULL;
2663 else
2664 owner = CurrentResourceOwner;
2665
2666 /* Scan to see if there are any locks belonging to the target owner */
2667 lockOwners = locallock->lockOwners;
2669 {
2671 {
2674 {
2675 /*
2676 * We will still hold this lock after forgetting this
2677 * ResourceOwner.
2678 */
2680 /* compact out unused slot */
2681 locallock->numLockOwners--;
2686 }
2687 else
2688 {
2690 /* We want to call LockRelease just once */
2692 locallock->nLocks = 1;
2694 locallock->tag.mode,
2695 sessionLock))
2697 }
2698 break;
2699 }
2700 }
2701}
References Assert, CurrentResourceOwner, elog, fb(), i, LockRelease(), LOCALLOCKOWNER::nLocks, ResourceOwnerForgetLock(), and WARNING.
Referenced by LockReleaseCurrentOwner(), and LockReleaseSession().
◆ RemoveFromWaitQueue()
Definition at line 2054 of file lock.c.
2055{
2060
2061 /* Make sure proc is waiting */
2064 Assert(waitLock);
2067
2068 /* Remove proc from lock's wait queue */
2070
2071 /* Undo increments of request counts by waiting process */
2074 waitLock->nRequested--;
2076 waitLock->requested[lockmode]--;
2077 /* don't forget to clear waitMask bit if appropriate */
2080
2081 /* Clean up the proc's own state, and pass it the ok/fail signal */
2085
2086 /*
2087 * Delete the proclock immediately if it represents no already-held locks.
2088 * (This must happen now because if the owner of the lock decides to
2089 * release it, and the requested/granted counts then go to zero,
2090 * LockRelease expects there to be no remaining proclocks.) Then see if
2091 * any other waiters for the lock can be woken up now.
2092 */
2093 CleanUpLock(waitLock, proclock,
2095 true);
2096}
References Assert, CleanUpLock(), dclist_delete_from_thoroughly(), dclist_is_empty(), dlist_node_is_detached(), fb(), LOCK::granted, lengthof, LOCK_LOCKMETHOD, LOCKBIT_OFF, LockMethods, LOCK::nGranted, LOCK::nRequested, PROC_WAIT_STATUS_ERROR, PROC_WAIT_STATUS_WAITING, LOCK::requested, PGPROC::waitLink, PGPROC::waitLock, PGPROC::waitLockMode, LOCK::waitMask, PGPROC::waitProcLock, LOCK::waitProcs, and PGPROC::waitStatus.
Referenced by CheckDeadLock(), and LockErrorCleanup().
◆ RemoveLocalLock()
Definition at line 1484 of file lock.c.
1485{
1487
1489 {
1492 }
1493 locallock->numLockOwners = 0;
1497
1499 {
1501
1503
1509 }
1510
1512 &(locallock->tag),
1515
1516 /*
1517 * Indicate that the lock is released for certain types of locks
1518 */
1520}
References Assert, CheckAndSetLockHeld(), FastPathStrongRelationLockData::count, elog, FastPathStrongLockHashPartition, FastPathStrongRelationLocks, fb(), HASH_REMOVE, hash_search(), i, LockMethodLocalHash, FastPathStrongRelationLockData::mutex, pfree(), ResourceOwnerForgetLock(), SpinLockAcquire(), SpinLockRelease(), and WARNING.
Referenced by LockAcquireExtended(), LockHasWaiters(), LockRelease(), LockReleaseAll(), and PostPrepare_Locks().
◆ ResetAwaitedLock()
Definition at line 1915 of file lock.c.
References awaitedLock, and fb().
Referenced by LockErrorCleanup().
◆ SetupLockInTable()
|
static |
Definition at line 1291 of file lock.c.
1293{
1294 LOCK *lock;
1295 PROCLOCK *proclock;
1298 bool found;
1299
1300 /*
1301 * Find or create a lock with this tag.
1302 */
1304 locktag,
1305 hashcode,
1306 HASH_ENTER_NULL,
1307 &found);
1308 if (!lock)
1310
1311 /*
1312 * if it's a new lock object, initialize it
1313 */
1314 if (!found)
1315 {
1316 lock->grantMask = 0;
1317 lock->waitMask = 0;
1320 lock->nRequested = 0;
1321 lock->nGranted = 0;
1325 }
1326 else
1327 {
1332 }
1333
1334 /*
1335 * Create the hash key for the proclock table.
1336 */
1337 proclocktag.myLock = lock;
1338 proclocktag.myProc = proc;
1339
1341
1342 /*
1343 * Find or create a proclock entry with this tag
1344 */
1346 &proclocktag,
1347 proclock_hashcode,
1348 HASH_ENTER_NULL,
1349 &found);
1350 if (!proclock)
1351 {
1352 /* Oops, not enough shmem for the proclock */
1354 {
1355 /*
1356 * There are no other requestors of this lock, so garbage-collect
1357 * the lock object. We *must* do this to avoid a permanent leak
1358 * of shared memory, because there won't be anything to cause
1359 * anyone to release the lock object later.
1360 */
1363 &(lock->tag),
1364 hashcode,
1365 HASH_REMOVE,
1366 NULL))
1368 }
1370 }
1371
1372 /*
1373 * If new, initialize the new entry
1374 */
1375 if (!found)
1376 {
1378
1379 /*
1380 * It might seem unsafe to access proclock->groupLeader without a
1381 * lock, but it's not really. Either we are initializing a proclock
1382 * on our own behalf, in which case our group leader isn't changing
1383 * because the group leader for a process can only ever be changed by
1384 * the process itself; or else we are transferring a fast-path lock to
1385 * the main lock table, in which case that process can't change its
1386 * lock group leader without first releasing all of its locks (and in
1387 * particular the one we are currently transferring).
1388 */
1390 proc->lockGroupLeader : proc;
1391 proclock->holdMask = 0;
1392 proclock->releaseMask = 0;
1393 /* Add proclock to appropriate lists */
1397 }
1398 else
1399 {
1402
1403#ifdef CHECK_DEADLOCK_RISK
1404
1405 /*
1406 * Issue warning if we already hold a lower-level lock on this object
1407 * and do not hold a lock of the requested level or higher. This
1408 * indicates a deadlock-prone coding practice (eg, we'd have a
1409 * deadlock if another backend were following the same code path at
1410 * about the same time).
1411 *
1412 * This is not enabled by default, because it may generate log entries
1413 * about user-level coding practices that are in fact safe in context.
1414 * It can be enabled to help find system-level problems.
1415 *
1416 * XXX Doing numeric comparison on the lockmodes is a hack; it'd be
1417 * better to use a table. For now, though, this works.
1418 */
1419 {
1421
1423 {
1425 {
1427 break; /* safe: we have a lock >= req level */
1429 " from %s to %s on object %u/%u/%u",
1431 lockMethodTable->lockModeNames[lockmode],
1434 break;
1435 }
1436 }
1437 }
1438#endif /* CHECK_DEADLOCK_RISK */
1439 }
1440
1441 /*
1442 * lock->nRequested and lock->requested[] count the total number of
1443 * requests, whether granted or waiting, so increment those immediately.
1444 * The other counts don't increment till we get the lock.
1445 */
1446 lock->nRequested++;
1447 lock->requested[lockmode]++;
1449
1450 /*
1451 * We shouldn't already hold the desired lock; else locallock table is
1452 * broken.
1453 */
1456 lockMethodTable->lockModeNames[lockmode],
1459
1460 return proclock;
1461}
References Assert, dclist_init(), dlist_init(), dlist_is_empty(), dlist_push_tail(), elog, ERROR, fb(), LOCK::granted, LOCK::grantMask, PROCLOCK::groupLeader, HASH_ENTER_NULL, HASH_REMOVE, hash_search_with_hash_value(), PROCLOCK::holdMask, i, LOCK_PRINT, LOCKBIT_ON, PGPROC::lockGroupLeader, LockHashPartition, PROCLOCK::lockLink, LockMethodLockHash, LockMethodProcLockHash, LOCKTAG::locktag_field1, LOCKTAG::locktag_field2, LOCKTAG::locktag_field3, LOG, MAX_LOCKMODES, MemSet, PGPROC::myProcLocks, LOCK::nGranted, LOCK::nRequested, PANIC, PROCLOCK::procLink, PROCLOCK_PRINT, ProcLockHashCode(), LOCK::procLocks, PROCLOCK::releaseMask, LOCK::requested, LOCK::tag, LOCK::waitMask, and LOCK::waitProcs.
Referenced by FastPathGetRelationLockEntry(), FastPathTransferRelationLocks(), LockAcquireExtended(), and VirtualXactLock().
◆ UnGrantLock()
|
static |
Definition at line 1689 of file lock.c.
1691{
1693
1697
1698 /*
1699 * fix the general lock stats
1700 */
1701 lock->nRequested--;
1702 lock->requested[lockmode]--;
1703 lock->nGranted--;
1704 lock->granted[lockmode]--;
1705
1707 {
1708 /* change the conflict mask. No more of this lock type. */
1710 }
1711
1713
1714 /*
1715 * We need only run ProcLockWakeup if the released lock conflicts with at
1716 * least one of the lock types requested by waiter(s). Otherwise whatever
1717 * conflict made them wait must still exist. NOTE: before MVCC, we could
1718 * skip wakeup if lock->granted[lockmode] was still positive. But that's
1719 * not true anymore, because the remaining granted locks might belong to
1720 * some waiter, who could now be awakened because he doesn't conflict with
1721 * his own locks.
1722 */
1725
1726 /*
1727 * Now fix the per-proclock state.
1728 */
1731
1733}
References Assert, fb(), LOCK::granted, LOCK::grantMask, PROCLOCK::holdMask, LOCK_PRINT, LOCKBIT_OFF, LOCK::nGranted, LOCK::nRequested, PROCLOCK_PRINT, LOCK::requested, and LOCK::waitMask.
Referenced by LockRefindAndRelease(), LockRelease(), and LockReleaseAll().
◆ VirtualXactLock()
| bool VirtualXactLock | ( | VirtualTransactionId | vxid, |
| bool | wait | ||
| ) |
Definition at line 4725 of file lock.c.
4726{
4727 LOCKTAG tag;
4728 PGPROC *proc;
4730
4732
4734 /* no vxid lock; localTransactionId is a normal, locked XID */
4736
4737 SET_LOCKTAG_VIRTUALTRANSACTION(tag, vxid);
4738
4739 /*
4740 * If a lock table entry must be made, this is the PGPROC on whose behalf
4741 * it must be done. Note that the transaction might end or the PGPROC
4742 * might be reassigned to a new backend before we get around to examining
4743 * it, but it doesn't matter. If we find upon examination that the
4744 * relevant lxid is no longer running here, that's enough to prove that
4745 * it's no longer running anywhere.
4746 */
4750
4751 /*
4752 * We must acquire this lock before checking the procNumber and lxid
4753 * against the ones we're waiting for. The target backend will only set
4754 * or clear lxid while holding this lock.
4755 */
4757
4760 {
4761 /* VXID ended */
4764 }
4765
4766 /*
4767 * If we aren't asked to wait, there's no need to set up a lock table
4768 * entry. The transaction is still in progress, so just return false.
4769 */
4770 if (!wait)
4771 {
4773 return false;
4774 }
4775
4776 /*
4777 * OK, we're going to need to sleep on the VXID. But first, we must set
4778 * up the primary lock table entry, if needed (ie, convert the proc's
4779 * fast-path lock on its VXID to a regular lock).
4780 */
4782 {
4783 PROCLOCK *proclock;
4784 uint32 hashcode;
4786
4787 hashcode = LockTagHashCode(&tag);
4788
4791
4793 &tag, hashcode, ExclusiveLock);
4794 if (!proclock)
4795 {
4802 }
4804
4806
4808 }
4809
4810 /*
4811 * If the proc has an XID now, we'll avoid a TwoPhaseGetXidByVirtualXID()
4812 * search. The proc might have assigned this XID but not yet locked it,
4813 * in which case the proc will lock this XID before releasing the VXID.
4814 * The fpInfoLock critical section excludes VirtualXactLockTableCleanup(),
4815 * so we won't save an XID of a different VXID. It doesn't matter whether
4816 * we save this before or after setting up the primary lock table entry.
4817 */
4818 xid = proc->xid;
4819
4820 /* Done with proc->fpLockBits */
4822
4823 /* Time to wait. */
4825
4828}
References Assert, DEFAULT_LOCKMETHOD, ereport, errcode(), errhint(), errmsg, ERROR, ExclusiveLock, fb(), PGPROC::fpInfoLock, PGPROC::fpLocalTransactionId, PGPROC::fpVXIDLock, GrantLock(), InvalidTransactionId, VirtualTransactionId::localTransactionId, LockAcquire(), LockHashPartitionLock, LockMethods, LockRelease(), LockTagHashCode(), LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), PROCLOCKTAG::myLock, VirtualTransactionId::procNumber, PGPROC::procNumber, ProcNumberGetProc(), SET_LOCKTAG_VIRTUALTRANSACTION, SetupLockInTable(), ShareLock, PROCLOCK::tag, VirtualTransactionIdIsRecoveredPreparedXact, VirtualTransactionIdIsValid, PGPROC::vxid, XactLockForVirtualXact(), and PGPROC::xid.
Referenced by ResolveRecoveryConflictWithVirtualXIDs(), WaitForLockersMultiple(), and WaitForOlderSnapshots().
◆ VirtualXactLockTableCleanup()
Definition at line 4625 of file lock.c.
4626{
4627 bool fastpath;
4628 LocalTransactionId lxid;
4629
4631
4632 /*
4633 * Clean up shared memory state.
4634 */
4636
4641
4643
4644 /*
4645 * If fpVXIDLock has been cleared without touching fpLocalTransactionId,
4646 * that means someone transferred the lock to the main lock table.
4647 */
4649 {
4650 VirtualTransactionId vxid;
4651 LOCKTAG locktag;
4652
4654 vxid.localTransactionId = lxid;
4655 SET_LOCKTAG_VIRTUALTRANSACTION(locktag, vxid);
4656
4659 }
4660}
References Assert, DEFAULT_LOCKMETHOD, ExclusiveLock, PGPROC::fpInfoLock, PGPROC::fpLocalTransactionId, PGPROC::fpVXIDLock, INVALID_PROC_NUMBER, InvalidLocalTransactionId, VirtualTransactionId::localTransactionId, LocalTransactionIdIsValid, LockMethods, LockRefindAndRelease(), LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MyProc, MyProcNumber, VirtualTransactionId::procNumber, PGPROC::procNumber, SET_LOCKTAG_VIRTUALTRANSACTION, and PGPROC::vxid.
Referenced by LockReleaseAll(), and ShutdownRecoveryTransactionEnvironment().
◆ VirtualXactLockTableInsert()
| void VirtualXactLockTableInsert | ( | VirtualTransactionId | vxid | ) |
Definition at line 4602 of file lock.c.
4603{
4605
4607
4611
4614
4616}
References Assert, PGPROC::fpInfoLock, PGPROC::fpLocalTransactionId, PGPROC::fpVXIDLock, InvalidLocalTransactionId, VirtualTransactionId::localTransactionId, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MyProc, VirtualTransactionId::procNumber, PGPROC::procNumber, VirtualTransactionIdIsValid, and PGPROC::vxid.
Referenced by InitRecoveryTransactionEnvironment(), and StartTransaction().
◆ WaitOnLock()
|
static |
Definition at line 1940 of file lock.c.
1941{
1944
1946 locallock->tag.lock.locktag_field2,
1947 locallock->tag.lock.locktag_field3,
1948 locallock->tag.lock.locktag_field4,
1949 locallock->tag.lock.locktag_type,
1950 locallock->tag.mode);
1951
1952 /* Setup error traceback support for ereport() */
1957
1958 /* adjust the process title to indicate that it's waiting */
1960
1961 /*
1962 * Record the fact that we are waiting for a lock, so that
1963 * LockErrorCleanup will clean up if cancel/die happens.
1964 */
1966 awaitedOwner = owner;
1967
1968 /*
1969 * NOTE: Think not to put any shared-state cleanup after the call to
1970 * ProcSleep, in either the normal or failure path. The lock state must
1971 * be fully set by the lock grantor, or by CheckDeadLock if we give up
1972 * waiting for the lock. This is necessary because of the possibility
1973 * that a cancel/die interrupt will interrupt ProcSleep after someone else
1974 * grants us the lock, but before we've noticed it. Hence, after granting,
1975 * the locktable state must fully reflect the fact that we own the lock;
1976 * we can't do additional work on return.
1977 *
1978 * We can and do use a PG_TRY block to try to clean up after failure, but
1979 * this still has a major limitation: elog(FATAL) can occur while waiting
1980 * (eg, a "die" interrupt), and then control won't come back here. So all
1981 * cleanup of essential state should happen in LockErrorCleanup, not here.
1982 * We can use PG_TRY to clear the "waiting" status flags, since doing that
1983 * is unimportant if the process exits.
1984 */
1985 PG_TRY();
1986 {
1988 }
1989 PG_CATCH();
1990 {
1991 /* In this path, awaitedLock remains set until LockErrorCleanup */
1992
1993 /* reset ps display to remove the suffix */
1994 set_ps_display_remove_suffix();
1995
1996 /* and propagate the error */
1997 PG_RE_THROW();
1998 }
1999 PG_END_TRY();
2000
2001 /*
2002 * We no longer want LockErrorCleanup to do anything.
2003 */
2005
2006 /* reset ps display to remove the suffix */
2007 set_ps_display_remove_suffix();
2008
2010
2012 locallock->tag.lock.locktag_field2,
2013 locallock->tag.lock.locktag_field3,
2014 locallock->tag.lock.locktag_field4,
2015 locallock->tag.lock.locktag_type,
2016 locallock->tag.mode);
2017
2019}
References awaitedLock, awaitedOwner, error_context_stack, fb(), PG_CATCH, PG_END_TRY, PG_RE_THROW, PG_TRY, ErrorContextCallback::previous, ProcSleep(), result, set_ps_display_remove_suffix(), set_ps_display_suffix(), and waitonlock_error_callback().
Referenced by LockAcquireExtended().
◆ waitonlock_error_callback()
Definition at line 2028 of file lock.c.
References arg, DescribeLockTag(), errcontext, fb(), GetLockmodeName(), initStringInfo(), LOCKTAG::locktag_lockmethodid, and mode.
Referenced by WaitOnLock().
◆ XactLockForVirtualXact()
|
static |
Definition at line 4674 of file lock.c.
4676{
4678
4679 /* There is no point to wait for 2PCs if you have no 2PCs. */
4681 return true;
4682
4683 do
4684 {
4686 LOCKTAG tag;
4687
4688 /* Clear state from previous iterations. */
4690 {
4691 xid = InvalidTransactionId;
4693 }
4694
4695 /* If we have no xid, try to find one. */
4699 {
4701 return true;
4702 }
4703
4704 /* Check or wait for XID completion. */
4705 SET_LOCKTAG_TRANSACTION(tag, xid);
4708 return false;
4711
4712 return true;
4713}
References Assert, fb(), InvalidTransactionId, LockAcquire(), LOCKACQUIRE_NOT_AVAIL, LockRelease(), max_prepared_xacts, SET_LOCKTAG_TRANSACTION, ShareLock, TransactionIdIsValid, and TwoPhaseGetXidByVirtualXID().
Referenced by VirtualXactLock().
Variable Documentation
◆ awaitedLock
|
static |
Definition at line 339 of file lock.c.
Referenced by GetAwaitedLock(), GrantAwaitedLock(), ResetAwaitedLock(), and WaitOnLock().
◆ awaitedOwner
|
static |
Definition at line 340 of file lock.c.
Referenced by GrantAwaitedLock(), and WaitOnLock().
◆ default_lockmethod
|
static |
Initial value:
= {
}
Definition at line 128 of file lock.c.
128 {
129 MaxLockMode,
130 LockConflicts,
131 lock_mode_names,
132#ifdef LOCK_DEBUG
133 &Trace_locks
134#else
135 &Dummy_trace
136#endif
137};
◆ Dummy_trace
◆ FastPathLocalUseCounts
|
static |
Definition at line 179 of file lock.c.
Referenced by FastPathGrantRelationLock(), FastPathUnGrantRelationLock(), LockAcquireExtended(), and LockRelease().
◆ FastPathLockGroupsPerBackend
| int FastPathLockGroupsPerBackend = 0 |
Definition at line 205 of file lock.c.
Referenced by CalculateFastPathLockShmemSize(), GetLockStatusData(), InitializeFastPathLocks(), and ProcGlobalShmemInit().
◆ FastPathStrongRelationLocks
|
static |
Definition at line 315 of file lock.c.
Referenced by AbortStrongLockAcquire(), BeginStrongLockAcquire(), lock_twophase_recover(), LockAcquireExtended(), LockManagerShmemInit(), LockManagerShmemRequest(), LockRefindAndRelease(), and RemoveLocalLock().
◆ lock_mode_names
Initial value:
=
{
"INVALID",
"AccessShareLock",
"RowShareLock",
"RowExclusiveLock",
"ShareUpdateExclusiveLock",
"ShareLock",
"ShareRowExclusiveLock",
"ExclusiveLock",
"AccessExclusiveLock"
}
Definition at line 111 of file lock.c.
112{
113 "INVALID",
114 "AccessShareLock",
115 "RowShareLock",
116 "RowExclusiveLock",
117 "ShareUpdateExclusiveLock",
118 "ShareLock",
119 "ShareRowExclusiveLock",
120 "ExclusiveLock",
121 "AccessExclusiveLock"
122};
◆ LockConflicts
◆ LockManagerShmemCallbacks
| const ShmemCallbacks LockManagerShmemCallbacks |
Initial value:
◆ LockMethodLocalHash
|
static |
Definition at line 334 of file lock.c.
Referenced by AtPrepare_Locks(), CheckForSessionAndXactLocks(), InitLockManagerAccess(), LockAcquireExtended(), LockHasWaiters(), LockHeldByMe(), LockReassignCurrentOwner(), LockRelease(), LockReleaseAll(), LockReleaseCurrentOwner(), LockReleaseSession(), PostPrepare_Locks(), and RemoveLocalLock().
◆ LockMethodLockHash
|
static |
Definition at line 332 of file lock.c.
Referenced by CleanUpLock(), FastPathGetRelationLockEntry(), GetLockConflicts(), lock_twophase_recover(), LockManagerShmemRequest(), LockRefindAndRelease(), LockRelease(), LockTagHashCode(), LockWaiterCount(), and SetupLockInTable().
◆ LockMethodProcLockHash
|
static |
Definition at line 333 of file lock.c.
Referenced by CleanUpLock(), FastPathGetRelationLockEntry(), GetLockStatusData(), GetRunningTransactionLocks(), lock_twophase_recover(), LockAcquireExtended(), LockManagerShmemRequest(), LockRefindAndRelease(), LockRelease(), PostPrepare_Locks(), and SetupLockInTable().
◆ LockMethods
|
static |
Initial value:
Definition at line 153 of file lock.c.
Referenced by DoLockModesConflict(), FastPathGetRelationLockEntry(), GetLockConflicts(), GetLockmodeName(), GetLocksMethodTable(), GetLockTagsMethodTable(), lock_twophase_postcommit(), lock_twophase_recover(), lock_twophase_standby_recover(), LockAcquireExtended(), LockHasWaiters(), LockRelease(), LockReleaseAll(), LockReleaseSession(), LockWaiterCount(), RemoveFromWaitQueue(), VirtualXactLock(), and VirtualXactLockTableCleanup().
◆ log_lock_failures
Definition at line 57 of file lock.c.
Referenced by heap_acquire_tuplock(), heap_lock_tuple(), and heapam_tuple_lock().
◆ max_locks_per_xact
| int max_locks_per_xact |
Definition at line 56 of file lock.c.
Referenced by CheckRequiredParameterValues(), InitControlFile(), InitializeFastPathLocks(), and XLogReportParameters().
◆ PG_USED_FOR_ASSERTS_ONLY
|
static |
◆ StrongLockInProgress
|
static |
Definition at line 338 of file lock.c.
Referenced by AbortStrongLockAcquire(), BeginStrongLockAcquire(), and FinishStrongLockAcquire().
◆ user_lockmethod
|
static |
Initial value:
Definition at line 139 of file lock.c.
139 {
140 MaxLockMode,
141 LockConflicts,
142 lock_mode_names,
143#ifdef LOCK_DEBUG
144 &Trace_userlocks
145#else
146 &Dummy_trace
147#endif
148};
