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