Line data Source code
1 : /*-------------------------------------------------------------------------
2 : *
3 : * deadlock.c
4 : * POSTGRES deadlock detection code
5 : *
6 : * See src/backend/storage/lmgr/README for a description of the deadlock
7 : * detection and resolution algorithms.
8 : *
9 : *
10 : * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
11 : * Portions Copyright (c) 1994, Regents of the University of California
12 : *
13 : *
14 : * IDENTIFICATION
15 : * src/backend/storage/lmgr/deadlock.c
16 : *
17 : * Interface:
18 : *
19 : * DeadLockCheck()
20 : * DeadLockReport()
21 : * RememberSimpleDeadLock()
22 : * InitDeadLockChecking()
23 : *
24 : *-------------------------------------------------------------------------
25 : */
26 : #include "postgres.h"
27 :
28 : #include "miscadmin.h"
29 : #include "pg_trace.h"
30 : #include "pgstat.h"
31 : #include "storage/lmgr.h"
32 : #include "storage/proc.h"
33 : #include "storage/procnumber.h"
34 : #include "utils/memutils.h"
35 :
36 :
37 : /*
38 : * One edge in the waits-for graph.
39 : *
40 : * waiter and blocker may or may not be members of a lock group, but if either
41 : * is, it will be the leader rather than any other member of the lock group.
42 : * The group leaders act as representatives of the whole group even though
43 : * those particular processes need not be waiting at all. There will be at
44 : * least one member of the waiter's lock group on the wait queue for the given
45 : * lock, maybe more.
46 : */
47 : typedef struct
48 : {
49 : PGPROC *waiter; /* the leader of the waiting lock group */
50 : PGPROC *blocker; /* the leader of the group it is waiting for */
51 : LOCK *lock; /* the lock being waited for */
52 : int pred; /* workspace for TopoSort */
53 : int link; /* workspace for TopoSort */
54 : } EDGE;
55 :
56 : /* One potential reordering of a lock's wait queue */
57 : typedef struct
58 : {
59 : LOCK *lock; /* the lock whose wait queue is described */
60 : PGPROC **procs; /* array of PGPROC *'s in new wait order */
61 : int nProcs;
62 : } WAIT_ORDER;
63 :
64 : /*
65 : * Information saved about each edge in a detected deadlock cycle. This
66 : * is used to print a diagnostic message upon failure.
67 : *
68 : * Note: because we want to examine this info after releasing the lock
69 : * manager's partition locks, we can't just store LOCK and PGPROC pointers;
70 : * we must extract out all the info we want to be able to print.
71 : */
72 : typedef struct
73 : {
74 : LOCKTAG locktag; /* ID of awaited lock object */
75 : LOCKMODE lockmode; /* type of lock we're waiting for */
76 : int pid; /* PID of blocked backend */
77 : } DEADLOCK_INFO;
78 :
79 :
80 : static bool DeadLockCheckRecurse(PGPROC *proc);
81 : static int TestConfiguration(PGPROC *startProc);
82 : static bool FindLockCycle(PGPROC *checkProc,
83 : EDGE *softEdges, int *nSoftEdges);
84 : static bool FindLockCycleRecurse(PGPROC *checkProc, int depth,
85 : EDGE *softEdges, int *nSoftEdges);
86 : static bool FindLockCycleRecurseMember(PGPROC *checkProc,
87 : PGPROC *checkProcLeader,
88 : int depth, EDGE *softEdges, int *nSoftEdges);
89 : static bool ExpandConstraints(EDGE *constraints, int nConstraints);
90 : static bool TopoSort(LOCK *lock, EDGE *constraints, int nConstraints,
91 : PGPROC **ordering);
92 :
93 : #ifdef DEBUG_DEADLOCK
94 : static void PrintLockQueue(LOCK *lock, const char *info);
95 : #endif
96 :
97 :
98 : /*
99 : * Working space for the deadlock detector
100 : */
101 :
102 : /* Workspace for FindLockCycle */
103 : static PGPROC **visitedProcs; /* Array of visited procs */
104 : static int nVisitedProcs;
105 :
106 : /* Workspace for TopoSort */
107 : static PGPROC **topoProcs; /* Array of not-yet-output procs */
108 : static int *beforeConstraints; /* Counts of remaining before-constraints */
109 : static int *afterConstraints; /* List head for after-constraints */
110 :
111 : /* Output area for ExpandConstraints */
112 : static WAIT_ORDER *waitOrders; /* Array of proposed queue rearrangements */
113 : static int nWaitOrders;
114 : static PGPROC **waitOrderProcs; /* Space for waitOrders queue contents */
115 :
116 : /* Current list of constraints being considered */
117 : static EDGE *curConstraints;
118 : static int nCurConstraints;
119 : static int maxCurConstraints;
120 :
121 : /* Storage space for results from FindLockCycle */
122 : static EDGE *possibleConstraints;
123 : static int nPossibleConstraints;
124 : static int maxPossibleConstraints;
125 : static DEADLOCK_INFO *deadlockDetails;
126 : static int nDeadlockDetails;
127 :
128 : /* PGPROC pointer of any blocking autovacuum worker found */
129 : static PGPROC *blocking_autovacuum_proc = NULL;
130 :
131 :
132 : /*
133 : * InitDeadLockChecking -- initialize deadlock checker during backend startup
134 : *
135 : * This does per-backend initialization of the deadlock checker; primarily,
136 : * allocation of working memory for DeadLockCheck. We do this per-backend
137 : * since there's no percentage in making the kernel do copy-on-write
138 : * inheritance of workspace from the postmaster. We allocate the space at
139 : * startup because the deadlock checker is run with all the partitions of the
140 : * lock table locked, and we want to keep that section as short as possible.
141 : */
142 : void
143 36318 : InitDeadLockChecking(void)
144 : {
145 : MemoryContext oldcxt;
146 :
147 : /* Make sure allocations are permanent */
148 36318 : oldcxt = MemoryContextSwitchTo(TopMemoryContext);
149 :
150 : /*
151 : * FindLockCycle needs at most MaxBackends entries in visitedProcs[] and
152 : * deadlockDetails[].
153 : */
154 36318 : visitedProcs = (PGPROC **) palloc(MaxBackends * sizeof(PGPROC *));
155 36318 : deadlockDetails = (DEADLOCK_INFO *) palloc(MaxBackends * sizeof(DEADLOCK_INFO));
156 :
157 : /*
158 : * TopoSort needs to consider at most MaxBackends wait-queue entries, and
159 : * it needn't run concurrently with FindLockCycle.
160 : */
161 36318 : topoProcs = visitedProcs; /* re-use this space */
162 36318 : beforeConstraints = (int *) palloc(MaxBackends * sizeof(int));
163 36318 : afterConstraints = (int *) palloc(MaxBackends * sizeof(int));
164 :
165 : /*
166 : * We need to consider rearranging at most MaxBackends/2 wait queues
167 : * (since it takes at least two waiters in a queue to create a soft edge),
168 : * and the expanded form of the wait queues can't involve more than
169 : * MaxBackends total waiters.
170 : */
171 36318 : waitOrders = (WAIT_ORDER *)
172 36318 : palloc((MaxBackends / 2) * sizeof(WAIT_ORDER));
173 36318 : waitOrderProcs = (PGPROC **) palloc(MaxBackends * sizeof(PGPROC *));
174 :
175 : /*
176 : * Allow at most MaxBackends distinct constraints in a configuration. (Is
177 : * this enough? In practice it seems it should be, but I don't quite see
178 : * how to prove it. If we run out, we might fail to find a workable wait
179 : * queue rearrangement even though one exists.) NOTE that this number
180 : * limits the maximum recursion depth of DeadLockCheckRecurse. Making it
181 : * really big might potentially allow a stack-overflow problem.
182 : */
183 36318 : maxCurConstraints = MaxBackends;
184 36318 : curConstraints = (EDGE *) palloc(maxCurConstraints * sizeof(EDGE));
185 :
186 : /*
187 : * Allow up to 3*MaxBackends constraints to be saved without having to
188 : * re-run TestConfiguration. (This is probably more than enough, but we
189 : * can survive if we run low on space by doing excess runs of
190 : * TestConfiguration to re-compute constraint lists each time needed.) The
191 : * last MaxBackends entries in possibleConstraints[] are reserved as
192 : * output workspace for FindLockCycle.
193 : */
194 : StaticAssertStmt(MAX_BACKENDS_BITS <= (32 - 3),
195 : "MAX_BACKENDS_BITS too big for * 4");
196 36318 : maxPossibleConstraints = MaxBackends * 4;
197 36318 : possibleConstraints =
198 36318 : (EDGE *) palloc(maxPossibleConstraints * sizeof(EDGE));
199 :
200 36318 : MemoryContextSwitchTo(oldcxt);
201 36318 : }
202 :
203 : /*
204 : * DeadLockCheck -- Checks for deadlocks for a given process
205 : *
206 : * This code looks for deadlocks involving the given process. If any
207 : * are found, it tries to rearrange lock wait queues to resolve the
208 : * deadlock. If resolution is impossible, return DS_HARD_DEADLOCK ---
209 : * the caller is then expected to abort the given proc's transaction.
210 : *
211 : * Caller must already have locked all partitions of the lock tables.
212 : *
213 : * On failure, deadlock details are recorded in deadlockDetails[] for
214 : * subsequent printing by DeadLockReport(). That activity is separate
215 : * because we don't want to do it while holding all those LWLocks.
216 : */
217 : DeadLockState
218 62 : DeadLockCheck(PGPROC *proc)
219 : {
220 : /* Initialize to "no constraints" */
221 62 : nCurConstraints = 0;
222 62 : nPossibleConstraints = 0;
223 62 : nWaitOrders = 0;
224 :
225 : /* Initialize to not blocked by an autovacuum worker */
226 62 : blocking_autovacuum_proc = NULL;
227 :
228 : /* Search for deadlocks and possible fixes */
229 62 : if (DeadLockCheckRecurse(proc))
230 : {
231 : /*
232 : * Call FindLockCycle one more time, to record the correct
233 : * deadlockDetails[] for the basic state with no rearrangements.
234 : */
235 : int nSoftEdges;
236 :
237 : TRACE_POSTGRESQL_DEADLOCK_FOUND();
238 :
239 10 : nWaitOrders = 0;
240 10 : if (!FindLockCycle(proc, possibleConstraints, &nSoftEdges))
241 0 : elog(FATAL, "deadlock seems to have disappeared");
242 :
243 10 : return DS_HARD_DEADLOCK; /* cannot find a non-deadlocked state */
244 : }
245 :
246 : /* Apply any needed rearrangements of wait queues */
247 58 : for (int i = 0; i < nWaitOrders; i++)
248 : {
249 6 : LOCK *lock = waitOrders[i].lock;
250 6 : PGPROC **procs = waitOrders[i].procs;
251 6 : int nProcs = waitOrders[i].nProcs;
252 6 : dclist_head *waitQueue = &lock->waitProcs;
253 :
254 : Assert(nProcs == dclist_count(waitQueue));
255 :
256 : #ifdef DEBUG_DEADLOCK
257 : PrintLockQueue(lock, "DeadLockCheck:");
258 : #endif
259 :
260 : /* Reset the queue and re-add procs in the desired order */
261 6 : dclist_init(waitQueue);
262 24 : for (int j = 0; j < nProcs; j++)
263 18 : dclist_push_tail(waitQueue, &procs[j]->links);
264 :
265 : #ifdef DEBUG_DEADLOCK
266 : PrintLockQueue(lock, "rearranged to:");
267 : #endif
268 :
269 : /* See if any waiters for the lock can be woken up now */
270 6 : ProcLockWakeup(GetLocksMethodTable(lock), lock);
271 : }
272 :
273 : /* Return code tells caller if we had to escape a deadlock or not */
274 52 : if (nWaitOrders > 0)
275 6 : return DS_SOFT_DEADLOCK;
276 46 : else if (blocking_autovacuum_proc != NULL)
277 0 : return DS_BLOCKED_BY_AUTOVACUUM;
278 : else
279 46 : return DS_NO_DEADLOCK;
280 : }
281 :
282 : /*
283 : * Return the PGPROC of the autovacuum that's blocking a process.
284 : *
285 : * We reset the saved pointer as soon as we pass it back.
286 : */
287 : PGPROC *
288 0 : GetBlockingAutoVacuumPgproc(void)
289 : {
290 : PGPROC *ptr;
291 :
292 0 : ptr = blocking_autovacuum_proc;
293 0 : blocking_autovacuum_proc = NULL;
294 :
295 0 : return ptr;
296 : }
297 :
298 : /*
299 : * DeadLockCheckRecurse -- recursively search for valid orderings
300 : *
301 : * curConstraints[] holds the current set of constraints being considered
302 : * by an outer level of recursion. Add to this each possible solution
303 : * constraint for any cycle detected at this level.
304 : *
305 : * Returns true if no solution exists. Returns false if a deadlock-free
306 : * state is attainable, in which case waitOrders[] shows the required
307 : * rearrangements of lock wait queues (if any).
308 : */
309 : static bool
310 68 : DeadLockCheckRecurse(PGPROC *proc)
311 : {
312 : int nEdges;
313 : int oldPossibleConstraints;
314 : bool savedList;
315 : int i;
316 :
317 68 : nEdges = TestConfiguration(proc);
318 68 : if (nEdges < 0)
319 10 : return true; /* hard deadlock --- no solution */
320 58 : if (nEdges == 0)
321 52 : return false; /* good configuration found */
322 6 : if (nCurConstraints >= maxCurConstraints)
323 0 : return true; /* out of room for active constraints? */
324 6 : oldPossibleConstraints = nPossibleConstraints;
325 6 : if (nPossibleConstraints + nEdges + MaxBackends <= maxPossibleConstraints)
326 : {
327 : /* We can save the edge list in possibleConstraints[] */
328 6 : nPossibleConstraints += nEdges;
329 6 : savedList = true;
330 : }
331 : else
332 : {
333 : /* Not room; will need to regenerate the edges on-the-fly */
334 0 : savedList = false;
335 : }
336 :
337 : /*
338 : * Try each available soft edge as an addition to the configuration.
339 : */
340 6 : for (i = 0; i < nEdges; i++)
341 : {
342 6 : if (!savedList && i > 0)
343 : {
344 : /* Regenerate the list of possible added constraints */
345 0 : if (nEdges != TestConfiguration(proc))
346 0 : elog(FATAL, "inconsistent results during deadlock check");
347 : }
348 6 : curConstraints[nCurConstraints] =
349 6 : possibleConstraints[oldPossibleConstraints + i];
350 6 : nCurConstraints++;
351 6 : if (!DeadLockCheckRecurse(proc))
352 6 : return false; /* found a valid solution! */
353 : /* give up on that added constraint, try again */
354 0 : nCurConstraints--;
355 : }
356 0 : nPossibleConstraints = oldPossibleConstraints;
357 0 : return true; /* no solution found */
358 : }
359 :
360 :
361 : /*--------------------
362 : * Test a configuration (current set of constraints) for validity.
363 : *
364 : * Returns:
365 : * 0: the configuration is good (no deadlocks)
366 : * -1: the configuration has a hard deadlock or is not self-consistent
367 : * >0: the configuration has one or more soft deadlocks
368 : *
369 : * In the soft-deadlock case, one of the soft cycles is chosen arbitrarily
370 : * and a list of its soft edges is returned beginning at
371 : * possibleConstraints+nPossibleConstraints. The return value is the
372 : * number of soft edges.
373 : *--------------------
374 : */
375 : static int
376 68 : TestConfiguration(PGPROC *startProc)
377 : {
378 68 : int softFound = 0;
379 68 : EDGE *softEdges = possibleConstraints + nPossibleConstraints;
380 : int nSoftEdges;
381 : int i;
382 :
383 : /*
384 : * Make sure we have room for FindLockCycle's output.
385 : */
386 68 : if (nPossibleConstraints + MaxBackends > maxPossibleConstraints)
387 0 : return -1;
388 :
389 : /*
390 : * Expand current constraint set into wait orderings. Fail if the
391 : * constraint set is not self-consistent.
392 : */
393 68 : if (!ExpandConstraints(curConstraints, nCurConstraints))
394 0 : return -1;
395 :
396 : /*
397 : * Check for cycles involving startProc or any of the procs mentioned in
398 : * constraints. We check startProc last because if it has a soft cycle
399 : * still to be dealt with, we want to deal with that first.
400 : */
401 74 : for (i = 0; i < nCurConstraints; i++)
402 : {
403 6 : if (FindLockCycle(curConstraints[i].waiter, softEdges, &nSoftEdges))
404 : {
405 0 : if (nSoftEdges == 0)
406 0 : return -1; /* hard deadlock detected */
407 0 : softFound = nSoftEdges;
408 : }
409 6 : if (FindLockCycle(curConstraints[i].blocker, softEdges, &nSoftEdges))
410 : {
411 0 : if (nSoftEdges == 0)
412 0 : return -1; /* hard deadlock detected */
413 0 : softFound = nSoftEdges;
414 : }
415 : }
416 68 : if (FindLockCycle(startProc, softEdges, &nSoftEdges))
417 : {
418 16 : if (nSoftEdges == 0)
419 10 : return -1; /* hard deadlock detected */
420 6 : softFound = nSoftEdges;
421 : }
422 58 : return softFound;
423 : }
424 :
425 :
426 : /*
427 : * FindLockCycle -- basic check for deadlock cycles
428 : *
429 : * Scan outward from the given proc to see if there is a cycle in the
430 : * waits-for graph that includes this proc. Return true if a cycle
431 : * is found, else false. If a cycle is found, we return a list of
432 : * the "soft edges", if any, included in the cycle. These edges could
433 : * potentially be eliminated by rearranging wait queues. We also fill
434 : * deadlockDetails[] with information about the detected cycle; this info
435 : * is not used by the deadlock algorithm itself, only to print a useful
436 : * message after failing.
437 : *
438 : * Since we need to be able to check hypothetical configurations that would
439 : * exist after wait queue rearrangement, the routine pays attention to the
440 : * table of hypothetical queue orders in waitOrders[]. These orders will
441 : * be believed in preference to the actual ordering seen in the locktable.
442 : */
443 : static bool
444 90 : FindLockCycle(PGPROC *checkProc,
445 : EDGE *softEdges, /* output argument */
446 : int *nSoftEdges) /* output argument */
447 : {
448 90 : nVisitedProcs = 0;
449 90 : nDeadlockDetails = 0;
450 90 : *nSoftEdges = 0;
451 90 : return FindLockCycleRecurse(checkProc, 0, softEdges, nSoftEdges);
452 : }
453 :
454 : static bool
455 268 : FindLockCycleRecurse(PGPROC *checkProc,
456 : int depth,
457 : EDGE *softEdges, /* output argument */
458 : int *nSoftEdges) /* output argument */
459 : {
460 : int i;
461 : dlist_iter iter;
462 :
463 : /*
464 : * If this process is a lock group member, check the leader instead. (Note
465 : * that we might be the leader, in which case this is a no-op.)
466 : */
467 268 : if (checkProc->lockGroupLeader != NULL)
468 52 : checkProc = checkProc->lockGroupLeader;
469 :
470 : /*
471 : * Have we already seen this proc?
472 : */
473 564 : for (i = 0; i < nVisitedProcs; i++)
474 : {
475 334 : if (visitedProcs[i] == checkProc)
476 : {
477 : /* If we return to starting point, we have a deadlock cycle */
478 38 : if (i == 0)
479 : {
480 : /*
481 : * record total length of cycle --- outer levels will now fill
482 : * deadlockDetails[]
483 : */
484 : Assert(depth <= MaxBackends);
485 26 : nDeadlockDetails = depth;
486 :
487 26 : return true;
488 : }
489 :
490 : /*
491 : * Otherwise, we have a cycle but it does not include the start
492 : * point, so say "no deadlock".
493 : */
494 12 : return false;
495 : }
496 : }
497 : /* Mark proc as seen */
498 : Assert(nVisitedProcs < MaxBackends);
499 230 : visitedProcs[nVisitedProcs++] = checkProc;
500 :
501 : /*
502 : * If the process is waiting, there is an outgoing waits-for edge to each
503 : * process that blocks it.
504 : */
505 386 : if (checkProc->links.next != NULL && checkProc->waitLock != NULL &&
506 156 : FindLockCycleRecurseMember(checkProc, checkProc, depth, softEdges,
507 : nSoftEdges))
508 82 : return true;
509 :
510 : /*
511 : * If the process is not waiting, there could still be outgoing waits-for
512 : * edges if it is part of a lock group, because other members of the lock
513 : * group might be waiting even though this process is not. (Given lock
514 : * groups {A1, A2} and {B1, B2}, if A1 waits for B1 and B2 waits for A2,
515 : * that is a deadlock even neither of B1 and A2 are waiting for anything.)
516 : */
517 228 : dlist_foreach(iter, &checkProc->lockGroupMembers)
518 : {
519 : PGPROC *memberProc;
520 :
521 88 : memberProc = dlist_container(PGPROC, lockGroupLink, iter.cur);
522 :
523 88 : if (memberProc->links.next != NULL && memberProc->waitLock != NULL &&
524 42 : memberProc != checkProc &&
525 42 : FindLockCycleRecurseMember(memberProc, checkProc, depth, softEdges,
526 : nSoftEdges))
527 8 : return true;
528 : }
529 :
530 140 : return false;
531 : }
532 :
533 : static bool
534 198 : FindLockCycleRecurseMember(PGPROC *checkProc,
535 : PGPROC *checkProcLeader,
536 : int depth,
537 : EDGE *softEdges, /* output argument */
538 : int *nSoftEdges) /* output argument */
539 : {
540 : PGPROC *proc;
541 198 : LOCK *lock = checkProc->waitLock;
542 : dlist_iter proclock_iter;
543 : LockMethod lockMethodTable;
544 : int conflictMask;
545 : int i;
546 : int numLockModes,
547 : lm;
548 :
549 : /*
550 : * The relation extension lock can never participate in actual deadlock
551 : * cycle. See Assert in LockAcquireExtended. So, there is no advantage
552 : * in checking wait edges from it.
553 : */
554 198 : if (LOCK_LOCKTAG(*lock) == LOCKTAG_RELATION_EXTEND)
555 0 : return false;
556 :
557 198 : lockMethodTable = GetLocksMethodTable(lock);
558 198 : numLockModes = lockMethodTable->numLockModes;
559 198 : conflictMask = lockMethodTable->conflictTab[checkProc->waitLockMode];
560 :
561 : /*
562 : * Scan for procs that already hold conflicting locks. These are "hard"
563 : * edges in the waits-for graph.
564 : */
565 572 : dlist_foreach(proclock_iter, &lock->procLocks)
566 : {
567 454 : PROCLOCK *proclock = dlist_container(PROCLOCK, lockLink, proclock_iter.cur);
568 : PGPROC *leader;
569 :
570 454 : proc = proclock->tag.myProc;
571 454 : leader = proc->lockGroupLeader == NULL ? proc : proc->lockGroupLeader;
572 :
573 : /* A proc never blocks itself or any other lock group member */
574 454 : if (leader != checkProcLeader)
575 : {
576 2222 : for (lm = 1; lm <= numLockModes; lm++)
577 : {
578 2076 : if ((proclock->holdMask & LOCKBIT_ON(lm)) &&
579 : (conflictMask & LOCKBIT_ON(lm)))
580 : {
581 : /* This proc hard-blocks checkProc */
582 146 : if (FindLockCycleRecurse(proc, depth + 1,
583 : softEdges, nSoftEdges))
584 : {
585 : /* fill deadlockDetails[] */
586 80 : DEADLOCK_INFO *info = &deadlockDetails[depth];
587 :
588 80 : info->locktag = lock->tag;
589 80 : info->lockmode = checkProc->waitLockMode;
590 80 : info->pid = checkProc->pid;
591 :
592 80 : return true;
593 : }
594 :
595 : /*
596 : * No deadlock here, but see if this proc is an autovacuum
597 : * that is directly hard-blocking our own proc. If so,
598 : * report it so that the caller can send a cancel signal
599 : * to it, if appropriate. If there's more than one such
600 : * proc, it's indeterminate which one will be reported.
601 : *
602 : * We don't touch autovacuums that are indirectly blocking
603 : * us; it's up to the direct blockee to take action. This
604 : * rule simplifies understanding the behavior and ensures
605 : * that an autovacuum won't be canceled with less than
606 : * deadlock_timeout grace period.
607 : *
608 : * Note we read statusFlags without any locking. This is
609 : * OK only for checking the PROC_IS_AUTOVACUUM flag,
610 : * because that flag is set at process start and never
611 : * reset. There is logic elsewhere to avoid canceling an
612 : * autovacuum that is working to prevent XID wraparound
613 : * problems (which needs to read a different statusFlags
614 : * bit), but we don't do that here to avoid grabbing
615 : * ProcArrayLock.
616 : */
617 66 : if (checkProc == MyProc &&
618 44 : proc->statusFlags & PROC_IS_AUTOVACUUM)
619 0 : blocking_autovacuum_proc = proc;
620 :
621 : /* We're done looking at this proclock */
622 66 : break;
623 : }
624 : }
625 : }
626 : }
627 :
628 : /*
629 : * Scan for procs that are ahead of this one in the lock's wait queue.
630 : * Those that have conflicting requests soft-block this one. This must be
631 : * done after the hard-block search, since if another proc both hard- and
632 : * soft-blocks this one, we want to call it a hard edge.
633 : *
634 : * If there is a proposed re-ordering of the lock's wait order, use that
635 : * rather than the current wait order.
636 : */
637 136 : for (i = 0; i < nWaitOrders; i++)
638 : {
639 54 : if (waitOrders[i].lock == lock)
640 36 : break;
641 : }
642 :
643 118 : if (i < nWaitOrders)
644 : {
645 : /* Use the given hypothetical wait queue order */
646 36 : PGPROC **procs = waitOrders[i].procs;
647 36 : int queue_size = waitOrders[i].nProcs;
648 :
649 46 : for (i = 0; i < queue_size; i++)
650 : {
651 : PGPROC *leader;
652 :
653 46 : proc = procs[i];
654 46 : leader = proc->lockGroupLeader == NULL ? proc :
655 : proc->lockGroupLeader;
656 :
657 : /*
658 : * TopoSort will always return an ordering with group members
659 : * adjacent to each other in the wait queue (see comments
660 : * therein). So, as soon as we reach a process in the same lock
661 : * group as checkProc, we know we've found all the conflicts that
662 : * precede any member of the lock group lead by checkProcLeader.
663 : */
664 46 : if (leader == checkProcLeader)
665 36 : break;
666 :
667 : /* Is there a conflict with this guy's request? */
668 10 : if ((LOCKBIT_ON(proc->waitLockMode) & conflictMask) != 0)
669 : {
670 : /* This proc soft-blocks checkProc */
671 10 : if (FindLockCycleRecurse(proc, depth + 1,
672 : softEdges, nSoftEdges))
673 : {
674 : /* fill deadlockDetails[] */
675 0 : DEADLOCK_INFO *info = &deadlockDetails[depth];
676 :
677 0 : info->locktag = lock->tag;
678 0 : info->lockmode = checkProc->waitLockMode;
679 0 : info->pid = checkProc->pid;
680 :
681 : /*
682 : * Add this edge to the list of soft edges in the cycle
683 : */
684 : Assert(*nSoftEdges < MaxBackends);
685 0 : softEdges[*nSoftEdges].waiter = checkProcLeader;
686 0 : softEdges[*nSoftEdges].blocker = leader;
687 0 : softEdges[*nSoftEdges].lock = lock;
688 0 : (*nSoftEdges)++;
689 0 : return true;
690 : }
691 : }
692 : }
693 : }
694 : else
695 : {
696 82 : PGPROC *lastGroupMember = NULL;
697 : dlist_iter proc_iter;
698 : dclist_head *waitQueue;
699 :
700 : /* Use the true lock wait queue order */
701 82 : waitQueue = &lock->waitProcs;
702 :
703 : /*
704 : * Find the last member of the lock group that is present in the wait
705 : * queue. Anything after this is not a soft lock conflict. If group
706 : * locking is not in use, then we know immediately which process we're
707 : * looking for, but otherwise we've got to search the wait queue to
708 : * find the last process actually present.
709 : */
710 82 : if (checkProc->lockGroupLeader == NULL)
711 64 : lastGroupMember = checkProc;
712 : else
713 : {
714 64 : dclist_foreach(proc_iter, waitQueue)
715 : {
716 46 : proc = dlist_container(PGPROC, links, proc_iter.cur);
717 :
718 46 : if (proc->lockGroupLeader == checkProcLeader)
719 26 : lastGroupMember = proc;
720 : }
721 : Assert(lastGroupMember != NULL);
722 : }
723 :
724 : /*
725 : * OK, now rescan (or scan) the queue to identify the soft conflicts.
726 : */
727 104 : dclist_foreach(proc_iter, waitQueue)
728 : {
729 : PGPROC *leader;
730 :
731 104 : proc = dlist_container(PGPROC, links, proc_iter.cur);
732 :
733 104 : leader = proc->lockGroupLeader == NULL ? proc :
734 : proc->lockGroupLeader;
735 :
736 : /* Done when we reach the target proc */
737 104 : if (proc == lastGroupMember)
738 72 : break;
739 :
740 : /* Is there a conflict with this guy's request? */
741 32 : if ((LOCKBIT_ON(proc->waitLockMode) & conflictMask) != 0 &&
742 : leader != checkProcLeader)
743 : {
744 : /* This proc soft-blocks checkProc */
745 22 : if (FindLockCycleRecurse(proc, depth + 1,
746 : softEdges, nSoftEdges))
747 : {
748 : /* fill deadlockDetails[] */
749 10 : DEADLOCK_INFO *info = &deadlockDetails[depth];
750 :
751 10 : info->locktag = lock->tag;
752 10 : info->lockmode = checkProc->waitLockMode;
753 10 : info->pid = checkProc->pid;
754 :
755 : /*
756 : * Add this edge to the list of soft edges in the cycle
757 : */
758 : Assert(*nSoftEdges < MaxBackends);
759 10 : softEdges[*nSoftEdges].waiter = checkProcLeader;
760 10 : softEdges[*nSoftEdges].blocker = leader;
761 10 : softEdges[*nSoftEdges].lock = lock;
762 10 : (*nSoftEdges)++;
763 10 : return true;
764 : }
765 : }
766 : }
767 : }
768 :
769 : /*
770 : * No conflict detected here.
771 : */
772 108 : return false;
773 : }
774 :
775 :
776 : /*
777 : * ExpandConstraints -- expand a list of constraints into a set of
778 : * specific new orderings for affected wait queues
779 : *
780 : * Input is a list of soft edges to be reversed. The output is a list
781 : * of nWaitOrders WAIT_ORDER structs in waitOrders[], with PGPROC array
782 : * workspace in waitOrderProcs[].
783 : *
784 : * Returns true if able to build an ordering that satisfies all the
785 : * constraints, false if not (there are contradictory constraints).
786 : */
787 : static bool
788 68 : ExpandConstraints(EDGE *constraints,
789 : int nConstraints)
790 : {
791 68 : int nWaitOrderProcs = 0;
792 : int i,
793 : j;
794 :
795 68 : nWaitOrders = 0;
796 :
797 : /*
798 : * Scan constraint list backwards. This is because the last-added
799 : * constraint is the only one that could fail, and so we want to test it
800 : * for inconsistency first.
801 : */
802 74 : for (i = nConstraints; --i >= 0;)
803 : {
804 6 : LOCK *lock = constraints[i].lock;
805 :
806 : /* Did we already make a list for this lock? */
807 6 : for (j = nWaitOrders; --j >= 0;)
808 : {
809 0 : if (waitOrders[j].lock == lock)
810 0 : break;
811 : }
812 6 : if (j >= 0)
813 0 : continue;
814 : /* No, so allocate a new list */
815 6 : waitOrders[nWaitOrders].lock = lock;
816 6 : waitOrders[nWaitOrders].procs = waitOrderProcs + nWaitOrderProcs;
817 6 : waitOrders[nWaitOrders].nProcs = dclist_count(&lock->waitProcs);
818 6 : nWaitOrderProcs += dclist_count(&lock->waitProcs);
819 : Assert(nWaitOrderProcs <= MaxBackends);
820 :
821 : /*
822 : * Do the topo sort. TopoSort need not examine constraints after this
823 : * one, since they must be for different locks.
824 : */
825 6 : if (!TopoSort(lock, constraints, i + 1,
826 6 : waitOrders[nWaitOrders].procs))
827 0 : return false;
828 6 : nWaitOrders++;
829 : }
830 68 : return true;
831 : }
832 :
833 :
834 : /*
835 : * TopoSort -- topological sort of a wait queue
836 : *
837 : * Generate a re-ordering of a lock's wait queue that satisfies given
838 : * constraints about certain procs preceding others. (Each such constraint
839 : * is a fact of a partial ordering.) Minimize rearrangement of the queue
840 : * not needed to achieve the partial ordering.
841 : *
842 : * This is a lot simpler and slower than, for example, the topological sort
843 : * algorithm shown in Knuth's Volume 1. However, Knuth's method doesn't
844 : * try to minimize the damage to the existing order. In practice we are
845 : * not likely to be working with more than a few constraints, so the apparent
846 : * slowness of the algorithm won't really matter.
847 : *
848 : * The initial queue ordering is taken directly from the lock's wait queue.
849 : * The output is an array of PGPROC pointers, of length equal to the lock's
850 : * wait queue length (the caller is responsible for providing this space).
851 : * The partial order is specified by an array of EDGE structs. Each EDGE
852 : * is one that we need to reverse, therefore the "waiter" must appear before
853 : * the "blocker" in the output array. The EDGE array may well contain
854 : * edges associated with other locks; these should be ignored.
855 : *
856 : * Returns true if able to build an ordering that satisfies all the
857 : * constraints, false if not (there are contradictory constraints).
858 : */
859 : static bool
860 6 : TopoSort(LOCK *lock,
861 : EDGE *constraints,
862 : int nConstraints,
863 : PGPROC **ordering) /* output argument */
864 : {
865 6 : dclist_head *waitQueue = &lock->waitProcs;
866 6 : int queue_size = dclist_count(waitQueue);
867 : PGPROC *proc;
868 : int i,
869 : j,
870 : jj,
871 : k,
872 : kk,
873 : last;
874 : dlist_iter proc_iter;
875 :
876 : /* First, fill topoProcs[] array with the procs in their current order */
877 6 : i = 0;
878 24 : dclist_foreach(proc_iter, waitQueue)
879 : {
880 18 : proc = dlist_container(PGPROC, links, proc_iter.cur);
881 18 : topoProcs[i++] = proc;
882 : }
883 : Assert(i == queue_size);
884 :
885 : /*
886 : * Scan the constraints, and for each proc in the array, generate a count
887 : * of the number of constraints that say it must be before something else,
888 : * plus a list of the constraints that say it must be after something
889 : * else. The count for the j'th proc is stored in beforeConstraints[j],
890 : * and the head of its list in afterConstraints[j]. Each constraint
891 : * stores its list link in constraints[i].link (note any constraint will
892 : * be in just one list). The array index for the before-proc of the i'th
893 : * constraint is remembered in constraints[i].pred.
894 : *
895 : * Note that it's not necessarily the case that every constraint affects
896 : * this particular wait queue. Prior to group locking, a process could be
897 : * waiting for at most one lock. But a lock group can be waiting for
898 : * zero, one, or multiple locks. Since topoProcs[] is an array of the
899 : * processes actually waiting, while constraints[] is an array of group
900 : * leaders, we've got to scan through topoProcs[] for each constraint,
901 : * checking whether both a waiter and a blocker for that group are
902 : * present. If so, the constraint is relevant to this wait queue; if not,
903 : * it isn't.
904 : */
905 12 : MemSet(beforeConstraints, 0, queue_size * sizeof(int));
906 12 : MemSet(afterConstraints, 0, queue_size * sizeof(int));
907 12 : for (i = 0; i < nConstraints; i++)
908 : {
909 : /*
910 : * Find a representative process that is on the lock queue and part of
911 : * the waiting lock group. This may or may not be the leader, which
912 : * may or may not be waiting at all. If there are any other processes
913 : * in the same lock group on the queue, set their number of
914 : * beforeConstraints to -1 to indicate that they should be emitted
915 : * with their groupmates rather than considered separately.
916 : *
917 : * In this loop and the similar one just below, it's critical that we
918 : * consistently select the same representative member of any one lock
919 : * group, so that all the constraints are associated with the same
920 : * proc, and the -1's are only associated with not-representative
921 : * members. We select the last one in the topoProcs array.
922 : */
923 6 : proc = constraints[i].waiter;
924 : Assert(proc != NULL);
925 6 : jj = -1;
926 24 : for (j = queue_size; --j >= 0;)
927 : {
928 18 : PGPROC *waiter = topoProcs[j];
929 :
930 18 : if (waiter == proc || waiter->lockGroupLeader == proc)
931 : {
932 : Assert(waiter->waitLock == lock);
933 10 : if (jj == -1)
934 6 : jj = j;
935 : else
936 : {
937 : Assert(beforeConstraints[j] <= 0);
938 4 : beforeConstraints[j] = -1;
939 : }
940 : }
941 : }
942 :
943 : /* If no matching waiter, constraint is not relevant to this lock. */
944 6 : if (jj < 0)
945 0 : continue;
946 :
947 : /*
948 : * Similarly, find a representative process that is on the lock queue
949 : * and waiting for the blocking lock group. Again, this could be the
950 : * leader but does not need to be.
951 : */
952 6 : proc = constraints[i].blocker;
953 : Assert(proc != NULL);
954 6 : kk = -1;
955 24 : for (k = queue_size; --k >= 0;)
956 : {
957 18 : PGPROC *blocker = topoProcs[k];
958 :
959 18 : if (blocker == proc || blocker->lockGroupLeader == proc)
960 : {
961 : Assert(blocker->waitLock == lock);
962 6 : if (kk == -1)
963 6 : kk = k;
964 : else
965 : {
966 : Assert(beforeConstraints[k] <= 0);
967 0 : beforeConstraints[k] = -1;
968 : }
969 : }
970 : }
971 :
972 : /* If no matching blocker, constraint is not relevant to this lock. */
973 6 : if (kk < 0)
974 0 : continue;
975 :
976 : Assert(beforeConstraints[jj] >= 0);
977 6 : beforeConstraints[jj]++; /* waiter must come before */
978 : /* add this constraint to list of after-constraints for blocker */
979 6 : constraints[i].pred = jj;
980 6 : constraints[i].link = afterConstraints[kk];
981 6 : afterConstraints[kk] = i + 1;
982 : }
983 :
984 : /*--------------------
985 : * Now scan the topoProcs array backwards. At each step, output the
986 : * last proc that has no remaining before-constraints plus any other
987 : * members of the same lock group; then decrease the beforeConstraints
988 : * count of each of the procs it was constrained against.
989 : * i = index of ordering[] entry we want to output this time
990 : * j = search index for topoProcs[]
991 : * k = temp for scanning constraint list for proc j
992 : * last = last non-null index in topoProcs (avoid redundant searches)
993 : *--------------------
994 : */
995 6 : last = queue_size - 1;
996 20 : for (i = queue_size - 1; i >= 0;)
997 : {
998 : int c;
999 14 : int nmatches = 0;
1000 :
1001 : /* Find next candidate to output */
1002 14 : while (topoProcs[last] == NULL)
1003 0 : last--;
1004 28 : for (j = last; j >= 0; j--)
1005 : {
1006 28 : if (topoProcs[j] != NULL && beforeConstraints[j] == 0)
1007 14 : break;
1008 : }
1009 :
1010 : /* If no available candidate, topological sort fails */
1011 14 : if (j < 0)
1012 0 : return false;
1013 :
1014 : /*
1015 : * Output everything in the lock group. There's no point in
1016 : * outputting an ordering where members of the same lock group are not
1017 : * consecutive on the wait queue: if some other waiter is between two
1018 : * requests that belong to the same group, then either it conflicts
1019 : * with both of them and is certainly not a solution; or it conflicts
1020 : * with at most one of them and is thus isomorphic to an ordering
1021 : * where the group members are consecutive.
1022 : */
1023 14 : proc = topoProcs[j];
1024 14 : if (proc->lockGroupLeader != NULL)
1025 4 : proc = proc->lockGroupLeader;
1026 : Assert(proc != NULL);
1027 56 : for (c = 0; c <= last; ++c)
1028 : {
1029 42 : if (topoProcs[c] == proc || (topoProcs[c] != NULL &&
1030 22 : topoProcs[c]->lockGroupLeader == proc))
1031 : {
1032 18 : ordering[i - nmatches] = topoProcs[c];
1033 18 : topoProcs[c] = NULL;
1034 18 : ++nmatches;
1035 : }
1036 : }
1037 : Assert(nmatches > 0);
1038 14 : i -= nmatches;
1039 :
1040 : /* Update beforeConstraints counts of its predecessors */
1041 20 : for (k = afterConstraints[j]; k > 0; k = constraints[k - 1].link)
1042 6 : beforeConstraints[constraints[k - 1].pred]--;
1043 : }
1044 :
1045 : /* Done */
1046 6 : return true;
1047 : }
1048 :
1049 : #ifdef DEBUG_DEADLOCK
1050 : static void
1051 : PrintLockQueue(LOCK *lock, const char *info)
1052 : {
1053 : dclist_head *waitQueue = &lock->waitProcs;
1054 : dlist_iter proc_iter;
1055 :
1056 : printf("%s lock %p queue ", info, lock);
1057 :
1058 : dclist_foreach(proc_iter, waitQueue)
1059 : {
1060 : PGPROC *proc = dlist_container(PGPROC, links, proc_iter.cur);
1061 :
1062 : printf(" %d", proc->pid);
1063 : }
1064 : printf("\n");
1065 : fflush(stdout);
1066 : }
1067 : #endif
1068 :
1069 : /*
1070 : * Report a detected deadlock, with available details.
1071 : */
1072 : void
1073 12 : DeadLockReport(void)
1074 : {
1075 : StringInfoData clientbuf; /* errdetail for client */
1076 : StringInfoData logbuf; /* errdetail for server log */
1077 : StringInfoData locktagbuf;
1078 : int i;
1079 :
1080 12 : initStringInfo(&clientbuf);
1081 12 : initStringInfo(&logbuf);
1082 12 : initStringInfo(&locktagbuf);
1083 :
1084 : /* Generate the "waits for" lines sent to the client */
1085 50 : for (i = 0; i < nDeadlockDetails; i++)
1086 : {
1087 38 : DEADLOCK_INFO *info = &deadlockDetails[i];
1088 : int nextpid;
1089 :
1090 : /* The last proc waits for the first one... */
1091 38 : if (i < nDeadlockDetails - 1)
1092 26 : nextpid = info[1].pid;
1093 : else
1094 12 : nextpid = deadlockDetails[0].pid;
1095 :
1096 : /* reset locktagbuf to hold next object description */
1097 38 : resetStringInfo(&locktagbuf);
1098 :
1099 38 : DescribeLockTag(&locktagbuf, &info->locktag);
1100 :
1101 38 : if (i > 0)
1102 26 : appendStringInfoChar(&clientbuf, '\n');
1103 :
1104 76 : appendStringInfo(&clientbuf,
1105 38 : _("Process %d waits for %s on %s; blocked by process %d."),
1106 : info->pid,
1107 38 : GetLockmodeName(info->locktag.locktag_lockmethodid,
1108 : info->lockmode),
1109 : locktagbuf.data,
1110 : nextpid);
1111 : }
1112 :
1113 : /* Duplicate all the above for the server ... */
1114 12 : appendBinaryStringInfo(&logbuf, clientbuf.data, clientbuf.len);
1115 :
1116 : /* ... and add info about query strings */
1117 50 : for (i = 0; i < nDeadlockDetails; i++)
1118 : {
1119 38 : DEADLOCK_INFO *info = &deadlockDetails[i];
1120 :
1121 38 : appendStringInfoChar(&logbuf, '\n');
1122 :
1123 38 : appendStringInfo(&logbuf,
1124 38 : _("Process %d: %s"),
1125 : info->pid,
1126 : pgstat_get_backend_current_activity(info->pid, false));
1127 : }
1128 :
1129 12 : pgstat_report_deadlock();
1130 :
1131 12 : ereport(ERROR,
1132 : (errcode(ERRCODE_T_R_DEADLOCK_DETECTED),
1133 : errmsg("deadlock detected"),
1134 : errdetail_internal("%s", clientbuf.data),
1135 : errdetail_log("%s", logbuf.data),
1136 : errhint("See server log for query details.")));
1137 : }
1138 :
1139 : /*
1140 : * RememberSimpleDeadLock: set up info for DeadLockReport when ProcSleep
1141 : * detects a trivial (two-way) deadlock. proc1 wants to block for lockmode
1142 : * on lock, but proc2 is already waiting and would be blocked by proc1.
1143 : */
1144 : void
1145 2 : RememberSimpleDeadLock(PGPROC *proc1,
1146 : LOCKMODE lockmode,
1147 : LOCK *lock,
1148 : PGPROC *proc2)
1149 : {
1150 2 : DEADLOCK_INFO *info = &deadlockDetails[0];
1151 :
1152 2 : info->locktag = lock->tag;
1153 2 : info->lockmode = lockmode;
1154 2 : info->pid = proc1->pid;
1155 2 : info++;
1156 2 : info->locktag = proc2->waitLock->tag;
1157 2 : info->lockmode = proc2->waitLockMode;
1158 2 : info->pid = proc2->pid;
1159 2 : nDeadlockDetails = 2;
1160 2 : }
|
