Line data Source code
1 : /*-------------------------------------------------------------------------
2 : *
3 : * standby.c
4 : * Misc functions used in Hot Standby mode.
5 : *
6 : * All functions for handling RM_STANDBY_ID, which relate to
7 : * AccessExclusiveLocks and starting snapshots for Hot Standby mode.
8 : * Plus conflict recovery processing.
9 : *
10 : * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
11 : * Portions Copyright (c) 1994, Regents of the University of California
12 : *
13 : * IDENTIFICATION
14 : * src/backend/storage/ipc/standby.c
15 : *
16 : *-------------------------------------------------------------------------
17 : */
18 : #include "postgres.h"
19 : #include "access/transam.h"
20 : #include "access/twophase.h"
21 : #include "access/xact.h"
22 : #include "access/xloginsert.h"
23 : #include "access/xlogrecovery.h"
24 : #include "access/xlogutils.h"
25 : #include "miscadmin.h"
26 : #include "pgstat.h"
27 : #include "replication/slot.h"
28 : #include "storage/bufmgr.h"
29 : #include "storage/proc.h"
30 : #include "storage/procarray.h"
31 : #include "storage/sinvaladt.h"
32 : #include "storage/standby.h"
33 : #include "utils/hsearch.h"
34 : #include "utils/injection_point.h"
35 : #include "utils/ps_status.h"
36 : #include "utils/timeout.h"
37 : #include "utils/timestamp.h"
38 :
39 : /* User-settable GUC parameters */
40 : int max_standby_archive_delay = 30 * 1000;
41 : int max_standby_streaming_delay = 30 * 1000;
42 : bool log_recovery_conflict_waits = false;
43 :
44 : /*
45 : * Keep track of all the exclusive locks owned by original transactions.
46 : * For each known exclusive lock, there is a RecoveryLockEntry in the
47 : * RecoveryLockHash hash table. All RecoveryLockEntrys belonging to a
48 : * given XID are chained together so that we can find them easily.
49 : * For each original transaction that is known to have any such locks,
50 : * there is a RecoveryLockXidEntry in the RecoveryLockXidHash hash table,
51 : * which stores the head of the chain of its locks.
52 : */
53 : typedef struct RecoveryLockEntry
54 : {
55 : xl_standby_lock key; /* hash key: xid, dbOid, relOid */
56 : struct RecoveryLockEntry *next; /* chain link */
57 : } RecoveryLockEntry;
58 :
59 : typedef struct RecoveryLockXidEntry
60 : {
61 : TransactionId xid; /* hash key -- must be first */
62 : struct RecoveryLockEntry *head; /* chain head */
63 : } RecoveryLockXidEntry;
64 :
65 : static HTAB *RecoveryLockHash = NULL;
66 : static HTAB *RecoveryLockXidHash = NULL;
67 :
68 : /* Flags set by timeout handlers */
69 : static volatile sig_atomic_t got_standby_deadlock_timeout = false;
70 : static volatile sig_atomic_t got_standby_delay_timeout = false;
71 : static volatile sig_atomic_t got_standby_lock_timeout = false;
72 :
73 : static void ResolveRecoveryConflictWithVirtualXIDs(VirtualTransactionId *waitlist,
74 : ProcSignalReason reason,
75 : uint32 wait_event_info,
76 : bool report_waiting);
77 : static void SendRecoveryConflictWithBufferPin(ProcSignalReason reason);
78 : static XLogRecPtr LogCurrentRunningXacts(RunningTransactions CurrRunningXacts);
79 : static void LogAccessExclusiveLocks(int nlocks, xl_standby_lock *locks);
80 : static const char *get_recovery_conflict_desc(ProcSignalReason reason);
81 :
82 : /*
83 : * InitRecoveryTransactionEnvironment
84 : * Initialize tracking of our primary's in-progress transactions.
85 : *
86 : * We need to issue shared invalidations and hold locks. Holding locks
87 : * means others may want to wait on us, so we need to make a lock table
88 : * vxact entry like a real transaction. We could create and delete
89 : * lock table entries for each transaction but its simpler just to create
90 : * one permanent entry and leave it there all the time. Locks are then
91 : * acquired and released as needed. Yes, this means you can see the
92 : * Startup process in pg_locks once we have run this.
93 : */
94 : void
95 228 : InitRecoveryTransactionEnvironment(void)
96 : {
97 : VirtualTransactionId vxid;
98 : HASHCTL hash_ctl;
99 :
100 : Assert(RecoveryLockHash == NULL); /* don't run this twice */
101 :
102 : /*
103 : * Initialize the hash tables for tracking the locks held by each
104 : * transaction.
105 : */
106 228 : hash_ctl.keysize = sizeof(xl_standby_lock);
107 228 : hash_ctl.entrysize = sizeof(RecoveryLockEntry);
108 228 : RecoveryLockHash = hash_create("RecoveryLockHash",
109 : 64,
110 : &hash_ctl,
111 : HASH_ELEM | HASH_BLOBS);
112 228 : hash_ctl.keysize = sizeof(TransactionId);
113 228 : hash_ctl.entrysize = sizeof(RecoveryLockXidEntry);
114 228 : RecoveryLockXidHash = hash_create("RecoveryLockXidHash",
115 : 64,
116 : &hash_ctl,
117 : HASH_ELEM | HASH_BLOBS);
118 :
119 : /*
120 : * Initialize shared invalidation management for Startup process, being
121 : * careful to register ourselves as a sendOnly process so we don't need to
122 : * read messages, nor will we get signaled when the queue starts filling
123 : * up.
124 : */
125 228 : SharedInvalBackendInit(true);
126 :
127 : /*
128 : * Lock a virtual transaction id for Startup process.
129 : *
130 : * We need to do GetNextLocalTransactionId() because
131 : * SharedInvalBackendInit() leaves localTransactionId invalid and the lock
132 : * manager doesn't like that at all.
133 : *
134 : * Note that we don't need to run XactLockTableInsert() because nobody
135 : * needs to wait on xids. That sounds a little strange, but table locks
136 : * are held by vxids and row level locks are held by xids. All queries
137 : * hold AccessShareLocks so never block while we write or lock new rows.
138 : */
139 228 : MyProc->vxid.procNumber = MyProcNumber;
140 228 : vxid.procNumber = MyProcNumber;
141 228 : vxid.localTransactionId = GetNextLocalTransactionId();
142 228 : VirtualXactLockTableInsert(vxid);
143 :
144 228 : standbyState = STANDBY_INITIALIZED;
145 228 : }
146 :
147 : /*
148 : * ShutdownRecoveryTransactionEnvironment
149 : * Shut down transaction tracking
150 : *
151 : * Prepare to switch from hot standby mode to normal operation. Shut down
152 : * recovery-time transaction tracking.
153 : *
154 : * This must be called even in shutdown of startup process if transaction
155 : * tracking has been initialized. Otherwise some locks the tracked
156 : * transactions were holding will not be released and may interfere with
157 : * the processes still running (but will exit soon later) at the exit of
158 : * startup process.
159 : */
160 : void
161 338 : ShutdownRecoveryTransactionEnvironment(void)
162 : {
163 : /*
164 : * Do nothing if RecoveryLockHash is NULL because that means that
165 : * transaction tracking has not yet been initialized or has already been
166 : * shut down. This makes it safe to have possibly-redundant calls of this
167 : * function during process exit.
168 : */
169 338 : if (RecoveryLockHash == NULL)
170 110 : return;
171 :
172 : /* Mark all tracked in-progress transactions as finished. */
173 228 : ExpireAllKnownAssignedTransactionIds();
174 :
175 : /* Release all locks the tracked transactions were holding */
176 228 : StandbyReleaseAllLocks();
177 :
178 : /* Destroy the lock hash tables. */
179 228 : hash_destroy(RecoveryLockHash);
180 228 : hash_destroy(RecoveryLockXidHash);
181 228 : RecoveryLockHash = NULL;
182 228 : RecoveryLockXidHash = NULL;
183 :
184 : /* Cleanup our VirtualTransaction */
185 228 : VirtualXactLockTableCleanup();
186 : }
187 :
188 :
189 : /*
190 : * -----------------------------------------------------
191 : * Standby wait timers and backend cancel logic
192 : * -----------------------------------------------------
193 : */
194 :
195 : /*
196 : * Determine the cutoff time at which we want to start canceling conflicting
197 : * transactions. Returns zero (a time safely in the past) if we are willing
198 : * to wait forever.
199 : */
200 : static TimestampTz
201 54 : GetStandbyLimitTime(void)
202 : {
203 : TimestampTz rtime;
204 : bool fromStream;
205 :
206 : /*
207 : * The cutoff time is the last WAL data receipt time plus the appropriate
208 : * delay variable. Delay of -1 means wait forever.
209 : */
210 54 : GetXLogReceiptTime(&rtime, &fromStream);
211 54 : if (fromStream)
212 : {
213 54 : if (max_standby_streaming_delay < 0)
214 0 : return 0; /* wait forever */
215 54 : return TimestampTzPlusMilliseconds(rtime, max_standby_streaming_delay);
216 : }
217 : else
218 : {
219 0 : if (max_standby_archive_delay < 0)
220 0 : return 0; /* wait forever */
221 0 : return TimestampTzPlusMilliseconds(rtime, max_standby_archive_delay);
222 : }
223 : }
224 :
225 : #define STANDBY_INITIAL_WAIT_US 1000
226 : static int standbyWait_us = STANDBY_INITIAL_WAIT_US;
227 :
228 : /*
229 : * Standby wait logic for ResolveRecoveryConflictWithVirtualXIDs.
230 : * We wait here for a while then return. If we decide we can't wait any
231 : * more then we return true, if we can wait some more return false.
232 : */
233 : static bool
234 30 : WaitExceedsMaxStandbyDelay(uint32 wait_event_info)
235 : {
236 : TimestampTz ltime;
237 :
238 30 : CHECK_FOR_INTERRUPTS();
239 :
240 : /* Are we past the limit time? */
241 30 : ltime = GetStandbyLimitTime();
242 30 : if (ltime && GetCurrentTimestamp() >= ltime)
243 6 : return true;
244 :
245 : /*
246 : * Sleep a bit (this is essential to avoid busy-waiting).
247 : */
248 24 : pgstat_report_wait_start(wait_event_info);
249 24 : pg_usleep(standbyWait_us);
250 24 : pgstat_report_wait_end();
251 :
252 : /*
253 : * Progressively increase the sleep times, but not to more than 1s, since
254 : * pg_usleep isn't interruptible on some platforms.
255 : */
256 24 : standbyWait_us *= 2;
257 24 : if (standbyWait_us > 1000000)
258 0 : standbyWait_us = 1000000;
259 :
260 24 : return false;
261 : }
262 :
263 : /*
264 : * Log the recovery conflict.
265 : *
266 : * wait_start is the timestamp when the caller started to wait.
267 : * now is the timestamp when this function has been called.
268 : * wait_list is the list of virtual transaction ids assigned to
269 : * conflicting processes. still_waiting indicates whether
270 : * the startup process is still waiting for the recovery conflict
271 : * to be resolved or not.
272 : */
273 : void
274 20 : LogRecoveryConflict(ProcSignalReason reason, TimestampTz wait_start,
275 : TimestampTz now, VirtualTransactionId *wait_list,
276 : bool still_waiting)
277 : {
278 : long secs;
279 : int usecs;
280 : long msecs;
281 : StringInfoData buf;
282 20 : int nprocs = 0;
283 :
284 : /*
285 : * There must be no conflicting processes when the recovery conflict has
286 : * already been resolved.
287 : */
288 : Assert(still_waiting || wait_list == NULL);
289 :
290 20 : TimestampDifference(wait_start, now, &secs, &usecs);
291 20 : msecs = secs * 1000 + usecs / 1000;
292 20 : usecs = usecs % 1000;
293 :
294 20 : if (wait_list)
295 : {
296 : VirtualTransactionId *vxids;
297 :
298 : /* Construct a string of list of the conflicting processes */
299 6 : vxids = wait_list;
300 12 : while (VirtualTransactionIdIsValid(*vxids))
301 : {
302 6 : PGPROC *proc = ProcNumberGetProc(vxids->procNumber);
303 :
304 : /* proc can be NULL if the target backend is not active */
305 6 : if (proc)
306 : {
307 6 : if (nprocs == 0)
308 : {
309 6 : initStringInfo(&buf);
310 6 : appendStringInfo(&buf, "%d", proc->pid);
311 : }
312 : else
313 0 : appendStringInfo(&buf, ", %d", proc->pid);
314 :
315 6 : nprocs++;
316 : }
317 :
318 6 : vxids++;
319 : }
320 : }
321 :
322 : /*
323 : * If wait_list is specified, report the list of PIDs of active
324 : * conflicting backends in a detail message. Note that if all the backends
325 : * in the list are not active, no detail message is logged.
326 : */
327 20 : if (still_waiting)
328 : {
329 10 : ereport(LOG,
330 : errmsg("recovery still waiting after %ld.%03d ms: %s",
331 : msecs, usecs, get_recovery_conflict_desc(reason)),
332 : nprocs > 0 ? errdetail_log_plural("Conflicting process: %s.",
333 : "Conflicting processes: %s.",
334 : nprocs, buf.data) : 0);
335 : }
336 : else
337 : {
338 10 : ereport(LOG,
339 : errmsg("recovery finished waiting after %ld.%03d ms: %s",
340 : msecs, usecs, get_recovery_conflict_desc(reason)));
341 : }
342 :
343 20 : if (nprocs > 0)
344 6 : pfree(buf.data);
345 20 : }
346 :
347 : /*
348 : * This is the main executioner for any query backend that conflicts with
349 : * recovery processing. Judgement has already been passed on it within
350 : * a specific rmgr. Here we just issue the orders to the procs. The procs
351 : * then throw the required error as instructed.
352 : *
353 : * If report_waiting is true, "waiting" is reported in PS display and the
354 : * wait for recovery conflict is reported in the log, if necessary. If
355 : * the caller is responsible for reporting them, report_waiting should be
356 : * false. Otherwise, both the caller and this function report the same
357 : * thing unexpectedly.
358 : */
359 : static void
360 27370 : ResolveRecoveryConflictWithVirtualXIDs(VirtualTransactionId *waitlist,
361 : ProcSignalReason reason, uint32 wait_event_info,
362 : bool report_waiting)
363 : {
364 27370 : TimestampTz waitStart = 0;
365 27370 : bool waiting = false;
366 27370 : bool logged_recovery_conflict = false;
367 :
368 : /* Fast exit, to avoid a kernel call if there's no work to be done. */
369 27370 : if (!VirtualTransactionIdIsValid(*waitlist))
370 27364 : return;
371 :
372 : /* Set the wait start timestamp for reporting */
373 6 : if (report_waiting && (log_recovery_conflict_waits || update_process_title))
374 4 : waitStart = GetCurrentTimestamp();
375 :
376 12 : while (VirtualTransactionIdIsValid(*waitlist))
377 : {
378 : /* reset standbyWait_us for each xact we wait for */
379 6 : standbyWait_us = STANDBY_INITIAL_WAIT_US;
380 :
381 : /* wait until the virtual xid is gone */
382 36 : while (!VirtualXactLock(*waitlist, false))
383 : {
384 : /* Is it time to kill it? */
385 30 : if (WaitExceedsMaxStandbyDelay(wait_event_info))
386 : {
387 : pid_t pid;
388 :
389 : /*
390 : * Now find out who to throw out of the balloon.
391 : */
392 : Assert(VirtualTransactionIdIsValid(*waitlist));
393 6 : pid = SignalVirtualTransaction(*waitlist, reason);
394 :
395 : /*
396 : * Wait a little bit for it to die so that we avoid flooding
397 : * an unresponsive backend when system is heavily loaded.
398 : */
399 6 : if (pid != 0)
400 6 : pg_usleep(5000L);
401 : }
402 :
403 30 : if (waitStart != 0 && (!logged_recovery_conflict || !waiting))
404 : {
405 28 : TimestampTz now = 0;
406 : bool maybe_log_conflict;
407 : bool maybe_update_title;
408 :
409 28 : maybe_log_conflict = (log_recovery_conflict_waits && !logged_recovery_conflict);
410 28 : maybe_update_title = (update_process_title && !waiting);
411 :
412 : /* Get the current timestamp if not report yet */
413 28 : if (maybe_log_conflict || maybe_update_title)
414 28 : now = GetCurrentTimestamp();
415 :
416 : /*
417 : * Report via ps if we have been waiting for more than 500
418 : * msec (should that be configurable?)
419 : */
420 56 : if (maybe_update_title &&
421 28 : TimestampDifferenceExceeds(waitStart, now, 500))
422 : {
423 0 : set_ps_display_suffix("waiting");
424 0 : waiting = true;
425 : }
426 :
427 : /*
428 : * Emit the log message if the startup process is waiting
429 : * longer than deadlock_timeout for recovery conflict.
430 : */
431 44 : if (maybe_log_conflict &&
432 16 : TimestampDifferenceExceeds(waitStart, now, DeadlockTimeout))
433 : {
434 4 : LogRecoveryConflict(reason, waitStart, now, waitlist, true);
435 4 : logged_recovery_conflict = true;
436 : }
437 : }
438 : }
439 :
440 : /* The virtual transaction is gone now, wait for the next one */
441 6 : waitlist++;
442 : }
443 :
444 : /*
445 : * Emit the log message if recovery conflict was resolved but the startup
446 : * process waited longer than deadlock_timeout for it.
447 : */
448 6 : if (logged_recovery_conflict)
449 4 : LogRecoveryConflict(reason, waitStart, GetCurrentTimestamp(),
450 : NULL, false);
451 :
452 : /* reset ps display to remove the suffix if we added one */
453 6 : if (waiting)
454 0 : set_ps_display_remove_suffix();
455 :
456 : }
457 :
458 : /*
459 : * Generate whatever recovery conflicts are needed to eliminate snapshots that
460 : * might see XIDs <= snapshotConflictHorizon as still running.
461 : *
462 : * snapshotConflictHorizon cutoffs are our standard approach to generating
463 : * granular recovery conflicts. Note that InvalidTransactionId values are
464 : * interpreted as "definitely don't need any conflicts" here, which is a
465 : * general convention that WAL records can (and often do) depend on.
466 : */
467 : void
468 32708 : ResolveRecoveryConflictWithSnapshot(TransactionId snapshotConflictHorizon,
469 : bool isCatalogRel,
470 : RelFileLocator locator)
471 : {
472 : VirtualTransactionId *backends;
473 :
474 : /*
475 : * If we get passed InvalidTransactionId then we do nothing (no conflict).
476 : *
477 : * This can happen when replaying already-applied WAL records after a
478 : * standby crash or restart, or when replaying an XLOG_HEAP2_VISIBLE
479 : * record that marks as frozen a page which was already all-visible. It's
480 : * also quite common with records generated during index deletion
481 : * (original execution of the deletion can reason that a recovery conflict
482 : * which is sufficient for the deletion operation must take place before
483 : * replay of the deletion record itself).
484 : */
485 32708 : if (!TransactionIdIsValid(snapshotConflictHorizon))
486 5342 : return;
487 :
488 : Assert(TransactionIdIsNormal(snapshotConflictHorizon));
489 27366 : backends = GetConflictingVirtualXIDs(snapshotConflictHorizon,
490 : locator.dbOid);
491 27366 : ResolveRecoveryConflictWithVirtualXIDs(backends,
492 : PROCSIG_RECOVERY_CONFLICT_SNAPSHOT,
493 : WAIT_EVENT_RECOVERY_CONFLICT_SNAPSHOT,
494 : true);
495 :
496 : /*
497 : * Note that WaitExceedsMaxStandbyDelay() is not taken into account here
498 : * (as opposed to ResolveRecoveryConflictWithVirtualXIDs() above). That
499 : * seems OK, given that this kind of conflict should not normally be
500 : * reached, e.g. due to using a physical replication slot.
501 : */
502 27366 : if (IsLogicalDecodingEnabled() && isCatalogRel)
503 30 : InvalidateObsoleteReplicationSlots(RS_INVAL_HORIZON, 0, locator.dbOid,
504 : snapshotConflictHorizon);
505 : }
506 :
507 : /*
508 : * Variant of ResolveRecoveryConflictWithSnapshot that works with
509 : * FullTransactionId values
510 : */
511 : void
512 178 : ResolveRecoveryConflictWithSnapshotFullXid(FullTransactionId snapshotConflictHorizon,
513 : bool isCatalogRel,
514 : RelFileLocator locator)
515 : {
516 : /*
517 : * ResolveRecoveryConflictWithSnapshot operates on 32-bit TransactionIds,
518 : * so truncate the logged FullTransactionId. If the logged value is very
519 : * old, so that XID wrap-around already happened on it, there can't be any
520 : * snapshots that still see it.
521 : */
522 178 : FullTransactionId nextXid = ReadNextFullTransactionId();
523 : uint64 diff;
524 :
525 178 : diff = U64FromFullTransactionId(nextXid) -
526 178 : U64FromFullTransactionId(snapshotConflictHorizon);
527 178 : if (diff < MaxTransactionId / 2)
528 : {
529 : TransactionId truncated;
530 :
531 178 : truncated = XidFromFullTransactionId(snapshotConflictHorizon);
532 178 : ResolveRecoveryConflictWithSnapshot(truncated,
533 : isCatalogRel,
534 : locator);
535 : }
536 178 : }
537 :
538 : void
539 2 : ResolveRecoveryConflictWithTablespace(Oid tsid)
540 : {
541 : VirtualTransactionId *temp_file_users;
542 :
543 : /*
544 : * Standby users may be currently using this tablespace for their
545 : * temporary files. We only care about current users because
546 : * temp_tablespace parameter will just ignore tablespaces that no longer
547 : * exist.
548 : *
549 : * Ask everybody to cancel their queries immediately so we can ensure no
550 : * temp files remain and we can remove the tablespace. Nuke the entire
551 : * site from orbit, it's the only way to be sure.
552 : *
553 : * XXX: We could work out the pids of active backends using this
554 : * tablespace by examining the temp filenames in the directory. We would
555 : * then convert the pids into VirtualXIDs before attempting to cancel
556 : * them.
557 : *
558 : * We don't wait for commit because drop tablespace is non-transactional.
559 : */
560 2 : temp_file_users = GetConflictingVirtualXIDs(InvalidTransactionId,
561 : InvalidOid);
562 2 : ResolveRecoveryConflictWithVirtualXIDs(temp_file_users,
563 : PROCSIG_RECOVERY_CONFLICT_TABLESPACE,
564 : WAIT_EVENT_RECOVERY_CONFLICT_TABLESPACE,
565 : true);
566 2 : }
567 :
568 : void
569 28 : ResolveRecoveryConflictWithDatabase(Oid dbid)
570 : {
571 : /*
572 : * We don't do ResolveRecoveryConflictWithVirtualXIDs() here since that
573 : * only waits for transactions and completely idle sessions would block
574 : * us. This is rare enough that we do this as simply as possible: no wait,
575 : * just force them off immediately.
576 : *
577 : * No locking is required here because we already acquired
578 : * AccessExclusiveLock. Anybody trying to connect while we do this will
579 : * block during InitPostgres() and then disconnect when they see the
580 : * database has been removed.
581 : */
582 32 : while (CountDBBackends(dbid) > 0)
583 : {
584 4 : CancelDBBackends(dbid, PROCSIG_RECOVERY_CONFLICT_DATABASE);
585 :
586 : /*
587 : * Wait awhile for them to die so that we avoid flooding an
588 : * unresponsive backend when system is heavily loaded.
589 : */
590 4 : pg_usleep(10000);
591 : }
592 28 : }
593 :
594 : /*
595 : * ResolveRecoveryConflictWithLock is called from ProcSleep()
596 : * to resolve conflicts with other backends holding relation locks.
597 : *
598 : * The WaitLatch sleep normally done in ProcSleep()
599 : * (when not InHotStandby) is performed here, for code clarity.
600 : *
601 : * We either resolve conflicts immediately or set a timeout to wake us at
602 : * the limit of our patience.
603 : *
604 : * Resolve conflicts by canceling to all backends holding a conflicting
605 : * lock. As we are already queued to be granted the lock, no new lock
606 : * requests conflicting with ours will be granted in the meantime.
607 : *
608 : * We also must check for deadlocks involving the Startup process and
609 : * hot-standby backend processes. If deadlock_timeout is reached in
610 : * this function, all the backends holding the conflicting locks are
611 : * requested to check themselves for deadlocks.
612 : *
613 : * logging_conflict should be true if the recovery conflict has not been
614 : * logged yet even though logging is enabled. After deadlock_timeout is
615 : * reached and the request for deadlock check is sent, we wait again to
616 : * be signaled by the release of the lock if logging_conflict is false.
617 : * Otherwise we return without waiting again so that the caller can report
618 : * the recovery conflict. In this case, then, this function is called again
619 : * with logging_conflict=false (because the recovery conflict has already
620 : * been logged) and we will wait again for the lock to be released.
621 : */
622 : void
623 6 : ResolveRecoveryConflictWithLock(LOCKTAG locktag, bool logging_conflict)
624 : {
625 : TimestampTz ltime;
626 : TimestampTz now;
627 :
628 : Assert(InHotStandby);
629 :
630 6 : ltime = GetStandbyLimitTime();
631 6 : now = GetCurrentTimestamp();
632 :
633 : /*
634 : * Update waitStart if first time through after the startup process
635 : * started waiting for the lock. It should not be updated every time
636 : * ResolveRecoveryConflictWithLock() is called during the wait.
637 : *
638 : * Use the current time obtained for comparison with ltime as waitStart
639 : * (i.e., the time when this process started waiting for the lock). Since
640 : * getting the current time newly can cause overhead, we reuse the
641 : * already-obtained time to avoid that overhead.
642 : *
643 : * Note that waitStart is updated without holding the lock table's
644 : * partition lock, to avoid the overhead by additional lock acquisition.
645 : * This can cause "waitstart" in pg_locks to become NULL for a very short
646 : * period of time after the wait started even though "granted" is false.
647 : * This is OK in practice because we can assume that users are likely to
648 : * look at "waitstart" when waiting for the lock for a long time.
649 : */
650 6 : if (pg_atomic_read_u64(&MyProc->waitStart) == 0)
651 2 : pg_atomic_write_u64(&MyProc->waitStart, now);
652 :
653 6 : if (now >= ltime && ltime != 0)
654 2 : {
655 : /*
656 : * We're already behind, so clear a path as quickly as possible.
657 : */
658 : VirtualTransactionId *backends;
659 :
660 2 : backends = GetLockConflicts(&locktag, AccessExclusiveLock, NULL);
661 :
662 : /*
663 : * Prevent ResolveRecoveryConflictWithVirtualXIDs() from reporting
664 : * "waiting" in PS display by disabling its argument report_waiting
665 : * because the caller, WaitOnLock(), has already reported that.
666 : */
667 2 : ResolveRecoveryConflictWithVirtualXIDs(backends,
668 : PROCSIG_RECOVERY_CONFLICT_LOCK,
669 2 : PG_WAIT_LOCK | locktag.locktag_type,
670 : false);
671 : }
672 : else
673 : {
674 : /*
675 : * Wait (or wait again) until ltime, and check for deadlocks as well
676 : * if we will be waiting longer than deadlock_timeout
677 : */
678 : EnableTimeoutParams timeouts[2];
679 4 : int cnt = 0;
680 :
681 4 : if (ltime != 0)
682 : {
683 4 : got_standby_lock_timeout = false;
684 4 : timeouts[cnt].id = STANDBY_LOCK_TIMEOUT;
685 4 : timeouts[cnt].type = TMPARAM_AT;
686 4 : timeouts[cnt].fin_time = ltime;
687 4 : cnt++;
688 : }
689 :
690 4 : got_standby_deadlock_timeout = false;
691 4 : timeouts[cnt].id = STANDBY_DEADLOCK_TIMEOUT;
692 4 : timeouts[cnt].type = TMPARAM_AFTER;
693 4 : timeouts[cnt].delay_ms = DeadlockTimeout;
694 4 : cnt++;
695 :
696 4 : enable_timeouts(timeouts, cnt);
697 : }
698 :
699 : /* Wait to be signaled by the release of the Relation Lock */
700 6 : ProcWaitForSignal(PG_WAIT_LOCK | locktag.locktag_type);
701 :
702 : /*
703 : * Exit if ltime is reached. Then all the backends holding conflicting
704 : * locks will be canceled in the next ResolveRecoveryConflictWithLock()
705 : * call.
706 : */
707 6 : if (got_standby_lock_timeout)
708 0 : goto cleanup;
709 :
710 6 : if (got_standby_deadlock_timeout)
711 : {
712 : VirtualTransactionId *backends;
713 :
714 4 : backends = GetLockConflicts(&locktag, AccessExclusiveLock, NULL);
715 :
716 : /* Quick exit if there's no work to be done */
717 4 : if (!VirtualTransactionIdIsValid(*backends))
718 0 : goto cleanup;
719 :
720 : /*
721 : * Send signals to all the backends holding the conflicting locks, to
722 : * ask them to check themselves for deadlocks.
723 : */
724 8 : while (VirtualTransactionIdIsValid(*backends))
725 : {
726 4 : SignalVirtualTransaction(*backends,
727 : PROCSIG_RECOVERY_CONFLICT_STARTUP_DEADLOCK);
728 4 : backends++;
729 : }
730 :
731 : /*
732 : * Exit if the recovery conflict has not been logged yet even though
733 : * logging is enabled, so that the caller can log that. Then
734 : * RecoveryConflictWithLock() is called again and we will wait again
735 : * for the lock to be released.
736 : */
737 4 : if (logging_conflict)
738 2 : goto cleanup;
739 :
740 : /*
741 : * Wait again here to be signaled by the release of the Relation Lock,
742 : * to prevent the subsequent RecoveryConflictWithLock() from causing
743 : * deadlock_timeout and sending a request for deadlocks check again.
744 : * Otherwise the request continues to be sent every deadlock_timeout
745 : * until the relation locks are released or ltime is reached.
746 : */
747 2 : got_standby_deadlock_timeout = false;
748 2 : ProcWaitForSignal(PG_WAIT_LOCK | locktag.locktag_type);
749 : }
750 :
751 2 : cleanup:
752 :
753 : /*
754 : * Clear any timeout requests established above. We assume here that the
755 : * Startup process doesn't have any other outstanding timeouts than those
756 : * used by this function. If that stops being true, we could cancel the
757 : * timeouts individually, but that'd be slower.
758 : */
759 6 : disable_all_timeouts(false);
760 6 : got_standby_lock_timeout = false;
761 6 : got_standby_deadlock_timeout = false;
762 6 : }
763 :
764 : /*
765 : * ResolveRecoveryConflictWithBufferPin is called from LockBufferForCleanup()
766 : * to resolve conflicts with other backends holding buffer pins.
767 : *
768 : * The ProcWaitForSignal() sleep normally done in LockBufferForCleanup()
769 : * (when not InHotStandby) is performed here, for code clarity.
770 : *
771 : * We either resolve conflicts immediately or set a timeout to wake us at
772 : * the limit of our patience.
773 : *
774 : * Resolve conflicts by sending a PROCSIG signal to all backends to check if
775 : * they hold one of the buffer pins that is blocking Startup process. If so,
776 : * those backends will take an appropriate error action, ERROR or FATAL.
777 : *
778 : * We also must check for deadlocks. Deadlocks occur because if queries
779 : * wait on a lock, that must be behind an AccessExclusiveLock, which can only
780 : * be cleared if the Startup process replays a transaction completion record.
781 : * If Startup process is also waiting then that is a deadlock. The deadlock
782 : * can occur if the query is waiting and then the Startup sleeps, or if
783 : * Startup is sleeping and the query waits on a lock. We protect against
784 : * only the former sequence here, the latter sequence is checked prior to
785 : * the query sleeping, in CheckRecoveryConflictDeadlock().
786 : *
787 : * Deadlocks are extremely rare, and relatively expensive to check for,
788 : * so we don't do a deadlock check right away ... only if we have had to wait
789 : * at least deadlock_timeout.
790 : */
791 : void
792 18 : ResolveRecoveryConflictWithBufferPin(void)
793 : {
794 : TimestampTz ltime;
795 :
796 : Assert(InHotStandby);
797 :
798 18 : ltime = GetStandbyLimitTime();
799 :
800 18 : if (GetCurrentTimestamp() >= ltime && ltime != 0)
801 : {
802 : /*
803 : * We're already behind, so clear a path as quickly as possible.
804 : */
805 2 : SendRecoveryConflictWithBufferPin(PROCSIG_RECOVERY_CONFLICT_BUFFERPIN);
806 : }
807 : else
808 : {
809 : /*
810 : * Wake up at ltime, and check for deadlocks as well if we will be
811 : * waiting longer than deadlock_timeout
812 : */
813 : EnableTimeoutParams timeouts[2];
814 16 : int cnt = 0;
815 :
816 16 : if (ltime != 0)
817 : {
818 16 : timeouts[cnt].id = STANDBY_TIMEOUT;
819 16 : timeouts[cnt].type = TMPARAM_AT;
820 16 : timeouts[cnt].fin_time = ltime;
821 16 : cnt++;
822 : }
823 :
824 16 : got_standby_deadlock_timeout = false;
825 16 : timeouts[cnt].id = STANDBY_DEADLOCK_TIMEOUT;
826 16 : timeouts[cnt].type = TMPARAM_AFTER;
827 16 : timeouts[cnt].delay_ms = DeadlockTimeout;
828 16 : cnt++;
829 :
830 16 : enable_timeouts(timeouts, cnt);
831 : }
832 :
833 : /*
834 : * Wait to be signaled by UnpinBuffer() or for the wait to be interrupted
835 : * by one of the timeouts established above.
836 : *
837 : * We assume that only UnpinBuffer() and the timeout requests established
838 : * above can wake us up here. WakeupRecovery() called by walreceiver or
839 : * SIGHUP signal handler, etc cannot do that because it uses the different
840 : * latch from that ProcWaitForSignal() waits on.
841 : */
842 18 : ProcWaitForSignal(WAIT_EVENT_BUFFER_CLEANUP);
843 :
844 18 : if (got_standby_delay_timeout)
845 2 : SendRecoveryConflictWithBufferPin(PROCSIG_RECOVERY_CONFLICT_BUFFERPIN);
846 16 : else if (got_standby_deadlock_timeout)
847 : {
848 : /*
849 : * Send out a request for hot-standby backends to check themselves for
850 : * deadlocks.
851 : *
852 : * XXX The subsequent ResolveRecoveryConflictWithBufferPin() will wait
853 : * to be signaled by UnpinBuffer() again and send a request for
854 : * deadlocks check if deadlock_timeout happens. This causes the
855 : * request to continue to be sent every deadlock_timeout until the
856 : * buffer is unpinned or ltime is reached. This would increase the
857 : * workload in the startup process and backends. In practice it may
858 : * not be so harmful because the period that the buffer is kept pinned
859 : * is basically no so long. But we should fix this?
860 : */
861 10 : SendRecoveryConflictWithBufferPin(PROCSIG_RECOVERY_CONFLICT_STARTUP_DEADLOCK);
862 : }
863 :
864 : /*
865 : * Clear any timeout requests established above. We assume here that the
866 : * Startup process doesn't have any other timeouts than what this function
867 : * uses. If that stops being true, we could cancel the timeouts
868 : * individually, but that'd be slower.
869 : */
870 18 : disable_all_timeouts(false);
871 18 : got_standby_delay_timeout = false;
872 18 : got_standby_deadlock_timeout = false;
873 18 : }
874 :
875 : static void
876 14 : SendRecoveryConflictWithBufferPin(ProcSignalReason reason)
877 : {
878 : Assert(reason == PROCSIG_RECOVERY_CONFLICT_BUFFERPIN ||
879 : reason == PROCSIG_RECOVERY_CONFLICT_STARTUP_DEADLOCK);
880 :
881 : /*
882 : * We send signal to all backends to ask them if they are holding the
883 : * buffer pin which is delaying the Startup process. Most of them will be
884 : * innocent, but we let the SIGUSR1 handling in each backend decide their
885 : * own fate.
886 : */
887 14 : CancelDBBackends(InvalidOid, reason);
888 14 : }
889 :
890 : /*
891 : * In Hot Standby perform early deadlock detection. We abort the lock
892 : * wait if we are about to sleep while holding the buffer pin that Startup
893 : * process is waiting for.
894 : *
895 : * Note: this code is pessimistic, because there is no way for it to
896 : * determine whether an actual deadlock condition is present: the lock we
897 : * need to wait for might be unrelated to any held by the Startup process.
898 : * Sooner or later, this mechanism should get ripped out in favor of somehow
899 : * accounting for buffer locks in DeadLockCheck(). However, errors here
900 : * seem to be very low-probability in practice, so for now it's not worth
901 : * the trouble.
902 : */
903 : void
904 2 : CheckRecoveryConflictDeadlock(void)
905 : {
906 : Assert(!InRecovery); /* do not call in Startup process */
907 :
908 2 : if (!HoldingBufferPinThatDelaysRecovery())
909 2 : return;
910 :
911 : /*
912 : * Error message should match ProcessInterrupts() but we avoid calling
913 : * that because we aren't handling an interrupt at this point. Note that
914 : * we only cancel the current transaction here, so if we are in a
915 : * subtransaction and the pin is held by a parent, then the Startup
916 : * process will continue to wait even though we have avoided deadlock.
917 : */
918 0 : ereport(ERROR,
919 : (errcode(ERRCODE_T_R_DEADLOCK_DETECTED),
920 : errmsg("canceling statement due to conflict with recovery"),
921 : errdetail("User transaction caused buffer deadlock with recovery.")));
922 : }
923 :
924 :
925 : /* --------------------------------
926 : * timeout handler routines
927 : * --------------------------------
928 : */
929 :
930 : /*
931 : * StandbyDeadLockHandler() will be called if STANDBY_DEADLOCK_TIMEOUT is
932 : * exceeded.
933 : */
934 : void
935 14 : StandbyDeadLockHandler(void)
936 : {
937 14 : got_standby_deadlock_timeout = true;
938 14 : }
939 :
940 : /*
941 : * StandbyTimeoutHandler() will be called if STANDBY_TIMEOUT is exceeded.
942 : */
943 : void
944 2 : StandbyTimeoutHandler(void)
945 : {
946 2 : got_standby_delay_timeout = true;
947 2 : }
948 :
949 : /*
950 : * StandbyLockTimeoutHandler() will be called if STANDBY_LOCK_TIMEOUT is exceeded.
951 : */
952 : void
953 2 : StandbyLockTimeoutHandler(void)
954 : {
955 2 : got_standby_lock_timeout = true;
956 2 : }
957 :
958 : /*
959 : * -----------------------------------------------------
960 : * Locking in Recovery Mode
961 : * -----------------------------------------------------
962 : *
963 : * All locks are held by the Startup process using a single virtual
964 : * transaction. This implementation is both simpler and in some senses,
965 : * more correct. The locks held mean "some original transaction held
966 : * this lock, so query access is not allowed at this time". So the Startup
967 : * process is the proxy by which the original locks are implemented.
968 : *
969 : * We only keep track of AccessExclusiveLocks, which are only ever held by
970 : * one transaction on one relation.
971 : *
972 : * We keep a table of known locks in the RecoveryLockHash hash table.
973 : * The point of that table is to let us efficiently de-duplicate locks,
974 : * which is important because checkpoints will re-report the same locks
975 : * already held. There is also a RecoveryLockXidHash table with one entry
976 : * per xid, which allows us to efficiently find all the locks held by a
977 : * given original transaction.
978 : *
979 : * We use session locks rather than normal locks so we don't need
980 : * ResourceOwners.
981 : */
982 :
983 :
984 : void
985 55072 : StandbyAcquireAccessExclusiveLock(TransactionId xid, Oid dbOid, Oid relOid)
986 : {
987 : RecoveryLockXidEntry *xidentry;
988 : RecoveryLockEntry *lockentry;
989 : xl_standby_lock key;
990 : LOCKTAG locktag;
991 : bool found;
992 :
993 : /* Already processed? */
994 110144 : if (!TransactionIdIsValid(xid) ||
995 110030 : TransactionIdDidCommit(xid) ||
996 54958 : TransactionIdDidAbort(xid))
997 114 : return;
998 :
999 54958 : elog(DEBUG4, "adding recovery lock: db %u rel %u", dbOid, relOid);
1000 :
1001 : /* dbOid is InvalidOid when we are locking a shared relation. */
1002 : Assert(OidIsValid(relOid));
1003 :
1004 : /* Create a hash entry for this xid, if we don't have one already. */
1005 54958 : xidentry = hash_search(RecoveryLockXidHash, &xid, HASH_ENTER, &found);
1006 54958 : if (!found)
1007 : {
1008 : Assert(xidentry->xid == xid); /* dynahash should have set this */
1009 22080 : xidentry->head = NULL;
1010 : }
1011 :
1012 : /* Create a hash entry for this lock, unless we have one already. */
1013 54958 : key.xid = xid;
1014 54958 : key.dbOid = dbOid;
1015 54958 : key.relOid = relOid;
1016 54958 : lockentry = hash_search(RecoveryLockHash, &key, HASH_ENTER, &found);
1017 54958 : if (!found)
1018 : {
1019 : /* It's new, so link it into the XID's list ... */
1020 51770 : lockentry->next = xidentry->head;
1021 51770 : xidentry->head = lockentry;
1022 :
1023 : /* ... and acquire the lock locally. */
1024 51770 : SET_LOCKTAG_RELATION(locktag, dbOid, relOid);
1025 :
1026 51770 : (void) LockAcquire(&locktag, AccessExclusiveLock, true, false);
1027 : }
1028 : }
1029 :
1030 : /*
1031 : * Release all the locks associated with this RecoveryLockXidEntry.
1032 : */
1033 : static void
1034 22080 : StandbyReleaseXidEntryLocks(RecoveryLockXidEntry *xidentry)
1035 : {
1036 : RecoveryLockEntry *entry;
1037 : RecoveryLockEntry *next;
1038 :
1039 73850 : for (entry = xidentry->head; entry != NULL; entry = next)
1040 : {
1041 : LOCKTAG locktag;
1042 :
1043 51770 : elog(DEBUG4,
1044 : "releasing recovery lock: xid %u db %u rel %u",
1045 : entry->key.xid, entry->key.dbOid, entry->key.relOid);
1046 : /* Release the lock ... */
1047 51770 : SET_LOCKTAG_RELATION(locktag, entry->key.dbOid, entry->key.relOid);
1048 51770 : if (!LockRelease(&locktag, AccessExclusiveLock, true))
1049 : {
1050 0 : elog(LOG,
1051 : "RecoveryLockHash contains entry for lock no longer recorded by lock manager: xid %u database %u relation %u",
1052 : entry->key.xid, entry->key.dbOid, entry->key.relOid);
1053 : Assert(false);
1054 : }
1055 : /* ... and remove the per-lock hash entry */
1056 51770 : next = entry->next;
1057 51770 : hash_search(RecoveryLockHash, entry, HASH_REMOVE, NULL);
1058 : }
1059 :
1060 22080 : xidentry->head = NULL; /* just for paranoia */
1061 22080 : }
1062 :
1063 : /*
1064 : * Release locks for specific XID, or all locks if it's InvalidXid.
1065 : */
1066 : static void
1067 23448 : StandbyReleaseLocks(TransactionId xid)
1068 : {
1069 : RecoveryLockXidEntry *entry;
1070 :
1071 23448 : if (TransactionIdIsValid(xid))
1072 : {
1073 23448 : if ((entry = hash_search(RecoveryLockXidHash, &xid, HASH_FIND, NULL)))
1074 : {
1075 22080 : StandbyReleaseXidEntryLocks(entry);
1076 22080 : hash_search(RecoveryLockXidHash, entry, HASH_REMOVE, NULL);
1077 : }
1078 : }
1079 : else
1080 0 : StandbyReleaseAllLocks();
1081 23448 : }
1082 :
1083 : /*
1084 : * Release locks for a transaction tree, starting at xid down, from
1085 : * RecoveryLockXidHash.
1086 : *
1087 : * Called during WAL replay of COMMIT/ROLLBACK when in hot standby mode,
1088 : * to remove any AccessExclusiveLocks requested by a transaction.
1089 : */
1090 : void
1091 22442 : StandbyReleaseLockTree(TransactionId xid, int nsubxids, TransactionId *subxids)
1092 : {
1093 : int i;
1094 :
1095 22442 : StandbyReleaseLocks(xid);
1096 :
1097 23448 : for (i = 0; i < nsubxids; i++)
1098 1006 : StandbyReleaseLocks(subxids[i]);
1099 22442 : }
1100 :
1101 : /*
1102 : * Called at end of recovery and when we see a shutdown checkpoint.
1103 : */
1104 : void
1105 228 : StandbyReleaseAllLocks(void)
1106 : {
1107 : HASH_SEQ_STATUS status;
1108 : RecoveryLockXidEntry *entry;
1109 :
1110 228 : elog(DEBUG2, "release all standby locks");
1111 :
1112 228 : hash_seq_init(&status, RecoveryLockXidHash);
1113 228 : while ((entry = hash_seq_search(&status)))
1114 : {
1115 0 : StandbyReleaseXidEntryLocks(entry);
1116 0 : hash_search(RecoveryLockXidHash, entry, HASH_REMOVE, NULL);
1117 : }
1118 228 : }
1119 :
1120 : /*
1121 : * StandbyReleaseOldLocks
1122 : * Release standby locks held by top-level XIDs that aren't running,
1123 : * as long as they're not prepared transactions.
1124 : *
1125 : * This is needed to prune the locks of crashed transactions, which didn't
1126 : * write an ABORT/COMMIT record.
1127 : */
1128 : void
1129 1662 : StandbyReleaseOldLocks(TransactionId oldxid)
1130 : {
1131 : HASH_SEQ_STATUS status;
1132 : RecoveryLockXidEntry *entry;
1133 :
1134 1662 : hash_seq_init(&status, RecoveryLockXidHash);
1135 2382 : while ((entry = hash_seq_search(&status)))
1136 : {
1137 : Assert(TransactionIdIsValid(entry->xid));
1138 :
1139 : /* Skip if prepared transaction. */
1140 720 : if (StandbyTransactionIdIsPrepared(entry->xid))
1141 0 : continue;
1142 :
1143 : /* Skip if >= oldxid. */
1144 720 : if (!TransactionIdPrecedes(entry->xid, oldxid))
1145 720 : continue;
1146 :
1147 : /* Remove all locks and hash table entry. */
1148 0 : StandbyReleaseXidEntryLocks(entry);
1149 0 : hash_search(RecoveryLockXidHash, entry, HASH_REMOVE, NULL);
1150 : }
1151 1662 : }
1152 :
1153 : /*
1154 : * --------------------------------------------------------------------
1155 : * Recovery handling for Rmgr RM_STANDBY_ID
1156 : *
1157 : * These record types will only be created if XLogStandbyInfoActive()
1158 : * --------------------------------------------------------------------
1159 : */
1160 :
1161 : void
1162 55250 : standby_redo(XLogReaderState *record)
1163 : {
1164 55250 : uint8 info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
1165 :
1166 : /* Backup blocks are not used in standby records */
1167 : Assert(!XLogRecHasAnyBlockRefs(record));
1168 :
1169 : /* Do nothing if we're not in hot standby mode */
1170 55250 : if (standbyState == STANDBY_DISABLED)
1171 300 : return;
1172 :
1173 54950 : if (info == XLOG_STANDBY_LOCK)
1174 : {
1175 52132 : xl_standby_locks *xlrec = (xl_standby_locks *) XLogRecGetData(record);
1176 : int i;
1177 :
1178 107204 : for (i = 0; i < xlrec->nlocks; i++)
1179 55072 : StandbyAcquireAccessExclusiveLock(xlrec->locks[i].xid,
1180 : xlrec->locks[i].dbOid,
1181 : xlrec->locks[i].relOid);
1182 : }
1183 2818 : else if (info == XLOG_RUNNING_XACTS)
1184 : {
1185 1538 : xl_running_xacts *xlrec = (xl_running_xacts *) XLogRecGetData(record);
1186 : RunningTransactionsData running;
1187 :
1188 1538 : running.xcnt = xlrec->xcnt;
1189 1538 : running.subxcnt = xlrec->subxcnt;
1190 1538 : running.subxid_status = xlrec->subxid_overflow ? SUBXIDS_MISSING : SUBXIDS_IN_ARRAY;
1191 1538 : running.nextXid = xlrec->nextXid;
1192 1538 : running.latestCompletedXid = xlrec->latestCompletedXid;
1193 1538 : running.oldestRunningXid = xlrec->oldestRunningXid;
1194 1538 : running.xids = xlrec->xids;
1195 :
1196 1538 : ProcArrayApplyRecoveryInfo(&running);
1197 :
1198 : /*
1199 : * The startup process currently has no convenient way to schedule
1200 : * stats to be reported. XLOG_RUNNING_XACTS records issued at a
1201 : * regular cadence, making this a convenient location to report stats.
1202 : * While these records aren't generated with wal_level=minimal, stats
1203 : * also cannot be accessed during WAL replay.
1204 : */
1205 1538 : pgstat_report_stat(true);
1206 : }
1207 1280 : else if (info == XLOG_INVALIDATIONS)
1208 : {
1209 1280 : xl_invalidations *xlrec = (xl_invalidations *) XLogRecGetData(record);
1210 :
1211 1280 : ProcessCommittedInvalidationMessages(xlrec->msgs,
1212 : xlrec->nmsgs,
1213 1280 : xlrec->relcacheInitFileInval,
1214 : xlrec->dbId,
1215 : xlrec->tsId);
1216 : }
1217 : else
1218 0 : elog(PANIC, "standby_redo: unknown op code %u", info);
1219 : }
1220 :
1221 : /*
1222 : * Log details of the current snapshot to WAL. This allows the snapshot state
1223 : * to be reconstructed on the standby and for logical decoding.
1224 : *
1225 : * This is used for Hot Standby as follows:
1226 : *
1227 : * We can move directly to STANDBY_SNAPSHOT_READY at startup if we
1228 : * start from a shutdown checkpoint because we know nothing was running
1229 : * at that time and our recovery snapshot is known empty. In the more
1230 : * typical case of an online checkpoint we need to jump through a few
1231 : * hoops to get a correct recovery snapshot and this requires a two or
1232 : * sometimes a three stage process.
1233 : *
1234 : * The initial snapshot must contain all running xids and all current
1235 : * AccessExclusiveLocks at a point in time on the standby. Assembling
1236 : * that information while the server is running requires many and
1237 : * various LWLocks, so we choose to derive that information piece by
1238 : * piece and then re-assemble that info on the standby. When that
1239 : * information is fully assembled we move to STANDBY_SNAPSHOT_READY.
1240 : *
1241 : * Since locking on the primary when we derive the information is not
1242 : * strict, we note that there is a time window between the derivation and
1243 : * writing to WAL of the derived information. That allows race conditions
1244 : * that we must resolve, since xids and locks may enter or leave the
1245 : * snapshot during that window. This creates the issue that an xid or
1246 : * lock may start *after* the snapshot has been derived yet *before* the
1247 : * snapshot is logged in the running xacts WAL record. We resolve this by
1248 : * starting to accumulate changes at a point just prior to when we derive
1249 : * the snapshot on the primary, then ignore duplicates when we later apply
1250 : * the snapshot from the running xacts record. This is implemented during
1251 : * CreateCheckPoint() where we use the logical checkpoint location as
1252 : * our starting point and then write the running xacts record immediately
1253 : * before writing the main checkpoint WAL record. Since we always start
1254 : * up from a checkpoint and are immediately at our starting point, we
1255 : * unconditionally move to STANDBY_INITIALIZED. After this point we
1256 : * must do 4 things:
1257 : * * move shared nextXid forwards as we see new xids
1258 : * * extend the clog and subtrans with each new xid
1259 : * * keep track of uncommitted known assigned xids
1260 : * * keep track of uncommitted AccessExclusiveLocks
1261 : *
1262 : * When we see a commit/abort we must remove known assigned xids and locks
1263 : * from the completing transaction. Attempted removals that cannot locate
1264 : * an entry are expected and must not cause an error when we are in state
1265 : * STANDBY_INITIALIZED. This is implemented in StandbyReleaseLocks() and
1266 : * KnownAssignedXidsRemove().
1267 : *
1268 : * Later, when we apply the running xact data we must be careful to ignore
1269 : * transactions already committed, since those commits raced ahead when
1270 : * making WAL entries.
1271 : *
1272 : * For logical decoding only the running xacts information is needed;
1273 : * there's no need to look at the locking information, but it's logged anyway,
1274 : * as there's no independent knob to just enable logical decoding. For
1275 : * details of how this is used, check snapbuild.c's introductory comment.
1276 : *
1277 : *
1278 : * Returns the RecPtr of the last inserted record.
1279 : */
1280 : XLogRecPtr
1281 2914 : LogStandbySnapshot(void)
1282 : {
1283 : XLogRecPtr recptr;
1284 : RunningTransactions running;
1285 : xl_standby_lock *locks;
1286 : int nlocks;
1287 2914 : bool logical_decoding_enabled = IsLogicalDecodingEnabled();
1288 :
1289 : Assert(XLogStandbyInfoActive());
1290 :
1291 : #ifdef USE_INJECTION_POINTS
1292 2914 : if (IS_INJECTION_POINT_ATTACHED("skip-log-running-xacts"))
1293 : {
1294 : /*
1295 : * This record could move slot's xmin forward during decoding, leading
1296 : * to unpredictable results, so skip it when requested by the test.
1297 : */
1298 0 : return GetInsertRecPtr();
1299 : }
1300 : #endif
1301 :
1302 : /*
1303 : * Get details of any AccessExclusiveLocks being held at the moment.
1304 : */
1305 2914 : locks = GetRunningTransactionLocks(&nlocks);
1306 2914 : if (nlocks > 0)
1307 358 : LogAccessExclusiveLocks(nlocks, locks);
1308 2914 : pfree(locks);
1309 :
1310 : /*
1311 : * Log details of all in-progress transactions. This should be the last
1312 : * record we write, because standby will open up when it sees this.
1313 : */
1314 2914 : running = GetRunningTransactionData();
1315 :
1316 : /*
1317 : * GetRunningTransactionData() acquired ProcArrayLock, we must release it.
1318 : * For Hot Standby this can be done before inserting the WAL record
1319 : * because ProcArrayApplyRecoveryInfo() rechecks the commit status using
1320 : * the clog. For logical decoding, though, the lock can't be released
1321 : * early because the clog might be "in the future" from the POV of the
1322 : * historic snapshot. This would allow for situations where we're waiting
1323 : * for the end of a transaction listed in the xl_running_xacts record
1324 : * which, according to the WAL, has committed before the xl_running_xacts
1325 : * record. Fortunately this routine isn't executed frequently, and it's
1326 : * only a shared lock.
1327 : */
1328 2914 : if (!logical_decoding_enabled)
1329 1840 : LWLockRelease(ProcArrayLock);
1330 :
1331 2914 : recptr = LogCurrentRunningXacts(running);
1332 :
1333 : /* Release lock if we kept it longer ... */
1334 2914 : if (logical_decoding_enabled)
1335 1074 : LWLockRelease(ProcArrayLock);
1336 :
1337 : /* GetRunningTransactionData() acquired XidGenLock, we must release it */
1338 2914 : LWLockRelease(XidGenLock);
1339 :
1340 2914 : return recptr;
1341 : }
1342 :
1343 : /*
1344 : * Record an enhanced snapshot of running transactions into WAL.
1345 : *
1346 : * The definitions of RunningTransactionsData and xl_running_xacts are
1347 : * similar. We keep them separate because xl_running_xacts is a contiguous
1348 : * chunk of memory and never exists fully until it is assembled in WAL.
1349 : * The inserted records are marked as not being important for durability,
1350 : * to avoid triggering superfluous checkpoint / archiving activity.
1351 : */
1352 : static XLogRecPtr
1353 2914 : LogCurrentRunningXacts(RunningTransactions CurrRunningXacts)
1354 : {
1355 : xl_running_xacts xlrec;
1356 : XLogRecPtr recptr;
1357 :
1358 2914 : xlrec.xcnt = CurrRunningXacts->xcnt;
1359 2914 : xlrec.subxcnt = CurrRunningXacts->subxcnt;
1360 2914 : xlrec.subxid_overflow = (CurrRunningXacts->subxid_status != SUBXIDS_IN_ARRAY);
1361 2914 : xlrec.nextXid = CurrRunningXacts->nextXid;
1362 2914 : xlrec.oldestRunningXid = CurrRunningXacts->oldestRunningXid;
1363 2914 : xlrec.latestCompletedXid = CurrRunningXacts->latestCompletedXid;
1364 :
1365 : /* Header */
1366 2914 : XLogBeginInsert();
1367 2914 : XLogSetRecordFlags(XLOG_MARK_UNIMPORTANT);
1368 2914 : XLogRegisterData(&xlrec, MinSizeOfXactRunningXacts);
1369 :
1370 : /* array of TransactionIds */
1371 2914 : if (xlrec.xcnt > 0)
1372 980 : XLogRegisterData(CurrRunningXacts->xids,
1373 980 : (xlrec.xcnt + xlrec.subxcnt) * sizeof(TransactionId));
1374 :
1375 2914 : recptr = XLogInsert(RM_STANDBY_ID, XLOG_RUNNING_XACTS);
1376 :
1377 2914 : if (xlrec.subxid_overflow)
1378 4 : elog(DEBUG2,
1379 : "snapshot of %d running transactions overflowed (lsn %X/%08X oldest xid %u latest complete %u next xid %u)",
1380 : CurrRunningXacts->xcnt,
1381 : LSN_FORMAT_ARGS(recptr),
1382 : CurrRunningXacts->oldestRunningXid,
1383 : CurrRunningXacts->latestCompletedXid,
1384 : CurrRunningXacts->nextXid);
1385 : else
1386 2910 : elog(DEBUG2,
1387 : "snapshot of %d+%d running transaction ids (lsn %X/%08X oldest xid %u latest complete %u next xid %u)",
1388 : CurrRunningXacts->xcnt, CurrRunningXacts->subxcnt,
1389 : LSN_FORMAT_ARGS(recptr),
1390 : CurrRunningXacts->oldestRunningXid,
1391 : CurrRunningXacts->latestCompletedXid,
1392 : CurrRunningXacts->nextXid);
1393 :
1394 : /*
1395 : * Ensure running_xacts information is synced to disk not too far in the
1396 : * future. We don't want to stall anything though (i.e. use XLogFlush()),
1397 : * so we let the wal writer do it during normal operation.
1398 : * XLogSetAsyncXactLSN() conveniently will mark the LSN as to-be-synced
1399 : * and nudge the WALWriter into action if sleeping. Check
1400 : * XLogBackgroundFlush() for details why a record might not be flushed
1401 : * without it.
1402 : */
1403 2914 : XLogSetAsyncXactLSN(recptr);
1404 :
1405 2914 : return recptr;
1406 : }
1407 :
1408 : /*
1409 : * Wholesale logging of AccessExclusiveLocks. Other lock types need not be
1410 : * logged, as described in backend/storage/lmgr/README.
1411 : */
1412 : static void
1413 265422 : LogAccessExclusiveLocks(int nlocks, xl_standby_lock *locks)
1414 : {
1415 : xl_standby_locks xlrec;
1416 :
1417 265422 : xlrec.nlocks = nlocks;
1418 :
1419 265422 : XLogBeginInsert();
1420 265422 : XLogRegisterData(&xlrec, offsetof(xl_standby_locks, locks));
1421 265422 : XLogRegisterData(locks, nlocks * sizeof(xl_standby_lock));
1422 265422 : XLogSetRecordFlags(XLOG_MARK_UNIMPORTANT);
1423 :
1424 265422 : (void) XLogInsert(RM_STANDBY_ID, XLOG_STANDBY_LOCK);
1425 265422 : }
1426 :
1427 : /*
1428 : * Individual logging of AccessExclusiveLocks for use during LockAcquire()
1429 : */
1430 : void
1431 265064 : LogAccessExclusiveLock(Oid dbOid, Oid relOid)
1432 : {
1433 : xl_standby_lock xlrec;
1434 :
1435 265064 : xlrec.xid = GetCurrentTransactionId();
1436 :
1437 265064 : xlrec.dbOid = dbOid;
1438 265064 : xlrec.relOid = relOid;
1439 :
1440 265064 : LogAccessExclusiveLocks(1, &xlrec);
1441 265064 : MyXactFlags |= XACT_FLAGS_ACQUIREDACCESSEXCLUSIVELOCK;
1442 265064 : }
1443 :
1444 : /*
1445 : * Prepare to log an AccessExclusiveLock, for use during LockAcquire()
1446 : */
1447 : void
1448 265490 : LogAccessExclusiveLockPrepare(void)
1449 : {
1450 : /*
1451 : * Ensure that a TransactionId has been assigned to this transaction, for
1452 : * two reasons, both related to lock release on the standby. First, we
1453 : * must assign an xid so that RecordTransactionCommit() and
1454 : * RecordTransactionAbort() do not optimise away the transaction
1455 : * completion record which recovery relies upon to release locks. It's a
1456 : * hack, but for a corner case not worth adding code for into the main
1457 : * commit path. Second, we must assign an xid before the lock is recorded
1458 : * in shared memory, otherwise a concurrently executing
1459 : * GetRunningTransactionLocks() might see a lock associated with an
1460 : * InvalidTransactionId which we later assert cannot happen.
1461 : */
1462 265490 : (void) GetCurrentTransactionId();
1463 265490 : }
1464 :
1465 : /*
1466 : * Emit WAL for invalidations. This currently is only used for commits without
1467 : * an xid but which contain invalidations.
1468 : */
1469 : void
1470 19306 : LogStandbyInvalidations(int nmsgs, SharedInvalidationMessage *msgs,
1471 : bool relcacheInitFileInval)
1472 : {
1473 : xl_invalidations xlrec;
1474 :
1475 : /* prepare record */
1476 19306 : memset(&xlrec, 0, sizeof(xlrec));
1477 19306 : xlrec.dbId = MyDatabaseId;
1478 19306 : xlrec.tsId = MyDatabaseTableSpace;
1479 19306 : xlrec.relcacheInitFileInval = relcacheInitFileInval;
1480 19306 : xlrec.nmsgs = nmsgs;
1481 :
1482 : /* perform insertion */
1483 19306 : XLogBeginInsert();
1484 19306 : XLogRegisterData(&xlrec, MinSizeOfInvalidations);
1485 19306 : XLogRegisterData(msgs,
1486 : nmsgs * sizeof(SharedInvalidationMessage));
1487 19306 : XLogInsert(RM_STANDBY_ID, XLOG_INVALIDATIONS);
1488 19306 : }
1489 :
1490 : /* Return the description of recovery conflict */
1491 : static const char *
1492 20 : get_recovery_conflict_desc(ProcSignalReason reason)
1493 : {
1494 20 : const char *reasonDesc = _("unknown reason");
1495 :
1496 20 : switch (reason)
1497 : {
1498 8 : case PROCSIG_RECOVERY_CONFLICT_BUFFERPIN:
1499 8 : reasonDesc = _("recovery conflict on buffer pin");
1500 8 : break;
1501 4 : case PROCSIG_RECOVERY_CONFLICT_LOCK:
1502 4 : reasonDesc = _("recovery conflict on lock");
1503 4 : break;
1504 4 : case PROCSIG_RECOVERY_CONFLICT_TABLESPACE:
1505 4 : reasonDesc = _("recovery conflict on tablespace");
1506 4 : break;
1507 4 : case PROCSIG_RECOVERY_CONFLICT_SNAPSHOT:
1508 4 : reasonDesc = _("recovery conflict on snapshot");
1509 4 : break;
1510 0 : case PROCSIG_RECOVERY_CONFLICT_LOGICALSLOT:
1511 0 : reasonDesc = _("recovery conflict on replication slot");
1512 0 : break;
1513 0 : case PROCSIG_RECOVERY_CONFLICT_STARTUP_DEADLOCK:
1514 0 : reasonDesc = _("recovery conflict on buffer deadlock");
1515 0 : break;
1516 0 : case PROCSIG_RECOVERY_CONFLICT_DATABASE:
1517 0 : reasonDesc = _("recovery conflict on database");
1518 0 : break;
1519 0 : default:
1520 0 : break;
1521 : }
1522 :
1523 20 : return reasonDesc;
1524 : }
|
