PostgreSQL Source Code git master
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
lock.c
Go to the documentation of this file.
1/*-------------------------------------------------------------------------
2 *
3 * lock.c
4 * POSTGRES primary lock mechanism
5 *
6 * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
7 * Portions Copyright (c) 1994, Regents of the University of California
8 *
9 *
10 * IDENTIFICATION
11 * src/backend/storage/lmgr/lock.c
12 *
13 * NOTES
14 * A lock table is a shared memory hash table. When
15 * a process tries to acquire a lock of a type that conflicts
16 * with existing locks, it is put to sleep using the routines
17 * in storage/lmgr/proc.c.
18 *
19 * For the most part, this code should be invoked via lmgr.c
20 * or another lock-management module, not directly.
21 *
22 * Interface:
23 *
24 * InitLocks(), GetLocksMethodTable(), GetLockTagsMethodTable(),
25 * LockAcquire(), LockRelease(), LockReleaseAll(),
26 * LockCheckConflicts(), GrantLock()
27 *
28 *-------------------------------------------------------------------------
29 */
30#include "postgres.h"
31
32#include <signal.h>
33#include <unistd.h>
34
35#include "access/transam.h"
36#include "access/twophase.h"
38#include "access/xlog.h"
39#include "access/xlogutils.h"
40#include "miscadmin.h"
41#include "pg_trace.h"
42#include "storage/proc.h"
43#include "storage/procarray.h"
44#include "storage/spin.h"
45#include "storage/standby.h"
46#include "utils/memutils.h"
47#include "utils/ps_status.h"
48#include "utils/resowner.h"
49
50
51/* This configuration variable is used to set the lock table size */
52int max_locks_per_xact; /* set by guc.c */
53
54#define NLOCKENTS() \
55 mul_size(max_locks_per_xact, add_size(MaxBackends, max_prepared_xacts))
56
57
58/*
59 * Data structures defining the semantics of the standard lock methods.
60 *
61 * The conflict table defines the semantics of the various lock modes.
62 */
63static const LOCKMASK LockConflicts[] = {
64 0,
65
66 /* AccessShareLock */
68
69 /* RowShareLock */
71
72 /* RowExclusiveLock */
75
76 /* ShareUpdateExclusiveLock */
80
81 /* ShareLock */
85
86 /* ShareRowExclusiveLock */
90
91 /* ExclusiveLock */
96
97 /* AccessExclusiveLock */
102
103};
104
105/* Names of lock modes, for debug printouts */
106static const char *const lock_mode_names[] =
107{
108 "INVALID",
109 "AccessShareLock",
110 "RowShareLock",
111 "RowExclusiveLock",
112 "ShareUpdateExclusiveLock",
113 "ShareLock",
114 "ShareRowExclusiveLock",
115 "ExclusiveLock",
116 "AccessExclusiveLock"
117};
118
119#ifndef LOCK_DEBUG
120static bool Dummy_trace = false;
121#endif
122
127#ifdef LOCK_DEBUG
128 &Trace_locks
129#else
131#endif
132};
133
138#ifdef LOCK_DEBUG
139 &Trace_userlocks
140#else
142#endif
143};
144
145/*
146 * map from lock method id to the lock table data structures
147 */
148static const LockMethod LockMethods[] = {
149 NULL,
152};
153
154
155/* Record that's written to 2PC state file when a lock is persisted */
156typedef struct TwoPhaseLockRecord
157{
161
162
163/*
164 * Count of the number of fast path lock slots we believe to be used. This
165 * might be higher than the real number if another backend has transferred
166 * our locks to the primary lock table, but it can never be lower than the
167 * real value, since only we can acquire locks on our own behalf.
168 *
169 * XXX Allocate a static array of the maximum size. We could use a pointer
170 * and then allocate just the right size to save a couple kB, but then we
171 * would have to initialize that, while for the static array that happens
172 * automatically. Doesn't seem worth the extra complexity.
173 */
175
176/*
177 * Flag to indicate if the relation extension lock is held by this backend.
178 * This flag is used to ensure that while holding the relation extension lock
179 * we don't try to acquire a heavyweight lock on any other object. This
180 * restriction implies that the relation extension lock won't ever participate
181 * in the deadlock cycle because we can never wait for any other heavyweight
182 * lock after acquiring this lock.
183 *
184 * Such a restriction is okay for relation extension locks as unlike other
185 * heavyweight locks these are not held till the transaction end. These are
186 * taken for a short duration to extend a particular relation and then
187 * released.
188 */
189static bool IsRelationExtensionLockHeld PG_USED_FOR_ASSERTS_ONLY = false;
190
191/*
192 * Number of fast-path locks per backend - size of the arrays in PGPROC.
193 * This is set only once during start, before initializing shared memory,
194 * and remains constant after that.
195 *
196 * We set the limit based on max_locks_per_transaction GUC, because that's
197 * the best information about expected number of locks per backend we have.
198 * See InitializeFastPathLocks() for details.
199 */
201
202/*
203 * Macros to calculate the fast-path group and index for a relation.
204 *
205 * The formula is a simple hash function, designed to spread the OIDs a bit,
206 * so that even contiguous values end up in different groups. In most cases
207 * there will be gaps anyway, but the multiplication should help a bit.
208 *
209 * The selected constant (49157) is a prime not too close to 2^k, and it's
210 * small enough to not cause overflows (in 64-bit).
211 */
212#define FAST_PATH_REL_GROUP(rel) \
213 (((uint64) (rel) * 49157) % FastPathLockGroupsPerBackend)
214
215/*
216 * Given the group/slot indexes, calculate the slot index in the whole array
217 * of fast-path lock slots.
218 */
219#define FAST_PATH_SLOT(group, index) \
220 (AssertMacro((uint32) (group) < FastPathLockGroupsPerBackend), \
221 AssertMacro((uint32) (index) < FP_LOCK_SLOTS_PER_GROUP), \
222 ((group) * FP_LOCK_SLOTS_PER_GROUP + (index)))
223
224/*
225 * Given a slot index (into the whole per-backend array), calculated using
226 * the FAST_PATH_SLOT macro, split it into group and index (in the group).
227 */
228#define FAST_PATH_GROUP(index) \
229 (AssertMacro((uint32) (index) < FP_LOCK_SLOTS_PER_BACKEND), \
230 ((index) / FP_LOCK_SLOTS_PER_GROUP))
231#define FAST_PATH_INDEX(index) \
232 (AssertMacro((uint32) (index) < FP_LOCK_SLOTS_PER_BACKEND), \
233 ((index) % FP_LOCK_SLOTS_PER_GROUP))
234
235/* Macros for manipulating proc->fpLockBits */
236#define FAST_PATH_BITS_PER_SLOT 3
237#define FAST_PATH_LOCKNUMBER_OFFSET 1
238#define FAST_PATH_MASK ((1 << FAST_PATH_BITS_PER_SLOT) - 1)
239#define FAST_PATH_BITS(proc, n) (proc)->fpLockBits[FAST_PATH_GROUP(n)]
240#define FAST_PATH_GET_BITS(proc, n) \
241 ((FAST_PATH_BITS(proc, n) >> (FAST_PATH_BITS_PER_SLOT * FAST_PATH_INDEX(n))) & FAST_PATH_MASK)
242#define FAST_PATH_BIT_POSITION(n, l) \
243 (AssertMacro((l) >= FAST_PATH_LOCKNUMBER_OFFSET), \
244 AssertMacro((l) < FAST_PATH_BITS_PER_SLOT+FAST_PATH_LOCKNUMBER_OFFSET), \
245 AssertMacro((n) < FP_LOCK_SLOTS_PER_BACKEND), \
246 ((l) - FAST_PATH_LOCKNUMBER_OFFSET + FAST_PATH_BITS_PER_SLOT * (FAST_PATH_INDEX(n))))
247#define FAST_PATH_SET_LOCKMODE(proc, n, l) \
248 FAST_PATH_BITS(proc, n) |= UINT64CONST(1) << FAST_PATH_BIT_POSITION(n, l)
249#define FAST_PATH_CLEAR_LOCKMODE(proc, n, l) \
250 FAST_PATH_BITS(proc, n) &= ~(UINT64CONST(1) << FAST_PATH_BIT_POSITION(n, l))
251#define FAST_PATH_CHECK_LOCKMODE(proc, n, l) \
252 (FAST_PATH_BITS(proc, n) & (UINT64CONST(1) << FAST_PATH_BIT_POSITION(n, l)))
253
254/*
255 * The fast-path lock mechanism is concerned only with relation locks on
256 * unshared relations by backends bound to a database. The fast-path
257 * mechanism exists mostly to accelerate acquisition and release of locks
258 * that rarely conflict. Because ShareUpdateExclusiveLock is
259 * self-conflicting, it can't use the fast-path mechanism; but it also does
260 * not conflict with any of the locks that do, so we can ignore it completely.
261 */
262#define EligibleForRelationFastPath(locktag, mode) \
263 ((locktag)->locktag_lockmethodid == DEFAULT_LOCKMETHOD && \
264 (locktag)->locktag_type == LOCKTAG_RELATION && \
265 (locktag)->locktag_field1 == MyDatabaseId && \
266 MyDatabaseId != InvalidOid && \
267 (mode) < ShareUpdateExclusiveLock)
268#define ConflictsWithRelationFastPath(locktag, mode) \
269 ((locktag)->locktag_lockmethodid == DEFAULT_LOCKMETHOD && \
270 (locktag)->locktag_type == LOCKTAG_RELATION && \
271 (locktag)->locktag_field1 != InvalidOid && \
272 (mode) > ShareUpdateExclusiveLock)
273
274static bool FastPathGrantRelationLock(Oid relid, LOCKMODE lockmode);
275static bool FastPathUnGrantRelationLock(Oid relid, LOCKMODE lockmode);
276static bool FastPathTransferRelationLocks(LockMethod lockMethodTable,
277 const LOCKTAG *locktag, uint32 hashcode);
279
280/*
281 * To make the fast-path lock mechanism work, we must have some way of
282 * preventing the use of the fast-path when a conflicting lock might be present.
283 * We partition* the locktag space into FAST_PATH_STRONG_LOCK_HASH_PARTITIONS,
284 * and maintain an integer count of the number of "strong" lockers
285 * in each partition. When any "strong" lockers are present (which is
286 * hopefully not very often), the fast-path mechanism can't be used, and we
287 * must fall back to the slower method of pushing matching locks directly
288 * into the main lock tables.
289 *
290 * The deadlock detector does not know anything about the fast path mechanism,
291 * so any locks that might be involved in a deadlock must be transferred from
292 * the fast-path queues to the main lock table.
293 */
294
295#define FAST_PATH_STRONG_LOCK_HASH_BITS 10
296#define FAST_PATH_STRONG_LOCK_HASH_PARTITIONS \
297 (1 << FAST_PATH_STRONG_LOCK_HASH_BITS)
298#define FastPathStrongLockHashPartition(hashcode) \
299 ((hashcode) % FAST_PATH_STRONG_LOCK_HASH_PARTITIONS)
300
301typedef struct
302{
303 slock_t mutex;
306
308
309
310/*
311 * Pointers to hash tables containing lock state
312 *
313 * The LockMethodLockHash and LockMethodProcLockHash hash tables are in
314 * shared memory; LockMethodLocalHash is local to each backend.
315 */
319
320
321/* private state for error cleanup */
325
326
327#ifdef LOCK_DEBUG
328
329/*------
330 * The following configuration options are available for lock debugging:
331 *
332 * TRACE_LOCKS -- give a bunch of output what's going on in this file
333 * TRACE_USERLOCKS -- same but for user locks
334 * TRACE_LOCK_OIDMIN-- do not trace locks for tables below this oid
335 * (use to avoid output on system tables)
336 * TRACE_LOCK_TABLE -- trace locks on this table (oid) unconditionally
337 * DEBUG_DEADLOCKS -- currently dumps locks at untimely occasions ;)
338 *
339 * Furthermore, but in storage/lmgr/lwlock.c:
340 * TRACE_LWLOCKS -- trace lightweight locks (pretty useless)
341 *
342 * Define LOCK_DEBUG at compile time to get all these enabled.
343 * --------
344 */
345
346int Trace_lock_oidmin = FirstNormalObjectId;
347bool Trace_locks = false;
348bool Trace_userlocks = false;
349int Trace_lock_table = 0;
350bool Debug_deadlocks = false;
351
352
353inline static bool
354LOCK_DEBUG_ENABLED(const LOCKTAG *tag)
355{
356 return
358 ((Oid) tag->locktag_field2 >= (Oid) Trace_lock_oidmin))
359 || (Trace_lock_table &&
360 (tag->locktag_field2 == Trace_lock_table));
361}
362
363
364inline static void
365LOCK_PRINT(const char *where, const LOCK *lock, LOCKMODE type)
366{
367 if (LOCK_DEBUG_ENABLED(&lock->tag))
368 elog(LOG,
369 "%s: lock(%p) id(%u,%u,%u,%u,%u,%u) grantMask(%x) "
370 "req(%d,%d,%d,%d,%d,%d,%d)=%d "
371 "grant(%d,%d,%d,%d,%d,%d,%d)=%d wait(%d) type(%s)",
372 where, lock,
376 lock->grantMask,
377 lock->requested[1], lock->requested[2], lock->requested[3],
378 lock->requested[4], lock->requested[5], lock->requested[6],
379 lock->requested[7], lock->nRequested,
380 lock->granted[1], lock->granted[2], lock->granted[3],
381 lock->granted[4], lock->granted[5], lock->granted[6],
382 lock->granted[7], lock->nGranted,
383 dclist_count(&lock->waitProcs),
384 LockMethods[LOCK_LOCKMETHOD(*lock)]->lockModeNames[type]);
385}
386
387
388inline static void
389PROCLOCK_PRINT(const char *where, const PROCLOCK *proclockP)
390{
391 if (LOCK_DEBUG_ENABLED(&proclockP->tag.myLock->tag))
392 elog(LOG,
393 "%s: proclock(%p) lock(%p) method(%u) proc(%p) hold(%x)",
394 where, proclockP, proclockP->tag.myLock,
395 PROCLOCK_LOCKMETHOD(*(proclockP)),
396 proclockP->tag.myProc, (int) proclockP->holdMask);
397}
398#else /* not LOCK_DEBUG */
399
400#define LOCK_PRINT(where, lock, type) ((void) 0)
401#define PROCLOCK_PRINT(where, proclockP) ((void) 0)
402#endif /* not LOCK_DEBUG */
403
404
405static uint32 proclock_hash(const void *key, Size keysize);
406static void RemoveLocalLock(LOCALLOCK *locallock);
407static PROCLOCK *SetupLockInTable(LockMethod lockMethodTable, PGPROC *proc,
408 const LOCKTAG *locktag, uint32 hashcode, LOCKMODE lockmode);
409static void GrantLockLocal(LOCALLOCK *locallock, ResourceOwner owner);
410static void BeginStrongLockAcquire(LOCALLOCK *locallock, uint32 fasthashcode);
411static void FinishStrongLockAcquire(void);
412static ProcWaitStatus WaitOnLock(LOCALLOCK *locallock, ResourceOwner owner);
413static void ReleaseLockIfHeld(LOCALLOCK *locallock, bool sessionLock);
414static void LockReassignOwner(LOCALLOCK *locallock, ResourceOwner parent);
415static bool UnGrantLock(LOCK *lock, LOCKMODE lockmode,
416 PROCLOCK *proclock, LockMethod lockMethodTable);
417static void CleanUpLock(LOCK *lock, PROCLOCK *proclock,
418 LockMethod lockMethodTable, uint32 hashcode,
419 bool wakeupNeeded);
420static void LockRefindAndRelease(LockMethod lockMethodTable, PGPROC *proc,
421 LOCKTAG *locktag, LOCKMODE lockmode,
422 bool decrement_strong_lock_count);
423static void GetSingleProcBlockerStatusData(PGPROC *blocked_proc,
425
426
427/*
428 * Initialize the lock manager's shmem data structures.
429 *
430 * This is called from CreateSharedMemoryAndSemaphores(), which see for more
431 * comments. In the normal postmaster case, the shared hash tables are
432 * created here, and backends inherit pointers to them via fork(). In the
433 * EXEC_BACKEND case, each backend re-executes this code to obtain pointers to
434 * the already existing shared hash tables. In either case, each backend must
435 * also call InitLockManagerAccess() to create the locallock hash table.
436 */
437void
439{
440 HASHCTL info;
441 long init_table_size,
442 max_table_size;
443 bool found;
444
445 /*
446 * Compute init/max size to request for lock hashtables. Note these
447 * calculations must agree with LockManagerShmemSize!
448 */
449 max_table_size = NLOCKENTS();
450 init_table_size = max_table_size / 2;
451
452 /*
453 * Allocate hash table for LOCK structs. This stores per-locked-object
454 * information.
455 */
456 info.keysize = sizeof(LOCKTAG);
457 info.entrysize = sizeof(LOCK);
459
460 LockMethodLockHash = ShmemInitHash("LOCK hash",
461 init_table_size,
462 max_table_size,
463 &info,
465
466 /* Assume an average of 2 holders per lock */
467 max_table_size *= 2;
468 init_table_size *= 2;
469
470 /*
471 * Allocate hash table for PROCLOCK structs. This stores
472 * per-lock-per-holder information.
473 */
474 info.keysize = sizeof(PROCLOCKTAG);
475 info.entrysize = sizeof(PROCLOCK);
476 info.hash = proclock_hash;
478
479 LockMethodProcLockHash = ShmemInitHash("PROCLOCK hash",
480 init_table_size,
481 max_table_size,
482 &info,
484
485 /*
486 * Allocate fast-path structures.
487 */
489 ShmemInitStruct("Fast Path Strong Relation Lock Data",
490 sizeof(FastPathStrongRelationLockData), &found);
491 if (!found)
493}
494
495/*
496 * Initialize the lock manager's backend-private data structures.
497 */
498void
500{
501 /*
502 * Allocate non-shared hash table for LOCALLOCK structs. This stores lock
503 * counts and resource owner information.
504 */
505 HASHCTL info;
506
507 info.keysize = sizeof(LOCALLOCKTAG);
508 info.entrysize = sizeof(LOCALLOCK);
509
510 LockMethodLocalHash = hash_create("LOCALLOCK hash",
511 16,
512 &info,
514}
515
516
517/*
518 * Fetch the lock method table associated with a given lock
519 */
522{
523 LOCKMETHODID lockmethodid = LOCK_LOCKMETHOD(*lock);
524
525 Assert(0 < lockmethodid && lockmethodid < lengthof(LockMethods));
526 return LockMethods[lockmethodid];
527}
528
529/*
530 * Fetch the lock method table associated with a given locktag
531 */
534{
535 LOCKMETHODID lockmethodid = (LOCKMETHODID) locktag->locktag_lockmethodid;
536
537 Assert(0 < lockmethodid && lockmethodid < lengthof(LockMethods));
538 return LockMethods[lockmethodid];
539}
540
541
542/*
543 * Compute the hash code associated with a LOCKTAG.
544 *
545 * To avoid unnecessary recomputations of the hash code, we try to do this
546 * just once per function, and then pass it around as needed. Aside from
547 * passing the hashcode to hash_search_with_hash_value(), we can extract
548 * the lock partition number from the hashcode.
549 */
550uint32
552{
553 return get_hash_value(LockMethodLockHash, locktag);
554}
555
556/*
557 * Compute the hash code associated with a PROCLOCKTAG.
558 *
559 * Because we want to use just one set of partition locks for both the
560 * LOCK and PROCLOCK hash tables, we have to make sure that PROCLOCKs
561 * fall into the same partition number as their associated LOCKs.
562 * dynahash.c expects the partition number to be the low-order bits of
563 * the hash code, and therefore a PROCLOCKTAG's hash code must have the
564 * same low-order bits as the associated LOCKTAG's hash code. We achieve
565 * this with this specialized hash function.
566 */
567static uint32
568proclock_hash(const void *key, Size keysize)
569{
570 const PROCLOCKTAG *proclocktag = (const PROCLOCKTAG *) key;
571 uint32 lockhash;
572 Datum procptr;
573
574 Assert(keysize == sizeof(PROCLOCKTAG));
575
576 /* Look into the associated LOCK object, and compute its hash code */
577 lockhash = LockTagHashCode(&proclocktag->myLock->tag);
578
579 /*
580 * To make the hash code also depend on the PGPROC, we xor the proc
581 * struct's address into the hash code, left-shifted so that the
582 * partition-number bits don't change. Since this is only a hash, we
583 * don't care if we lose high-order bits of the address; use an
584 * intermediate variable to suppress cast-pointer-to-int warnings.
585 */
586 procptr = PointerGetDatum(proclocktag->myProc);
587 lockhash ^= ((uint32) procptr) << LOG2_NUM_LOCK_PARTITIONS;
588
589 return lockhash;
590}
591
592/*
593 * Compute the hash code associated with a PROCLOCKTAG, given the hashcode
594 * for its underlying LOCK.
595 *
596 * We use this just to avoid redundant calls of LockTagHashCode().
597 */
598static inline uint32
599ProcLockHashCode(const PROCLOCKTAG *proclocktag, uint32 hashcode)
600{
601 uint32 lockhash = hashcode;
602 Datum procptr;
603
604 /*
605 * This must match proclock_hash()!
606 */
607 procptr = PointerGetDatum(proclocktag->myProc);
608 lockhash ^= ((uint32) procptr) << LOG2_NUM_LOCK_PARTITIONS;
609
610 return lockhash;
611}
612
613/*
614 * Given two lock modes, return whether they would conflict.
615 */
616bool
618{
619 LockMethod lockMethodTable = LockMethods[DEFAULT_LOCKMETHOD];
620
621 if (lockMethodTable->conflictTab[mode1] & LOCKBIT_ON(mode2))
622 return true;
623
624 return false;
625}
626
627/*
628 * LockHeldByMe -- test whether lock 'locktag' is held by the current
629 * transaction
630 *
631 * Returns true if current transaction holds a lock on 'tag' of mode
632 * 'lockmode'. If 'orstronger' is true, a stronger lockmode is also OK.
633 * ("Stronger" is defined as "numerically higher", which is a bit
634 * semantically dubious but is OK for the purposes we use this for.)
635 */
636bool
637LockHeldByMe(const LOCKTAG *locktag,
638 LOCKMODE lockmode, bool orstronger)
639{
640 LOCALLOCKTAG localtag;
641 LOCALLOCK *locallock;
642
643 /*
644 * See if there is a LOCALLOCK entry for this lock and lockmode
645 */
646 MemSet(&localtag, 0, sizeof(localtag)); /* must clear padding */
647 localtag.lock = *locktag;
648 localtag.mode = lockmode;
649
651 &localtag,
652 HASH_FIND, NULL);
653
654 if (locallock && locallock->nLocks > 0)
655 return true;
656
657 if (orstronger)
658 {
659 LOCKMODE slockmode;
660
661 for (slockmode = lockmode + 1;
662 slockmode <= MaxLockMode;
663 slockmode++)
664 {
665 if (LockHeldByMe(locktag, slockmode, false))
666 return true;
667 }
668 }
669
670 return false;
671}
672
673#ifdef USE_ASSERT_CHECKING
674/*
675 * GetLockMethodLocalHash -- return the hash of local locks, for modules that
676 * evaluate assertions based on all locks held.
677 */
678HTAB *
679GetLockMethodLocalHash(void)
680{
681 return LockMethodLocalHash;
682}
683#endif
684
685/*
686 * LockHasWaiters -- look up 'locktag' and check if releasing this
687 * lock would wake up other processes waiting for it.
688 */
689bool
690LockHasWaiters(const LOCKTAG *locktag, LOCKMODE lockmode, bool sessionLock)
691{
692 LOCKMETHODID lockmethodid = locktag->locktag_lockmethodid;
693 LockMethod lockMethodTable;
694 LOCALLOCKTAG localtag;
695 LOCALLOCK *locallock;
696 LOCK *lock;
697 PROCLOCK *proclock;
698 LWLock *partitionLock;
699 bool hasWaiters = false;
700
701 if (lockmethodid <= 0 || lockmethodid >= lengthof(LockMethods))
702 elog(ERROR, "unrecognized lock method: %d", lockmethodid);
703 lockMethodTable = LockMethods[lockmethodid];
704 if (lockmode <= 0 || lockmode > lockMethodTable->numLockModes)
705 elog(ERROR, "unrecognized lock mode: %d", lockmode);
706
707#ifdef LOCK_DEBUG
708 if (LOCK_DEBUG_ENABLED(locktag))
709 elog(LOG, "LockHasWaiters: lock [%u,%u] %s",
710 locktag->locktag_field1, locktag->locktag_field2,
711 lockMethodTable->lockModeNames[lockmode]);
712#endif
713
714 /*
715 * Find the LOCALLOCK entry for this lock and lockmode
716 */
717 MemSet(&localtag, 0, sizeof(localtag)); /* must clear padding */
718 localtag.lock = *locktag;
719 localtag.mode = lockmode;
720
722 &localtag,
723 HASH_FIND, NULL);
724
725 /*
726 * let the caller print its own error message, too. Do not ereport(ERROR).
727 */
728 if (!locallock || locallock->nLocks <= 0)
729 {
730 elog(WARNING, "you don't own a lock of type %s",
731 lockMethodTable->lockModeNames[lockmode]);
732 return false;
733 }
734
735 /*
736 * Check the shared lock table.
737 */
738 partitionLock = LockHashPartitionLock(locallock->hashcode);
739
740 LWLockAcquire(partitionLock, LW_SHARED);
741
742 /*
743 * We don't need to re-find the lock or proclock, since we kept their
744 * addresses in the locallock table, and they couldn't have been removed
745 * while we were holding a lock on them.
746 */
747 lock = locallock->lock;
748 LOCK_PRINT("LockHasWaiters: found", lock, lockmode);
749 proclock = locallock->proclock;
750 PROCLOCK_PRINT("LockHasWaiters: found", proclock);
751
752 /*
753 * Double-check that we are actually holding a lock of the type we want to
754 * release.
755 */
756 if (!(proclock->holdMask & LOCKBIT_ON(lockmode)))
757 {
758 PROCLOCK_PRINT("LockHasWaiters: WRONGTYPE", proclock);
759 LWLockRelease(partitionLock);
760 elog(WARNING, "you don't own a lock of type %s",
761 lockMethodTable->lockModeNames[lockmode]);
762 RemoveLocalLock(locallock);
763 return false;
764 }
765
766 /*
767 * Do the checking.
768 */
769 if ((lockMethodTable->conflictTab[lockmode] & lock->waitMask) != 0)
770 hasWaiters = true;
771
772 LWLockRelease(partitionLock);
773
774 return hasWaiters;
775}
776
777/*
778 * LockAcquire -- Check for lock conflicts, sleep if conflict found,
779 * set lock if/when no conflicts.
780 *
781 * Inputs:
782 * locktag: unique identifier for the lockable object
783 * lockmode: lock mode to acquire
784 * sessionLock: if true, acquire lock for session not current transaction
785 * dontWait: if true, don't wait to acquire lock
786 *
787 * Returns one of:
788 * LOCKACQUIRE_NOT_AVAIL lock not available, and dontWait=true
789 * LOCKACQUIRE_OK lock successfully acquired
790 * LOCKACQUIRE_ALREADY_HELD incremented count for lock already held
791 * LOCKACQUIRE_ALREADY_CLEAR incremented count for lock already clear
792 *
793 * In the normal case where dontWait=false and the caller doesn't need to
794 * distinguish a freshly acquired lock from one already taken earlier in
795 * this same transaction, there is no need to examine the return value.
796 *
797 * Side Effects: The lock is acquired and recorded in lock tables.
798 *
799 * NOTE: if we wait for the lock, there is no way to abort the wait
800 * short of aborting the transaction.
801 */
803LockAcquire(const LOCKTAG *locktag,
804 LOCKMODE lockmode,
805 bool sessionLock,
806 bool dontWait)
807{
808 return LockAcquireExtended(locktag, lockmode, sessionLock, dontWait,
809 true, NULL);
810}
811
812/*
813 * LockAcquireExtended - allows us to specify additional options
814 *
815 * reportMemoryError specifies whether a lock request that fills the lock
816 * table should generate an ERROR or not. Passing "false" allows the caller
817 * to attempt to recover from lock-table-full situations, perhaps by forcibly
818 * canceling other lock holders and then retrying. Note, however, that the
819 * return code for that is LOCKACQUIRE_NOT_AVAIL, so that it's unsafe to use
820 * in combination with dontWait = true, as the cause of failure couldn't be
821 * distinguished.
822 *
823 * If locallockp isn't NULL, *locallockp receives a pointer to the LOCALLOCK
824 * table entry if a lock is successfully acquired, or NULL if not.
825 */
828 LOCKMODE lockmode,
829 bool sessionLock,
830 bool dontWait,
831 bool reportMemoryError,
832 LOCALLOCK **locallockp)
833{
834 LOCKMETHODID lockmethodid = locktag->locktag_lockmethodid;
835 LockMethod lockMethodTable;
836 LOCALLOCKTAG localtag;
837 LOCALLOCK *locallock;
838 LOCK *lock;
839 PROCLOCK *proclock;
840 bool found;
841 ResourceOwner owner;
842 uint32 hashcode;
843 LWLock *partitionLock;
844 bool found_conflict;
845 ProcWaitStatus waitResult;
846 bool log_lock = false;
847
848 if (lockmethodid <= 0 || lockmethodid >= lengthof(LockMethods))
849 elog(ERROR, "unrecognized lock method: %d", lockmethodid);
850 lockMethodTable = LockMethods[lockmethodid];
851 if (lockmode <= 0 || lockmode > lockMethodTable->numLockModes)
852 elog(ERROR, "unrecognized lock mode: %d", lockmode);
853
854 if (RecoveryInProgress() && !InRecovery &&
855 (locktag->locktag_type == LOCKTAG_OBJECT ||
856 locktag->locktag_type == LOCKTAG_RELATION) &&
857 lockmode > RowExclusiveLock)
859 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
860 errmsg("cannot acquire lock mode %s on database objects while recovery is in progress",
861 lockMethodTable->lockModeNames[lockmode]),
862 errhint("Only RowExclusiveLock or less can be acquired on database objects during recovery.")));
863
864#ifdef LOCK_DEBUG
865 if (LOCK_DEBUG_ENABLED(locktag))
866 elog(LOG, "LockAcquire: lock [%u,%u] %s",
867 locktag->locktag_field1, locktag->locktag_field2,
868 lockMethodTable->lockModeNames[lockmode]);
869#endif
870
871 /* Identify owner for lock */
872 if (sessionLock)
873 owner = NULL;
874 else
875 owner = CurrentResourceOwner;
876
877 /*
878 * Find or create a LOCALLOCK entry for this lock and lockmode
879 */
880 MemSet(&localtag, 0, sizeof(localtag)); /* must clear padding */
881 localtag.lock = *locktag;
882 localtag.mode = lockmode;
883
885 &localtag,
886 HASH_ENTER, &found);
887
888 /*
889 * if it's a new locallock object, initialize it
890 */
891 if (!found)
892 {
893 locallock->lock = NULL;
894 locallock->proclock = NULL;
895 locallock->hashcode = LockTagHashCode(&(localtag.lock));
896 locallock->nLocks = 0;
897 locallock->holdsStrongLockCount = false;
898 locallock->lockCleared = false;
899 locallock->numLockOwners = 0;
900 locallock->maxLockOwners = 8;
901 locallock->lockOwners = NULL; /* in case next line fails */
902 locallock->lockOwners = (LOCALLOCKOWNER *)
904 locallock->maxLockOwners * sizeof(LOCALLOCKOWNER));
905 }
906 else
907 {
908 /* Make sure there will be room to remember the lock */
909 if (locallock->numLockOwners >= locallock->maxLockOwners)
910 {
911 int newsize = locallock->maxLockOwners * 2;
912
913 locallock->lockOwners = (LOCALLOCKOWNER *)
914 repalloc(locallock->lockOwners,
915 newsize * sizeof(LOCALLOCKOWNER));
916 locallock->maxLockOwners = newsize;
917 }
918 }
919 hashcode = locallock->hashcode;
920
921 if (locallockp)
922 *locallockp = locallock;
923
924 /*
925 * If we already hold the lock, we can just increase the count locally.
926 *
927 * If lockCleared is already set, caller need not worry about absorbing
928 * sinval messages related to the lock's object.
929 */
930 if (locallock->nLocks > 0)
931 {
932 GrantLockLocal(locallock, owner);
933 if (locallock->lockCleared)
935 else
937 }
938
939 /*
940 * We don't acquire any other heavyweight lock while holding the relation
941 * extension lock. We do allow to acquire the same relation extension
942 * lock more than once but that case won't reach here.
943 */
944 Assert(!IsRelationExtensionLockHeld);
945
946 /*
947 * Prepare to emit a WAL record if acquisition of this lock needs to be
948 * replayed in a standby server.
949 *
950 * Here we prepare to log; after lock is acquired we'll issue log record.
951 * This arrangement simplifies error recovery in case the preparation step
952 * fails.
953 *
954 * Only AccessExclusiveLocks can conflict with lock types that read-only
955 * transactions can acquire in a standby server. Make sure this definition
956 * matches the one in GetRunningTransactionLocks().
957 */
958 if (lockmode >= AccessExclusiveLock &&
959 locktag->locktag_type == LOCKTAG_RELATION &&
962 {
964 log_lock = true;
965 }
966
967 /*
968 * Attempt to take lock via fast path, if eligible. But if we remember
969 * having filled up the fast path array, we don't attempt to make any
970 * further use of it until we release some locks. It's possible that some
971 * other backend has transferred some of those locks to the shared hash
972 * table, leaving space free, but it's not worth acquiring the LWLock just
973 * to check. It's also possible that we're acquiring a second or third
974 * lock type on a relation we have already locked using the fast-path, but
975 * for now we don't worry about that case either.
976 */
977 if (EligibleForRelationFastPath(locktag, lockmode) &&
979 {
980 uint32 fasthashcode = FastPathStrongLockHashPartition(hashcode);
981 bool acquired;
982
983 /*
984 * LWLockAcquire acts as a memory sequencing point, so it's safe to
985 * assume that any strong locker whose increment to
986 * FastPathStrongRelationLocks->counts becomes visible after we test
987 * it has yet to begin to transfer fast-path locks.
988 */
990 if (FastPathStrongRelationLocks->count[fasthashcode] != 0)
991 acquired = false;
992 else
993 acquired = FastPathGrantRelationLock(locktag->locktag_field2,
994 lockmode);
996 if (acquired)
997 {
998 /*
999 * The locallock might contain stale pointers to some old shared
1000 * objects; we MUST reset these to null before considering the
1001 * lock to be acquired via fast-path.
1002 */
1003 locallock->lock = NULL;
1004 locallock->proclock = NULL;
1005 GrantLockLocal(locallock, owner);
1006 return LOCKACQUIRE_OK;
1007 }
1008 }
1009
1010 /*
1011 * If this lock could potentially have been taken via the fast-path by
1012 * some other backend, we must (temporarily) disable further use of the
1013 * fast-path for this lock tag, and migrate any locks already taken via
1014 * this method to the main lock table.
1015 */
1016 if (ConflictsWithRelationFastPath(locktag, lockmode))
1017 {
1018 uint32 fasthashcode = FastPathStrongLockHashPartition(hashcode);
1019
1020 BeginStrongLockAcquire(locallock, fasthashcode);
1021 if (!FastPathTransferRelationLocks(lockMethodTable, locktag,
1022 hashcode))
1023 {
1025 if (locallock->nLocks == 0)
1026 RemoveLocalLock(locallock);
1027 if (locallockp)
1028 *locallockp = NULL;
1029 if (reportMemoryError)
1030 ereport(ERROR,
1031 (errcode(ERRCODE_OUT_OF_MEMORY),
1032 errmsg("out of shared memory"),
1033 errhint("You might need to increase \"%s\".", "max_locks_per_transaction")));
1034 else
1035 return LOCKACQUIRE_NOT_AVAIL;
1036 }
1037 }
1038
1039 /*
1040 * We didn't find the lock in our LOCALLOCK table, and we didn't manage to
1041 * take it via the fast-path, either, so we've got to mess with the shared
1042 * lock table.
1043 */
1044 partitionLock = LockHashPartitionLock(hashcode);
1045
1046 LWLockAcquire(partitionLock, LW_EXCLUSIVE);
1047
1048 /*
1049 * Find or create lock and proclock entries with this tag
1050 *
1051 * Note: if the locallock object already existed, it might have a pointer
1052 * to the lock already ... but we should not assume that that pointer is
1053 * valid, since a lock object with zero hold and request counts can go
1054 * away anytime. So we have to use SetupLockInTable() to recompute the
1055 * lock and proclock pointers, even if they're already set.
1056 */
1057 proclock = SetupLockInTable(lockMethodTable, MyProc, locktag,
1058 hashcode, lockmode);
1059 if (!proclock)
1060 {
1062 LWLockRelease(partitionLock);
1063 if (locallock->nLocks == 0)
1064 RemoveLocalLock(locallock);
1065 if (locallockp)
1066 *locallockp = NULL;
1067 if (reportMemoryError)
1068 ereport(ERROR,
1069 (errcode(ERRCODE_OUT_OF_MEMORY),
1070 errmsg("out of shared memory"),
1071 errhint("You might need to increase \"%s\".", "max_locks_per_transaction")));
1072 else
1073 return LOCKACQUIRE_NOT_AVAIL;
1074 }
1075 locallock->proclock = proclock;
1076 lock = proclock->tag.myLock;
1077 locallock->lock = lock;
1078
1079 /*
1080 * If lock requested conflicts with locks requested by waiters, must join
1081 * wait queue. Otherwise, check for conflict with already-held locks.
1082 * (That's last because most complex check.)
1083 */
1084 if (lockMethodTable->conflictTab[lockmode] & lock->waitMask)
1085 found_conflict = true;
1086 else
1087 found_conflict = LockCheckConflicts(lockMethodTable, lockmode,
1088 lock, proclock);
1089
1090 if (!found_conflict)
1091 {
1092 /* No conflict with held or previously requested locks */
1093 GrantLock(lock, proclock, lockmode);
1094 waitResult = PROC_WAIT_STATUS_OK;
1095 }
1096 else
1097 {
1098 /*
1099 * Join the lock's wait queue. We call this even in the dontWait
1100 * case, because JoinWaitQueue() may discover that we can acquire the
1101 * lock immediately after all.
1102 */
1103 waitResult = JoinWaitQueue(locallock, lockMethodTable, dontWait);
1104 }
1105
1106 if (waitResult == PROC_WAIT_STATUS_ERROR)
1107 {
1108 /*
1109 * We're not getting the lock because a deadlock was detected already
1110 * while trying to join the wait queue, or because we would have to
1111 * wait but the caller requested no blocking.
1112 *
1113 * Undo the changes to shared entries before releasing the partition
1114 * lock.
1115 */
1117
1118 if (proclock->holdMask == 0)
1119 {
1120 uint32 proclock_hashcode;
1121
1122 proclock_hashcode = ProcLockHashCode(&proclock->tag,
1123 hashcode);
1124 dlist_delete(&proclock->lockLink);
1125 dlist_delete(&proclock->procLink);
1127 &(proclock->tag),
1128 proclock_hashcode,
1130 NULL))
1131 elog(PANIC, "proclock table corrupted");
1132 }
1133 else
1134 PROCLOCK_PRINT("LockAcquire: did not join wait queue", proclock);
1135 lock->nRequested--;
1136 lock->requested[lockmode]--;
1137 LOCK_PRINT("LockAcquire: did not join wait queue",
1138 lock, lockmode);
1139 Assert((lock->nRequested > 0) &&
1140 (lock->requested[lockmode] >= 0));
1141 Assert(lock->nGranted <= lock->nRequested);
1142 LWLockRelease(partitionLock);
1143 if (locallock->nLocks == 0)
1144 RemoveLocalLock(locallock);
1145
1146 if (dontWait)
1147 {
1148 if (locallockp)
1149 *locallockp = NULL;
1150 return LOCKACQUIRE_NOT_AVAIL;
1151 }
1152 else
1153 {
1155 /* DeadLockReport() will not return */
1156 }
1157 }
1158
1159 /*
1160 * We are now in the lock queue, or the lock was already granted. If
1161 * queued, go to sleep.
1162 */
1163 if (waitResult == PROC_WAIT_STATUS_WAITING)
1164 {
1165 Assert(!dontWait);
1166 PROCLOCK_PRINT("LockAcquire: sleeping on lock", proclock);
1167 LOCK_PRINT("LockAcquire: sleeping on lock", lock, lockmode);
1168 LWLockRelease(partitionLock);
1169
1170 waitResult = WaitOnLock(locallock, owner);
1171
1172 /*
1173 * NOTE: do not do any material change of state between here and
1174 * return. All required changes in locktable state must have been
1175 * done when the lock was granted to us --- see notes in WaitOnLock.
1176 */
1177
1178 if (waitResult == PROC_WAIT_STATUS_ERROR)
1179 {
1180 /*
1181 * We failed as a result of a deadlock, see CheckDeadLock(). Quit
1182 * now.
1183 */
1184 Assert(!dontWait);
1186 /* DeadLockReport() will not return */
1187 }
1188 }
1189 else
1190 LWLockRelease(partitionLock);
1191 Assert(waitResult == PROC_WAIT_STATUS_OK);
1192
1193 /* The lock was granted to us. Update the local lock entry accordingly */
1194 Assert((proclock->holdMask & LOCKBIT_ON(lockmode)) != 0);
1195 GrantLockLocal(locallock, owner);
1196
1197 /*
1198 * Lock state is fully up-to-date now; if we error out after this, no
1199 * special error cleanup is required.
1200 */
1202
1203 /*
1204 * Emit a WAL record if acquisition of this lock needs to be replayed in a
1205 * standby server.
1206 */
1207 if (log_lock)
1208 {
1209 /*
1210 * Decode the locktag back to the original values, to avoid sending
1211 * lots of empty bytes with every message. See lock.h to check how a
1212 * locktag is defined for LOCKTAG_RELATION
1213 */
1215 locktag->locktag_field2);
1216 }
1217
1218 return LOCKACQUIRE_OK;
1219}
1220
1221/*
1222 * Find or create LOCK and PROCLOCK objects as needed for a new lock
1223 * request.
1224 *
1225 * Returns the PROCLOCK object, or NULL if we failed to create the objects
1226 * for lack of shared memory.
1227 *
1228 * The appropriate partition lock must be held at entry, and will be
1229 * held at exit.
1230 */
1231static PROCLOCK *
1232SetupLockInTable(LockMethod lockMethodTable, PGPROC *proc,
1233 const LOCKTAG *locktag, uint32 hashcode, LOCKMODE lockmode)
1234{
1235 LOCK *lock;
1236 PROCLOCK *proclock;
1237 PROCLOCKTAG proclocktag;
1238 uint32 proclock_hashcode;
1239 bool found;
1240
1241 /*
1242 * Find or create a lock with this tag.
1243 */
1245 locktag,
1246 hashcode,
1248 &found);
1249 if (!lock)
1250 return NULL;
1251
1252 /*
1253 * if it's a new lock object, initialize it
1254 */
1255 if (!found)
1256 {
1257 lock->grantMask = 0;
1258 lock->waitMask = 0;
1259 dlist_init(&lock->procLocks);
1260 dclist_init(&lock->waitProcs);
1261 lock->nRequested = 0;
1262 lock->nGranted = 0;
1263 MemSet(lock->requested, 0, sizeof(int) * MAX_LOCKMODES);
1264 MemSet(lock->granted, 0, sizeof(int) * MAX_LOCKMODES);
1265 LOCK_PRINT("LockAcquire: new", lock, lockmode);
1266 }
1267 else
1268 {
1269 LOCK_PRINT("LockAcquire: found", lock, lockmode);
1270 Assert((lock->nRequested >= 0) && (lock->requested[lockmode] >= 0));
1271 Assert((lock->nGranted >= 0) && (lock->granted[lockmode] >= 0));
1272 Assert(lock->nGranted <= lock->nRequested);
1273 }
1274
1275 /*
1276 * Create the hash key for the proclock table.
1277 */
1278 proclocktag.myLock = lock;
1279 proclocktag.myProc = proc;
1280
1281 proclock_hashcode = ProcLockHashCode(&proclocktag, hashcode);
1282
1283 /*
1284 * Find or create a proclock entry with this tag
1285 */
1287 &proclocktag,
1288 proclock_hashcode,
1290 &found);
1291 if (!proclock)
1292 {
1293 /* Oops, not enough shmem for the proclock */
1294 if (lock->nRequested == 0)
1295 {
1296 /*
1297 * There are no other requestors of this lock, so garbage-collect
1298 * the lock object. We *must* do this to avoid a permanent leak
1299 * of shared memory, because there won't be anything to cause
1300 * anyone to release the lock object later.
1301 */
1302 Assert(dlist_is_empty(&(lock->procLocks)));
1304 &(lock->tag),
1305 hashcode,
1307 NULL))
1308 elog(PANIC, "lock table corrupted");
1309 }
1310 return NULL;
1311 }
1312
1313 /*
1314 * If new, initialize the new entry
1315 */
1316 if (!found)
1317 {
1318 uint32 partition = LockHashPartition(hashcode);
1319
1320 /*
1321 * It might seem unsafe to access proclock->groupLeader without a
1322 * lock, but it's not really. Either we are initializing a proclock
1323 * on our own behalf, in which case our group leader isn't changing
1324 * because the group leader for a process can only ever be changed by
1325 * the process itself; or else we are transferring a fast-path lock to
1326 * the main lock table, in which case that process can't change it's
1327 * lock group leader without first releasing all of its locks (and in
1328 * particular the one we are currently transferring).
1329 */
1330 proclock->groupLeader = proc->lockGroupLeader != NULL ?
1331 proc->lockGroupLeader : proc;
1332 proclock->holdMask = 0;
1333 proclock->releaseMask = 0;
1334 /* Add proclock to appropriate lists */
1335 dlist_push_tail(&lock->procLocks, &proclock->lockLink);
1336 dlist_push_tail(&proc->myProcLocks[partition], &proclock->procLink);
1337 PROCLOCK_PRINT("LockAcquire: new", proclock);
1338 }
1339 else
1340 {
1341 PROCLOCK_PRINT("LockAcquire: found", proclock);
1342 Assert((proclock->holdMask & ~lock->grantMask) == 0);
1343
1344#ifdef CHECK_DEADLOCK_RISK
1345
1346 /*
1347 * Issue warning if we already hold a lower-level lock on this object
1348 * and do not hold a lock of the requested level or higher. This
1349 * indicates a deadlock-prone coding practice (eg, we'd have a
1350 * deadlock if another backend were following the same code path at
1351 * about the same time).
1352 *
1353 * This is not enabled by default, because it may generate log entries
1354 * about user-level coding practices that are in fact safe in context.
1355 * It can be enabled to help find system-level problems.
1356 *
1357 * XXX Doing numeric comparison on the lockmodes is a hack; it'd be
1358 * better to use a table. For now, though, this works.
1359 */
1360 {
1361 int i;
1362
1363 for (i = lockMethodTable->numLockModes; i > 0; i--)
1364 {
1365 if (proclock->holdMask & LOCKBIT_ON(i))
1366 {
1367 if (i >= (int) lockmode)
1368 break; /* safe: we have a lock >= req level */
1369 elog(LOG, "deadlock risk: raising lock level"
1370 " from %s to %s on object %u/%u/%u",
1371 lockMethodTable->lockModeNames[i],
1372 lockMethodTable->lockModeNames[lockmode],
1373 lock->tag.locktag_field1, lock->tag.locktag_field2,
1374 lock->tag.locktag_field3);
1375 break;
1376 }
1377 }
1378 }
1379#endif /* CHECK_DEADLOCK_RISK */
1380 }
1381
1382 /*
1383 * lock->nRequested and lock->requested[] count the total number of
1384 * requests, whether granted or waiting, so increment those immediately.
1385 * The other counts don't increment till we get the lock.
1386 */
1387 lock->nRequested++;
1388 lock->requested[lockmode]++;
1389 Assert((lock->nRequested > 0) && (lock->requested[lockmode] > 0));
1390
1391 /*
1392 * We shouldn't already hold the desired lock; else locallock table is
1393 * broken.
1394 */
1395 if (proclock->holdMask & LOCKBIT_ON(lockmode))
1396 elog(ERROR, "lock %s on object %u/%u/%u is already held",
1397 lockMethodTable->lockModeNames[lockmode],
1398 lock->tag.locktag_field1, lock->tag.locktag_field2,
1399 lock->tag.locktag_field3);
1400
1401 return proclock;
1402}
1403
1404/*
1405 * Check and set/reset the flag that we hold the relation extension lock.
1406 *
1407 * It is callers responsibility that this function is called after
1408 * acquiring/releasing the relation extension lock.
1409 *
1410 * Pass acquired as true if lock is acquired, false otherwise.
1411 */
1412static inline void
1413CheckAndSetLockHeld(LOCALLOCK *locallock, bool acquired)
1414{
1415#ifdef USE_ASSERT_CHECKING
1416 if (LOCALLOCK_LOCKTAG(*locallock) == LOCKTAG_RELATION_EXTEND)
1417 IsRelationExtensionLockHeld = acquired;
1418#endif
1419}
1420
1421/*
1422 * Subroutine to free a locallock entry
1423 */
1424static void
1426{
1427 int i;
1428
1429 for (i = locallock->numLockOwners - 1; i >= 0; i--)
1430 {
1431 if (locallock->lockOwners[i].owner != NULL)
1432 ResourceOwnerForgetLock(locallock->lockOwners[i].owner, locallock);
1433 }
1434 locallock->numLockOwners = 0;
1435 if (locallock->lockOwners != NULL)
1436 pfree(locallock->lockOwners);
1437 locallock->lockOwners = NULL;
1438
1439 if (locallock->holdsStrongLockCount)
1440 {
1441 uint32 fasthashcode;
1442
1443 fasthashcode = FastPathStrongLockHashPartition(locallock->hashcode);
1444
1446 Assert(FastPathStrongRelationLocks->count[fasthashcode] > 0);
1447 FastPathStrongRelationLocks->count[fasthashcode]--;
1448 locallock->holdsStrongLockCount = false;
1450 }
1451
1453 &(locallock->tag),
1454 HASH_REMOVE, NULL))
1455 elog(WARNING, "locallock table corrupted");
1456
1457 /*
1458 * Indicate that the lock is released for certain types of locks
1459 */
1460 CheckAndSetLockHeld(locallock, false);
1461}
1462
1463/*
1464 * LockCheckConflicts -- test whether requested lock conflicts
1465 * with those already granted
1466 *
1467 * Returns true if conflict, false if no conflict.
1468 *
1469 * NOTES:
1470 * Here's what makes this complicated: one process's locks don't
1471 * conflict with one another, no matter what purpose they are held for
1472 * (eg, session and transaction locks do not conflict). Nor do the locks
1473 * of one process in a lock group conflict with those of another process in
1474 * the same group. So, we must subtract off these locks when determining
1475 * whether the requested new lock conflicts with those already held.
1476 */
1477bool
1479 LOCKMODE lockmode,
1480 LOCK *lock,
1481 PROCLOCK *proclock)
1482{
1483 int numLockModes = lockMethodTable->numLockModes;
1484 LOCKMASK myLocks;
1485 int conflictMask = lockMethodTable->conflictTab[lockmode];
1486 int conflictsRemaining[MAX_LOCKMODES];
1487 int totalConflictsRemaining = 0;
1488 dlist_iter proclock_iter;
1489 int i;
1490
1491 /*
1492 * first check for global conflicts: If no locks conflict with my request,
1493 * then I get the lock.
1494 *
1495 * Checking for conflict: lock->grantMask represents the types of
1496 * currently held locks. conflictTable[lockmode] has a bit set for each
1497 * type of lock that conflicts with request. Bitwise compare tells if
1498 * there is a conflict.
1499 */
1500 if (!(conflictMask & lock->grantMask))
1501 {
1502 PROCLOCK_PRINT("LockCheckConflicts: no conflict", proclock);
1503 return false;
1504 }
1505
1506 /*
1507 * Rats. Something conflicts. But it could still be my own lock, or a
1508 * lock held by another member of my locking group. First, figure out how
1509 * many conflicts remain after subtracting out any locks I hold myself.
1510 */
1511 myLocks = proclock->holdMask;
1512 for (i = 1; i <= numLockModes; i++)
1513 {
1514 if ((conflictMask & LOCKBIT_ON(i)) == 0)
1515 {
1516 conflictsRemaining[i] = 0;
1517 continue;
1518 }
1519 conflictsRemaining[i] = lock->granted[i];
1520 if (myLocks & LOCKBIT_ON(i))
1521 --conflictsRemaining[i];
1522 totalConflictsRemaining += conflictsRemaining[i];
1523 }
1524
1525 /* If no conflicts remain, we get the lock. */
1526 if (totalConflictsRemaining == 0)
1527 {
1528 PROCLOCK_PRINT("LockCheckConflicts: resolved (simple)", proclock);
1529 return false;
1530 }
1531
1532 /* If no group locking, it's definitely a conflict. */
1533 if (proclock->groupLeader == MyProc && MyProc->lockGroupLeader == NULL)
1534 {
1535 Assert(proclock->tag.myProc == MyProc);
1536 PROCLOCK_PRINT("LockCheckConflicts: conflicting (simple)",
1537 proclock);
1538 return true;
1539 }
1540
1541 /*
1542 * The relation extension lock conflict even between the group members.
1543 */
1545 {
1546 PROCLOCK_PRINT("LockCheckConflicts: conflicting (group)",
1547 proclock);
1548 return true;
1549 }
1550
1551 /*
1552 * Locks held in conflicting modes by members of our own lock group are
1553 * not real conflicts; we can subtract those out and see if we still have
1554 * a conflict. This is O(N) in the number of processes holding or
1555 * awaiting locks on this object. We could improve that by making the
1556 * shared memory state more complex (and larger) but it doesn't seem worth
1557 * it.
1558 */
1559 dlist_foreach(proclock_iter, &lock->procLocks)
1560 {
1561 PROCLOCK *otherproclock =
1562 dlist_container(PROCLOCK, lockLink, proclock_iter.cur);
1563
1564 if (proclock != otherproclock &&
1565 proclock->groupLeader == otherproclock->groupLeader &&
1566 (otherproclock->holdMask & conflictMask) != 0)
1567 {
1568 int intersectMask = otherproclock->holdMask & conflictMask;
1569
1570 for (i = 1; i <= numLockModes; i++)
1571 {
1572 if ((intersectMask & LOCKBIT_ON(i)) != 0)
1573 {
1574 if (conflictsRemaining[i] <= 0)
1575 elog(PANIC, "proclocks held do not match lock");
1576 conflictsRemaining[i]--;
1577 totalConflictsRemaining--;
1578 }
1579 }
1580
1581 if (totalConflictsRemaining == 0)
1582 {
1583 PROCLOCK_PRINT("LockCheckConflicts: resolved (group)",
1584 proclock);
1585 return false;
1586 }
1587 }
1588 }
1589
1590 /* Nope, it's a real conflict. */
1591 PROCLOCK_PRINT("LockCheckConflicts: conflicting (group)", proclock);
1592 return true;
1593}
1594
1595/*
1596 * GrantLock -- update the lock and proclock data structures to show
1597 * the lock request has been granted.
1598 *
1599 * NOTE: if proc was blocked, it also needs to be removed from the wait list
1600 * and have its waitLock/waitProcLock fields cleared. That's not done here.
1601 *
1602 * NOTE: the lock grant also has to be recorded in the associated LOCALLOCK
1603 * table entry; but since we may be awaking some other process, we can't do
1604 * that here; it's done by GrantLockLocal, instead.
1605 */
1606void
1607GrantLock(LOCK *lock, PROCLOCK *proclock, LOCKMODE lockmode)
1608{
1609 lock->nGranted++;
1610 lock->granted[lockmode]++;
1611 lock->grantMask |= LOCKBIT_ON(lockmode);
1612 if (lock->granted[lockmode] == lock->requested[lockmode])
1613 lock->waitMask &= LOCKBIT_OFF(lockmode);
1614 proclock->holdMask |= LOCKBIT_ON(lockmode);
1615 LOCK_PRINT("GrantLock", lock, lockmode);
1616 Assert((lock->nGranted > 0) && (lock->granted[lockmode] > 0));
1617 Assert(lock->nGranted <= lock->nRequested);
1618}
1619
1620/*
1621 * UnGrantLock -- opposite of GrantLock.
1622 *
1623 * Updates the lock and proclock data structures to show that the lock
1624 * is no longer held nor requested by the current holder.
1625 *
1626 * Returns true if there were any waiters waiting on the lock that
1627 * should now be woken up with ProcLockWakeup.
1628 */
1629static bool
1630UnGrantLock(LOCK *lock, LOCKMODE lockmode,
1631 PROCLOCK *proclock, LockMethod lockMethodTable)
1632{
1633 bool wakeupNeeded = false;
1634
1635 Assert((lock->nRequested > 0) && (lock->requested[lockmode] > 0));
1636 Assert((lock->nGranted > 0) && (lock->granted[lockmode] > 0));
1637 Assert(lock->nGranted <= lock->nRequested);
1638
1639 /*
1640 * fix the general lock stats
1641 */
1642 lock->nRequested--;
1643 lock->requested[lockmode]--;
1644 lock->nGranted--;
1645 lock->granted[lockmode]--;
1646
1647 if (lock->granted[lockmode] == 0)
1648 {
1649 /* change the conflict mask. No more of this lock type. */
1650 lock->grantMask &= LOCKBIT_OFF(lockmode);
1651 }
1652
1653 LOCK_PRINT("UnGrantLock: updated", lock, lockmode);
1654
1655 /*
1656 * We need only run ProcLockWakeup if the released lock conflicts with at
1657 * least one of the lock types requested by waiter(s). Otherwise whatever
1658 * conflict made them wait must still exist. NOTE: before MVCC, we could
1659 * skip wakeup if lock->granted[lockmode] was still positive. But that's
1660 * not true anymore, because the remaining granted locks might belong to
1661 * some waiter, who could now be awakened because he doesn't conflict with
1662 * his own locks.
1663 */
1664 if (lockMethodTable->conflictTab[lockmode] & lock->waitMask)
1665 wakeupNeeded = true;
1666
1667 /*
1668 * Now fix the per-proclock state.
1669 */
1670 proclock->holdMask &= LOCKBIT_OFF(lockmode);
1671 PROCLOCK_PRINT("UnGrantLock: updated", proclock);
1672
1673 return wakeupNeeded;
1674}
1675
1676/*
1677 * CleanUpLock -- clean up after releasing a lock. We garbage-collect the
1678 * proclock and lock objects if possible, and call ProcLockWakeup if there
1679 * are remaining requests and the caller says it's OK. (Normally, this
1680 * should be called after UnGrantLock, and wakeupNeeded is the result from
1681 * UnGrantLock.)
1682 *
1683 * The appropriate partition lock must be held at entry, and will be
1684 * held at exit.
1685 */
1686static void
1687CleanUpLock(LOCK *lock, PROCLOCK *proclock,
1688 LockMethod lockMethodTable, uint32 hashcode,
1689 bool wakeupNeeded)
1690{
1691 /*
1692 * If this was my last hold on this lock, delete my entry in the proclock
1693 * table.
1694 */
1695 if (proclock->holdMask == 0)
1696 {
1697 uint32 proclock_hashcode;
1698
1699 PROCLOCK_PRINT("CleanUpLock: deleting", proclock);
1700 dlist_delete(&proclock->lockLink);
1701 dlist_delete(&proclock->procLink);
1702 proclock_hashcode = ProcLockHashCode(&proclock->tag, hashcode);
1704 &(proclock->tag),
1705 proclock_hashcode,
1707 NULL))
1708 elog(PANIC, "proclock table corrupted");
1709 }
1710
1711 if (lock->nRequested == 0)
1712 {
1713 /*
1714 * The caller just released the last lock, so garbage-collect the lock
1715 * object.
1716 */
1717 LOCK_PRINT("CleanUpLock: deleting", lock, 0);
1720 &(lock->tag),
1721 hashcode,
1723 NULL))
1724 elog(PANIC, "lock table corrupted");
1725 }
1726 else if (wakeupNeeded)
1727 {
1728 /* There are waiters on this lock, so wake them up. */
1729 ProcLockWakeup(lockMethodTable, lock);
1730 }
1731}
1732
1733/*
1734 * GrantLockLocal -- update the locallock data structures to show
1735 * the lock request has been granted.
1736 *
1737 * We expect that LockAcquire made sure there is room to add a new
1738 * ResourceOwner entry.
1739 */
1740static void
1742{
1743 LOCALLOCKOWNER *lockOwners = locallock->lockOwners;
1744 int i;
1745
1746 Assert(locallock->numLockOwners < locallock->maxLockOwners);
1747 /* Count the total */
1748 locallock->nLocks++;
1749 /* Count the per-owner lock */
1750 for (i = 0; i < locallock->numLockOwners; i++)
1751 {
1752 if (lockOwners[i].owner == owner)
1753 {
1754 lockOwners[i].nLocks++;
1755 return;
1756 }
1757 }
1758 lockOwners[i].owner = owner;
1759 lockOwners[i].nLocks = 1;
1760 locallock->numLockOwners++;
1761 if (owner != NULL)
1762 ResourceOwnerRememberLock(owner, locallock);
1763
1764 /* Indicate that the lock is acquired for certain types of locks. */
1765 CheckAndSetLockHeld(locallock, true);
1766}
1767
1768/*
1769 * BeginStrongLockAcquire - inhibit use of fastpath for a given LOCALLOCK,
1770 * and arrange for error cleanup if it fails
1771 */
1772static void
1773BeginStrongLockAcquire(LOCALLOCK *locallock, uint32 fasthashcode)
1774{
1776 Assert(locallock->holdsStrongLockCount == false);
1777
1778 /*
1779 * Adding to a memory location is not atomic, so we take a spinlock to
1780 * ensure we don't collide with someone else trying to bump the count at
1781 * the same time.
1782 *
1783 * XXX: It might be worth considering using an atomic fetch-and-add
1784 * instruction here, on architectures where that is supported.
1785 */
1786
1788 FastPathStrongRelationLocks->count[fasthashcode]++;
1789 locallock->holdsStrongLockCount = true;
1790 StrongLockInProgress = locallock;
1792}
1793
1794/*
1795 * FinishStrongLockAcquire - cancel pending cleanup for a strong lock
1796 * acquisition once it's no longer needed
1797 */
1798static void
1800{
1801 StrongLockInProgress = NULL;
1802}
1803
1804/*
1805 * AbortStrongLockAcquire - undo strong lock state changes performed by
1806 * BeginStrongLockAcquire.
1807 */
1808void
1810{
1811 uint32 fasthashcode;
1812 LOCALLOCK *locallock = StrongLockInProgress;
1813
1814 if (locallock == NULL)
1815 return;
1816
1817 fasthashcode = FastPathStrongLockHashPartition(locallock->hashcode);
1818 Assert(locallock->holdsStrongLockCount == true);
1820 Assert(FastPathStrongRelationLocks->count[fasthashcode] > 0);
1821 FastPathStrongRelationLocks->count[fasthashcode]--;
1822 locallock->holdsStrongLockCount = false;
1823 StrongLockInProgress = NULL;
1825}
1826
1827/*
1828 * GrantAwaitedLock -- call GrantLockLocal for the lock we are doing
1829 * WaitOnLock on.
1830 *
1831 * proc.c needs this for the case where we are booted off the lock by
1832 * timeout, but discover that someone granted us the lock anyway.
1833 *
1834 * We could just export GrantLockLocal, but that would require including
1835 * resowner.h in lock.h, which creates circularity.
1836 */
1837void
1839{
1841}
1842
1843/*
1844 * GetAwaitedLock -- Return the lock we're currently doing WaitOnLock on.
1845 */
1846LOCALLOCK *
1848{
1849 return awaitedLock;
1850}
1851
1852/*
1853 * MarkLockClear -- mark an acquired lock as "clear"
1854 *
1855 * This means that we know we have absorbed all sinval messages that other
1856 * sessions generated before we acquired this lock, and so we can confidently
1857 * assume we know about any catalog changes protected by this lock.
1858 */
1859void
1861{
1862 Assert(locallock->nLocks > 0);
1863 locallock->lockCleared = true;
1864}
1865
1866/*
1867 * WaitOnLock -- wait to acquire a lock
1868 *
1869 * This is a wrapper around ProcSleep, with extra tracing and bookkeeping.
1870 */
1871static ProcWaitStatus
1873{
1874 ProcWaitStatus result;
1875
1876 TRACE_POSTGRESQL_LOCK_WAIT_START(locallock->tag.lock.locktag_field1,
1877 locallock->tag.lock.locktag_field2,
1878 locallock->tag.lock.locktag_field3,
1879 locallock->tag.lock.locktag_field4,
1880 locallock->tag.lock.locktag_type,
1881 locallock->tag.mode);
1882
1883 /* adjust the process title to indicate that it's waiting */
1884 set_ps_display_suffix("waiting");
1885
1886 /*
1887 * Record the fact that we are waiting for a lock, so that
1888 * LockErrorCleanup will clean up if cancel/die happens.
1889 */
1890 awaitedLock = locallock;
1891 awaitedOwner = owner;
1892
1893 /*
1894 * NOTE: Think not to put any shared-state cleanup after the call to
1895 * ProcSleep, in either the normal or failure path. The lock state must
1896 * be fully set by the lock grantor, or by CheckDeadLock if we give up
1897 * waiting for the lock. This is necessary because of the possibility
1898 * that a cancel/die interrupt will interrupt ProcSleep after someone else
1899 * grants us the lock, but before we've noticed it. Hence, after granting,
1900 * the locktable state must fully reflect the fact that we own the lock;
1901 * we can't do additional work on return.
1902 *
1903 * We can and do use a PG_TRY block to try to clean up after failure, but
1904 * this still has a major limitation: elog(FATAL) can occur while waiting
1905 * (eg, a "die" interrupt), and then control won't come back here. So all
1906 * cleanup of essential state should happen in LockErrorCleanup, not here.
1907 * We can use PG_TRY to clear the "waiting" status flags, since doing that
1908 * is unimportant if the process exits.
1909 */
1910 PG_TRY();
1911 {
1912 result = ProcSleep(locallock);
1913 }
1914 PG_CATCH();
1915 {
1916 /* In this path, awaitedLock remains set until LockErrorCleanup */
1917
1918 /* reset ps display to remove the suffix */
1920
1921 /* and propagate the error */
1922 PG_RE_THROW();
1923 }
1924 PG_END_TRY();
1925
1926 /*
1927 * We no longer want LockErrorCleanup to do anything.
1928 */
1929 awaitedLock = NULL;
1930
1931 /* reset ps display to remove the suffix */
1933
1934 TRACE_POSTGRESQL_LOCK_WAIT_DONE(locallock->tag.lock.locktag_field1,
1935 locallock->tag.lock.locktag_field2,
1936 locallock->tag.lock.locktag_field3,
1937 locallock->tag.lock.locktag_field4,
1938 locallock->tag.lock.locktag_type,
1939 locallock->tag.mode);
1940
1941 return result;
1942}
1943
1944/*
1945 * Remove a proc from the wait-queue it is on (caller must know it is on one).
1946 * This is only used when the proc has failed to get the lock, so we set its
1947 * waitStatus to PROC_WAIT_STATUS_ERROR.
1948 *
1949 * Appropriate partition lock must be held by caller. Also, caller is
1950 * responsible for signaling the proc if needed.
1951 *
1952 * NB: this does not clean up any locallock object that may exist for the lock.
1953 */
1954void
1956{
1957 LOCK *waitLock = proc->waitLock;
1958 PROCLOCK *proclock = proc->waitProcLock;
1959 LOCKMODE lockmode = proc->waitLockMode;
1960 LOCKMETHODID lockmethodid = LOCK_LOCKMETHOD(*waitLock);
1961
1962 /* Make sure proc is waiting */
1964 Assert(proc->links.next != NULL);
1965 Assert(waitLock);
1966 Assert(!dclist_is_empty(&waitLock->waitProcs));
1967 Assert(0 < lockmethodid && lockmethodid < lengthof(LockMethods));
1968
1969 /* Remove proc from lock's wait queue */
1970 dclist_delete_from_thoroughly(&waitLock->waitProcs, &proc->links);
1971
1972 /* Undo increments of request counts by waiting process */
1973 Assert(waitLock->nRequested > 0);
1974 Assert(waitLock->nRequested > proc->waitLock->nGranted);
1975 waitLock->nRequested--;
1976 Assert(waitLock->requested[lockmode] > 0);
1977 waitLock->requested[lockmode]--;
1978 /* don't forget to clear waitMask bit if appropriate */
1979 if (waitLock->granted[lockmode] == waitLock->requested[lockmode])
1980 waitLock->waitMask &= LOCKBIT_OFF(lockmode);
1981
1982 /* Clean up the proc's own state, and pass it the ok/fail signal */
1983 proc->waitLock = NULL;
1984 proc->waitProcLock = NULL;
1986
1987 /*
1988 * Delete the proclock immediately if it represents no already-held locks.
1989 * (This must happen now because if the owner of the lock decides to
1990 * release it, and the requested/granted counts then go to zero,
1991 * LockRelease expects there to be no remaining proclocks.) Then see if
1992 * any other waiters for the lock can be woken up now.
1993 */
1994 CleanUpLock(waitLock, proclock,
1995 LockMethods[lockmethodid], hashcode,
1996 true);
1997}
1998
1999/*
2000 * LockRelease -- look up 'locktag' and release one 'lockmode' lock on it.
2001 * Release a session lock if 'sessionLock' is true, else release a
2002 * regular transaction lock.
2003 *
2004 * Side Effects: find any waiting processes that are now wakable,
2005 * grant them their requested locks and awaken them.
2006 * (We have to grant the lock here to avoid a race between
2007 * the waking process and any new process to
2008 * come along and request the lock.)
2009 */
2010bool
2011LockRelease(const LOCKTAG *locktag, LOCKMODE lockmode, bool sessionLock)
2012{
2013 LOCKMETHODID lockmethodid = locktag->locktag_lockmethodid;
2014 LockMethod lockMethodTable;
2015 LOCALLOCKTAG localtag;
2016 LOCALLOCK *locallock;
2017 LOCK *lock;
2018 PROCLOCK *proclock;
2019 LWLock *partitionLock;
2020 bool wakeupNeeded;
2021
2022 if (lockmethodid <= 0 || lockmethodid >= lengthof(LockMethods))
2023 elog(ERROR, "unrecognized lock method: %d", lockmethodid);
2024 lockMethodTable = LockMethods[lockmethodid];
2025 if (lockmode <= 0 || lockmode > lockMethodTable->numLockModes)
2026 elog(ERROR, "unrecognized lock mode: %d", lockmode);
2027
2028#ifdef LOCK_DEBUG
2029 if (LOCK_DEBUG_ENABLED(locktag))
2030 elog(LOG, "LockRelease: lock [%u,%u] %s",
2031 locktag->locktag_field1, locktag->locktag_field2,
2032 lockMethodTable->lockModeNames[lockmode]);
2033#endif
2034
2035 /*
2036 * Find the LOCALLOCK entry for this lock and lockmode
2037 */
2038 MemSet(&localtag, 0, sizeof(localtag)); /* must clear padding */
2039 localtag.lock = *locktag;
2040 localtag.mode = lockmode;
2041
2043 &localtag,
2044 HASH_FIND, NULL);
2045
2046 /*
2047 * let the caller print its own error message, too. Do not ereport(ERROR).
2048 */
2049 if (!locallock || locallock->nLocks <= 0)
2050 {
2051 elog(WARNING, "you don't own a lock of type %s",
2052 lockMethodTable->lockModeNames[lockmode]);
2053 return false;
2054 }
2055
2056 /*
2057 * Decrease the count for the resource owner.
2058 */
2059 {
2060 LOCALLOCKOWNER *lockOwners = locallock->lockOwners;
2061 ResourceOwner owner;
2062 int i;
2063
2064 /* Identify owner for lock */
2065 if (sessionLock)
2066 owner = NULL;
2067 else
2068 owner = CurrentResourceOwner;
2069
2070 for (i = locallock->numLockOwners - 1; i >= 0; i--)
2071 {
2072 if (lockOwners[i].owner == owner)
2073 {
2074 Assert(lockOwners[i].nLocks > 0);
2075 if (--lockOwners[i].nLocks == 0)
2076 {
2077 if (owner != NULL)
2078 ResourceOwnerForgetLock(owner, locallock);
2079 /* compact out unused slot */
2080 locallock->numLockOwners--;
2081 if (i < locallock->numLockOwners)
2082 lockOwners[i] = lockOwners[locallock->numLockOwners];
2083 }
2084 break;
2085 }
2086 }
2087 if (i < 0)
2088 {
2089 /* don't release a lock belonging to another owner */
2090 elog(WARNING, "you don't own a lock of type %s",
2091 lockMethodTable->lockModeNames[lockmode]);
2092 return false;
2093 }
2094 }
2095
2096 /*
2097 * Decrease the total local count. If we're still holding the lock, we're
2098 * done.
2099 */
2100 locallock->nLocks--;
2101
2102 if (locallock->nLocks > 0)
2103 return true;
2104
2105 /*
2106 * At this point we can no longer suppose we are clear of invalidation
2107 * messages related to this lock. Although we'll delete the LOCALLOCK
2108 * object before any intentional return from this routine, it seems worth
2109 * the trouble to explicitly reset lockCleared right now, just in case
2110 * some error prevents us from deleting the LOCALLOCK.
2111 */
2112 locallock->lockCleared = false;
2113
2114 /* Attempt fast release of any lock eligible for the fast path. */
2115 if (EligibleForRelationFastPath(locktag, lockmode) &&
2117 {
2118 bool released;
2119
2120 /*
2121 * We might not find the lock here, even if we originally entered it
2122 * here. Another backend may have moved it to the main table.
2123 */
2125 released = FastPathUnGrantRelationLock(locktag->locktag_field2,
2126 lockmode);
2128 if (released)
2129 {
2130 RemoveLocalLock(locallock);
2131 return true;
2132 }
2133 }
2134
2135 /*
2136 * Otherwise we've got to mess with the shared lock table.
2137 */
2138 partitionLock = LockHashPartitionLock(locallock->hashcode);
2139
2140 LWLockAcquire(partitionLock, LW_EXCLUSIVE);
2141
2142 /*
2143 * Normally, we don't need to re-find the lock or proclock, since we kept
2144 * their addresses in the locallock table, and they couldn't have been
2145 * removed while we were holding a lock on them. But it's possible that
2146 * the lock was taken fast-path and has since been moved to the main hash
2147 * table by another backend, in which case we will need to look up the
2148 * objects here. We assume the lock field is NULL if so.
2149 */
2150 lock = locallock->lock;
2151 if (!lock)
2152 {
2153 PROCLOCKTAG proclocktag;
2154
2155 Assert(EligibleForRelationFastPath(locktag, lockmode));
2157 locktag,
2158 locallock->hashcode,
2159 HASH_FIND,
2160 NULL);
2161 if (!lock)
2162 elog(ERROR, "failed to re-find shared lock object");
2163 locallock->lock = lock;
2164
2165 proclocktag.myLock = lock;
2166 proclocktag.myProc = MyProc;
2168 &proclocktag,
2169 HASH_FIND,
2170 NULL);
2171 if (!locallock->proclock)
2172 elog(ERROR, "failed to re-find shared proclock object");
2173 }
2174 LOCK_PRINT("LockRelease: found", lock, lockmode);
2175 proclock = locallock->proclock;
2176 PROCLOCK_PRINT("LockRelease: found", proclock);
2177
2178 /*
2179 * Double-check that we are actually holding a lock of the type we want to
2180 * release.
2181 */
2182 if (!(proclock->holdMask & LOCKBIT_ON(lockmode)))
2183 {
2184 PROCLOCK_PRINT("LockRelease: WRONGTYPE", proclock);
2185 LWLockRelease(partitionLock);
2186 elog(WARNING, "you don't own a lock of type %s",
2187 lockMethodTable->lockModeNames[lockmode]);
2188 RemoveLocalLock(locallock);
2189 return false;
2190 }
2191
2192 /*
2193 * Do the releasing. CleanUpLock will waken any now-wakable waiters.
2194 */
2195 wakeupNeeded = UnGrantLock(lock, lockmode, proclock, lockMethodTable);
2196
2197 CleanUpLock(lock, proclock,
2198 lockMethodTable, locallock->hashcode,
2199 wakeupNeeded);
2200
2201 LWLockRelease(partitionLock);
2202
2203 RemoveLocalLock(locallock);
2204 return true;
2205}
2206
2207/*
2208 * LockReleaseAll -- Release all locks of the specified lock method that
2209 * are held by the current process.
2210 *
2211 * Well, not necessarily *all* locks. The available behaviors are:
2212 * allLocks == true: release all locks including session locks.
2213 * allLocks == false: release all non-session locks.
2214 */
2215void
2216LockReleaseAll(LOCKMETHODID lockmethodid, bool allLocks)
2217{
2218 HASH_SEQ_STATUS status;
2219 LockMethod lockMethodTable;
2220 int i,
2221 numLockModes;
2222 LOCALLOCK *locallock;
2223 LOCK *lock;
2224 int partition;
2225 bool have_fast_path_lwlock = false;
2226
2227 if (lockmethodid <= 0 || lockmethodid >= lengthof(LockMethods))
2228 elog(ERROR, "unrecognized lock method: %d", lockmethodid);
2229 lockMethodTable = LockMethods[lockmethodid];
2230
2231#ifdef LOCK_DEBUG
2232 if (*(lockMethodTable->trace_flag))
2233 elog(LOG, "LockReleaseAll: lockmethod=%d", lockmethodid);
2234#endif
2235
2236 /*
2237 * Get rid of our fast-path VXID lock, if appropriate. Note that this is
2238 * the only way that the lock we hold on our own VXID can ever get
2239 * released: it is always and only released when a toplevel transaction
2240 * ends.
2241 */
2242 if (lockmethodid == DEFAULT_LOCKMETHOD)
2244
2245 numLockModes = lockMethodTable->numLockModes;
2246
2247 /*
2248 * First we run through the locallock table and get rid of unwanted
2249 * entries, then we scan the process's proclocks and get rid of those. We
2250 * do this separately because we may have multiple locallock entries
2251 * pointing to the same proclock, and we daren't end up with any dangling
2252 * pointers. Fast-path locks are cleaned up during the locallock table
2253 * scan, though.
2254 */
2256
2257 while ((locallock = (LOCALLOCK *) hash_seq_search(&status)) != NULL)
2258 {
2259 /*
2260 * If the LOCALLOCK entry is unused, something must've gone wrong
2261 * while trying to acquire this lock. Just forget the local entry.
2262 */
2263 if (locallock->nLocks == 0)
2264 {
2265 RemoveLocalLock(locallock);
2266 continue;
2267 }
2268
2269 /* Ignore items that are not of the lockmethod to be removed */
2270 if (LOCALLOCK_LOCKMETHOD(*locallock) != lockmethodid)
2271 continue;
2272
2273 /*
2274 * If we are asked to release all locks, we can just zap the entry.
2275 * Otherwise, must scan to see if there are session locks. We assume
2276 * there is at most one lockOwners entry for session locks.
2277 */
2278 if (!allLocks)
2279 {
2280 LOCALLOCKOWNER *lockOwners = locallock->lockOwners;
2281
2282 /* If session lock is above array position 0, move it down to 0 */
2283 for (i = 0; i < locallock->numLockOwners; i++)
2284 {
2285 if (lockOwners[i].owner == NULL)
2286 lockOwners[0] = lockOwners[i];
2287 else
2288 ResourceOwnerForgetLock(lockOwners[i].owner, locallock);
2289 }
2290
2291 if (locallock->numLockOwners > 0 &&
2292 lockOwners[0].owner == NULL &&
2293 lockOwners[0].nLocks > 0)
2294 {
2295 /* Fix the locallock to show just the session locks */
2296 locallock->nLocks = lockOwners[0].nLocks;
2297 locallock->numLockOwners = 1;
2298 /* We aren't deleting this locallock, so done */
2299 continue;
2300 }
2301 else
2302 locallock->numLockOwners = 0;
2303 }
2304
2305#ifdef USE_ASSERT_CHECKING
2306
2307 /*
2308 * Tuple locks are currently held only for short durations within a
2309 * transaction. Check that we didn't forget to release one.
2310 */
2311 if (LOCALLOCK_LOCKTAG(*locallock) == LOCKTAG_TUPLE && !allLocks)
2312 elog(WARNING, "tuple lock held at commit");
2313#endif
2314
2315 /*
2316 * If the lock or proclock pointers are NULL, this lock was taken via
2317 * the relation fast-path (and is not known to have been transferred).
2318 */
2319 if (locallock->proclock == NULL || locallock->lock == NULL)
2320 {
2321 LOCKMODE lockmode = locallock->tag.mode;
2322 Oid relid;
2323
2324 /* Verify that a fast-path lock is what we've got. */
2325 if (!EligibleForRelationFastPath(&locallock->tag.lock, lockmode))
2326 elog(PANIC, "locallock table corrupted");
2327
2328 /*
2329 * If we don't currently hold the LWLock that protects our
2330 * fast-path data structures, we must acquire it before attempting
2331 * to release the lock via the fast-path. We will continue to
2332 * hold the LWLock until we're done scanning the locallock table,
2333 * unless we hit a transferred fast-path lock. (XXX is this
2334 * really such a good idea? There could be a lot of entries ...)
2335 */
2336 if (!have_fast_path_lwlock)
2337 {
2339 have_fast_path_lwlock = true;
2340 }
2341
2342 /* Attempt fast-path release. */
2343 relid = locallock->tag.lock.locktag_field2;
2344 if (FastPathUnGrantRelationLock(relid, lockmode))
2345 {
2346 RemoveLocalLock(locallock);
2347 continue;
2348 }
2349
2350 /*
2351 * Our lock, originally taken via the fast path, has been
2352 * transferred to the main lock table. That's going to require
2353 * some extra work, so release our fast-path lock before starting.
2354 */
2356 have_fast_path_lwlock = false;
2357
2358 /*
2359 * Now dump the lock. We haven't got a pointer to the LOCK or
2360 * PROCLOCK in this case, so we have to handle this a bit
2361 * differently than a normal lock release. Unfortunately, this
2362 * requires an extra LWLock acquire-and-release cycle on the
2363 * partitionLock, but hopefully it shouldn't happen often.
2364 */
2365 LockRefindAndRelease(lockMethodTable, MyProc,
2366 &locallock->tag.lock, lockmode, false);
2367 RemoveLocalLock(locallock);
2368 continue;
2369 }
2370
2371 /* Mark the proclock to show we need to release this lockmode */
2372 if (locallock->nLocks > 0)
2373 locallock->proclock->releaseMask |= LOCKBIT_ON(locallock->tag.mode);
2374
2375 /* And remove the locallock hashtable entry */
2376 RemoveLocalLock(locallock);
2377 }
2378
2379 /* Done with the fast-path data structures */
2380 if (have_fast_path_lwlock)
2382
2383 /*
2384 * Now, scan each lock partition separately.
2385 */
2386 for (partition = 0; partition < NUM_LOCK_PARTITIONS; partition++)
2387 {
2388 LWLock *partitionLock;
2389 dlist_head *procLocks = &MyProc->myProcLocks[partition];
2390 dlist_mutable_iter proclock_iter;
2391
2392 partitionLock = LockHashPartitionLockByIndex(partition);
2393
2394 /*
2395 * If the proclock list for this partition is empty, we can skip
2396 * acquiring the partition lock. This optimization is trickier than
2397 * it looks, because another backend could be in process of adding
2398 * something to our proclock list due to promoting one of our
2399 * fast-path locks. However, any such lock must be one that we
2400 * decided not to delete above, so it's okay to skip it again now;
2401 * we'd just decide not to delete it again. We must, however, be
2402 * careful to re-fetch the list header once we've acquired the
2403 * partition lock, to be sure we have a valid, up-to-date pointer.
2404 * (There is probably no significant risk if pointer fetch/store is
2405 * atomic, but we don't wish to assume that.)
2406 *
2407 * XXX This argument assumes that the locallock table correctly
2408 * represents all of our fast-path locks. While allLocks mode
2409 * guarantees to clean up all of our normal locks regardless of the
2410 * locallock situation, we lose that guarantee for fast-path locks.
2411 * This is not ideal.
2412 */
2413 if (dlist_is_empty(procLocks))
2414 continue; /* needn't examine this partition */
2415
2416 LWLockAcquire(partitionLock, LW_EXCLUSIVE);
2417
2418 dlist_foreach_modify(proclock_iter, procLocks)
2419 {
2420 PROCLOCK *proclock = dlist_container(PROCLOCK, procLink, proclock_iter.cur);
2421 bool wakeupNeeded = false;
2422
2423 Assert(proclock->tag.myProc == MyProc);
2424
2425 lock = proclock->tag.myLock;
2426
2427 /* Ignore items that are not of the lockmethod to be removed */
2428 if (LOCK_LOCKMETHOD(*lock) != lockmethodid)
2429 continue;
2430
2431 /*
2432 * In allLocks mode, force release of all locks even if locallock
2433 * table had problems
2434 */
2435 if (allLocks)
2436 proclock->releaseMask = proclock->holdMask;
2437 else
2438 Assert((proclock->releaseMask & ~proclock->holdMask) == 0);
2439
2440 /*
2441 * Ignore items that have nothing to be released, unless they have
2442 * holdMask == 0 and are therefore recyclable
2443 */
2444 if (proclock->releaseMask == 0 && proclock->holdMask != 0)
2445 continue;
2446
2447 PROCLOCK_PRINT("LockReleaseAll", proclock);
2448 LOCK_PRINT("LockReleaseAll", lock, 0);
2449 Assert(lock->nRequested >= 0);
2450 Assert(lock->nGranted >= 0);
2451 Assert(lock->nGranted <= lock->nRequested);
2452 Assert((proclock->holdMask & ~lock->grantMask) == 0);
2453
2454 /*
2455 * Release the previously-marked lock modes
2456 */
2457 for (i = 1; i <= numLockModes; i++)
2458 {
2459 if (proclock->releaseMask & LOCKBIT_ON(i))
2460 wakeupNeeded |= UnGrantLock(lock, i, proclock,
2461 lockMethodTable);
2462 }
2463 Assert((lock->nRequested >= 0) && (lock->nGranted >= 0));
2464 Assert(lock->nGranted <= lock->nRequested);
2465 LOCK_PRINT("LockReleaseAll: updated", lock, 0);
2466
2467 proclock->releaseMask = 0;
2468
2469 /* CleanUpLock will wake up waiters if needed. */
2470 CleanUpLock(lock, proclock,
2471 lockMethodTable,
2472 LockTagHashCode(&lock->tag),
2473 wakeupNeeded);
2474 } /* loop over PROCLOCKs within this partition */
2475
2476 LWLockRelease(partitionLock);
2477 } /* loop over partitions */
2478
2479#ifdef LOCK_DEBUG
2480 if (*(lockMethodTable->trace_flag))
2481 elog(LOG, "LockReleaseAll done");
2482#endif
2483}
2484
2485/*
2486 * LockReleaseSession -- Release all session locks of the specified lock method
2487 * that are held by the current process.
2488 */
2489void
2491{
2492 HASH_SEQ_STATUS status;
2493 LOCALLOCK *locallock;
2494
2495 if (lockmethodid <= 0 || lockmethodid >= lengthof(LockMethods))
2496 elog(ERROR, "unrecognized lock method: %d", lockmethodid);
2497
2499
2500 while ((locallock = (LOCALLOCK *) hash_seq_search(&status)) != NULL)
2501 {
2502 /* Ignore items that are not of the specified lock method */
2503 if (LOCALLOCK_LOCKMETHOD(*locallock) != lockmethodid)
2504 continue;
2505
2506 ReleaseLockIfHeld(locallock, true);
2507 }
2508}
2509
2510/*
2511 * LockReleaseCurrentOwner
2512 * Release all locks belonging to CurrentResourceOwner
2513 *
2514 * If the caller knows what those locks are, it can pass them as an array.
2515 * That speeds up the call significantly, when a lot of locks are held.
2516 * Otherwise, pass NULL for locallocks, and we'll traverse through our hash
2517 * table to find them.
2518 */
2519void
2520LockReleaseCurrentOwner(LOCALLOCK **locallocks, int nlocks)
2521{
2522 if (locallocks == NULL)
2523 {
2524 HASH_SEQ_STATUS status;
2525 LOCALLOCK *locallock;
2526
2528
2529 while ((locallock = (LOCALLOCK *) hash_seq_search(&status)) != NULL)
2530 ReleaseLockIfHeld(locallock, false);
2531 }
2532 else
2533 {
2534 int i;
2535
2536 for (i = nlocks - 1; i >= 0; i--)
2537 ReleaseLockIfHeld(locallocks[i], false);
2538 }
2539}
2540
2541/*
2542 * ReleaseLockIfHeld
2543 * Release any session-level locks on this lockable object if sessionLock
2544 * is true; else, release any locks held by CurrentResourceOwner.
2545 *
2546 * It is tempting to pass this a ResourceOwner pointer (or NULL for session
2547 * locks), but without refactoring LockRelease() we cannot support releasing
2548 * locks belonging to resource owners other than CurrentResourceOwner.
2549 * If we were to refactor, it'd be a good idea to fix it so we don't have to
2550 * do a hashtable lookup of the locallock, too. However, currently this
2551 * function isn't used heavily enough to justify refactoring for its
2552 * convenience.
2553 */
2554static void
2555ReleaseLockIfHeld(LOCALLOCK *locallock, bool sessionLock)
2556{
2557 ResourceOwner owner;
2558 LOCALLOCKOWNER *lockOwners;
2559 int i;
2560
2561 /* Identify owner for lock (must match LockRelease!) */
2562 if (sessionLock)
2563 owner = NULL;
2564 else
2565 owner = CurrentResourceOwner;
2566
2567 /* Scan to see if there are any locks belonging to the target owner */
2568 lockOwners = locallock->lockOwners;
2569 for (i = locallock->numLockOwners - 1; i >= 0; i--)
2570 {
2571 if (lockOwners[i].owner == owner)
2572 {
2573 Assert(lockOwners[i].nLocks > 0);
2574 if (lockOwners[i].nLocks < locallock->nLocks)
2575 {
2576 /*
2577 * We will still hold this lock after forgetting this
2578 * ResourceOwner.
2579 */
2580 locallock->nLocks -= lockOwners[i].nLocks;
2581 /* compact out unused slot */
2582 locallock->numLockOwners--;
2583 if (owner != NULL)
2584 ResourceOwnerForgetLock(owner, locallock);
2585 if (i < locallock->numLockOwners)
2586 lockOwners[i] = lockOwners[locallock->numLockOwners];
2587 }
2588 else
2589 {
2590 Assert(lockOwners[i].nLocks == locallock->nLocks);
2591 /* We want to call LockRelease just once */
2592 lockOwners[i].nLocks = 1;
2593 locallock->nLocks = 1;
2594 if (!LockRelease(&locallock->tag.lock,
2595 locallock->tag.mode,
2596 sessionLock))
2597 elog(WARNING, "ReleaseLockIfHeld: failed??");
2598 }
2599 break;
2600 }
2601 }
2602}
2603
2604/*
2605 * LockReassignCurrentOwner
2606 * Reassign all locks belonging to CurrentResourceOwner to belong
2607 * to its parent resource owner.
2608 *
2609 * If the caller knows what those locks are, it can pass them as an array.
2610 * That speeds up the call significantly, when a lot of locks are held
2611 * (e.g pg_dump with a large schema). Otherwise, pass NULL for locallocks,
2612 * and we'll traverse through our hash table to find them.
2613 */
2614void
2615LockReassignCurrentOwner(LOCALLOCK **locallocks, int nlocks)
2616{
2618
2619 Assert(parent != NULL);
2620
2621 if (locallocks == NULL)
2622 {
2623 HASH_SEQ_STATUS status;
2624 LOCALLOCK *locallock;
2625
2627
2628 while ((locallock = (LOCALLOCK *) hash_seq_search(&status)) != NULL)
2629 LockReassignOwner(locallock, parent);
2630 }
2631 else
2632 {
2633 int i;
2634
2635 for (i = nlocks - 1; i >= 0; i--)
2636 LockReassignOwner(locallocks[i], parent);
2637 }
2638}
2639
2640/*
2641 * Subroutine of LockReassignCurrentOwner. Reassigns a given lock belonging to
2642 * CurrentResourceOwner to its parent.
2643 */
2644static void
2646{
2647 LOCALLOCKOWNER *lockOwners;
2648 int i;
2649 int ic = -1;
2650 int ip = -1;
2651
2652 /*
2653 * Scan to see if there are any locks belonging to current owner or its
2654 * parent
2655 */
2656 lockOwners = locallock->lockOwners;
2657 for (i = locallock->numLockOwners - 1; i >= 0; i--)
2658 {
2659 if (lockOwners[i].owner == CurrentResourceOwner)
2660 ic = i;
2661 else if (lockOwners[i].owner == parent)
2662 ip = i;
2663 }
2664
2665 if (ic < 0)
2666 return; /* no current locks */
2667
2668 if (ip < 0)
2669 {
2670 /* Parent has no slot, so just give it the child's slot */
2671 lockOwners[ic].owner = parent;
2672 ResourceOwnerRememberLock(parent, locallock);
2673 }
2674 else
2675 {
2676 /* Merge child's count with parent's */
2677 lockOwners[ip].nLocks += lockOwners[ic].nLocks;
2678 /* compact out unused slot */
2679 locallock->numLockOwners--;
2680 if (ic < locallock->numLockOwners)
2681 lockOwners[ic] = lockOwners[locallock->numLockOwners];
2682 }
2684}
2685
2686/*
2687 * FastPathGrantRelationLock
2688 * Grant lock using per-backend fast-path array, if there is space.
2689 */
2690static bool
2692{
2693 uint32 i;
2694 uint32 unused_slot = FP_LOCK_SLOTS_PER_BACKEND;
2695
2696 /* fast-path group the lock belongs to */
2697 uint32 group = FAST_PATH_REL_GROUP(relid);
2698
2699 /* Scan for existing entry for this relid, remembering empty slot. */
2700 for (i = 0; i < FP_LOCK_SLOTS_PER_GROUP; i++)
2701 {
2702 /* index into the whole per-backend array */
2703 uint32 f = FAST_PATH_SLOT(group, i);
2704
2705 if (FAST_PATH_GET_BITS(MyProc, f) == 0)
2706 unused_slot = f;
2707 else if (MyProc->fpRelId[f] == relid)
2708 {
2709 Assert(!FAST_PATH_CHECK_LOCKMODE(MyProc, f, lockmode));
2710 FAST_PATH_SET_LOCKMODE(MyProc, f, lockmode);
2711 return true;
2712 }
2713 }
2714
2715 /* If no existing entry, use any empty slot. */
2716 if (unused_slot < FP_LOCK_SLOTS_PER_BACKEND)
2717 {
2718 MyProc->fpRelId[unused_slot] = relid;
2719 FAST_PATH_SET_LOCKMODE(MyProc, unused_slot, lockmode);
2720 ++FastPathLocalUseCounts[group];
2721 return true;
2722 }
2723
2724 /* No existing entry, and no empty slot. */
2725 return false;
2726}
2727
2728/*
2729 * FastPathUnGrantRelationLock
2730 * Release fast-path lock, if present. Update backend-private local
2731 * use count, while we're at it.
2732 */
2733static bool
2735{
2736 uint32 i;
2737 bool result = false;
2738
2739 /* fast-path group the lock belongs to */
2740 uint32 group = FAST_PATH_REL_GROUP(relid);
2741
2742 FastPathLocalUseCounts[group] = 0;
2743 for (i = 0; i < FP_LOCK_SLOTS_PER_GROUP; i++)
2744 {
2745 /* index into the whole per-backend array */
2746 uint32 f = FAST_PATH_SLOT(group, i);
2747
2748 if (MyProc->fpRelId[f] == relid
2749 && FAST_PATH_CHECK_LOCKMODE(MyProc, f, lockmode))
2750 {
2751 Assert(!result);
2752 FAST_PATH_CLEAR_LOCKMODE(MyProc, f, lockmode);
2753 result = true;
2754 /* we continue iterating so as to update FastPathLocalUseCount */
2755 }
2756 if (FAST_PATH_GET_BITS(MyProc, f) != 0)
2757 ++FastPathLocalUseCounts[group];
2758 }
2759 return result;
2760}
2761
2762/*
2763 * FastPathTransferRelationLocks
2764 * Transfer locks matching the given lock tag from per-backend fast-path
2765 * arrays to the shared hash table.
2766 *
2767 * Returns true if successful, false if ran out of shared memory.
2768 */
2769static bool
2770FastPathTransferRelationLocks(LockMethod lockMethodTable, const LOCKTAG *locktag,
2771 uint32 hashcode)
2772{
2773 LWLock *partitionLock = LockHashPartitionLock(hashcode);
2774 Oid relid = locktag->locktag_field2;
2775 uint32 i;
2776
2777 /*
2778 * Every PGPROC that can potentially hold a fast-path lock is present in
2779 * ProcGlobal->allProcs. Prepared transactions are not, but any
2780 * outstanding fast-path locks held by prepared transactions are
2781 * transferred to the main lock table.
2782 */
2783 for (i = 0; i < ProcGlobal->allProcCount; i++)
2784 {
2785 PGPROC *proc = &ProcGlobal->allProcs[i];
2786 uint32 j,
2787 group;
2788
2790
2791 /*
2792 * If the target backend isn't referencing the same database as the
2793 * lock, then we needn't examine the individual relation IDs at all;
2794 * none of them can be relevant.
2795 *
2796 * proc->databaseId is set at backend startup time and never changes
2797 * thereafter, so it might be safe to perform this test before
2798 * acquiring &proc->fpInfoLock. In particular, it's certainly safe to
2799 * assume that if the target backend holds any fast-path locks, it
2800 * must have performed a memory-fencing operation (in particular, an
2801 * LWLock acquisition) since setting proc->databaseId. However, it's
2802 * less clear that our backend is certain to have performed a memory
2803 * fencing operation since the other backend set proc->databaseId. So
2804 * for now, we test it after acquiring the LWLock just to be safe.
2805 */
2806 if (proc->databaseId != locktag->locktag_field1)
2807 {
2808 LWLockRelease(&proc->fpInfoLock);
2809 continue;
2810 }
2811
2812 /* fast-path group the lock belongs to */
2813 group = FAST_PATH_REL_GROUP(relid);
2814
2815 for (j = 0; j < FP_LOCK_SLOTS_PER_GROUP; j++)
2816 {
2817 uint32 lockmode;
2818
2819 /* index into the whole per-backend array */
2820 uint32 f = FAST_PATH_SLOT(group, j);
2821
2822 /* Look for an allocated slot matching the given relid. */
2823 if (relid != proc->fpRelId[f] || FAST_PATH_GET_BITS(proc, f) == 0)
2824 continue;
2825
2826 /* Find or create lock object. */
2827 LWLockAcquire(partitionLock, LW_EXCLUSIVE);
2828 for (lockmode = FAST_PATH_LOCKNUMBER_OFFSET;
2830 ++lockmode)
2831 {
2832 PROCLOCK *proclock;
2833
2834 if (!FAST_PATH_CHECK_LOCKMODE(proc, f, lockmode))
2835 continue;
2836 proclock = SetupLockInTable(lockMethodTable, proc, locktag,
2837 hashcode, lockmode);
2838 if (!proclock)
2839 {
2840 LWLockRelease(partitionLock);
2841 LWLockRelease(&proc->fpInfoLock);
2842 return false;
2843 }
2844 GrantLock(proclock->tag.myLock, proclock, lockmode);
2845 FAST_PATH_CLEAR_LOCKMODE(proc, f, lockmode);
2846 }
2847 LWLockRelease(partitionLock);
2848
2849 /* No need to examine remaining slots. */
2850 break;
2851 }
2852 LWLockRelease(&proc->fpInfoLock);
2853 }
2854 return true;
2855}
2856
2857/*
2858 * FastPathGetRelationLockEntry
2859 * Return the PROCLOCK for a lock originally taken via the fast-path,
2860 * transferring it to the primary lock table if necessary.
2861 *
2862 * Note: caller takes care of updating the locallock object.
2863 */
2864static PROCLOCK *
2866{
2867 LockMethod lockMethodTable = LockMethods[DEFAULT_LOCKMETHOD];
2868 LOCKTAG *locktag = &locallock->tag.lock;
2869 PROCLOCK *proclock = NULL;
2870 LWLock *partitionLock = LockHashPartitionLock(locallock->hashcode);
2871 Oid relid = locktag->locktag_field2;
2872 uint32 i,
2873 group;
2874
2875 /* fast-path group the lock belongs to */
2876 group = FAST_PATH_REL_GROUP(relid);
2877
2879
2880 for (i = 0; i < FP_LOCK_SLOTS_PER_GROUP; i++)
2881 {
2882 uint32 lockmode;
2883
2884 /* index into the whole per-backend array */
2885 uint32 f = FAST_PATH_SLOT(group, i);
2886
2887 /* Look for an allocated slot matching the given relid. */
2888 if (relid != MyProc->fpRelId[f] || FAST_PATH_GET_BITS(MyProc, f) == 0)
2889 continue;
2890
2891 /* If we don't have a lock of the given mode, forget it! */
2892 lockmode = locallock->tag.mode;
2893 if (!FAST_PATH_CHECK_LOCKMODE(MyProc, f, lockmode))
2894 break;
2895
2896 /* Find or create lock object. */
2897 LWLockAcquire(partitionLock, LW_EXCLUSIVE);
2898
2899 proclock = SetupLockInTable(lockMethodTable, MyProc, locktag,
2900 locallock->hashcode, lockmode);
2901 if (!proclock)
2902 {
2903 LWLockRelease(partitionLock);
2905 ereport(ERROR,
2906 (errcode(ERRCODE_OUT_OF_MEMORY),
2907 errmsg("out of shared memory"),
2908 errhint("You might need to increase \"%s\".", "max_locks_per_transaction")));
2909 }
2910 GrantLock(proclock->tag.myLock, proclock, lockmode);
2911 FAST_PATH_CLEAR_LOCKMODE(MyProc, f, lockmode);
2912
2913 LWLockRelease(partitionLock);
2914
2915 /* No need to examine remaining slots. */
2916 break;
2917 }
2918
2920
2921 /* Lock may have already been transferred by some other backend. */
2922 if (proclock == NULL)
2923 {
2924 LOCK *lock;
2925 PROCLOCKTAG proclocktag;
2926 uint32 proclock_hashcode;
2927
2928 LWLockAcquire(partitionLock, LW_SHARED);
2929
2931 locktag,
2932 locallock->hashcode,
2933 HASH_FIND,
2934 NULL);
2935 if (!lock)
2936 elog(ERROR, "failed to re-find shared lock object");
2937
2938 proclocktag.myLock = lock;
2939 proclocktag.myProc = MyProc;
2940
2941 proclock_hashcode = ProcLockHashCode(&proclocktag, locallock->hashcode);
2942 proclock = (PROCLOCK *)
2944 &proclocktag,
2945 proclock_hashcode,
2946 HASH_FIND,
2947 NULL);
2948 if (!proclock)
2949 elog(ERROR, "failed to re-find shared proclock object");
2950 LWLockRelease(partitionLock);
2951 }
2952
2953 return proclock;
2954}
2955
2956/*
2957 * GetLockConflicts
2958 * Get an array of VirtualTransactionIds of xacts currently holding locks
2959 * that would conflict with the specified lock/lockmode.
2960 * xacts merely awaiting such a lock are NOT reported.
2961 *
2962 * The result array is palloc'd and is terminated with an invalid VXID.
2963 * *countp, if not null, is updated to the number of items set.
2964 *
2965 * Of course, the result could be out of date by the time it's returned, so
2966 * use of this function has to be thought about carefully. Similarly, a
2967 * PGPROC with no "lxid" will be considered non-conflicting regardless of any
2968 * lock it holds. Existing callers don't care about a locker after that
2969 * locker's pg_xact updates complete. CommitTransaction() clears "lxid" after
2970 * pg_xact updates and before releasing locks.
2971 *
2972 * Note we never include the current xact's vxid in the result array,
2973 * since an xact never blocks itself.
2974 */
2976GetLockConflicts(const LOCKTAG *locktag, LOCKMODE lockmode, int *countp)
2977{
2978 static VirtualTransactionId *vxids;
2979 LOCKMETHODID lockmethodid = locktag->locktag_lockmethodid;
2980 LockMethod lockMethodTable;
2981 LOCK *lock;
2982 LOCKMASK conflictMask;
2983 dlist_iter proclock_iter;
2984 PROCLOCK *proclock;
2985 uint32 hashcode;
2986 LWLock *partitionLock;
2987 int count = 0;
2988 int fast_count = 0;
2989
2990 if (lockmethodid <= 0 || lockmethodid >= lengthof(LockMethods))
2991 elog(ERROR, "unrecognized lock method: %d", lockmethodid);
2992 lockMethodTable = LockMethods[lockmethodid];
2993 if (lockmode <= 0 || lockmode > lockMethodTable->numLockModes)
2994 elog(ERROR, "unrecognized lock mode: %d", lockmode);
2995
2996 /*
2997 * Allocate memory to store results, and fill with InvalidVXID. We only
2998 * need enough space for MaxBackends + max_prepared_xacts + a terminator.
2999 * InHotStandby allocate once in TopMemoryContext.
3000 */
3001 if (InHotStandby)
3002 {
3003 if (vxids == NULL)
3004 vxids = (VirtualTransactionId *)
3006 sizeof(VirtualTransactionId) *
3008 }
3009 else
3010 vxids = (VirtualTransactionId *)
3013
3014 /* Compute hash code and partition lock, and look up conflicting modes. */
3015 hashcode = LockTagHashCode(locktag);
3016 partitionLock = LockHashPartitionLock(hashcode);
3017 conflictMask = lockMethodTable->conflictTab[lockmode];
3018
3019 /*
3020 * Fast path locks might not have been entered in the primary lock table.
3021 * If the lock we're dealing with could conflict with such a lock, we must
3022 * examine each backend's fast-path array for conflicts.
3023 */
3024 if (ConflictsWithRelationFastPath(locktag, lockmode))
3025 {
3026 int i;
3027 Oid relid = locktag->locktag_field2;
3029
3030 /*
3031 * Iterate over relevant PGPROCs. Anything held by a prepared
3032 * transaction will have been transferred to the primary lock table,
3033 * so we need not worry about those. This is all a bit fuzzy, because
3034 * new locks could be taken after we've visited a particular
3035 * partition, but the callers had better be prepared to deal with that
3036 * anyway, since the locks could equally well be taken between the
3037 * time we return the value and the time the caller does something
3038 * with it.
3039 */
3040 for (i = 0; i < ProcGlobal->allProcCount; i++)
3041 {
3042 PGPROC *proc = &ProcGlobal->allProcs[i];
3043 uint32 j,
3044 group;
3045
3046 /* A backend never blocks itself */
3047 if (proc == MyProc)
3048 continue;
3049
3051
3052 /*
3053 * If the target backend isn't referencing the same database as
3054 * the lock, then we needn't examine the individual relation IDs
3055 * at all; none of them can be relevant.
3056 *
3057 * See FastPathTransferRelationLocks() for discussion of why we do
3058 * this test after acquiring the lock.
3059 */
3060 if (proc->databaseId != locktag->locktag_field1)
3061 {
3062 LWLockRelease(&proc->fpInfoLock);
3063 continue;
3064 }
3065
3066 /* fast-path group the lock belongs to */
3067 group = FAST_PATH_REL_GROUP(relid);
3068
3069 for (j = 0; j < FP_LOCK_SLOTS_PER_GROUP; j++)
3070 {
3071 uint32 lockmask;
3072
3073 /* index into the whole per-backend array */
3074 uint32 f = FAST_PATH_SLOT(group, j);
3075
3076 /* Look for an allocated slot matching the given relid. */
3077 if (relid != proc->fpRelId[f])
3078 continue;
3079 lockmask = FAST_PATH_GET_BITS(proc, f);
3080 if (!lockmask)
3081 continue;
3082 lockmask <<= FAST_PATH_LOCKNUMBER_OFFSET;
3083
3084 /*
3085 * There can only be one entry per relation, so if we found it
3086 * and it doesn't conflict, we can skip the rest of the slots.
3087 */
3088 if ((lockmask & conflictMask) == 0)
3089 break;
3090
3091 /* Conflict! */
3092 GET_VXID_FROM_PGPROC(vxid, *proc);
3093
3095 vxids[count++] = vxid;
3096 /* else, xact already committed or aborted */
3097
3098 /* No need to examine remaining slots. */
3099 break;
3100 }
3101
3102 LWLockRelease(&proc->fpInfoLock);
3103 }
3104 }
3105
3106 /* Remember how many fast-path conflicts we found. */
3107 fast_count = count;
3108
3109 /*
3110 * Look up the lock object matching the tag.
3111 */
3112 LWLockAcquire(partitionLock, LW_SHARED);
3113
3115 locktag,
3116 hashcode,
3117 HASH_FIND,
3118 NULL);
3119 if (!lock)
3120 {
3121 /*
3122 * If the lock object doesn't exist, there is nothing holding a lock
3123 * on this lockable object.
3124 */
3125 LWLockRelease(partitionLock);
3126 vxids[count].procNumber = INVALID_PROC_NUMBER;
3128 if (countp)
3129 *countp = count;
3130 return vxids;
3131 }
3132
3133 /*
3134 * Examine each existing holder (or awaiter) of the lock.
3135 */
3136 dlist_foreach(proclock_iter, &lock->procLocks)
3137 {
3138 proclock = dlist_container(PROCLOCK, lockLink, proclock_iter.cur);
3139
3140 if (conflictMask & proclock->holdMask)
3141 {
3142 PGPROC *proc = proclock->tag.myProc;
3143
3144 /* A backend never blocks itself */
3145 if (proc != MyProc)
3146 {
3148
3149 GET_VXID_FROM_PGPROC(vxid, *proc);
3150
3152 {
3153 int i;
3154
3155 /* Avoid duplicate entries. */
3156 for (i = 0; i < fast_count; ++i)
3157 if (VirtualTransactionIdEquals(vxids[i], vxid))
3158 break;
3159 if (i >= fast_count)
3160 vxids[count++] = vxid;
3161 }
3162 /* else, xact already committed or aborted */
3163 }
3164 }
3165 }
3166
3167 LWLockRelease(partitionLock);
3168
3169 if (count > MaxBackends + max_prepared_xacts) /* should never happen */
3170 elog(PANIC, "too many conflicting locks found");
3171
3172 vxids[count].procNumber = INVALID_PROC_NUMBER;
3174 if (countp)
3175 *countp = count;
3176 return vxids;
3177}
3178
3179/*
3180 * Find a lock in the shared lock table and release it. It is the caller's
3181 * responsibility to verify that this is a sane thing to do. (For example, it
3182 * would be bad to release a lock here if there might still be a LOCALLOCK
3183 * object with pointers to it.)
3184 *
3185 * We currently use this in two situations: first, to release locks held by
3186 * prepared transactions on commit (see lock_twophase_postcommit); and second,
3187 * to release locks taken via the fast-path, transferred to the main hash
3188 * table, and then released (see LockReleaseAll).
3189 */
3190static void
3192 LOCKTAG *locktag, LOCKMODE lockmode,
3193 bool decrement_strong_lock_count)
3194{
3195 LOCK *lock;
3196 PROCLOCK *proclock;
3197 PROCLOCKTAG proclocktag;
3198 uint32 hashcode;
3199 uint32 proclock_hashcode;
3200 LWLock *partitionLock;
3201 bool wakeupNeeded;
3202
3203 hashcode = LockTagHashCode(locktag);
3204 partitionLock = LockHashPartitionLock(hashcode);
3205
3206 LWLockAcquire(partitionLock, LW_EXCLUSIVE);
3207
3208 /*
3209 * Re-find the lock object (it had better be there).
3210 */
3212 locktag,
3213 hashcode,
3214 HASH_FIND,
3215 NULL);
3216 if (!lock)
3217 elog(PANIC, "failed to re-find shared lock object");
3218
3219 /*
3220 * Re-find the proclock object (ditto).
3221 */
3222 proclocktag.myLock = lock;
3223 proclocktag.myProc = proc;
3224
3225 proclock_hashcode = ProcLockHashCode(&proclocktag, hashcode);
3226
3228 &proclocktag,
3229 proclock_hashcode,
3230 HASH_FIND,
3231 NULL);
3232 if (!proclock)
3233 elog(PANIC, "failed to re-find shared proclock object");
3234
3235 /*
3236 * Double-check that we are actually holding a lock of the type we want to
3237 * release.
3238 */
3239 if (!(proclock->holdMask & LOCKBIT_ON(lockmode)))
3240 {
3241 PROCLOCK_PRINT("lock_twophase_postcommit: WRONGTYPE", proclock);
3242 LWLockRelease(partitionLock);
3243 elog(WARNING, "you don't own a lock of type %s",
3244 lockMethodTable->lockModeNames[lockmode]);
3245 return;
3246 }
3247
3248 /*
3249 * Do the releasing. CleanUpLock will waken any now-wakable waiters.
3250 */
3251 wakeupNeeded = UnGrantLock(lock, lockmode, proclock, lockMethodTable);
3252
3253 CleanUpLock(lock, proclock,
3254 lockMethodTable, hashcode,
3255 wakeupNeeded);
3256
3257 LWLockRelease(partitionLock);
3258
3259 /*
3260 * Decrement strong lock count. This logic is needed only for 2PC.
3261 */
3262 if (decrement_strong_lock_count
3263 && ConflictsWithRelationFastPath(locktag, lockmode))
3264 {
3265 uint32 fasthashcode = FastPathStrongLockHashPartition(hashcode);
3266
3268 Assert(FastPathStrongRelationLocks->count[fasthashcode] > 0);
3269 FastPathStrongRelationLocks->count[fasthashcode]--;
3271 }
3272}
3273
3274/*
3275 * CheckForSessionAndXactLocks
3276 * Check to see if transaction holds both session-level and xact-level
3277 * locks on the same object; if so, throw an error.
3278 *
3279 * If we have both session- and transaction-level locks on the same object,
3280 * PREPARE TRANSACTION must fail. This should never happen with regular
3281 * locks, since we only take those at session level in some special operations
3282 * like VACUUM. It's possible to hit this with advisory locks, though.
3283 *
3284 * It would be nice if we could keep the session hold and give away the
3285 * transactional hold to the prepared xact. However, that would require two
3286 * PROCLOCK objects, and we cannot be sure that another PROCLOCK will be
3287 * available when it comes time for PostPrepare_Locks to do the deed.
3288 * So for now, we error out while we can still do so safely.
3289 *
3290 * Since the LOCALLOCK table stores a separate entry for each lockmode,
3291 * we can't implement this check by examining LOCALLOCK entries in isolation.
3292 * We must build a transient hashtable that is indexed by locktag only.
3293 */
3294static void
3296{
3297 typedef struct
3298 {
3299 LOCKTAG lock; /* identifies the lockable object */
3300 bool sessLock; /* is any lockmode held at session level? */
3301 bool xactLock; /* is any lockmode held at xact level? */
3302 } PerLockTagEntry;
3303
3304 HASHCTL hash_ctl;
3305 HTAB *lockhtab;
3306 HASH_SEQ_STATUS status;
3307 LOCALLOCK *locallock;
3308
3309 /* Create a local hash table keyed by LOCKTAG only */
3310 hash_ctl.keysize = sizeof(LOCKTAG);
3311 hash_ctl.entrysize = sizeof(PerLockTagEntry);
3312 hash_ctl.hcxt = CurrentMemoryContext;
3313
3314 lockhtab = hash_create("CheckForSessionAndXactLocks table",
3315 256, /* arbitrary initial size */
3316 &hash_ctl,
3318
3319 /* Scan local lock table to find entries for each LOCKTAG */
3321
3322 while ((locallock = (LOCALLOCK *) hash_seq_search(&status)) != NULL)
3323 {
3324 LOCALLOCKOWNER *lockOwners = locallock->lockOwners;
3325 PerLockTagEntry *hentry;
3326 bool found;
3327 int i;
3328
3329 /*
3330 * Ignore VXID locks. We don't want those to be held by prepared
3331 * transactions, since they aren't meaningful after a restart.
3332 */
3334 continue;
3335
3336 /* Ignore it if we don't actually hold the lock */
3337 if (locallock->nLocks <= 0)
3338 continue;
3339
3340 /* Otherwise, find or make an entry in lockhtab */
3341 hentry = (PerLockTagEntry *) hash_search(lockhtab,
3342 &locallock->tag.lock,
3343 HASH_ENTER, &found);
3344 if (!found) /* initialize, if newly created */
3345 hentry->sessLock = hentry->xactLock = false;
3346
3347 /* Scan to see if we hold lock at session or xact level or both */
3348 for (i = locallock->numLockOwners - 1; i >= 0; i--)
3349 {
3350 if (lockOwners[i].owner == NULL)
3351 hentry->sessLock = true;
3352 else
3353 hentry->xactLock = true;
3354 }
3355
3356 /*
3357 * We can throw error immediately when we see both types of locks; no
3358 * need to wait around to see if there are more violations.
3359 */
3360 if (hentry->sessLock && hentry->xactLock)
3361 ereport(ERROR,
3362 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3363 errmsg("cannot PREPARE while holding both session-level and transaction-level locks on the same object")));
3364 }
3365
3366 /* Success, so clean up */
3367 hash_destroy(lockhtab);
3368}
3369
3370/*
3371 * AtPrepare_Locks
3372 * Do the preparatory work for a PREPARE: make 2PC state file records
3373 * for all locks currently held.
3374 *
3375 * Session-level locks are ignored, as are VXID locks.
3376 *
3377 * For the most part, we don't need to touch shared memory for this ---
3378 * all the necessary state information is in the locallock table.
3379 * Fast-path locks are an exception, however: we move any such locks to
3380 * the main table before allowing PREPARE TRANSACTION to succeed.
3381 */
3382void
3384{
3385 HASH_SEQ_STATUS status;
3386 LOCALLOCK *locallock;
3387
3388 /* First, verify there aren't locks of both xact and session level */
3390
3391 /* Now do the per-locallock cleanup work */
3393
3394 while ((locallock = (LOCALLOCK *) hash_seq_search(&status)) != NULL)
3395 {
3396 TwoPhaseLockRecord record;
3397 LOCALLOCKOWNER *lockOwners = locallock->lockOwners;
3398 bool haveSessionLock;
3399 bool haveXactLock;
3400 int i;
3401
3402 /*
3403 * Ignore VXID locks. We don't want those to be held by prepared
3404 * transactions, since they aren't meaningful after a restart.
3405 */
3407 continue;
3408
3409 /* Ignore it if we don't actually hold the lock */
3410 if (locallock->nLocks <= 0)
3411 continue;
3412
3413 /* Scan to see whether we hold it at session or transaction level */
3414 haveSessionLock = haveXactLock = false;
3415 for (i = locallock->numLockOwners - 1; i >= 0; i--)
3416 {
3417 if (lockOwners[i].owner == NULL)
3418 haveSessionLock = true;
3419 else
3420 haveXactLock = true;
3421 }
3422
3423 /* Ignore it if we have only session lock */
3424 if (!haveXactLock)
3425 continue;
3426
3427 /* This can't happen, because we already checked it */
3428 if (haveSessionLock)
3429 ereport(ERROR,
3430 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3431 errmsg("cannot PREPARE while holding both session-level and transaction-level locks on the same object")));
3432
3433 /*
3434 * If the local lock was taken via the fast-path, we need to move it
3435 * to the primary lock table, or just get a pointer to the existing
3436 * primary lock table entry if by chance it's already been
3437 * transferred.
3438 */
3439 if (locallock->proclock == NULL)
3440 {
3441 locallock->proclock = FastPathGetRelationLockEntry(locallock);
3442 locallock->lock = locallock->proclock->tag.myLock;
3443 }
3444
3445 /*
3446 * Arrange to not release any strong lock count held by this lock
3447 * entry. We must retain the count until the prepared transaction is
3448 * committed or rolled back.
3449 */
3450 locallock->holdsStrongLockCount = false;
3451
3452 /*
3453 * Create a 2PC record.
3454 */
3455 memcpy(&(record.locktag), &(locallock->tag.lock), sizeof(LOCKTAG));
3456 record.lockmode = locallock->tag.mode;
3457
3459 &record, sizeof(TwoPhaseLockRecord));
3460 }
3461}
3462
3463/*
3464 * PostPrepare_Locks
3465 * Clean up after successful PREPARE
3466 *
3467 * Here, we want to transfer ownership of our locks to a dummy PGPROC
3468 * that's now associated with the prepared transaction, and we want to
3469 * clean out the corresponding entries in the LOCALLOCK table.
3470 *
3471 * Note: by removing the LOCALLOCK entries, we are leaving dangling
3472 * pointers in the transaction's resource owner. This is OK at the
3473 * moment since resowner.c doesn't try to free locks retail at a toplevel
3474 * transaction commit or abort. We could alternatively zero out nLocks
3475 * and leave the LOCALLOCK entries to be garbage-collected by LockReleaseAll,
3476 * but that probably costs more cycles.
3477 */
3478void
3480{
3481 PGPROC *newproc = TwoPhaseGetDummyProc(xid, false);
3482 HASH_SEQ_STATUS status;
3483 LOCALLOCK *locallock;
3484 LOCK *lock;
3485 PROCLOCK *proclock;
3486 PROCLOCKTAG proclocktag;
3487 int partition;
3488
3489 /* Can't prepare a lock group follower. */
3490 Assert(MyProc->lockGroupLeader == NULL ||
3492
3493 /* This is a critical section: any error means big trouble */
3495
3496 /*
3497 * First we run through the locallock table and get rid of unwanted
3498 * entries, then we scan the process's proclocks and transfer them to the
3499 * target proc.
3500 *
3501 * We do this separately because we may have multiple locallock entries
3502 * pointing to the same proclock, and we daren't end up with any dangling
3503 * pointers.
3504 */
3506
3507 while ((locallock = (LOCALLOCK *) hash_seq_search(&status)) != NULL)
3508 {
3509 LOCALLOCKOWNER *lockOwners = locallock->lockOwners;
3510 bool haveSessionLock;
3511 bool haveXactLock;
3512 int i;
3513
3514 if (locallock->proclock == NULL || locallock->lock == NULL)
3515 {
3516 /*
3517 * We must've run out of shared memory while trying to set up this
3518 * lock. Just forget the local entry.
3519 */
3520 Assert(locallock->nLocks == 0);
3521 RemoveLocalLock(locallock);
3522 continue;
3523 }
3524
3525 /* Ignore VXID locks */
3527 continue;
3528
3529 /* Scan to see whether we hold it at session or transaction level */
3530 haveSessionLock = haveXactLock = false;
3531 for (i = locallock->numLockOwners - 1; i >= 0; i--)
3532 {
3533 if (lockOwners[i].owner == NULL)
3534 haveSessionLock = true;
3535 else
3536 haveXactLock = true;
3537 }
3538
3539 /* Ignore it if we have only session lock */
3540 if (!haveXactLock)
3541 continue;
3542
3543 /* This can't happen, because we already checked it */
3544 if (haveSessionLock)
3545 ereport(PANIC,
3546 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3547 errmsg("cannot PREPARE while holding both session-level and transaction-level locks on the same object")));
3548
3549 /* Mark the proclock to show we need to release this lockmode */
3550 if (locallock->nLocks > 0)
3551 locallock->proclock->releaseMask |= LOCKBIT_ON(locallock->tag.mode);
3552
3553 /* And remove the locallock hashtable entry */
3554 RemoveLocalLock(locallock);
3555 }
3556
3557 /*
3558 * Now, scan each lock partition separately.
3559 */
3560 for (partition = 0; partition < NUM_LOCK_PARTITIONS; partition++)
3561 {
3562 LWLock *partitionLock;
3563 dlist_head *procLocks = &(MyProc->myProcLocks[partition]);
3564 dlist_mutable_iter proclock_iter;
3565
3566 partitionLock = LockHashPartitionLockByIndex(partition);
3567
3568 /*
3569 * If the proclock list for this partition is empty, we can skip
3570 * acquiring the partition lock. This optimization is safer than the
3571 * situation in LockReleaseAll, because we got rid of any fast-path
3572 * locks during AtPrepare_Locks, so there cannot be any case where
3573 * another backend is adding something to our lists now. For safety,
3574 * though, we code this the same way as in LockReleaseAll.
3575 */
3576 if (dlist_is_empty(procLocks))
3577 continue; /* needn't examine this partition */
3578
3579 LWLockAcquire(partitionLock, LW_EXCLUSIVE);
3580
3581 dlist_foreach_modify(proclock_iter, procLocks)
3582 {
3583 proclock = dlist_container(PROCLOCK, procLink, proclock_iter.cur);
3584
3585 Assert(proclock->tag.myProc == MyProc);
3586
3587 lock = proclock->tag.myLock;
3588
3589 /* Ignore VXID locks */
3591 continue;
3592
3593 PROCLOCK_PRINT("PostPrepare_Locks", proclock);
3594 LOCK_PRINT("PostPrepare_Locks", lock, 0);
3595 Assert(lock->nRequested >= 0);
3596 Assert(lock->nGranted >= 0);
3597 Assert(lock->nGranted <= lock->nRequested);
3598 Assert((proclock->holdMask & ~lock->grantMask) == 0);
3599
3600 /* Ignore it if nothing to release (must be a session lock) */
3601 if (proclock->releaseMask == 0)
3602 continue;
3603
3604 /* Else we should be releasing all locks */
3605 if (proclock->releaseMask != proclock->holdMask)
3606 elog(PANIC, "we seem to have dropped a bit somewhere");
3607
3608 /*
3609 * We cannot simply modify proclock->tag.myProc to reassign
3610 * ownership of the lock, because that's part of the hash key and
3611 * the proclock would then be in the wrong hash chain. Instead
3612 * use hash_update_hash_key. (We used to create a new hash entry,
3613 * but that risks out-of-memory failure if other processes are
3614 * busy making proclocks too.) We must unlink the proclock from
3615 * our procLink chain and put it into the new proc's chain, too.
3616 *
3617 * Note: the updated proclock hash key will still belong to the
3618 * same hash partition, cf proclock_hash(). So the partition lock
3619 * we already hold is sufficient for this.
3620 */
3621 dlist_delete(&proclock->procLink);
3622
3623 /*
3624 * Create the new hash key for the proclock.
3625 */
3626 proclocktag.myLock = lock;
3627 proclocktag.myProc = newproc;
3628
3629 /*
3630 * Update groupLeader pointer to point to the new proc. (We'd
3631 * better not be a member of somebody else's lock group!)
3632 */
3633 Assert(proclock->groupLeader == proclock->tag.myProc);
3634 proclock->groupLeader = newproc;
3635
3636 /*
3637 * Update the proclock. We should not find any existing entry for
3638 * the same hash key, since there can be only one entry for any
3639 * given lock with my own proc.
3640 */
3642 proclock,
3643 &proclocktag))
3644 elog(PANIC, "duplicate entry found while reassigning a prepared transaction's locks");
3645
3646 /* Re-link into the new proc's proclock list */
3647 dlist_push_tail(&newproc->myProcLocks[partition], &proclock->procLink);
3648
3649 PROCLOCK_PRINT("PostPrepare_Locks: updated", proclock);
3650 } /* loop over PROCLOCKs within this partition */
3651
3652 LWLockRelease(partitionLock);
3653 } /* loop over partitions */
3654
3656}
3657
3658
3659/*
3660 * Estimate shared-memory space used for lock tables
3661 */
3662Size
3664{
3665 Size size = 0;
3666 long max_table_size;
3667
3668 /* lock hash table */
3669 max_table_size = NLOCKENTS();
3670 size = add_size(size, hash_estimate_size(max_table_size, sizeof(LOCK)));
3671
3672 /* proclock hash table */
3673 max_table_size *= 2;
3674 size = add_size(size, hash_estimate_size(max_table_size, sizeof(PROCLOCK)));
3675
3676 /*
3677 * Since NLOCKENTS is only an estimate, add 10% safety margin.
3678 */
3679 size = add_size(size, size / 10);
3680
3681 return size;
3682}
3683
3684/*
3685 * GetLockStatusData - Return a summary of the lock manager's internal
3686 * status, for use in a user-level reporting function.
3687 *
3688 * The return data consists of an array of LockInstanceData objects,
3689 * which are a lightly abstracted version of the PROCLOCK data structures,
3690 * i.e. there is one entry for each unique lock and interested PGPROC.
3691 * It is the caller's responsibility to match up related items (such as
3692 * references to the same lockable object or PGPROC) if wanted.
3693 *
3694 * The design goal is to hold the LWLocks for as short a time as possible;
3695 * thus, this function simply makes a copy of the necessary data and releases
3696 * the locks, allowing the caller to contemplate and format the data for as
3697 * long as it pleases.
3698 */
3699LockData *
3701{
3702 LockData *data;
3703 PROCLOCK *proclock;
3704 HASH_SEQ_STATUS seqstat;
3705 int els;
3706 int el;
3707 int i;
3708
3709 data = (LockData *) palloc(sizeof(LockData));
3710
3711 /* Guess how much space we'll need. */
3712 els = MaxBackends;
3713 el = 0;
3714 data->locks = (LockInstanceData *) palloc(sizeof(LockInstanceData) * els);
3715
3716 /*
3717 * First, we iterate through the per-backend fast-path arrays, locking
3718 * them one at a time. This might produce an inconsistent picture of the
3719 * system state, but taking all of those LWLocks at the same time seems
3720 * impractical (in particular, note MAX_SIMUL_LWLOCKS). It shouldn't
3721 * matter too much, because none of these locks can be involved in lock
3722 * conflicts anyway - anything that might must be present in the main lock
3723 * table. (For the same reason, we don't sweat about making leaderPid
3724 * completely valid. We cannot safely dereference another backend's
3725 * lockGroupLeader field without holding all lock partition locks, and
3726 * it's not worth that.)
3727 */
3728 for (i = 0; i < ProcGlobal->allProcCount; ++i)
3729 {
3730 PGPROC *proc = &ProcGlobal->allProcs[i];
3731
3732 /* Skip backends with pid=0, as they don't hold fast-path locks */
3733 if (proc->pid == 0)
3734 continue;
3735
3737
3738 for (uint32 g = 0; g < FastPathLockGroupsPerBackend; g++)
3739 {
3740 /* Skip groups without registered fast-path locks */
3741 if (proc->fpLockBits[g] == 0)
3742 continue;
3743
3744 for (int j = 0; j < FP_LOCK_SLOTS_PER_GROUP; j++)
3745 {
3746 LockInstanceData *instance;
3747 uint32 f = FAST_PATH_SLOT(g, j);
3748 uint32 lockbits = FAST_PATH_GET_BITS(proc, f);
3749
3750 /* Skip unallocated slots */
3751 if (!lockbits)
3752 continue;
3753
3754 if (el >= els)
3755 {
3756 els += MaxBackends;
3757 data->locks = (LockInstanceData *)
3758 repalloc(data->locks, sizeof(LockInstanceData) * els);
3759 }
3760
3761 instance = &data->locks[el];
3762 SET_LOCKTAG_RELATION(instance->locktag, proc->databaseId,
3763 proc->fpRelId[f]);
3764 instance->holdMask = lockbits << FAST_PATH_LOCKNUMBER_OFFSET;
3765 instance->waitLockMode = NoLock;
3766 instance->vxid.procNumber = proc->vxid.procNumber;
3767 instance->vxid.localTransactionId = proc->vxid.lxid;
3768 instance->pid = proc->pid;
3769 instance->leaderPid = proc->pid;
3770 instance->fastpath = true;
3771
3772 /*
3773 * Successfully taking fast path lock means there were no
3774 * conflicting locks.
3775 */
3776 instance->waitStart = 0;
3777
3778 el++;
3779 }
3780 }
3781
3782 if (proc->fpVXIDLock)
3783 {
3785 LockInstanceData *instance;
3786
3787 if (el >= els)
3788 {
3789 els += MaxBackends;
3790 data->locks = (LockInstanceData *)
3791 repalloc(data->locks, sizeof(LockInstanceData) * els);
3792 }
3793
3794 vxid.procNumber = proc->vxid.procNumber;
3796
3797 instance = &data->locks[el];
3798 SET_LOCKTAG_VIRTUALTRANSACTION(instance->locktag, vxid);
3799 instance->holdMask = LOCKBIT_ON(ExclusiveLock);
3800 instance->waitLockMode = NoLock;
3801 instance->vxid.procNumber = proc->vxid.procNumber;
3802 instance->vxid.localTransactionId = proc->vxid.lxid;
3803 instance->pid = proc->pid;
3804 instance->leaderPid = proc->pid;
3805 instance->fastpath = true;
3806 instance->waitStart = 0;
3807
3808 el++;
3809 }
3810
3811 LWLockRelease(&proc->fpInfoLock);
3812 }
3813
3814 /*
3815 * Next, acquire lock on the entire shared lock data structure. We do
3816 * this so that, at least for locks in the primary lock table, the state
3817 * will be self-consistent.
3818 *
3819 * Since this is a read-only operation, we take shared instead of
3820 * exclusive lock. There's not a whole lot of point to this, because all
3821 * the normal operations require exclusive lock, but it doesn't hurt
3822 * anything either. It will at least allow two backends to do
3823 * GetLockStatusData in parallel.
3824 *
3825 * Must grab LWLocks in partition-number order to avoid LWLock deadlock.
3826 */
3827 for (i = 0; i < NUM_LOCK_PARTITIONS; i++)
3829
3830 /* Now we can safely count the number of proclocks */
3832 if (data->nelements > els)
3833 {
3834 els = data->nelements;
3835 data->locks = (LockInstanceData *)
3836 repalloc(data->locks, sizeof(LockInstanceData) * els);
3837 }
3838
3839 /* Now scan the tables to copy the data */
3841
3842 while ((proclock = (PROCLOCK *) hash_seq_search(&seqstat)))
3843 {
3844 PGPROC *proc = proclock->tag.myProc;
3845 LOCK *lock = proclock->tag.myLock;
3846 LockInstanceData *instance = &data->locks[el];
3847
3848 memcpy(&instance->locktag, &lock->tag, sizeof(LOCKTAG));
3849 instance->holdMask = proclock->holdMask;
3850 if (proc->waitLock == proclock->tag.myLock)
3851 instance->waitLockMode = proc->waitLockMode;
3852 else
3853 instance->waitLockMode = NoLock;
3854 instance->vxid.procNumber = proc->vxid.procNumber;
3855 instance->vxid.localTransactionId = proc->vxid.lxid;
3856 instance->pid = proc->pid;
3857 instance->leaderPid = proclock->groupLeader->pid;
3858 instance->fastpath = false;
3859 instance->waitStart = (TimestampTz) pg_atomic_read_u64(&proc->waitStart);
3860
3861 el++;
3862 }
3863
3864 /*
3865 * And release locks. We do this in reverse order for two reasons: (1)
3866 * Anyone else who needs more than one of the locks will be trying to lock
3867 * them in increasing order; we don't want to release the other process
3868 * until it can get all the locks it needs. (2) This avoids O(N^2)
3869 * behavior inside LWLockRelease.
3870 */
3871 for (i = NUM_LOCK_PARTITIONS; --i >= 0;)
3873
3874 Assert(el == data->nelements);
3875
3876 return data;
3877}
3878
3879/*
3880 * GetBlockerStatusData - Return a summary of the lock manager's state
3881 * concerning locks that are blocking the specified PID or any member of
3882 * the PID's lock group, for use in a user-level reporting function.
3883 *
3884 * For each PID within the lock group that is awaiting some heavyweight lock,
3885 * the return data includes an array of LockInstanceData objects, which are
3886 * the same data structure used by GetLockStatusData; but unlike that function,
3887 * this one reports only the PROCLOCKs associated with the lock that that PID
3888 * is blocked on. (Hence, all the locktags should be the same for any one
3889 * blocked PID.) In addition, we return an array of the PIDs of those backends
3890 * that are ahead of the blocked PID in the lock's wait queue. These can be
3891 * compared with the PIDs in the LockInstanceData objects to determine which
3892 * waiters are ahead of or behind the blocked PID in the queue.
3893 *
3894 * If blocked_pid isn't a valid backend PID or nothing in its lock group is
3895 * waiting on any heavyweight lock, return empty arrays.
3896 *
3897 * The design goal is to hold the LWLocks for as short a time as possible;
3898 * thus, this function simply makes a copy of the necessary data and releases
3899 * the locks, allowing the caller to contemplate and format the data for as
3900 * long as it pleases.
3901 */
3903GetBlockerStatusData(int blocked_pid)
3904{
3906 PGPROC *proc;
3907 int i;
3908
3910
3911 /*
3912 * Guess how much space we'll need, and preallocate. Most of the time
3913 * this will avoid needing to do repalloc while holding the LWLocks. (We
3914 * assume, but check with an Assert, that MaxBackends is enough entries
3915 * for the procs[] array; the other two could need enlargement, though.)
3916 */
3917 data->nprocs = data->nlocks = data->npids = 0;
3918 data->maxprocs = data->maxlocks = data->maxpids = MaxBackends;
3919 data->procs = (BlockedProcData *) palloc(sizeof(BlockedProcData) * data->maxprocs);
3920 data->locks = (LockInstanceData *) palloc(sizeof(LockInstanceData) * data->maxlocks);
3921 data->waiter_pids = (int *) palloc(sizeof(int) * data->maxpids);
3922
3923 /*
3924 * In order to search the ProcArray for blocked_pid and assume that that
3925 * entry won't immediately disappear under us, we must hold ProcArrayLock.
3926 * In addition, to examine the lock grouping fields of any other backend,
3927 * we must hold all the hash partition locks. (Only one of those locks is
3928 * actually relevant for any one lock group, but we can't know which one
3929 * ahead of time.) It's fairly annoying to hold all those locks
3930 * throughout this, but it's no worse than GetLockStatusData(), and it
3931 * does have the advantage that we're guaranteed to return a
3932 * self-consistent instantaneous state.
3933 */
3934 LWLockAcquire(ProcArrayLock, LW_SHARED);
3935
3936 proc = BackendPidGetProcWithLock(blocked_pid);
3937
3938 /* Nothing to do if it's gone */
3939 if (proc != NULL)
3940 {
3941 /*
3942 * Acquire lock on the entire shared lock data structure. See notes
3943 * in GetLockStatusData().
3944 */
3945 for (i = 0; i < NUM_LOCK_PARTITIONS; i++)
3947
3948 if (proc->lockGroupLeader == NULL)
3949 {
3950 /* Easy case, proc is not a lock group member */
3952 }
3953 else
3954 {
3955 /* Examine all procs in proc's lock group */
3956 dlist_iter iter;
3957
3959 {
3960 PGPROC *memberProc;
3961
3962 memberProc = dlist_container(PGPROC, lockGroupLink, iter.cur);
3964 }
3965 }
3966
3967 /*
3968 * And release locks. See notes in GetLockStatusData().
3969 */
3970 for (i = NUM_LOCK_PARTITIONS; --i >= 0;)
3972
3973 Assert(data->nprocs <= data->maxprocs);
3974 }
3975
3976 LWLockRelease(ProcArrayLock);
3977
3978 return data;
3979}
3980
3981/* Accumulate data about one possibly-blocked proc for GetBlockerStatusData */
3982static void
3984{
3985 LOCK *theLock = blocked_proc->waitLock;
3986 BlockedProcData *bproc;
3987 dlist_iter proclock_iter;
3988 dlist_iter proc_iter;
3989 dclist_head *waitQueue;
3990 int queue_size;
3991
3992 /* Nothing to do if this proc is not blocked */
3993 if (theLock == NULL)
3994 return;
3995
3996 /* Set up a procs[] element */
3997 bproc = &data->procs[data->nprocs++];
3998 bproc->pid = blocked_proc->pid;
3999 bproc->first_lock = data->nlocks;
4000 bproc->first_waiter = data->npids;
4001
4002 /*
4003 * We may ignore the proc's fast-path arrays, since nothing in those could
4004 * be related to a contended lock.
4005 */
4006
4007 /* Collect all PROCLOCKs associated with theLock */
4008 dlist_foreach(proclock_iter, &theLock->procLocks)
4009 {
4010 PROCLOCK *proclock =
4011 dlist_container(PROCLOCK, lockLink, proclock_iter.cur);
4012 PGPROC *proc = proclock->tag.myProc;
4013 LOCK *lock = proclock->tag.myLock;
4014 LockInstanceData *instance;
4015
4016 if (data->nlocks >= data->maxlocks)
4017 {
4018 data->maxlocks += MaxBackends;
4019 data->locks = (LockInstanceData *)
4020 repalloc(data->locks, sizeof(LockInstanceData) * data->maxlocks);
4021 }
4022
4023 instance = &data->locks[data->nlocks];
4024 memcpy(&instance->locktag, &lock->tag, sizeof(LOCKTAG));
4025 instance->holdMask = proclock->holdMask;
4026 if (proc->waitLock == lock)
4027 instance->waitLockMode = proc->waitLockMode;
4028 else
4029 instance->waitLockMode = NoLock;
4030 instance->vxid.procNumber = proc->vxid.procNumber;
4031 instance->vxid.localTransactionId = proc->vxid.lxid;
4032 instance->pid = proc->pid;
4033 instance->leaderPid = proclock->groupLeader->pid;
4034 instance->fastpath = false;
4035 data->nlocks++;
4036 }
4037
4038 /* Enlarge waiter_pids[] if it's too small to hold all wait queue PIDs */
4039 waitQueue = &(theLock->waitProcs);
4040 queue_size = dclist_count(waitQueue);
4041
4042 if (queue_size > data->maxpids - data->npids)
4043 {
4044 data->maxpids = Max(data->maxpids + MaxBackends,
4045 data->npids + queue_size);
4046 data->waiter_pids = (int *) repalloc(data->waiter_pids,
4047 sizeof(int) * data->maxpids);
4048 }
4049
4050 /* Collect PIDs from the lock's wait queue, stopping at blocked_proc */
4051 dclist_foreach(proc_iter, waitQueue)
4052 {
4053 PGPROC *queued_proc = dlist_container(PGPROC, links, proc_iter.cur);
4054
4055 if (queued_proc == blocked_proc)
4056 break;
4057 data->waiter_pids[data->npids++] = queued_proc->pid;
4058 queued_proc = (PGPROC *) queued_proc->links.next;
4059 }
4060
4061 bproc->num_locks = data->nlocks - bproc->first_lock;
4062 bproc->num_waiters = data->npids - bproc->first_waiter;
4063}
4064
4065/*
4066 * Returns a list of currently held AccessExclusiveLocks, for use by
4067 * LogStandbySnapshot(). The result is a palloc'd array,
4068 * with the number of elements returned into *nlocks.
4069 *
4070 * XXX This currently takes a lock on all partitions of the lock table,
4071 * but it's possible to do better. By reference counting locks and storing
4072 * the value in the ProcArray entry for each backend we could tell if any
4073 * locks need recording without having to acquire the partition locks and
4074 * scan the lock table. Whether that's worth the additional overhead
4075 * is pretty dubious though.
4076 */
4079{
4080 xl_standby_lock *accessExclusiveLocks;
4081 PROCLOCK *proclock;
4082 HASH_SEQ_STATUS seqstat;
4083 int i;
4084 int index;
4085 int els;
4086
4087 /*
4088 * Acquire lock on the entire shared lock data structure.
4089 *
4090 * Must grab LWLocks in partition-number order to avoid LWLock deadlock.
4091 */
4092 for (i = 0; i < NUM_LOCK_PARTITIONS; i++)
4094
4095 /* Now we can safely count the number of proclocks */
4097
4098 /*
4099 * Allocating enough space for all locks in the lock table is overkill,
4100 * but it's more convenient and faster than having to enlarge the array.
4101 */
4102 accessExclusiveLocks = palloc(els * sizeof(xl_standby_lock));
4103
4104 /* Now scan the tables to copy the data */
4106
4107 /*
4108 * If lock is a currently granted AccessExclusiveLock then it will have
4109 * just one proclock holder, so locks are never accessed twice in this
4110 * particular case. Don't copy this code for use elsewhere because in the
4111 * general case this will give you duplicate locks when looking at
4112 * non-exclusive lock types.
4113 */
4114 index = 0;
4115 while ((proclock = (PROCLOCK *) hash_seq_search(&seqstat)))
4116 {
4117 /* make sure this definition matches the one used in LockAcquire */
4118 if ((proclock->holdMask & LOCKBIT_ON(AccessExclusiveLock)) &&
4120 {
4121 PGPROC *proc = proclock->tag.myProc;
4122 LOCK *lock = proclock->tag.myLock;
4123 TransactionId xid = proc->xid;
4124
4125 /*
4126 * Don't record locks for transactions if we know they have
4127 * already issued their WAL record for commit but not yet released
4128 * lock. It is still possible that we see locks held by already
4129 * complete transactions, if they haven't yet zeroed their xids.
4130 */
4131 if (!TransactionIdIsValid(xid))
4132 continue;
4133
4134 accessExclusiveLocks[index].xid = xid;
4135 accessExclusiveLocks[index].dbOid = lock->tag.locktag_field1;
4136 accessExclusiveLocks[index].relOid = lock->tag.locktag_field2;
4137
4138 index++;
4139 }
4140 }
4141
4142 Assert(index <= els);
4143
4144 /*
4145 * And release locks. We do this in reverse order for two reasons: (1)
4146 * Anyone else who needs more than one of the locks will be trying to lock
4147 * them in increasing order; we don't want to release the other process
4148 * until it can get all the locks it needs. (2) This avoids O(N^2)
4149 * behavior inside LWLockRelease.
4150 */
4151 for (i = NUM_LOCK_PARTITIONS; --i >= 0;)
4153
4154 *nlocks = index;
4155 return accessExclusiveLocks;
4156}
4157
4158/* Provide the textual name of any lock mode */
4159const char *
4161{
4162 Assert(lockmethodid > 0 && lockmethodid < lengthof(LockMethods));
4163 Assert(mode > 0 && mode <= LockMethods[lockmethodid]->numLockModes);
4164 return LockMethods[lockmethodid]->lockModeNames[mode];
4165}
4166
4167#ifdef LOCK_DEBUG
4168/*
4169 * Dump all locks in the given proc's myProcLocks lists.
4170 *
4171 * Caller is responsible for having acquired appropriate LWLocks.
4172 */
4173void
4174DumpLocks(PGPROC *proc)
4175{
4176 int i;
4177
4178 if (proc == NULL)
4179 return;
4180
4181 if (proc->waitLock)
4182 LOCK_PRINT("DumpLocks: waiting on", proc->waitLock, 0);
4183
4184 for (i = 0; i < NUM_LOCK_PARTITIONS; i++)
4185 {
4186 dlist_head *procLocks = &proc->myProcLocks[i];
4187 dlist_iter iter;
4188
4189 dlist_foreach(iter, procLocks)
4190 {
4191 PROCLOCK *proclock = dlist_container(PROCLOCK, procLink, iter.cur);
4192 LOCK *lock = proclock->tag.myLock;
4193
4194 Assert(proclock->tag.myProc == proc);
4195 PROCLOCK_PRINT("DumpLocks", proclock);
4196 LOCK_PRINT("DumpLocks", lock, 0);
4197 }
4198 }
4199}
4200
4201/*
4202 * Dump all lmgr locks.
4203 *
4204 * Caller is responsible for having acquired appropriate LWLocks.
4205 */
4206void
4207DumpAllLocks(void)
4208{
4209 PGPROC *proc;
4210 PROCLOCK *proclock;
4211 LOCK *lock;
4212 HASH_SEQ_STATUS status;
4213
4214 proc = MyProc;
4215
4216 if (proc && proc->waitLock)
4217 LOCK_PRINT("DumpAllLocks: waiting on", proc->waitLock, 0);
4218
4220
4221 while ((proclock = (PROCLOCK *) hash_seq_search(&status)) != NULL)
4222 {
4223 PROCLOCK_PRINT("DumpAllLocks", proclock);
4224
4225 lock = proclock->tag.myLock;
4226 if (lock)
4227 LOCK_PRINT("DumpAllLocks", lock, 0);
4228 else
4229 elog(LOG, "DumpAllLocks: proclock->tag.myLock = NULL");
4230 }
4231}
4232#endif /* LOCK_DEBUG */
4233
4234/*
4235 * LOCK 2PC resource manager's routines
4236 */
4237
4238/*
4239 * Re-acquire a lock belonging to a transaction that was prepared.
4240 *
4241 * Because this function is run at db startup, re-acquiring the locks should
4242 * never conflict with running transactions because there are none. We
4243 * assume that the lock state represented by the stored 2PC files is legal.
4244 *
4245 * When switching from Hot Standby mode to normal operation, the locks will
4246 * be already held by the startup process. The locks are acquired for the new
4247 * procs without checking for conflicts, so we don't get a conflict between the
4248 * startup process and the dummy procs, even though we will momentarily have
4249 * a situation where two procs are holding the same AccessExclusiveLock,
4250 * which isn't normally possible because the conflict. If we're in standby
4251 * mode, but a recovery snapshot hasn't been established yet, it's possible
4252 * that some but not all of the locks are already held by the startup process.
4253 *
4254 * This approach is simple, but also a bit dangerous, because if there isn't
4255 * enough shared memory to acquire the locks, an error will be thrown, which
4256 * is promoted to FATAL and recovery will abort, bringing down postmaster.
4257 * A safer approach would be to transfer the locks like we do in
4258 * AtPrepare_Locks, but then again, in hot standby mode it's possible for
4259 * read-only backends to use up all the shared lock memory anyway, so that
4260 * replaying the WAL record that needs to acquire a lock will throw an error
4261 * and PANIC anyway.
4262 */
4263void
4265 void *recdata, uint32 len)
4266{
4267 TwoPhaseLockRecord *rec = (TwoPhaseLockRecord *) recdata;
4268 PGPROC *proc = TwoPhaseGetDummyProc(xid, false);
4269 LOCKTAG *locktag;
4270 LOCKMODE lockmode;
4271 LOCKMETHODID lockmethodid;
4272 LOCK *lock;
4273 PROCLOCK *proclock;
4274 PROCLOCKTAG proclocktag;
4275 bool found;
4276 uint32 hashcode;
4277 uint32 proclock_hashcode;
4278 int partition;
4279 LWLock *partitionLock;
4280 LockMethod lockMethodTable;
4281
4282 Assert(len == sizeof(TwoPhaseLockRecord));
4283 locktag = &rec->locktag;
4284 lockmode = rec->lockmode;
4285 lockmethodid = locktag->locktag_lockmethodid;
4286
4287 if (lockmethodid <= 0 || lockmethodid >= lengthof(LockMethods))
4288 elog(ERROR, "unrecognized lock method: %d", lockmethodid);
4289 lockMethodTable = LockMethods[lockmethodid];
4290
4291 hashcode = LockTagHashCode(locktag);
4292 partition = LockHashPartition(hashcode);
4293 partitionLock = LockHashPartitionLock(hashcode);
4294
4295 LWLockAcquire(partitionLock, LW_EXCLUSIVE);
4296
4297 /*
4298 * Find or create a lock with this tag.
4299 */
4301 locktag,
4302 hashcode,
4304 &found);
4305 if (!lock)
4306 {
4307 LWLockRelease(partitionLock);
4308 ereport(ERROR,
4309 (errcode(ERRCODE_OUT_OF_MEMORY),
4310 errmsg("out of shared memory"),
4311 errhint("You might need to increase \"%s\".", "max_locks_per_transaction")));
4312 }
4313
4314 /*
4315 * if it's a new lock object, initialize it
4316 */
4317 if (!found)
4318 {
4319 lock->grantMask = 0;
4320 lock->waitMask = 0;
4321 dlist_init(&lock->procLocks);
4322 dclist_init(&lock->waitProcs);
4323 lock->nRequested = 0;
4324 lock->nGranted = 0;
4325 MemSet(lock->requested, 0, sizeof(int) * MAX_LOCKMODES);
4326 MemSet(lock->granted, 0, sizeof(int) * MAX_LOCKMODES);
4327 LOCK_PRINT("lock_twophase_recover: new", lock, lockmode);
4328 }
4329 else
4330 {
4331 LOCK_PRINT("lock_twophase_recover: found", lock, lockmode);
4332 Assert((lock->nRequested >= 0) && (lock->requested[lockmode] >= 0));
4333 Assert((lock->nGranted >= 0) && (lock->granted[lockmode] >= 0));
4334 Assert(lock->nGranted <= lock->nRequested);
4335 }
4336
4337 /*
4338 * Create the hash key for the proclock table.
4339 */
4340 proclocktag.myLock = lock;
4341 proclocktag.myProc = proc;
4342
4343 proclock_hashcode = ProcLockHashCode(&proclocktag, hashcode);
4344
4345 /*
4346 * Find or create a proclock entry with this tag
4347 */
4349 &proclocktag,
4350 proclock_hashcode,
4352 &found);
4353 if (!proclock)
4354 {
4355 /* Oops, not enough shmem for the proclock */
4356 if (lock->nRequested == 0)
4357 {
4358 /*
4359 * There are no other requestors of this lock, so garbage-collect
4360 * the lock object. We *must* do this to avoid a permanent leak
4361 * of shared memory, because there won't be anything to cause
4362 * anyone to release the lock object later.
4363 */
4366 &(lock->tag),
4367 hashcode,
4369 NULL))
4370 elog(PANIC, "lock table corrupted");
4371 }
4372 LWLockRelease(partitionLock);
4373 ereport(ERROR,
4374 (errcode(ERRCODE_OUT_OF_MEMORY),
4375 errmsg("out of shared memory"),
4376 errhint("You might need to increase \"%s\".", "max_locks_per_transaction")));
4377 }
4378
4379 /*
4380 * If new, initialize the new entry
4381 */
4382 if (!found)
4383 {
4384 Assert(proc->lockGroupLeader == NULL);
4385 proclock->groupLeader = proc;
4386 proclock->holdMask = 0;
4387 proclock->releaseMask = 0;
4388 /* Add proclock to appropriate lists */
4389 dlist_push_tail(&lock->procLocks, &proclock->lockLink);
4390 dlist_push_tail(&proc->myProcLocks[partition],
4391 &proclock->procLink);
4392 PROCLOCK_PRINT("lock_twophase_recover: new", proclock);
4393 }
4394 else
4395 {
4396 PROCLOCK_PRINT("lock_twophase_recover: found", proclock);
4397 Assert((proclock->holdMask & ~lock->grantMask) == 0);
4398 }
4399
4400 /*
4401 * lock->nRequested and lock->requested[] count the total number of
4402 * requests, whether granted or waiting, so increment those immediately.
4403 */
4404 lock->nRequested++;
4405 lock->requested[lockmode]++;
4406 Assert((lock->nRequested > 0) && (lock->requested[lockmode] > 0));
4407
4408 /*
4409 * We shouldn't already hold the desired lock.
4410 */
4411 if (proclock->holdMask & LOCKBIT_ON(lockmode))
4412 elog(ERROR, "lock %s on object %u/%u/%u is already held",
4413 lockMethodTable->lockModeNames[lockmode],
4414 lock->tag.locktag_field1, lock->tag.locktag_field2,
4415 lock->tag.locktag_field3);
4416
4417 /*
4418 * We ignore any possible conflicts and just grant ourselves the lock. Not
4419 * only because we don't bother, but also to avoid deadlocks when
4420 * switching from standby to normal mode. See function comment.
4421 */
4422 GrantLock(lock, proclock, lockmode);
4423
4424 /*
4425 * Bump strong lock count, to make sure any fast-path lock requests won't
4426 * be granted without consulting the primary lock table.
4427 */
4428 if (ConflictsWithRelationFastPath(&lock->tag, lockmode))
4429 {
4430 uint32 fasthashcode = FastPathStrongLockHashPartition(hashcode);
4431
4433 FastPathStrongRelationLocks->count[fasthashcode]++;
4435 }
4436
4437 LWLockRelease(partitionLock);
4438}
4439
4440/*
4441 * Re-acquire a lock belonging to a transaction that was prepared, when
4442 * starting up into hot standby mode.
4443 */
4444void
4446 void *recdata, uint32 len)
4447{
4448 TwoPhaseLockRecord *rec = (TwoPhaseLockRecord *) recdata;
4449 LOCKTAG *locktag;
4450 LOCKMODE lockmode;
4451 LOCKMETHODID lockmethodid;
4452
4453 Assert(len == sizeof(TwoPhaseLockRecord));
4454 locktag = &rec->locktag;
4455 lockmode = rec->lockmode;
4456 lockmethodid = locktag->locktag_lockmethodid;
4457
4458 if (lockmethodid <= 0 || lockmethodid >= lengthof(LockMethods))
4459 elog(ERROR, "unrecognized lock method: %d", lockmethodid);
4460
4461 if (lockmode == AccessExclusiveLock &&
4462 locktag->locktag_type == LOCKTAG_RELATION)
4463 {
4465 locktag->locktag_field1 /* dboid */ ,
4466 locktag->locktag_field2 /* reloid */ );
4467 }
4468}
4469
4470
4471/*
4472 * 2PC processing routine for COMMIT PREPARED case.
4473 *
4474 * Find and release the lock indicated by the 2PC record.
4475 */
4476void
4478 void *recdata, uint32 len)
4479{
4480 TwoPhaseLockRecord *rec = (TwoPhaseLockRecord *) recdata;
4481 PGPROC *proc = TwoPhaseGetDummyProc(xid, true);
4482 LOCKTAG *locktag;
4483 LOCKMETHODID lockmethodid;
4484 LockMethod lockMethodTable;
4485
4486 Assert(len == sizeof(TwoPhaseLockRecord));
4487 locktag = &rec->locktag;
4488 lockmethodid = locktag->locktag_lockmethodid;
4489
4490 if (lockmethodid <= 0 || lockmethodid >= lengthof(LockMethods))
4491 elog(ERROR, "unrecognized lock method: %d", lockmethodid);
4492 lockMethodTable = LockMethods[lockmethodid];
4493
4494 LockRefindAndRelease(lockMethodTable, proc, locktag, rec->lockmode, true);
4495}
4496
4497/*
4498 * 2PC processing routine for ROLLBACK PREPARED case.
4499 *
4500 * This is actually just the same as the COMMIT case.
4501 */
4502void
4504 void *recdata, uint32 len)
4505{
4506 lock_twophase_postcommit(xid, info, recdata, len);
4507}
4508
4509/*
4510 * VirtualXactLockTableInsert
4511 *
4512 * Take vxid lock via the fast-path. There can't be any pre-existing
4513 * lockers, as we haven't advertised this vxid via the ProcArray yet.
4514 *
4515 * Since MyProc->fpLocalTransactionId will normally contain the same data
4516 * as MyProc->vxid.lxid, you might wonder if we really need both. The
4517 * difference is that MyProc->vxid.lxid is set and cleared unlocked, and
4518 * examined by procarray.c, while fpLocalTransactionId is protected by
4519 * fpInfoLock and is used only by the locking subsystem. Doing it this
4520 * way makes it easier to verify that there are no funny race conditions.
4521 *
4522 * We don't bother recording this lock in the local lock table, since it's
4523 * only ever released at the end of a transaction. Instead,
4524 * LockReleaseAll() calls VirtualXactLockTableCleanup().
4525 */
4526void
4528{
4530
4532
4535 Assert(MyProc->fpVXIDLock == false);
4536
4537 MyProc->fpVXIDLock = true;
4539
4541}
4542
4543/*
4544 * VirtualXactLockTableCleanup
4545 *
4546 * Check whether a VXID lock has been materialized; if so, release it,
4547 * unblocking waiters.
4548 */
4549void
4551{
4552 bool fastpath;
4553 LocalTransactionId lxid;
4554
4556
4557 /*
4558 * Clean up shared memory state.
4559 */
4561
4562 fastpath = MyProc->fpVXIDLock;
4564 MyProc->fpVXIDLock = false;
4566
4568
4569 /*
4570 * If fpVXIDLock has been cleared without touching fpLocalTransactionId,
4571 * that means someone transferred the lock to the main lock table.
4572 */
4573 if (!fastpath && LocalTransactionIdIsValid(lxid))
4574 {
4576 LOCKTAG locktag;
4577
4578 vxid.procNumber = MyProcNumber;
4579 vxid.localTransactionId = lxid;
4580 SET_LOCKTAG_VIRTUALTRANSACTION(locktag, vxid);
4581
4583 &locktag, ExclusiveLock, false);
4584 }
4585}
4586
4587/*
4588 * XactLockForVirtualXact
4589 *
4590 * If TransactionIdIsValid(xid), this is essentially XactLockTableWait(xid,
4591 * NULL, NULL, XLTW_None) or ConditionalXactLockTableWait(xid). Unlike those
4592 * functions, it assumes "xid" is never a subtransaction and that "xid" is
4593 * prepared, committed, or aborted.
4594 *
4595 * If !TransactionIdIsValid(xid), this locks every prepared XID having been
4596 * known as "vxid" before its PREPARE TRANSACTION.
4597 */
4598static bool
4600 TransactionId xid, bool wait)
4601{
4602 bool more = false;
4603
4604 /* There is no point to wait for 2PCs if you have no 2PCs. */
4605 if (max_prepared_xacts == 0)
4606 return true;
4607
4608 do
4609 {
4611 LOCKTAG tag;
4612
4613 /* Clear state from previous iterations. */
4614 if (more)
4615 {
4617 more = false;
4618 }
4619
4620 /* If we have no xid, try to find one. */
4621 if (!TransactionIdIsValid(xid))
4622 xid = TwoPhaseGetXidByVirtualXID(vxid, &more);
4623 if (!TransactionIdIsValid(xid))
4624 {
4625 Assert(!more);
4626 return true;
4627 }
4628
4629 /* Check or wait for XID completion. */
4630 SET_LOCKTAG_TRANSACTION(tag, xid);
4631 lar = LockAcquire(&tag, ShareLock, false, !wait);
4632 if (lar == LOCKACQUIRE_NOT_AVAIL)
4633 return false;
4634 LockRelease(&tag, ShareLock, false);
4635 } while (more);
4636
4637 return true;
4638}
4639
4640/*
4641 * VirtualXactLock
4642 *
4643 * If wait = true, wait as long as the given VXID or any XID acquired by the
4644 * same transaction is still running. Then, return true.
4645 *
4646 * If wait = false, just check whether that VXID or one of those XIDs is still
4647 * running, and return true or false.
4648 */
4649bool
4651{
4652 LOCKTAG tag;
4653 PGPROC *proc;
4655
4657
4659 /* no vxid lock; localTransactionId is a normal, locked XID */
4660 return XactLockForVirtualXact(vxid, vxid.localTransactionId, wait);
4661
4663
4664 /*
4665 * If a lock table entry must be made, this is the PGPROC on whose behalf
4666 * it must be done. Note that the transaction might end or the PGPROC
4667 * might be reassigned to a new backend before we get around to examining
4668 * it, but it doesn't matter. If we find upon examination that the
4669 * relevant lxid is no longer running here, that's enough to prove that
4670 * it's no longer running anywhere.
4671 */
4672 proc = ProcNumberGetProc(vxid.procNumber);
4673 if (proc == NULL)
4674 return XactLockForVirtualXact(vxid, InvalidTransactionId, wait);
4675
4676 /*
4677 * We must acquire this lock before checking the procNumber and lxid
4678 * against the ones we're waiting for. The target backend will only set
4679 * or clear lxid while holding this lock.
4680 */
4682
4683 if (proc->vxid.procNumber != vxid.procNumber
4685 {
4686 /* VXID ended */
4687 LWLockRelease(&proc->fpInfoLock);
4688 return XactLockForVirtualXact(vxid, InvalidTransactionId, wait);
4689 }
4690
4691 /*
4692 * If we aren't asked to wait, there's no need to set up a lock table
4693 * entry. The transaction is still in progress, so just return false.
4694 */
4695 if (!wait)
4696 {
4697 LWLockRelease(&proc->fpInfoLock);
4698 return false;
4699 }
4700
4701 /*
4702 * OK, we're going to need to sleep on the VXID. But first, we must set
4703 * up the primary lock table entry, if needed (ie, convert the proc's
4704 * fast-path lock on its VXID to a regular lock).
4705 */
4706 if (proc->fpVXIDLock)
4707 {
4708 PROCLOCK *proclock;
4709 uint32 hashcode;
4710 LWLock *partitionLock;
4711
4712 hashcode = LockTagHashCode(&tag);
4713
4714 partitionLock = LockHashPartitionLock(hashcode);
4715 LWLockAcquire(partitionLock, LW_EXCLUSIVE);
4716
4718 &tag, hashcode, ExclusiveLock);
4719 if (!proclock)
4720 {
4721 LWLockRelease(partitionLock);
4722 LWLockRelease(&proc->fpInfoLock);
4723 ereport(ERROR,
4724 (errcode(ERRCODE_OUT_OF_MEMORY),
4725 errmsg("out of shared memory"),
4726 errhint("You might need to increase \"%s\".", "max_locks_per_transaction")));
4727 }
4728 GrantLock(proclock->tag.myLock, proclock, ExclusiveLock);
4729
4730 LWLockRelease(partitionLock);
4731
4732 proc->fpVXIDLock = false;
4733 }
4734
4735 /*
4736 * If the proc has an XID now, we'll avoid a TwoPhaseGetXidByVirtualXID()
4737 * search. The proc might have assigned this XID but not yet locked it,
4738 * in which case the proc will lock this XID before releasing the VXID.
4739 * The fpInfoLock critical section excludes VirtualXactLockTableCleanup(),
4740 * so we won't save an XID of a different VXID. It doesn't matter whether
4741 * we save this before or after setting up the primary lock table entry.
4742 */
4743 xid = proc->xid;
4744
4745 /* Done with proc->fpLockBits */
4746 LWLockRelease(&proc->fpInfoLock);
4747
4748 /* Time to wait. */
4749 (void) LockAcquire(&tag, ShareLock, false, false);
4750
4751 LockRelease(&tag, ShareLock, false);
4752 return XactLockForVirtualXact(vxid, xid, wait);
4753}
4754
4755/*
4756 * LockWaiterCount
4757 *
4758 * Find the number of lock requester on this locktag
4759 */
4760int
4762{
4763 LOCKMETHODID lockmethodid = locktag->locktag_lockmethodid;
4764 LOCK *lock;
4765 bool found;
4766 uint32 hashcode;
4767 LWLock *partitionLock;
4768 int waiters = 0;
4769
4770 if (lockmethodid <= 0 || lockmethodid >= lengthof(LockMethods))
4771 elog(ERROR, "unrecognized lock method: %d", lockmethodid);
4772
4773 hashcode = LockTagHashCode(locktag);
4774 partitionLock = LockHashPartitionLock(hashcode);
4775 LWLockAcquire(partitionLock, LW_EXCLUSIVE);
4776
4778 locktag,
4779 hashcode,
4780 HASH_FIND,
4781 &found);
4782 if (found)
4783 {
4784 Assert(lock != NULL);
4785 waiters = lock->nRequested;
4786 }
4787 LWLockRelease(partitionLock);
4788
4789 return waiters;
4790}
static uint64 pg_atomic_read_u64(volatile pg_atomic_uint64 *ptr)
Definition: atomics.h:467
#define Max(x, y)
Definition: c.h:952
#define Assert(condition)
Definition: c.h:812
uint16_t uint16
Definition: c.h:484
uint32_t uint32
Definition: c.h:485
#define lengthof(array)
Definition: c.h:742
uint32 LocalTransactionId
Definition: c.h:608
#define MemSet(start, val, len)
Definition: c.h:974
uint32 TransactionId
Definition: c.h:606
size_t Size
Definition: c.h:559
int64 TimestampTz
Definition: timestamp.h:39
void DeadLockReport(void)
Definition: deadlock.c:1072
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:955
void hash_destroy(HTAB *hashp)
Definition: dynahash.c:865
void * hash_search_with_hash_value(HTAB *hashp, const void *keyPtr, uint32 hashvalue, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:968
void * hash_seq_search(HASH_SEQ_STATUS *status)
Definition: dynahash.c:1420
long hash_get_num_entries(HTAB *hashp)
Definition: dynahash.c:1341
Size hash_estimate_size(long num_entries, Size entrysize)
Definition: dynahash.c:783
HTAB * hash_create(const char *tabname, long nelem, const HASHCTL *info, int flags)
Definition: dynahash.c:352
bool hash_update_hash_key(HTAB *hashp, void *existingEntry, const void *newKeyPtr)
Definition: dynahash.c:1145
uint32 get_hash_value(HTAB *hashp, const void *keyPtr)
Definition: dynahash.c:911
void hash_seq_init(HASH_SEQ_STATUS *status, HTAB *hashp)
Definition: dynahash.c:1385
int errhint(const char *fmt,...)
Definition: elog.c:1317
int errcode(int sqlerrcode)
Definition: elog.c:853
int errmsg(const char *fmt,...)
Definition: elog.c:1070
#define LOG
Definition: elog.h:31
#define PG_RE_THROW()
Definition: elog.h:412
#define PG_TRY(...)
Definition: elog.h:371
#define WARNING
Definition: elog.h:36
#define PG_END_TRY(...)
Definition: elog.h:396
#define PANIC
Definition: elog.h:42
#define ERROR
Definition: elog.h:39
#define PG_CATCH(...)
Definition: elog.h:381
#define elog(elevel,...)
Definition: elog.h:225
#define ereport(elevel,...)
Definition: elog.h:149
ProcNumber MyProcNumber
Definition: globals.c:89
int MaxBackends
Definition: globals.c:145
@ HASH_FIND
Definition: hsearch.h:113
@ HASH_REMOVE
Definition: hsearch.h:115
@ HASH_ENTER
Definition: hsearch.h:114
@ HASH_ENTER_NULL
Definition: hsearch.h:116
#define HASH_CONTEXT
Definition: hsearch.h:102
#define HASH_ELEM
Definition: hsearch.h:95
#define HASH_FUNCTION
Definition: hsearch.h:98
#define HASH_BLOBS
Definition: hsearch.h:97
#define HASH_PARTITION
Definition: hsearch.h:92
#define dlist_foreach(iter, lhead)
Definition: ilist.h:623
static void dlist_init(dlist_head *head)
Definition: ilist.h:314
static void dlist_delete(dlist_node *node)
Definition: ilist.h:405
static uint32 dclist_count(const dclist_head *head)
Definition: ilist.h:932
static bool dclist_is_empty(const dclist_head *head)
Definition: ilist.h:682
#define dlist_foreach_modify(iter, lhead)
Definition: ilist.h:640
static bool dlist_is_empty(const dlist_head *head)
Definition: ilist.h:336
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 void dclist_init(dclist_head *head)
Definition: ilist.h:671
#define dlist_container(type, membername, ptr)
Definition: ilist.h:593
#define dclist_foreach(iter, lhead)
Definition: ilist.h:970
int j
Definition: isn.c:73
int i
Definition: isn.c:72
static bool XactLockForVirtualXact(VirtualTransactionId vxid, TransactionId xid, bool wait)
Definition: lock.c:4599
LockAcquireResult LockAcquire(const LOCKTAG *locktag, LOCKMODE lockmode, bool sessionLock, bool dontWait)
Definition: lock.c:803
static LOCALLOCK * awaitedLock
Definition: lock.c:323
static void RemoveLocalLock(LOCALLOCK *locallock)
Definition: lock.c:1425
LockAcquireResult LockAcquireExtended(const LOCKTAG *locktag, LOCKMODE lockmode, bool sessionLock, bool dontWait, bool reportMemoryError, LOCALLOCK **locallockp)
Definition: lock.c:827
static void LockReassignOwner(LOCALLOCK *locallock, ResourceOwner parent)
Definition: lock.c:2645
bool LockHeldByMe(const LOCKTAG *locktag, LOCKMODE lockmode, bool orstronger)
Definition: lock.c:637
static bool Dummy_trace
Definition: lock.c:120
static const char *const lock_mode_names[]
Definition: lock.c:106
#define LOCK_PRINT(where, lock, type)
Definition: lock.c:400
bool DoLockModesConflict(LOCKMODE mode1, LOCKMODE mode2)
Definition: lock.c:617
static PROCLOCK * SetupLockInTable(LockMethod lockMethodTable, PGPROC *proc, const LOCKTAG *locktag, uint32 hashcode, LOCKMODE lockmode)
Definition: lock.c:1232
static PROCLOCK * FastPathGetRelationLockEntry(LOCALLOCK *locallock)
Definition: lock.c:2865
void VirtualXactLockTableInsert(VirtualTransactionId vxid)
Definition: lock.c:4527
#define NLOCKENTS()
Definition: lock.c:54
#define FastPathStrongLockHashPartition(hashcode)
Definition: lock.c:298
static uint32 ProcLockHashCode(const PROCLOCKTAG *proclocktag, uint32 hashcode)
Definition: lock.c:599
#define FAST_PATH_CHECK_LOCKMODE(proc, n, l)
Definition: lock.c:251
void GrantAwaitedLock(void)
Definition: lock.c:1838
int LockWaiterCount(const LOCKTAG *locktag)
Definition: lock.c:4761
void AtPrepare_Locks(void)
Definition: lock.c:3383
bool LockRelease(const LOCKTAG *locktag, LOCKMODE lockmode, bool sessionLock)
Definition: lock.c:2011
void lock_twophase_postcommit(TransactionId xid, uint16 info, void *recdata, uint32 len)
Definition: lock.c:4477
#define FAST_PATH_LOCKNUMBER_OFFSET
Definition: lock.c:237
Size LockManagerShmemSize(void)
Definition: lock.c:3663
#define FAST_PATH_REL_GROUP(rel)
Definition: lock.c:212
void InitLockManagerAccess(void)
Definition: lock.c:499
void GrantLock(LOCK *lock, PROCLOCK *proclock, LOCKMODE lockmode)
Definition: lock.c:1607
void VirtualXactLockTableCleanup(void)
Definition: lock.c:4550
bool VirtualXactLock(VirtualTransactionId vxid, bool wait)
Definition: lock.c:4650
VirtualTransactionId * GetLockConflicts(const LOCKTAG *locktag, LOCKMODE lockmode, int *countp)
Definition: lock.c:2976
static volatile FastPathStrongRelationLockData * FastPathStrongRelationLocks
Definition: lock.c:307
void RemoveFromWaitQueue(PGPROC *proc, uint32 hashcode)
Definition: lock.c:1955
void LockReleaseAll(LOCKMETHODID lockmethodid, bool allLocks)
Definition: lock.c:2216
#define FAST_PATH_SLOT(group, index)
Definition: lock.c:219
static void CheckAndSetLockHeld(LOCALLOCK *locallock, bool acquired)
Definition: lock.c:1413
#define ConflictsWithRelationFastPath(locktag, mode)
Definition: lock.c:268
static bool FastPathTransferRelationLocks(LockMethod lockMethodTable, const LOCKTAG *locktag, uint32 hashcode)
Definition: lock.c:2770
static HTAB * LockMethodLocalHash
Definition: lock.c:318
void LockReassignCurrentOwner(LOCALLOCK **locallocks, int nlocks)
Definition: lock.c:2615
static bool UnGrantLock(LOCK *lock, LOCKMODE lockmode, PROCLOCK *proclock, LockMethod lockMethodTable)
Definition: lock.c:1630
#define FAST_PATH_SET_LOCKMODE(proc, n, l)
Definition: lock.c:247
#define PROCLOCK_PRINT(where, proclockP)
Definition: lock.c:401
static void CleanUpLock(LOCK *lock, PROCLOCK *proclock, LockMethod lockMethodTable, uint32 hashcode, bool wakeupNeeded)
Definition: lock.c:1687
static uint32 proclock_hash(const void *key, Size keysize)
Definition: lock.c:568
static bool FastPathUnGrantRelationLock(Oid relid, LOCKMODE lockmode)
Definition: lock.c:2734
void AbortStrongLockAcquire(void)
Definition: lock.c:1809
static bool FastPathGrantRelationLock(Oid relid, LOCKMODE lockmode)
Definition: lock.c:2691
static int FastPathLocalUseCounts[FP_LOCK_GROUPS_PER_BACKEND_MAX]
Definition: lock.c:174
static HTAB * LockMethodLockHash
Definition: lock.c:316
static ResourceOwner awaitedOwner
Definition: lock.c:324
BlockedProcsData * GetBlockerStatusData(int blocked_pid)
Definition: lock.c:3903
void LockManagerShmemInit(void)
Definition: lock.c:438
void lock_twophase_postabort(TransactionId xid, uint16 info, void *recdata, uint32 len)
Definition: lock.c:4503
static ProcWaitStatus WaitOnLock(LOCALLOCK *locallock, ResourceOwner owner)
Definition: lock.c:1872
bool LockHasWaiters(const LOCKTAG *locktag, LOCKMODE lockmode, bool sessionLock)
Definition: lock.c:690
const char * GetLockmodeName(LOCKMETHODID lockmethodid, LOCKMODE mode)
Definition: lock.c:4160
static void GetSingleProcBlockerStatusData(PGPROC *blocked_proc, BlockedProcsData *data)
Definition: lock.c:3983
#define FAST_PATH_CLEAR_LOCKMODE(proc, n, l)
Definition: lock.c:249
int max_locks_per_xact
Definition: lock.c:52
static const LockMethod LockMethods[]
Definition: lock.c:148
void lock_twophase_standby_recover(TransactionId xid, uint16 info, void *recdata, uint32 len)
Definition: lock.c:4445
void LockReleaseCurrentOwner(LOCALLOCK **locallocks, int nlocks)
Definition: lock.c:2520
LOCALLOCK * GetAwaitedLock(void)
Definition: lock.c:1847
void lock_twophase_recover(TransactionId xid, uint16 info, void *recdata, uint32 len)
Definition: lock.c:4264
void LockReleaseSession(LOCKMETHODID lockmethodid)
Definition: lock.c:2490
void MarkLockClear(LOCALLOCK *locallock)
Definition: lock.c:1860
LockData * GetLockStatusData(void)
Definition: lock.c:3700
static bool IsRelationExtensionLockHeld PG_USED_FOR_ASSERTS_ONLY
Definition: lock.c:189
static const LockMethodData default_lockmethod
Definition: lock.c:123
#define FAST_PATH_GET_BITS(proc, n)
Definition: lock.c:240
static LOCALLOCK * StrongLockInProgress
Definition: lock.c:322
#define FAST_PATH_BITS_PER_SLOT
Definition: lock.c:236
static const LockMethodData user_lockmethod
Definition: lock.c:134
int FastPathLockGroupsPerBackend
Definition: lock.c:200
#define EligibleForRelationFastPath(locktag, mode)
Definition: lock.c:262
uint32 LockTagHashCode(const LOCKTAG *locktag)
Definition: lock.c:551
static void BeginStrongLockAcquire(LOCALLOCK *locallock, uint32 fasthashcode)
Definition: lock.c:1773
bool LockCheckConflicts(LockMethod lockMethodTable, LOCKMODE lockmode, LOCK *lock, PROCLOCK *proclock)
Definition: lock.c:1478
static void GrantLockLocal(LOCALLOCK *locallock, ResourceOwner owner)
Definition: lock.c:1741
static const LOCKMASK LockConflicts[]
Definition: lock.c:63
static void ReleaseLockIfHeld(LOCALLOCK *locallock, bool sessionLock)
Definition: lock.c:2555
LockMethod GetLocksMethodTable(const LOCK *lock)
Definition: lock.c:521
static void FinishStrongLockAcquire(void)
Definition: lock.c:1799
#define FAST_PATH_STRONG_LOCK_HASH_PARTITIONS
Definition: lock.c:296
void PostPrepare_Locks(TransactionId xid)
Definition: lock.c:3479
xl_standby_lock * GetRunningTransactionLocks(int *nlocks)
Definition: lock.c:4078
static void LockRefindAndRelease(LockMethod lockMethodTable, PGPROC *proc, LOCKTAG *locktag, LOCKMODE lockmode, bool decrement_strong_lock_count)
Definition: lock.c:3191
static void CheckForSessionAndXactLocks(void)
Definition: lock.c:3295
static HTAB * LockMethodProcLockHash
Definition: lock.c:317
struct TwoPhaseLockRecord TwoPhaseLockRecord
LockMethod GetLockTagsMethodTable(const LOCKTAG *locktag)
Definition: lock.c:533
uint16 LOCKMETHODID
Definition: lock.h:122
#define DEFAULT_LOCKMETHOD
Definition: lock.h:125
struct LOCALLOCK LOCALLOCK
#define LOCK_LOCKTAG(lock)
Definition: lock.h:325
struct LOCK LOCK
#define SET_LOCKTAG_VIRTUALTRANSACTION(locktag, vxid)
Definition: lock.h:235
struct PROCLOCK PROCLOCK
@ LOCKTAG_OBJECT
Definition: lock.h:145
@ LOCKTAG_RELATION_EXTEND
Definition: lock.h:138
@ LOCKTAG_RELATION
Definition: lock.h:137
@ LOCKTAG_TUPLE
Definition: lock.h:141
@ LOCKTAG_VIRTUALTRANSACTION
Definition: lock.h:143
#define VirtualTransactionIdIsValid(vxid)
Definition: lock.h:67
#define LockHashPartitionLock(hashcode)
Definition: lock.h:526
#define GET_VXID_FROM_PGPROC(vxid_dst, proc)
Definition: lock.h:77
#define LOCK_LOCKMETHOD(lock)
Definition: lock.h:324
#define LOCKBIT_OFF(lockmode)
Definition: lock.h:85
#define LOCALLOCK_LOCKMETHOD(llock)
Definition: lock.h:443
#define InvalidLocalTransactionId
Definition: lock.h:65
#define SET_LOCKTAG_TRANSACTION(locktag, xid)
Definition: lock.h:226
struct LOCKTAG LOCKTAG
#define SET_LOCKTAG_RELATION(locktag, dboid, reloid)
Definition: lock.h:181
#define MAX_LOCKMODES
Definition: lock.h:82
struct PROCLOCKTAG PROCLOCKTAG
#define LOCKBIT_ON(lockmode)
Definition: lock.h:84
#define LocalTransactionIdIsValid(lxid)
Definition: lock.h:66
#define LOCALLOCK_LOCKTAG(llock)
Definition: lock.h:444
#define LockHashPartition(hashcode)
Definition: lock.h:524
#define VirtualTransactionIdEquals(vxid1, vxid2)
Definition: lock.h:71
struct LOCALLOCKTAG LOCALLOCKTAG
#define PROCLOCK_LOCKMETHOD(proclock)
Definition: lock.h:382
#define LockHashPartitionLockByIndex(i)
Definition: lock.h:529
LockAcquireResult
Definition: lock.h:500
@ LOCKACQUIRE_ALREADY_CLEAR
Definition: lock.h:504
@ LOCKACQUIRE_OK
Definition: lock.h:502
@ LOCKACQUIRE_ALREADY_HELD
Definition: lock.h:503
@ LOCKACQUIRE_NOT_AVAIL
Definition: lock.h:501
#define VirtualTransactionIdIsRecoveredPreparedXact(vxid)
Definition: lock.h:69
int LOCKMODE
Definition: lockdefs.h:26
#define NoLock
Definition: lockdefs.h:34
#define AccessExclusiveLock
Definition: lockdefs.h:43
#define ShareRowExclusiveLock
Definition: lockdefs.h:41
#define AccessShareLock
Definition: lockdefs.h:36
int LOCKMASK
Definition: lockdefs.h:25
#define ShareUpdateExclusiveLock
Definition: lockdefs.h:39
#define ExclusiveLock
Definition: lockdefs.h:42
#define RowShareLock
Definition: lockdefs.h:37
#define ShareLock
Definition: lockdefs.h:40
#define MaxLockMode
Definition: lockdefs.h:45
#define RowExclusiveLock
Definition: lockdefs.h:38
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1168
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1781
#define NUM_LOCK_PARTITIONS
Definition: lwlock.h:97
#define LOG2_NUM_LOCK_PARTITIONS
Definition: lwlock.h:96
@ LW_SHARED
Definition: lwlock.h:115
@ LW_EXCLUSIVE
Definition: lwlock.h:114
void * MemoryContextAlloc(MemoryContext context, Size size)
Definition: mcxt.c:1181
void * repalloc(void *pointer, Size size)
Definition: mcxt.c:1541
void pfree(void *pointer)
Definition: mcxt.c:1521
void * palloc0(Size size)
Definition: mcxt.c:1347
MemoryContext TopMemoryContext
Definition: mcxt.c:149
void * palloc(Size size)
Definition: mcxt.c:1317
MemoryContext CurrentMemoryContext
Definition: mcxt.c:143
#define START_CRIT_SECTION()
Definition: miscadmin.h:149
#define END_CRIT_SECTION()
Definition: miscadmin.h:151
static PgChecksumMode mode
Definition: pg_checksums.c:55
const void size_t len
const void * data
static Datum PointerGetDatum(const void *X)
Definition: postgres.h:322
uintptr_t Datum
Definition: postgres.h:64
unsigned int Oid
Definition: postgres_ext.h:31
#define FP_LOCK_GROUPS_PER_BACKEND_MAX
Definition: proc.h:83
#define FP_LOCK_SLOTS_PER_BACKEND
Definition: proc.h:85
#define FP_LOCK_SLOTS_PER_GROUP
Definition: proc.h:84
ProcWaitStatus
Definition: proc.h:123
@ PROC_WAIT_STATUS_OK
Definition: proc.h:124
@ PROC_WAIT_STATUS_WAITING
Definition: proc.h:125
@ PROC_WAIT_STATUS_ERROR
Definition: proc.h:126
PGPROC * BackendPidGetProcWithLock(int pid)
Definition: procarray.c:3219
PGPROC * ProcNumberGetProc(ProcNumber procNumber)
Definition: procarray.c:3138
#define INVALID_PROC_NUMBER
Definition: procnumber.h:26
void set_ps_display_remove_suffix(void)
Definition: ps_status.c:423
void set_ps_display_suffix(const char *suffix)
Definition: ps_status.c:371
void ResourceOwnerRememberLock(ResourceOwner owner, LOCALLOCK *locallock)
Definition: resowner.c:1045
ResourceOwner ResourceOwnerGetParent(ResourceOwner owner)
Definition: resowner.c:888
ResourceOwner CurrentResourceOwner
Definition: resowner.c:165
void ResourceOwnerForgetLock(ResourceOwner owner, LOCALLOCK *locallock)
Definition: resowner.c:1065
HTAB * ShmemInitHash(const char *name, long init_size, long max_size, HASHCTL *infoP, int hash_flags)
Definition: shmem.c:327
Size add_size(Size s1, Size s2)
Definition: shmem.c:488
void * ShmemInitStruct(const char *name, Size size, bool *foundPtr)
Definition: shmem.c:382
static pg_noinline void Size size
Definition: slab.c:607
#define SpinLockInit(lock)
Definition: spin.h:57
#define SpinLockRelease(lock)
Definition: spin.h:61
#define SpinLockAcquire(lock)
Definition: spin.h:59
ProcWaitStatus JoinWaitQueue(LOCALLOCK *locallock, LockMethod lockMethodTable, bool dontWait)
Definition: proc.c:1089
PGPROC * MyProc
Definition: proc.c:66
ProcWaitStatus ProcSleep(LOCALLOCK *locallock)
Definition: proc.c:1258
void ProcLockWakeup(LockMethod lockMethodTable, LOCK *lock)
Definition: proc.c:1736
PROC_HDR * ProcGlobal
Definition: proc.c:78
void LogAccessExclusiveLockPrepare(void)
Definition: standby.c:1436
void StandbyAcquireAccessExclusiveLock(TransactionId xid, Oid dbOid, Oid relOid)
Definition: standby.c:985
void LogAccessExclusiveLock(Oid dbOid, Oid relOid)
Definition: standby.c:1419
int first_lock
Definition: lock.h:476
int first_waiter
Definition: lock.h:480
int num_waiters
Definition: lock.h:481
int num_locks
Definition: lock.h:477
uint32 count[FAST_PATH_STRONG_LOCK_HASH_PARTITIONS]
Definition: lock.c:304
Size keysize
Definition: hsearch.h:75
HashValueFunc hash
Definition: hsearch.h:78
Size entrysize
Definition: hsearch.h:76
MemoryContext hcxt
Definition: hsearch.h:86
long num_partitions
Definition: hsearch.h:68
Definition: dynahash.c:220
int64 nLocks
Definition: lock.h:423
struct ResourceOwnerData * owner
Definition: lock.h:422
LOCKTAG lock
Definition: lock.h:410
LOCKMODE mode
Definition: lock.h:411
LOCALLOCKOWNER * lockOwners
Definition: lock.h:438
uint32 hashcode
Definition: lock.h:432
int maxLockOwners
Definition: lock.h:437
LOCK * lock
Definition: lock.h:433
int64 nLocks
Definition: lock.h:435
int numLockOwners
Definition: lock.h:436
bool holdsStrongLockCount
Definition: lock.h:439
PROCLOCK * proclock
Definition: lock.h:434
LOCALLOCKTAG tag
Definition: lock.h:429
bool lockCleared
Definition: lock.h:440
Definition: lock.h:165
uint8 locktag_type
Definition: lock.h:170
uint32 locktag_field3
Definition: lock.h:168
uint32 locktag_field1
Definition: lock.h:166
uint8 locktag_lockmethodid
Definition: lock.h:171
uint16 locktag_field4
Definition: lock.h:169
uint32 locktag_field2
Definition: lock.h:167
Definition: lock.h:309
int nRequested
Definition: lock.h:319
LOCKTAG tag
Definition: lock.h:311
int requested[MAX_LOCKMODES]
Definition: lock.h:318
dclist_head waitProcs
Definition: lock.h:317
int granted[MAX_LOCKMODES]
Definition: lock.h:320
LOCKMASK grantMask
Definition: lock.h:314
LOCKMASK waitMask
Definition: lock.h:315
int nGranted
Definition: lock.h:321
dlist_head procLocks
Definition: lock.h:316
Definition: lwlock.h:42
Definition: lock.h:466
LOCKMASK holdMask
Definition: lock.h:455
LOCKMODE waitLockMode
Definition: lock.h:456
bool fastpath
Definition: lock.h:462
LOCKTAG locktag
Definition: lock.h:454
TimestampTz waitStart
Definition: lock.h:458
int leaderPid
Definition: lock.h:461
VirtualTransactionId vxid
Definition: lock.h:457
const bool * trace_flag
Definition: lock.h:113
const LOCKMASK * conflictTab
Definition: lock.h:111
const char *const * lockModeNames
Definition: lock.h:112
int numLockModes
Definition: lock.h:110
Definition: proc.h:162
LWLock fpInfoLock
Definition: proc.h:293
LocalTransactionId lxid
Definition: proc.h:200
PROCLOCK * waitProcLock
Definition: proc.h:233
struct PGPROC::@123 vxid
dlist_head lockGroupMembers
Definition: proc.h:305
Oid * fpRelId
Definition: proc.h:295
Oid databaseId
Definition: proc.h:207
uint64 * fpLockBits
Definition: proc.h:294
pg_atomic_uint64 waitStart
Definition: proc.h:237
bool fpVXIDLock
Definition: proc.h:296
ProcNumber procNumber
Definition: proc.h:195
int pid
Definition: proc.h:182
LOCK * waitLock
Definition: proc.h:232
TransactionId xid
Definition: proc.h:172
LOCKMODE waitLockMode
Definition: proc.h:234
PGPROC * lockGroupLeader
Definition: proc.h:304
LocalTransactionId fpLocalTransactionId
Definition: proc.h:297
dlist_head myProcLocks[NUM_LOCK_PARTITIONS]
Definition: proc.h:261
ProcWaitStatus waitStatus
Definition: proc.h:167
dlist_node links
Definition: proc.h:163
LOCK * myLock
Definition: lock.h:365
PGPROC * myProc
Definition: lock.h:366
Definition: lock.h:370
LOCKMASK holdMask
Definition: lock.h:376
dlist_node lockLink
Definition: lock.h:378
PGPROC * groupLeader
Definition: lock.h:375
LOCKMASK releaseMask
Definition: lock.h:377
PROCLOCKTAG tag
Definition: lock.h:372
dlist_node procLink
Definition: lock.h:379
PGPROC * allProcs
Definition: proc.h:384
uint32 allProcCount
Definition: proc.h:402
LOCKTAG locktag
Definition: lock.c:158
LOCKMODE lockmode
Definition: lock.c:159
LocalTransactionId localTransactionId
Definition: lock.h:62
ProcNumber procNumber
Definition: lock.h:61
dlist_node * cur
Definition: ilist.h:179
dlist_node * cur
Definition: ilist.h:200
dlist_node * next
Definition: ilist.h:140
Definition: type.h:96
TransactionId xid
Definition: lockdefs.h:53
#define InvalidTransactionId
Definition: transam.h:31
#define FirstNormalObjectId
Definition: transam.h:197
#define TransactionIdIsValid(xid)
Definition: transam.h:41
void RegisterTwoPhaseRecord(TwoPhaseRmgrId rmid, uint16 info, const void *data, uint32 len)
Definition: twophase.c:1265
int max_prepared_xacts
Definition: twophase.c:115
TransactionId TwoPhaseGetXidByVirtualXID(VirtualTransactionId vxid, bool *have_more)
Definition: twophase.c:852
PGPROC * TwoPhaseGetDummyProc(TransactionId xid, bool lock_held)
Definition: twophase.c:918
#define TWOPHASE_RM_LOCK_ID
Definition: twophase_rmgr.h:25
const char * type
bool RecoveryInProgress(void)
Definition: xlog.c:6334
#define XLogStandbyInfoActive()
Definition: xlog.h:123
bool InRecovery
Definition: xlogutils.c:50
#define InHotStandby
Definition: xlogutils.h:60
static struct link * links
Definition: zic.c:299