PostgreSQL Source Code  git master
procarray.c
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * procarray.c
4  * POSTGRES process array code.
5  *
6  *
7  * This module maintains arrays of the PGPROC and PGXACT structures for all
8  * active backends. Although there are several uses for this, the principal
9  * one is as a means of determining the set of currently running transactions.
10  *
11  * Because of various subtle race conditions it is critical that a backend
12  * hold the correct locks while setting or clearing its MyPgXact->xid field.
13  * See notes in src/backend/access/transam/README.
14  *
15  * The process arrays now also include structures representing prepared
16  * transactions. The xid and subxids fields of these are valid, as are the
17  * myProcLocks lists. They can be distinguished from regular backend PGPROCs
18  * at need by checking for pid == 0.
19  *
20  * During hot standby, we also keep a list of XIDs representing transactions
21  * that are known to be running in the master (or more precisely, were running
22  * as of the current point in the WAL stream). This list is kept in the
23  * KnownAssignedXids array, and is updated by watching the sequence of
24  * arriving XIDs. This is necessary because if we leave those XIDs out of
25  * snapshots taken for standby queries, then they will appear to be already
26  * complete, leading to MVCC failures. Note that in hot standby, the PGPROC
27  * array represents standby processes, which by definition are not running
28  * transactions that have XIDs.
29  *
30  * It is perhaps possible for a backend on the master to terminate without
31  * writing an abort record for its transaction. While that shouldn't really
32  * happen, it would tie up KnownAssignedXids indefinitely, so we protect
33  * ourselves by pruning the array when a valid list of running XIDs arrives.
34  *
35  * Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
36  * Portions Copyright (c) 1994, Regents of the University of California
37  *
38  *
39  * IDENTIFICATION
40  * src/backend/storage/ipc/procarray.c
41  *
42  *-------------------------------------------------------------------------
43  */
44 #include "postgres.h"
45 
46 #include <signal.h>
47 
48 #include "access/clog.h"
49 #include "access/subtrans.h"
50 #include "access/transam.h"
51 #include "access/twophase.h"
52 #include "access/xact.h"
53 #include "access/xlog.h"
54 #include "catalog/catalog.h"
55 #include "catalog/pg_authid.h"
56 #include "commands/dbcommands.h"
57 #include "miscadmin.h"
58 #include "pgstat.h"
59 #include "storage/proc.h"
60 #include "storage/procarray.h"
61 #include "storage/spin.h"
62 #include "utils/builtins.h"
63 #include "utils/rel.h"
64 #include "utils/snapmgr.h"
65 
66 #define UINT32_ACCESS_ONCE(var) ((uint32)(*((volatile uint32 *)&(var))))
67 
68 /* Our shared memory area */
69 typedef struct ProcArrayStruct
70 {
71  int numProcs; /* number of valid procs entries */
72  int maxProcs; /* allocated size of procs array */
73 
74  /*
75  * Known assigned XIDs handling
76  */
77  int maxKnownAssignedXids; /* allocated size of array */
78  int numKnownAssignedXids; /* current # of valid entries */
79  int tailKnownAssignedXids; /* index of oldest valid element */
80  int headKnownAssignedXids; /* index of newest element, + 1 */
81  slock_t known_assigned_xids_lck; /* protects head/tail pointers */
82 
83  /*
84  * Highest subxid that has been removed from KnownAssignedXids array to
85  * prevent overflow; or InvalidTransactionId if none. We track this for
86  * similar reasons to tracking overflowing cached subxids in PGXACT
87  * entries. Must hold exclusive ProcArrayLock to change this, and shared
88  * lock to read it.
89  */
91 
92  /* oldest xmin of any replication slot */
94  /* oldest catalog xmin of any replication slot */
96 
97  /* indexes into allPgXact[], has PROCARRAY_MAXPROCS entries */
98  int pgprocnos[FLEXIBLE_ARRAY_MEMBER];
100 
102 
103 static PGPROC *allProcs;
105 
106 /*
107  * Bookkeeping for tracking emulated transactions in recovery
108  */
112 
113 /*
114  * If we're in STANDBY_SNAPSHOT_PENDING state, standbySnapshotPendingXmin is
115  * the highest xid that might still be running that we don't have in
116  * KnownAssignedXids.
117  */
119 
120 #ifdef XIDCACHE_DEBUG
121 
122 /* counters for XidCache measurement */
123 static long xc_by_recent_xmin = 0;
124 static long xc_by_known_xact = 0;
125 static long xc_by_my_xact = 0;
126 static long xc_by_latest_xid = 0;
127 static long xc_by_main_xid = 0;
128 static long xc_by_child_xid = 0;
129 static long xc_by_known_assigned = 0;
130 static long xc_no_overflow = 0;
131 static long xc_slow_answer = 0;
132 
133 #define xc_by_recent_xmin_inc() (xc_by_recent_xmin++)
134 #define xc_by_known_xact_inc() (xc_by_known_xact++)
135 #define xc_by_my_xact_inc() (xc_by_my_xact++)
136 #define xc_by_latest_xid_inc() (xc_by_latest_xid++)
137 #define xc_by_main_xid_inc() (xc_by_main_xid++)
138 #define xc_by_child_xid_inc() (xc_by_child_xid++)
139 #define xc_by_known_assigned_inc() (xc_by_known_assigned++)
140 #define xc_no_overflow_inc() (xc_no_overflow++)
141 #define xc_slow_answer_inc() (xc_slow_answer++)
142 
143 static void DisplayXidCache(void);
144 #else /* !XIDCACHE_DEBUG */
145 
146 #define xc_by_recent_xmin_inc() ((void) 0)
147 #define xc_by_known_xact_inc() ((void) 0)
148 #define xc_by_my_xact_inc() ((void) 0)
149 #define xc_by_latest_xid_inc() ((void) 0)
150 #define xc_by_main_xid_inc() ((void) 0)
151 #define xc_by_child_xid_inc() ((void) 0)
152 #define xc_by_known_assigned_inc() ((void) 0)
153 #define xc_no_overflow_inc() ((void) 0)
154 #define xc_slow_answer_inc() ((void) 0)
155 #endif /* XIDCACHE_DEBUG */
156 
157 /* Primitives for KnownAssignedXids array handling for standby */
158 static void KnownAssignedXidsCompress(bool force);
159 static void KnownAssignedXidsAdd(TransactionId from_xid, TransactionId to_xid,
160  bool exclusive_lock);
161 static bool KnownAssignedXidsSearch(TransactionId xid, bool remove);
162 static bool KnownAssignedXidExists(TransactionId xid);
163 static void KnownAssignedXidsRemove(TransactionId xid);
164 static void KnownAssignedXidsRemoveTree(TransactionId xid, int nsubxids,
165  TransactionId *subxids);
167 static int KnownAssignedXidsGet(TransactionId *xarray, TransactionId xmax);
169  TransactionId *xmin,
170  TransactionId xmax);
172 static void KnownAssignedXidsDisplay(int trace_level);
173 static void KnownAssignedXidsReset(void);
174 static inline void ProcArrayEndTransactionInternal(PGPROC *proc,
175  PGXACT *pgxact, TransactionId latestXid);
176 static void ProcArrayGroupClearXid(PGPROC *proc, TransactionId latestXid);
177 
178 /*
179  * Report shared-memory space needed by CreateSharedProcArray.
180  */
181 Size
183 {
184  Size size;
185 
186  /* Size of the ProcArray structure itself */
187 #define PROCARRAY_MAXPROCS (MaxBackends + max_prepared_xacts)
188 
190  size = add_size(size, mul_size(sizeof(int), PROCARRAY_MAXPROCS));
191 
192  /*
193  * During Hot Standby processing we have a data structure called
194  * KnownAssignedXids, created in shared memory. Local data structures are
195  * also created in various backends during GetSnapshotData(),
196  * TransactionIdIsInProgress() and GetRunningTransactionData(). All of the
197  * main structures created in those functions must be identically sized,
198  * since we may at times copy the whole of the data structures around. We
199  * refer to this size as TOTAL_MAX_CACHED_SUBXIDS.
200  *
201  * Ideally we'd only create this structure if we were actually doing hot
202  * standby in the current run, but we don't know that yet at the time
203  * shared memory is being set up.
204  */
205 #define TOTAL_MAX_CACHED_SUBXIDS \
206  ((PGPROC_MAX_CACHED_SUBXIDS + 1) * PROCARRAY_MAXPROCS)
207 
208  if (EnableHotStandby)
209  {
210  size = add_size(size,
211  mul_size(sizeof(TransactionId),
213  size = add_size(size,
214  mul_size(sizeof(bool), TOTAL_MAX_CACHED_SUBXIDS));
215  }
216 
217  return size;
218 }
219 
220 /*
221  * Initialize the shared PGPROC array during postmaster startup.
222  */
223 void
225 {
226  bool found;
227 
228  /* Create or attach to the ProcArray shared structure */
229  procArray = (ProcArrayStruct *)
230  ShmemInitStruct("Proc Array",
232  mul_size(sizeof(int),
234  &found);
235 
236  if (!found)
237  {
238  /*
239  * We're the first - initialize.
240  */
241  procArray->numProcs = 0;
242  procArray->maxProcs = PROCARRAY_MAXPROCS;
244  procArray->numKnownAssignedXids = 0;
245  procArray->tailKnownAssignedXids = 0;
246  procArray->headKnownAssignedXids = 0;
251  }
252 
253  allProcs = ProcGlobal->allProcs;
254  allPgXact = ProcGlobal->allPgXact;
255 
256  /* Create or attach to the KnownAssignedXids arrays too, if needed */
257  if (EnableHotStandby)
258  {
260  ShmemInitStruct("KnownAssignedXids",
261  mul_size(sizeof(TransactionId),
263  &found);
264  KnownAssignedXidsValid = (bool *)
265  ShmemInitStruct("KnownAssignedXidsValid",
266  mul_size(sizeof(bool), TOTAL_MAX_CACHED_SUBXIDS),
267  &found);
268  }
269 
271 }
272 
273 /*
274  * Add the specified PGPROC to the shared array.
275  */
276 void
278 {
279  ProcArrayStruct *arrayP = procArray;
280  int index;
281 
282  LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
283 
284  if (arrayP->numProcs >= arrayP->maxProcs)
285  {
286  /*
287  * Oops, no room. (This really shouldn't happen, since there is a
288  * fixed supply of PGPROC structs too, and so we should have failed
289  * earlier.)
290  */
291  LWLockRelease(ProcArrayLock);
292  ereport(FATAL,
293  (errcode(ERRCODE_TOO_MANY_CONNECTIONS),
294  errmsg("sorry, too many clients already")));
295  }
296 
297  /*
298  * Keep the procs array sorted by (PGPROC *) so that we can utilize
299  * locality of references much better. This is useful while traversing the
300  * ProcArray because there is an increased likelihood of finding the next
301  * PGPROC structure in the cache.
302  *
303  * Since the occurrence of adding/removing a proc is much lower than the
304  * access to the ProcArray itself, the overhead should be marginal
305  */
306  for (index = 0; index < arrayP->numProcs; index++)
307  {
308  /*
309  * If we are the first PGPROC or if we have found our right position
310  * in the array, break
311  */
312  if ((arrayP->pgprocnos[index] == -1) || (arrayP->pgprocnos[index] > proc->pgprocno))
313  break;
314  }
315 
316  memmove(&arrayP->pgprocnos[index + 1], &arrayP->pgprocnos[index],
317  (arrayP->numProcs - index) * sizeof(int));
318  arrayP->pgprocnos[index] = proc->pgprocno;
319  arrayP->numProcs++;
320 
321  LWLockRelease(ProcArrayLock);
322 }
323 
324 /*
325  * Remove the specified PGPROC from the shared array.
326  *
327  * When latestXid is a valid XID, we are removing a live 2PC gxact from the
328  * array, and thus causing it to appear as "not running" anymore. In this
329  * case we must advance latestCompletedXid. (This is essentially the same
330  * as ProcArrayEndTransaction followed by removal of the PGPROC, but we take
331  * the ProcArrayLock only once, and don't damage the content of the PGPROC;
332  * twophase.c depends on the latter.)
333  */
334 void
336 {
337  ProcArrayStruct *arrayP = procArray;
338  int index;
339 
340 #ifdef XIDCACHE_DEBUG
341  /* dump stats at backend shutdown, but not prepared-xact end */
342  if (proc->pid != 0)
343  DisplayXidCache();
344 #endif
345 
346  LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
347 
348  if (TransactionIdIsValid(latestXid))
349  {
350  Assert(TransactionIdIsValid(allPgXact[proc->pgprocno].xid));
351 
352  /* Advance global latestCompletedXid while holding the lock */
354  latestXid))
356  }
357  else
358  {
359  /* Shouldn't be trying to remove a live transaction here */
360  Assert(!TransactionIdIsValid(allPgXact[proc->pgprocno].xid));
361  }
362 
363  for (index = 0; index < arrayP->numProcs; index++)
364  {
365  if (arrayP->pgprocnos[index] == proc->pgprocno)
366  {
367  /* Keep the PGPROC array sorted. See notes above */
368  memmove(&arrayP->pgprocnos[index], &arrayP->pgprocnos[index + 1],
369  (arrayP->numProcs - index - 1) * sizeof(int));
370  arrayP->pgprocnos[arrayP->numProcs - 1] = -1; /* for debugging */
371  arrayP->numProcs--;
372  LWLockRelease(ProcArrayLock);
373  return;
374  }
375  }
376 
377  /* Oops */
378  LWLockRelease(ProcArrayLock);
379 
380  elog(LOG, "failed to find proc %p in ProcArray", proc);
381 }
382 
383 
384 /*
385  * ProcArrayEndTransaction -- mark a transaction as no longer running
386  *
387  * This is used interchangeably for commit and abort cases. The transaction
388  * commit/abort must already be reported to WAL and pg_xact.
389  *
390  * proc is currently always MyProc, but we pass it explicitly for flexibility.
391  * latestXid is the latest Xid among the transaction's main XID and
392  * subtransactions, or InvalidTransactionId if it has no XID. (We must ask
393  * the caller to pass latestXid, instead of computing it from the PGPROC's
394  * contents, because the subxid information in the PGPROC might be
395  * incomplete.)
396  */
397 void
399 {
400  PGXACT *pgxact = &allPgXact[proc->pgprocno];
401 
402  if (TransactionIdIsValid(latestXid))
403  {
404  /*
405  * We must lock ProcArrayLock while clearing our advertised XID, so
406  * that we do not exit the set of "running" transactions while someone
407  * else is taking a snapshot. See discussion in
408  * src/backend/access/transam/README.
409  */
410  Assert(TransactionIdIsValid(allPgXact[proc->pgprocno].xid));
411 
412  /*
413  * If we can immediately acquire ProcArrayLock, we clear our own XID
414  * and release the lock. If not, use group XID clearing to improve
415  * efficiency.
416  */
417  if (LWLockConditionalAcquire(ProcArrayLock, LW_EXCLUSIVE))
418  {
419  ProcArrayEndTransactionInternal(proc, pgxact, latestXid);
420  LWLockRelease(ProcArrayLock);
421  }
422  else
423  ProcArrayGroupClearXid(proc, latestXid);
424  }
425  else
426  {
427  /*
428  * If we have no XID, we don't need to lock, since we won't affect
429  * anyone else's calculation of a snapshot. We might change their
430  * estimate of global xmin, but that's OK.
431  */
432  Assert(!TransactionIdIsValid(allPgXact[proc->pgprocno].xid));
433 
435  pgxact->xmin = InvalidTransactionId;
436  /* must be cleared with xid/xmin: */
438  pgxact->delayChkpt = false; /* be sure this is cleared in abort */
439  proc->recoveryConflictPending = false;
440 
441  Assert(pgxact->nxids == 0);
442  Assert(pgxact->overflowed == false);
443  }
444 }
445 
446 /*
447  * Mark a write transaction as no longer running.
448  *
449  * We don't do any locking here; caller must handle that.
450  */
451 static inline void
453  TransactionId latestXid)
454 {
455  pgxact->xid = InvalidTransactionId;
457  pgxact->xmin = InvalidTransactionId;
458  /* must be cleared with xid/xmin: */
460  pgxact->delayChkpt = false; /* be sure this is cleared in abort */
461  proc->recoveryConflictPending = false;
462 
463  /* Clear the subtransaction-XID cache too while holding the lock */
464  pgxact->nxids = 0;
465  pgxact->overflowed = false;
466 
467  /* Also advance global latestCompletedXid while holding the lock */
469  latestXid))
471 }
472 
473 /*
474  * ProcArrayGroupClearXid -- group XID clearing
475  *
476  * When we cannot immediately acquire ProcArrayLock in exclusive mode at
477  * commit time, add ourselves to a list of processes that need their XIDs
478  * cleared. The first process to add itself to the list will acquire
479  * ProcArrayLock in exclusive mode and perform ProcArrayEndTransactionInternal
480  * on behalf of all group members. This avoids a great deal of contention
481  * around ProcArrayLock when many processes are trying to commit at once,
482  * since the lock need not be repeatedly handed off from one committing
483  * process to the next.
484  */
485 static void
487 {
488  PROC_HDR *procglobal = ProcGlobal;
489  uint32 nextidx;
490  uint32 wakeidx;
491 
492  /* We should definitely have an XID to clear. */
493  Assert(TransactionIdIsValid(allPgXact[proc->pgprocno].xid));
494 
495  /* Add ourselves to the list of processes needing a group XID clear. */
496  proc->procArrayGroupMember = true;
497  proc->procArrayGroupMemberXid = latestXid;
498  nextidx = pg_atomic_read_u32(&procglobal->procArrayGroupFirst);
499  while (true)
500  {
501  pg_atomic_write_u32(&proc->procArrayGroupNext, nextidx);
502 
504  &nextidx,
505  (uint32) proc->pgprocno))
506  break;
507  }
508 
509  /*
510  * If the list was not empty, the leader will clear our XID. It is
511  * impossible to have followers without a leader because the first process
512  * that has added itself to the list will always have nextidx as
513  * INVALID_PGPROCNO.
514  */
515  if (nextidx != INVALID_PGPROCNO)
516  {
517  int extraWaits = 0;
518 
519  /* Sleep until the leader clears our XID. */
521  for (;;)
522  {
523  /* acts as a read barrier */
524  PGSemaphoreLock(proc->sem);
525  if (!proc->procArrayGroupMember)
526  break;
527  extraWaits++;
528  }
530 
532 
533  /* Fix semaphore count for any absorbed wakeups */
534  while (extraWaits-- > 0)
535  PGSemaphoreUnlock(proc->sem);
536  return;
537  }
538 
539  /* We are the leader. Acquire the lock on behalf of everyone. */
540  LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
541 
542  /*
543  * Now that we've got the lock, clear the list of processes waiting for
544  * group XID clearing, saving a pointer to the head of the list. Trying
545  * to pop elements one at a time could lead to an ABA problem.
546  */
547  nextidx = pg_atomic_exchange_u32(&procglobal->procArrayGroupFirst,
549 
550  /* Remember head of list so we can perform wakeups after dropping lock. */
551  wakeidx = nextidx;
552 
553  /* Walk the list and clear all XIDs. */
554  while (nextidx != INVALID_PGPROCNO)
555  {
556  PGPROC *proc = &allProcs[nextidx];
557  PGXACT *pgxact = &allPgXact[nextidx];
558 
560 
561  /* Move to next proc in list. */
562  nextidx = pg_atomic_read_u32(&proc->procArrayGroupNext);
563  }
564 
565  /* We're done with the lock now. */
566  LWLockRelease(ProcArrayLock);
567 
568  /*
569  * Now that we've released the lock, go back and wake everybody up. We
570  * don't do this under the lock so as to keep lock hold times to a
571  * minimum. The system calls we need to perform to wake other processes
572  * up are probably much slower than the simple memory writes we did while
573  * holding the lock.
574  */
575  while (wakeidx != INVALID_PGPROCNO)
576  {
577  PGPROC *proc = &allProcs[wakeidx];
578 
579  wakeidx = pg_atomic_read_u32(&proc->procArrayGroupNext);
581 
582  /* ensure all previous writes are visible before follower continues. */
584 
585  proc->procArrayGroupMember = false;
586 
587  if (proc != MyProc)
588  PGSemaphoreUnlock(proc->sem);
589  }
590 }
591 
592 /*
593  * ProcArrayClearTransaction -- clear the transaction fields
594  *
595  * This is used after successfully preparing a 2-phase transaction. We are
596  * not actually reporting the transaction's XID as no longer running --- it
597  * will still appear as running because the 2PC's gxact is in the ProcArray
598  * too. We just have to clear out our own PGXACT.
599  */
600 void
602 {
603  PGXACT *pgxact = &allPgXact[proc->pgprocno];
604 
605  /*
606  * We can skip locking ProcArrayLock here, because this action does not
607  * actually change anyone's view of the set of running XIDs: our entry is
608  * duplicate with the gxact that has already been inserted into the
609  * ProcArray.
610  */
611  pgxact->xid = InvalidTransactionId;
613  pgxact->xmin = InvalidTransactionId;
614  proc->recoveryConflictPending = false;
615 
616  /* redundant, but just in case */
618  pgxact->delayChkpt = false;
619 
620  /* Clear the subtransaction-XID cache too */
621  pgxact->nxids = 0;
622  pgxact->overflowed = false;
623 }
624 
625 /*
626  * ProcArrayInitRecovery -- initialize recovery xid mgmt environment
627  *
628  * Remember up to where the startup process initialized the CLOG and subtrans
629  * so we can ensure it's initialized gaplessly up to the point where necessary
630  * while in recovery.
631  */
632 void
634 {
636  Assert(TransactionIdIsNormal(initializedUptoXID));
637 
638  /*
639  * we set latestObservedXid to the xid SUBTRANS has been initialized up
640  * to, so we can extend it from that point onwards in
641  * RecordKnownAssignedTransactionIds, and when we get consistent in
642  * ProcArrayApplyRecoveryInfo().
643  */
644  latestObservedXid = initializedUptoXID;
646 }
647 
648 /*
649  * ProcArrayApplyRecoveryInfo -- apply recovery info about xids
650  *
651  * Takes us through 3 states: Initialized, Pending and Ready.
652  * Normal case is to go all the way to Ready straight away, though there
653  * are atypical cases where we need to take it in steps.
654  *
655  * Use the data about running transactions on master to create the initial
656  * state of KnownAssignedXids. We also use these records to regularly prune
657  * KnownAssignedXids because we know it is possible that some transactions
658  * with FATAL errors fail to write abort records, which could cause eventual
659  * overflow.
660  *
661  * See comments for LogStandbySnapshot().
662  */
663 void
665 {
666  TransactionId *xids;
667  int nxids;
668  int i;
669 
674 
675  /*
676  * Remove stale transactions, if any.
677  */
679 
680  /*
681  * Remove stale locks, if any.
682  */
684 
685  /*
686  * If our snapshot is already valid, nothing else to do...
687  */
689  return;
690 
691  /*
692  * If our initial RunningTransactionsData had an overflowed snapshot then
693  * we knew we were missing some subxids from our snapshot. If we continue
694  * to see overflowed snapshots then we might never be able to start up, so
695  * we make another test to see if our snapshot is now valid. We know that
696  * the missing subxids are equal to or earlier than nextXid. After we
697  * initialise we continue to apply changes during recovery, so once the
698  * oldestRunningXid is later than the nextXid from the initial snapshot we
699  * know that we no longer have missing information and can mark the
700  * snapshot as valid.
701  */
703  {
704  /*
705  * If the snapshot isn't overflowed or if its empty we can reset our
706  * pending state and use this snapshot instead.
707  */
708  if (!running->subxid_overflow || running->xcnt == 0)
709  {
710  /*
711  * If we have already collected known assigned xids, we need to
712  * throw them away before we apply the recovery snapshot.
713  */
716  }
717  else
718  {
720  running->oldestRunningXid))
721  {
724  "recovery snapshots are now enabled");
725  }
726  else
728  "recovery snapshot waiting for non-overflowed snapshot or "
729  "until oldest active xid on standby is at least %u (now %u)",
731  running->oldestRunningXid);
732  return;
733  }
734  }
735 
737 
738  /*
739  * NB: this can be reached at least twice, so make sure new code can deal
740  * with that.
741  */
742 
743  /*
744  * Nobody else is running yet, but take locks anyhow
745  */
746  LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
747 
748  /*
749  * KnownAssignedXids is sorted so we cannot just add the xids, we have to
750  * sort them first.
751  *
752  * Some of the new xids are top-level xids and some are subtransactions.
753  * We don't call SubTransSetParent because it doesn't matter yet. If we
754  * aren't overflowed then all xids will fit in snapshot and so we don't
755  * need subtrans. If we later overflow, an xid assignment record will add
756  * xids to subtrans. If RunningTransactionsData is overflowed then we
757  * don't have enough information to correctly update subtrans anyway.
758  */
759 
760  /*
761  * Allocate a temporary array to avoid modifying the array passed as
762  * argument.
763  */
764  xids = palloc(sizeof(TransactionId) * (running->xcnt + running->subxcnt));
765 
766  /*
767  * Add to the temp array any xids which have not already completed.
768  */
769  nxids = 0;
770  for (i = 0; i < running->xcnt + running->subxcnt; i++)
771  {
772  TransactionId xid = running->xids[i];
773 
774  /*
775  * The running-xacts snapshot can contain xids that were still visible
776  * in the procarray when the snapshot was taken, but were already
777  * WAL-logged as completed. They're not running anymore, so ignore
778  * them.
779  */
781  continue;
782 
783  xids[nxids++] = xid;
784  }
785 
786  if (nxids > 0)
787  {
788  if (procArray->numKnownAssignedXids != 0)
789  {
790  LWLockRelease(ProcArrayLock);
791  elog(ERROR, "KnownAssignedXids is not empty");
792  }
793 
794  /*
795  * Sort the array so that we can add them safely into
796  * KnownAssignedXids.
797  */
798  qsort(xids, nxids, sizeof(TransactionId), xidComparator);
799 
800  /*
801  * Add the sorted snapshot into KnownAssignedXids. The running-xacts
802  * snapshot may include duplicated xids because of prepared
803  * transactions, so ignore them.
804  */
805  for (i = 0; i < nxids; i++)
806  {
807  if (i > 0 && TransactionIdEquals(xids[i - 1], xids[i]))
808  {
809  elog(DEBUG1,
810  "found duplicated transaction %u for KnownAssignedXids insertion",
811  xids[i]);
812  continue;
813  }
814  KnownAssignedXidsAdd(xids[i], xids[i], true);
815  }
816 
818  }
819 
820  pfree(xids);
821 
822  /*
823  * latestObservedXid is at least set to the point where SUBTRANS was
824  * started up to (cf. ProcArrayInitRecovery()) or to the biggest xid
825  * RecordKnownAssignedTransactionIds() was called for. Initialize
826  * subtrans from thereon, up to nextXid - 1.
827  *
828  * We need to duplicate parts of RecordKnownAssignedTransactionId() here,
829  * because we've just added xids to the known assigned xids machinery that
830  * haven't gone through RecordKnownAssignedTransactionId().
831  */
835  {
838  }
839  TransactionIdRetreat(latestObservedXid); /* = running->nextXid - 1 */
840 
841  /* ----------
842  * Now we've got the running xids we need to set the global values that
843  * are used to track snapshots as they evolve further.
844  *
845  * - latestCompletedXid which will be the xmax for snapshots
846  * - lastOverflowedXid which shows whether snapshots overflow
847  * - nextXid
848  *
849  * If the snapshot overflowed, then we still initialise with what we know,
850  * but the recovery snapshot isn't fully valid yet because we know there
851  * are some subxids missing. We don't know the specific subxids that are
852  * missing, so conservatively assume the last one is latestObservedXid.
853  * ----------
854  */
855  if (running->subxid_overflow)
856  {
858 
861  }
862  else
863  {
865 
867  }
868 
869  /*
870  * If a transaction wrote a commit record in the gap between taking and
871  * logging the snapshot then latestCompletedXid may already be higher than
872  * the value from the snapshot, so check before we use the incoming value.
873  */
875  running->latestCompletedXid))
877 
879 
880  LWLockRelease(ProcArrayLock);
881 
882  /* ShmemVariableCache->nextFullXid must be beyond any observed xid. */
884 
886 
889  elog(trace_recovery(DEBUG1), "recovery snapshots are now enabled");
890  else
892  "recovery snapshot waiting for non-overflowed snapshot or "
893  "until oldest active xid on standby is at least %u (now %u)",
895  running->oldestRunningXid);
896 }
897 
898 /*
899  * ProcArrayApplyXidAssignment
900  * Process an XLOG_XACT_ASSIGNMENT WAL record
901  */
902 void
904  int nsubxids, TransactionId *subxids)
905 {
906  TransactionId max_xid;
907  int i;
908 
910 
911  max_xid = TransactionIdLatest(topxid, nsubxids, subxids);
912 
913  /*
914  * Mark all the subtransactions as observed.
915  *
916  * NOTE: This will fail if the subxid contains too many previously
917  * unobserved xids to fit into known-assigned-xids. That shouldn't happen
918  * as the code stands, because xid-assignment records should never contain
919  * more than PGPROC_MAX_CACHED_SUBXIDS entries.
920  */
922 
923  /*
924  * Notice that we update pg_subtrans with the top-level xid, rather than
925  * the parent xid. This is a difference between normal processing and
926  * recovery, yet is still correct in all cases. The reason is that
927  * subtransaction commit is not marked in clog until commit processing, so
928  * all aborted subtransactions have already been clearly marked in clog.
929  * As a result we are able to refer directly to the top-level
930  * transaction's state rather than skipping through all the intermediate
931  * states in the subtransaction tree. This should be the first time we
932  * have attempted to SubTransSetParent().
933  */
934  for (i = 0; i < nsubxids; i++)
935  SubTransSetParent(subxids[i], topxid);
936 
937  /* KnownAssignedXids isn't maintained yet, so we're done for now */
939  return;
940 
941  /*
942  * Uses same locking as transaction commit
943  */
944  LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
945 
946  /*
947  * Remove subxids from known-assigned-xacts.
948  */
950 
951  /*
952  * Advance lastOverflowedXid to be at least the last of these subxids.
953  */
954  if (TransactionIdPrecedes(procArray->lastOverflowedXid, max_xid))
955  procArray->lastOverflowedXid = max_xid;
956 
957  LWLockRelease(ProcArrayLock);
958 }
959 
960 /*
961  * TransactionIdIsInProgress -- is given transaction running in some backend
962  *
963  * Aside from some shortcuts such as checking RecentXmin and our own Xid,
964  * there are four possibilities for finding a running transaction:
965  *
966  * 1. The given Xid is a main transaction Id. We will find this out cheaply
967  * by looking at the PGXACT struct for each backend.
968  *
969  * 2. The given Xid is one of the cached subxact Xids in the PGPROC array.
970  * We can find this out cheaply too.
971  *
972  * 3. In Hot Standby mode, we must search the KnownAssignedXids list to see
973  * if the Xid is running on the master.
974  *
975  * 4. Search the SubTrans tree to find the Xid's topmost parent, and then see
976  * if that is running according to PGXACT or KnownAssignedXids. This is the
977  * slowest way, but sadly it has to be done always if the others failed,
978  * unless we see that the cached subxact sets are complete (none have
979  * overflowed).
980  *
981  * ProcArrayLock has to be held while we do 1, 2, 3. If we save the top Xids
982  * while doing 1 and 3, we can release the ProcArrayLock while we do 4.
983  * This buys back some concurrency (and we can't retrieve the main Xids from
984  * PGXACT again anyway; see GetNewTransactionId).
985  */
986 bool
988 {
989  static TransactionId *xids = NULL;
990  int nxids = 0;
991  ProcArrayStruct *arrayP = procArray;
992  TransactionId topxid;
993  int i,
994  j;
995 
996  /*
997  * Don't bother checking a transaction older than RecentXmin; it could not
998  * possibly still be running. (Note: in particular, this guarantees that
999  * we reject InvalidTransactionId, FrozenTransactionId, etc as not
1000  * running.)
1001  */
1003  {
1005  return false;
1006  }
1007 
1008  /*
1009  * We may have just checked the status of this transaction, so if it is
1010  * already known to be completed, we can fall out without any access to
1011  * shared memory.
1012  */
1014  {
1016  return false;
1017  }
1018 
1019  /*
1020  * Also, we can handle our own transaction (and subtransactions) without
1021  * any access to shared memory.
1022  */
1024  {
1026  return true;
1027  }
1028 
1029  /*
1030  * If first time through, get workspace to remember main XIDs in. We
1031  * malloc it permanently to avoid repeated palloc/pfree overhead.
1032  */
1033  if (xids == NULL)
1034  {
1035  /*
1036  * In hot standby mode, reserve enough space to hold all xids in the
1037  * known-assigned list. If we later finish recovery, we no longer need
1038  * the bigger array, but we don't bother to shrink it.
1039  */
1040  int maxxids = RecoveryInProgress() ? TOTAL_MAX_CACHED_SUBXIDS : arrayP->maxProcs;
1041 
1042  xids = (TransactionId *) malloc(maxxids * sizeof(TransactionId));
1043  if (xids == NULL)
1044  ereport(ERROR,
1045  (errcode(ERRCODE_OUT_OF_MEMORY),
1046  errmsg("out of memory")));
1047  }
1048 
1049  LWLockAcquire(ProcArrayLock, LW_SHARED);
1050 
1051  /*
1052  * Now that we have the lock, we can check latestCompletedXid; if the
1053  * target Xid is after that, it's surely still running.
1054  */
1056  {
1057  LWLockRelease(ProcArrayLock);
1059  return true;
1060  }
1061 
1062  /* No shortcuts, gotta grovel through the array */
1063  for (i = 0; i < arrayP->numProcs; i++)
1064  {
1065  int pgprocno = arrayP->pgprocnos[i];
1066  PGPROC *proc = &allProcs[pgprocno];
1067  PGXACT *pgxact = &allPgXact[pgprocno];
1068  TransactionId pxid;
1069  int pxids;
1070 
1071  /* Ignore my own proc --- dealt with it above */
1072  if (proc == MyProc)
1073  continue;
1074 
1075  /* Fetch xid just once - see GetNewTransactionId */
1076  pxid = UINT32_ACCESS_ONCE(pgxact->xid);
1077 
1078  if (!TransactionIdIsValid(pxid))
1079  continue;
1080 
1081  /*
1082  * Step 1: check the main Xid
1083  */
1084  if (TransactionIdEquals(pxid, xid))
1085  {
1086  LWLockRelease(ProcArrayLock);
1088  return true;
1089  }
1090 
1091  /*
1092  * We can ignore main Xids that are younger than the target Xid, since
1093  * the target could not possibly be their child.
1094  */
1095  if (TransactionIdPrecedes(xid, pxid))
1096  continue;
1097 
1098  /*
1099  * Step 2: check the cached child-Xids arrays
1100  */
1101  pxids = pgxact->nxids;
1102  pg_read_barrier(); /* pairs with barrier in GetNewTransactionId() */
1103  for (j = pxids - 1; j >= 0; j--)
1104  {
1105  /* Fetch xid just once - see GetNewTransactionId */
1106  TransactionId cxid = UINT32_ACCESS_ONCE(proc->subxids.xids[j]);
1107 
1108  if (TransactionIdEquals(cxid, xid))
1109  {
1110  LWLockRelease(ProcArrayLock);
1112  return true;
1113  }
1114  }
1115 
1116  /*
1117  * Save the main Xid for step 4. We only need to remember main Xids
1118  * that have uncached children. (Note: there is no race condition
1119  * here because the overflowed flag cannot be cleared, only set, while
1120  * we hold ProcArrayLock. So we can't miss an Xid that we need to
1121  * worry about.)
1122  */
1123  if (pgxact->overflowed)
1124  xids[nxids++] = pxid;
1125  }
1126 
1127  /*
1128  * Step 3: in hot standby mode, check the known-assigned-xids list. XIDs
1129  * in the list must be treated as running.
1130  */
1131  if (RecoveryInProgress())
1132  {
1133  /* none of the PGXACT entries should have XIDs in hot standby mode */
1134  Assert(nxids == 0);
1135 
1136  if (KnownAssignedXidExists(xid))
1137  {
1138  LWLockRelease(ProcArrayLock);
1140  return true;
1141  }
1142 
1143  /*
1144  * If the KnownAssignedXids overflowed, we have to check pg_subtrans
1145  * too. Fetch all xids from KnownAssignedXids that are lower than
1146  * xid, since if xid is a subtransaction its parent will always have a
1147  * lower value. Note we will collect both main and subXIDs here, but
1148  * there's no help for it.
1149  */
1150  if (TransactionIdPrecedesOrEquals(xid, procArray->lastOverflowedXid))
1151  nxids = KnownAssignedXidsGet(xids, xid);
1152  }
1153 
1154  LWLockRelease(ProcArrayLock);
1155 
1156  /*
1157  * If none of the relevant caches overflowed, we know the Xid is not
1158  * running without even looking at pg_subtrans.
1159  */
1160  if (nxids == 0)
1161  {
1163  return false;
1164  }
1165 
1166  /*
1167  * Step 4: have to check pg_subtrans.
1168  *
1169  * At this point, we know it's either a subtransaction of one of the Xids
1170  * in xids[], or it's not running. If it's an already-failed
1171  * subtransaction, we want to say "not running" even though its parent may
1172  * still be running. So first, check pg_xact to see if it's been aborted.
1173  */
1175 
1176  if (TransactionIdDidAbort(xid))
1177  return false;
1178 
1179  /*
1180  * It isn't aborted, so check whether the transaction tree it belongs to
1181  * is still running (or, more precisely, whether it was running when we
1182  * held ProcArrayLock).
1183  */
1184  topxid = SubTransGetTopmostTransaction(xid);
1185  Assert(TransactionIdIsValid(topxid));
1186  if (!TransactionIdEquals(topxid, xid))
1187  {
1188  for (i = 0; i < nxids; i++)
1189  {
1190  if (TransactionIdEquals(xids[i], topxid))
1191  return true;
1192  }
1193  }
1194 
1195  return false;
1196 }
1197 
1198 /*
1199  * TransactionIdIsActive -- is xid the top-level XID of an active backend?
1200  *
1201  * This differs from TransactionIdIsInProgress in that it ignores prepared
1202  * transactions, as well as transactions running on the master if we're in
1203  * hot standby. Also, we ignore subtransactions since that's not needed
1204  * for current uses.
1205  */
1206 bool
1208 {
1209  bool result = false;
1210  ProcArrayStruct *arrayP = procArray;
1211  int i;
1212 
1213  /*
1214  * Don't bother checking a transaction older than RecentXmin; it could not
1215  * possibly still be running.
1216  */
1218  return false;
1219 
1220  LWLockAcquire(ProcArrayLock, LW_SHARED);
1221 
1222  for (i = 0; i < arrayP->numProcs; i++)
1223  {
1224  int pgprocno = arrayP->pgprocnos[i];
1225  PGPROC *proc = &allProcs[pgprocno];
1226  PGXACT *pgxact = &allPgXact[pgprocno];
1227  TransactionId pxid;
1228 
1229  /* Fetch xid just once - see GetNewTransactionId */
1230  pxid = UINT32_ACCESS_ONCE(pgxact->xid);
1231 
1232  if (!TransactionIdIsValid(pxid))
1233  continue;
1234 
1235  if (proc->pid == 0)
1236  continue; /* ignore prepared transactions */
1237 
1238  if (TransactionIdEquals(pxid, xid))
1239  {
1240  result = true;
1241  break;
1242  }
1243  }
1244 
1245  LWLockRelease(ProcArrayLock);
1246 
1247  return result;
1248 }
1249 
1250 
1251 /*
1252  * GetOldestXmin -- returns oldest transaction that was running
1253  * when any current transaction was started.
1254  *
1255  * If rel is NULL or a shared relation, all backends are considered, otherwise
1256  * only backends running in this database are considered.
1257  *
1258  * The flags are used to ignore the backends in calculation when any of the
1259  * corresponding flags is set. Typically, if you want to ignore ones with
1260  * PROC_IN_VACUUM flag, you can use PROCARRAY_FLAGS_VACUUM.
1261  *
1262  * PROCARRAY_SLOTS_XMIN causes GetOldestXmin to ignore the xmin and
1263  * catalog_xmin of any replication slots that exist in the system when
1264  * calculating the oldest xmin.
1265  *
1266  * This is used by VACUUM to decide which deleted tuples must be preserved in
1267  * the passed in table. For shared relations backends in all databases must be
1268  * considered, but for non-shared relations that's not required, since only
1269  * backends in my own database could ever see the tuples in them. Also, we can
1270  * ignore concurrently running lazy VACUUMs because (a) they must be working
1271  * on other tables, and (b) they don't need to do snapshot-based lookups.
1272  *
1273  * This is also used to determine where to truncate pg_subtrans. For that
1274  * backends in all databases have to be considered, so rel = NULL has to be
1275  * passed in.
1276  *
1277  * Note: we include all currently running xids in the set of considered xids.
1278  * This ensures that if a just-started xact has not yet set its snapshot,
1279  * when it does set the snapshot it cannot set xmin less than what we compute.
1280  * See notes in src/backend/access/transam/README.
1281  *
1282  * Note: despite the above, it's possible for the calculated value to move
1283  * backwards on repeated calls. The calculated value is conservative, so that
1284  * anything older is definitely not considered as running by anyone anymore,
1285  * but the exact value calculated depends on a number of things. For example,
1286  * if rel = NULL and there are no transactions running in the current
1287  * database, GetOldestXmin() returns latestCompletedXid. If a transaction
1288  * begins after that, its xmin will include in-progress transactions in other
1289  * databases that started earlier, so another call will return a lower value.
1290  * Nonetheless it is safe to vacuum a table in the current database with the
1291  * first result. There are also replication-related effects: a walsender
1292  * process can set its xmin based on transactions that are no longer running
1293  * in the master but are still being replayed on the standby, thus possibly
1294  * making the GetOldestXmin reading go backwards. In this case there is a
1295  * possibility that we lose data that the standby would like to have, but
1296  * unless the standby uses a replication slot to make its xmin persistent
1297  * there is little we can do about that --- data is only protected if the
1298  * walsender runs continuously while queries are executed on the standby.
1299  * (The Hot Standby code deals with such cases by failing standby queries
1300  * that needed to access already-removed data, so there's no integrity bug.)
1301  * The return value is also adjusted with vacuum_defer_cleanup_age, so
1302  * increasing that setting on the fly is another easy way to make
1303  * GetOldestXmin() move backwards, with no consequences for data integrity.
1304  */
1306 GetOldestXmin(Relation rel, int flags)
1307 {
1308  ProcArrayStruct *arrayP = procArray;
1309  TransactionId result;
1310  int index;
1311  bool allDbs;
1312 
1315 
1316  /*
1317  * If we're not computing a relation specific limit, or if a shared
1318  * relation has been passed in, backends in all databases have to be
1319  * considered.
1320  */
1321  allDbs = rel == NULL || rel->rd_rel->relisshared;
1322 
1323  /* Cannot look for individual databases during recovery */
1324  Assert(allDbs || !RecoveryInProgress());
1325 
1326  LWLockAcquire(ProcArrayLock, LW_SHARED);
1327 
1328  /*
1329  * We initialize the MIN() calculation with latestCompletedXid + 1. This
1330  * is a lower bound for the XIDs that might appear in the ProcArray later,
1331  * and so protects us against overestimating the result due to future
1332  * additions.
1333  */
1335  Assert(TransactionIdIsNormal(result));
1336  TransactionIdAdvance(result);
1337 
1338  for (index = 0; index < arrayP->numProcs; index++)
1339  {
1340  int pgprocno = arrayP->pgprocnos[index];
1341  PGPROC *proc = &allProcs[pgprocno];
1342  PGXACT *pgxact = &allPgXact[pgprocno];
1343 
1344  if (pgxact->vacuumFlags & (flags & PROCARRAY_PROC_FLAGS_MASK))
1345  continue;
1346 
1347  if (allDbs ||
1348  proc->databaseId == MyDatabaseId ||
1349  proc->databaseId == 0) /* always include WalSender */
1350  {
1351  /* Fetch xid just once - see GetNewTransactionId */
1352  TransactionId xid = UINT32_ACCESS_ONCE(pgxact->xid);
1353 
1354  /* First consider the transaction's own Xid, if any */
1355  if (TransactionIdIsNormal(xid) &&
1356  TransactionIdPrecedes(xid, result))
1357  result = xid;
1358 
1359  /*
1360  * Also consider the transaction's Xmin, if set.
1361  *
1362  * We must check both Xid and Xmin because a transaction might
1363  * have an Xmin but not (yet) an Xid; conversely, if it has an
1364  * Xid, that could determine some not-yet-set Xmin.
1365  */
1366  xid = UINT32_ACCESS_ONCE(pgxact->xmin);
1367  if (TransactionIdIsNormal(xid) &&
1368  TransactionIdPrecedes(xid, result))
1369  result = xid;
1370  }
1371  }
1372 
1373  /*
1374  * Fetch into local variable while ProcArrayLock is held - the
1375  * LWLockRelease below is a barrier, ensuring this happens inside the
1376  * lock.
1377  */
1378  replication_slot_xmin = procArray->replication_slot_xmin;
1379  replication_slot_catalog_xmin = procArray->replication_slot_catalog_xmin;
1380 
1381  if (RecoveryInProgress())
1382  {
1383  /*
1384  * Check to see whether KnownAssignedXids contains an xid value older
1385  * than the main procarray.
1386  */
1388 
1389  LWLockRelease(ProcArrayLock);
1390 
1391  if (TransactionIdIsNormal(kaxmin) &&
1392  TransactionIdPrecedes(kaxmin, result))
1393  result = kaxmin;
1394  }
1395  else
1396  {
1397  /*
1398  * No other information needed, so release the lock immediately.
1399  */
1400  LWLockRelease(ProcArrayLock);
1401 
1402  /*
1403  * Compute the cutoff XID by subtracting vacuum_defer_cleanup_age,
1404  * being careful not to generate a "permanent" XID.
1405  *
1406  * vacuum_defer_cleanup_age provides some additional "slop" for the
1407  * benefit of hot standby queries on standby servers. This is quick
1408  * and dirty, and perhaps not all that useful unless the master has a
1409  * predictable transaction rate, but it offers some protection when
1410  * there's no walsender connection. Note that we are assuming
1411  * vacuum_defer_cleanup_age isn't large enough to cause wraparound ---
1412  * so guc.c should limit it to no more than the xidStopLimit threshold
1413  * in varsup.c. Also note that we intentionally don't apply
1414  * vacuum_defer_cleanup_age on standby servers.
1415  */
1416  result -= vacuum_defer_cleanup_age;
1417  if (!TransactionIdIsNormal(result))
1418  result = FirstNormalTransactionId;
1419  }
1420 
1421  /*
1422  * Check whether there are replication slots requiring an older xmin.
1423  */
1424  if (!(flags & PROCARRAY_SLOTS_XMIN) &&
1425  TransactionIdIsValid(replication_slot_xmin) &&
1426  NormalTransactionIdPrecedes(replication_slot_xmin, result))
1427  result = replication_slot_xmin;
1428 
1429  /*
1430  * After locks have been released and vacuum_defer_cleanup_age has been
1431  * applied, check whether we need to back up further to make logical
1432  * decoding possible. We need to do so if we're computing the global limit
1433  * (rel = NULL) or if the passed relation is a catalog relation of some
1434  * kind.
1435  */
1436  if (!(flags & PROCARRAY_SLOTS_XMIN) &&
1437  (rel == NULL ||
1439  TransactionIdIsValid(replication_slot_catalog_xmin) &&
1440  NormalTransactionIdPrecedes(replication_slot_catalog_xmin, result))
1442 
1443  return result;
1444 }
1445 
1446 /*
1447  * GetMaxSnapshotXidCount -- get max size for snapshot XID array
1448  *
1449  * We have to export this for use by snapmgr.c.
1450  */
1451 int
1453 {
1454  return procArray->maxProcs;
1455 }
1456 
1457 /*
1458  * GetMaxSnapshotSubxidCount -- get max size for snapshot sub-XID array
1459  *
1460  * We have to export this for use by snapmgr.c.
1461  */
1462 int
1464 {
1465  return TOTAL_MAX_CACHED_SUBXIDS;
1466 }
1467 
1468 /*
1469  * GetSnapshotData -- returns information about running transactions.
1470  *
1471  * The returned snapshot includes xmin (lowest still-running xact ID),
1472  * xmax (highest completed xact ID + 1), and a list of running xact IDs
1473  * in the range xmin <= xid < xmax. It is used as follows:
1474  * All xact IDs < xmin are considered finished.
1475  * All xact IDs >= xmax are considered still running.
1476  * For an xact ID xmin <= xid < xmax, consult list to see whether
1477  * it is considered running or not.
1478  * This ensures that the set of transactions seen as "running" by the
1479  * current xact will not change after it takes the snapshot.
1480  *
1481  * All running top-level XIDs are included in the snapshot, except for lazy
1482  * VACUUM processes. We also try to include running subtransaction XIDs,
1483  * but since PGPROC has only a limited cache area for subxact XIDs, full
1484  * information may not be available. If we find any overflowed subxid arrays,
1485  * we have to mark the snapshot's subxid data as overflowed, and extra work
1486  * *may* need to be done to determine what's running (see XidInMVCCSnapshot()
1487  * in heapam_visibility.c).
1488  *
1489  * We also update the following backend-global variables:
1490  * TransactionXmin: the oldest xmin of any snapshot in use in the
1491  * current transaction (this is the same as MyPgXact->xmin).
1492  * RecentXmin: the xmin computed for the most recent snapshot. XIDs
1493  * older than this are known not running any more.
1494  * RecentGlobalXmin: the global xmin (oldest TransactionXmin across all
1495  * running transactions, except those running LAZY VACUUM). This is
1496  * the same computation done by
1497  * GetOldestXmin(NULL, PROCARRAY_FLAGS_VACUUM).
1498  * RecentGlobalDataXmin: the global xmin for non-catalog tables
1499  * >= RecentGlobalXmin
1500  *
1501  * Note: this function should probably not be called with an argument that's
1502  * not statically allocated (see xip allocation below).
1503  */
1504 Snapshot
1506 {
1507  ProcArrayStruct *arrayP = procArray;
1508  TransactionId xmin;
1509  TransactionId xmax;
1510  TransactionId globalxmin;
1511  int index;
1512  int count = 0;
1513  int subcount = 0;
1514  bool suboverflowed = false;
1517 
1518  Assert(snapshot != NULL);
1519 
1520  /*
1521  * Allocating space for maxProcs xids is usually overkill; numProcs would
1522  * be sufficient. But it seems better to do the malloc while not holding
1523  * the lock, so we can't look at numProcs. Likewise, we allocate much
1524  * more subxip storage than is probably needed.
1525  *
1526  * This does open a possibility for avoiding repeated malloc/free: since
1527  * maxProcs does not change at runtime, we can simply reuse the previous
1528  * xip arrays if any. (This relies on the fact that all callers pass
1529  * static SnapshotData structs.)
1530  */
1531  if (snapshot->xip == NULL)
1532  {
1533  /*
1534  * First call for this snapshot. Snapshot is same size whether or not
1535  * we are in recovery, see later comments.
1536  */
1537  snapshot->xip = (TransactionId *)
1539  if (snapshot->xip == NULL)
1540  ereport(ERROR,
1541  (errcode(ERRCODE_OUT_OF_MEMORY),
1542  errmsg("out of memory")));
1543  Assert(snapshot->subxip == NULL);
1544  snapshot->subxip = (TransactionId *)
1546  if (snapshot->subxip == NULL)
1547  ereport(ERROR,
1548  (errcode(ERRCODE_OUT_OF_MEMORY),
1549  errmsg("out of memory")));
1550  }
1551 
1552  /*
1553  * It is sufficient to get shared lock on ProcArrayLock, even if we are
1554  * going to set MyPgXact->xmin.
1555  */
1556  LWLockAcquire(ProcArrayLock, LW_SHARED);
1557 
1558  /* xmax is always latestCompletedXid + 1 */
1561  TransactionIdAdvance(xmax);
1562 
1563  /* initialize xmin calculation with xmax */
1564  globalxmin = xmin = xmax;
1565 
1567 
1568  if (!snapshot->takenDuringRecovery)
1569  {
1570  int *pgprocnos = arrayP->pgprocnos;
1571  int numProcs;
1572 
1573  /*
1574  * Spin over procArray checking xid, xmin, and subxids. The goal is
1575  * to gather all active xids, find the lowest xmin, and try to record
1576  * subxids.
1577  */
1578  numProcs = arrayP->numProcs;
1579  for (index = 0; index < numProcs; index++)
1580  {
1581  int pgprocno = pgprocnos[index];
1582  PGXACT *pgxact = &allPgXact[pgprocno];
1583  TransactionId xid;
1584 
1585  /*
1586  * Skip over backends doing logical decoding which manages xmin
1587  * separately (check below) and ones running LAZY VACUUM.
1588  */
1589  if (pgxact->vacuumFlags &
1591  continue;
1592 
1593  /* Update globalxmin to be the smallest valid xmin */
1594  xid = UINT32_ACCESS_ONCE(pgxact->xmin);
1595  if (TransactionIdIsNormal(xid) &&
1596  NormalTransactionIdPrecedes(xid, globalxmin))
1597  globalxmin = xid;
1598 
1599  /* Fetch xid just once - see GetNewTransactionId */
1600  xid = UINT32_ACCESS_ONCE(pgxact->xid);
1601 
1602  /*
1603  * If the transaction has no XID assigned, we can skip it; it
1604  * won't have sub-XIDs either. If the XID is >= xmax, we can also
1605  * skip it; such transactions will be treated as running anyway
1606  * (and any sub-XIDs will also be >= xmax).
1607  */
1608  if (!TransactionIdIsNormal(xid)
1609  || !NormalTransactionIdPrecedes(xid, xmax))
1610  continue;
1611 
1612  /*
1613  * We don't include our own XIDs (if any) in the snapshot, but we
1614  * must include them in xmin.
1615  */
1616  if (NormalTransactionIdPrecedes(xid, xmin))
1617  xmin = xid;
1618  if (pgxact == MyPgXact)
1619  continue;
1620 
1621  /* Add XID to snapshot. */
1622  snapshot->xip[count++] = xid;
1623 
1624  /*
1625  * Save subtransaction XIDs if possible (if we've already
1626  * overflowed, there's no point). Note that the subxact XIDs must
1627  * be later than their parent, so no need to check them against
1628  * xmin. We could filter against xmax, but it seems better not to
1629  * do that much work while holding the ProcArrayLock.
1630  *
1631  * The other backend can add more subxids concurrently, but cannot
1632  * remove any. Hence it's important to fetch nxids just once.
1633  * Should be safe to use memcpy, though. (We needn't worry about
1634  * missing any xids added concurrently, because they must postdate
1635  * xmax.)
1636  *
1637  * Again, our own XIDs are not included in the snapshot.
1638  */
1639  if (!suboverflowed)
1640  {
1641  if (pgxact->overflowed)
1642  suboverflowed = true;
1643  else
1644  {
1645  int nxids = pgxact->nxids;
1646 
1647  if (nxids > 0)
1648  {
1649  PGPROC *proc = &allProcs[pgprocno];
1650 
1651  pg_read_barrier(); /* pairs with GetNewTransactionId */
1652 
1653  memcpy(snapshot->subxip + subcount,
1654  (void *) proc->subxids.xids,
1655  nxids * sizeof(TransactionId));
1656  subcount += nxids;
1657  }
1658  }
1659  }
1660  }
1661  }
1662  else
1663  {
1664  /*
1665  * We're in hot standby, so get XIDs from KnownAssignedXids.
1666  *
1667  * We store all xids directly into subxip[]. Here's why:
1668  *
1669  * In recovery we don't know which xids are top-level and which are
1670  * subxacts, a design choice that greatly simplifies xid processing.
1671  *
1672  * It seems like we would want to try to put xids into xip[] only, but
1673  * that is fairly small. We would either need to make that bigger or
1674  * to increase the rate at which we WAL-log xid assignment; neither is
1675  * an appealing choice.
1676  *
1677  * We could try to store xids into xip[] first and then into subxip[]
1678  * if there are too many xids. That only works if the snapshot doesn't
1679  * overflow because we do not search subxip[] in that case. A simpler
1680  * way is to just store all xids in the subxact array because this is
1681  * by far the bigger array. We just leave the xip array empty.
1682  *
1683  * Either way we need to change the way XidInMVCCSnapshot() works
1684  * depending upon when the snapshot was taken, or change normal
1685  * snapshot processing so it matches.
1686  *
1687  * Note: It is possible for recovery to end before we finish taking
1688  * the snapshot, and for newly assigned transaction ids to be added to
1689  * the ProcArray. xmax cannot change while we hold ProcArrayLock, so
1690  * those newly added transaction ids would be filtered away, so we
1691  * need not be concerned about them.
1692  */
1693  subcount = KnownAssignedXidsGetAndSetXmin(snapshot->subxip, &xmin,
1694  xmax);
1695 
1696  if (TransactionIdPrecedesOrEquals(xmin, procArray->lastOverflowedXid))
1697  suboverflowed = true;
1698  }
1699 
1700 
1701  /*
1702  * Fetch into local variable while ProcArrayLock is held - the
1703  * LWLockRelease below is a barrier, ensuring this happens inside the
1704  * lock.
1705  */
1706  replication_slot_xmin = procArray->replication_slot_xmin;
1707  replication_slot_catalog_xmin = procArray->replication_slot_catalog_xmin;
1708 
1710  MyPgXact->xmin = TransactionXmin = xmin;
1711 
1712  LWLockRelease(ProcArrayLock);
1713 
1714  /*
1715  * Update globalxmin to include actual process xids. This is a slightly
1716  * different way of computing it than GetOldestXmin uses, but should give
1717  * the same result.
1718  */
1719  if (TransactionIdPrecedes(xmin, globalxmin))
1720  globalxmin = xmin;
1721 
1722  /* Update global variables too */
1726 
1727  /* Check whether there's a replication slot requiring an older xmin. */
1728  if (TransactionIdIsValid(replication_slot_xmin) &&
1729  NormalTransactionIdPrecedes(replication_slot_xmin, RecentGlobalXmin))
1731 
1732  /* Non-catalog tables can be vacuumed if older than this xid */
1734 
1735  /*
1736  * Check whether there's a replication slot requiring an older catalog
1737  * xmin.
1738  */
1739  if (TransactionIdIsNormal(replication_slot_catalog_xmin) &&
1740  NormalTransactionIdPrecedes(replication_slot_catalog_xmin, RecentGlobalXmin))
1742 
1743  RecentXmin = xmin;
1744 
1745  snapshot->xmin = xmin;
1746  snapshot->xmax = xmax;
1747  snapshot->xcnt = count;
1748  snapshot->subxcnt = subcount;
1749  snapshot->suboverflowed = suboverflowed;
1750 
1751  snapshot->curcid = GetCurrentCommandId(false);
1752 
1753  /*
1754  * This is a new snapshot, so set both refcounts are zero, and mark it as
1755  * not copied in persistent memory.
1756  */
1757  snapshot->active_count = 0;
1758  snapshot->regd_count = 0;
1759  snapshot->copied = false;
1760 
1761  if (old_snapshot_threshold < 0)
1762  {
1763  /*
1764  * If not using "snapshot too old" feature, fill related fields with
1765  * dummy values that don't require any locking.
1766  */
1767  snapshot->lsn = InvalidXLogRecPtr;
1768  snapshot->whenTaken = 0;
1769  }
1770  else
1771  {
1772  /*
1773  * Capture the current time and WAL stream location in case this
1774  * snapshot becomes old enough to need to fall back on the special
1775  * "old snapshot" logic.
1776  */
1777  snapshot->lsn = GetXLogInsertRecPtr();
1778  snapshot->whenTaken = GetSnapshotCurrentTimestamp();
1779  MaintainOldSnapshotTimeMapping(snapshot->whenTaken, xmin);
1780  }
1781 
1782  return snapshot;
1783 }
1784 
1785 /*
1786  * ProcArrayInstallImportedXmin -- install imported xmin into MyPgXact->xmin
1787  *
1788  * This is called when installing a snapshot imported from another
1789  * transaction. To ensure that OldestXmin doesn't go backwards, we must
1790  * check that the source transaction is still running, and we'd better do
1791  * that atomically with installing the new xmin.
1792  *
1793  * Returns true if successful, false if source xact is no longer running.
1794  */
1795 bool
1797  VirtualTransactionId *sourcevxid)
1798 {
1799  bool result = false;
1800  ProcArrayStruct *arrayP = procArray;
1801  int index;
1802 
1804  if (!sourcevxid)
1805  return false;
1806 
1807  /* Get lock so source xact can't end while we're doing this */
1808  LWLockAcquire(ProcArrayLock, LW_SHARED);
1809 
1810  for (index = 0; index < arrayP->numProcs; index++)
1811  {
1812  int pgprocno = arrayP->pgprocnos[index];
1813  PGPROC *proc = &allProcs[pgprocno];
1814  PGXACT *pgxact = &allPgXact[pgprocno];
1815  TransactionId xid;
1816 
1817  /* Ignore procs running LAZY VACUUM */
1818  if (pgxact->vacuumFlags & PROC_IN_VACUUM)
1819  continue;
1820 
1821  /* We are only interested in the specific virtual transaction. */
1822  if (proc->backendId != sourcevxid->backendId)
1823  continue;
1824  if (proc->lxid != sourcevxid->localTransactionId)
1825  continue;
1826 
1827  /*
1828  * We check the transaction's database ID for paranoia's sake: if it's
1829  * in another DB then its xmin does not cover us. Caller should have
1830  * detected this already, so we just treat any funny cases as
1831  * "transaction not found".
1832  */
1833  if (proc->databaseId != MyDatabaseId)
1834  continue;
1835 
1836  /*
1837  * Likewise, let's just make real sure its xmin does cover us.
1838  */
1839  xid = UINT32_ACCESS_ONCE(pgxact->xmin);
1840  if (!TransactionIdIsNormal(xid) ||
1841  !TransactionIdPrecedesOrEquals(xid, xmin))
1842  continue;
1843 
1844  /*
1845  * We're good. Install the new xmin. As in GetSnapshotData, set
1846  * TransactionXmin too. (Note that because snapmgr.c called
1847  * GetSnapshotData first, we'll be overwriting a valid xmin here, so
1848  * we don't check that.)
1849  */
1850  MyPgXact->xmin = TransactionXmin = xmin;
1851 
1852  result = true;
1853  break;
1854  }
1855 
1856  LWLockRelease(ProcArrayLock);
1857 
1858  return result;
1859 }
1860 
1861 /*
1862  * ProcArrayInstallRestoredXmin -- install restored xmin into MyPgXact->xmin
1863  *
1864  * This is like ProcArrayInstallImportedXmin, but we have a pointer to the
1865  * PGPROC of the transaction from which we imported the snapshot, rather than
1866  * an XID.
1867  *
1868  * Returns true if successful, false if source xact is no longer running.
1869  */
1870 bool
1872 {
1873  bool result = false;
1874  TransactionId xid;
1875  PGXACT *pgxact;
1876 
1878  Assert(proc != NULL);
1879 
1880  /* Get lock so source xact can't end while we're doing this */
1881  LWLockAcquire(ProcArrayLock, LW_SHARED);
1882 
1883  pgxact = &allPgXact[proc->pgprocno];
1884 
1885  /*
1886  * Be certain that the referenced PGPROC has an advertised xmin which is
1887  * no later than the one we're installing, so that the system-wide xmin
1888  * can't go backwards. Also, make sure it's running in the same database,
1889  * so that the per-database xmin cannot go backwards.
1890  */
1891  xid = UINT32_ACCESS_ONCE(pgxact->xmin);
1892  if (proc->databaseId == MyDatabaseId &&
1893  TransactionIdIsNormal(xid) &&
1894  TransactionIdPrecedesOrEquals(xid, xmin))
1895  {
1896  MyPgXact->xmin = TransactionXmin = xmin;
1897  result = true;
1898  }
1899 
1900  LWLockRelease(ProcArrayLock);
1901 
1902  return result;
1903 }
1904 
1905 /*
1906  * GetRunningTransactionData -- returns information about running transactions.
1907  *
1908  * Similar to GetSnapshotData but returns more information. We include
1909  * all PGXACTs with an assigned TransactionId, even VACUUM processes and
1910  * prepared transactions.
1911  *
1912  * We acquire XidGenLock and ProcArrayLock, but the caller is responsible for
1913  * releasing them. Acquiring XidGenLock ensures that no new XIDs enter the proc
1914  * array until the caller has WAL-logged this snapshot, and releases the
1915  * lock. Acquiring ProcArrayLock ensures that no transactions commit until the
1916  * lock is released.
1917  *
1918  * The returned data structure is statically allocated; caller should not
1919  * modify it, and must not assume it is valid past the next call.
1920  *
1921  * This is never executed during recovery so there is no need to look at
1922  * KnownAssignedXids.
1923  *
1924  * Dummy PGXACTs from prepared transaction are included, meaning that this
1925  * may return entries with duplicated TransactionId values coming from
1926  * transaction finishing to prepare. Nothing is done about duplicated
1927  * entries here to not hold on ProcArrayLock more than necessary.
1928  *
1929  * We don't worry about updating other counters, we want to keep this as
1930  * simple as possible and leave GetSnapshotData() as the primary code for
1931  * that bookkeeping.
1932  *
1933  * Note that if any transaction has overflowed its cached subtransactions
1934  * then there is no real need include any subtransactions.
1935  */
1938 {
1939  /* result workspace */
1940  static RunningTransactionsData CurrentRunningXactsData;
1941 
1942  ProcArrayStruct *arrayP = procArray;
1943  RunningTransactions CurrentRunningXacts = &CurrentRunningXactsData;
1944  TransactionId latestCompletedXid;
1945  TransactionId oldestRunningXid;
1946  TransactionId *xids;
1947  int index;
1948  int count;
1949  int subcount;
1950  bool suboverflowed;
1951 
1953 
1954  /*
1955  * Allocating space for maxProcs xids is usually overkill; numProcs would
1956  * be sufficient. But it seems better to do the malloc while not holding
1957  * the lock, so we can't look at numProcs. Likewise, we allocate much
1958  * more subxip storage than is probably needed.
1959  *
1960  * Should only be allocated in bgwriter, since only ever executed during
1961  * checkpoints.
1962  */
1963  if (CurrentRunningXacts->xids == NULL)
1964  {
1965  /*
1966  * First call
1967  */
1968  CurrentRunningXacts->xids = (TransactionId *)
1970  if (CurrentRunningXacts->xids == NULL)
1971  ereport(ERROR,
1972  (errcode(ERRCODE_OUT_OF_MEMORY),
1973  errmsg("out of memory")));
1974  }
1975 
1976  xids = CurrentRunningXacts->xids;
1977 
1978  count = subcount = 0;
1979  suboverflowed = false;
1980 
1981  /*
1982  * Ensure that no xids enter or leave the procarray while we obtain
1983  * snapshot.
1984  */
1985  LWLockAcquire(ProcArrayLock, LW_SHARED);
1986  LWLockAcquire(XidGenLock, LW_SHARED);
1987 
1988  latestCompletedXid = ShmemVariableCache->latestCompletedXid;
1989 
1991 
1992  /*
1993  * Spin over procArray collecting all xids
1994  */
1995  for (index = 0; index < arrayP->numProcs; index++)
1996  {
1997  int pgprocno = arrayP->pgprocnos[index];
1998  PGXACT *pgxact = &allPgXact[pgprocno];
1999  TransactionId xid;
2000 
2001  /* Fetch xid just once - see GetNewTransactionId */
2002  xid = UINT32_ACCESS_ONCE(pgxact->xid);
2003 
2004  /*
2005  * We don't need to store transactions that don't have a TransactionId
2006  * yet because they will not show as running on a standby server.
2007  */
2008  if (!TransactionIdIsValid(xid))
2009  continue;
2010 
2011  /*
2012  * Be careful not to exclude any xids before calculating the values of
2013  * oldestRunningXid and suboverflowed, since these are used to clean
2014  * up transaction information held on standbys.
2015  */
2016  if (TransactionIdPrecedes(xid, oldestRunningXid))
2017  oldestRunningXid = xid;
2018 
2019  if (pgxact->overflowed)
2020  suboverflowed = true;
2021 
2022  /*
2023  * If we wished to exclude xids this would be the right place for it.
2024  * Procs with the PROC_IN_VACUUM flag set don't usually assign xids,
2025  * but they do during truncation at the end when they get the lock and
2026  * truncate, so it is not much of a problem to include them if they
2027  * are seen and it is cleaner to include them.
2028  */
2029 
2030  xids[count++] = xid;
2031  }
2032 
2033  /*
2034  * Spin over procArray collecting all subxids, but only if there hasn't
2035  * been a suboverflow.
2036  */
2037  if (!suboverflowed)
2038  {
2039  for (index = 0; index < arrayP->numProcs; index++)
2040  {
2041  int pgprocno = arrayP->pgprocnos[index];
2042  PGPROC *proc = &allProcs[pgprocno];
2043  PGXACT *pgxact = &allPgXact[pgprocno];
2044  int nxids;
2045 
2046  /*
2047  * Save subtransaction XIDs. Other backends can't add or remove
2048  * entries while we're holding XidGenLock.
2049  */
2050  nxids = pgxact->nxids;
2051  if (nxids > 0)
2052  {
2053  /* barrier not really required, as XidGenLock is held, but ... */
2054  pg_read_barrier(); /* pairs with GetNewTransactionId */
2055 
2056  memcpy(&xids[count], (void *) proc->subxids.xids,
2057  nxids * sizeof(TransactionId));
2058  count += nxids;
2059  subcount += nxids;
2060 
2061  /*
2062  * Top-level XID of a transaction is always less than any of
2063  * its subxids, so we don't need to check if any of the
2064  * subxids are smaller than oldestRunningXid
2065  */
2066  }
2067  }
2068  }
2069 
2070  /*
2071  * It's important *not* to include the limits set by slots here because
2072  * snapbuild.c uses oldestRunningXid to manage its xmin horizon. If those
2073  * were to be included here the initial value could never increase because
2074  * of a circular dependency where slots only increase their limits when
2075  * running xacts increases oldestRunningXid and running xacts only
2076  * increases if slots do.
2077  */
2078 
2079  CurrentRunningXacts->xcnt = count - subcount;
2080  CurrentRunningXacts->subxcnt = subcount;
2081  CurrentRunningXacts->subxid_overflow = suboverflowed;
2083  CurrentRunningXacts->oldestRunningXid = oldestRunningXid;
2084  CurrentRunningXacts->latestCompletedXid = latestCompletedXid;
2085 
2086  Assert(TransactionIdIsValid(CurrentRunningXacts->nextXid));
2087  Assert(TransactionIdIsValid(CurrentRunningXacts->oldestRunningXid));
2088  Assert(TransactionIdIsNormal(CurrentRunningXacts->latestCompletedXid));
2089 
2090  /* We don't release the locks here, the caller is responsible for that */
2091 
2092  return CurrentRunningXacts;
2093 }
2094 
2095 /*
2096  * GetOldestActiveTransactionId()
2097  *
2098  * Similar to GetSnapshotData but returns just oldestActiveXid. We include
2099  * all PGXACTs with an assigned TransactionId, even VACUUM processes.
2100  * We look at all databases, though there is no need to include WALSender
2101  * since this has no effect on hot standby conflicts.
2102  *
2103  * This is never executed during recovery so there is no need to look at
2104  * KnownAssignedXids.
2105  *
2106  * We don't worry about updating other counters, we want to keep this as
2107  * simple as possible and leave GetSnapshotData() as the primary code for
2108  * that bookkeeping.
2109  */
2112 {
2113  ProcArrayStruct *arrayP = procArray;
2114  TransactionId oldestRunningXid;
2115  int index;
2116 
2118 
2119  /*
2120  * Read nextXid, as the upper bound of what's still active.
2121  *
2122  * Reading a TransactionId is atomic, but we must grab the lock to make
2123  * sure that all XIDs < nextXid are already present in the proc array (or
2124  * have already completed), when we spin over it.
2125  */
2126  LWLockAcquire(XidGenLock, LW_SHARED);
2128  LWLockRelease(XidGenLock);
2129 
2130  /*
2131  * Spin over procArray collecting all xids and subxids.
2132  */
2133  LWLockAcquire(ProcArrayLock, LW_SHARED);
2134  for (index = 0; index < arrayP->numProcs; index++)
2135  {
2136  int pgprocno = arrayP->pgprocnos[index];
2137  PGXACT *pgxact = &allPgXact[pgprocno];
2138  TransactionId xid;
2139 
2140  /* Fetch xid just once - see GetNewTransactionId */
2141  xid = UINT32_ACCESS_ONCE(pgxact->xid);
2142 
2143  if (!TransactionIdIsNormal(xid))
2144  continue;
2145 
2146  if (TransactionIdPrecedes(xid, oldestRunningXid))
2147  oldestRunningXid = xid;
2148 
2149  /*
2150  * Top-level XID of a transaction is always less than any of its
2151  * subxids, so we don't need to check if any of the subxids are
2152  * smaller than oldestRunningXid
2153  */
2154  }
2155  LWLockRelease(ProcArrayLock);
2156 
2157  return oldestRunningXid;
2158 }
2159 
2160 /*
2161  * GetOldestSafeDecodingTransactionId -- lowest xid not affected by vacuum
2162  *
2163  * Returns the oldest xid that we can guarantee not to have been affected by
2164  * vacuum, i.e. no rows >= that xid have been vacuumed away unless the
2165  * transaction aborted. Note that the value can (and most of the time will) be
2166  * much more conservative than what really has been affected by vacuum, but we
2167  * currently don't have better data available.
2168  *
2169  * This is useful to initialize the cutoff xid after which a new changeset
2170  * extraction replication slot can start decoding changes.
2171  *
2172  * Must be called with ProcArrayLock held either shared or exclusively,
2173  * although most callers will want to use exclusive mode since it is expected
2174  * that the caller will immediately use the xid to peg the xmin horizon.
2175  */
2178 {
2179  ProcArrayStruct *arrayP = procArray;
2180  TransactionId oldestSafeXid;
2181  int index;
2182  bool recovery_in_progress = RecoveryInProgress();
2183 
2184  Assert(LWLockHeldByMe(ProcArrayLock));
2185 
2186  /*
2187  * Acquire XidGenLock, so no transactions can acquire an xid while we're
2188  * running. If no transaction with xid were running concurrently a new xid
2189  * could influence the RecentXmin et al.
2190  *
2191  * We initialize the computation to nextXid since that's guaranteed to be
2192  * a safe, albeit pessimal, value.
2193  */
2194  LWLockAcquire(XidGenLock, LW_SHARED);
2196 
2197  /*
2198  * If there's already a slot pegging the xmin horizon, we can start with
2199  * that value, it's guaranteed to be safe since it's computed by this
2200  * routine initially and has been enforced since. We can always use the
2201  * slot's general xmin horizon, but the catalog horizon is only usable
2202  * when only catalog data is going to be looked at.
2203  */
2204  if (TransactionIdIsValid(procArray->replication_slot_xmin) &&
2206  oldestSafeXid))
2207  oldestSafeXid = procArray->replication_slot_xmin;
2208 
2209  if (catalogOnly &&
2212  oldestSafeXid))
2213  oldestSafeXid = procArray->replication_slot_catalog_xmin;
2214 
2215  /*
2216  * If we're not in recovery, we walk over the procarray and collect the
2217  * lowest xid. Since we're called with ProcArrayLock held and have
2218  * acquired XidGenLock, no entries can vanish concurrently, since
2219  * PGXACT->xid is only set with XidGenLock held and only cleared with
2220  * ProcArrayLock held.
2221  *
2222  * In recovery we can't lower the safe value besides what we've computed
2223  * above, so we'll have to wait a bit longer there. We unfortunately can
2224  * *not* use KnownAssignedXidsGetOldestXmin() since the KnownAssignedXids
2225  * machinery can miss values and return an older value than is safe.
2226  */
2227  if (!recovery_in_progress)
2228  {
2229  /*
2230  * Spin over procArray collecting all min(PGXACT->xid)
2231  */
2232  for (index = 0; index < arrayP->numProcs; index++)
2233  {
2234  int pgprocno = arrayP->pgprocnos[index];
2235  PGXACT *pgxact = &allPgXact[pgprocno];
2236  TransactionId xid;
2237 
2238  /* Fetch xid just once - see GetNewTransactionId */
2239  xid = UINT32_ACCESS_ONCE(pgxact->xid);
2240 
2241  if (!TransactionIdIsNormal(xid))
2242  continue;
2243 
2244  if (TransactionIdPrecedes(xid, oldestSafeXid))
2245  oldestSafeXid = xid;
2246  }
2247  }
2248 
2249  LWLockRelease(XidGenLock);
2250 
2251  return oldestSafeXid;
2252 }
2253 
2254 /*
2255  * GetVirtualXIDsDelayingChkpt -- Get the VXIDs of transactions that are
2256  * delaying checkpoint because they have critical actions in progress.
2257  *
2258  * Constructs an array of VXIDs of transactions that are currently in commit
2259  * critical sections, as shown by having delayChkpt set in their PGXACT.
2260  *
2261  * Returns a palloc'd array that should be freed by the caller.
2262  * *nvxids is the number of valid entries.
2263  *
2264  * Note that because backends set or clear delayChkpt without holding any lock,
2265  * the result is somewhat indeterminate, but we don't really care. Even in
2266  * a multiprocessor with delayed writes to shared memory, it should be certain
2267  * that setting of delayChkpt will propagate to shared memory when the backend
2268  * takes a lock, so we cannot fail to see a virtual xact as delayChkpt if
2269  * it's already inserted its commit record. Whether it takes a little while
2270  * for clearing of delayChkpt to propagate is unimportant for correctness.
2271  */
2274 {
2275  VirtualTransactionId *vxids;
2276  ProcArrayStruct *arrayP = procArray;
2277  int count = 0;
2278  int index;
2279 
2280  /* allocate what's certainly enough result space */
2281  vxids = (VirtualTransactionId *)
2282  palloc(sizeof(VirtualTransactionId) * arrayP->maxProcs);
2283 
2284  LWLockAcquire(ProcArrayLock, LW_SHARED);
2285 
2286  for (index = 0; index < arrayP->numProcs; index++)
2287  {
2288  int pgprocno = arrayP->pgprocnos[index];
2289  PGPROC *proc = &allProcs[pgprocno];
2290  PGXACT *pgxact = &allPgXact[pgprocno];
2291 
2292  if (pgxact->delayChkpt)
2293  {
2294  VirtualTransactionId vxid;
2295 
2296  GET_VXID_FROM_PGPROC(vxid, *proc);
2297  if (VirtualTransactionIdIsValid(vxid))
2298  vxids[count++] = vxid;
2299  }
2300  }
2301 
2302  LWLockRelease(ProcArrayLock);
2303 
2304  *nvxids = count;
2305  return vxids;
2306 }
2307 
2308 /*
2309  * HaveVirtualXIDsDelayingChkpt -- Are any of the specified VXIDs delaying?
2310  *
2311  * This is used with the results of GetVirtualXIDsDelayingChkpt to see if any
2312  * of the specified VXIDs are still in critical sections of code.
2313  *
2314  * Note: this is O(N^2) in the number of vxacts that are/were delaying, but
2315  * those numbers should be small enough for it not to be a problem.
2316  */
2317 bool
2319 {
2320  bool result = false;
2321  ProcArrayStruct *arrayP = procArray;
2322  int index;
2323 
2324  LWLockAcquire(ProcArrayLock, LW_SHARED);
2325 
2326  for (index = 0; index < arrayP->numProcs; index++)
2327  {
2328  int pgprocno = arrayP->pgprocnos[index];
2329  PGPROC *proc = &allProcs[pgprocno];
2330  PGXACT *pgxact = &allPgXact[pgprocno];
2331  VirtualTransactionId vxid;
2332 
2333  GET_VXID_FROM_PGPROC(vxid, *proc);
2334 
2335  if (pgxact->delayChkpt && VirtualTransactionIdIsValid(vxid))
2336  {
2337  int i;
2338 
2339  for (i = 0; i < nvxids; i++)
2340  {
2341  if (VirtualTransactionIdEquals(vxid, vxids[i]))
2342  {
2343  result = true;
2344  break;
2345  }
2346  }
2347  if (result)
2348  break;
2349  }
2350  }
2351 
2352  LWLockRelease(ProcArrayLock);
2353 
2354  return result;
2355 }
2356 
2357 /*
2358  * BackendPidGetProc -- get a backend's PGPROC given its PID
2359  *
2360  * Returns NULL if not found. Note that it is up to the caller to be
2361  * sure that the question remains meaningful for long enough for the
2362  * answer to be used ...
2363  */
2364 PGPROC *
2366 {
2367  PGPROC *result;
2368 
2369  if (pid == 0) /* never match dummy PGPROCs */
2370  return NULL;
2371 
2372  LWLockAcquire(ProcArrayLock, LW_SHARED);
2373 
2374  result = BackendPidGetProcWithLock(pid);
2375 
2376  LWLockRelease(ProcArrayLock);
2377 
2378  return result;
2379 }
2380 
2381 /*
2382  * BackendPidGetProcWithLock -- get a backend's PGPROC given its PID
2383  *
2384  * Same as above, except caller must be holding ProcArrayLock. The found
2385  * entry, if any, can be assumed to be valid as long as the lock remains held.
2386  */
2387 PGPROC *
2389 {
2390  PGPROC *result = NULL;
2391  ProcArrayStruct *arrayP = procArray;
2392  int index;
2393 
2394  if (pid == 0) /* never match dummy PGPROCs */
2395  return NULL;
2396 
2397  for (index = 0; index < arrayP->numProcs; index++)
2398  {
2399  PGPROC *proc = &allProcs[arrayP->pgprocnos[index]];
2400 
2401  if (proc->pid == pid)
2402  {
2403  result = proc;
2404  break;
2405  }
2406  }
2407 
2408  return result;
2409 }
2410 
2411 /*
2412  * BackendXidGetPid -- get a backend's pid given its XID
2413  *
2414  * Returns 0 if not found or it's a prepared transaction. Note that
2415  * it is up to the caller to be sure that the question remains
2416  * meaningful for long enough for the answer to be used ...
2417  *
2418  * Only main transaction Ids are considered. This function is mainly
2419  * useful for determining what backend owns a lock.
2420  *
2421  * Beware that not every xact has an XID assigned. However, as long as you
2422  * only call this using an XID found on disk, you're safe.
2423  */
2424 int
2426 {
2427  int result = 0;
2428  ProcArrayStruct *arrayP = procArray;
2429  int index;
2430 
2431  if (xid == InvalidTransactionId) /* never match invalid xid */
2432  return 0;
2433 
2434  LWLockAcquire(ProcArrayLock, LW_SHARED);
2435 
2436  for (index = 0; index < arrayP->numProcs; index++)
2437  {
2438  int pgprocno = arrayP->pgprocnos[index];
2439  PGPROC *proc = &allProcs[pgprocno];
2440  PGXACT *pgxact = &allPgXact[pgprocno];
2441 
2442  if (pgxact->xid == xid)
2443  {
2444  result = proc->pid;
2445  break;
2446  }
2447  }
2448 
2449  LWLockRelease(ProcArrayLock);
2450 
2451  return result;
2452 }
2453 
2454 /*
2455  * IsBackendPid -- is a given pid a running backend
2456  *
2457  * This is not called by the backend, but is called by external modules.
2458  */
2459 bool
2461 {
2462  return (BackendPidGetProc(pid) != NULL);
2463 }
2464 
2465 
2466 /*
2467  * GetCurrentVirtualXIDs -- returns an array of currently active VXIDs.
2468  *
2469  * The array is palloc'd. The number of valid entries is returned into *nvxids.
2470  *
2471  * The arguments allow filtering the set of VXIDs returned. Our own process
2472  * is always skipped. In addition:
2473  * If limitXmin is not InvalidTransactionId, skip processes with
2474  * xmin > limitXmin.
2475  * If excludeXmin0 is true, skip processes with xmin = 0.
2476  * If allDbs is false, skip processes attached to other databases.
2477  * If excludeVacuum isn't zero, skip processes for which
2478  * (vacuumFlags & excludeVacuum) is not zero.
2479  *
2480  * Note: the purpose of the limitXmin and excludeXmin0 parameters is to
2481  * allow skipping backends whose oldest live snapshot is no older than
2482  * some snapshot we have. Since we examine the procarray with only shared
2483  * lock, there are race conditions: a backend could set its xmin just after
2484  * we look. Indeed, on multiprocessors with weak memory ordering, the
2485  * other backend could have set its xmin *before* we look. We know however
2486  * that such a backend must have held shared ProcArrayLock overlapping our
2487  * own hold of ProcArrayLock, else we would see its xmin update. Therefore,
2488  * any snapshot the other backend is taking concurrently with our scan cannot
2489  * consider any transactions as still running that we think are committed
2490  * (since backends must hold ProcArrayLock exclusive to commit).
2491  */
2493 GetCurrentVirtualXIDs(TransactionId limitXmin, bool excludeXmin0,
2494  bool allDbs, int excludeVacuum,
2495  int *nvxids)
2496 {
2497  VirtualTransactionId *vxids;
2498  ProcArrayStruct *arrayP = procArray;
2499  int count = 0;
2500  int index;
2501 
2502  /* allocate what's certainly enough result space */
2503  vxids = (VirtualTransactionId *)
2504  palloc(sizeof(VirtualTransactionId) * arrayP->maxProcs);
2505 
2506  LWLockAcquire(ProcArrayLock, LW_SHARED);
2507 
2508  for (index = 0; index < arrayP->numProcs; index++)
2509  {
2510  int pgprocno = arrayP->pgprocnos[index];
2511  PGPROC *proc = &allProcs[pgprocno];
2512  PGXACT *pgxact = &allPgXact[pgprocno];
2513 
2514  if (proc == MyProc)
2515  continue;
2516 
2517  if (excludeVacuum & pgxact->vacuumFlags)
2518  continue;
2519 
2520  if (allDbs || proc->databaseId == MyDatabaseId)
2521  {
2522  /* Fetch xmin just once - might change on us */
2523  TransactionId pxmin = UINT32_ACCESS_ONCE(pgxact->xmin);
2524 
2525  if (excludeXmin0 && !TransactionIdIsValid(pxmin))
2526  continue;
2527 
2528  /*
2529  * InvalidTransactionId precedes all other XIDs, so a proc that
2530  * hasn't set xmin yet will not be rejected by this test.
2531  */
2532  if (!TransactionIdIsValid(limitXmin) ||
2533  TransactionIdPrecedesOrEquals(pxmin, limitXmin))
2534  {
2535  VirtualTransactionId vxid;
2536 
2537  GET_VXID_FROM_PGPROC(vxid, *proc);
2538  if (VirtualTransactionIdIsValid(vxid))
2539  vxids[count++] = vxid;
2540  }
2541  }
2542  }
2543 
2544  LWLockRelease(ProcArrayLock);
2545 
2546  *nvxids = count;
2547  return vxids;
2548 }
2549 
2550 /*
2551  * GetConflictingVirtualXIDs -- returns an array of currently active VXIDs.
2552  *
2553  * Usage is limited to conflict resolution during recovery on standby servers.
2554  * limitXmin is supplied as either latestRemovedXid, or InvalidTransactionId
2555  * in cases where we cannot accurately determine a value for latestRemovedXid.
2556  *
2557  * If limitXmin is InvalidTransactionId then we want to kill everybody,
2558  * so we're not worried if they have a snapshot or not, nor does it really
2559  * matter what type of lock we hold.
2560  *
2561  * All callers that are checking xmins always now supply a valid and useful
2562  * value for limitXmin. The limitXmin is always lower than the lowest
2563  * numbered KnownAssignedXid that is not already a FATAL error. This is
2564  * because we only care about cleanup records that are cleaning up tuple
2565  * versions from committed transactions. In that case they will only occur
2566  * at the point where the record is less than the lowest running xid. That
2567  * allows us to say that if any backend takes a snapshot concurrently with
2568  * us then the conflict assessment made here would never include the snapshot
2569  * that is being derived. So we take LW_SHARED on the ProcArray and allow
2570  * concurrent snapshots when limitXmin is valid. We might think about adding
2571  * Assert(limitXmin < lowest(KnownAssignedXids))
2572  * but that would not be true in the case of FATAL errors lagging in array,
2573  * but we already know those are bogus anyway, so we skip that test.
2574  *
2575  * If dbOid is valid we skip backends attached to other databases.
2576  *
2577  * Be careful to *not* pfree the result from this function. We reuse
2578  * this array sufficiently often that we use malloc for the result.
2579  */
2582 {
2583  static VirtualTransactionId *vxids;
2584  ProcArrayStruct *arrayP = procArray;
2585  int count = 0;
2586  int index;
2587 
2588  /*
2589  * If first time through, get workspace to remember main XIDs in. We
2590  * malloc it permanently to avoid repeated palloc/pfree overhead. Allow
2591  * result space, remembering room for a terminator.
2592  */
2593  if (vxids == NULL)
2594  {
2595  vxids = (VirtualTransactionId *)
2596  malloc(sizeof(VirtualTransactionId) * (arrayP->maxProcs + 1));
2597  if (vxids == NULL)
2598  ereport(ERROR,
2599  (errcode(ERRCODE_OUT_OF_MEMORY),
2600  errmsg("out of memory")));
2601  }
2602 
2603  LWLockAcquire(ProcArrayLock, LW_SHARED);
2604 
2605  for (index = 0; index < arrayP->numProcs; index++)
2606  {
2607  int pgprocno = arrayP->pgprocnos[index];
2608  PGPROC *proc = &allProcs[pgprocno];
2609  PGXACT *pgxact = &allPgXact[pgprocno];
2610 
2611  /* Exclude prepared transactions */
2612  if (proc->pid == 0)
2613  continue;
2614 
2615  if (!OidIsValid(dbOid) ||
2616  proc->databaseId == dbOid)
2617  {
2618  /* Fetch xmin just once - can't change on us, but good coding */
2619  TransactionId pxmin = UINT32_ACCESS_ONCE(pgxact->xmin);
2620 
2621  /*
2622  * We ignore an invalid pxmin because this means that backend has
2623  * no snapshot currently. We hold a Share lock to avoid contention
2624  * with users taking snapshots. That is not a problem because the
2625  * current xmin is always at least one higher than the latest
2626  * removed xid, so any new snapshot would never conflict with the
2627  * test here.
2628  */
2629  if (!TransactionIdIsValid(limitXmin) ||
2630  (TransactionIdIsValid(pxmin) && !TransactionIdFollows(pxmin, limitXmin)))
2631  {
2632  VirtualTransactionId vxid;
2633 
2634  GET_VXID_FROM_PGPROC(vxid, *proc);
2635  if (VirtualTransactionIdIsValid(vxid))
2636  vxids[count++] = vxid;
2637  }
2638  }
2639  }
2640 
2641  LWLockRelease(ProcArrayLock);
2642 
2643  /* add the terminator */
2644  vxids[count].backendId = InvalidBackendId;
2646 
2647  return vxids;
2648 }
2649 
2650 /*
2651  * CancelVirtualTransaction - used in recovery conflict processing
2652  *
2653  * Returns pid of the process signaled, or 0 if not found.
2654  */
2655 pid_t
2657 {
2658  ProcArrayStruct *arrayP = procArray;
2659  int index;
2660  pid_t pid = 0;
2661 
2662  LWLockAcquire(ProcArrayLock, LW_SHARED);
2663 
2664  for (index = 0; index < arrayP->numProcs; index++)
2665  {
2666  int pgprocno = arrayP->pgprocnos[index];
2667  PGPROC *proc = &allProcs[pgprocno];
2668  VirtualTransactionId procvxid;
2669 
2670  GET_VXID_FROM_PGPROC(procvxid, *proc);
2671 
2672  if (procvxid.backendId == vxid.backendId &&
2673  procvxid.localTransactionId == vxid.localTransactionId)
2674  {
2675  proc->recoveryConflictPending = true;
2676  pid = proc->pid;
2677  if (pid != 0)
2678  {
2679  /*
2680  * Kill the pid if it's still here. If not, that's what we
2681  * wanted so ignore any errors.
2682  */
2683  (void) SendProcSignal(pid, sigmode, vxid.backendId);
2684  }
2685  break;
2686  }
2687  }
2688 
2689  LWLockRelease(ProcArrayLock);
2690 
2691  return pid;
2692 }
2693 
2694 /*
2695  * MinimumActiveBackends --- count backends (other than myself) that are
2696  * in active transactions. Return true if the count exceeds the
2697  * minimum threshold passed. This is used as a heuristic to decide if
2698  * a pre-XLOG-flush delay is worthwhile during commit.
2699  *
2700  * Do not count backends that are blocked waiting for locks, since they are
2701  * not going to get to run until someone else commits.
2702  */
2703 bool
2705 {
2706  ProcArrayStruct *arrayP = procArray;
2707  int count = 0;
2708  int index;
2709 
2710  /* Quick short-circuit if no minimum is specified */
2711  if (min == 0)
2712  return true;
2713 
2714  /*
2715  * Note: for speed, we don't acquire ProcArrayLock. This is a little bit
2716  * bogus, but since we are only testing fields for zero or nonzero, it
2717  * should be OK. The result is only used for heuristic purposes anyway...
2718  */
2719  for (index = 0; index < arrayP->numProcs; index++)
2720  {
2721  int pgprocno = arrayP->pgprocnos[index];
2722  PGPROC *proc = &allProcs[pgprocno];
2723  PGXACT *pgxact = &allPgXact[pgprocno];
2724 
2725  /*
2726  * Since we're not holding a lock, need to be prepared to deal with
2727  * garbage, as someone could have incremented numProcs but not yet
2728  * filled the structure.
2729  *
2730  * If someone just decremented numProcs, 'proc' could also point to a
2731  * PGPROC entry that's no longer in the array. It still points to a
2732  * PGPROC struct, though, because freed PGPROC entries just go to the
2733  * free list and are recycled. Its contents are nonsense in that case,
2734  * but that's acceptable for this function.
2735  */
2736  if (pgprocno == -1)
2737  continue; /* do not count deleted entries */
2738  if (proc == MyProc)
2739  continue; /* do not count myself */
2740  if (pgxact->xid == InvalidTransactionId)
2741  continue; /* do not count if no XID assigned */
2742  if (proc->pid == 0)
2743  continue; /* do not count prepared xacts */
2744  if (proc->waitLock != NULL)
2745  continue; /* do not count if blocked on a lock */
2746  count++;
2747  if (count >= min)
2748  break;
2749  }
2750 
2751  return count >= min;
2752 }
2753 
2754 /*
2755  * CountDBBackends --- count backends that are using specified database
2756  */
2757 int
2759 {
2760  ProcArrayStruct *arrayP = procArray;
2761  int count = 0;
2762  int index;
2763 
2764  LWLockAcquire(ProcArrayLock, LW_SHARED);
2765 
2766  for (index = 0; index < arrayP->numProcs; index++)
2767  {
2768  int pgprocno = arrayP->pgprocnos[index];
2769  PGPROC *proc = &allProcs[pgprocno];
2770 
2771  if (proc->pid == 0)
2772  continue; /* do not count prepared xacts */
2773  if (!OidIsValid(databaseid) ||
2774  proc->databaseId == databaseid)
2775  count++;
2776  }
2777 
2778  LWLockRelease(ProcArrayLock);
2779 
2780  return count;
2781 }
2782 
2783 /*
2784  * CountDBConnections --- counts database backends ignoring any background
2785  * worker processes
2786  */
2787 int
2789 {
2790  ProcArrayStruct *arrayP = procArray;
2791  int count = 0;
2792  int index;
2793 
2794  LWLockAcquire(ProcArrayLock, LW_SHARED);
2795 
2796  for (index = 0; index < arrayP->numProcs; index++)
2797  {
2798  int pgprocno = arrayP->pgprocnos[index];
2799  PGPROC *proc = &allProcs[pgprocno];
2800 
2801  if (proc->pid == 0)
2802  continue; /* do not count prepared xacts */
2803  if (proc->isBackgroundWorker)
2804  continue; /* do not count background workers */
2805  if (!OidIsValid(databaseid) ||
2806  proc->databaseId == databaseid)
2807  count++;
2808  }
2809 
2810  LWLockRelease(ProcArrayLock);
2811 
2812  return count;
2813 }
2814 
2815 /*
2816  * CancelDBBackends --- cancel backends that are using specified database
2817  */
2818 void
2819 CancelDBBackends(Oid databaseid, ProcSignalReason sigmode, bool conflictPending)
2820 {
2821  ProcArrayStruct *arrayP = procArray;
2822  int index;
2823  pid_t pid = 0;
2824 
2825  /* tell all backends to die */
2826  LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
2827 
2828  for (index = 0; index < arrayP->numProcs; index++)
2829  {
2830  int pgprocno = arrayP->pgprocnos[index];
2831  PGPROC *proc = &allProcs[pgprocno];
2832 
2833  if (databaseid == InvalidOid || proc->databaseId == databaseid)
2834  {
2835  VirtualTransactionId procvxid;
2836 
2837  GET_VXID_FROM_PGPROC(procvxid, *proc);
2838 
2839  proc->recoveryConflictPending = conflictPending;
2840  pid = proc->pid;
2841  if (pid != 0)
2842  {
2843  /*
2844  * Kill the pid if it's still here. If not, that's what we
2845  * wanted so ignore any errors.
2846  */
2847  (void) SendProcSignal(pid, sigmode, procvxid.backendId);
2848  }
2849  }
2850  }
2851 
2852  LWLockRelease(ProcArrayLock);
2853 }
2854 
2855 /*
2856  * CountUserBackends --- count backends that are used by specified user
2857  */
2858 int
2860 {
2861  ProcArrayStruct *arrayP = procArray;
2862  int count = 0;
2863  int index;
2864 
2865  LWLockAcquire(ProcArrayLock, LW_SHARED);
2866 
2867  for (index = 0; index < arrayP->numProcs; index++)
2868  {
2869  int pgprocno = arrayP->pgprocnos[index];
2870  PGPROC *proc = &allProcs[pgprocno];
2871 
2872  if (proc->pid == 0)
2873  continue; /* do not count prepared xacts */
2874  if (proc->isBackgroundWorker)
2875  continue; /* do not count background workers */
2876  if (proc->roleId == roleid)
2877  count++;
2878  }
2879 
2880  LWLockRelease(ProcArrayLock);
2881 
2882  return count;
2883 }
2884 
2885 /*
2886  * CountOtherDBBackends -- check for other backends running in the given DB
2887  *
2888  * If there are other backends in the DB, we will wait a maximum of 5 seconds
2889  * for them to exit. Autovacuum backends are encouraged to exit early by
2890  * sending them SIGTERM, but normal user backends are just waited for.
2891  *
2892  * The current backend is always ignored; it is caller's responsibility to
2893  * check whether the current backend uses the given DB, if it's important.
2894  *
2895  * Returns true if there are (still) other backends in the DB, false if not.
2896  * Also, *nbackends and *nprepared are set to the number of other backends
2897  * and prepared transactions in the DB, respectively.
2898  *
2899  * This function is used to interlock DROP DATABASE and related commands
2900  * against there being any active backends in the target DB --- dropping the
2901  * DB while active backends remain would be a Bad Thing. Note that we cannot
2902  * detect here the possibility of a newly-started backend that is trying to
2903  * connect to the doomed database, so additional interlocking is needed during
2904  * backend startup. The caller should normally hold an exclusive lock on the
2905  * target DB before calling this, which is one reason we mustn't wait
2906  * indefinitely.
2907  */
2908 bool
2909 CountOtherDBBackends(Oid databaseId, int *nbackends, int *nprepared)
2910 {
2911  ProcArrayStruct *arrayP = procArray;
2912 
2913 #define MAXAUTOVACPIDS 10 /* max autovacs to SIGTERM per iteration */
2914  int autovac_pids[MAXAUTOVACPIDS];
2915  int tries;
2916 
2917  /* 50 tries with 100ms sleep between tries makes 5 sec total wait */
2918  for (tries = 0; tries < 50; tries++)
2919  {
2920  int nautovacs = 0;
2921  bool found = false;
2922  int index;
2923 
2925 
2926  *nbackends = *nprepared = 0;
2927 
2928  LWLockAcquire(ProcArrayLock, LW_SHARED);
2929 
2930  for (index = 0; index < arrayP->numProcs; index++)
2931  {
2932  int pgprocno = arrayP->pgprocnos[index];
2933  PGPROC *proc = &allProcs[pgprocno];
2934  PGXACT *pgxact = &allPgXact[pgprocno];
2935 
2936  if (proc->databaseId != databaseId)
2937  continue;
2938  if (proc == MyProc)
2939  continue;
2940 
2941  found = true;
2942 
2943  if (proc->pid == 0)
2944  (*nprepared)++;
2945  else
2946  {
2947  (*nbackends)++;
2948  if ((pgxact->vacuumFlags & PROC_IS_AUTOVACUUM) &&
2949  nautovacs < MAXAUTOVACPIDS)
2950  autovac_pids[nautovacs++] = proc->pid;
2951  }
2952  }
2953 
2954  LWLockRelease(ProcArrayLock);
2955 
2956  if (!found)
2957  return false; /* no conflicting backends, so done */
2958 
2959  /*
2960  * Send SIGTERM to any conflicting autovacuums before sleeping. We
2961  * postpone this step until after the loop because we don't want to
2962  * hold ProcArrayLock while issuing kill(). We have no idea what might
2963  * block kill() inside the kernel...
2964  */
2965  for (index = 0; index < nautovacs; index++)
2966  (void) kill(autovac_pids[index], SIGTERM); /* ignore any error */
2967 
2968  /* sleep, then try again */
2969  pg_usleep(100 * 1000L); /* 100ms */
2970  }
2971 
2972  return true; /* timed out, still conflicts */
2973 }
2974 
2975 /*
2976  * Terminate existing connections to the specified database. This routine
2977  * is used by the DROP DATABASE command when user has asked to forcefully
2978  * drop the database.
2979  *
2980  * The current backend is always ignored; it is caller's responsibility to
2981  * check whether the current backend uses the given DB, if it's important.
2982  *
2983  * It doesn't allow to terminate the connections even if there is a one
2984  * backend with the prepared transaction in the target database.
2985  */
2986 void
2988 {
2989  ProcArrayStruct *arrayP = procArray;
2990  List *pids = NIL;
2991  int nprepared = 0;
2992  int i;
2993 
2994  LWLockAcquire(ProcArrayLock, LW_SHARED);
2995 
2996  for (i = 0; i < procArray->numProcs; i++)
2997  {
2998  int pgprocno = arrayP->pgprocnos[i];
2999  PGPROC *proc = &allProcs[pgprocno];
3000 
3001  if (proc->databaseId != databaseId)
3002  continue;
3003  if (proc == MyProc)
3004  continue;
3005 
3006  if (proc->pid != 0)
3007  pids = lappend_int(pids, proc->pid);
3008  else
3009  nprepared++;
3010  }
3011 
3012  LWLockRelease(ProcArrayLock);
3013 
3014  if (nprepared > 0)
3015  ereport(ERROR,
3016  (errcode(ERRCODE_OBJECT_IN_USE),
3017  errmsg("database \"%s\" is being used by prepared transaction",
3018  get_database_name(databaseId)),
3019  errdetail_plural("There is %d prepared transaction using the database.",
3020  "There are %d prepared transactions using the database.",
3021  nprepared,
3022  nprepared)));
3023 
3024  if (pids)
3025  {
3026  ListCell *lc;
3027 
3028  /*
3029  * Check whether we have the necessary rights to terminate other
3030  * sessions. We don't terminate any session untill we ensure that we
3031  * have rights on all the sessions to be terminated. These checks are
3032  * the same as we do in pg_terminate_backend.
3033  *
3034  * In this case we don't raise some warnings - like "PID %d is not a
3035  * PostgreSQL server process", because for us already finished session
3036  * is not a problem.
3037  */
3038  foreach(lc, pids)
3039  {
3040  int pid = lfirst_int(lc);
3041  PGPROC *proc = BackendPidGetProc(pid);
3042 
3043  if (proc != NULL)
3044  {
3045  /* Only allow superusers to signal superuser-owned backends. */
3046  if (superuser_arg(proc->roleId) && !superuser())
3047  ereport(ERROR,
3048  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
3049  (errmsg("must be a superuser to terminate superuser process"))));
3050 
3051  /* Users can signal backends they have role membership in. */
3052  if (!has_privs_of_role(GetUserId(), proc->roleId) &&
3053  !has_privs_of_role(GetUserId(), DEFAULT_ROLE_SIGNAL_BACKENDID))
3054  ereport(ERROR,
3055  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
3056  (errmsg("must be a member of the role whose process is being terminated or member of pg_signal_backend"))));
3057  }
3058  }
3059 
3060  /*
3061  * There's a race condition here: once we release the ProcArrayLock,
3062  * it's possible for the session to exit before we issue kill. That
3063  * race condition possibility seems too unlikely to worry about. See
3064  * pg_signal_backend.
3065  */
3066  foreach(lc, pids)
3067  {
3068  int pid = lfirst_int(lc);
3069  PGPROC *proc = BackendPidGetProc(pid);
3070 
3071  if (proc != NULL)
3072  {
3073  /*
3074  * If we have setsid(), signal the backend's whole process
3075  * group
3076  */
3077 #ifdef HAVE_SETSID
3078  (void) kill(-pid, SIGTERM);
3079 #else
3080  (void) kill(pid, SIGTERM);
3081 #endif
3082  }
3083  }
3084  }
3085 }
3086 
3087 /*
3088  * ProcArraySetReplicationSlotXmin
3089  *
3090  * Install limits to future computations of the xmin horizon to prevent vacuum
3091  * and HOT pruning from removing affected rows still needed by clients with
3092  * replication slots.
3093  */
3094 void
3096  bool already_locked)
3097 {
3098  Assert(!already_locked || LWLockHeldByMe(ProcArrayLock));
3099 
3100  if (!already_locked)
3101  LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
3102 
3103  procArray->replication_slot_xmin = xmin;
3104  procArray->replication_slot_catalog_xmin = catalog_xmin;
3105 
3106  if (!already_locked)
3107  LWLockRelease(ProcArrayLock);
3108 }
3109 
3110 /*
3111  * ProcArrayGetReplicationSlotXmin
3112  *
3113  * Return the current slot xmin limits. That's useful to be able to remove
3114  * data that's older than those limits.
3115  */
3116 void
3118  TransactionId *catalog_xmin)
3119 {
3120  LWLockAcquire(ProcArrayLock, LW_SHARED);
3121 
3122  if (xmin != NULL)
3123  *xmin = procArray->replication_slot_xmin;
3124 
3125  if (catalog_xmin != NULL)
3126  *catalog_xmin = procArray->replication_slot_catalog_xmin;
3127 
3128  LWLockRelease(ProcArrayLock);
3129 }
3130 
3131 
3132 #define XidCacheRemove(i) \
3133  do { \
3134  MyProc->subxids.xids[i] = MyProc->subxids.xids[MyPgXact->nxids - 1]; \
3135  pg_write_barrier(); \
3136  MyPgXact->nxids--; \
3137  } while (0)
3138 
3139 /*
3140  * XidCacheRemoveRunningXids
3141  *
3142  * Remove a bunch of TransactionIds from the list of known-running
3143  * subtransactions for my backend. Both the specified xid and those in
3144  * the xids[] array (of length nxids) are removed from the subxids cache.
3145  * latestXid must be the latest XID among the group.
3146  */
3147 void
3149  int nxids, const TransactionId *xids,
3150  TransactionId latestXid)
3151 {
3152  int i,
3153  j;
3154 
3156 
3157  /*
3158  * We must hold ProcArrayLock exclusively in order to remove transactions
3159  * from the PGPROC array. (See src/backend/access/transam/README.) It's
3160  * possible this could be relaxed since we know this routine is only used
3161  * to abort subtransactions, but pending closer analysis we'd best be
3162  * conservative.
3163  *
3164  * Note that we do not have to be careful about memory ordering of our own
3165  * reads wrt. GetNewTransactionId() here - only this process can modify
3166  * relevant fields of MyProc/MyPgXact. But we do have to be careful about
3167  * our own writes being well ordered.
3168  */
3169  LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
3170 
3171  /*
3172  * Under normal circumstances xid and xids[] will be in increasing order,
3173  * as will be the entries in subxids. Scan backwards to avoid O(N^2)
3174  * behavior when removing a lot of xids.
3175  */
3176  for (i = nxids - 1; i >= 0; i--)
3177  {
3178  TransactionId anxid = xids[i];
3179 
3180  for (j = MyPgXact->nxids - 1; j >= 0; j--)
3181  {
3182  if (TransactionIdEquals(MyProc->subxids.xids[j], anxid))
3183  {
3184  XidCacheRemove(j);
3185  break;
3186  }
3187  }
3188 
3189  /*
3190  * Ordinarily we should have found it, unless the cache has
3191  * overflowed. However it's also possible for this routine to be
3192  * invoked multiple times for the same subtransaction, in case of an
3193  * error during AbortSubTransaction. So instead of Assert, emit a
3194  * debug warning.
3195  */
3196  if (j < 0 && !MyPgXact->overflowed)
3197  elog(WARNING, "did not find subXID %u in MyProc", anxid);
3198  }
3199 
3200  for (j = MyPgXact->nxids - 1; j >= 0; j--)
3201  {
3202  if (TransactionIdEquals(MyProc->subxids.xids[j], xid))
3203  {
3204  XidCacheRemove(j);
3205  break;
3206  }
3207  }
3208  /* Ordinarily we should have found it, unless the cache has overflowed */
3209  if (j < 0 && !MyPgXact->overflowed)
3210  elog(WARNING, "did not find subXID %u in MyProc", xid);
3211 
3212  /* Also advance global latestCompletedXid while holding the lock */
3214  latestXid))
3216 
3217  LWLockRelease(ProcArrayLock);
3218 }
3219 
3220 #ifdef XIDCACHE_DEBUG
3221 
3222 /*
3223  * Print stats about effectiveness of XID cache
3224  */
3225 static void
3226 DisplayXidCache(void)
3227 {
3228  fprintf(stderr,
3229  "XidCache: xmin: %ld, known: %ld, myxact: %ld, latest: %ld, mainxid: %ld, childxid: %ld, knownassigned: %ld, nooflo: %ld, slow: %ld\n",
3230  xc_by_recent_xmin,
3231  xc_by_known_xact,
3232  xc_by_my_xact,
3233  xc_by_latest_xid,
3234  xc_by_main_xid,
3235  xc_by_child_xid,
3236  xc_by_known_assigned,
3237  xc_no_overflow,
3238  xc_slow_answer);
3239 }
3240 #endif /* XIDCACHE_DEBUG */
3241 
3242 
3243 /* ----------------------------------------------
3244  * KnownAssignedTransactionIds sub-module
3245  * ----------------------------------------------
3246  */
3247 
3248 /*
3249  * In Hot Standby mode, we maintain a list of transactions that are (or were)
3250  * running in the master at the current point in WAL. These XIDs must be
3251  * treated as running by standby transactions, even though they are not in
3252  * the standby server's PGXACT array.
3253  *
3254  * We record all XIDs that we know have been assigned. That includes all the
3255  * XIDs seen in WAL records, plus all unobserved XIDs that we can deduce have
3256  * been assigned. We can deduce the existence of unobserved XIDs because we
3257  * know XIDs are assigned in sequence, with no gaps. The KnownAssignedXids
3258  * list expands as new XIDs are observed or inferred, and contracts when
3259  * transaction completion records arrive.
3260  *
3261  * During hot standby we do not fret too much about the distinction between
3262  * top-level XIDs and subtransaction XIDs. We store both together in the
3263  * KnownAssignedXids list. In backends, this is copied into snapshots in
3264  * GetSnapshotData(), taking advantage of the fact that XidInMVCCSnapshot()
3265  * doesn't care about the distinction either. Subtransaction XIDs are
3266  * effectively treated as top-level XIDs and in the typical case pg_subtrans
3267  * links are *not* maintained (which does not affect visibility).
3268  *
3269  * We have room in KnownAssignedXids and in snapshots to hold maxProcs *
3270  * (1 + PGPROC_MAX_CACHED_SUBXIDS) XIDs, so every master transaction must
3271  * report its subtransaction XIDs in a WAL XLOG_XACT_ASSIGNMENT record at
3272  * least every PGPROC_MAX_CACHED_SUBXIDS. When we receive one of these
3273  * records, we mark the subXIDs as children of the top XID in pg_subtrans,
3274  * and then remove them from KnownAssignedXids. This prevents overflow of
3275  * KnownAssignedXids and snapshots, at the cost that status checks for these
3276  * subXIDs will take a slower path through TransactionIdIsInProgress().
3277  * This means that KnownAssignedXids is not necessarily complete for subXIDs,
3278  * though it should be complete for top-level XIDs; this is the same situation
3279  * that holds with respect to the PGPROC entries in normal running.
3280  *
3281  * When we throw away subXIDs from KnownAssignedXids, we need to keep track of
3282  * that, similarly to tracking overflow of a PGPROC's subxids array. We do
3283  * that by remembering the lastOverflowedXid, ie the last thrown-away subXID.
3284  * As long as that is within the range of interesting XIDs, we have to assume
3285  * that subXIDs are missing from snapshots. (Note that subXID overflow occurs
3286  * on primary when 65th subXID arrives, whereas on standby it occurs when 64th
3287  * subXID arrives - that is not an error.)
3288  *
3289  * Should a backend on primary somehow disappear before it can write an abort
3290  * record, then we just leave those XIDs in KnownAssignedXids. They actually
3291  * aborted but we think they were running; the distinction is irrelevant
3292  * because either way any changes done by the transaction are not visible to
3293  * backends in the standby. We prune KnownAssignedXids when
3294  * XLOG_RUNNING_XACTS arrives, to forestall possible overflow of the
3295  * array due to such dead XIDs.
3296  */
3297 
3298 /*
3299  * RecordKnownAssignedTransactionIds
3300  * Record the given XID in KnownAssignedXids, as well as any preceding
3301  * unobserved XIDs.
3302  *
3303  * RecordKnownAssignedTransactionIds() should be run for *every* WAL record
3304  * associated with a transaction. Must be called for each record after we
3305  * have executed StartupCLOG() et al, since we must ExtendCLOG() etc..
3306  *
3307  * Called during recovery in analogy with and in place of GetNewTransactionId()
3308  */
3309 void
3311 {
3315 
3316  elog(trace_recovery(DEBUG4), "record known xact %u latestObservedXid %u",
3317  xid, latestObservedXid);
3318 
3319  /*
3320  * When a newly observed xid arrives, it is frequently the case that it is
3321  * *not* the next xid in sequence. When this occurs, we must treat the
3322  * intervening xids as running also.
3323  */
3325  {
3326  TransactionId next_expected_xid;
3327 
3328  /*
3329  * Extend subtrans like we do in GetNewTransactionId() during normal
3330  * operation using individual extend steps. Note that we do not need
3331  * to extend clog since its extensions are WAL logged.
3332  *
3333  * This part has to be done regardless of standbyState since we
3334  * immediately start assigning subtransactions to their toplevel
3335  * transactions.
3336  */
3337  next_expected_xid = latestObservedXid;
3338  while (TransactionIdPrecedes(next_expected_xid, xid))
3339  {
3340  TransactionIdAdvance(next_expected_xid);
3341  ExtendSUBTRANS(next_expected_xid);
3342  }
3343  Assert(next_expected_xid == xid);
3344 
3345  /*
3346  * If the KnownAssignedXids machinery isn't up yet, there's nothing
3347  * more to do since we don't track assigned xids yet.
3348  */
3350  {
3351  latestObservedXid = xid;
3352  return;
3353  }
3354 
3355  /*
3356  * Add (latestObservedXid, xid] onto the KnownAssignedXids array.
3357  */
3358  next_expected_xid = latestObservedXid;
3359  TransactionIdAdvance(next_expected_xid);
3360  KnownAssignedXidsAdd(next_expected_xid, xid, false);
3361 
3362  /*
3363  * Now we can advance latestObservedXid
3364  */
3365  latestObservedXid = xid;
3366 
3367  /* ShmemVariableCache->nextFullXid must be beyond any observed xid */
3369  next_expected_xid = latestObservedXid;
3370  TransactionIdAdvance(next_expected_xid);
3371  }
3372 }
3373 
3374 /*
3375  * ExpireTreeKnownAssignedTransactionIds
3376  * Remove the given XIDs from KnownAssignedXids.
3377  *
3378  * Called during recovery in analogy with and in place of ProcArrayEndTransaction()
3379  */
3380 void
3382  TransactionId *subxids, TransactionId max_xid)
3383 {
3385 
3386  /*
3387  * Uses same locking as transaction commit
3388  */
3389  LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
3390 
3391  KnownAssignedXidsRemoveTree(xid, nsubxids, subxids);
3392 
3393  /* As in ProcArrayEndTransaction, advance latestCompletedXid */
3395  max_xid))
3397 
3398  LWLockRelease(ProcArrayLock);
3399 }
3400 
3401 /*
3402  * ExpireAllKnownAssignedTransactionIds
3403  * Remove all entries in KnownAssignedXids
3404  */
3405 void
3407 {
3408  LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
3410  LWLockRelease(ProcArrayLock);
3411 }
3412 
3413 /*
3414  * ExpireOldKnownAssignedTransactionIds
3415  * Remove KnownAssignedXids entries preceding the given XID
3416  */
3417 void
3419 {
3420  LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
3422  LWLockRelease(ProcArrayLock);
3423 }
3424 
3425 
3426 /*
3427  * Private module functions to manipulate KnownAssignedXids
3428  *
3429  * There are 5 main uses of the KnownAssignedXids data structure:
3430  *
3431  * * backends taking snapshots - all valid XIDs need to be copied out
3432  * * backends seeking to determine presence of a specific XID
3433  * * startup process adding new known-assigned XIDs
3434  * * startup process removing specific XIDs as transactions end
3435  * * startup process pruning array when special WAL records arrive
3436  *
3437  * This data structure is known to be a hot spot during Hot Standby, so we
3438  * go to some lengths to make these operations as efficient and as concurrent
3439  * as possible.
3440  *
3441  * The XIDs are stored in an array in sorted order --- TransactionIdPrecedes
3442  * order, to be exact --- to allow binary search for specific XIDs. Note:
3443  * in general TransactionIdPrecedes would not provide a total order, but
3444  * we know that the entries present at any instant should not extend across
3445  * a large enough fraction of XID space to wrap around (the master would
3446  * shut down for fear of XID wrap long before that happens). So it's OK to
3447  * use TransactionIdPrecedes as a binary-search comparator.
3448  *
3449  * It's cheap to maintain the sortedness during insertions, since new known
3450  * XIDs are always reported in XID order; we just append them at the right.
3451  *
3452  * To keep individual deletions cheap, we need to allow gaps in the array.
3453  * This is implemented by marking array elements as valid or invalid using
3454  * the parallel boolean array KnownAssignedXidsValid[]. A deletion is done
3455  * by setting KnownAssignedXidsValid[i] to false, *without* clearing the
3456  * XID entry itself. This preserves the property that the XID entries are
3457  * sorted, so we can do binary searches easily. Periodically we compress
3458  * out the unused entries; that's much cheaper than having to compress the
3459  * array immediately on every deletion.
3460  *
3461  * The actually valid items in KnownAssignedXids[] and KnownAssignedXidsValid[]
3462  * are those with indexes tail <= i < head; items outside this subscript range
3463  * have unspecified contents. When head reaches the end of the array, we
3464  * force compression of unused entries rather than wrapping around, since
3465  * allowing wraparound would greatly complicate the search logic. We maintain
3466  * an explicit tail pointer so that pruning of old XIDs can be done without
3467  * immediately moving the array contents. In most cases only a small fraction
3468  * of the array contains valid entries at any instant.
3469  *
3470  * Although only the startup process can ever change the KnownAssignedXids
3471  * data structure, we still need interlocking so that standby backends will
3472  * not observe invalid intermediate states. The convention is that backends
3473  * must hold shared ProcArrayLock to examine the array. To remove XIDs from
3474  * the array, the startup process must hold ProcArrayLock exclusively, for
3475  * the usual transactional reasons (compare commit/abort of a transaction
3476  * during normal running). Compressing unused entries out of the array
3477  * likewise requires exclusive lock. To add XIDs to the array, we just insert
3478  * them into slots to the right of the head pointer and then advance the head
3479  * pointer. This wouldn't require any lock at all, except that on machines
3480  * with weak memory ordering we need to be careful that other processors
3481  * see the array element changes before they see the head pointer change.
3482  * We handle this by using a spinlock to protect reads and writes of the
3483  * head/tail pointers. (We could dispense with the spinlock if we were to
3484  * create suitable memory access barrier primitives and use those instead.)
3485  * The spinlock must be taken to read or write the head/tail pointers unless
3486  * the caller holds ProcArrayLock exclusively.
3487  *
3488  * Algorithmic analysis:
3489  *
3490  * If we have a maximum of M slots, with N XIDs currently spread across
3491  * S elements then we have N <= S <= M always.
3492  *
3493  * * Adding a new XID is O(1) and needs little locking (unless compression
3494  * must happen)
3495  * * Compressing the array is O(S) and requires exclusive lock
3496  * * Removing an XID is O(logS) and requires exclusive lock
3497  * * Taking a snapshot is O(S) and requires shared lock
3498  * * Checking for an XID is O(logS) and requires shared lock
3499  *
3500  * In comparison, using a hash table for KnownAssignedXids would mean that
3501  * taking snapshots would be O(M). If we can maintain S << M then the
3502  * sorted array technique will deliver significantly faster snapshots.
3503  * If we try to keep S too small then we will spend too much time compressing,
3504  * so there is an optimal point for any workload mix. We use a heuristic to
3505  * decide when to compress the array, though trimming also helps reduce
3506  * frequency of compressing. The heuristic requires us to track the number of
3507  * currently valid XIDs in the array.
3508  */
3509 
3510 
3511 /*
3512  * Compress KnownAssignedXids by shifting valid data down to the start of the
3513  * array, removing any gaps.
3514  *
3515  * A compression step is forced if "force" is true, otherwise we do it
3516  * only if a heuristic indicates it's a good time to do it.
3517  *
3518  * Caller must hold ProcArrayLock in exclusive mode.
3519  */
3520 static void
3522 {
3523  ProcArrayStruct *pArray = procArray;
3524  int head,
3525  tail;
3526  int compress_index;
3527  int i;
3528 
3529  /* no spinlock required since we hold ProcArrayLock exclusively */
3530  head = pArray->headKnownAssignedXids;
3531  tail = pArray->tailKnownAssignedXids;
3532 
3533  if (!force)
3534  {
3535  /*
3536  * If we can choose how much to compress, use a heuristic to avoid
3537  * compressing too often or not often enough.
3538  *
3539  * Heuristic is if we have a large enough current spread and less than
3540  * 50% of the elements are currently in use, then compress. This
3541  * should ensure we compress fairly infrequently. We could compress
3542  * less often though the virtual array would spread out more and
3543  * snapshots would become more expensive.
3544  */
3545  int nelements = head - tail;
3546 
3547  if (nelements < 4 * PROCARRAY_MAXPROCS ||
3548  nelements < 2 * pArray->numKnownAssignedXids)
3549  return;
3550  }
3551 
3552  /*
3553  * We compress the array by reading the valid values from tail to head,
3554  * re-aligning data to 0th element.
3555  */
3556  compress_index = 0;
3557  for (i = tail; i < head; i++)
3558  {
3559  if (KnownAssignedXidsValid[i])
3560  {
3561  KnownAssignedXids[compress_index] = KnownAssignedXids[i];
3562  KnownAssignedXidsValid[compress_index] = true;
3563  compress_index++;
3564  }
3565  }
3566 
3567  pArray->tailKnownAssignedXids = 0;
3568  pArray->headKnownAssignedXids = compress_index;
3569 }
3570 
3571 /*
3572  * Add xids into KnownAssignedXids at the head of the array.
3573  *
3574  * xids from from_xid to to_xid, inclusive, are added to the array.
3575  *
3576  * If exclusive_lock is true then caller already holds ProcArrayLock in
3577  * exclusive mode, so we need no extra locking here. Else caller holds no
3578  * lock, so we need to be sure we maintain sufficient interlocks against
3579  * concurrent readers. (Only the startup process ever calls this, so no need
3580  * to worry about concurrent writers.)
3581  */
3582 static void
3584  bool exclusive_lock)
3585 {
3586  ProcArrayStruct *pArray = procArray;
3587  TransactionId next_xid;
3588  int head,
3589  tail;
3590  int nxids;
3591  int i;
3592 
3593  Assert(TransactionIdPrecedesOrEquals(from_xid, to_xid));
3594 
3595  /*
3596  * Calculate how many array slots we'll need. Normally this is cheap; in
3597  * the unusual case where the XIDs cross the wrap point, we do it the hard
3598  * way.
3599  */
3600  if (to_xid >= from_xid)
3601  nxids = to_xid - from_xid + 1;
3602  else
3603  {
3604  nxids = 1;
3605  next_xid = from_xid;
3606  while (TransactionIdPrecedes(next_xid, to_xid))
3607  {
3608  nxids++;
3609  TransactionIdAdvance(next_xid);
3610  }
3611  }
3612 
3613  /*
3614  * Since only the startup process modifies the head/tail pointers, we
3615  * don't need a lock to read them here.
3616  */
3617  head = pArray->headKnownAssignedXids;
3618  tail = pArray->tailKnownAssignedXids;
3619 
3620  Assert(head >= 0 && head <= pArray->maxKnownAssignedXids);
3621  Assert(tail >= 0 && tail < pArray->maxKnownAssignedXids);
3622 
3623  /*
3624  * Verify that insertions occur in TransactionId sequence. Note that even
3625  * if the last existing element is marked invalid, it must still have a
3626  * correctly sequenced XID value.
3627  */
3628  if (head > tail &&
3629  TransactionIdFollowsOrEquals(KnownAssignedXids[head - 1], from_xid))
3630  {
3632  elog(ERROR, "out-of-order XID insertion in KnownAssignedXids");
3633  }
3634 
3635  /*
3636  * If our xids won't fit in the remaining space, compress out free space
3637  */
3638  if (head + nxids > pArray->maxKnownAssignedXids)
3639  {
3640  /* must hold lock to compress */
3641  if (!exclusive_lock)
3642  LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
3643 
3645 
3646  head = pArray->headKnownAssignedXids;
3647  /* note: we no longer care about the tail pointer */
3648 
3649  if (!exclusive_lock)
3650  LWLockRelease(ProcArrayLock);
3651 
3652  /*
3653  * If it still won't fit then we're out of memory
3654  */
3655  if (head + nxids > pArray->maxKnownAssignedXids)
3656  elog(ERROR, "too many KnownAssignedXids");
3657  }
3658 
3659  /* Now we can insert the xids into the space starting at head */
3660  next_xid = from_xid;
3661  for (i = 0; i < nxids; i++)
3662  {
3663  KnownAssignedXids[head] = next_xid;
3664  KnownAssignedXidsValid[head] = true;
3665  TransactionIdAdvance(next_xid);
3666  head++;
3667  }
3668 
3669  /* Adjust count of number of valid entries */
3670  pArray->numKnownAssignedXids += nxids;
3671 
3672  /*
3673  * Now update the head pointer. We use a spinlock to protect this
3674  * pointer, not because the update is likely to be non-atomic, but to
3675  * ensure that other processors see the above array updates before they
3676  * see the head pointer change.
3677  *
3678  * If we're holding ProcArrayLock exclusively, there's no need to take the
3679  * spinlock.
3680  */
3681  if (exclusive_lock)
3682  pArray->headKnownAssignedXids = head;
3683  else
3684  {
3686  pArray->headKnownAssignedXids = head;
3688  }
3689 }
3690 
3691 /*
3692  * KnownAssignedXidsSearch
3693  *
3694  * Searches KnownAssignedXids for a specific xid and optionally removes it.
3695  * Returns true if it was found, false if not.
3696  *
3697  * Caller must hold ProcArrayLock in shared or exclusive mode.
3698  * Exclusive lock must be held for remove = true.
3699  */
3700 static bool
3702 {
3703  ProcArrayStruct *pArray = procArray;
3704  int first,
3705  last;
3706  int head;
3707  int tail;
3708  int result_index = -1;
3709 
3710  if (remove)
3711  {
3712  /* we hold ProcArrayLock exclusively, so no need for spinlock */
3713  tail = pArray->tailKnownAssignedXids;
3714  head = pArray->headKnownAssignedXids;
3715  }
3716  else
3717  {
3718  /* take spinlock to ensure we see up-to-date array contents */
3720  tail = pArray->tailKnownAssignedXids;
3721  head = pArray->headKnownAssignedXids;
3723  }
3724 
3725  /*
3726  * Standard binary search. Note we can ignore the KnownAssignedXidsValid
3727  * array here, since even invalid entries will contain sorted XIDs.
3728  */
3729  first = tail;
3730  last = head - 1;
3731  while (first <= last)
3732  {
3733  int mid_index;
3734  TransactionId mid_xid;
3735 
3736  mid_index = (first + last) / 2;
3737  mid_xid = KnownAssignedXids[mid_index];
3738 
3739  if (xid == mid_xid)
3740  {
3741  result_index = mid_index;
3742  break;
3743  }
3744  else if (TransactionIdPrecedes(xid, mid_xid))
3745  last = mid_index - 1;
3746  else
3747  first = mid_index + 1;
3748  }
3749 
3750  if (result_index < 0)
3751  return false; /* not in array */
3752 
3753  if (!KnownAssignedXidsValid[result_index])
3754  return false; /* in array, but invalid */
3755 
3756  if (remove)
3757  {
3758  KnownAssignedXidsValid[result_index] = false;
3759 
3760  pArray->numKnownAssignedXids--;
3761  Assert(pArray->numKnownAssignedXids >= 0);
3762 
3763  /*
3764  * If we're removing the tail element then advance tail pointer over
3765  * any invalid elements. This will speed future searches.
3766  */
3767  if (result_index == tail)
3768  {
3769  tail++;
3770  while (tail < head && !KnownAssignedXidsValid[tail])
3771  tail++;
3772  if (tail >= head)
3773  {
3774  /* Array is empty, so we can reset both pointers */
3775  pArray->headKnownAssignedXids = 0;
3776  pArray->tailKnownAssignedXids = 0;
3777  }
3778  else
3779  {
3780  pArray->tailKnownAssignedXids = tail;
3781  }
3782  }
3783  }
3784 
3785  return true;
3786 }
3787 
3788 /*
3789  * Is the specified XID present in KnownAssignedXids[]?
3790  *
3791  * Caller must hold ProcArrayLock in shared or exclusive mode.
3792  */
3793 static bool
3795 {
3797 
3798  return KnownAssignedXidsSearch(xid, false);
3799 }
3800 
3801 /*
3802  * Remove the specified XID from KnownAssignedXids[].
3803  *
3804  * Caller must hold ProcArrayLock in exclusive mode.
3805  */
3806 static void
3808 {
3810 
3811  elog(trace_recovery(DEBUG4), "remove KnownAssignedXid %u", xid);
3812 
3813  /*
3814  * Note: we cannot consider it an error to remove an XID that's not
3815  * present. We intentionally remove subxact IDs while processing
3816  * XLOG_XACT_ASSIGNMENT, to avoid array overflow. Then those XIDs will be
3817  * removed again when the top-level xact commits or aborts.
3818  *
3819  * It might be possible to track such XIDs to distinguish this case from
3820  * actual errors, but it would be complicated and probably not worth it.
3821  * So, just ignore the search result.
3822  */
3823  (void) KnownAssignedXidsSearch(xid, true);
3824 }
3825 
3826 /*
3827  * KnownAssignedXidsRemoveTree
3828  * Remove xid (if it's not InvalidTransactionId) and all the subxids.
3829  *
3830  * Caller must hold ProcArrayLock in exclusive mode.
3831  */
3832 static void
3834  TransactionId *subxids)
3835 {
3836  int i;
3837 
3838  if (TransactionIdIsValid(xid))
3840 
3841  for (i = 0; i < nsubxids; i++)
3842  KnownAssignedXidsRemove(subxids[i]);
3843 
3844  /* Opportunistically compress the array */
3846 }
3847 
3848 /*
3849  * Prune KnownAssignedXids up to, but *not* including xid. If xid is invalid
3850  * then clear the whole table.
3851  *
3852  * Caller must hold ProcArrayLock in exclusive mode.
3853  */
3854 static void
3856 {
3857  ProcArrayStruct *pArray = procArray;
3858  int count = 0;
3859  int head,
3860  tail,
3861  i;
3862 
3863  if (!TransactionIdIsValid(removeXid))
3864  {
3865  elog(trace_recovery(DEBUG4), "removing all KnownAssignedXids");
3866  pArray->numKnownAssignedXids = 0;
3867  pArray->headKnownAssignedXids = pArray->tailKnownAssignedXids = 0;
3868  return;
3869  }
3870 
3871  elog(trace_recovery(DEBUG4), "prune KnownAssignedXids to %u", removeXid);
3872 
3873  /*
3874  * Mark entries invalid starting at the tail. Since array is sorted, we
3875  * can stop as soon as we reach an entry >= removeXid.
3876  */
3877  tail = pArray->tailKnownAssignedXids;
3878  head = pArray->headKnownAssignedXids;
3879 
3880  for (i = tail; i < head; i++)
3881  {
3882  if (KnownAssignedXidsValid[i])
3883  {
3884  TransactionId knownXid = KnownAssignedXids[i];
3885 
3886  if (TransactionIdFollowsOrEquals(knownXid, removeXid))
3887  break;
3888 
3889  if (!StandbyTransactionIdIsPrepared(knownXid))
3890  {
3891  KnownAssignedXidsValid[i] = false;
3892  count++;
3893  }
3894  }
3895  }
3896 
3897  pArray->numKnownAssignedXids -= count;
3898  Assert(pArray->numKnownAssignedXids >= 0);
3899 
3900  /*
3901  * Advance the tail pointer if we've marked the tail item invalid.
3902  */
3903  for (i = tail; i < head; i++)
3904  {
3905  if (KnownAssignedXidsValid[i])
3906  break;
3907  }
3908  if (i >= head)
3909  {
3910  /* Array is empty, so we can reset both pointers */
3911  pArray->headKnownAssignedXids = 0;
3912  pArray->tailKnownAssignedXids = 0;
3913  }
3914  else
3915  {
3916  pArray->tailKnownAssignedXids = i;
3917  }
3918 
3919  /* Opportunistically compress the array */
3921 }
3922 
3923 /*
3924  * KnownAssignedXidsGet - Get an array of xids by scanning KnownAssignedXids.
3925  * We filter out anything >= xmax.
3926  *
3927  * Returns the number of XIDs stored into xarray[]. Caller is responsible
3928  * that array is large enough.
3929  *
3930  * Caller must hold ProcArrayLock in (at least) shared mode.
3931  */
3932 static int
3934 {
3936 
3937  return KnownAssignedXidsGetAndSetXmin(xarray, &xtmp, xmax);
3938 }
3939 
3940 /*
3941  * KnownAssignedXidsGetAndSetXmin - as KnownAssignedXidsGet, plus
3942  * we reduce *xmin to the lowest xid value seen if not already lower.
3943  *
3944  * Caller must hold ProcArrayLock in (at least) shared mode.
3945  */
3946 static int
3948  TransactionId xmax)
3949 {
3950  int count = 0;
3951  int head,
3952  tail;
3953  int i;
3954 
3955  /*
3956  * Fetch head just once, since it may change while we loop. We can stop
3957  * once we reach the initially seen head, since we are certain that an xid
3958  * cannot enter and then leave the array while we hold ProcArrayLock. We
3959  * might miss newly-added xids, but they should be >= xmax so irrelevant
3960  * anyway.
3961  *
3962  * Must take spinlock to ensure we see up-to-date array contents.
3963  */
3965  tail = procArray->tailKnownAssignedXids;
3966  head = procArray->headKnownAssignedXids;
3968 
3969  for (i = tail; i < head; i++)
3970  {
3971  /* Skip any gaps in the array */
3972  if (KnownAssignedXidsValid[i])
3973  {
3974  TransactionId knownXid = KnownAssignedXids[i];
3975 
3976  /*
3977  * Update xmin if required. Only the first XID need be checked,
3978  * since the array is sorted.
3979  */
3980  if (count == 0 &&
3981  TransactionIdPrecedes(knownXid, *xmin))
3982  *xmin = knownXid;
3983 
3984  /*
3985  * Filter out anything >= xmax, again relying on sorted property
3986  * of array.
3987  */
3988  if (TransactionIdIsValid(xmax) &&
3989  TransactionIdFollowsOrEquals(knownXid, xmax))
3990  break;
3991 
3992  /* Add knownXid into output array */
3993  xarray[count++] = knownXid;
3994  }
3995  }
3996 
3997  return count;
3998 }
3999 
4000 /*
4001  * Get oldest XID in the KnownAssignedXids array, or InvalidTransactionId
4002  * if nothing there.
4003  */
4004 static TransactionId
4006 {
4007  int head,
4008  tail;
4009  int i;
4010 
4011  /*
4012  * Fetch head just once, since it may change while we loop.
4013  */
4015  tail = procArray->tailKnownAssignedXids;
4016  head = procArray->headKnownAssignedXids;
4018 
4019  for (i = tail; i < head; i++)
4020  {
4021  /* Skip any gaps in the array */
4022  if (KnownAssignedXidsValid[i])
4023  return KnownAssignedXids[i];
4024  }
4025 
4026  return InvalidTransactionId;
4027 }
4028 
4029 /*
4030  * Display KnownAssignedXids to provide debug trail
4031  *
4032  * Currently this is only called within startup process, so we need no
4033  * special locking.
4034  *
4035  * Note this is pretty expensive, and much of the expense will be incurred
4036  * even if the elog message will get discarded. It's not currently called
4037  * in any performance-critical places, however, so no need to be tenser.
4038  */
4039 static void
4041 {
4042  ProcArrayStruct *pArray = procArray;
4044  int head,
4045  tail,
4046  i;
4047  int nxids = 0;
4048 
4049  tail = pArray->tailKnownAssignedXids;
4050  head = pArray->headKnownAssignedXids;
4051 
4052  initStringInfo(&buf);
4053 
4054  for (i = tail; i < head; i++)
4055  {
4056  if (KnownAssignedXidsValid[i])
4057  {
4058  nxids++;
4059  appendStringInfo(&buf, "[%d]=%u ", i, KnownAssignedXids[i]);
4060  }
4061  }
4062 
4063  elog(trace_level, "%d KnownAssignedXids (num=%d tail=%d head=%d) %s",
4064  nxids,
4065  pArray->numKnownAssignedXids,
4066  pArray->tailKnownAssignedXids,
4067  pArray->headKnownAssignedXids,
4068  buf.data);
4069 
4070  pfree(buf.data);
4071 }
4072 
4073 /*
4074  * KnownAssignedXidsReset
4075  * Resets KnownAssignedXids to be empty
4076  */
4077 static void
4079 {
4080  ProcArrayStruct *pArray = procArray;
4081 
4082  LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
4083 
4084  pArray->numKnownAssignedXids = 0;
4085  pArray->tailKnownAssignedXids = 0;
4086  pArray->headKnownAssignedXids = 0;
4087 
4088  LWLockRelease(ProcArrayLock);
4089 }
#define TransactionIdAdvance(dest)
Definition: transam.h:75
int slock_t
Definition: s_lock.h:934
void ProcArrayApplyRecoveryInfo(RunningTransactions running)
Definition: procarray.c:664
#define NIL
Definition: pg_list.h:65
#define XidCacheRemove(i)
Definition: procarray.c:3132
static TransactionId latestObservedXid
Definition: procarray.c:111
VirtualTransactionId * GetCurrentVirtualXIDs(TransactionId limitXmin, bool excludeXmin0, bool allDbs, int excludeVacuum, int *nvxids)
Definition: procarray.c:2493
TransactionId oldestRunningXid
Definition: standby.h:76
bool procArrayGroupMember
Definition: proc.h:166
pid_t CancelVirtualTransaction(VirtualTransactionId vxid, ProcSignalReason sigmode)
Definition: procarray.c:2656
#define PROCARRAY_MAXPROCS
#define InvalidXLogRecPtr
Definition: xlogdefs.h:28
TransactionId GetOldestSafeDecodingTransactionId(bool catalogOnly)
Definition: procarray.c:2177
int CountDBBackends(Oid databaseid)
Definition: procarray.c:2758
#define DEBUG1
Definition: elog.h:25
static void KnownAssignedXidsDisplay(int trace_level)
Definition: procarray.c:4040
#define GET_VXID_FROM_PGPROC(vxid, proc)
Definition: lock.h:79
#define TransactionIdEquals(id1, id2)
Definition: transam.h:43
bool TransactionIdFollows(TransactionId id1, TransactionId id2)
Definition: transam.c:334
#define PROC_IN_LOGICAL_DECODING
Definition: proc.h:57
BackendId backendId
Definition: proc.h:113
uint32 TransactionId
Definition: c.h:514
bool copied
Definition: snapshot.h:185
void AdvanceNextFullTransactionIdPastXid(TransactionId xid)
Definition: varsup.c:262
void PGSemaphoreUnlock(PGSemaphore sema)
Definition: posix_sema.c:340
Definition: proc.h:222
#define DEBUG3
Definition: elog.h:23
bool TransactionIdIsCurrentTransactionId(TransactionId xid)
Definition: xact.c:853
Oid GetUserId(void)
Definition: miscinit.c:380
TransactionId SubTransGetTopmostTransaction(TransactionId xid)
Definition: subtrans.c:150
bool LWLockHeldByMe(LWLock *l)
Definition: lwlock.c:1842
TransactionId xmin
Definition: proc.h:228
static bool pg_atomic_compare_exchange_u32(volatile pg_atomic_uint32 *ptr, uint32 *expected, uint32 newval)
Definition: atomics.h:311
PGPROC * BackendPidGetProc(int pid)
Definition: procarray.c:2365
#define FullTransactionIdIsValid(x)
Definition: transam.h:51
PGXACT * allPgXact
Definition: proc.h:249
PGPROC * MyProc
Definition: proc.c:67
bool TransactionIdIsInProgress(TransactionId xid)
Definition: procarray.c:987
TransactionId xid
Definition: proc.h:224
TransactionId TransactionIdLatest(TransactionId mainxid, int nxids, const TransactionId *xids)
Definition: transam.c:365
int vacuum_defer_cleanup_age
Definition: standby.c:39
#define UINT32_ACCESS_ONCE(var)
Definition: procarray.c:66
#define SpinLockInit(lock)
Definition: spin.h:60
bool has_privs_of_role(Oid member, Oid role)
Definition: acl.c:4900
VirtualTransactionId * GetConflictingVirtualXIDs(TransactionId limitXmin, Oid dbOid)
Definition: procarray.c:2581
TransactionId replication_slot_catalog_xmin
Definition: procarray.c:95
XLogRecPtr lsn
Definition: snapshot.h:203
bool TransactionIdFollowsOrEquals(TransactionId id1, TransactionId id2)
Definition: transam.c:349
VirtualTransactionId * GetVirtualXIDsDelayingChkpt(int *nvxids)
Definition: procarray.c:2273
static void ProcArrayGroupClearXid(PGPROC *proc, TransactionId latestXid)
Definition: procarray.c:486
#define xc_by_my_xact_inc()
Definition: procarray.c:148
Oid roleId
Definition: proc.h:115
int errcode(int sqlerrcode)
Definition: elog.c:608
TransactionId RecentXmin
Definition: snapmgr.c:167
slock_t known_assigned_xids_lck
Definition: procarray.c:81
bool superuser(void)
Definition: superuser.c:46
PROC_HDR * ProcGlobal
Definition: proc.c:80
bool suboverflowed
Definition: snapshot.h:182
TransactionId * xids
Definition: standby.h:79
#define kill(pid, sig)
Definition: win32_port.h:426
FullTransactionId nextFullXid
Definition: transam.h:164
bool TransactionIdDidCommit(TransactionId transactionId)
Definition: transam.c:125
#define LOG
Definition: elog.h:26
Form_pg_class rd_rel
Definition: rel.h:83
unsigned int Oid
Definition: postgres_ext.h:31
bool RecoveryInProgress(void)
Definition: xlog.c:7935
#define TransactionIdRetreat(dest)
Definition: transam.h:92
LocalTransactionId localTransactionId
Definition: lock.h:65
void ProcArrayEndTransaction(PGPROC *proc, TransactionId latestXid)
Definition: procarray.c:398
#define xc_by_child_xid_inc()
Definition: procarray.c:151
bool TransactionIdIsKnownCompleted(TransactionId transactionId)
Definition: transam.c:238
#define DEBUG4
Definition: elog.h:22
#define fprintf
Definition: port.h:196
void ExpireTreeKnownAssignedTransactionIds(TransactionId xid, int nsubxids, TransactionId *subxids, TransactionId max_xid)
Definition: procarray.c:3381
#define MAXAUTOVACPIDS
uint32 regd_count
Definition: snapshot.h:199
#define OidIsValid(objectId)
Definition: c.h:645
void ProcArrayGetReplicationSlotXmin(TransactionId *xmin, TransactionId *catalog_xmin)
Definition: procarray.c:3117
void ExpireAllKnownAssignedTransactionIds(void)
Definition: procarray.c:3406
PGXACT * MyPgXact
Definition: proc.c:68
int trace_recovery(int trace_level)
Definition: elog.c:3589
uint8 vacuumFlags
Definition: proc.h:233
#define PROC_VACUUM_STATE_MASK
Definition: proc.h:62
#define XidFromFullTransactionId(x)
Definition: transam.h:48
TransactionId TransactionXmin
Definition: snapmgr.c:166
void LWLockRegisterTranche(int tranche_id, const char *tranche_name)
Definition: lwlock.c:603
TransactionId latestCompletedXid
Definition: standby.h:77
Definition: type.h:89
#define malloc(a)
Definition: header.h:50
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1726
static uint32 pg_atomic_exchange_u32(volatile pg_atomic_uint32 *ptr, uint32 newval)
Definition: atomics.h:292
bool isBackgroundWorker
Definition: proc.h:120
#define VirtualTransactionIdEquals(vxid1, vxid2)
Definition: lock.h:73
#define xc_by_recent_xmin_inc()
Definition: procarray.c:146
#define xc_by_known_xact_inc()
Definition: procarray.c:147
bool MinimumActiveBackends(int min)
Definition: procarray.c:2704
static void KnownAssignedXidsRemovePreceding(TransactionId xid)
Definition: procarray.c:3855
PGPROC * BackendPidGetProcWithLock(int pid)
Definition: procarray.c:2388
#define SpinLockAcquire(lock)
Definition: spin.h:62
void pg_usleep(long microsec)
Definition: signal.c:53
int SendProcSignal(pid_t pid, ProcSignalReason reason, BackendId backendId)
Definition: procsignal.c:179
void pfree(void *pointer)
Definition: mcxt.c:1056
#define PROC_IN_VACUUM
Definition: proc.h:54
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition: stringinfo.c:91
bool TransactionIdPrecedesOrEquals(TransactionId id1, TransactionId id2)
Definition: transam.c:319
int CountDBConnections(Oid databaseid)
Definition: procarray.c:2788
#define FirstNormalTransactionId
Definition: transam.h:34
#define ERROR
Definition: elog.h:43
void XidCacheRemoveRunningXids(TransactionId xid, int nxids, const TransactionId *xids, TransactionId latestXid)
Definition: procarray.c:3148
TimestampTz GetSnapshotCurrentTimestamp(void)
Definition: snapmgr.c:1720
void ProcArrayClearTransaction(PGPROC *proc)
Definition: procarray.c:601
#define lfirst_int(lc)
Definition: pg_list.h:191
#define PROCARRAY_SLOTS_XMIN
Definition: procarray.h:37
void * ShmemInitStruct(const char *name, Size size, bool *foundPtr)
Definition: shmem.c:372
#define PROCARRAY_PROC_FLAGS_MASK
Definition: procarray.h:44
void ExtendSUBTRANS(TransactionId newestXact)
Definition: subtrans.c:326
void ProcArrayRemove(PGPROC *proc, TransactionId latestXid)
Definition: procarray.c:335
#define FATAL
Definition: elog.h:52
XLogRecPtr GetXLogInsertRecPtr(void)
Definition: xlog.c:11191
void CancelDBBackends(Oid databaseid, ProcSignalReason sigmode, bool conflictPending)
Definition: procarray.c:2819
char * get_database_name(Oid dbid)
Definition: dbcommands.c:2155
#define xc_by_main_xid_inc()
Definition: procarray.c:150
bool LWLockConditionalAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1294
static char * buf
Definition: pg_test_fsync.c:67
bool recoveryConflictPending
Definition: proc.h:127
#define memmove(d, s, c)
Definition: c.h:1267
#define xc_by_known_assigned_inc()
Definition: procarray.c:152
TransactionId RecentGlobalXmin
Definition: snapmgr.c:168
uint8 nxids
Definition: proc.h:238
VariableCache ShmemVariableCache
Definition: varsup.c:34
int maxKnownAssignedXids
Definition: procarray.c:77
#define InvalidTransactionId
Definition: transam.h:31
bool StandbyTransactionIdIsPrepared(TransactionId xid)
Definition: twophase.c:1371
static PGPROC * allProcs
Definition: procarray.c:103
Oid databaseId
Definition: proc.h:114
unsigned int uint32
Definition: c.h:359
TransactionId xmax
Definition: snapshot.h:158
static void pgstat_report_wait_end(void)
Definition: pgstat.h:1342
TransactionId xmin
Definition: snapshot.h:157
static void KnownAssignedXidsReset(void)
Definition: procarray.c:4078
LOCK * waitLock
Definition: proc.h:139
int numKnownAssignedXids
Definition: procarray.c:78
TransactionId RecentGlobalDataXmin
Definition: snapmgr.c:169
static bool * KnownAssignedXidsValid
Definition: procarray.c:110
struct XidCache subxids
Definition: proc.h:162
TransactionId lastOverflowedXid
Definition: procarray.c:90
#define ereport(elevel, rest)
Definition: elog.h:141
bool TransactionIdDidAbort(TransactionId transactionId)
Definition: transam.c:181
#define xc_by_latest_xid_inc()
Definition: procarray.c:149
bool delayChkpt
Definition: proc.h:235
bool superuser_arg(Oid roleid)
Definition: superuser.c:56
#define INVALID_PGPROCNO
Definition: proc.h:77
bool TransactionIdPrecedes(TransactionId id1, TransactionId id2)
Definition: transam.c:300
TransactionId * xip
Definition: snapshot.h:168
static void KnownAssignedXidsRemoveTree(TransactionId xid, int nsubxids, TransactionId *subxids)
Definition: procarray.c:3833
pg_atomic_uint32 procArrayGroupNext
Definition: proc.h:168
List * lappend_int(List *list, int datum)
Definition: list.c:340
Definition: proc.h:244
void initStringInfo(StringInfo str)
Definition: stringinfo.c:59
static ProcArrayStruct * procArray
Definition: procarray.c:101
#define WARNING
Definition: elog.h:40
#define VirtualTransactionIdIsValid(vxid)
Definition: lock.h:70
#define SpinLockRelease(lock)
Definition: spin.h:64
TransactionId replication_slot_xmin
Definition: procarray.c:93
Size mul_size(Size s1, Size s2)
Definition: shmem.c:492
int BackendXidGetPid(TransactionId xid)
Definition: procarray.c:2425
#define InvalidBackendId
Definition: backendid.h:23
static PGXACT * allPgXact
Definition: procarray.c:104
#define RelationIsAccessibleInLogicalDecoding(relation)
Definition: rel.h:578
static int KnownAssignedXidsGet(TransactionId *xarray, TransactionId xmax)
Definition: procarray.c:3933
Size add_size(Size s1, Size s2)
Definition: shmem.c:475
Oid MyDatabaseId
Definition: globals.c:85
static TransactionId KnownAssignedXidsGetOldestXmin(void)
Definition: procarray.c:4005
bool overflowed
Definition: proc.h:234
static void ProcArrayEndTransactionInternal(PGPROC *proc, PGXACT *pgxact, TransactionId latestXid)
Definition: procarray.c:452
#define InvalidOid
Definition: postgres_ext.h:36
CommandId curcid
Definition: snapshot.h:187
int GetMaxSnapshotXidCount(void)
Definition: procarray.c:1452
TransactionId GetOldestXmin(Relation rel, int flags)
Definition: procarray.c:1306
int pgprocnos[FLEXIBLE_ARRAY_MEMBER]
Definition: procarray.c:98
TransactionId xids[PGPROC_MAX_CACHED_SUBXIDS]
Definition: proc.h:40
#define TOTAL_MAX_CACHED_SUBXIDS
#define Assert(condition)
Definition: c.h:739
static TransactionId * KnownAssignedXids
Definition: procarray.c:109
BackendId backendId
Definition: lock.h:64
#define pg_read_barrier()
Definition: atomics.h:158
void CreateSharedProcArray(void)
Definition: procarray.c:224
bool takenDuringRecovery
Definition: snapshot.h:184
size_t Size
Definition: c.h:467
static void pgstat_report_wait_start(uint32 wait_event_info)
Definition: pgstat.h:1318
Snapshot GetSnapshotData(Snapshot snapshot)
Definition: procarray.c:1505
int errdetail_plural(const char *fmt_singular, const char *fmt_plural, unsigned long n,...)
Definition: elog.c:1047
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1122
static int KnownAssignedXidsGetAndSetXmin(TransactionId *xarray, TransactionId *xmin, TransactionId xmax)
Definition: procarray.c:3947
static void KnownAssignedXidsAdd(TransactionId from_xid, TransactionId to_xid, bool exclusive_lock)
Definition: procarray.c:3583
bool ProcArrayInstallRestoredXmin(TransactionId xmin, PGPROC *proc)
Definition: procarray.c:1871
#define NormalTransactionIdPrecedes(id1, id2)
Definition: transam.h:98
#define xc_no_overflow_inc()
Definition: procarray.c:153
bool EnableHotStandby
Definition: xlog.c:93
void PGSemaphoreLock(PGSemaphore sema)
Definition: posix_sema.c:320
static void KnownAssignedXidsCompress(bool force)
Definition: procarray.c:3521
int CountUserBackends(Oid roleid)
Definition: procarray.c:2859
static bool KnownAssignedXidExists(TransactionId xid)
Definition: procarray.c:3794
int pgprocno
Definition: proc.h:110
TransactionId nextXid
Definition: standby.h:75
bool TransactionIdIsActive(TransactionId xid)
Definition: procarray.c:1207
#define xc_slow_answer_inc()
Definition: procarray.c:154
pg_atomic_uint32 procArrayGroupFirst
Definition: proc.h:261
void ProcArrayInitRecovery(TransactionId initializedUptoXID)
Definition: procarray.c:633
uint32 xcnt
Definition: snapshot.h:169
void * palloc(Size size)
Definition: mcxt.c:949
int errmsg(const char *fmt,...)
Definition: elog.c:822
struct ProcArrayStruct ProcArrayStruct
static bool KnownAssignedXidsSearch(TransactionId xid, bool remove)
Definition: procarray.c:3701
static void KnownAssignedXidsRemove(TransactionId xid)
Definition: procarray.c:3807
#define elog(elevel,...)
Definition: elog.h:228
int old_snapshot_threshold
Definition: snapmgr.c:75
#define InvalidLocalTransactionId
Definition: lock.h:68
int i
void ExpireOldKnownAssignedTransactionIds(TransactionId xid)
Definition: procarray.c:3418
TransactionId GetOldestActiveTransactionId(void)
Definition: procarray.c:2111
bool IsBackendPid(int pid)
Definition: procarray.c:2460
#define pg_write_barrier()
Definition: atomics.h:159
ProcSignalReason
Definition: procsignal.h:30
void ProcArraySetReplicationSlotXmin(TransactionId xmin, TransactionId catalog_xmin, bool already_locked)
Definition: procarray.c:3095
int GetMaxSnapshotSubxidCount(void)
Definition: procarray.c:1463
RunningTransactions GetRunningTransactionData(void)
Definition: procarray.c:1937
void ProcArrayApplyXidAssignment(TransactionId topxid, int nsubxids, TransactionId *subxids)
Definition: procarray.c:903
TimestampTz whenTaken
Definition: snapshot.h:202
void TerminateOtherDBBackends(Oid databaseId)
Definition: procarray.c:2987
PGPROC * allProcs
Definition: proc.h:247
#define CHECK_FOR_INTERRUPTS()
Definition: miscadmin.h:99
bool CountOtherDBBackends(Oid databaseId, int *nbackends, int *nprepared)
Definition: procarray.c:2909
CommandId GetCurrentCommandId(bool used)
Definition: xact.c:745
#define qsort(a, b, c, d)
Definition: port.h:488
#define TransactionIdIsValid(xid)
Definition: transam.h:41
static void pg_atomic_write_u32(volatile pg_atomic_uint32 *ptr, uint32 val)
Definition: atomics.h:258
void MaintainOldSnapshotTimeMapping(TimestampTz whenTaken, TransactionId xmin)
Definition: snapmgr.c:1882
PGSemaphore sem
Definition: proc.h:101
bool HaveVirtualXIDsDelayingChkpt(VirtualTransactionId *vxids, int nvxids)
Definition: procarray.c:2318
void RecordKnownAssignedTransactionIds(TransactionId xid)
Definition: procarray.c:3310
#define TransactionIdIsNormal(xid)
Definition: transam.h:42
void SubTransSetParent(TransactionId xid, TransactionId parent)
Definition: subtrans.c:74
bool ProcArrayInstallImportedXmin(TransactionId xmin, VirtualTransactionId *sourcevxid)
Definition: procarray.c:1796
int tailKnownAssignedXids
Definition: procarray.c:79
static TransactionId standbySnapshotPendingXmin
Definition: procarray.c:118
Definition: proc.h:95
Definition: pg_list.h:50
int pid
Definition: proc.h:109
HotStandbyState standbyState
Definition: xlog.c:203
void ProcArrayAdd(PGPROC *proc)
Definition: procarray.c:277
#define PROC_IS_AUTOVACUUM
Definition: proc.h:53
#define offsetof(type, field)
Definition: c.h:662
TransactionId procArrayGroupMemberXid
Definition: proc.h:174
Size ProcArrayShmemSize(void)
Definition: procarray.c:182
void StandbyReleaseOldLocks(TransactionId oldxid)
Definition: standby.c:751
TransactionId * subxip
Definition: snapshot.h:180
uint32 active_count
Definition: snapshot.h:198
int headKnownAssignedXids
Definition: procarray.c:80
int xidComparator(const void *arg1, const void *arg2)
Definition: xid.c:138
static uint32 pg_atomic_read_u32(volatile pg_atomic_uint32 *ptr)
Definition: atomics.h:241
int32 subxcnt
Definition: snapshot.h:181
LocalTransactionId lxid
Definition: proc.h:106
TransactionId latestCompletedXid
Definition: transam.h:182