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