PostgreSQL Source Code git master
proc.c
Go to the documentation of this file.
1/*-------------------------------------------------------------------------
2 *
3 * proc.c
4 * routines to manage per-process shared memory data structure
5 *
6 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
7 * Portions Copyright (c) 1994, Regents of the University of California
8 *
9 *
10 * IDENTIFICATION
11 * src/backend/storage/lmgr/proc.c
12 *
13 *-------------------------------------------------------------------------
14 */
15/*
16 * Interface (a):
17 * JoinWaitQueue(), ProcSleep(), ProcWakeup()
18 *
19 * Waiting for a lock causes the backend to be put to sleep. Whoever releases
20 * the lock wakes the process up again (and gives it an error code so it knows
21 * whether it was awoken on an error condition).
22 *
23 * Interface (b):
24 *
25 * ProcReleaseLocks -- frees the locks associated with current transaction
26 *
27 * ProcKill -- destroys the shared memory state (and locks)
28 * associated with the process.
29 */
30#include "postgres.h"
31
32#include <signal.h>
33#include <unistd.h>
34#include <sys/time.h>
35
36#include "access/transam.h"
37#include "access/twophase.h"
38#include "access/xlogutils.h"
39#include "miscadmin.h"
40#include "pgstat.h"
43#include "replication/syncrep.h"
45#include "storage/ipc.h"
46#include "storage/lmgr.h"
47#include "storage/pmsignal.h"
48#include "storage/proc.h"
49#include "storage/procarray.h"
50#include "storage/procsignal.h"
51#include "storage/spin.h"
52#include "storage/standby.h"
53#include "utils/timeout.h"
54#include "utils/timestamp.h"
55
56/* GUC variables */
57int DeadlockTimeout = 1000;
63bool log_lock_waits = false;
64
65/* Pointer to this process's PGPROC struct, if any */
66PGPROC *MyProc = NULL;
67
68/*
69 * This spinlock protects the freelist of recycled PGPROC structures.
70 * We cannot use an LWLock because the LWLock manager depends on already
71 * having a PGPROC and a wait semaphore! But these structures are touched
72 * relatively infrequently (only at backend startup or shutdown) and not for
73 * very long, so a spinlock is okay.
74 */
76
77/* Pointers to shared-memory structures */
81
83
84/* Is a deadlock check pending? */
85static volatile sig_atomic_t got_deadlock_timeout;
86
87static void RemoveProcFromArray(int code, Datum arg);
88static void ProcKill(int code, Datum arg);
89static void AuxiliaryProcKill(int code, Datum arg);
90static void CheckDeadLock(void);
91
92
93/*
94 * Report shared-memory space needed by InitProcGlobal.
95 */
96Size
98{
99 Size size = 0;
100 Size TotalProcs =
102 Size fpLockBitsSize,
103 fpRelIdSize;
104
105 /* ProcGlobal */
106 size = add_size(size, sizeof(PROC_HDR));
107 size = add_size(size, mul_size(TotalProcs, sizeof(PGPROC)));
108 size = add_size(size, sizeof(slock_t));
109
110 size = add_size(size, mul_size(TotalProcs, sizeof(*ProcGlobal->xids)));
111 size = add_size(size, mul_size(TotalProcs, sizeof(*ProcGlobal->subxidStates)));
112 size = add_size(size, mul_size(TotalProcs, sizeof(*ProcGlobal->statusFlags)));
113
114 /*
115 * Memory needed for PGPROC fast-path lock arrays. Make sure the sizes are
116 * nicely aligned in each backend.
117 */
118 fpLockBitsSize = MAXALIGN(FastPathLockGroupsPerBackend * sizeof(uint64));
120
121 size = add_size(size, mul_size(TotalProcs, (fpLockBitsSize + fpRelIdSize)));
122
123 return size;
124}
125
126/*
127 * Report number of semaphores needed by InitProcGlobal.
128 */
129int
131{
132 /*
133 * We need a sema per backend (including autovacuum), plus one for each
134 * auxiliary process.
135 */
137}
138
139/*
140 * InitProcGlobal -
141 * Initialize the global process table during postmaster or standalone
142 * backend startup.
143 *
144 * We also create all the per-process semaphores we will need to support
145 * the requested number of backends. We used to allocate semaphores
146 * only when backends were actually started up, but that is bad because
147 * it lets Postgres fail under load --- a lot of Unix systems are
148 * (mis)configured with small limits on the number of semaphores, and
149 * running out when trying to start another backend is a common failure.
150 * So, now we grab enough semaphores to support the desired max number
151 * of backends immediately at initialization --- if the sysadmin has set
152 * MaxConnections, max_worker_processes, max_wal_senders, or
153 * autovacuum_worker_slots higher than his kernel will support, he'll
154 * find out sooner rather than later.
155 *
156 * Another reason for creating semaphores here is that the semaphore
157 * implementation typically requires us to create semaphores in the
158 * postmaster, not in backends.
159 *
160 * Note: this is NOT called by individual backends under a postmaster,
161 * not even in the EXEC_BACKEND case. The ProcGlobal and AuxiliaryProcs
162 * pointers must be propagated specially for EXEC_BACKEND operation.
163 */
164void
166{
167 PGPROC *procs;
168 int i,
169 j;
170 bool found;
172
173 /* Used for setup of per-backend fast-path slots. */
174 char *fpPtr,
175 *fpEndPtr PG_USED_FOR_ASSERTS_ONLY;
176 Size fpLockBitsSize,
177 fpRelIdSize;
178
179 /* Create the ProcGlobal shared structure */
180 ProcGlobal = (PROC_HDR *)
181 ShmemInitStruct("Proc Header", sizeof(PROC_HDR), &found);
182 Assert(!found);
183
184 /*
185 * Initialize the data structures.
186 */
197
198 /*
199 * Create and initialize all the PGPROC structures we'll need. There are
200 * six separate consumers: (1) normal backends, (2) autovacuum workers and
201 * special workers, (3) background workers, (4) walsenders, (5) auxiliary
202 * processes, and (6) prepared transactions. (For largely-historical
203 * reasons, we combine autovacuum and special workers into one category
204 * with a single freelist.) Each PGPROC structure is dedicated to exactly
205 * one of these purposes, and they do not move between groups.
206 */
207 procs = (PGPROC *) ShmemAlloc(TotalProcs * sizeof(PGPROC));
208 MemSet(procs, 0, TotalProcs * sizeof(PGPROC));
209 ProcGlobal->allProcs = procs;
210 /* XXX allProcCount isn't really all of them; it excludes prepared xacts */
212
213 /*
214 * Allocate arrays mirroring PGPROC fields in a dense manner. See
215 * PROC_HDR.
216 *
217 * XXX: It might make sense to increase padding for these arrays, given
218 * how hotly they are accessed.
219 */
221 (TransactionId *) ShmemAlloc(TotalProcs * sizeof(*ProcGlobal->xids));
222 MemSet(ProcGlobal->xids, 0, TotalProcs * sizeof(*ProcGlobal->xids));
224 MemSet(ProcGlobal->subxidStates, 0, TotalProcs * sizeof(*ProcGlobal->subxidStates));
225 ProcGlobal->statusFlags = (uint8 *) ShmemAlloc(TotalProcs * sizeof(*ProcGlobal->statusFlags));
226 MemSet(ProcGlobal->statusFlags, 0, TotalProcs * sizeof(*ProcGlobal->statusFlags));
227
228 /*
229 * Allocate arrays for fast-path locks. Those are variable-length, so
230 * can't be included in PGPROC directly. We allocate a separate piece of
231 * shared memory and then divide that between backends.
232 */
233 fpLockBitsSize = MAXALIGN(FastPathLockGroupsPerBackend * sizeof(uint64));
235
236 fpPtr = ShmemAlloc(TotalProcs * (fpLockBitsSize + fpRelIdSize));
237 MemSet(fpPtr, 0, TotalProcs * (fpLockBitsSize + fpRelIdSize));
238
239 /* For asserts checking we did not overflow. */
240 fpEndPtr = fpPtr + (TotalProcs * (fpLockBitsSize + fpRelIdSize));
241
242 for (i = 0; i < TotalProcs; i++)
243 {
244 PGPROC *proc = &procs[i];
245
246 /* Common initialization for all PGPROCs, regardless of type. */
247
248 /*
249 * Set the fast-path lock arrays, and move the pointer. We interleave
250 * the two arrays, to (hopefully) get some locality for each backend.
251 */
252 proc->fpLockBits = (uint64 *) fpPtr;
253 fpPtr += fpLockBitsSize;
254
255 proc->fpRelId = (Oid *) fpPtr;
256 fpPtr += fpRelIdSize;
257
258 Assert(fpPtr <= fpEndPtr);
259
260 /*
261 * Set up per-PGPROC semaphore, latch, and fpInfoLock. Prepared xact
262 * dummy PGPROCs don't need these though - they're never associated
263 * with a real process
264 */
266 {
267 proc->sem = PGSemaphoreCreate();
268 InitSharedLatch(&(proc->procLatch));
270 }
271
272 /*
273 * Newly created PGPROCs for normal backends, autovacuum workers,
274 * special workers, bgworkers, and walsenders must be queued up on the
275 * appropriate free list. Because there can only ever be a small,
276 * fixed number of auxiliary processes, no free list is used in that
277 * case; InitAuxiliaryProcess() instead uses a linear search. PGPROCs
278 * for prepared transactions are added to a free list by
279 * TwoPhaseShmemInit().
280 */
281 if (i < MaxConnections)
282 {
283 /* PGPROC for normal backend, add to freeProcs list */
286 }
288 {
289 /* PGPROC for AV or special worker, add to autovacFreeProcs list */
292 }
294 {
295 /* PGPROC for bgworker, add to bgworkerFreeProcs list */
298 }
299 else if (i < MaxBackends)
300 {
301 /* PGPROC for walsender, add to walsenderFreeProcs list */
304 }
305
306 /* Initialize myProcLocks[] shared memory queues. */
307 for (j = 0; j < NUM_LOCK_PARTITIONS; j++)
308 dlist_init(&(proc->myProcLocks[j]));
309
310 /* Initialize lockGroupMembers list. */
312
313 /*
314 * Initialize the atomic variables, otherwise, it won't be safe to
315 * access them for backends that aren't currently in use.
316 */
319 pg_atomic_init_u64(&(proc->waitStart), 0);
320 }
321
322 /* Should have consumed exactly the expected amount of fast-path memory. */
323 Assert(fpPtr == fpEndPtr);
324
325 /*
326 * Save pointers to the blocks of PGPROC structures reserved for auxiliary
327 * processes and prepared transactions.
328 */
329 AuxiliaryProcs = &procs[MaxBackends];
331
332 /* Create ProcStructLock spinlock, too */
333 ProcStructLock = (slock_t *) ShmemAlloc(sizeof(slock_t));
335}
336
337/*
338 * InitProcess -- initialize a per-process PGPROC entry for this backend
339 */
340void
342{
343 dlist_head *procgloballist;
344
345 /*
346 * ProcGlobal should be set up already (if we are a backend, we inherit
347 * this by fork() or EXEC_BACKEND mechanism from the postmaster).
348 */
349 if (ProcGlobal == NULL)
350 elog(PANIC, "proc header uninitialized");
351
352 if (MyProc != NULL)
353 elog(ERROR, "you already exist");
354
355 /*
356 * Before we start accessing the shared memory in a serious way, mark
357 * ourselves as an active postmaster child; this is so that the postmaster
358 * can detect it if we exit without cleaning up.
359 */
362
363 /*
364 * Decide which list should supply our PGPROC. This logic must match the
365 * way the freelists were constructed in InitProcGlobal().
366 */
368 procgloballist = &ProcGlobal->autovacFreeProcs;
369 else if (AmBackgroundWorkerProcess())
370 procgloballist = &ProcGlobal->bgworkerFreeProcs;
371 else if (AmWalSenderProcess())
372 procgloballist = &ProcGlobal->walsenderFreeProcs;
373 else
374 procgloballist = &ProcGlobal->freeProcs;
375
376 /*
377 * Try to get a proc struct from the appropriate free list. If this
378 * fails, we must be out of PGPROC structures (not to mention semaphores).
379 *
380 * While we are holding the ProcStructLock, also copy the current shared
381 * estimate of spins_per_delay to local storage.
382 */
384
386
387 if (!dlist_is_empty(procgloballist))
388 {
391 }
392 else
393 {
394 /*
395 * If we reach here, all the PGPROCs are in use. This is one of the
396 * possible places to detect "too many backends", so give the standard
397 * error message. XXX do we need to give a different failure message
398 * in the autovacuum case?
399 */
401 if (AmWalSenderProcess())
403 (errcode(ERRCODE_TOO_MANY_CONNECTIONS),
404 errmsg("number of requested standby connections exceeds \"max_wal_senders\" (currently %d)",
407 (errcode(ERRCODE_TOO_MANY_CONNECTIONS),
408 errmsg("sorry, too many clients already")));
409 }
411
412 /*
413 * Cross-check that the PGPROC is of the type we expect; if this were not
414 * the case, it would get returned to the wrong list.
415 */
416 Assert(MyProc->procgloballist == procgloballist);
417
418 /*
419 * Initialize all fields of MyProc, except for those previously
420 * initialized by InitProcGlobal.
421 */
424 MyProc->fpVXIDLock = false;
431 /* databaseId and roleId will be filled in later */
437 MyProc->statusFlags = 0;
438 /* NB -- autovac launcher intentionally does not set IS_AUTOVACUUM */
442 MyProc->lwWaitMode = 0;
443 MyProc->waitLock = NULL;
444 MyProc->waitProcLock = NULL;
446#ifdef USE_ASSERT_CHECKING
447 {
448 int i;
449
450 /* Last process should have released all locks. */
451 for (i = 0; i < NUM_LOCK_PARTITIONS; i++)
453 }
454#endif
456
457 /* Initialize fields for sync rep */
458 MyProc->waitLSN = 0;
461
462 /* Initialize fields for group XID clearing. */
466
467 /* Check that group locking fields are in a proper initial state. */
468 Assert(MyProc->lockGroupLeader == NULL);
470
471 /* Initialize wait event information. */
473
474 /* Initialize fields for group transaction status update. */
475 MyProc->clogGroupMember = false;
481
482 /*
483 * Acquire ownership of the PGPROC's latch, so that we can use WaitLatch
484 * on it. That allows us to repoint the process latch, which so far
485 * points to process local one, to the shared one.
486 */
489
490 /* now that we have a proc, report wait events to shared memory */
492
493 /*
494 * We might be reusing a semaphore that belonged to a failed process. So
495 * be careful and reinitialize its value here. (This is not strictly
496 * necessary anymore, but seems like a good idea for cleanliness.)
497 */
499
500 /*
501 * Arrange to clean up at backend exit.
502 */
504
505 /*
506 * Now that we have a PGPROC, we could try to acquire locks, so initialize
507 * local state needed for LWLocks, and the deadlock checker.
508 */
511
512#ifdef EXEC_BACKEND
513
514 /*
515 * Initialize backend-local pointers to all the shared data structures.
516 * (We couldn't do this until now because it needs LWLocks.)
517 */
519 AttachSharedMemoryStructs();
520#endif
521}
522
523/*
524 * InitProcessPhase2 -- make MyProc visible in the shared ProcArray.
525 *
526 * This is separate from InitProcess because we can't acquire LWLocks until
527 * we've created a PGPROC, but in the EXEC_BACKEND case ProcArrayAdd won't
528 * work until after we've done AttachSharedMemoryStructs.
529 */
530void
532{
533 Assert(MyProc != NULL);
534
535 /*
536 * Add our PGPROC to the PGPROC array in shared memory.
537 */
539
540 /*
541 * Arrange to clean that up at backend exit.
542 */
544}
545
546/*
547 * InitAuxiliaryProcess -- create a PGPROC entry for an auxiliary process
548 *
549 * This is called by bgwriter and similar processes so that they will have a
550 * MyProc value that's real enough to let them wait for LWLocks. The PGPROC
551 * and sema that are assigned are one of the extra ones created during
552 * InitProcGlobal.
553 *
554 * Auxiliary processes are presently not expected to wait for real (lockmgr)
555 * locks, so we need not set up the deadlock checker. They are never added
556 * to the ProcArray or the sinval messaging mechanism, either. They also
557 * don't get a VXID assigned, since this is only useful when we actually
558 * hold lockmgr locks.
559 *
560 * Startup process however uses locks but never waits for them in the
561 * normal backend sense. Startup process also takes part in sinval messaging
562 * as a sendOnly process, so never reads messages from sinval queue. So
563 * Startup process does have a VXID and does show up in pg_locks.
564 */
565void
567{
568 PGPROC *auxproc;
569 int proctype;
570
571 /*
572 * ProcGlobal should be set up already (if we are a backend, we inherit
573 * this by fork() or EXEC_BACKEND mechanism from the postmaster).
574 */
575 if (ProcGlobal == NULL || AuxiliaryProcs == NULL)
576 elog(PANIC, "proc header uninitialized");
577
578 if (MyProc != NULL)
579 elog(ERROR, "you already exist");
580
583
584 /*
585 * We use the ProcStructLock to protect assignment and releasing of
586 * AuxiliaryProcs entries.
587 *
588 * While we are holding the ProcStructLock, also copy the current shared
589 * estimate of spins_per_delay to local storage.
590 */
592
594
595 /*
596 * Find a free auxproc ... *big* trouble if there isn't one ...
597 */
598 for (proctype = 0; proctype < NUM_AUXILIARY_PROCS; proctype++)
599 {
600 auxproc = &AuxiliaryProcs[proctype];
601 if (auxproc->pid == 0)
602 break;
603 }
604 if (proctype >= NUM_AUXILIARY_PROCS)
605 {
607 elog(FATAL, "all AuxiliaryProcs are in use");
608 }
609
610 /* Mark auxiliary proc as in use by me */
611 /* use volatile pointer to prevent code rearrangement */
612 ((volatile PGPROC *) auxproc)->pid = MyProcPid;
613
615
616 MyProc = auxproc;
618
619 /*
620 * Initialize all fields of MyProc, except for those previously
621 * initialized by InitProcGlobal.
622 */
625 MyProc->fpVXIDLock = false;
634 MyProc->isRegularBackend = false;
636 MyProc->statusFlags = 0;
638 MyProc->lwWaitMode = 0;
639 MyProc->waitLock = NULL;
640 MyProc->waitProcLock = NULL;
642#ifdef USE_ASSERT_CHECKING
643 {
644 int i;
645
646 /* Last process should have released all locks. */
647 for (i = 0; i < NUM_LOCK_PARTITIONS; i++)
649 }
650#endif
651
652 /*
653 * Acquire ownership of the PGPROC's latch, so that we can use WaitLatch
654 * on it. That allows us to repoint the process latch, which so far
655 * points to process local one, to the shared one.
656 */
659
660 /* now that we have a proc, report wait events to shared memory */
662
663 /* Check that group locking fields are in a proper initial state. */
664 Assert(MyProc->lockGroupLeader == NULL);
666
667 /*
668 * We might be reusing a semaphore that belonged to a failed process. So
669 * be careful and reinitialize its value here. (This is not strictly
670 * necessary anymore, but seems like a good idea for cleanliness.)
671 */
673
674 /*
675 * Arrange to clean up at process exit.
676 */
678
679 /*
680 * Now that we have a PGPROC, we could try to acquire lightweight locks.
681 * Initialize local state needed for them. (Heavyweight locks cannot be
682 * acquired in aux processes.)
683 */
685
686#ifdef EXEC_BACKEND
687
688 /*
689 * Initialize backend-local pointers to all the shared data structures.
690 * (We couldn't do this until now because it needs LWLocks.)
691 */
693 AttachSharedMemoryStructs();
694#endif
695}
696
697/*
698 * Used from bufmgr to share the value of the buffer that Startup waits on,
699 * or to reset the value to "not waiting" (-1). This allows processing
700 * of recovery conflicts for buffer pins. Set is made before backends look
701 * at this value, so locking not required, especially since the set is
702 * an atomic integer set operation.
703 */
704void
706{
707 /* use volatile pointer to prevent code rearrangement */
708 volatile PROC_HDR *procglobal = ProcGlobal;
709
710 procglobal->startupBufferPinWaitBufId = bufid;
711}
712
713/*
714 * Used by backends when they receive a request to check for buffer pin waits.
715 */
716int
718{
719 /* use volatile pointer to prevent code rearrangement */
720 volatile PROC_HDR *procglobal = ProcGlobal;
721
722 return procglobal->startupBufferPinWaitBufId;
723}
724
725/*
726 * Check whether there are at least N free PGPROC objects. If false is
727 * returned, *nfree will be set to the number of free PGPROC objects.
728 * Otherwise, *nfree will be set to n.
729 *
730 * Note: this is designed on the assumption that N will generally be small.
731 */
732bool
733HaveNFreeProcs(int n, int *nfree)
734{
735 dlist_iter iter;
736
737 Assert(n > 0);
738 Assert(nfree);
739
741
742 *nfree = 0;
744 {
745 (*nfree)++;
746 if (*nfree == n)
747 break;
748 }
749
751
752 return (*nfree == n);
753}
754
755/*
756 * Cancel any pending wait for lock, when aborting a transaction, and revert
757 * any strong lock count acquisition for a lock being acquired.
758 *
759 * (Normally, this would only happen if we accept a cancel/die
760 * interrupt while waiting; but an ereport(ERROR) before or during the lock
761 * wait is within the realm of possibility, too.)
762 */
763void
765{
766 LOCALLOCK *lockAwaited;
767 LWLock *partitionLock;
768 DisableTimeoutParams timeouts[2];
769
771
773
774 /* Nothing to do if we weren't waiting for a lock */
775 lockAwaited = GetAwaitedLock();
776 if (lockAwaited == NULL)
777 {
779 return;
780 }
781
782 /*
783 * Turn off the deadlock and lock timeout timers, if they are still
784 * running (see ProcSleep). Note we must preserve the LOCK_TIMEOUT
785 * indicator flag, since this function is executed before
786 * ProcessInterrupts when responding to SIGINT; else we'd lose the
787 * knowledge that the SIGINT came from a lock timeout and not an external
788 * source.
789 */
790 timeouts[0].id = DEADLOCK_TIMEOUT;
791 timeouts[0].keep_indicator = false;
792 timeouts[1].id = LOCK_TIMEOUT;
793 timeouts[1].keep_indicator = true;
794 disable_timeouts(timeouts, 2);
795
796 /* Unlink myself from the wait queue, if on it (might not be anymore!) */
797 partitionLock = LockHashPartitionLock(lockAwaited->hashcode);
798 LWLockAcquire(partitionLock, LW_EXCLUSIVE);
799
801 {
802 /* We could not have been granted the lock yet */
803 RemoveFromWaitQueue(MyProc, lockAwaited->hashcode);
804 }
805 else
806 {
807 /*
808 * Somebody kicked us off the lock queue already. Perhaps they
809 * granted us the lock, or perhaps they detected a deadlock. If they
810 * did grant us the lock, we'd better remember it in our local lock
811 * table.
812 */
815 }
816
817 LWLockRelease(partitionLock);
818
820}
821
822
823/*
824 * ProcReleaseLocks() -- release locks associated with current transaction
825 * at main transaction commit or abort
826 *
827 * At main transaction commit, we release standard locks except session locks.
828 * At main transaction abort, we release all locks including session locks.
829 *
830 * Advisory locks are released only if they are transaction-level;
831 * session-level holds remain, whether this is a commit or not.
832 *
833 * At subtransaction commit, we don't release any locks (so this func is not
834 * needed at all); we will defer the releasing to the parent transaction.
835 * At subtransaction abort, we release all locks held by the subtransaction;
836 * this is implemented by retail releasing of the locks under control of
837 * the ResourceOwner mechanism.
838 */
839void
840ProcReleaseLocks(bool isCommit)
841{
842 if (!MyProc)
843 return;
844 /* If waiting, get off wait queue (should only be needed after error) */
846 /* Release standard locks, including session-level if aborting */
848 /* Release transaction-level advisory locks */
850}
851
852
853/*
854 * RemoveProcFromArray() -- Remove this process from the shared ProcArray.
855 */
856static void
858{
859 Assert(MyProc != NULL);
861}
862
863/*
864 * ProcKill() -- Destroy the per-proc data structure for
865 * this process. Release any of its held LW locks.
866 */
867static void
869{
870 PGPROC *proc;
871 dlist_head *procgloballist;
872
873 Assert(MyProc != NULL);
874
875 /* not safe if forked by system(), etc. */
876 if (MyProc->pid != (int) getpid())
877 elog(PANIC, "ProcKill() called in child process");
878
879 /* Make sure we're out of the sync rep lists */
881
882#ifdef USE_ASSERT_CHECKING
883 {
884 int i;
885
886 /* Last process should have released all locks. */
887 for (i = 0; i < NUM_LOCK_PARTITIONS; i++)
889 }
890#endif
891
892 /*
893 * Release any LW locks I am holding. There really shouldn't be any, but
894 * it's cheap to check again before we cut the knees off the LWLock
895 * facility by releasing our PGPROC ...
896 */
898
899 /* Cancel any pending condition variable sleep, too */
901
902 /*
903 * Detach from any lock group of which we are a member. If the leader
904 * exits before all other group members, its PGPROC will remain allocated
905 * until the last group process exits; that process must return the
906 * leader's PGPROC to the appropriate list.
907 */
908 if (MyProc->lockGroupLeader != NULL)
909 {
910 PGPROC *leader = MyProc->lockGroupLeader;
911 LWLock *leader_lwlock = LockHashPartitionLockByProc(leader);
912
913 LWLockAcquire(leader_lwlock, LW_EXCLUSIVE);
916 if (dlist_is_empty(&leader->lockGroupMembers))
917 {
918 leader->lockGroupLeader = NULL;
919 if (leader != MyProc)
920 {
921 procgloballist = leader->procgloballist;
922
923 /* Leader exited first; return its PGPROC. */
925 dlist_push_head(procgloballist, &leader->links);
927 }
928 }
929 else if (leader != MyProc)
930 MyProc->lockGroupLeader = NULL;
931 LWLockRelease(leader_lwlock);
932 }
933
934 /*
935 * Reset MyLatch to the process local one. This is so that signal
936 * handlers et al can continue using the latch after the shared latch
937 * isn't ours anymore.
938 *
939 * Similarly, stop reporting wait events to MyProc->wait_event_info.
940 *
941 * After that clear MyProc and disown the shared latch.
942 */
945
946 proc = MyProc;
947 MyProc = NULL;
949 DisownLatch(&proc->procLatch);
950
951 /* Mark the proc no longer in use */
952 proc->pid = 0;
955
956 procgloballist = proc->procgloballist;
958
959 /*
960 * If we're still a member of a locking group, that means we're a leader
961 * which has somehow exited before its children. The last remaining child
962 * will release our PGPROC. Otherwise, release it now.
963 */
964 if (proc->lockGroupLeader == NULL)
965 {
966 /* Since lockGroupLeader is NULL, lockGroupMembers should be empty. */
968
969 /* Return PGPROC structure (and semaphore) to appropriate freelist */
970 dlist_push_tail(procgloballist, &proc->links);
971 }
972
973 /* Update shared estimate of spins_per_delay */
975
977
978 /* wake autovac launcher if needed -- see comments in FreeWorkerInfo */
979 if (AutovacuumLauncherPid != 0)
981}
982
983/*
984 * AuxiliaryProcKill() -- Cut-down version of ProcKill for auxiliary
985 * processes (bgwriter, etc). The PGPROC and sema are not released, only
986 * marked as not-in-use.
987 */
988static void
990{
991 int proctype = DatumGetInt32(arg);
993 PGPROC *proc;
994
995 Assert(proctype >= 0 && proctype < NUM_AUXILIARY_PROCS);
996
997 /* not safe if forked by system(), etc. */
998 if (MyProc->pid != (int) getpid())
999 elog(PANIC, "AuxiliaryProcKill() called in child process");
1000
1001 auxproc = &AuxiliaryProcs[proctype];
1002
1003 Assert(MyProc == auxproc);
1004
1005 /* Release any LW locks I am holding (see notes above) */
1007
1008 /* Cancel any pending condition variable sleep, too */
1010
1011 /* look at the equivalent ProcKill() code for comments */
1014
1015 proc = MyProc;
1016 MyProc = NULL;
1018 DisownLatch(&proc->procLatch);
1019
1021
1022 /* Mark auxiliary proc no longer in use */
1023 proc->pid = 0;
1026
1027 /* Update shared estimate of spins_per_delay */
1029
1031}
1032
1033/*
1034 * AuxiliaryPidGetProc -- get PGPROC for an auxiliary process
1035 * given its PID
1036 *
1037 * Returns NULL if not found.
1038 */
1039PGPROC *
1041{
1042 PGPROC *result = NULL;
1043 int index;
1044
1045 if (pid == 0) /* never match dummy PGPROCs */
1046 return NULL;
1047
1048 for (index = 0; index < NUM_AUXILIARY_PROCS; index++)
1049 {
1050 PGPROC *proc = &AuxiliaryProcs[index];
1051
1052 if (proc->pid == pid)
1053 {
1054 result = proc;
1055 break;
1056 }
1057 }
1058 return result;
1059}
1060
1061
1062/*
1063 * JoinWaitQueue -- join the wait queue on the specified lock
1064 *
1065 * It's not actually guaranteed that we need to wait when this function is
1066 * called, because it could be that when we try to find a position at which
1067 * to insert ourself into the wait queue, we discover that we must be inserted
1068 * ahead of everyone who wants a lock that conflict with ours. In that case,
1069 * we get the lock immediately. Because of this, it's sensible for this function
1070 * to have a dontWait argument, despite the name.
1071 *
1072 * On entry, the caller has already set up LOCK and PROCLOCK entries to
1073 * reflect that we have "requested" the lock. The caller is responsible for
1074 * cleaning that up, if we end up not joining the queue after all.
1075 *
1076 * The lock table's partition lock must be held at entry, and is still held
1077 * at exit. The caller must release it before calling ProcSleep().
1078 *
1079 * Result is one of the following:
1080 *
1081 * PROC_WAIT_STATUS_OK - lock was immediately granted
1082 * PROC_WAIT_STATUS_WAITING - joined the wait queue; call ProcSleep()
1083 * PROC_WAIT_STATUS_ERROR - immediate deadlock was detected, or would
1084 * need to wait and dontWait == true
1085 *
1086 * NOTES: The process queue is now a priority queue for locking.
1087 */
1089JoinWaitQueue(LOCALLOCK *locallock, LockMethod lockMethodTable, bool dontWait)
1090{
1091 LOCKMODE lockmode = locallock->tag.mode;
1092 LOCK *lock = locallock->lock;
1093 PROCLOCK *proclock = locallock->proclock;
1094 uint32 hashcode = locallock->hashcode;
1095 LWLock *partitionLock PG_USED_FOR_ASSERTS_ONLY = LockHashPartitionLock(hashcode);
1096 dclist_head *waitQueue = &lock->waitProcs;
1097 PGPROC *insert_before = NULL;
1098 LOCKMASK myProcHeldLocks;
1099 LOCKMASK myHeldLocks;
1100 bool early_deadlock = false;
1101 PGPROC *leader = MyProc->lockGroupLeader;
1102
1103 Assert(LWLockHeldByMeInMode(partitionLock, LW_EXCLUSIVE));
1104
1105 /*
1106 * Set bitmask of locks this process already holds on this object.
1107 */
1108 myHeldLocks = MyProc->heldLocks = proclock->holdMask;
1109
1110 /*
1111 * Determine which locks we're already holding.
1112 *
1113 * If group locking is in use, locks held by members of my locking group
1114 * need to be included in myHeldLocks. This is not required for relation
1115 * extension lock which conflict among group members. However, including
1116 * them in myHeldLocks will give group members the priority to get those
1117 * locks as compared to other backends which are also trying to acquire
1118 * those locks. OTOH, we can avoid giving priority to group members for
1119 * that kind of locks, but there doesn't appear to be a clear advantage of
1120 * the same.
1121 */
1122 myProcHeldLocks = proclock->holdMask;
1123 myHeldLocks = myProcHeldLocks;
1124 if (leader != NULL)
1125 {
1126 dlist_iter iter;
1127
1128 dlist_foreach(iter, &lock->procLocks)
1129 {
1130 PROCLOCK *otherproclock;
1131
1132 otherproclock = dlist_container(PROCLOCK, lockLink, iter.cur);
1133
1134 if (otherproclock->groupLeader == leader)
1135 myHeldLocks |= otherproclock->holdMask;
1136 }
1137 }
1138
1139 /*
1140 * Determine where to add myself in the wait queue.
1141 *
1142 * Normally I should go at the end of the queue. However, if I already
1143 * hold locks that conflict with the request of any previous waiter, put
1144 * myself in the queue just in front of the first such waiter. This is not
1145 * a necessary step, since deadlock detection would move me to before that
1146 * waiter anyway; but it's relatively cheap to detect such a conflict
1147 * immediately, and avoid delaying till deadlock timeout.
1148 *
1149 * Special case: if I find I should go in front of some waiter, check to
1150 * see if I conflict with already-held locks or the requests before that
1151 * waiter. If not, then just grant myself the requested lock immediately.
1152 * This is the same as the test for immediate grant in LockAcquire, except
1153 * we are only considering the part of the wait queue before my insertion
1154 * point.
1155 */
1156 if (myHeldLocks != 0 && !dclist_is_empty(waitQueue))
1157 {
1158 LOCKMASK aheadRequests = 0;
1159 dlist_iter iter;
1160
1161 dclist_foreach(iter, waitQueue)
1162 {
1163 PGPROC *proc = dlist_container(PGPROC, links, iter.cur);
1164
1165 /*
1166 * If we're part of the same locking group as this waiter, its
1167 * locks neither conflict with ours nor contribute to
1168 * aheadRequests.
1169 */
1170 if (leader != NULL && leader == proc->lockGroupLeader)
1171 continue;
1172
1173 /* Must he wait for me? */
1174 if (lockMethodTable->conflictTab[proc->waitLockMode] & myHeldLocks)
1175 {
1176 /* Must I wait for him ? */
1177 if (lockMethodTable->conflictTab[lockmode] & proc->heldLocks)
1178 {
1179 /*
1180 * Yes, so we have a deadlock. Easiest way to clean up
1181 * correctly is to call RemoveFromWaitQueue(), but we
1182 * can't do that until we are *on* the wait queue. So, set
1183 * a flag to check below, and break out of loop. Also,
1184 * record deadlock info for later message.
1185 */
1186 RememberSimpleDeadLock(MyProc, lockmode, lock, proc);
1187 early_deadlock = true;
1188 break;
1189 }
1190 /* I must go before this waiter. Check special case. */
1191 if ((lockMethodTable->conflictTab[lockmode] & aheadRequests) == 0 &&
1192 !LockCheckConflicts(lockMethodTable, lockmode, lock,
1193 proclock))
1194 {
1195 /* Skip the wait and just grant myself the lock. */
1196 GrantLock(lock, proclock, lockmode);
1197 return PROC_WAIT_STATUS_OK;
1198 }
1199
1200 /* Put myself into wait queue before conflicting process */
1201 insert_before = proc;
1202 break;
1203 }
1204 /* Nope, so advance to next waiter */
1205 aheadRequests |= LOCKBIT_ON(proc->waitLockMode);
1206 }
1207 }
1208
1209 /*
1210 * If we detected deadlock, give up without waiting. This must agree with
1211 * CheckDeadLock's recovery code.
1212 */
1213 if (early_deadlock)
1215
1216 /*
1217 * At this point we know that we'd really need to sleep. If we've been
1218 * commanded not to do that, bail out.
1219 */
1220 if (dontWait)
1222
1223 /*
1224 * Insert self into queue, at the position determined above.
1225 */
1226 if (insert_before)
1227 dclist_insert_before(waitQueue, &insert_before->links, &MyProc->links);
1228 else
1229 dclist_push_tail(waitQueue, &MyProc->links);
1230
1231 lock->waitMask |= LOCKBIT_ON(lockmode);
1232
1233 /* Set up wait information in PGPROC object, too */
1234 MyProc->heldLocks = myProcHeldLocks;
1235 MyProc->waitLock = lock;
1236 MyProc->waitProcLock = proclock;
1237 MyProc->waitLockMode = lockmode;
1238
1240
1242}
1243
1244/*
1245 * ProcSleep -- put process to sleep waiting on lock
1246 *
1247 * This must be called when JoinWaitQueue() returns PROC_WAIT_STATUS_WAITING.
1248 * Returns after the lock has been granted, or if a deadlock is detected. Can
1249 * also bail out with ereport(ERROR), if some other error condition, or a
1250 * timeout or cancellation is triggered.
1251 *
1252 * Result is one of the following:
1253 *
1254 * PROC_WAIT_STATUS_OK - lock was granted
1255 * PROC_WAIT_STATUS_ERROR - a deadlock was detected
1256 */
1259{
1260 LOCKMODE lockmode = locallock->tag.mode;
1261 LOCK *lock = locallock->lock;
1262 uint32 hashcode = locallock->hashcode;
1263 LWLock *partitionLock = LockHashPartitionLock(hashcode);
1264 TimestampTz standbyWaitStart = 0;
1265 bool allow_autovacuum_cancel = true;
1266 bool logged_recovery_conflict = false;
1267 ProcWaitStatus myWaitStatus;
1268
1269 /* The caller must've armed the on-error cleanup mechanism */
1270 Assert(GetAwaitedLock() == locallock);
1271 Assert(!LWLockHeldByMe(partitionLock));
1272
1273 /*
1274 * Now that we will successfully clean up after an ereport, it's safe to
1275 * check to see if there's a buffer pin deadlock against the Startup
1276 * process. Of course, that's only necessary if we're doing Hot Standby
1277 * and are not the Startup process ourselves.
1278 */
1281
1282 /* Reset deadlock_state before enabling the timeout handler */
1284 got_deadlock_timeout = false;
1285
1286 /*
1287 * Set timer so we can wake up after awhile and check for a deadlock. If a
1288 * deadlock is detected, the handler sets MyProc->waitStatus =
1289 * PROC_WAIT_STATUS_ERROR, allowing us to know that we must report failure
1290 * rather than success.
1291 *
1292 * By delaying the check until we've waited for a bit, we can avoid
1293 * running the rather expensive deadlock-check code in most cases.
1294 *
1295 * If LockTimeout is set, also enable the timeout for that. We can save a
1296 * few cycles by enabling both timeout sources in one call.
1297 *
1298 * If InHotStandby we set lock waits slightly later for clarity with other
1299 * code.
1300 */
1301 if (!InHotStandby)
1302 {
1303 if (LockTimeout > 0)
1304 {
1305 EnableTimeoutParams timeouts[2];
1306
1307 timeouts[0].id = DEADLOCK_TIMEOUT;
1308 timeouts[0].type = TMPARAM_AFTER;
1309 timeouts[0].delay_ms = DeadlockTimeout;
1310 timeouts[1].id = LOCK_TIMEOUT;
1311 timeouts[1].type = TMPARAM_AFTER;
1312 timeouts[1].delay_ms = LockTimeout;
1313 enable_timeouts(timeouts, 2);
1314 }
1315 else
1317
1318 /*
1319 * Use the current time obtained for the deadlock timeout timer as
1320 * waitStart (i.e., the time when this process started waiting for the
1321 * lock). Since getting the current time newly can cause overhead, we
1322 * reuse the already-obtained time to avoid that overhead.
1323 *
1324 * Note that waitStart is updated without holding the lock table's
1325 * partition lock, to avoid the overhead by additional lock
1326 * acquisition. This can cause "waitstart" in pg_locks to become NULL
1327 * for a very short period of time after the wait started even though
1328 * "granted" is false. This is OK in practice because we can assume
1329 * that users are likely to look at "waitstart" when waiting for the
1330 * lock for a long time.
1331 */
1334 }
1336 {
1337 /*
1338 * Set the wait start timestamp if logging is enabled and in hot
1339 * standby.
1340 */
1341 standbyWaitStart = GetCurrentTimestamp();
1342 }
1343
1344 /*
1345 * If somebody wakes us between LWLockRelease and WaitLatch, the latch
1346 * will not wait. But a set latch does not necessarily mean that the lock
1347 * is free now, as there are many other sources for latch sets than
1348 * somebody releasing the lock.
1349 *
1350 * We process interrupts whenever the latch has been set, so cancel/die
1351 * interrupts are processed quickly. This means we must not mind losing
1352 * control to a cancel/die interrupt here. We don't, because we have no
1353 * shared-state-change work to do after being granted the lock (the
1354 * grantor did it all). We do have to worry about canceling the deadlock
1355 * timeout and updating the locallock table, but if we lose control to an
1356 * error, LockErrorCleanup will fix that up.
1357 */
1358 do
1359 {
1360 if (InHotStandby)
1361 {
1362 bool maybe_log_conflict =
1363 (standbyWaitStart != 0 && !logged_recovery_conflict);
1364
1365 /* Set a timer and wait for that or for the lock to be granted */
1367 maybe_log_conflict);
1368
1369 /*
1370 * Emit the log message if the startup process is waiting longer
1371 * than deadlock_timeout for recovery conflict on lock.
1372 */
1373 if (maybe_log_conflict)
1374 {
1376
1377 if (TimestampDifferenceExceeds(standbyWaitStart, now,
1379 {
1380 VirtualTransactionId *vxids;
1381 int cnt;
1382
1383 vxids = GetLockConflicts(&locallock->tag.lock,
1384 AccessExclusiveLock, &cnt);
1385
1386 /*
1387 * Log the recovery conflict and the list of PIDs of
1388 * backends holding the conflicting lock. Note that we do
1389 * logging even if there are no such backends right now
1390 * because the startup process here has already waited
1391 * longer than deadlock_timeout.
1392 */
1394 standbyWaitStart, now,
1395 cnt > 0 ? vxids : NULL, true);
1396 logged_recovery_conflict = true;
1397 }
1398 }
1399 }
1400 else
1401 {
1403 PG_WAIT_LOCK | locallock->tag.lock.locktag_type);
1405 /* check for deadlocks first, as that's probably log-worthy */
1407 {
1408 CheckDeadLock();
1409 got_deadlock_timeout = false;
1410 }
1412 }
1413
1414 /*
1415 * waitStatus could change from PROC_WAIT_STATUS_WAITING to something
1416 * else asynchronously. Read it just once per loop to prevent
1417 * surprising behavior (such as missing log messages).
1418 */
1419 myWaitStatus = *((volatile ProcWaitStatus *) &MyProc->waitStatus);
1420
1421 /*
1422 * If we are not deadlocked, but are waiting on an autovacuum-induced
1423 * task, send a signal to interrupt it.
1424 */
1425 if (deadlock_state == DS_BLOCKED_BY_AUTOVACUUM && allow_autovacuum_cancel)
1426 {
1428 uint8 statusFlags;
1429 uint8 lockmethod_copy;
1430 LOCKTAG locktag_copy;
1431
1432 /*
1433 * Grab info we need, then release lock immediately. Note this
1434 * coding means that there is a tiny chance that the process
1435 * terminates its current transaction and starts a different one
1436 * before we have a change to send the signal; the worst possible
1437 * consequence is that a for-wraparound vacuum is canceled. But
1438 * that could happen in any case unless we were to do kill() with
1439 * the lock held, which is much more undesirable.
1440 */
1441 LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
1442 statusFlags = ProcGlobal->statusFlags[autovac->pgxactoff];
1443 lockmethod_copy = lock->tag.locktag_lockmethodid;
1444 locktag_copy = lock->tag;
1445 LWLockRelease(ProcArrayLock);
1446
1447 /*
1448 * Only do it if the worker is not working to protect against Xid
1449 * wraparound.
1450 */
1451 if ((statusFlags & PROC_IS_AUTOVACUUM) &&
1452 !(statusFlags & PROC_VACUUM_FOR_WRAPAROUND))
1453 {
1454 int pid = autovac->pid;
1455
1456 /* report the case, if configured to do so */
1458 {
1459 StringInfoData locktagbuf;
1460 StringInfoData logbuf; /* errdetail for server log */
1461
1462 initStringInfo(&locktagbuf);
1463 initStringInfo(&logbuf);
1464 DescribeLockTag(&locktagbuf, &locktag_copy);
1465 appendStringInfo(&logbuf,
1466 "Process %d waits for %s on %s.",
1467 MyProcPid,
1468 GetLockmodeName(lockmethod_copy, lockmode),
1469 locktagbuf.data);
1470
1472 (errmsg_internal("sending cancel to blocking autovacuum PID %d",
1473 pid),
1474 errdetail_log("%s", logbuf.data)));
1475
1476 pfree(locktagbuf.data);
1477 pfree(logbuf.data);
1478 }
1479
1480 /* send the autovacuum worker Back to Old Kent Road */
1481 if (kill(pid, SIGINT) < 0)
1482 {
1483 /*
1484 * There's a race condition here: once we release the
1485 * ProcArrayLock, it's possible for the autovac worker to
1486 * close up shop and exit before we can do the kill().
1487 * Therefore, we do not whinge about no-such-process.
1488 * Other errors such as EPERM could conceivably happen if
1489 * the kernel recycles the PID fast enough, but such cases
1490 * seem improbable enough that it's probably best to issue
1491 * a warning if we see some other errno.
1492 */
1493 if (errno != ESRCH)
1495 (errmsg("could not send signal to process %d: %m",
1496 pid)));
1497 }
1498 }
1499
1500 /* prevent signal from being sent again more than once */
1501 allow_autovacuum_cancel = false;
1502 }
1503
1504 /*
1505 * If awoken after the deadlock check interrupt has run, and
1506 * log_lock_waits is on, then report about the wait.
1507 */
1509 {
1511 lock_waiters_sbuf,
1512 lock_holders_sbuf;
1513 const char *modename;
1514 long secs;
1515 int usecs;
1516 long msecs;
1517 dlist_iter proc_iter;
1518 PROCLOCK *curproclock;
1519 bool first_holder = true,
1520 first_waiter = true;
1521 int lockHoldersNum = 0;
1522
1524 initStringInfo(&lock_waiters_sbuf);
1525 initStringInfo(&lock_holders_sbuf);
1526
1527 DescribeLockTag(&buf, &locallock->tag.lock);
1528 modename = GetLockmodeName(locallock->tag.lock.locktag_lockmethodid,
1529 lockmode);
1532 &secs, &usecs);
1533 msecs = secs * 1000 + usecs / 1000;
1534 usecs = usecs % 1000;
1535
1536 /*
1537 * we loop over the lock's procLocks to gather a list of all
1538 * holders and waiters. Thus we will be able to provide more
1539 * detailed information for lock debugging purposes.
1540 *
1541 * lock->procLocks contains all processes which hold or wait for
1542 * this lock.
1543 */
1544
1545 LWLockAcquire(partitionLock, LW_SHARED);
1546
1547 dlist_foreach(proc_iter, &lock->procLocks)
1548 {
1549 curproclock =
1550 dlist_container(PROCLOCK, lockLink, proc_iter.cur);
1551
1552 /*
1553 * we are a waiter if myProc->waitProcLock == curproclock; we
1554 * are a holder if it is NULL or something different
1555 */
1556 if (curproclock->tag.myProc->waitProcLock == curproclock)
1557 {
1558 if (first_waiter)
1559 {
1560 appendStringInfo(&lock_waiters_sbuf, "%d",
1561 curproclock->tag.myProc->pid);
1562 first_waiter = false;
1563 }
1564 else
1565 appendStringInfo(&lock_waiters_sbuf, ", %d",
1566 curproclock->tag.myProc->pid);
1567 }
1568 else
1569 {
1570 if (first_holder)
1571 {
1572 appendStringInfo(&lock_holders_sbuf, "%d",
1573 curproclock->tag.myProc->pid);
1574 first_holder = false;
1575 }
1576 else
1577 appendStringInfo(&lock_holders_sbuf, ", %d",
1578 curproclock->tag.myProc->pid);
1579
1580 lockHoldersNum++;
1581 }
1582 }
1583
1584 LWLockRelease(partitionLock);
1585
1587 ereport(LOG,
1588 (errmsg("process %d avoided deadlock for %s on %s by rearranging queue order after %ld.%03d ms",
1589 MyProcPid, modename, buf.data, msecs, usecs),
1590 (errdetail_log_plural("Process holding the lock: %s. Wait queue: %s.",
1591 "Processes holding the lock: %s. Wait queue: %s.",
1592 lockHoldersNum, lock_holders_sbuf.data, lock_waiters_sbuf.data))));
1593 else if (deadlock_state == DS_HARD_DEADLOCK)
1594 {
1595 /*
1596 * This message is a bit redundant with the error that will be
1597 * reported subsequently, but in some cases the error report
1598 * might not make it to the log (eg, if it's caught by an
1599 * exception handler), and we want to ensure all long-wait
1600 * events get logged.
1601 */
1602 ereport(LOG,
1603 (errmsg("process %d detected deadlock while waiting for %s on %s after %ld.%03d ms",
1604 MyProcPid, modename, buf.data, msecs, usecs),
1605 (errdetail_log_plural("Process holding the lock: %s. Wait queue: %s.",
1606 "Processes holding the lock: %s. Wait queue: %s.",
1607 lockHoldersNum, lock_holders_sbuf.data, lock_waiters_sbuf.data))));
1608 }
1609
1610 if (myWaitStatus == PROC_WAIT_STATUS_WAITING)
1611 ereport(LOG,
1612 (errmsg("process %d still waiting for %s on %s after %ld.%03d ms",
1613 MyProcPid, modename, buf.data, msecs, usecs),
1614 (errdetail_log_plural("Process holding the lock: %s. Wait queue: %s.",
1615 "Processes holding the lock: %s. Wait queue: %s.",
1616 lockHoldersNum, lock_holders_sbuf.data, lock_waiters_sbuf.data))));
1617 else if (myWaitStatus == PROC_WAIT_STATUS_OK)
1618 ereport(LOG,
1619 (errmsg("process %d acquired %s on %s after %ld.%03d ms",
1620 MyProcPid, modename, buf.data, msecs, usecs)));
1621 else
1622 {
1623 Assert(myWaitStatus == PROC_WAIT_STATUS_ERROR);
1624
1625 /*
1626 * Currently, the deadlock checker always kicks its own
1627 * process, which means that we'll only see
1628 * PROC_WAIT_STATUS_ERROR when deadlock_state ==
1629 * DS_HARD_DEADLOCK, and there's no need to print redundant
1630 * messages. But for completeness and future-proofing, print
1631 * a message if it looks like someone else kicked us off the
1632 * lock.
1633 */
1635 ereport(LOG,
1636 (errmsg("process %d failed to acquire %s on %s after %ld.%03d ms",
1637 MyProcPid, modename, buf.data, msecs, usecs),
1638 (errdetail_log_plural("Process holding the lock: %s. Wait queue: %s.",
1639 "Processes holding the lock: %s. Wait queue: %s.",
1640 lockHoldersNum, lock_holders_sbuf.data, lock_waiters_sbuf.data))));
1641 }
1642
1643 /*
1644 * At this point we might still need to wait for the lock. Reset
1645 * state so we don't print the above messages again.
1646 */
1648
1649 pfree(buf.data);
1650 pfree(lock_holders_sbuf.data);
1651 pfree(lock_waiters_sbuf.data);
1652 }
1653 } while (myWaitStatus == PROC_WAIT_STATUS_WAITING);
1654
1655 /*
1656 * Disable the timers, if they are still running. As in LockErrorCleanup,
1657 * we must preserve the LOCK_TIMEOUT indicator flag: if a lock timeout has
1658 * already caused QueryCancelPending to become set, we want the cancel to
1659 * be reported as a lock timeout, not a user cancel.
1660 */
1661 if (!InHotStandby)
1662 {
1663 if (LockTimeout > 0)
1664 {
1665 DisableTimeoutParams timeouts[2];
1666
1667 timeouts[0].id = DEADLOCK_TIMEOUT;
1668 timeouts[0].keep_indicator = false;
1669 timeouts[1].id = LOCK_TIMEOUT;
1670 timeouts[1].keep_indicator = true;
1671 disable_timeouts(timeouts, 2);
1672 }
1673 else
1675 }
1676
1677 /*
1678 * Emit the log message if recovery conflict on lock was resolved but the
1679 * startup process waited longer than deadlock_timeout for it.
1680 */
1681 if (InHotStandby && logged_recovery_conflict)
1683 standbyWaitStart, GetCurrentTimestamp(),
1684 NULL, false);
1685
1686 /*
1687 * We don't have to do anything else, because the awaker did all the
1688 * necessary updates of the lock table and MyProc. (The caller is
1689 * responsible for updating the local lock table.)
1690 */
1691 return myWaitStatus;
1692}
1693
1694
1695/*
1696 * ProcWakeup -- wake up a process by setting its latch.
1697 *
1698 * Also remove the process from the wait queue and set its links invalid.
1699 *
1700 * The appropriate lock partition lock must be held by caller.
1701 *
1702 * XXX: presently, this code is only used for the "success" case, and only
1703 * works correctly for that case. To clean up in failure case, would need
1704 * to twiddle the lock's request counts too --- see RemoveFromWaitQueue.
1705 * Hence, in practice the waitStatus parameter must be PROC_WAIT_STATUS_OK.
1706 */
1707void
1709{
1710 if (dlist_node_is_detached(&proc->links))
1711 return;
1712
1714
1715 /* Remove process from wait queue */
1717
1718 /* Clean up process' state and pass it the ok/fail signal */
1719 proc->waitLock = NULL;
1720 proc->waitProcLock = NULL;
1721 proc->waitStatus = waitStatus;
1723
1724 /* And awaken it */
1725 SetLatch(&proc->procLatch);
1726}
1727
1728/*
1729 * ProcLockWakeup -- routine for waking up processes when a lock is
1730 * released (or a prior waiter is aborted). Scan all waiters
1731 * for lock, waken any that are no longer blocked.
1732 *
1733 * The appropriate lock partition lock must be held by caller.
1734 */
1735void
1736ProcLockWakeup(LockMethod lockMethodTable, LOCK *lock)
1737{
1738 dclist_head *waitQueue = &lock->waitProcs;
1739 LOCKMASK aheadRequests = 0;
1740 dlist_mutable_iter miter;
1741
1742 if (dclist_is_empty(waitQueue))
1743 return;
1744
1745 dclist_foreach_modify(miter, waitQueue)
1746 {
1747 PGPROC *proc = dlist_container(PGPROC, links, miter.cur);
1748 LOCKMODE lockmode = proc->waitLockMode;
1749
1750 /*
1751 * Waken if (a) doesn't conflict with requests of earlier waiters, and
1752 * (b) doesn't conflict with already-held locks.
1753 */
1754 if ((lockMethodTable->conflictTab[lockmode] & aheadRequests) == 0 &&
1755 !LockCheckConflicts(lockMethodTable, lockmode, lock,
1756 proc->waitProcLock))
1757 {
1758 /* OK to waken */
1759 GrantLock(lock, proc->waitProcLock, lockmode);
1760 /* removes proc from the lock's waiting process queue */
1762 }
1763 else
1764 {
1765 /*
1766 * Lock conflicts: Don't wake, but remember requested mode for
1767 * later checks.
1768 */
1769 aheadRequests |= LOCKBIT_ON(lockmode);
1770 }
1771 }
1772}
1773
1774/*
1775 * CheckDeadLock
1776 *
1777 * We only get to this routine, if DEADLOCK_TIMEOUT fired while waiting for a
1778 * lock to be released by some other process. Check if there's a deadlock; if
1779 * not, just return. (But signal ProcSleep to log a message, if
1780 * log_lock_waits is true.) If we have a real deadlock, remove ourselves from
1781 * the lock's wait queue and signal an error to ProcSleep.
1782 */
1783static void
1785{
1786 int i;
1787
1788 /*
1789 * Acquire exclusive lock on the entire shared lock data structures. Must
1790 * grab LWLocks in partition-number order to avoid LWLock deadlock.
1791 *
1792 * Note that the deadlock check interrupt had better not be enabled
1793 * anywhere that this process itself holds lock partition locks, else this
1794 * will wait forever. Also note that LWLockAcquire creates a critical
1795 * section, so that this routine cannot be interrupted by cancel/die
1796 * interrupts.
1797 */
1798 for (i = 0; i < NUM_LOCK_PARTITIONS; i++)
1800
1801 /*
1802 * Check to see if we've been awoken by anyone in the interim.
1803 *
1804 * If we have, we can return and resume our transaction -- happy day.
1805 * Before we are awoken the process releasing the lock grants it to us so
1806 * we know that we don't have to wait anymore.
1807 *
1808 * We check by looking to see if we've been unlinked from the wait queue.
1809 * This is safe because we hold the lock partition lock.
1810 */
1811 if (MyProc->links.prev == NULL ||
1812 MyProc->links.next == NULL)
1813 goto check_done;
1814
1815#ifdef LOCK_DEBUG
1816 if (Debug_deadlocks)
1817 DumpAllLocks();
1818#endif
1819
1820 /* Run the deadlock check, and set deadlock_state for use by ProcSleep */
1822
1824 {
1825 /*
1826 * Oops. We have a deadlock.
1827 *
1828 * Get this process out of wait state. (Note: we could do this more
1829 * efficiently by relying on lockAwaited, but use this coding to
1830 * preserve the flexibility to kill some other transaction than the
1831 * one detecting the deadlock.)
1832 *
1833 * RemoveFromWaitQueue sets MyProc->waitStatus to
1834 * PROC_WAIT_STATUS_ERROR, so ProcSleep will report an error after we
1835 * return from the signal handler.
1836 */
1837 Assert(MyProc->waitLock != NULL);
1839
1840 /*
1841 * We're done here. Transaction abort caused by the error that
1842 * ProcSleep will raise will cause any other locks we hold to be
1843 * released, thus allowing other processes to wake up; we don't need
1844 * to do that here. NOTE: an exception is that releasing locks we
1845 * hold doesn't consider the possibility of waiters that were blocked
1846 * behind us on the lock we just failed to get, and might now be
1847 * wakable because we're not in front of them anymore. However,
1848 * RemoveFromWaitQueue took care of waking up any such processes.
1849 */
1850 }
1851
1852 /*
1853 * And release locks. We do this in reverse order for two reasons: (1)
1854 * Anyone else who needs more than one of the locks will be trying to lock
1855 * them in increasing order; we don't want to release the other process
1856 * until it can get all the locks it needs. (2) This avoids O(N^2)
1857 * behavior inside LWLockRelease.
1858 */
1859check_done:
1860 for (i = NUM_LOCK_PARTITIONS; --i >= 0;)
1862}
1863
1864/*
1865 * CheckDeadLockAlert - Handle the expiry of deadlock_timeout.
1866 *
1867 * NB: Runs inside a signal handler, be careful.
1868 */
1869void
1871{
1872 int save_errno = errno;
1873
1874 got_deadlock_timeout = true;
1875
1876 /*
1877 * Have to set the latch again, even if handle_sig_alarm already did. Back
1878 * then got_deadlock_timeout wasn't yet set... It's unlikely that this
1879 * ever would be a problem, but setting a set latch again is cheap.
1880 *
1881 * Note that, when this function runs inside procsignal_sigusr1_handler(),
1882 * the handler function sets the latch again after the latch is set here.
1883 */
1885 errno = save_errno;
1886}
1887
1888/*
1889 * ProcWaitForSignal - wait for a signal from another backend.
1890 *
1891 * As this uses the generic process latch the caller has to be robust against
1892 * unrelated wakeups: Always check that the desired state has occurred, and
1893 * wait again if not.
1894 */
1895void
1897{
1899 wait_event_info);
1902}
1903
1904/*
1905 * ProcSendSignal - set the latch of a backend identified by ProcNumber
1906 */
1907void
1909{
1910 if (procNumber < 0 || procNumber >= ProcGlobal->allProcCount)
1911 elog(ERROR, "procNumber out of range");
1912
1913 SetLatch(&ProcGlobal->allProcs[procNumber].procLatch);
1914}
1915
1916/*
1917 * BecomeLockGroupLeader - designate process as lock group leader
1918 *
1919 * Once this function has returned, other processes can join the lock group
1920 * by calling BecomeLockGroupMember.
1921 */
1922void
1924{
1925 LWLock *leader_lwlock;
1926
1927 /* If we already did it, we don't need to do it again. */
1929 return;
1930
1931 /* We had better not be a follower. */
1932 Assert(MyProc->lockGroupLeader == NULL);
1933
1934 /* Create single-member group, containing only ourselves. */
1935 leader_lwlock = LockHashPartitionLockByProc(MyProc);
1936 LWLockAcquire(leader_lwlock, LW_EXCLUSIVE);
1939 LWLockRelease(leader_lwlock);
1940}
1941
1942/*
1943 * BecomeLockGroupMember - designate process as lock group member
1944 *
1945 * This is pretty straightforward except for the possibility that the leader
1946 * whose group we're trying to join might exit before we manage to do so;
1947 * and the PGPROC might get recycled for an unrelated process. To avoid
1948 * that, we require the caller to pass the PID of the intended PGPROC as
1949 * an interlock. Returns true if we successfully join the intended lock
1950 * group, and false if not.
1951 */
1952bool
1954{
1955 LWLock *leader_lwlock;
1956 bool ok = false;
1957
1958 /* Group leader can't become member of group */
1959 Assert(MyProc != leader);
1960
1961 /* Can't already be a member of a group */
1962 Assert(MyProc->lockGroupLeader == NULL);
1963
1964 /* PID must be valid. */
1965 Assert(pid != 0);
1966
1967 /*
1968 * Get lock protecting the group fields. Note LockHashPartitionLockByProc
1969 * calculates the proc number based on the PGPROC slot without looking at
1970 * its contents, so we will acquire the correct lock even if the leader
1971 * PGPROC is in process of being recycled.
1972 */
1973 leader_lwlock = LockHashPartitionLockByProc(leader);
1974 LWLockAcquire(leader_lwlock, LW_EXCLUSIVE);
1975
1976 /* Is this the leader we're looking for? */
1977 if (leader->pid == pid && leader->lockGroupLeader == leader)
1978 {
1979 /* OK, join the group */
1980 ok = true;
1981 MyProc->lockGroupLeader = leader;
1983 }
1984 LWLockRelease(leader_lwlock);
1985
1986 return ok;
1987}
static void pg_atomic_write_u64(volatile pg_atomic_uint64 *ptr, uint64 val)
Definition: atomics.h:485
static void pg_atomic_init_u32(volatile pg_atomic_uint32 *ptr, uint32 val)
Definition: atomics.h:221
static uint32 pg_atomic_read_u32(volatile pg_atomic_uint32 *ptr)
Definition: atomics.h:239
static void pg_atomic_init_u64(volatile pg_atomic_uint64 *ptr, uint64 val)
Definition: atomics.h:453
int autovacuum_worker_slots
Definition: autovacuum.c:118
int AutovacuumLauncherPid
Definition: autovacuum.c:316
void TimestampDifference(TimestampTz start_time, TimestampTz stop_time, long *secs, int *microsecs)
Definition: timestamp.c:1720
bool TimestampDifferenceExceeds(TimestampTz start_time, TimestampTz stop_time, int msec)
Definition: timestamp.c:1780
TimestampTz GetCurrentTimestamp(void)
Definition: timestamp.c:1644
Datum now(PG_FUNCTION_ARGS)
Definition: timestamp.c:1608
#define MAXALIGN(LEN)
Definition: c.h:768
uint8_t uint8
Definition: c.h:486
#define PG_USED_FOR_ASSERTS_ONLY
Definition: c.h:204
#define Assert(condition)
Definition: c.h:815
uint64_t uint64
Definition: c.h:489
uint32_t uint32
Definition: c.h:488
#define MemSet(start, val, len)
Definition: c.h:977
uint32 TransactionId
Definition: c.h:609
size_t Size
Definition: c.h:562
#define TRANSACTION_STATUS_IN_PROGRESS
Definition: clog.h:27
bool ConditionVariableCancelSleep(void)
int64 TimestampTz
Definition: timestamp.h:39
PGPROC * GetBlockingAutoVacuumPgproc(void)
Definition: deadlock.c:287
void RememberSimpleDeadLock(PGPROC *proc1, LOCKMODE lockmode, LOCK *lock, PGPROC *proc2)
Definition: deadlock.c:1144
void InitDeadLockChecking(void)
Definition: deadlock.c:143
DeadLockState DeadLockCheck(PGPROC *proc)
Definition: deadlock.c:217
int errmsg_internal(const char *fmt,...)
Definition: elog.c:1157
bool message_level_is_interesting(int elevel)
Definition: elog.c:272
int errcode(int sqlerrcode)
Definition: elog.c:853
int errdetail_log_plural(const char *fmt_singular, const char *fmt_plural, unsigned long n,...)
Definition: elog.c:1272
int errmsg(const char *fmt,...)
Definition: elog.c:1070
int errdetail_log(const char *fmt,...)
Definition: elog.c:1251
#define LOG
Definition: elog.h:31
#define FATAL
Definition: elog.h:41
#define WARNING
Definition: elog.h:36
#define PANIC
Definition: elog.h:42
#define DEBUG1
Definition: elog.h:30
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:225
#define ereport(elevel,...)
Definition: elog.h:149
int MyProcPid
Definition: globals.c:46
ProcNumber MyProcNumber
Definition: globals.c:89
bool IsUnderPostmaster
Definition: globals.c:119
int MaxConnections
Definition: globals.c:142
int MaxBackends
Definition: globals.c:145
struct Latch * MyLatch
Definition: globals.c:62
int max_worker_processes
Definition: globals.c:143
static dlist_node * dlist_pop_head_node(dlist_head *head)
Definition: ilist.h:450
#define dlist_foreach(iter, lhead)
Definition: ilist.h:623
static void dlist_init(dlist_head *head)
Definition: ilist.h:314
static void dclist_push_tail(dclist_head *head, dlist_node *node)
Definition: ilist.h:709
static void dlist_delete(dlist_node *node)
Definition: ilist.h:405
static bool dclist_is_empty(const dclist_head *head)
Definition: ilist.h:682
static bool dlist_node_is_detached(const dlist_node *node)
Definition: ilist.h:525
static void dlist_push_head(dlist_head *head, dlist_node *node)
Definition: ilist.h:347
static bool dlist_is_empty(const dlist_head *head)
Definition: ilist.h:336
static void dlist_push_tail(dlist_head *head, dlist_node *node)
Definition: ilist.h:364
static void dclist_delete_from_thoroughly(dclist_head *head, dlist_node *node)
Definition: ilist.h:776
static void dclist_insert_before(dclist_head *head, dlist_node *before, dlist_node *node)
Definition: ilist.h:745
#define dclist_foreach_modify(iter, lhead)
Definition: ilist.h:973
static void dlist_node_init(dlist_node *node)
Definition: ilist.h:325
#define dlist_container(type, membername, ptr)
Definition: ilist.h:593
#define dclist_foreach(iter, lhead)
Definition: ilist.h:970
void on_shmem_exit(pg_on_exit_callback function, Datum arg)
Definition: ipc.c:365
int j
Definition: isn.c:73
int i
Definition: isn.c:72
void OwnLatch(Latch *latch)
Definition: latch.c:463
void DisownLatch(Latch *latch)
Definition: latch.c:489
void InitSharedLatch(Latch *latch)
Definition: latch.c:430
void SetLatch(Latch *latch)
Definition: latch.c:632
void ResetLatch(Latch *latch)
Definition: latch.c:724
int WaitLatch(Latch *latch, int wakeEvents, long timeout, uint32 wait_event_info)
Definition: latch.c:517
#define WL_EXIT_ON_PM_DEATH
Definition: latch.h:132
#define WL_LATCH_SET
Definition: latch.h:127
void DescribeLockTag(StringInfo buf, const LOCKTAG *tag)
Definition: lmgr.c:1232
void GrantAwaitedLock(void)
Definition: lock.c:1838
void GrantLock(LOCK *lock, PROCLOCK *proclock, LOCKMODE lockmode)
Definition: lock.c:1607
VirtualTransactionId * GetLockConflicts(const LOCKTAG *locktag, LOCKMODE lockmode, int *countp)
Definition: lock.c:2976
void RemoveFromWaitQueue(PGPROC *proc, uint32 hashcode)
Definition: lock.c:1955
void LockReleaseAll(LOCKMETHODID lockmethodid, bool allLocks)
Definition: lock.c:2216
void AbortStrongLockAcquire(void)
Definition: lock.c:1809
const char * GetLockmodeName(LOCKMETHODID lockmethodid, LOCKMODE mode)
Definition: lock.c:4160
LOCALLOCK * GetAwaitedLock(void)
Definition: lock.c:1847
int FastPathLockGroupsPerBackend
Definition: lock.c:200
uint32 LockTagHashCode(const LOCKTAG *locktag)
Definition: lock.c:551
bool LockCheckConflicts(LockMethod lockMethodTable, LOCKMODE lockmode, LOCK *lock, PROCLOCK *proclock)
Definition: lock.c:1478
#define DEFAULT_LOCKMETHOD
Definition: lock.h:125
#define LockHashPartitionLock(hashcode)
Definition: lock.h:526
#define USER_LOCKMETHOD
Definition: lock.h:126
#define InvalidLocalTransactionId
Definition: lock.h:65
DeadLockState
Definition: lock.h:509
@ DS_HARD_DEADLOCK
Definition: lock.h:513
@ DS_BLOCKED_BY_AUTOVACUUM
Definition: lock.h:514
@ DS_NO_DEADLOCK
Definition: lock.h:511
@ DS_NOT_YET_CHECKED
Definition: lock.h:510
@ DS_SOFT_DEADLOCK
Definition: lock.h:512
#define LOCKBIT_ON(lockmode)
Definition: lock.h:84
#define LockHashPartitionLockByProc(leader_pgproc)
Definition: lock.h:541
#define LockHashPartitionLockByIndex(i)
Definition: lock.h:529
int LOCKMODE
Definition: lockdefs.h:26
#define AccessExclusiveLock
Definition: lockdefs.h:43
int LOCKMASK
Definition: lockdefs.h:25
bool LWLockHeldByMe(LWLock *lock)
Definition: lwlock.c:1893
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1168
bool LWLockHeldByMeInMode(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1937
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1781
void LWLockReleaseAll(void)
Definition: lwlock.c:1876
void LWLockInitialize(LWLock *lock, int tranche_id)
Definition: lwlock.c:707
void InitLWLockAccess(void)
Definition: lwlock.c:557
@ LW_WS_NOT_WAITING
Definition: lwlock.h:30
#define NUM_LOCK_PARTITIONS
Definition: lwlock.h:97
@ LWTRANCHE_LOCK_FASTPATH
Definition: lwlock.h:190
@ LW_SHARED
Definition: lwlock.h:115
@ LW_EXCLUSIVE
Definition: lwlock.h:114
void pfree(void *pointer)
Definition: mcxt.c:1521
#define RESUME_INTERRUPTS()
Definition: miscadmin.h:135
#define AmAutoVacuumWorkerProcess()
Definition: miscadmin.h:381
#define AmBackgroundWorkerProcess()
Definition: miscadmin.h:382
#define CHECK_FOR_INTERRUPTS()
Definition: miscadmin.h:122
#define AmWalSenderProcess()
Definition: miscadmin.h:383
#define HOLD_INTERRUPTS()
Definition: miscadmin.h:133
#define AmSpecialWorkerProcess()
Definition: miscadmin.h:393
#define AmRegularBackendProcess()
Definition: miscadmin.h:379
void SwitchToSharedLatch(void)
Definition: miscinit.c:215
void SwitchBackToLocalLatch(void)
Definition: miscinit.c:242
void * arg
static char * buf
Definition: pg_test_fsync.c:72
void RegisterPostmasterChildActive(void)
Definition: pmsignal.c:290
void PGSemaphoreReset(PGSemaphore sema)
Definition: posix_sema.c:294
PGSemaphore PGSemaphoreCreate(void)
Definition: posix_sema.c:261
uintptr_t Datum
Definition: postgres.h:69
static Datum Int32GetDatum(int32 X)
Definition: postgres.h:217
static int32 DatumGetInt32(Datum X)
Definition: postgres.h:207
#define NON_EXEC_STATIC
Definition: postgres.h:581
#define InvalidOid
Definition: postgres_ext.h:37
unsigned int Oid
Definition: postgres_ext.h:32
#define NUM_AUXILIARY_PROCS
Definition: proc.h:445
#define PROC_VACUUM_FOR_WRAPAROUND
Definition: proc.h:60
#define FP_LOCK_SLOTS_PER_GROUP
Definition: proc.h:84
#define GetNumberFromPGProc(proc)
Definition: proc.h:424
#define NUM_SPECIAL_WORKER_PROCS
Definition: proc.h:433
ProcWaitStatus
Definition: proc.h:123
@ PROC_WAIT_STATUS_OK
Definition: proc.h:124
@ PROC_WAIT_STATUS_WAITING
Definition: proc.h:125
@ PROC_WAIT_STATUS_ERROR
Definition: proc.h:126
#define PROC_IS_AUTOVACUUM
Definition: proc.h:57
void ProcArrayAdd(PGPROC *proc)
Definition: procarray.c:468
void ProcArrayRemove(PGPROC *proc, TransactionId latestXid)
Definition: procarray.c:565
#define INVALID_PROC_NUMBER
Definition: procnumber.h:26
int ProcNumber
Definition: procnumber.h:24
@ PROCSIG_RECOVERY_CONFLICT_LOCK
Definition: procsignal.h:44
void set_spins_per_delay(int shared_spins_per_delay)
Definition: s_lock.c:207
int update_spins_per_delay(int shared_spins_per_delay)
Definition: s_lock.c:218
#define DEFAULT_SPINS_PER_DELAY
Definition: s_lock.h:720
Size add_size(Size s1, Size s2)
Definition: shmem.c:488
Size mul_size(Size s1, Size s2)
Definition: shmem.c:505
void * ShmemAlloc(Size size)
Definition: shmem.c:147
void * ShmemInitStruct(const char *name, Size size, bool *foundPtr)
Definition: shmem.c:382
static pg_noinline void Size size
Definition: slab.c:607
#define SpinLockInit(lock)
Definition: spin.h:57
#define SpinLockRelease(lock)
Definition: spin.h:61
#define SpinLockAcquire(lock)
Definition: spin.h:59
ProcWaitStatus JoinWaitQueue(LOCALLOCK *locallock, LockMethod lockMethodTable, bool dontWait)
Definition: proc.c:1089
void ProcSendSignal(ProcNumber procNumber)
Definition: proc.c:1908
bool log_lock_waits
Definition: proc.c:63
int IdleSessionTimeout
Definition: proc.c:62
PGPROC * MyProc
Definition: proc.c:66
Size ProcGlobalShmemSize(void)
Definition: proc.c:97
void ProcWakeup(PGPROC *proc, ProcWaitStatus waitStatus)
Definition: proc.c:1708
int StatementTimeout
Definition: proc.c:58
bool HaveNFreeProcs(int n, int *nfree)
Definition: proc.c:733
static void RemoveProcFromArray(int code, Datum arg)
Definition: proc.c:857
void InitAuxiliaryProcess(void)
Definition: proc.c:566
PGPROC * PreparedXactProcs
Definition: proc.c:80
static DeadLockState deadlock_state
Definition: proc.c:82
int IdleInTransactionSessionTimeout
Definition: proc.c:60
NON_EXEC_STATIC PGPROC * AuxiliaryProcs
Definition: proc.c:79
int GetStartupBufferPinWaitBufId(void)
Definition: proc.c:717
ProcWaitStatus ProcSleep(LOCALLOCK *locallock)
Definition: proc.c:1258
int DeadlockTimeout
Definition: proc.c:57
int TransactionTimeout
Definition: proc.c:61
void ProcLockWakeup(LockMethod lockMethodTable, LOCK *lock)
Definition: proc.c:1736
PROC_HDR * ProcGlobal
Definition: proc.c:78
static void CheckDeadLock(void)
Definition: proc.c:1784
NON_EXEC_STATIC slock_t * ProcStructLock
Definition: proc.c:75
int ProcGlobalSemas(void)
Definition: proc.c:130
void ProcReleaseLocks(bool isCommit)
Definition: proc.c:840
void LockErrorCleanup(void)
Definition: proc.c:764
bool BecomeLockGroupMember(PGPROC *leader, int pid)
Definition: proc.c:1953
void BecomeLockGroupLeader(void)
Definition: proc.c:1923
static void ProcKill(int code, Datum arg)
Definition: proc.c:868
void InitProcess(void)
Definition: proc.c:341
void CheckDeadLockAlert(void)
Definition: proc.c:1870
void InitProcessPhase2(void)
Definition: proc.c:531
void InitProcGlobal(void)
Definition: proc.c:165
static volatile sig_atomic_t got_deadlock_timeout
Definition: proc.c:85
PGPROC * AuxiliaryPidGetProc(int pid)
Definition: proc.c:1040
void SetStartupBufferPinWaitBufId(int bufid)
Definition: proc.c:705
void ProcWaitForSignal(uint32 wait_event_info)
Definition: proc.c:1896
int LockTimeout
Definition: proc.c:59
static void AuxiliaryProcKill(int code, Datum arg)
Definition: proc.c:989
void CheckRecoveryConflictDeadlock(void)
Definition: standby.c:904
bool log_recovery_conflict_waits
Definition: standby.c:41
void LogRecoveryConflict(ProcSignalReason reason, TimestampTz wait_start, TimestampTz now, VirtualTransactionId *wait_list, bool still_waiting)
Definition: standby.c:273
void ResolveRecoveryConflictWithLock(LOCKTAG locktag, bool logging_conflict)
Definition: standby.c:622
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition: stringinfo.c:145
void initStringInfo(StringInfo str)
Definition: stringinfo.c:97
TimeoutId id
Definition: timeout.h:71
TimeoutType type
Definition: timeout.h:61
TimeoutId id
Definition: timeout.h:60
LOCKTAG lock
Definition: lock.h:410
LOCKMODE mode
Definition: lock.h:411
uint32 hashcode
Definition: lock.h:432
LOCK * lock
Definition: lock.h:433
PROCLOCK * proclock
Definition: lock.h:434
LOCALLOCKTAG tag
Definition: lock.h:429
Definition: lock.h:165
uint8 locktag_type
Definition: lock.h:170
uint8 locktag_lockmethodid
Definition: lock.h:171
Definition: lock.h:309
LOCKTAG tag
Definition: lock.h:311
dclist_head waitProcs
Definition: lock.h:317
LOCKMASK waitMask
Definition: lock.h:315
dlist_head procLocks
Definition: lock.h:316
Definition: lwlock.h:42
const LOCKMASK * conflictTab
Definition: lock.h:111
Definition: proc.h:162
LWLock fpInfoLock
Definition: proc.h:293
bool isRegularBackend
Definition: proc.h:213
TransactionId xmin
Definition: proc.h:177
bool procArrayGroupMember
Definition: proc.h:269
LocalTransactionId lxid
Definition: proc.h:200
PROCLOCK * waitProcLock
Definition: proc.h:233
XLogRecPtr clogGroupMemberLsn
Definition: proc.h:289
pg_atomic_uint32 procArrayGroupNext
Definition: proc.h:271
uint8 lwWaitMode
Definition: proc.h:224
dlist_head lockGroupMembers
Definition: proc.h:305
struct PGPROC::@124 vxid
uint32 wait_event_info
Definition: proc.h:279
dlist_head * procgloballist
Definition: proc.h:164
Oid * fpRelId
Definition: proc.h:295
uint8 statusFlags
Definition: proc.h:242
bool recoveryConflictPending
Definition: proc.h:220
TransactionId clogGroupMemberXid
Definition: proc.h:284
Oid databaseId
Definition: proc.h:207
int64 clogGroupMemberPage
Definition: proc.h:287
bool clogGroupMember
Definition: proc.h:282
uint64 * fpLockBits
Definition: proc.h:294
pg_atomic_uint64 waitStart
Definition: proc.h:237
bool fpVXIDLock
Definition: proc.h:296
ProcNumber procNumber
Definition: proc.h:195
int pid
Definition: proc.h:182
XLogRecPtr waitLSN
Definition: proc.h:252
dlist_node syncRepLinks
Definition: proc.h:254
int syncRepState
Definition: proc.h:253
pg_atomic_uint32 clogGroupNext
Definition: proc.h:283
dlist_node lockGroupLink
Definition: proc.h:306
XidStatus clogGroupMemberXidStatus
Definition: proc.h:285
int pgxactoff
Definition: proc.h:184
LOCK * waitLock
Definition: proc.h:232
TransactionId xid
Definition: proc.h:172
LOCKMODE waitLockMode
Definition: proc.h:234
int delayChkptFlags
Definition: proc.h:240
PGPROC * lockGroupLeader
Definition: proc.h:304
LocalTransactionId fpLocalTransactionId
Definition: proc.h:297
TransactionId procArrayGroupMemberXid
Definition: proc.h:277
LOCKMASK heldLocks
Definition: proc.h:235
PGSemaphore sem
Definition: proc.h:166
dlist_head myProcLocks[NUM_LOCK_PARTITIONS]
Definition: proc.h:261
Oid roleId
Definition: proc.h:208
ProcWaitStatus waitStatus
Definition: proc.h:167
Oid tempNamespaceId
Definition: proc.h:210
dlist_node links
Definition: proc.h:163
uint8 lwWaiting
Definition: proc.h:223
Latch procLatch
Definition: proc.h:169
PGPROC * myProc
Definition: lock.h:366
Definition: lock.h:370
LOCKMASK holdMask
Definition: lock.h:376
PGPROC * groupLeader
Definition: lock.h:375
PROCLOCKTAG tag
Definition: lock.h:372
Definition: proc.h:369
uint8 * statusFlags
Definition: proc.h:386
XidCacheStatus * subxidStates
Definition: proc.h:380
dlist_head autovacFreeProcs
Definition: proc.h:393
dlist_head freeProcs
Definition: proc.h:391
ProcNumber checkpointerProc
Definition: proc.h:408
int startupBufferPinWaitBufId
Definition: proc.h:413
PGPROC * allProcs
Definition: proc.h:371
pg_atomic_uint32 clogGroupFirst
Definition: proc.h:401
int spins_per_delay
Definition: proc.h:411
TransactionId * xids
Definition: proc.h:374
dlist_head walsenderFreeProcs
Definition: proc.h:397
dlist_head bgworkerFreeProcs
Definition: proc.h:395
ProcNumber walwriterProc
Definition: proc.h:407
pg_atomic_uint32 procArrayGroupFirst
Definition: proc.h:399
uint32 allProcCount
Definition: proc.h:389
dlist_node * cur
Definition: ilist.h:179
dlist_node * cur
Definition: ilist.h:200
dlist_node * next
Definition: ilist.h:140
dlist_node * prev
Definition: ilist.h:139
Definition: type.h:96
void SyncRepCleanupAtProcExit(void)
Definition: syncrep.c:373
#define SYNC_REP_NOT_WAITING
Definition: syncrep.h:30
void enable_timeout_after(TimeoutId id, int delay_ms)
Definition: timeout.c:560
TimestampTz get_timeout_start_time(TimeoutId id)
Definition: timeout.c:813
void disable_timeout(TimeoutId id, bool keep_indicator)
Definition: timeout.c:685
void enable_timeouts(const EnableTimeoutParams *timeouts, int count)
Definition: timeout.c:630
void disable_timeouts(const DisableTimeoutParams *timeouts, int count)
Definition: timeout.c:718
@ LOCK_TIMEOUT
Definition: timeout.h:28
@ DEADLOCK_TIMEOUT
Definition: timeout.h:27
@ TMPARAM_AFTER
Definition: timeout.h:53
#define InvalidTransactionId
Definition: transam.h:31
int max_prepared_xacts
Definition: twophase.c:115
void pgstat_set_wait_event_storage(uint32 *wait_event_info)
Definition: wait_event.c:349
void pgstat_reset_wait_event_storage(void)
Definition: wait_event.c:361
#define PG_WAIT_LOCK
Definition: wait_event.h:19
int max_wal_senders
Definition: walsender.c:121
#define kill(pid, sig)
Definition: win32_port.h:493
#define SIGUSR2
Definition: win32_port.h:171
bool RecoveryInProgress(void)
Definition: xlog.c:6355
#define InvalidXLogRecPtr
Definition: xlogdefs.h:28
bool InRecovery
Definition: xlogutils.c:50
#define InHotStandby
Definition: xlogutils.h:60
static struct link * links
Definition: zic.c:299