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