#include "postgres.h"
#include <signal.h>
#include "access/clog.h"
#include "access/subtrans.h"
#include "access/transam.h"
#include "access/twophase.h"
#include "access/xact.h"
#include "access/xlog.h"
#include "catalog/catalog.h"
#include "catalog/pg_authid.h"
#include "commands/dbcommands.h"
#include "miscadmin.h"
#include "pgstat.h"
#include "storage/proc.h"
#include "storage/procarray.h"
#include "storage/spin.h"
#include "utils/acl.h"
#include "utils/builtins.h"
#include "utils/rel.h"
#include "utils/snapmgr.h"

Include dependency graph for procarray.c:

Data Structures
struct	ProcArrayStruct

struct	GlobalVisState

struct	ComputeXidHorizonsResult

Macros
#define	UINT32_ACCESS_ONCE(var) ((uint32)(((volatile uint32 )&(var))))

#define	xc_by_recent_xmin_inc() ((void) 0)

#define	xc_by_known_xact_inc() ((void) 0)

#define	xc_by_my_xact_inc() ((void) 0)

#define	xc_by_latest_xid_inc() ((void) 0)

#define	xc_by_main_xid_inc() ((void) 0)

#define	xc_by_child_xid_inc() ((void) 0)

#define	xc_by_known_assigned_inc() ((void) 0)

#define	xc_no_overflow_inc() ((void) 0)

#define	xc_slow_answer_inc() ((void) 0)

#define	PROCARRAY_MAXPROCS (MaxBackends + max_prepared_xacts)

#define	TOTAL_MAX_CACHED_SUBXIDS ((PGPROC_MAX_CACHED_SUBXIDS + 1) * PROCARRAY_MAXPROCS)

#define	MAXAUTOVACPIDS 10 /* max autovacs to SIGTERM per iteration */

Typedefs
typedef struct ProcArrayStruct	ProcArrayStruct

typedef struct ComputeXidHorizonsResult	ComputeXidHorizonsResult

Functions
static void	KnownAssignedXidsCompress (bool force)

static void	KnownAssignedXidsAdd (TransactionId from_xid, TransactionId to_xid, bool exclusive_lock)

static bool	KnownAssignedXidsSearch (TransactionId xid, bool remove)

static bool	KnownAssignedXidExists (TransactionId xid)

static void	KnownAssignedXidsRemove (TransactionId xid)

static void	KnownAssignedXidsRemoveTree (TransactionId xid, int nsubxids, TransactionId *subxids)

static void	KnownAssignedXidsRemovePreceding (TransactionId xid)

static int	KnownAssignedXidsGet (TransactionId *xarray, TransactionId xmax)

static int	KnownAssignedXidsGetAndSetXmin (TransactionId xarray, TransactionId xmin, TransactionId xmax)

static TransactionId	KnownAssignedXidsGetOldestXmin (void)

static void	KnownAssignedXidsDisplay (int trace_level)

static void	KnownAssignedXidsReset (void)

static void	ProcArrayEndTransactionInternal (PGPROC *proc, TransactionId latestXid)

static void	ProcArrayGroupClearXid (PGPROC *proc, TransactionId latestXid)

static void	MaintainLatestCompletedXid (TransactionId latestXid)

static void	MaintainLatestCompletedXidRecovery (TransactionId latestXid)

static FullTransactionId	FullXidRelativeTo (FullTransactionId rel, TransactionId xid)

static void	GlobalVisUpdateApply (ComputeXidHorizonsResult *horizons)

Size	ProcArrayShmemSize (void)

void	CreateSharedProcArray (void)

void	ProcArrayAdd (PGPROC *proc)

void	ProcArrayRemove (PGPROC *proc, TransactionId latestXid)

void	ProcArrayEndTransaction (PGPROC *proc, TransactionId latestXid)

void	ProcArrayClearTransaction (PGPROC *proc)

void	ProcArrayInitRecovery (TransactionId initializedUptoXID)

void	ProcArrayApplyRecoveryInfo (RunningTransactions running)

void	ProcArrayApplyXidAssignment (TransactionId topxid, int nsubxids, TransactionId *subxids)

bool	TransactionIdIsInProgress (TransactionId xid)

bool	TransactionIdIsActive (TransactionId xid)

static void	ComputeXidHorizons (ComputeXidHorizonsResult *h)

TransactionId	GetOldestNonRemovableTransactionId (Relation rel)

TransactionId	GetOldestTransactionIdConsideredRunning (void)

void	GetReplicationHorizons (TransactionId xmin, TransactionId catalog_xmin)

int	GetMaxSnapshotXidCount (void)

int	GetMaxSnapshotSubxidCount (void)

static void	GetSnapshotDataInitOldSnapshot (Snapshot snapshot)

static bool	GetSnapshotDataReuse (Snapshot snapshot)

Snapshot	GetSnapshotData (Snapshot snapshot)

bool	ProcArrayInstallImportedXmin (TransactionId xmin, VirtualTransactionId *sourcevxid)

bool	ProcArrayInstallRestoredXmin (TransactionId xmin, PGPROC *proc)

RunningTransactions	GetRunningTransactionData (void)

TransactionId	GetOldestActiveTransactionId (void)

TransactionId	GetOldestSafeDecodingTransactionId (bool catalogOnly)

VirtualTransactionId *	GetVirtualXIDsDelayingChkpt (int *nvxids)

bool	HaveVirtualXIDsDelayingChkpt (VirtualTransactionId *vxids, int nvxids)

PGPROC *	BackendPidGetProc (int pid)

PGPROC *	BackendPidGetProcWithLock (int pid)

int	BackendXidGetPid (TransactionId xid)

bool	IsBackendPid (int pid)

VirtualTransactionId *	GetCurrentVirtualXIDs (TransactionId limitXmin, bool excludeXmin0, bool allDbs, int excludeVacuum, int *nvxids)

VirtualTransactionId *	GetConflictingVirtualXIDs (TransactionId limitXmin, Oid dbOid)

pid_t	CancelVirtualTransaction (VirtualTransactionId vxid, ProcSignalReason sigmode)

pid_t	SignalVirtualTransaction (VirtualTransactionId vxid, ProcSignalReason sigmode, bool conflictPending)

bool	MinimumActiveBackends (int min)

int	CountDBBackends (Oid databaseid)

int	CountDBConnections (Oid databaseid)

void	CancelDBBackends (Oid databaseid, ProcSignalReason sigmode, bool conflictPending)

int	CountUserBackends (Oid roleid)

bool	CountOtherDBBackends (Oid databaseId, int nbackends, int nprepared)

void	TerminateOtherDBBackends (Oid databaseId)

void	ProcArraySetReplicationSlotXmin (TransactionId xmin, TransactionId catalog_xmin, bool already_locked)

void	ProcArrayGetReplicationSlotXmin (TransactionId xmin, TransactionId catalog_xmin)

void	XidCacheRemoveRunningXids (TransactionId xid, int nxids, const TransactionId *xids, TransactionId latestXid)

GlobalVisState *	GlobalVisTestFor (Relation rel)

static bool	GlobalVisTestShouldUpdate (GlobalVisState *state)

static void	GlobalVisUpdate (void)

bool	GlobalVisTestIsRemovableFullXid (GlobalVisState *state, FullTransactionId fxid)

bool	GlobalVisTestIsRemovableXid (GlobalVisState *state, TransactionId xid)

FullTransactionId	GlobalVisTestNonRemovableFullHorizon (GlobalVisState *state)

TransactionId	GlobalVisTestNonRemovableHorizon (GlobalVisState *state)

bool	GlobalVisCheckRemovableFullXid (Relation rel, FullTransactionId fxid)

bool	GlobalVisCheckRemovableXid (Relation rel, TransactionId xid)

void	RecordKnownAssignedTransactionIds (TransactionId xid)

void	ExpireTreeKnownAssignedTransactionIds (TransactionId xid, int nsubxids, TransactionId *subxids, TransactionId max_xid)

void	ExpireAllKnownAssignedTransactionIds (void)

void	ExpireOldKnownAssignedTransactionIds (TransactionId xid)

Variables
static ProcArrayStruct *	procArray

static PGPROC *	allProcs

static TransactionId *	KnownAssignedXids

static bool *	KnownAssignedXidsValid

static TransactionId	latestObservedXid = InvalidTransactionId

static TransactionId	standbySnapshotPendingXmin

static GlobalVisState	GlobalVisSharedRels

static GlobalVisState	GlobalVisCatalogRels

static GlobalVisState	GlobalVisDataRels

static GlobalVisState	GlobalVisTempRels

static TransactionId	ComputeXidHorizonsResultLastXmin

Macro Definition Documentation

◆ MAXAUTOVACPIDS

#define MAXAUTOVACPIDS 10 /* max autovacs to SIGTERM per iteration */

Referenced by CountOtherDBBackends().

◆ PROCARRAY_MAXPROCS

#define PROCARRAY_MAXPROCS (MaxBackends + max_prepared_xacts)

Referenced by CreateSharedProcArray(), KnownAssignedXidsCompress(), and ProcArrayShmemSize().

◆ TOTAL_MAX_CACHED_SUBXIDS

#define TOTAL_MAX_CACHED_SUBXIDS ((PGPROC_MAX_CACHED_SUBXIDS + 1) * PROCARRAY_MAXPROCS)

Referenced by CreateSharedProcArray(), GetMaxSnapshotSubxidCount(), GetRunningTransactionData(), ProcArrayShmemSize(), and TransactionIdIsInProgress().

◆ UINT32_ACCESS_ONCE

#define UINT32_ACCESS_ONCE ( var ) ((uint32)(*((volatile uint32 *)&(var))))

Definition at line 69 of file procarray.c.

Referenced by ComputeXidHorizons(), GetConflictingVirtualXIDs(), GetCurrentVirtualXIDs(), GetOldestActiveTransactionId(), GetOldestSafeDecodingTransactionId(), GetRunningTransactionData(), GetSnapshotData(), ProcArrayInstallImportedXmin(), ProcArrayInstallRestoredXmin(), TransactionIdIsActive(), and TransactionIdIsInProgress().

◆ xc_by_child_xid_inc

#define xc_by_child_xid_inc ( ) ((void) 0)

Definition at line 316 of file procarray.c.

Referenced by TransactionIdIsInProgress().

◆ xc_by_known_assigned_inc

#define xc_by_known_assigned_inc ( ) ((void) 0)

Definition at line 317 of file procarray.c.

Referenced by TransactionIdIsInProgress().

◆ xc_by_known_xact_inc

#define xc_by_known_xact_inc ( ) ((void) 0)

Definition at line 312 of file procarray.c.

Referenced by TransactionIdIsInProgress().

◆ xc_by_latest_xid_inc

#define xc_by_latest_xid_inc ( ) ((void) 0)

Definition at line 314 of file procarray.c.

Referenced by TransactionIdIsInProgress().

◆ xc_by_main_xid_inc

#define xc_by_main_xid_inc ( ) ((void) 0)

Definition at line 315 of file procarray.c.

Referenced by TransactionIdIsInProgress().

◆ xc_by_my_xact_inc

#define xc_by_my_xact_inc ( ) ((void) 0)

Definition at line 313 of file procarray.c.

Referenced by TransactionIdIsInProgress().

◆ xc_by_recent_xmin_inc

#define xc_by_recent_xmin_inc ( ) ((void) 0)

Definition at line 311 of file procarray.c.

Referenced by TransactionIdIsInProgress().

◆ xc_no_overflow_inc

#define xc_no_overflow_inc ( ) ((void) 0)

Definition at line 318 of file procarray.c.

Referenced by TransactionIdIsInProgress().

◆ xc_slow_answer_inc

#define xc_slow_answer_inc ( ) ((void) 0)

Definition at line 319 of file procarray.c.

Referenced by TransactionIdIsInProgress().

Typedef Documentation

◆ ComputeXidHorizonsResult

typedef struct ComputeXidHorizonsResult ComputeXidHorizonsResult

◆ ProcArrayStruct

typedef struct ProcArrayStruct ProcArrayStruct

Function Documentation

◆ BackendPidGetProc()

PGPROC* BackendPidGetProc ( int pid )

Definition at line 3062 of file procarray.c.

References BackendPidGetProcWithLock(), LW_SHARED, LWLockAcquire(), and LWLockRelease().

Referenced by IsBackendPid(), pg_signal_backend(), pg_stat_get_activity(), pg_stat_get_backend_wait_event(), pg_stat_get_backend_wait_event_type(), ProcSendSignal(), TerminateOtherDBBackends(), and test_shm_mq_main().

 {
     PGPROC     *result;
 
     if (pid == 0)               /* never match dummy PGPROCs */
         return NULL;
 
     LWLockAcquire(ProcArrayLock, LW_SHARED);
 
     result = BackendPidGetProcWithLock(pid);
 
     LWLockRelease(ProcArrayLock);
 
     return result;
 }

◆ BackendPidGetProcWithLock()

PGPROC* BackendPidGetProcWithLock ( int pid )

Definition at line 3085 of file procarray.c.

References ProcArrayStruct::numProcs, ProcArrayStruct::pgprocnos, PGPROC::pid, and procArray.

Referenced by BackendPidGetProc(), and GetBlockerStatusData().

 {
     PGPROC     *result = NULL;
     ProcArrayStruct *arrayP = procArray;
     int         index;
 
     if (pid == 0)               /* never match dummy PGPROCs */
         return NULL;
 
     for (index = 0; index < arrayP->numProcs; index++)
     {
         PGPROC     *proc = &allProcs[arrayP->pgprocnos[index]];
 
         if (proc->pid == pid)
         {
             result = proc;
             break;
         }
     }
 
     return result;
 }

◆ BackendXidGetPid()

int BackendXidGetPid ( TransactionId xid )

Definition at line 3122 of file procarray.c.

References InvalidTransactionId, LW_SHARED, LWLockAcquire(), LWLockRelease(), ProcArrayStruct::numProcs, ProcArrayStruct::pgprocnos, PGPROC::pid, procArray, ProcGlobal, and PROC_HDR::xids.

Referenced by pgrowlocks().

 {
     int         result = 0;
     ProcArrayStruct *arrayP = procArray;
     TransactionId *other_xids = ProcGlobal->xids;
     int         index;
 
     if (xid == InvalidTransactionId)    /* never match invalid xid */
         return 0;
 
     LWLockAcquire(ProcArrayLock, LW_SHARED);
 
     for (index = 0; index < arrayP->numProcs; index++)
     {
         int         pgprocno = arrayP->pgprocnos[index];
         PGPROC     *proc = &allProcs[pgprocno];
 
         if (other_xids[index] == xid)
         {
             result = proc->pid;
             break;
         }
     }
 
     LWLockRelease(ProcArrayLock);
 
     return result;
 }

◆ CancelDBBackends()

void CancelDBBackends	(	Oid	databaseid,
		ProcSignalReason	sigmode,
		bool	conflictPending
	)

Definition at line 3521 of file procarray.c.

References VirtualTransactionId::backendId, PGPROC::databaseId, GET_VXID_FROM_PGPROC, InvalidOid, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), ProcArrayStruct::numProcs, ProcArrayStruct::pgprocnos, PGPROC::pid, procArray, PGPROC::recoveryConflictPending, and SendProcSignal().

Referenced by ResolveRecoveryConflictWithDatabase(), and SendRecoveryConflictWithBufferPin().

 {
     ProcArrayStruct *arrayP = procArray;
     int         index;
 
     /* tell all backends to die */
     LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
 
     for (index = 0; index < arrayP->numProcs; index++)
     {
         int         pgprocno = arrayP->pgprocnos[index];
         PGPROC     *proc = &allProcs[pgprocno];
 
         if (databaseid == InvalidOid || proc->databaseId == databaseid)
         {
             VirtualTransactionId procvxid;
             pid_t       pid;
 
             GET_VXID_FROM_PGPROC(procvxid, *proc);
 
             proc->recoveryConflictPending = conflictPending;
             pid = proc->pid;
             if (pid != 0)
             {
                 /*
                  * Kill the pid if it's still here. If not, that's what we
                  * wanted so ignore any errors.
                  */
                 (void) SendProcSignal(pid, sigmode, procvxid.backendId);
             }
         }
     }
 
     LWLockRelease(ProcArrayLock);
 }

◆ CancelVirtualTransaction()

pid_t CancelVirtualTransaction	(	VirtualTransactionId	vxid,
		ProcSignalReason	sigmode
	)

Definition at line 3352 of file procarray.c.

References SignalVirtualTransaction().

Referenced by ResolveRecoveryConflictWithVirtualXIDs().

 {
     return SignalVirtualTransaction(vxid, sigmode, true);
 }

◆ ComputeXidHorizons()

static void ComputeXidHorizons ( ComputeXidHorizonsResult * h )

static

Definition at line 1662 of file procarray.c.

Referenced by GetOldestNonRemovableTransactionId(), GetOldestTransactionIdConsideredRunning(), GetReplicationHorizons(), and GlobalVisUpdate().

 {
     ProcArrayStruct *arrayP = procArray;
     TransactionId kaxmin;
     bool        in_recovery = RecoveryInProgress();
     TransactionId *other_xids = ProcGlobal->xids;
 
     LWLockAcquire(ProcArrayLock, LW_SHARED);
 
     h->latest_completed = ShmemVariableCache->latestCompletedXid;
 
     /*
      * We initialize the MIN() calculation with latestCompletedXid + 1. This
      * is a lower bound for the XIDs that might appear in the ProcArray later,
      * and so protects us against overestimating the result due to future
      * additions.
      */
     {
         TransactionId initial;
 
         initial = XidFromFullTransactionId(h->latest_completed);
         Assert(TransactionIdIsValid(initial));
         TransactionIdAdvance(initial);
 
         h->oldest_considered_running = initial;
         h->shared_oldest_nonremovable = initial;
         h->catalog_oldest_nonremovable = initial;
         h->data_oldest_nonremovable = initial;
 
         /*
          * Only modifications made by this backend affect the horizon for
          * temporary relations. Instead of a check in each iteration of the
          * loop over all PGPROCs it is cheaper to just initialize to the
          * current top-level xid any.
          *
          * Without an assigned xid we could use a horizon as aggressive as
          * ReadNewTransactionid(), but we can get away with the much cheaper
          * latestCompletedXid + 1: If this backend has no xid there, by
          * definition, can't be any newer changes in the temp table than
          * latestCompletedXid.
          */
         if (TransactionIdIsValid(MyProc->xid))
             h->temp_oldest_nonremovable = MyProc->xid;
         else
             h->temp_oldest_nonremovable = initial;
     }
 
     /*
      * Fetch slot horizons while ProcArrayLock is held - the
      * LWLockAcquire/LWLockRelease are a barrier, ensuring this happens inside
      * the lock.
      */
     h->slot_xmin = procArray->replication_slot_xmin;
     h->slot_catalog_xmin = procArray->replication_slot_catalog_xmin;
 
     for (int index = 0; index < arrayP->numProcs; index++)
     {
         int         pgprocno = arrayP->pgprocnos[index];
         PGPROC     *proc = &allProcs[pgprocno];
         int8        statusFlags = ProcGlobal->statusFlags[index];
         TransactionId xid;
         TransactionId xmin;
 
         /* Fetch xid just once - see GetNewTransactionId */
         xid = UINT32_ACCESS_ONCE(other_xids[index]);
         xmin = UINT32_ACCESS_ONCE(proc->xmin);
 
         /*
          * Consider both the transaction's Xmin, and its Xid.
          *
          * We must check both because a transaction might have an Xmin but not
          * (yet) an Xid; conversely, if it has an Xid, that could determine
          * some not-yet-set Xmin.
          */
         xmin = TransactionIdOlder(xmin, xid);
 
         /* if neither is set, this proc doesn't influence the horizon */
         if (!TransactionIdIsValid(xmin))
             continue;
 
         /*
          * Don't ignore any procs when determining which transactions might be
          * considered running.  While slots should ensure logical decoding
          * backends are protected even without this check, it can't hurt to
          * include them here as well..
          */
         h->oldest_considered_running =
             TransactionIdOlder(h->oldest_considered_running, xmin);
 
         /*
          * Skip over backends either vacuuming (which is ok with rows being
          * removed, as long as pg_subtrans is not truncated) or doing logical
          * decoding (which manages xmin separately, check below).
          */
         if (statusFlags & (PROC_IN_VACUUM | PROC_IN_LOGICAL_DECODING))
             continue;
 
         /* shared tables need to take backends in all databases into account */
         h->shared_oldest_nonremovable =
             TransactionIdOlder(h->shared_oldest_nonremovable, xmin);
 
         /*
          * Normally queries in other databases are ignored for anything but
          * the shared horizon. But in recovery we cannot compute an accurate
          * per-database horizon as all xids are managed via the
          * KnownAssignedXids machinery.
          *
          * Be careful to compute a pessimistic value when MyDatabaseId is not
          * set. If this is a backend in the process of starting up, we may not
          * use a "too aggressive" horizon (otherwise we could end up using it
          * to prune still needed data away). If the current backend never
          * connects to a database that is harmless, because
          * data_oldest_nonremovable will never be utilized.
          */
         if (in_recovery ||
             MyDatabaseId == InvalidOid || proc->databaseId == MyDatabaseId ||
             proc->databaseId == 0)  /* always include WalSender */
         {
             /*
              * We can ignore this backend if it's running CREATE INDEX
              * CONCURRENTLY or REINDEX CONCURRENTLY on a "safe" index -- but
              * only on vacuums of user-defined tables.
              */
             if (!(statusFlags & PROC_IN_SAFE_IC))
                 h->data_oldest_nonremovable =
                     TransactionIdOlder(h->data_oldest_nonremovable, xmin);
 
             /* Catalog tables need to consider all backends in this db */
             h->catalog_oldest_nonremovable =
                 TransactionIdOlder(h->catalog_oldest_nonremovable, xmin);
 
         }
     }
 
     /* catalog horizon should never be later than data */
     Assert(TransactionIdPrecedesOrEquals(h->catalog_oldest_nonremovable,
                                          h->data_oldest_nonremovable));
 
     /*
      * If in recovery fetch oldest xid in KnownAssignedXids, will be applied
      * after lock is released.
      */
     if (in_recovery)
         kaxmin = KnownAssignedXidsGetOldestXmin();
 
     /*
      * No other information from shared state is needed, release the lock
      * immediately. The rest of the computations can be done without a lock.
      */
     LWLockRelease(ProcArrayLock);
 
     if (in_recovery)
     {
         h->oldest_considered_running =
             TransactionIdOlder(h->oldest_considered_running, kaxmin);
         h->shared_oldest_nonremovable =
             TransactionIdOlder(h->shared_oldest_nonremovable, kaxmin);
         h->data_oldest_nonremovable =
             TransactionIdOlder(h->data_oldest_nonremovable, kaxmin);
         h->catalog_oldest_nonremovable =
             TransactionIdOlder(h->catalog_oldest_nonremovable, kaxmin);
         /* temp relations cannot be accessed in recovery */
     }
     else
     {
         /*
          * Compute the cutoff XID by subtracting vacuum_defer_cleanup_age.
          *
          * vacuum_defer_cleanup_age provides some additional "slop" for the
          * benefit of hot standby queries on standby servers.  This is quick
          * and dirty, and perhaps not all that useful unless the primary has a
          * predictable transaction rate, but it offers some protection when
          * there's no walsender connection.  Note that we are assuming
          * vacuum_defer_cleanup_age isn't large enough to cause wraparound ---
          * so guc.c should limit it to no more than the xidStopLimit threshold
          * in varsup.c.  Also note that we intentionally don't apply
          * vacuum_defer_cleanup_age on standby servers.
          */
         h->oldest_considered_running =
             TransactionIdRetreatedBy(h->oldest_considered_running,
                                      vacuum_defer_cleanup_age);
         h->shared_oldest_nonremovable =
             TransactionIdRetreatedBy(h->shared_oldest_nonremovable,
                                      vacuum_defer_cleanup_age);
         h->data_oldest_nonremovable =
             TransactionIdRetreatedBy(h->data_oldest_nonremovable,
                                      vacuum_defer_cleanup_age);
         h->catalog_oldest_nonremovable =
             TransactionIdRetreatedBy(h->catalog_oldest_nonremovable,
                                      vacuum_defer_cleanup_age);
         /* defer doesn't apply to temp relations */
     }
 
     /*
      * Check whether there are replication slots requiring an older xmin.
      */
     h->shared_oldest_nonremovable =
         TransactionIdOlder(h->shared_oldest_nonremovable, h->slot_xmin);
     h->data_oldest_nonremovable =
         TransactionIdOlder(h->data_oldest_nonremovable, h->slot_xmin);
 
     /*
      * The only difference between catalog / data horizons is that the slot's
      * catalog xmin is applied to the catalog one (so catalogs can be accessed
      * for logical decoding). Initialize with data horizon, and then back up
      * further if necessary. Have to back up the shared horizon as well, since
      * that also can contain catalogs.
      */
     h->shared_oldest_nonremovable_raw = h->shared_oldest_nonremovable;
     h->shared_oldest_nonremovable =
         TransactionIdOlder(h->shared_oldest_nonremovable,
                            h->slot_catalog_xmin);
     h->catalog_oldest_nonremovable =
         TransactionIdOlder(h->catalog_oldest_nonremovable,
                            h->slot_xmin);
     h->catalog_oldest_nonremovable =
         TransactionIdOlder(h->catalog_oldest_nonremovable,
                            h->slot_catalog_xmin);
 
     /*
      * It's possible that slots / vacuum_defer_cleanup_age backed up the
      * horizons further than oldest_considered_running. Fix.
      */
     h->oldest_considered_running =
         TransactionIdOlder(h->oldest_considered_running,
                            h->shared_oldest_nonremovable);
     h->oldest_considered_running =
         TransactionIdOlder(h->oldest_considered_running,
                            h->catalog_oldest_nonremovable);
     h->oldest_considered_running =
         TransactionIdOlder(h->oldest_considered_running,
                            h->data_oldest_nonremovable);
 
     /*
      * shared horizons have to be at least as old as the oldest visible in
      * current db
      */
     Assert(TransactionIdPrecedesOrEquals(h->shared_oldest_nonremovable,
                                          h->data_oldest_nonremovable));
     Assert(TransactionIdPrecedesOrEquals(h->shared_oldest_nonremovable,
                                          h->catalog_oldest_nonremovable));
 
     /*
      * Horizons need to ensure that pg_subtrans access is still possible for
      * the relevant backends.
      */
     Assert(TransactionIdPrecedesOrEquals(h->oldest_considered_running,
                                          h->shared_oldest_nonremovable));
     Assert(TransactionIdPrecedesOrEquals(h->oldest_considered_running,
                                          h->catalog_oldest_nonremovable));
     Assert(TransactionIdPrecedesOrEquals(h->oldest_considered_running,
                                          h->data_oldest_nonremovable));
     Assert(TransactionIdPrecedesOrEquals(h->oldest_considered_running,
                                          h->temp_oldest_nonremovable));
     Assert(!TransactionIdIsValid(h->slot_xmin) ||
            TransactionIdPrecedesOrEquals(h->oldest_considered_running,
                                          h->slot_xmin));
     Assert(!TransactionIdIsValid(h->slot_catalog_xmin) ||
            TransactionIdPrecedesOrEquals(h->oldest_considered_running,
                                          h->slot_catalog_xmin));
 
     /* update approximate horizons with the computed horizons */
     GlobalVisUpdateApply(h);
 }

◆ CountDBBackends()

int CountDBBackends ( Oid databaseid )

Definition at line 3460 of file procarray.c.

References PGPROC::databaseId, LW_SHARED, LWLockAcquire(), LWLockRelease(), ProcArrayStruct::numProcs, OidIsValid, ProcArrayStruct::pgprocnos, PGPROC::pid, and procArray.

Referenced by ResolveRecoveryConflictWithDatabase().

 {
     ProcArrayStruct *arrayP = procArray;
     int         count = 0;
     int         index;
 
     LWLockAcquire(ProcArrayLock, LW_SHARED);
 
     for (index = 0; index < arrayP->numProcs; index++)
     {
         int         pgprocno = arrayP->pgprocnos[index];
         PGPROC     *proc = &allProcs[pgprocno];
 
         if (proc->pid == 0)
             continue;           /* do not count prepared xacts */
         if (!OidIsValid(databaseid) ||
             proc->databaseId == databaseid)
             count++;
     }
 
     LWLockRelease(ProcArrayLock);
 
     return count;
 }

◆ CountDBConnections()

int CountDBConnections ( Oid databaseid )

Definition at line 3490 of file procarray.c.

References PGPROC::databaseId, PGPROC::isBackgroundWorker, LW_SHARED, LWLockAcquire(), LWLockRelease(), ProcArrayStruct::numProcs, OidIsValid, ProcArrayStruct::pgprocnos, PGPROC::pid, and procArray.

Referenced by CheckMyDatabase().

 {
     ProcArrayStruct *arrayP = procArray;
     int         count = 0;
     int         index;
 
     LWLockAcquire(ProcArrayLock, LW_SHARED);
 
     for (index = 0; index < arrayP->numProcs; index++)
     {
         int         pgprocno = arrayP->pgprocnos[index];
         PGPROC     *proc = &allProcs[pgprocno];
 
         if (proc->pid == 0)
             continue;           /* do not count prepared xacts */
         if (proc->isBackgroundWorker)
             continue;           /* do not count background workers */
         if (!OidIsValid(databaseid) ||
             proc->databaseId == databaseid)
             count++;
     }
 
     LWLockRelease(ProcArrayLock);
 
     return count;
 }

◆ CountOtherDBBackends()

bool CountOtherDBBackends	(	Oid	databaseId,
		int *	nbackends,
		int *	nprepared
	)

Definition at line 3611 of file procarray.c.

References CHECK_FOR_INTERRUPTS, PGPROC::databaseId, kill, LW_SHARED, LWLockAcquire(), LWLockRelease(), MAXAUTOVACPIDS, MyProc, ProcArrayStruct::numProcs, pg_usleep(), ProcArrayStruct::pgprocnos, PGPROC::pid, PROC_IS_AUTOVACUUM, procArray, ProcGlobal, and PROC_HDR::statusFlags.

Referenced by createdb(), dropdb(), movedb(), and RenameDatabase().

 {
     ProcArrayStruct *arrayP = procArray;
 
 #define MAXAUTOVACPIDS  10      /* max autovacs to SIGTERM per iteration */
     int         autovac_pids[MAXAUTOVACPIDS];
     int         tries;
 
     /* 50 tries with 100ms sleep between tries makes 5 sec total wait */
     for (tries = 0; tries < 50; tries++)
     {
         int         nautovacs = 0;
         bool        found = false;
         int         index;
 
         CHECK_FOR_INTERRUPTS();
 
         *nbackends = *nprepared = 0;
 
         LWLockAcquire(ProcArrayLock, LW_SHARED);
 
         for (index = 0; index < arrayP->numProcs; index++)
         {
             int         pgprocno = arrayP->pgprocnos[index];
             PGPROC     *proc = &allProcs[pgprocno];
             uint8       statusFlags = ProcGlobal->statusFlags[index];
 
             if (proc->databaseId != databaseId)
                 continue;
             if (proc == MyProc)
                 continue;
 
             found = true;
 
             if (proc->pid == 0)
                 (*nprepared)++;
             else
             {
                 (*nbackends)++;
                 if ((statusFlags & PROC_IS_AUTOVACUUM) &&
                     nautovacs < MAXAUTOVACPIDS)
                     autovac_pids[nautovacs++] = proc->pid;
             }
         }
 
         LWLockRelease(ProcArrayLock);
 
         if (!found)
             return false;       /* no conflicting backends, so done */
 
         /*
          * Send SIGTERM to any conflicting autovacuums before sleeping. We
          * postpone this step until after the loop because we don't want to
          * hold ProcArrayLock while issuing kill(). We have no idea what might
          * block kill() inside the kernel...
          */
         for (index = 0; index < nautovacs; index++)
             (void) kill(autovac_pids[index], SIGTERM);  /* ignore any error */
 
         /* sleep, then try again */
         pg_usleep(100 * 1000L); /* 100ms */
     }
 
     return true;                /* timed out, still conflicts */
 }

◆ CountUserBackends()

int CountUserBackends ( Oid roleid )

Definition at line 3561 of file procarray.c.

References PGPROC::isBackgroundWorker, LW_SHARED, LWLockAcquire(), LWLockRelease(), ProcArrayStruct::numProcs, ProcArrayStruct::pgprocnos, PGPROC::pid, procArray, and PGPROC::roleId.

Referenced by InitializeSessionUserId().

 {
     ProcArrayStruct *arrayP = procArray;
     int         count = 0;
     int         index;
 
     LWLockAcquire(ProcArrayLock, LW_SHARED);
 
     for (index = 0; index < arrayP->numProcs; index++)
     {
         int         pgprocno = arrayP->pgprocnos[index];
         PGPROC     *proc = &allProcs[pgprocno];
 
         if (proc->pid == 0)
             continue;           /* do not count prepared xacts */
         if (proc->isBackgroundWorker)
             continue;           /* do not count background workers */
         if (proc->roleId == roleid)
             count++;
     }
 
     LWLockRelease(ProcArrayLock);
 
     return count;
 }

◆ CreateSharedProcArray()

void CreateSharedProcArray ( void )

Definition at line 394 of file procarray.c.

References add_size(), PROC_HDR::allProcs, EnableHotStandby, ProcArrayStruct::headKnownAssignedXids, InvalidTransactionId, ProcArrayStruct::known_assigned_xids_lck, KnownAssignedXids, KnownAssignedXidsValid, ProcArrayStruct::lastOverflowedXid, ProcArrayStruct::maxKnownAssignedXids, ProcArrayStruct::maxProcs, mul_size(), ProcArrayStruct::numKnownAssignedXids, ProcArrayStruct::numProcs, offsetof, ProcArrayStruct::pgprocnos, PROCARRAY_MAXPROCS, ProcGlobal, ProcArrayStruct::replication_slot_catalog_xmin, ProcArrayStruct::replication_slot_xmin, ShmemInitStruct(), ShmemVariableCache, SpinLockInit, ProcArrayStruct::tailKnownAssignedXids, TOTAL_MAX_CACHED_SUBXIDS, and VariableCacheData::xactCompletionCount.

Referenced by CreateSharedMemoryAndSemaphores().

 {
     bool        found;
 
     /* Create or attach to the ProcArray shared structure */
     procArray = (ProcArrayStruct *)
         ShmemInitStruct("Proc Array",
                         add_size(offsetof(ProcArrayStruct, pgprocnos),
                                  mul_size(sizeof(int),
                                           PROCARRAY_MAXPROCS)),
                         &found);
 
     if (!found)
     {
         /*
          * We're the first - initialize.
          */
         procArray->numProcs = 0;
         procArray->maxProcs = PROCARRAY_MAXPROCS;
         procArray->maxKnownAssignedXids = TOTAL_MAX_CACHED_SUBXIDS;
         procArray->numKnownAssignedXids = 0;
         procArray->tailKnownAssignedXids = 0;
         procArray->headKnownAssignedXids = 0;
         SpinLockInit(&procArray->known_assigned_xids_lck);
         procArray->lastOverflowedXid = InvalidTransactionId;
         procArray->replication_slot_xmin = InvalidTransactionId;
         procArray->replication_slot_catalog_xmin = InvalidTransactionId;
         ShmemVariableCache->xactCompletionCount = 1;
     }
 
     allProcs = ProcGlobal->allProcs;
 
     /* Create or attach to the KnownAssignedXids arrays too, if needed */
     if (EnableHotStandby)
     {
         KnownAssignedXids = (TransactionId *)
             ShmemInitStruct("KnownAssignedXids",
                             mul_size(sizeof(TransactionId),
                                      TOTAL_MAX_CACHED_SUBXIDS),
                             &found);
         KnownAssignedXidsValid = (bool *)
             ShmemInitStruct("KnownAssignedXidsValid",
                             mul_size(sizeof(bool), TOTAL_MAX_CACHED_SUBXIDS),
                             &found);
     }
 }

◆ ExpireAllKnownAssignedTransactionIds()

void ExpireAllKnownAssignedTransactionIds ( void )

Definition at line 4389 of file procarray.c.

References InvalidTransactionId, KnownAssignedXidsRemovePreceding(), LW_EXCLUSIVE, LWLockAcquire(), and LWLockRelease().

Referenced by ShutdownRecoveryTransactionEnvironment().

 {
     LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
     KnownAssignedXidsRemovePreceding(InvalidTransactionId);
     LWLockRelease(ProcArrayLock);
 }

◆ ExpireOldKnownAssignedTransactionIds()

void ExpireOldKnownAssignedTransactionIds ( TransactionId xid )

Definition at line 4401 of file procarray.c.

References KnownAssignedXidsRemovePreceding(), LW_EXCLUSIVE, LWLockAcquire(), and LWLockRelease().

Referenced by ProcArrayApplyRecoveryInfo().

 {
     LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
     KnownAssignedXidsRemovePreceding(xid);
     LWLockRelease(ProcArrayLock);
 }

◆ ExpireTreeKnownAssignedTransactionIds()

void ExpireTreeKnownAssignedTransactionIds	(	TransactionId	xid,
		int	nsubxids,
		TransactionId *	subxids,
		TransactionId	max_xid
	)

Definition at line 4363 of file procarray.c.

References Assert, KnownAssignedXidsRemoveTree(), LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MaintainLatestCompletedXidRecovery(), ShmemVariableCache, STANDBY_INITIALIZED, standbyState, and VariableCacheData::xactCompletionCount.

Referenced by xact_redo_abort(), and xact_redo_commit().

 {
     Assert(standbyState >= STANDBY_INITIALIZED);
 
     /*
      * Uses same locking as transaction commit
      */
     LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
 
     KnownAssignedXidsRemoveTree(xid, nsubxids, subxids);
 
     /* As in ProcArrayEndTransaction, advance latestCompletedXid */
     MaintainLatestCompletedXidRecovery(max_xid);
 
     /* ... and xactCompletionCount */
     ShmemVariableCache->xactCompletionCount++;
 
     LWLockRelease(ProcArrayLock);
 }

◆ FullXidRelativeTo()

static FullTransactionId FullXidRelativeTo	(	FullTransactionId	rel,
		TransactionId	xid
	)

inlinestatic

Definition at line 4210 of file procarray.c.

References Assert, AssertTransactionIdInAllowableRange, FullTransactionIdFromU64(), TransactionIdIsValid, U64FromFullTransactionId, and XidFromFullTransactionId.

Referenced by GetSnapshotData(), GlobalVisTestIsRemovableXid(), GlobalVisUpdateApply(), MaintainLatestCompletedXid(), and MaintainLatestCompletedXidRecovery().

 {
     TransactionId rel_xid = XidFromFullTransactionId(rel);
 
     Assert(TransactionIdIsValid(xid));
     Assert(TransactionIdIsValid(rel_xid));
 
     /* not guaranteed to find issues, but likely to catch mistakes */
     AssertTransactionIdInAllowableRange(xid);
 
     return FullTransactionIdFromU64(U64FromFullTransactionId(rel)
                                     + (int32) (xid - rel_xid));
 }

◆ GetConflictingVirtualXIDs()

VirtualTransactionId* GetConflictingVirtualXIDs	(	TransactionId	limitXmin,
		Oid	dbOid
	)

Definition at line 3278 of file procarray.c.

References VirtualTransactionId::backendId, PGPROC::databaseId, ereport, errcode(), errmsg(), ERROR, GET_VXID_FROM_PGPROC, InvalidBackendId, InvalidLocalTransactionId, VirtualTransactionId::localTransactionId, LW_SHARED, LWLockAcquire(), LWLockRelease(), malloc, ProcArrayStruct::maxProcs, ProcArrayStruct::numProcs, OidIsValid, ProcArrayStruct::pgprocnos, PGPROC::pid, procArray, TransactionIdFollows(), TransactionIdIsValid, UINT32_ACCESS_ONCE, VirtualTransactionIdIsValid, and PGPROC::xmin.

Referenced by ResolveRecoveryConflictWithSnapshot(), and ResolveRecoveryConflictWithTablespace().

 {
     static VirtualTransactionId *vxids;
     ProcArrayStruct *arrayP = procArray;
     int         count = 0;
     int         index;
 
     /*
      * If first time through, get workspace to remember main XIDs in. We
      * malloc it permanently to avoid repeated palloc/pfree overhead. Allow
      * result space, remembering room for a terminator.
      */
     if (vxids == NULL)
     {
         vxids = (VirtualTransactionId *)
             malloc(sizeof(VirtualTransactionId) * (arrayP->maxProcs + 1));
         if (vxids == NULL)
             ereport(ERROR,
                     (errcode(ERRCODE_OUT_OF_MEMORY),
                      errmsg("out of memory")));
     }
 
     LWLockAcquire(ProcArrayLock, LW_SHARED);
 
     for (index = 0; index < arrayP->numProcs; index++)
     {
         int         pgprocno = arrayP->pgprocnos[index];
         PGPROC     *proc = &allProcs[pgprocno];
 
         /* Exclude prepared transactions */
         if (proc->pid == 0)
             continue;
 
         if (!OidIsValid(dbOid) ||
             proc->databaseId == dbOid)
         {
             /* Fetch xmin just once - can't change on us, but good coding */
             TransactionId pxmin = UINT32_ACCESS_ONCE(proc->xmin);
 
             /*
              * We ignore an invalid pxmin because this means that backend has
              * no snapshot currently. We hold a Share lock to avoid contention
              * with users taking snapshots.  That is not a problem because the
              * current xmin is always at least one higher than the latest
              * removed xid, so any new snapshot would never conflict with the
              * test here.
              */
             if (!TransactionIdIsValid(limitXmin) ||
                 (TransactionIdIsValid(pxmin) && !TransactionIdFollows(pxmin, limitXmin)))
             {
                 VirtualTransactionId vxid;
 
                 GET_VXID_FROM_PGPROC(vxid, *proc);
                 if (VirtualTransactionIdIsValid(vxid))
                     vxids[count++] = vxid;
             }
         }
     }
 
     LWLockRelease(ProcArrayLock);
 
     /* add the terminator */
     vxids[count].backendId = InvalidBackendId;
     vxids[count].localTransactionId = InvalidLocalTransactionId;
 
     return vxids;
 }

◆ GetCurrentVirtualXIDs()

VirtualTransactionId* GetCurrentVirtualXIDs	(	TransactionId	limitXmin,
		bool	excludeXmin0,
		bool	allDbs,
		int	excludeVacuum,
		int *	nvxids
	)

Definition at line 3190 of file procarray.c.

References PGPROC::databaseId, GET_VXID_FROM_PGPROC, LW_SHARED, LWLockAcquire(), LWLockRelease(), ProcArrayStruct::maxProcs, MyDatabaseId, MyProc, ProcArrayStruct::numProcs, palloc(), ProcArrayStruct::pgprocnos, procArray, ProcGlobal, PROC_HDR::statusFlags, TransactionIdIsValid, TransactionIdPrecedesOrEquals(), UINT32_ACCESS_ONCE, VirtualTransactionIdIsValid, and PGPROC::xmin.

Referenced by WaitForOlderSnapshots().

 {
     VirtualTransactionId *vxids;
     ProcArrayStruct *arrayP = procArray;
     int         count = 0;
     int         index;
 
     /* allocate what's certainly enough result space */
     vxids = (VirtualTransactionId *)
         palloc(sizeof(VirtualTransactionId) * arrayP->maxProcs);
 
     LWLockAcquire(ProcArrayLock, LW_SHARED);
 
     for (index = 0; index < arrayP->numProcs; index++)
     {
         int         pgprocno = arrayP->pgprocnos[index];
         PGPROC     *proc = &allProcs[pgprocno];
         uint8       statusFlags = ProcGlobal->statusFlags[index];
 
         if (proc == MyProc)
             continue;
 
         if (excludeVacuum & statusFlags)
             continue;
 
         if (allDbs || proc->databaseId == MyDatabaseId)
         {
             /* Fetch xmin just once - might change on us */
             TransactionId pxmin = UINT32_ACCESS_ONCE(proc->xmin);
 
             if (excludeXmin0 && !TransactionIdIsValid(pxmin))
                 continue;
 
             /*
              * InvalidTransactionId precedes all other XIDs, so a proc that
              * hasn't set xmin yet will not be rejected by this test.
              */
             if (!TransactionIdIsValid(limitXmin) ||
                 TransactionIdPrecedesOrEquals(pxmin, limitXmin))
             {
                 VirtualTransactionId vxid;
 
                 GET_VXID_FROM_PGPROC(vxid, *proc);
                 if (VirtualTransactionIdIsValid(vxid))
                     vxids[count++] = vxid;
             }
         }
     }
 
     LWLockRelease(ProcArrayLock);
 
     *nvxids = count;
     return vxids;
 }

◆ GetMaxSnapshotSubxidCount()

int GetMaxSnapshotSubxidCount ( void )

Definition at line 2009 of file procarray.c.

References TOTAL_MAX_CACHED_SUBXIDS.

Referenced by ExportSnapshot(), GetSnapshotData(), ImportSnapshot(), and SetTransactionSnapshot().

 {
     return TOTAL_MAX_CACHED_SUBXIDS;
 }

◆ GetMaxSnapshotXidCount()

int GetMaxSnapshotXidCount ( void )

Definition at line 1998 of file procarray.c.

References ProcArrayStruct::maxProcs.

Referenced by GetSnapshotData(), ImportSnapshot(), SetTransactionSnapshot(), and SnapBuildInitialSnapshot().

 {
     return procArray->maxProcs;
 }

◆ GetOldestActiveTransactionId()

TransactionId GetOldestActiveTransactionId ( void )

Definition at line 2811 of file procarray.c.

References Assert, LW_SHARED, LWLockAcquire(), LWLockRelease(), VariableCacheData::nextXid, ProcArrayStruct::numProcs, procArray, ProcGlobal, RecoveryInProgress(), ShmemVariableCache, TransactionIdIsNormal, TransactionIdPrecedes(), UINT32_ACCESS_ONCE, XidFromFullTransactionId, and PROC_HDR::xids.

Referenced by CreateCheckPoint().

 {
     ProcArrayStruct *arrayP = procArray;
     TransactionId *other_xids = ProcGlobal->xids;
     TransactionId oldestRunningXid;
     int         index;
 
     Assert(!RecoveryInProgress());
 
     /*
      * Read nextXid, as the upper bound of what's still active.
      *
      * Reading a TransactionId is atomic, but we must grab the lock to make
      * sure that all XIDs < nextXid are already present in the proc array (or
      * have already completed), when we spin over it.
      */
     LWLockAcquire(XidGenLock, LW_SHARED);
     oldestRunningXid = XidFromFullTransactionId(ShmemVariableCache->nextXid);
     LWLockRelease(XidGenLock);
 
     /*
      * Spin over procArray collecting all xids and subxids.
      */
     LWLockAcquire(ProcArrayLock, LW_SHARED);
     for (index = 0; index < arrayP->numProcs; index++)
     {
         TransactionId xid;
 
         /* Fetch xid just once - see GetNewTransactionId */
         xid = UINT32_ACCESS_ONCE(other_xids[index]);
 
         if (!TransactionIdIsNormal(xid))
             continue;
 
         if (TransactionIdPrecedes(xid, oldestRunningXid))
             oldestRunningXid = xid;
 
         /*
          * Top-level XID of a transaction is always less than any of its
          * subxids, so we don't need to check if any of the subxids are
          * smaller than oldestRunningXid
          */
     }
     LWLockRelease(ProcArrayLock);
 
     return oldestRunningXid;
 }

◆ GetOldestNonRemovableTransactionId()

TransactionId GetOldestNonRemovableTransactionId ( Relation rel )

Definition at line 1939 of file procarray.c.

References ComputeXidHorizonsResult::catalog_oldest_nonremovable, ComputeXidHorizons(), ComputeXidHorizonsResult::data_oldest_nonremovable, RelationData::rd_rel, RELATION_IS_LOCAL, RelationIsAccessibleInLogicalDecoding, ComputeXidHorizonsResult::shared_oldest_nonremovable, and ComputeXidHorizonsResult::temp_oldest_nonremovable.

Referenced by acquire_sample_rows(), collect_corrupt_items(), heapam_index_build_range_scan(), statapprox_heap(), vac_update_datfrozenxid(), and vacuum_set_xid_limits().

 {
     ComputeXidHorizonsResult horizons;
 
     ComputeXidHorizons(&horizons);
 
     /* select horizon appropriate for relation */
     if (rel == NULL || rel->rd_rel->relisshared)
         return horizons.shared_oldest_nonremovable;
     else if (RelationIsAccessibleInLogicalDecoding(rel))
         return horizons.catalog_oldest_nonremovable;
     else if (RELATION_IS_LOCAL(rel))
         return horizons.temp_oldest_nonremovable;
     else
         return horizons.data_oldest_nonremovable;
 }

◆ GetOldestSafeDecodingTransactionId()

TransactionId GetOldestSafeDecodingTransactionId ( bool catalogOnly )

Definition at line 2876 of file procarray.c.

References Assert, LW_SHARED, LWLockAcquire(), LWLockHeldByMe(), LWLockRelease(), VariableCacheData::nextXid, ProcArrayStruct::numProcs, procArray, ProcGlobal, RecoveryInProgress(), ProcArrayStruct::replication_slot_catalog_xmin, ProcArrayStruct::replication_slot_xmin, ShmemVariableCache, TransactionIdIsNormal, TransactionIdIsValid, TransactionIdPrecedes(), UINT32_ACCESS_ONCE, XidFromFullTransactionId, and PROC_HDR::xids.

Referenced by CreateInitDecodingContext(), and SnapBuildInitialSnapshot().

 {
     ProcArrayStruct *arrayP = procArray;
     TransactionId oldestSafeXid;
     int         index;
     bool        recovery_in_progress = RecoveryInProgress();
 
     Assert(LWLockHeldByMe(ProcArrayLock));
 
     /*
      * Acquire XidGenLock, so no transactions can acquire an xid while we're
      * running. If no transaction with xid were running concurrently a new xid
      * could influence the RecentXmin et al.
      *
      * We initialize the computation to nextXid since that's guaranteed to be
      * a safe, albeit pessimal, value.
      */
     LWLockAcquire(XidGenLock, LW_SHARED);
     oldestSafeXid = XidFromFullTransactionId(ShmemVariableCache->nextXid);
 
     /*
      * If there's already a slot pegging the xmin horizon, we can start with
      * that value, it's guaranteed to be safe since it's computed by this
      * routine initially and has been enforced since.  We can always use the
      * slot's general xmin horizon, but the catalog horizon is only usable
      * when only catalog data is going to be looked at.
      */
     if (TransactionIdIsValid(procArray->replication_slot_xmin) &&
         TransactionIdPrecedes(procArray->replication_slot_xmin,
                               oldestSafeXid))
         oldestSafeXid = procArray->replication_slot_xmin;
 
     if (catalogOnly &&
         TransactionIdIsValid(procArray->replication_slot_catalog_xmin) &&
         TransactionIdPrecedes(procArray->replication_slot_catalog_xmin,
                               oldestSafeXid))
         oldestSafeXid = procArray->replication_slot_catalog_xmin;
 
     /*
      * If we're not in recovery, we walk over the procarray and collect the
      * lowest xid. Since we're called with ProcArrayLock held and have
      * acquired XidGenLock, no entries can vanish concurrently, since
      * ProcGlobal->xids[i] is only set with XidGenLock held and only cleared
      * with ProcArrayLock held.
      *
      * In recovery we can't lower the safe value besides what we've computed
      * above, so we'll have to wait a bit longer there. We unfortunately can
      * *not* use KnownAssignedXidsGetOldestXmin() since the KnownAssignedXids
      * machinery can miss values and return an older value than is safe.
      */
     if (!recovery_in_progress)
     {
         TransactionId *other_xids = ProcGlobal->xids;
 
         /*
          * Spin over procArray collecting min(ProcGlobal->xids[i])
          */
         for (index = 0; index < arrayP->numProcs; index++)
         {
             TransactionId xid;
 
             /* Fetch xid just once - see GetNewTransactionId */
             xid = UINT32_ACCESS_ONCE(other_xids[index]);
 
             if (!TransactionIdIsNormal(xid))
                 continue;
 
             if (TransactionIdPrecedes(xid, oldestSafeXid))
                 oldestSafeXid = xid;
         }
     }
 
     LWLockRelease(XidGenLock);
 
     return oldestSafeXid;
 }

◆ GetOldestTransactionIdConsideredRunning()

TransactionId GetOldestTransactionIdConsideredRunning ( void )

Definition at line 1963 of file procarray.c.

References ComputeXidHorizons(), and ComputeXidHorizonsResult::oldest_considered_running.

Referenced by CreateCheckPoint(), and CreateRestartPoint().

 {
     ComputeXidHorizonsResult horizons;
 
     ComputeXidHorizons(&horizons);
 
     return horizons.oldest_considered_running;
 }

◆ GetReplicationHorizons()

void GetReplicationHorizons	(	TransactionId *	xmin,
		TransactionId *	catalog_xmin
	)

Definition at line 1976 of file procarray.c.

References ComputeXidHorizons(), ComputeXidHorizonsResult::shared_oldest_nonremovable_raw, and ComputeXidHorizonsResult::slot_catalog_xmin.

Referenced by XLogWalRcvSendHSFeedback().

 {
     ComputeXidHorizonsResult horizons;
 
     ComputeXidHorizons(&horizons);
 
     /*
      * Don't want to use shared_oldest_nonremovable here, as that contains the
      * effect of replication slot's catalog_xmin. We want to send a separate
      * feedback for the catalog horizon, so the primary can remove data table
      * contents more aggressively.
      */
     *xmin = horizons.shared_oldest_nonremovable_raw;
     *catalog_xmin = horizons.slot_catalog_xmin;
 }

◆ GetRunningTransactionData()

RunningTransactions GetRunningTransactionData ( void )

Definition at line 2636 of file procarray.c.

References Assert, XidCacheStatus::count, ereport, errcode(), errmsg(), ERROR, RunningTransactionsData::latestCompletedXid, VariableCacheData::latestCompletedXid, LW_SHARED, LWLockAcquire(), malloc, RunningTransactionsData::nextXid, VariableCacheData::nextXid, ProcArrayStruct::numProcs, RunningTransactionsData::oldestRunningXid, XidCacheStatus::overflowed, pg_read_barrier, ProcArrayStruct::pgprocnos, procArray, ProcGlobal, RecoveryInProgress(), ShmemVariableCache, RunningTransactionsData::subxcnt, RunningTransactionsData::subxid_overflow, PGPROC::subxids, PROC_HDR::subxidStates, TOTAL_MAX_CACHED_SUBXIDS, TransactionIdIsNormal, TransactionIdIsValid, TransactionIdPrecedes(), UINT32_ACCESS_ONCE, RunningTransactionsData::xcnt, XidFromFullTransactionId, XidCache::xids, RunningTransactionsData::xids, and PROC_HDR::xids.

Referenced by LogStandbySnapshot().

 {
     /* result workspace */
     static RunningTransactionsData CurrentRunningXactsData;
 
     ProcArrayStruct *arrayP = procArray;
     TransactionId *other_xids = ProcGlobal->xids;
     RunningTransactions CurrentRunningXacts = &CurrentRunningXactsData;
     TransactionId latestCompletedXid;
     TransactionId oldestRunningXid;
     TransactionId *xids;
     int         index;
     int         count;
     int         subcount;
     bool        suboverflowed;
 
     Assert(!RecoveryInProgress());
 
     /*
      * Allocating space for maxProcs xids is usually overkill; numProcs would
      * be sufficient.  But it seems better to do the malloc while not holding
      * the lock, so we can't look at numProcs.  Likewise, we allocate much
      * more subxip storage than is probably needed.
      *
      * Should only be allocated in bgwriter, since only ever executed during
      * checkpoints.
      */
     if (CurrentRunningXacts->xids == NULL)
     {
         /*
          * First call
          */
         CurrentRunningXacts->xids = (TransactionId *)
             malloc(TOTAL_MAX_CACHED_SUBXIDS * sizeof(TransactionId));
         if (CurrentRunningXacts->xids == NULL)
             ereport(ERROR,
                     (errcode(ERRCODE_OUT_OF_MEMORY),
                      errmsg("out of memory")));
     }
 
     xids = CurrentRunningXacts->xids;
 
     count = subcount = 0;
     suboverflowed = false;
 
     /*
      * Ensure that no xids enter or leave the procarray while we obtain
      * snapshot.
      */
     LWLockAcquire(ProcArrayLock, LW_SHARED);
     LWLockAcquire(XidGenLock, LW_SHARED);
 
     latestCompletedXid =
         XidFromFullTransactionId(ShmemVariableCache->latestCompletedXid);
     oldestRunningXid =
         XidFromFullTransactionId(ShmemVariableCache->nextXid);
 
     /*
      * Spin over procArray collecting all xids
      */
     for (index = 0; index < arrayP->numProcs; index++)
     {
         TransactionId xid;
 
         /* Fetch xid just once - see GetNewTransactionId */
         xid = UINT32_ACCESS_ONCE(other_xids[index]);
 
         /*
          * We don't need to store transactions that don't have a TransactionId
          * yet because they will not show as running on a standby server.
          */
         if (!TransactionIdIsValid(xid))
             continue;
 
         /*
          * Be careful not to exclude any xids before calculating the values of
          * oldestRunningXid and suboverflowed, since these are used to clean
          * up transaction information held on standbys.
          */
         if (TransactionIdPrecedes(xid, oldestRunningXid))
             oldestRunningXid = xid;
 
         if (ProcGlobal->subxidStates[index].overflowed)
             suboverflowed = true;
 
         /*
          * If we wished to exclude xids this would be the right place for it.
          * Procs with the PROC_IN_VACUUM flag set don't usually assign xids,
          * but they do during truncation at the end when they get the lock and
          * truncate, so it is not much of a problem to include them if they
          * are seen and it is cleaner to include them.
          */
 
         xids[count++] = xid;
     }
 
     /*
      * Spin over procArray collecting all subxids, but only if there hasn't
      * been a suboverflow.
      */
     if (!suboverflowed)
     {
         XidCacheStatus *other_subxidstates = ProcGlobal->subxidStates;
 
         for (index = 0; index < arrayP->numProcs; index++)
         {
             int         pgprocno = arrayP->pgprocnos[index];
             PGPROC     *proc = &allProcs[pgprocno];
             int         nsubxids;
 
             /*
              * Save subtransaction XIDs. Other backends can't add or remove
              * entries while we're holding XidGenLock.
              */
             nsubxids = other_subxidstates[index].count;
             if (nsubxids > 0)
             {
                 /* barrier not really required, as XidGenLock is held, but ... */
                 pg_read_barrier();  /* pairs with GetNewTransactionId */
 
                 memcpy(&xids[count], (void *) proc->subxids.xids,
                        nsubxids * sizeof(TransactionId));
                 count += nsubxids;
                 subcount += nsubxids;
 
                 /*
                  * Top-level XID of a transaction is always less than any of
                  * its subxids, so we don't need to check if any of the
                  * subxids are smaller than oldestRunningXid
                  */
             }
         }
     }
 
     /*
      * It's important *not* to include the limits set by slots here because
      * snapbuild.c uses oldestRunningXid to manage its xmin horizon. If those
      * were to be included here the initial value could never increase because
      * of a circular dependency where slots only increase their limits when
      * running xacts increases oldestRunningXid and running xacts only
      * increases if slots do.
      */
 
     CurrentRunningXacts->xcnt = count - subcount;
     CurrentRunningXacts->subxcnt = subcount;
     CurrentRunningXacts->subxid_overflow = suboverflowed;
     CurrentRunningXacts->nextXid = XidFromFullTransactionId(ShmemVariableCache->nextXid);
     CurrentRunningXacts->oldestRunningXid = oldestRunningXid;
     CurrentRunningXacts->latestCompletedXid = latestCompletedXid;
 
     Assert(TransactionIdIsValid(CurrentRunningXacts->nextXid));
     Assert(TransactionIdIsValid(CurrentRunningXacts->oldestRunningXid));
     Assert(TransactionIdIsNormal(CurrentRunningXacts->latestCompletedXid));
 
     /* We don't release the locks here, the caller is responsible for that */
 
     return CurrentRunningXacts;
 }

◆ GetSnapshotData()

Snapshot GetSnapshotData ( Snapshot snapshot )

Definition at line 2135 of file procarray.c.

References SnapshotData::active_count, Assert, SnapshotData::copied, XidCacheStatus::count, SnapshotData::curcid, GlobalVisState::definitely_needed, ereport, errcode(), errmsg(), ERROR, FullTransactionIdAdvance(), FullTransactionIdNewer(), FullXidRelativeTo(), GetCurrentCommandId(), GetMaxSnapshotSubxidCount(), GetMaxSnapshotXidCount(), GetSnapshotDataInitOldSnapshot(), GetSnapshotDataReuse(), InvalidTransactionId, KnownAssignedXidsGetAndSetXmin(), ProcArrayStruct::lastOverflowedXid, VariableCacheData::latestCompletedXid, likely, LW_SHARED, LWLockAcquire(), LWLockRelease(), malloc, GlobalVisState::maybe_needed, MyProc, NormalTransactionIdPrecedes, ProcArrayStruct::numProcs, VariableCacheData::oldestXid, pg_read_barrier, ProcArrayStruct::pgprocnos, PGPROC::pgxactoff, PROC_IN_LOGICAL_DECODING, PROC_IN_VACUUM, procArray, ProcGlobal, RecentXmin, RecoveryInProgress(), SnapshotData::regd_count, ProcArrayStruct::replication_slot_catalog_xmin, ProcArrayStruct::replication_slot_xmin, ShmemVariableCache, SnapshotData::snapXactCompletionCount, PROC_HDR::statusFlags, SnapshotData::suboverflowed, SnapshotData::subxcnt, PGPROC::subxids, PROC_HDR::subxidStates, SnapshotData::subxip, SnapshotData::takenDuringRecovery, TransactionIdAdvance, TransactionIdIsNormal, TransactionIdIsValid, TransactionIdOlder(), TransactionIdPrecedesOrEquals(), TransactionIdRetreatedBy(), TransactionXmin, UINT32_ACCESS_ONCE, vacuum_defer_cleanup_age, VariableCacheData::xactCompletionCount, SnapshotData::xcnt, PGPROC::xid, XidFromFullTransactionId, XidCache::xids, PROC_HDR::xids, SnapshotData::xip, SnapshotData::xmax, PGPROC::xmin, and SnapshotData::xmin.

Referenced by GetLatestSnapshot(), GetNonHistoricCatalogSnapshot(), GetSerializableTransactionSnapshotInt(), GetTransactionSnapshot(), and SetTransactionSnapshot().

 {
     ProcArrayStruct *arrayP = procArray;
     TransactionId *other_xids = ProcGlobal->xids;
     TransactionId xmin;
     TransactionId xmax;
     size_t      count = 0;
     int         subcount = 0;
     bool        suboverflowed = false;
     FullTransactionId latest_completed;
     TransactionId oldestxid;
     int         mypgxactoff;
     TransactionId myxid;
     uint64      curXactCompletionCount;
 
     TransactionId replication_slot_xmin = InvalidTransactionId;
     TransactionId replication_slot_catalog_xmin = InvalidTransactionId;
 
     Assert(snapshot != NULL);
 
     /*
      * Allocating space for maxProcs xids is usually overkill; numProcs would
      * be sufficient.  But it seems better to do the malloc while not holding
      * the lock, so we can't look at numProcs.  Likewise, we allocate much
      * more subxip storage than is probably needed.
      *
      * This does open a possibility for avoiding repeated malloc/free: since
      * maxProcs does not change at runtime, we can simply reuse the previous
      * xip arrays if any.  (This relies on the fact that all callers pass
      * static SnapshotData structs.)
      */
     if (snapshot->xip == NULL)
     {
         /*
          * First call for this snapshot. Snapshot is same size whether or not
          * we are in recovery, see later comments.
          */
         snapshot->xip = (TransactionId *)
             malloc(GetMaxSnapshotXidCount() * sizeof(TransactionId));
         if (snapshot->xip == NULL)
             ereport(ERROR,
                     (errcode(ERRCODE_OUT_OF_MEMORY),
                      errmsg("out of memory")));
         Assert(snapshot->subxip == NULL);
         snapshot->subxip = (TransactionId *)
             malloc(GetMaxSnapshotSubxidCount() * sizeof(TransactionId));
         if (snapshot->subxip == NULL)
             ereport(ERROR,
                     (errcode(ERRCODE_OUT_OF_MEMORY),
                      errmsg("out of memory")));
     }
 
     /*
      * It is sufficient to get shared lock on ProcArrayLock, even if we are
      * going to set MyProc->xmin.
      */
     LWLockAcquire(ProcArrayLock, LW_SHARED);
 
     if (GetSnapshotDataReuse(snapshot))
     {
         LWLockRelease(ProcArrayLock);
         return snapshot;
     }
 
     latest_completed = ShmemVariableCache->latestCompletedXid;
     mypgxactoff = MyProc->pgxactoff;
     myxid = other_xids[mypgxactoff];
     Assert(myxid == MyProc->xid);
 
     oldestxid = ShmemVariableCache->oldestXid;
     curXactCompletionCount = ShmemVariableCache->xactCompletionCount;
 
     /* xmax is always latestCompletedXid + 1 */
     xmax = XidFromFullTransactionId(latest_completed);
     TransactionIdAdvance(xmax);
     Assert(TransactionIdIsNormal(xmax));
 
     /* initialize xmin calculation with xmax */
     xmin = xmax;
 
     /* take own xid into account, saves a check inside the loop */
     if (TransactionIdIsNormal(myxid) && NormalTransactionIdPrecedes(myxid, xmin))
         xmin = myxid;
 
     snapshot->takenDuringRecovery = RecoveryInProgress();
 
     if (!snapshot->takenDuringRecovery)
     {
         size_t      numProcs = arrayP->numProcs;
         TransactionId *xip = snapshot->xip;
         int        *pgprocnos = arrayP->pgprocnos;
         XidCacheStatus *subxidStates = ProcGlobal->subxidStates;
         uint8      *allStatusFlags = ProcGlobal->statusFlags;
 
         /*
          * First collect set of pgxactoff/xids that need to be included in the
          * snapshot.
          */
         for (size_t pgxactoff = 0; pgxactoff < numProcs; pgxactoff++)
         {
             /* Fetch xid just once - see GetNewTransactionId */
             TransactionId xid = UINT32_ACCESS_ONCE(other_xids[pgxactoff]);
             uint8       statusFlags;
 
             Assert(allProcs[arrayP->pgprocnos[pgxactoff]].pgxactoff == pgxactoff);
 
             /*
              * If the transaction has no XID assigned, we can skip it; it
              * won't have sub-XIDs either.
              */
             if (likely(xid == InvalidTransactionId))
                 continue;
 
             /*
              * We don't include our own XIDs (if any) in the snapshot. It
              * needs to be includeded in the xmin computation, but we did so
              * outside the loop.
              */
             if (pgxactoff == mypgxactoff)
                 continue;
 
             /*
              * The only way we are able to get here with a non-normal xid
              * is during bootstrap - with this backend using
              * BootstrapTransactionId. But the above test should filter
              * that out.
              */
             Assert(TransactionIdIsNormal(xid));
 
             /*
              * If the XID is >= xmax, we can skip it; such transactions will
              * be treated as running anyway (and any sub-XIDs will also be >=
              * xmax).
              */
             if (!NormalTransactionIdPrecedes(xid, xmax))
                 continue;
 
             /*
              * Skip over backends doing logical decoding which manages xmin
              * separately (check below) and ones running LAZY VACUUM.
              */
             statusFlags = allStatusFlags[pgxactoff];
             if (statusFlags & (PROC_IN_LOGICAL_DECODING | PROC_IN_VACUUM))
                 continue;
 
             if (NormalTransactionIdPrecedes(xid, xmin))
                 xmin = xid;
 
             /* Add XID to snapshot. */
             xip[count++] = xid;
 
             /*
              * Save subtransaction XIDs if possible (if we've already
              * overflowed, there's no point).  Note that the subxact XIDs must
              * be later than their parent, so no need to check them against
              * xmin.  We could filter against xmax, but it seems better not to
              * do that much work while holding the ProcArrayLock.
              *
              * The other backend can add more subxids concurrently, but cannot
              * remove any.  Hence it's important to fetch nxids just once.
              * Should be safe to use memcpy, though.  (We needn't worry about
              * missing any xids added concurrently, because they must postdate
              * xmax.)
              *
              * Again, our own XIDs are not included in the snapshot.
              */
             if (!suboverflowed)
             {
 
                 if (subxidStates[pgxactoff].overflowed)
                     suboverflowed = true;
                 else
                 {
                     int         nsubxids = subxidStates[pgxactoff].count;
 
                     if (nsubxids > 0)
                     {
                         int         pgprocno = pgprocnos[pgxactoff];
                         PGPROC     *proc = &allProcs[pgprocno];
 
                         pg_read_barrier();  /* pairs with GetNewTransactionId */
 
                         memcpy(snapshot->subxip + subcount,
                                (void *) proc->subxids.xids,
                                nsubxids * sizeof(TransactionId));
                         subcount += nsubxids;
                     }
                 }
             }
         }
     }
     else
     {
         /*
          * We're in hot standby, so get XIDs from KnownAssignedXids.
          *
          * We store all xids directly into subxip[]. Here's why:
          *
          * In recovery we don't know which xids are top-level and which are
          * subxacts, a design choice that greatly simplifies xid processing.
          *
          * It seems like we would want to try to put xids into xip[] only, but
          * that is fairly small. We would either need to make that bigger or
          * to increase the rate at which we WAL-log xid assignment; neither is
          * an appealing choice.
          *
          * We could try to store xids into xip[] first and then into subxip[]
          * if there are too many xids. That only works if the snapshot doesn't
          * overflow because we do not search subxip[] in that case. A simpler
          * way is to just store all xids in the subxact array because this is
          * by far the bigger array. We just leave the xip array empty.
          *
          * Either way we need to change the way XidInMVCCSnapshot() works
          * depending upon when the snapshot was taken, or change normal
          * snapshot processing so it matches.
          *
          * Note: It is possible for recovery to end before we finish taking
          * the snapshot, and for newly assigned transaction ids to be added to
          * the ProcArray.  xmax cannot change while we hold ProcArrayLock, so
          * those newly added transaction ids would be filtered away, so we
          * need not be concerned about them.
          */
         subcount = KnownAssignedXidsGetAndSetXmin(snapshot->subxip, &xmin,
                                                   xmax);
 
         if (TransactionIdPrecedesOrEquals(xmin, procArray->lastOverflowedXid))
             suboverflowed = true;
     }
 
 
     /*
      * Fetch into local variable while ProcArrayLock is held - the
      * LWLockRelease below is a barrier, ensuring this happens inside the
      * lock.
      */
     replication_slot_xmin = procArray->replication_slot_xmin;
     replication_slot_catalog_xmin = procArray->replication_slot_catalog_xmin;
 
     if (!TransactionIdIsValid(MyProc->xmin))
         MyProc->xmin = TransactionXmin = xmin;
 
     LWLockRelease(ProcArrayLock);
 
     /* maintain state for GlobalVis* */
     {
         TransactionId def_vis_xid;
         TransactionId def_vis_xid_data;
         FullTransactionId def_vis_fxid;
         FullTransactionId def_vis_fxid_data;
         FullTransactionId oldestfxid;
 
         /*
          * Converting oldestXid is only safe when xid horizon cannot advance,
          * i.e. holding locks. While we don't hold the lock anymore, all the
          * necessary data has been gathered with lock held.
          */
         oldestfxid = FullXidRelativeTo(latest_completed, oldestxid);
 
         /* apply vacuum_defer_cleanup_age */
         def_vis_xid_data =
             TransactionIdRetreatedBy(xmin, vacuum_defer_cleanup_age);
 
         /* Check whether there's a replication slot requiring an older xmin. */
         def_vis_xid_data =
             TransactionIdOlder(def_vis_xid_data, replication_slot_xmin);
 
         /*
          * Rows in non-shared, non-catalog tables possibly could be vacuumed
          * if older than this xid.
          */
         def_vis_xid = def_vis_xid_data;
 
         /*
          * Check whether there's a replication slot requiring an older catalog
          * xmin.
          */
         def_vis_xid =
             TransactionIdOlder(replication_slot_catalog_xmin, def_vis_xid);
 
         def_vis_fxid = FullXidRelativeTo(latest_completed, def_vis_xid);
         def_vis_fxid_data = FullXidRelativeTo(latest_completed, def_vis_xid_data);
 
         /*
          * Check if we can increase upper bound. As a previous
          * GlobalVisUpdate() might have computed more aggressive values, don't
          * overwrite them if so.
          */
         GlobalVisSharedRels.definitely_needed =
             FullTransactionIdNewer(def_vis_fxid,
                                    GlobalVisSharedRels.definitely_needed);
         GlobalVisCatalogRels.definitely_needed =
             FullTransactionIdNewer(def_vis_fxid,
                                    GlobalVisCatalogRels.definitely_needed);
         GlobalVisDataRels.definitely_needed =
             FullTransactionIdNewer(def_vis_fxid_data,
                                    GlobalVisDataRels.definitely_needed);
         /* See temp_oldest_nonremovable computation in ComputeXidHorizons() */
         if (TransactionIdIsNormal(myxid))
             GlobalVisTempRels.definitely_needed =
                 FullXidRelativeTo(latest_completed, myxid);
         else
         {
             GlobalVisTempRels.definitely_needed = latest_completed;
             FullTransactionIdAdvance(&GlobalVisTempRels.definitely_needed);
         }
 
         /*
          * Check if we know that we can initialize or increase the lower
          * bound. Currently the only cheap way to do so is to use
          * ShmemVariableCache->oldestXid as input.
          *
          * We should definitely be able to do better. We could e.g. put a
          * global lower bound value into ShmemVariableCache.
          */
         GlobalVisSharedRels.maybe_needed =
             FullTransactionIdNewer(GlobalVisSharedRels.maybe_needed,
                                    oldestfxid);
         GlobalVisCatalogRels.maybe_needed =
             FullTransactionIdNewer(GlobalVisCatalogRels.maybe_needed,
                                    oldestfxid);
         GlobalVisDataRels.maybe_needed =
             FullTransactionIdNewer(GlobalVisDataRels.maybe_needed,
                                    oldestfxid);
         /* accurate value known */
         GlobalVisTempRels.maybe_needed = GlobalVisTempRels.definitely_needed;
     }
 
     RecentXmin = xmin;
     Assert(TransactionIdPrecedesOrEquals(TransactionXmin, RecentXmin));
 
     snapshot->xmin = xmin;
     snapshot->xmax = xmax;
     snapshot->xcnt = count;
     snapshot->subxcnt = subcount;
     snapshot->suboverflowed = suboverflowed;
     snapshot->snapXactCompletionCount = curXactCompletionCount;
 
     snapshot->curcid = GetCurrentCommandId(false);
 
     /*
      * This is a new snapshot, so set both refcounts are zero, and mark it as
      * not copied in persistent memory.
      */
     snapshot->active_count = 0;
     snapshot->regd_count = 0;
     snapshot->copied = false;
 
     GetSnapshotDataInitOldSnapshot(snapshot);
 
     return snapshot;
 }

◆ GetSnapshotDataInitOldSnapshot()

static void GetSnapshotDataInitOldSnapshot ( Snapshot snapshot )

static

Definition at line 2018 of file procarray.c.

References GetSnapshotCurrentTimestamp(), GetXLogInsertRecPtr(), InvalidXLogRecPtr, SnapshotData::lsn, MaintainOldSnapshotTimeMapping(), OldSnapshotThresholdActive(), SnapshotData::whenTaken, and SnapshotData::xmin.

Referenced by GetSnapshotData(), and GetSnapshotDataReuse().

 {
     if (!OldSnapshotThresholdActive())
     {
         /*
          * If not using "snapshot too old" feature, fill related fields with
          * dummy values that don't require any locking.
          */
         snapshot->lsn = InvalidXLogRecPtr;
         snapshot->whenTaken = 0;
     }
     else
     {
         /*
          * Capture the current time and WAL stream location in case this
          * snapshot becomes old enough to need to fall back on the special
          * "old snapshot" logic.
          */
         snapshot->lsn = GetXLogInsertRecPtr();
         snapshot->whenTaken = GetSnapshotCurrentTimestamp();
         MaintainOldSnapshotTimeMapping(snapshot->whenTaken, snapshot->xmin);
     }
 }

◆ GetSnapshotDataReuse()

static bool GetSnapshotDataReuse ( Snapshot snapshot )

static

Definition at line 2052 of file procarray.c.

References SnapshotData::active_count, Assert, SnapshotData::copied, SnapshotData::curcid, GetCurrentCommandId(), GetSnapshotDataInitOldSnapshot(), LWLockHeldByMe(), MyProc, RecentXmin, SnapshotData::regd_count, ShmemVariableCache, SnapshotData::snapXactCompletionCount, TransactionIdIsValid, TransactionIdPrecedesOrEquals(), TransactionXmin, unlikely, VariableCacheData::xactCompletionCount, PGPROC::xmin, and SnapshotData::xmin.

Referenced by GetSnapshotData().

 {
     uint64 curXactCompletionCount;
 
     Assert(LWLockHeldByMe(ProcArrayLock));
 
     if (unlikely(snapshot->snapXactCompletionCount == 0))
         return false;
 
     curXactCompletionCount = ShmemVariableCache->xactCompletionCount;
     if (curXactCompletionCount != snapshot->snapXactCompletionCount)
         return false;
 
     /*
      * If the current xactCompletionCount is still the same as it was at the
      * time the snapshot was built, we can be sure that rebuilding the
      * contents of the snapshot the hard way would result in the same snapshot
      * contents:
      *
      * As explained in transam/README, the set of xids considered running by
      * GetSnapshotData() cannot change while ProcArrayLock is held. Snapshot
      * contents only depend on transactions with xids and xactCompletionCount
      * is incremented whenever a transaction with an xid finishes (while
      * holding ProcArrayLock) exclusively). Thus the xactCompletionCount check
      * ensures we would detect if the snapshot would have changed.
      *
      * As the snapshot contents are the same as it was before, it is safe
      * to re-enter the snapshot's xmin into the PGPROC array. None of the rows
      * visible under the snapshot could already have been removed (that'd
      * require the set of running transactions to change) and it fulfills the
      * requirement that concurrent GetSnapshotData() calls yield the same
      * xmin.
      */
     if (!TransactionIdIsValid(MyProc->xmin))
         MyProc->xmin = TransactionXmin = snapshot->xmin;
 
     RecentXmin = snapshot->xmin;
     Assert(TransactionIdPrecedesOrEquals(TransactionXmin, RecentXmin));
 
     snapshot->curcid = GetCurrentCommandId(false);
     snapshot->active_count = 0;
     snapshot->regd_count = 0;
     snapshot->copied = false;
 
     GetSnapshotDataInitOldSnapshot(snapshot);
 
     return true;
 }

◆ GetVirtualXIDsDelayingChkpt()

VirtualTransactionId* GetVirtualXIDsDelayingChkpt ( int * nvxids )

Definition at line 2972 of file procarray.c.

References PGPROC::delayChkpt, GET_VXID_FROM_PGPROC, LW_SHARED, LWLockAcquire(), LWLockRelease(), ProcArrayStruct::maxProcs, ProcArrayStruct::numProcs, palloc(), ProcArrayStruct::pgprocnos, procArray, and VirtualTransactionIdIsValid.

Referenced by CreateCheckPoint().

 {
     VirtualTransactionId *vxids;
     ProcArrayStruct *arrayP = procArray;
     int         count = 0;
     int         index;
 
     /* allocate what's certainly enough result space */
     vxids = (VirtualTransactionId *)
         palloc(sizeof(VirtualTransactionId) * arrayP->maxProcs);
 
     LWLockAcquire(ProcArrayLock, LW_SHARED);
 
     for (index = 0; index < arrayP->numProcs; index++)
     {
         int         pgprocno = arrayP->pgprocnos[index];
         PGPROC     *proc = &allProcs[pgprocno];
 
         if (proc->delayChkpt)
         {
             VirtualTransactionId vxid;
 
             GET_VXID_FROM_PGPROC(vxid, *proc);
             if (VirtualTransactionIdIsValid(vxid))
                 vxids[count++] = vxid;
         }
     }
 
     LWLockRelease(ProcArrayLock);
 
     *nvxids = count;
     return vxids;
 }

◆ GlobalVisCheckRemovableFullXid()

bool GlobalVisCheckRemovableFullXid	(	Relation	rel,
		FullTransactionId	fxid
	)

Definition at line 4175 of file procarray.c.

References GlobalVisTestFor(), and GlobalVisTestIsRemovableFullXid().

Referenced by BTPageIsRecyclable(), and gistPageRecyclable().

 {
     GlobalVisState *state;
 
     state = GlobalVisTestFor(rel);
 
     return GlobalVisTestIsRemovableFullXid(state, fxid);
 }

◆ GlobalVisCheckRemovableXid()

bool GlobalVisCheckRemovableXid	(	Relation	rel,
		TransactionId	xid
	)

Definition at line 4189 of file procarray.c.

References GlobalVisTestFor(), and GlobalVisTestIsRemovableXid().

Referenced by GinPageIsRecyclable().

 {
     GlobalVisState *state;
 
     state = GlobalVisTestFor(rel);
 
     return GlobalVisTestIsRemovableXid(state, xid);
 }

◆ GlobalVisTestFor()

GlobalVisState* GlobalVisTestFor ( Relation rel )

Definition at line 3955 of file procarray.c.

References Assert, GlobalVisState::definitely_needed, FullTransactionIdIsValid, GlobalVisCatalogRels, GlobalVisDataRels, GlobalVisSharedRels, GlobalVisTempRels, IsCatalogRelation(), GlobalVisState::maybe_needed, RelationData::rd_rel, RecentXmin, RecoveryInProgress(), RELATION_IS_LOCAL, and RelationIsAccessibleInLogicalDecoding.

Referenced by get_actual_variable_endpoint(), GlobalVisCheckRemovableFullXid(), GlobalVisCheckRemovableXid(), heap_hot_search_buffer(), heap_index_delete_tuples(), heap_page_prune_opt(), lazy_scan_heap(), and vacuumRedirectAndPlaceholder().

 {
     bool        need_shared;
     bool        need_catalog;
     GlobalVisState *state;
 
     /* XXX: we should assert that a snapshot is pushed or registered */
     Assert(RecentXmin);
 
     if (!rel)
         need_shared = need_catalog = true;
     else
     {
         /*
          * Other kinds currently don't contain xids, nor always the necessary
          * logical decoding markers.
          */
         Assert(rel->rd_rel->relkind == RELKIND_RELATION ||
                rel->rd_rel->relkind == RELKIND_MATVIEW ||
                rel->rd_rel->relkind == RELKIND_TOASTVALUE);
 
         need_shared = rel->rd_rel->relisshared || RecoveryInProgress();
         need_catalog = IsCatalogRelation(rel) || RelationIsAccessibleInLogicalDecoding(rel);
     }
 
     if (need_shared)
         state = &GlobalVisSharedRels;
     else if (need_catalog)
         state = &GlobalVisCatalogRels;
     else if (RELATION_IS_LOCAL(rel))
         state = &GlobalVisTempRels;
     else
         state = &GlobalVisDataRels;
 
     Assert(FullTransactionIdIsValid(state->definitely_needed) &&
            FullTransactionIdIsValid(state->maybe_needed));
 
     return state;
 }

◆ GlobalVisTestIsRemovableFullXid()

bool GlobalVisTestIsRemovableFullXid	(	GlobalVisState *	state,
		FullTransactionId	fxid
	)

Definition at line 4081 of file procarray.c.

References Assert, GlobalVisState::definitely_needed, FullTransactionIdFollowsOrEquals, FullTransactionIdPrecedes, GlobalVisTestShouldUpdate(), GlobalVisUpdate(), and GlobalVisState::maybe_needed.

Referenced by GlobalVisCheckRemovableFullXid(), and GlobalVisTestIsRemovableXid().

 {
     /*
      * If fxid is older than maybe_needed bound, it definitely is visible to
      * everyone.
      */
     if (FullTransactionIdPrecedes(fxid, state->maybe_needed))
         return true;
 
     /*
      * If fxid is >= definitely_needed bound, it is very likely to still be
      * considered running.
      */
     if (FullTransactionIdFollowsOrEquals(fxid, state->definitely_needed))
         return false;
 
     /*
      * fxid is between maybe_needed and definitely_needed, i.e. there might or
      * might not exist a snapshot considering fxid running. If it makes sense,
      * update boundaries and recheck.
      */
     if (GlobalVisTestShouldUpdate(state))
     {
         GlobalVisUpdate();
 
         Assert(FullTransactionIdPrecedes(fxid, state->definitely_needed));
 
         return FullTransactionIdPrecedes(fxid, state->maybe_needed);
     }
     else
         return false;
 }

◆ GlobalVisTestIsRemovableXid()

bool GlobalVisTestIsRemovableXid	(	GlobalVisState *	state,
		TransactionId	xid
	)

Definition at line 4123 of file procarray.c.

References GlobalVisState::definitely_needed, FullXidRelativeTo(), and GlobalVisTestIsRemovableFullXid().

Referenced by GlobalVisCheckRemovableXid(), heap_page_prune_opt(), heap_prune_satisfies_vacuum(), HeapTupleIsSurelyDead(), HeapTupleSatisfiesNonVacuumable(), and vacuumRedirectAndPlaceholder().

 {
     FullTransactionId fxid;
 
     /*
      * Convert 32 bit argument to FullTransactionId. We can do so safely
      * because we know the xid has to, at the very least, be between
      * [oldestXid, nextFullXid), i.e. within 2 billion of xid. To avoid taking
      * a lock to determine either, we can just compare with
      * state->definitely_needed, which was based on those value at the time
      * the current snapshot was built.
      */
     fxid = FullXidRelativeTo(state->definitely_needed, xid);
 
     return GlobalVisTestIsRemovableFullXid(state, fxid);
 }

◆ GlobalVisTestNonRemovableFullHorizon()

FullTransactionId GlobalVisTestNonRemovableFullHorizon ( GlobalVisState * state )

Definition at line 4150 of file procarray.c.

References GlobalVisTestShouldUpdate(), GlobalVisUpdate(), and GlobalVisState::maybe_needed.

Referenced by GlobalVisTestNonRemovableHorizon().

 {
     /* acquire accurate horizon if not already done */
     if (GlobalVisTestShouldUpdate(state))
         GlobalVisUpdate();
 
     return state->maybe_needed;
 }

◆ GlobalVisTestNonRemovableHorizon()

TransactionId GlobalVisTestNonRemovableHorizon ( GlobalVisState * state )

Definition at line 4161 of file procarray.c.

References GlobalVisTestNonRemovableFullHorizon(), and XidFromFullTransactionId.

Referenced by heap_page_prune_opt(), and heap_prune_satisfies_vacuum().

 {
     FullTransactionId cutoff;
 
     cutoff = GlobalVisTestNonRemovableFullHorizon(state);
 
     return XidFromFullTransactionId(cutoff);
 }

◆ GlobalVisTestShouldUpdate()

static bool GlobalVisTestShouldUpdate ( GlobalVisState * state )

static

Definition at line 4006 of file procarray.c.

References ComputeXidHorizonsResultLastXmin, GlobalVisState::definitely_needed, FullTransactionIdFollowsOrEquals, GlobalVisState::maybe_needed, RecentXmin, and TransactionIdIsValid.

Referenced by GlobalVisTestIsRemovableFullXid(), and GlobalVisTestNonRemovableFullHorizon().

 {
     /* hasn't been updated yet */
     if (!TransactionIdIsValid(ComputeXidHorizonsResultLastXmin))
         return true;
 
     /*
      * If the maybe_needed/definitely_needed boundaries are the same, it's
      * unlikely to be beneficial to refresh boundaries.
      */
     if (FullTransactionIdFollowsOrEquals(state->maybe_needed,
                                          state->definitely_needed))
         return false;
 
     /* does the last snapshot built have a different xmin? */
     return RecentXmin != ComputeXidHorizonsResultLastXmin;
 }

◆ GlobalVisUpdate()

static void GlobalVisUpdate ( void )

static

Definition at line 4064 of file procarray.c.

References ComputeXidHorizons().

Referenced by GlobalVisTestIsRemovableFullXid(), and GlobalVisTestNonRemovableFullHorizon().

 {
     ComputeXidHorizonsResult horizons;
 
     /* updates the horizons as a side-effect */
     ComputeXidHorizons(&horizons);
 }

◆ GlobalVisUpdateApply()

static void GlobalVisUpdateApply ( ComputeXidHorizonsResult * horizons )

static

Definition at line 4025 of file procarray.c.

References ComputeXidHorizonsResult::catalog_oldest_nonremovable, ComputeXidHorizonsResultLastXmin, ComputeXidHorizonsResult::data_oldest_nonremovable, GlobalVisState::definitely_needed, FullTransactionIdNewer(), FullXidRelativeTo(), ComputeXidHorizonsResult::latest_completed, GlobalVisState::maybe_needed, RecentXmin, ComputeXidHorizonsResult::shared_oldest_nonremovable, and ComputeXidHorizonsResult::temp_oldest_nonremovable.

Referenced by ComputeXidHorizons().

 {
     GlobalVisSharedRels.maybe_needed =
         FullXidRelativeTo(horizons->latest_completed,
                           horizons->shared_oldest_nonremovable);
     GlobalVisCatalogRels.maybe_needed =
         FullXidRelativeTo(horizons->latest_completed,
                           horizons->catalog_oldest_nonremovable);
     GlobalVisDataRels.maybe_needed =
         FullXidRelativeTo(horizons->latest_completed,
                           horizons->data_oldest_nonremovable);
     GlobalVisTempRels.maybe_needed =
         FullXidRelativeTo(horizons->latest_completed,
                           horizons->temp_oldest_nonremovable);
 
     /*
      * In longer running transactions it's possible that transactions we
      * previously needed to treat as running aren't around anymore. So update
      * definitely_needed to not be earlier than maybe_needed.
      */
     GlobalVisSharedRels.definitely_needed =
         FullTransactionIdNewer(GlobalVisSharedRels.maybe_needed,
                                GlobalVisSharedRels.definitely_needed);
     GlobalVisCatalogRels.definitely_needed =
         FullTransactionIdNewer(GlobalVisCatalogRels.maybe_needed,
                                GlobalVisCatalogRels.definitely_needed);
     GlobalVisDataRels.definitely_needed =
         FullTransactionIdNewer(GlobalVisDataRels.maybe_needed,
                                GlobalVisDataRels.definitely_needed);
     GlobalVisTempRels.definitely_needed = GlobalVisTempRels.maybe_needed;
 
     ComputeXidHorizonsResultLastXmin = RecentXmin;
 }

◆ HaveVirtualXIDsDelayingChkpt()

bool HaveVirtualXIDsDelayingChkpt	(	VirtualTransactionId *	vxids,
		int	nvxids
	)

Definition at line 3016 of file procarray.c.

References PGPROC::delayChkpt, GET_VXID_FROM_PGPROC, i, LW_SHARED, LWLockAcquire(), LWLockRelease(), ProcArrayStruct::numProcs, ProcArrayStruct::pgprocnos, procArray, VirtualTransactionIdEquals, and VirtualTransactionIdIsValid.

Referenced by CreateCheckPoint().

 {
     bool        result = false;
     ProcArrayStruct *arrayP = procArray;
     int         index;
 
     LWLockAcquire(ProcArrayLock, LW_SHARED);
 
     for (index = 0; index < arrayP->numProcs; index++)
     {
         int         pgprocno = arrayP->pgprocnos[index];
         PGPROC     *proc = &allProcs[pgprocno];
         VirtualTransactionId vxid;
 
         GET_VXID_FROM_PGPROC(vxid, *proc);
 
         if (proc->delayChkpt && VirtualTransactionIdIsValid(vxid))
         {
             int         i;
 
             for (i = 0; i < nvxids; i++)
             {
                 if (VirtualTransactionIdEquals(vxid, vxids[i]))
                 {
                     result = true;
                     break;
                 }
             }
             if (result)
                 break;
         }
     }
 
     LWLockRelease(ProcArrayLock);
 
     return result;
 }

◆ IsBackendPid()

bool IsBackendPid ( int pid )

Definition at line 3157 of file procarray.c.

References BackendPidGetProc().

Referenced by pg_stat_get_subscription().

 {
     return (BackendPidGetProc(pid) != NULL);
 }

◆ KnownAssignedXidExists()

static bool KnownAssignedXidExists ( TransactionId xid )

static

Definition at line 4777 of file procarray.c.

References Assert, KnownAssignedXidsSearch(), and TransactionIdIsValid.

Referenced by TransactionIdIsInProgress().

 {
     Assert(TransactionIdIsValid(xid));
 
     return KnownAssignedXidsSearch(xid, false);
 }

◆ KnownAssignedXidsAdd()

static void KnownAssignedXidsAdd	(	TransactionId	from_xid,
		TransactionId	to_xid,
		bool	exclusive_lock
	)

static

Definition at line 4566 of file procarray.c.

References Assert, elog, ERROR, ProcArrayStruct::headKnownAssignedXids, i, ProcArrayStruct::known_assigned_xids_lck, KnownAssignedXids, KnownAssignedXidsCompress(), KnownAssignedXidsDisplay(), KnownAssignedXidsValid, LOG, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), ProcArrayStruct::maxKnownAssignedXids, ProcArrayStruct::numKnownAssignedXids, procArray, SpinLockAcquire, SpinLockRelease, ProcArrayStruct::tailKnownAssignedXids, TransactionIdAdvance, TransactionIdFollowsOrEquals(), TransactionIdPrecedes(), and TransactionIdPrecedesOrEquals().

Referenced by ProcArrayApplyRecoveryInfo(), and RecordKnownAssignedTransactionIds().

 {
     ProcArrayStruct *pArray = procArray;
     TransactionId next_xid;
     int         head,
                 tail;
     int         nxids;
     int         i;
 
     Assert(TransactionIdPrecedesOrEquals(from_xid, to_xid));
 
     /*
      * Calculate how many array slots we'll need.  Normally this is cheap; in
      * the unusual case where the XIDs cross the wrap point, we do it the hard
      * way.
      */
     if (to_xid >= from_xid)
         nxids = to_xid - from_xid + 1;
     else
     {
         nxids = 1;
         next_xid = from_xid;
         while (TransactionIdPrecedes(next_xid, to_xid))
         {
             nxids++;
             TransactionIdAdvance(next_xid);
         }
     }
 
     /*
      * Since only the startup process modifies the head/tail pointers, we
      * don't need a lock to read them here.
      */
     head = pArray->headKnownAssignedXids;
     tail = pArray->tailKnownAssignedXids;
 
     Assert(head >= 0 && head <= pArray->maxKnownAssignedXids);
     Assert(tail >= 0 && tail < pArray->maxKnownAssignedXids);
 
     /*
      * Verify that insertions occur in TransactionId sequence.  Note that even
      * if the last existing element is marked invalid, it must still have a
      * correctly sequenced XID value.
      */
     if (head > tail &&
         TransactionIdFollowsOrEquals(KnownAssignedXids[head - 1], from_xid))
     {
         KnownAssignedXidsDisplay(LOG);
         elog(ERROR, "out-of-order XID insertion in KnownAssignedXids");
     }
 
     /*
      * If our xids won't fit in the remaining space, compress out free space
      */
     if (head + nxids > pArray->maxKnownAssignedXids)
     {
         /* must hold lock to compress */
         if (!exclusive_lock)
             LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
 
         KnownAssignedXidsCompress(true);
 
         head = pArray->headKnownAssignedXids;
         /* note: we no longer care about the tail pointer */
 
         if (!exclusive_lock)
             LWLockRelease(ProcArrayLock);
 
         /*
          * If it still won't fit then we're out of memory
          */
         if (head + nxids > pArray->maxKnownAssignedXids)
             elog(ERROR, "too many KnownAssignedXids");
     }
 
     /* Now we can insert the xids into the space starting at head */
     next_xid = from_xid;
     for (i = 0; i < nxids; i++)
     {
         KnownAssignedXids[head] = next_xid;
         KnownAssignedXidsValid[head] = true;
         TransactionIdAdvance(next_xid);
         head++;
     }
 
     /* Adjust count of number of valid entries */
     pArray->numKnownAssignedXids += nxids;
 
     /*
      * Now update the head pointer.  We use a spinlock to protect this
      * pointer, not because the update is likely to be non-atomic, but to
      * ensure that other processors see the above array updates before they
      * see the head pointer change.
      *
      * If we're holding ProcArrayLock exclusively, there's no need to take the
      * spinlock.
      */
     if (exclusive_lock)
         pArray->headKnownAssignedXids = head;
     else
     {
         SpinLockAcquire(&pArray->known_assigned_xids_lck);
         pArray->headKnownAssignedXids = head;
         SpinLockRelease(&pArray->known_assigned_xids_lck);
     }
 }

◆ KnownAssignedXidsCompress()

static void KnownAssignedXidsCompress ( bool force )

static

Definition at line 4504 of file procarray.c.

References ProcArrayStruct::headKnownAssignedXids, i, KnownAssignedXids, KnownAssignedXidsValid, ProcArrayStruct::numKnownAssignedXids, procArray, PROCARRAY_MAXPROCS, and ProcArrayStruct::tailKnownAssignedXids.

Referenced by KnownAssignedXidsAdd(), KnownAssignedXidsRemovePreceding(), and KnownAssignedXidsRemoveTree().

 {
     ProcArrayStruct *pArray = procArray;
     int         head,
                 tail;
     int         compress_index;
     int         i;
 
     /* no spinlock required since we hold ProcArrayLock exclusively */
     head = pArray->headKnownAssignedXids;
     tail = pArray->tailKnownAssignedXids;
 
     if (!force)
     {
         /*
          * If we can choose how much to compress, use a heuristic to avoid
          * compressing too often or not often enough.
          *
          * Heuristic is if we have a large enough current spread and less than
          * 50% of the elements are currently in use, then compress. This
          * should ensure we compress fairly infrequently. We could compress
          * less often though the virtual array would spread out more and
          * snapshots would become more expensive.
          */
         int         nelements = head - tail;
 
         if (nelements < 4 * PROCARRAY_MAXPROCS ||
             nelements < 2 * pArray->numKnownAssignedXids)
             return;
     }
 
     /*
      * We compress the array by reading the valid values from tail to head,
      * re-aligning data to 0th element.
      */
     compress_index = 0;
     for (i = tail; i < head; i++)
     {
         if (KnownAssignedXidsValid[i])
         {
             KnownAssignedXids[compress_index] = KnownAssignedXids[i];
             KnownAssignedXidsValid[compress_index] = true;
             compress_index++;
         }
     }
 
     pArray->tailKnownAssignedXids = 0;
     pArray->headKnownAssignedXids = compress_index;
 }

◆ KnownAssignedXidsDisplay()

static void KnownAssignedXidsDisplay ( int trace_level )

static

Definition at line 5023 of file procarray.c.

References appendStringInfo(), buf, StringInfoData::data, elog, ProcArrayStruct::headKnownAssignedXids, i, initStringInfo(), KnownAssignedXids, KnownAssignedXidsValid, ProcArrayStruct::numKnownAssignedXids, pfree(), procArray, and ProcArrayStruct::tailKnownAssignedXids.

Referenced by KnownAssignedXidsAdd(), and ProcArrayApplyRecoveryInfo().

 {
     ProcArrayStruct *pArray = procArray;
     StringInfoData buf;
     int         head,
                 tail,
                 i;
     int         nxids = 0;
 
     tail = pArray->tailKnownAssignedXids;
     head = pArray->headKnownAssignedXids;
 
     initStringInfo(&buf);
 
     for (i = tail; i < head; i++)
     {
         if (KnownAssignedXidsValid[i])
         {
             nxids++;
             appendStringInfo(&buf, "[%d]=%u ", i, KnownAssignedXids[i]);
         }
     }
 
     elog(trace_level, "%d KnownAssignedXids (num=%d tail=%d head=%d) %s",
          nxids,
          pArray->numKnownAssignedXids,
          pArray->tailKnownAssignedXids,
          pArray->headKnownAssignedXids,
          buf.data);
 
     pfree(buf.data);
 }

◆ KnownAssignedXidsGet()

static int KnownAssignedXidsGet	(	TransactionId *	xarray,
		TransactionId	xmax
	)

static

Definition at line 4916 of file procarray.c.

References InvalidTransactionId, and KnownAssignedXidsGetAndSetXmin().

Referenced by TransactionIdIsInProgress().

 {
     TransactionId xtmp = InvalidTransactionId;
 
     return KnownAssignedXidsGetAndSetXmin(xarray, &xtmp, xmax);
 }

◆ KnownAssignedXidsGetAndSetXmin()

static int KnownAssignedXidsGetAndSetXmin	(	TransactionId *	xarray,
		TransactionId *	xmin,
		TransactionId	xmax
	)

static

Definition at line 4930 of file procarray.c.

References ProcArrayStruct::headKnownAssignedXids, i, ProcArrayStruct::known_assigned_xids_lck, KnownAssignedXids, KnownAssignedXidsValid, SpinLockAcquire, SpinLockRelease, ProcArrayStruct::tailKnownAssignedXids, TransactionIdFollowsOrEquals(), TransactionIdIsValid, and TransactionIdPrecedes().

Referenced by GetSnapshotData(), and KnownAssignedXidsGet().

 {
     int         count = 0;
     int         head,
                 tail;
     int         i;
 
     /*
      * Fetch head just once, since it may change while we loop. We can stop
      * once we reach the initially seen head, since we are certain that an xid
      * cannot enter and then leave the array while we hold ProcArrayLock.  We
      * might miss newly-added xids, but they should be >= xmax so irrelevant
      * anyway.
      *
      * Must take spinlock to ensure we see up-to-date array contents.
      */
     SpinLockAcquire(&procArray->known_assigned_xids_lck);
     tail = procArray->tailKnownAssignedXids;
     head = procArray->headKnownAssignedXids;
     SpinLockRelease(&procArray->known_assigned_xids_lck);
 
     for (i = tail; i < head; i++)
     {
         /* Skip any gaps in the array */
         if (KnownAssignedXidsValid[i])
         {
             TransactionId knownXid = KnownAssignedXids[i];
 
             /*
              * Update xmin if required.  Only the first XID need be checked,
              * since the array is sorted.
              */
             if (count == 0 &&
                 TransactionIdPrecedes(knownXid, *xmin))
                 *xmin = knownXid;
 
             /*
              * Filter out anything >= xmax, again relying on sorted property
              * of array.
              */
             if (TransactionIdIsValid(xmax) &&
                 TransactionIdFollowsOrEquals(knownXid, xmax))
                 break;
 
             /* Add knownXid into output array */
             xarray[count++] = knownXid;
         }
     }
 
     return count;
 }

◆ KnownAssignedXidsGetOldestXmin()

static TransactionId KnownAssignedXidsGetOldestXmin ( void )

static

Definition at line 4988 of file procarray.c.

References ProcArrayStruct::headKnownAssignedXids, i, InvalidTransactionId, ProcArrayStruct::known_assigned_xids_lck, KnownAssignedXids, KnownAssignedXidsValid, SpinLockAcquire, SpinLockRelease, and ProcArrayStruct::tailKnownAssignedXids.

Referenced by ComputeXidHorizons().

 {
     int         head,
                 tail;
     int         i;
 
     /*
      * Fetch head just once, since it may change while we loop.
      */
     SpinLockAcquire(&procArray->known_assigned_xids_lck);
     tail = procArray->tailKnownAssignedXids;
     head = procArray->headKnownAssignedXids;
     SpinLockRelease(&procArray->known_assigned_xids_lck);
 
     for (i = tail; i < head; i++)
     {
         /* Skip any gaps in the array */
         if (KnownAssignedXidsValid[i])
             return KnownAssignedXids[i];
     }
 
     return InvalidTransactionId;
 }

◆ KnownAssignedXidsRemove()

static void KnownAssignedXidsRemove ( TransactionId xid )

static

Definition at line 4790 of file procarray.c.

References Assert, DEBUG4, elog, KnownAssignedXidsSearch(), trace_recovery(), and TransactionIdIsValid.

Referenced by KnownAssignedXidsRemoveTree().

 {
     Assert(TransactionIdIsValid(xid));
 
     elog(trace_recovery(DEBUG4), "remove KnownAssignedXid %u", xid);
 
     /*
      * Note: we cannot consider it an error to remove an XID that's not
      * present.  We intentionally remove subxact IDs while processing
      * XLOG_XACT_ASSIGNMENT, to avoid array overflow.  Then those XIDs will be
      * removed again when the top-level xact commits or aborts.
      *
      * It might be possible to track such XIDs to distinguish this case from
      * actual errors, but it would be complicated and probably not worth it.
      * So, just ignore the search result.
      */
     (void) KnownAssignedXidsSearch(xid, true);
 }

◆ KnownAssignedXidsRemovePreceding()

static void KnownAssignedXidsRemovePreceding ( TransactionId xid )

static

Definition at line 4838 of file procarray.c.

References Assert, DEBUG4, elog, ProcArrayStruct::headKnownAssignedXids, i, KnownAssignedXids, KnownAssignedXidsCompress(), KnownAssignedXidsValid, ProcArrayStruct::numKnownAssignedXids, procArray, StandbyTransactionIdIsPrepared(), ProcArrayStruct::tailKnownAssignedXids, trace_recovery(), TransactionIdFollowsOrEquals(), and TransactionIdIsValid.

Referenced by ExpireAllKnownAssignedTransactionIds(), and ExpireOldKnownAssignedTransactionIds().

 {
     ProcArrayStruct *pArray = procArray;
     int         count = 0;
     int         head,
                 tail,
                 i;
 
     if (!TransactionIdIsValid(removeXid))
     {
         elog(trace_recovery(DEBUG4), "removing all KnownAssignedXids");
         pArray->numKnownAssignedXids = 0;
         pArray->headKnownAssignedXids = pArray->tailKnownAssignedXids = 0;
         return;
     }
 
     elog(trace_recovery(DEBUG4), "prune KnownAssignedXids to %u", removeXid);
 
     /*
      * Mark entries invalid starting at the tail.  Since array is sorted, we
      * can stop as soon as we reach an entry >= removeXid.
      */
     tail = pArray->tailKnownAssignedXids;
     head = pArray->headKnownAssignedXids;
 
     for (i = tail; i < head; i++)
     {
         if (KnownAssignedXidsValid[i])
         {
             TransactionId knownXid = KnownAssignedXids[i];
 
             if (TransactionIdFollowsOrEquals(knownXid, removeXid))
                 break;
 
             if (!StandbyTransactionIdIsPrepared(knownXid))
             {
                 KnownAssignedXidsValid[i] = false;
                 count++;
             }
         }
     }
 
     pArray->numKnownAssignedXids -= count;
     Assert(pArray->numKnownAssignedXids >= 0);
 
     /*
      * Advance the tail pointer if we've marked the tail item invalid.
      */
     for (i = tail; i < head; i++)
     {
         if (KnownAssignedXidsValid[i])
             break;
     }
     if (i >= head)
     {
         /* Array is empty, so we can reset both pointers */
         pArray->headKnownAssignedXids = 0;
         pArray->tailKnownAssignedXids = 0;
     }
     else
     {
         pArray->tailKnownAssignedXids = i;
     }
 
     /* Opportunistically compress the array */
     KnownAssignedXidsCompress(false);
 }

◆ KnownAssignedXidsRemoveTree()

static void KnownAssignedXidsRemoveTree	(	TransactionId	xid,
		int	nsubxids,
		TransactionId *	subxids
	)

static

Definition at line 4816 of file procarray.c.

References i, KnownAssignedXidsCompress(), KnownAssignedXidsRemove(), and TransactionIdIsValid.

Referenced by ExpireTreeKnownAssignedTransactionIds(), and ProcArrayApplyXidAssignment().

 {
     int         i;
 
     if (TransactionIdIsValid(xid))
         KnownAssignedXidsRemove(xid);
 
     for (i = 0; i < nsubxids; i++)
         KnownAssignedXidsRemove(subxids[i]);
 
     /* Opportunistically compress the array */
     KnownAssignedXidsCompress(false);
 }

◆ KnownAssignedXidsReset()

static void KnownAssignedXidsReset ( void )

static

Definition at line 5061 of file procarray.c.

References ProcArrayStruct::headKnownAssignedXids, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), ProcArrayStruct::numKnownAssignedXids, procArray, and ProcArrayStruct::tailKnownAssignedXids.

Referenced by ProcArrayApplyRecoveryInfo().

 {
     ProcArrayStruct *pArray = procArray;
 
     LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
 
     pArray->numKnownAssignedXids = 0;
     pArray->tailKnownAssignedXids = 0;
     pArray->headKnownAssignedXids = 0;
 
     LWLockRelease(ProcArrayLock);
 }

◆ KnownAssignedXidsSearch()

static bool KnownAssignedXidsSearch	(	TransactionId	xid,
		bool	remove
	)

static

Definition at line 4684 of file procarray.c.

References Assert, ProcArrayStruct::headKnownAssignedXids, ProcArrayStruct::known_assigned_xids_lck, KnownAssignedXids, KnownAssignedXidsValid, ProcArrayStruct::numKnownAssignedXids, procArray, SpinLockAcquire, SpinLockRelease, ProcArrayStruct::tailKnownAssignedXids, and TransactionIdPrecedes().

Referenced by KnownAssignedXidExists(), and KnownAssignedXidsRemove().

 {
     ProcArrayStruct *pArray = procArray;
     int         first,
                 last;
     int         head;
     int         tail;
     int         result_index = -1;
 
     if (remove)
     {
         /* we hold ProcArrayLock exclusively, so no need for spinlock */
         tail = pArray->tailKnownAssignedXids;
         head = pArray->headKnownAssignedXids;
     }
     else
     {
         /* take spinlock to ensure we see up-to-date array contents */
         SpinLockAcquire(&pArray->known_assigned_xids_lck);
         tail = pArray->tailKnownAssignedXids;
         head = pArray->headKnownAssignedXids;
         SpinLockRelease(&pArray->known_assigned_xids_lck);
     }
 
     /*
      * Standard binary search.  Note we can ignore the KnownAssignedXidsValid
      * array here, since even invalid entries will contain sorted XIDs.
      */
     first = tail;
     last = head - 1;
     while (first <= last)
     {
         int         mid_index;
         TransactionId mid_xid;
 
         mid_index = (first + last) / 2;
         mid_xid = KnownAssignedXids[mid_index];
 
         if (xid == mid_xid)
         {
             result_index = mid_index;
             break;
         }
         else if (TransactionIdPrecedes(xid, mid_xid))
             last = mid_index - 1;
         else
             first = mid_index + 1;
     }
 
     if (result_index < 0)
         return false;           /* not in array */
 
     if (!KnownAssignedXidsValid[result_index])
         return false;           /* in array, but invalid */
 
     if (remove)
     {
         KnownAssignedXidsValid[result_index] = false;
 
         pArray->numKnownAssignedXids--;
         Assert(pArray->numKnownAssignedXids >= 0);
 
         /*
          * If we're removing the tail element then advance tail pointer over
          * any invalid elements.  This will speed future searches.
          */
         if (result_index == tail)
         {
             tail++;
             while (tail < head && !KnownAssignedXidsValid[tail])
                 tail++;
             if (tail >= head)
             {
                 /* Array is empty, so we can reset both pointers */
                 pArray->headKnownAssignedXids = 0;
                 pArray->tailKnownAssignedXids = 0;
             }
             else
             {
                 pArray->tailKnownAssignedXids = tail;
             }
         }
     }
 
     return true;
 }

◆ MaintainLatestCompletedXid()

static void MaintainLatestCompletedXid ( TransactionId latestXid )

static

Definition at line 913 of file procarray.c.

References Assert, FullTransactionIdIsNormal, FullTransactionIdIsValid, FullXidRelativeTo(), IsBootstrapProcessingMode, VariableCacheData::latestCompletedXid, LWLockHeldByMe(), RecoveryInProgress(), ShmemVariableCache, TransactionIdPrecedes(), and XidFromFullTransactionId.

Referenced by ProcArrayEndTransactionInternal(), ProcArrayRemove(), and XidCacheRemoveRunningXids().

 {
     FullTransactionId cur_latest = ShmemVariableCache->latestCompletedXid;
 
     Assert(FullTransactionIdIsValid(cur_latest));
     Assert(!RecoveryInProgress());
     Assert(LWLockHeldByMe(ProcArrayLock));
 
     if (TransactionIdPrecedes(XidFromFullTransactionId(cur_latest), latestXid))
     {
         ShmemVariableCache->latestCompletedXid =
             FullXidRelativeTo(cur_latest, latestXid);
     }
 
     Assert(IsBootstrapProcessingMode() ||
            FullTransactionIdIsNormal(ShmemVariableCache->latestCompletedXid));
 }

◆ MaintainLatestCompletedXidRecovery()

static void MaintainLatestCompletedXidRecovery ( TransactionId latestXid )

static

Definition at line 935 of file procarray.c.

References AmStartupProcess, Assert, FullTransactionIdIsNormal, FullTransactionIdIsValid, FullXidRelativeTo(), IsUnderPostmaster, VariableCacheData::latestCompletedXid, LWLockHeldByMe(), VariableCacheData::nextXid, ShmemVariableCache, TransactionIdPrecedes(), and XidFromFullTransactionId.

Referenced by ExpireTreeKnownAssignedTransactionIds(), and ProcArrayApplyRecoveryInfo().

 {
     FullTransactionId cur_latest = ShmemVariableCache->latestCompletedXid;
     FullTransactionId rel;
 
     Assert(AmStartupProcess() || !IsUnderPostmaster);
     Assert(LWLockHeldByMe(ProcArrayLock));
 
     /*
      * Need a FullTransactionId to compare latestXid with. Can't rely on
      * latestCompletedXid to be initialized in recovery. But in recovery it's
      * safe to access nextXid without a lock for the startup process.
      */
     rel = ShmemVariableCache->nextXid;
     Assert(FullTransactionIdIsValid(ShmemVariableCache->nextXid));
 
     if (!FullTransactionIdIsValid(cur_latest) ||
         TransactionIdPrecedes(XidFromFullTransactionId(cur_latest), latestXid))
     {
         ShmemVariableCache->latestCompletedXid =
             FullXidRelativeTo(rel, latestXid);
     }
 
     Assert(FullTransactionIdIsNormal(ShmemVariableCache->latestCompletedXid));
 }

◆ MinimumActiveBackends()

bool MinimumActiveBackends ( int min )

Definition at line 3407 of file procarray.c.

References InvalidTransactionId, MyProc, ProcArrayStruct::numProcs, ProcArrayStruct::pgprocnos, PGPROC::pid, procArray, PGPROC::waitLock, and PGPROC::xid.

Referenced by XLogFlush().

 {
     ProcArrayStruct *arrayP = procArray;
     int         count = 0;
     int         index;
 
     /* Quick short-circuit if no minimum is specified */
     if (min == 0)
         return true;
 
     /*
      * Note: for speed, we don't acquire ProcArrayLock.  This is a little bit
      * bogus, but since we are only testing fields for zero or nonzero, it
      * should be OK.  The result is only used for heuristic purposes anyway...
      */
     for (index = 0; index < arrayP->numProcs; index++)
     {
         int         pgprocno = arrayP->pgprocnos[index];
         PGPROC     *proc = &allProcs[pgprocno];
 
         /*
          * Since we're not holding a lock, need to be prepared to deal with
          * garbage, as someone could have incremented numProcs but not yet
          * filled the structure.
          *
          * If someone just decremented numProcs, 'proc' could also point to a
          * PGPROC entry that's no longer in the array. It still points to a
          * PGPROC struct, though, because freed PGPROC entries just go to the
          * free list and are recycled. Its contents are nonsense in that case,
          * but that's acceptable for this function.
          */
         if (pgprocno == -1)
             continue;           /* do not count deleted entries */
         if (proc == MyProc)
             continue;           /* do not count myself */
         if (proc->xid == InvalidTransactionId)
             continue;           /* do not count if no XID assigned */
         if (proc->pid == 0)
             continue;           /* do not count prepared xacts */
         if (proc->waitLock != NULL)
             continue;           /* do not count if blocked on a lock */
         count++;
         if (count >= min)
             break;
     }
 
     return count >= min;
 }

◆ ProcArrayAdd()

void ProcArrayAdd ( PGPROC * proc )

Definition at line 445 of file procarray.c.

References ereport, errcode(), errmsg(), FATAL, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), ProcArrayStruct::maxProcs, ProcArrayStruct::numProcs, PGPROC::pgprocno, ProcArrayStruct::pgprocnos, PGPROC::pgxactoff, procArray, ProcGlobal, PGPROC::statusFlags, PROC_HDR::statusFlags, PROC_HDR::subxidStates, PGPROC::subxidStatus, PGPROC::xid, and PROC_HDR::xids.

Referenced by InitProcessPhase2(), and MarkAsPrepared().

 {
     ProcArrayStruct *arrayP = procArray;
     int         index;
 
     /* See ProcGlobal comment explaining why both locks are held */
     LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
     LWLockAcquire(XidGenLock, LW_EXCLUSIVE);
 
     if (arrayP->numProcs >= arrayP->maxProcs)
     {
         /*
          * Oops, no room.  (This really shouldn't happen, since there is a
          * fixed supply of PGPROC structs too, and so we should have failed
          * earlier.)
          */
         ereport(FATAL,
                 (errcode(ERRCODE_TOO_MANY_CONNECTIONS),
                  errmsg("sorry, too many clients already")));
     }
 
     /*
      * Keep the procs array sorted by (PGPROC *) so that we can utilize
      * locality of references much better. This is useful while traversing the
      * ProcArray because there is an increased likelihood of finding the next
      * PGPROC structure in the cache.
      *
      * Since the occurrence of adding/removing a proc is much lower than the
      * access to the ProcArray itself, the overhead should be marginal
      */
     for (index = 0; index < arrayP->numProcs; index++)
     {
         /*
          * If we are the first PGPROC or if we have found our right position
          * in the array, break
          */
         if ((arrayP->pgprocnos[index] == -1) || (arrayP->pgprocnos[index] > proc->pgprocno))
             break;
     }
 
     memmove(&arrayP->pgprocnos[index + 1], &arrayP->pgprocnos[index],
             (arrayP->numProcs - index) * sizeof(*arrayP->pgprocnos));
     memmove(&ProcGlobal->xids[index + 1], &ProcGlobal->xids[index],
             (arrayP->numProcs - index) * sizeof(*ProcGlobal->xids));
     memmove(&ProcGlobal->subxidStates[index + 1], &ProcGlobal->subxidStates[index],
             (arrayP->numProcs - index) * sizeof(*ProcGlobal->subxidStates));
     memmove(&ProcGlobal->statusFlags[index + 1], &ProcGlobal->statusFlags[index],
             (arrayP->numProcs - index) * sizeof(*ProcGlobal->statusFlags));
 
     arrayP->pgprocnos[index] = proc->pgprocno;
     ProcGlobal->xids[index] = proc->xid;
     ProcGlobal->subxidStates[index] = proc->subxidStatus;
     ProcGlobal->statusFlags[index] = proc->statusFlags;
 
     arrayP->numProcs++;
 
     for (; index < arrayP->numProcs; index++)
     {
         allProcs[arrayP->pgprocnos[index]].pgxactoff = index;
     }
 
     /*
      * Release in reversed acquisition order, to reduce frequency of having to
      * wait for XidGenLock while holding ProcArrayLock.
      */
     LWLockRelease(XidGenLock);
     LWLockRelease(ProcArrayLock);
 }

◆ ProcArrayApplyRecoveryInfo()

void ProcArrayApplyRecoveryInfo ( RunningTransactions running )

Definition at line 1000 of file procarray.c.

References AdvanceNextFullTransactionIdPastXid(), Assert, DEBUG1, DEBUG3, elog, ERROR, ExpireOldKnownAssignedTransactionIds(), ExtendSUBTRANS(), FullTransactionIdIsValid, i, InvalidTransactionId, KnownAssignedXidsAdd(), KnownAssignedXidsDisplay(), KnownAssignedXidsReset(), ProcArrayStruct::lastOverflowedXid, RunningTransactionsData::latestCompletedXid, latestObservedXid, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MaintainLatestCompletedXidRecovery(), RunningTransactionsData::nextXid, VariableCacheData::nextXid, ProcArrayStruct::numKnownAssignedXids, RunningTransactionsData::oldestRunningXid, palloc(), pfree(), qsort, ShmemVariableCache, STANDBY_INITIALIZED, STANDBY_SNAPSHOT_PENDING, STANDBY_SNAPSHOT_READY, StandbyReleaseOldLocks(), standbySnapshotPendingXmin, standbyState, RunningTransactionsData::subxcnt, RunningTransactionsData::subxid_overflow, trace_recovery(), TransactionIdAdvance, TransactionIdDidAbort(), TransactionIdDidCommit(), TransactionIdEquals, TransactionIdIsNormal, TransactionIdIsValid, TransactionIdPrecedes(), TransactionIdRetreat, RunningTransactionsData::xcnt, xidComparator(), and RunningTransactionsData::xids.

Referenced by standby_redo(), StartupXLOG(), and xlog_redo().

 {
     TransactionId *xids;
     int         nxids;
     int         i;
 
     Assert(standbyState >= STANDBY_INITIALIZED);
     Assert(TransactionIdIsValid(running->nextXid));
     Assert(TransactionIdIsValid(running->oldestRunningXid));
     Assert(TransactionIdIsNormal(running->latestCompletedXid));
 
     /*
      * Remove stale transactions, if any.
      */
     ExpireOldKnownAssignedTransactionIds(running->oldestRunningXid);
 
     /*
      * Remove stale locks, if any.
      */
     StandbyReleaseOldLocks(running->oldestRunningXid);
 
     /*
      * If our snapshot is already valid, nothing else to do...
      */
     if (standbyState == STANDBY_SNAPSHOT_READY)
         return;
 
     /*
      * If our initial RunningTransactionsData had an overflowed snapshot then
      * we knew we were missing some subxids from our snapshot. If we continue
      * to see overflowed snapshots then we might never be able to start up, so
      * we make another test to see if our snapshot is now valid. We know that
      * the missing subxids are equal to or earlier than nextXid. After we
      * initialise we continue to apply changes during recovery, so once the
      * oldestRunningXid is later than the nextXid from the initial snapshot we
      * know that we no longer have missing information and can mark the
      * snapshot as valid.
      */
     if (standbyState == STANDBY_SNAPSHOT_PENDING)
     {
         /*
          * If the snapshot isn't overflowed or if its empty we can reset our
          * pending state and use this snapshot instead.
          */
         if (!running->subxid_overflow || running->xcnt == 0)
         {
             /*
              * If we have already collected known assigned xids, we need to
              * throw them away before we apply the recovery snapshot.
              */
             KnownAssignedXidsReset();
             standbyState = STANDBY_INITIALIZED;
         }
         else
         {
             if (TransactionIdPrecedes(standbySnapshotPendingXmin,
                                       running->oldestRunningXid))
             {
                 standbyState = STANDBY_SNAPSHOT_READY;
                 elog(trace_recovery(DEBUG1),
                      "recovery snapshots are now enabled");
             }
             else
                 elog(trace_recovery(DEBUG1),
                      "recovery snapshot waiting for non-overflowed snapshot or "
                      "until oldest active xid on standby is at least %u (now %u)",
                      standbySnapshotPendingXmin,
                      running->oldestRunningXid);
             return;
         }
     }
 
     Assert(standbyState == STANDBY_INITIALIZED);
 
     /*
      * NB: this can be reached at least twice, so make sure new code can deal
      * with that.
      */
 
     /*
      * Nobody else is running yet, but take locks anyhow
      */
     LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
 
     /*
      * KnownAssignedXids is sorted so we cannot just add the xids, we have to
      * sort them first.
      *
      * Some of the new xids are top-level xids and some are subtransactions.
      * We don't call SubTransSetParent because it doesn't matter yet. If we
      * aren't overflowed then all xids will fit in snapshot and so we don't
      * need subtrans. If we later overflow, an xid assignment record will add
      * xids to subtrans. If RunningTransactionsData is overflowed then we
      * don't have enough information to correctly update subtrans anyway.
      */
 
     /*
      * Allocate a temporary array to avoid modifying the array passed as
      * argument.
      */
     xids = palloc(sizeof(TransactionId) * (running->xcnt + running->subxcnt));
 
     /*
      * Add to the temp array any xids which have not already completed.
      */
     nxids = 0;
     for (i = 0; i < running->xcnt + running->subxcnt; i++)
     {
         TransactionId xid = running->xids[i];
 
         /*
          * The running-xacts snapshot can contain xids that were still visible
          * in the procarray when the snapshot was taken, but were already
          * WAL-logged as completed. They're not running anymore, so ignore
          * them.
          */
         if (TransactionIdDidCommit(xid) || TransactionIdDidAbort(xid))
             continue;
 
         xids[nxids++] = xid;
     }
 
     if (nxids > 0)
     {
         if (procArray->numKnownAssignedXids != 0)
         {
             LWLockRelease(ProcArrayLock);
             elog(ERROR, "KnownAssignedXids is not empty");
         }
 
         /*
          * Sort the array so that we can add them safely into
          * KnownAssignedXids.
          */
         qsort(xids, nxids, sizeof(TransactionId), xidComparator);
 
         /*
          * Add the sorted snapshot into KnownAssignedXids.  The running-xacts
          * snapshot may include duplicated xids because of prepared
          * transactions, so ignore them.
          */
         for (i = 0; i < nxids; i++)
         {
             if (i > 0 && TransactionIdEquals(xids[i - 1], xids[i]))
             {
                 elog(DEBUG1,
                      "found duplicated transaction %u for KnownAssignedXids insertion",
                      xids[i]);
                 continue;
             }
             KnownAssignedXidsAdd(xids[i], xids[i], true);
         }
 
         KnownAssignedXidsDisplay(trace_recovery(DEBUG3));
     }
 
     pfree(xids);
 
     /*
      * latestObservedXid is at least set to the point where SUBTRANS was
      * started up to (cf. ProcArrayInitRecovery()) or to the biggest xid
      * RecordKnownAssignedTransactionIds() was called for.  Initialize
      * subtrans from thereon, up to nextXid - 1.
      *
      * We need to duplicate parts of RecordKnownAssignedTransactionId() here,
      * because we've just added xids to the known assigned xids machinery that
      * haven't gone through RecordKnownAssignedTransactionId().
      */
     Assert(TransactionIdIsNormal(latestObservedXid));
     TransactionIdAdvance(latestObservedXid);
     while (TransactionIdPrecedes(latestObservedXid, running->nextXid))
     {
         ExtendSUBTRANS(latestObservedXid);
         TransactionIdAdvance(latestObservedXid);
     }
     TransactionIdRetreat(latestObservedXid);    /* = running->nextXid - 1 */
 
     /* ----------
      * Now we've got the running xids we need to set the global values that
      * are used to track snapshots as they evolve further.
      *
      * - latestCompletedXid which will be the xmax for snapshots
      * - lastOverflowedXid which shows whether snapshots overflow
      * - nextXid
      *
      * If the snapshot overflowed, then we still initialise with what we know,
      * but the recovery snapshot isn't fully valid yet because we know there
      * are some subxids missing. We don't know the specific subxids that are
      * missing, so conservatively assume the last one is latestObservedXid.
      * ----------
      */
     if (running->subxid_overflow)
     {
         standbyState = STANDBY_SNAPSHOT_PENDING;
 
         standbySnapshotPendingXmin = latestObservedXid;
         procArray->lastOverflowedXid = latestObservedXid;
     }
     else
     {
         standbyState = STANDBY_SNAPSHOT_READY;
 
         standbySnapshotPendingXmin = InvalidTransactionId;
     }
 
     /*
      * If a transaction wrote a commit record in the gap between taking and
      * logging the snapshot then latestCompletedXid may already be higher than
      * the value from the snapshot, so check before we use the incoming value.
      * It also might not yet be set at all.
      */
     MaintainLatestCompletedXidRecovery(running->latestCompletedXid);
 
     LWLockRelease(ProcArrayLock);
 
     /* ShmemVariableCache->nextXid must be beyond any observed xid. */
     AdvanceNextFullTransactionIdPastXid(latestObservedXid);
 
     Assert(FullTransactionIdIsValid(ShmemVariableCache->nextXid));
 
     KnownAssignedXidsDisplay(trace_recovery(DEBUG3));
     if (standbyState == STANDBY_SNAPSHOT_READY)
         elog(trace_recovery(DEBUG1), "recovery snapshots are now enabled");
     else
         elog(trace_recovery(DEBUG1),
              "recovery snapshot waiting for non-overflowed snapshot or "
              "until oldest active xid on standby is at least %u (now %u)",
              standbySnapshotPendingXmin,
              running->oldestRunningXid);
 }

◆ ProcArrayApplyXidAssignment()

void ProcArrayApplyXidAssignment	(	TransactionId	topxid,
		int	nsubxids,
		TransactionId *	subxids
	)

Definition at line 1236 of file procarray.c.

References Assert, i, InvalidTransactionId, KnownAssignedXidsRemoveTree(), ProcArrayStruct::lastOverflowedXid, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), RecordKnownAssignedTransactionIds(), STANDBY_INITIALIZED, standbyState, SubTransSetParent(), TransactionIdLatest(), and TransactionIdPrecedes().

Referenced by xact_redo().

 {
     TransactionId max_xid;
     int         i;
 
     Assert(standbyState >= STANDBY_INITIALIZED);
 
     max_xid = TransactionIdLatest(topxid, nsubxids, subxids);
 
     /*
      * Mark all the subtransactions as observed.
      *
      * NOTE: This will fail if the subxid contains too many previously
      * unobserved xids to fit into known-assigned-xids. That shouldn't happen
      * as the code stands, because xid-assignment records should never contain
      * more than PGPROC_MAX_CACHED_SUBXIDS entries.
      */
     RecordKnownAssignedTransactionIds(max_xid);
 
     /*
      * Notice that we update pg_subtrans with the top-level xid, rather than
      * the parent xid. This is a difference between normal processing and
      * recovery, yet is still correct in all cases. The reason is that
      * subtransaction commit is not marked in clog until commit processing, so
      * all aborted subtransactions have already been clearly marked in clog.
      * As a result we are able to refer directly to the top-level
      * transaction's state rather than skipping through all the intermediate
      * states in the subtransaction tree. This should be the first time we
      * have attempted to SubTransSetParent().
      */
     for (i = 0; i < nsubxids; i++)
         SubTransSetParent(subxids[i], topxid);
 
     /* KnownAssignedXids isn't maintained yet, so we're done for now */
     if (standbyState == STANDBY_INITIALIZED)
         return;
 
     /*
      * Uses same locking as transaction commit
      */
     LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
 
     /*
      * Remove subxids from known-assigned-xacts.
      */
     KnownAssignedXidsRemoveTree(InvalidTransactionId, nsubxids, subxids);
 
     /*
      * Advance lastOverflowedXid to be at least the last of these subxids.
      */
     if (TransactionIdPrecedes(procArray->lastOverflowedXid, max_xid))
         procArray->lastOverflowedXid = max_xid;
 
     LWLockRelease(ProcArrayLock);
 }

◆ ProcArrayClearTransaction()

void ProcArrayClearTransaction ( PGPROC * proc )

Definition at line 853 of file procarray.c.

References Assert, XidCacheStatus::count, PGPROC::delayChkpt, InvalidLocalTransactionId, InvalidTransactionId, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), PGPROC::lxid, XidCacheStatus::overflowed, PGPROC::pgxactoff, PROC_VACUUM_STATE_MASK, ProcGlobal, PGPROC::recoveryConflictPending, ShmemVariableCache, PGPROC::statusFlags, PROC_HDR::subxidStates, PGPROC::subxidStatus, VariableCacheData::xactCompletionCount, PGPROC::xid, PROC_HDR::xids, and PGPROC::xmin.

Referenced by PrepareTransaction().

 {
     size_t      pgxactoff;
 
     /*
      * Currently we need to lock ProcArrayLock exclusively here, as we
      * increment xactCompletionCount below. We also need it at least in shared
      * mode for pgproc->pgxactoff to stay the same below.
      *
      * We could however, as this action does not actually change anyone's view
      * of the set of running XIDs (our entry is duplicate with the gxact that
      * has already been inserted into the ProcArray), lower the lock level to
      * shared if we were to make xactCompletionCount an atomic variable. But
      * that doesn't seem worth it currently, as a 2PC commit is heavyweight
      * enough for this not to be the bottleneck.  If it ever becomes a
      * bottleneck it may also be worth considering to combine this with the
      * subsequent ProcArrayRemove()
      */
     LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
 
     pgxactoff = proc->pgxactoff;
 
     ProcGlobal->xids[pgxactoff] = InvalidTransactionId;
     proc->xid = InvalidTransactionId;
 
     proc->lxid = InvalidLocalTransactionId;
     proc->xmin = InvalidTransactionId;
     proc->recoveryConflictPending = false;
 
     Assert(!(proc->statusFlags & PROC_VACUUM_STATE_MASK));
     Assert(!proc->delayChkpt);
 
     /*
      * Need to increment completion count even though transaction hasn't
      * really committed yet. The reason for that is that GetSnapshotData()
      * omits the xid of the current transaction, thus without the increment we
      * otherwise could end up reusing the snapshot later. Which would be bad,
      * because it might not count the prepared transaction as running.
      */
     ShmemVariableCache->xactCompletionCount++;
 
     /* Clear the subtransaction-XID cache too */
     Assert(ProcGlobal->subxidStates[pgxactoff].count == proc->subxidStatus.count &&
            ProcGlobal->subxidStates[pgxactoff].overflowed == proc->subxidStatus.overflowed);
     if (proc->subxidStatus.count > 0 || proc->subxidStatus.overflowed)
     {
         ProcGlobal->subxidStates[pgxactoff].count = 0;
         ProcGlobal->subxidStates[pgxactoff].overflowed = false;
         proc->subxidStatus.count = 0;
         proc->subxidStatus.overflowed = false;
     }
 
     LWLockRelease(ProcArrayLock);
 }

◆ ProcArrayEndTransaction()

void ProcArrayEndTransaction	(	PGPROC *	proc,
		TransactionId	latestXid
	)

Definition at line 620 of file procarray.c.

References Assert, XidCacheStatus::count, PGPROC::delayChkpt, InvalidLocalTransactionId, InvalidTransactionId, LW_EXCLUSIVE, LWLockAcquire(), LWLockConditionalAcquire(), LWLockHeldByMe(), LWLockRelease(), PGPROC::lxid, XidCacheStatus::overflowed, PGPROC::pgxactoff, PROC_VACUUM_STATE_MASK, ProcArrayEndTransactionInternal(), ProcArrayGroupClearXid(), ProcGlobal, PGPROC::recoveryConflictPending, PGPROC::statusFlags, PROC_HDR::statusFlags, PGPROC::subxidStatus, TransactionIdIsValid, PGPROC::xid, and PGPROC::xmin.

Referenced by AbortTransaction(), and CommitTransaction().

 {
     if (TransactionIdIsValid(latestXid))
     {
         /*
          * We must lock ProcArrayLock while clearing our advertised XID, so
          * that we do not exit the set of "running" transactions while someone
          * else is taking a snapshot.  See discussion in
          * src/backend/access/transam/README.
          */
         Assert(TransactionIdIsValid(proc->xid));
 
         /*
          * If we can immediately acquire ProcArrayLock, we clear our own XID
          * and release the lock.  If not, use group XID clearing to improve
          * efficiency.
          */
         if (LWLockConditionalAcquire(ProcArrayLock, LW_EXCLUSIVE))
         {
             ProcArrayEndTransactionInternal(proc, latestXid);
             LWLockRelease(ProcArrayLock);
         }
         else
             ProcArrayGroupClearXid(proc, latestXid);
     }
     else
     {
         /*
          * If we have no XID, we don't need to lock, since we won't affect
          * anyone else's calculation of a snapshot.  We might change their
          * estimate of global xmin, but that's OK.
          */
         Assert(!TransactionIdIsValid(proc->xid));
         Assert(proc->subxidStatus.count == 0);
         Assert(!proc->subxidStatus.overflowed);
 
         proc->lxid = InvalidLocalTransactionId;
         proc->xmin = InvalidTransactionId;
         proc->delayChkpt = false;   /* be sure this is cleared in abort */
         proc->recoveryConflictPending = false;
 
         /* must be cleared with xid/xmin: */
         /* avoid unnecessarily dirtying shared cachelines */
         if (proc->statusFlags & PROC_VACUUM_STATE_MASK)
         {
             Assert(!LWLockHeldByMe(ProcArrayLock));
             LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
             Assert(proc->statusFlags == ProcGlobal->statusFlags[proc->pgxactoff]);
             proc->statusFlags &= ~PROC_VACUUM_STATE_MASK;
             ProcGlobal->statusFlags[proc->pgxactoff] = proc->statusFlags;
             LWLockRelease(ProcArrayLock);
         }
     }
 }

◆ ProcArrayEndTransactionInternal()

static void ProcArrayEndTransactionInternal	(	PGPROC *	proc,
		TransactionId	latestXid
	)

inlinestatic

Definition at line 681 of file procarray.c.

References Assert, XidCacheStatus::count, PGPROC::delayChkpt, InvalidLocalTransactionId, InvalidTransactionId, LW_EXCLUSIVE, LWLockHeldByMeInMode(), PGPROC::lxid, MaintainLatestCompletedXid(), XidCacheStatus::overflowed, PGPROC::pgxactoff, PROC_VACUUM_STATE_MASK, ProcGlobal, PGPROC::recoveryConflictPending, ShmemVariableCache, PGPROC::statusFlags, PROC_HDR::statusFlags, PROC_HDR::subxidStates, PGPROC::subxidStatus, TransactionIdIsValid, VariableCacheData::xactCompletionCount, PGPROC::xid, PROC_HDR::xids, and PGPROC::xmin.

Referenced by ProcArrayEndTransaction(), and ProcArrayGroupClearXid().

 {
     size_t      pgxactoff = proc->pgxactoff;
 
     /*
      * Note: we need exclusive lock here because we're going to change other
      * processes' PGPROC entries.
      */
     Assert(LWLockHeldByMeInMode(ProcArrayLock, LW_EXCLUSIVE));
     Assert(TransactionIdIsValid(ProcGlobal->xids[pgxactoff]));
     Assert(ProcGlobal->xids[pgxactoff] == proc->xid);
 
     ProcGlobal->xids[pgxactoff] = InvalidTransactionId;
     proc->xid = InvalidTransactionId;
     proc->lxid = InvalidLocalTransactionId;
     proc->xmin = InvalidTransactionId;
     proc->delayChkpt = false;   /* be sure this is cleared in abort */
     proc->recoveryConflictPending = false;
 
     /* must be cleared with xid/xmin: */
     /* avoid unnecessarily dirtying shared cachelines */
     if (proc->statusFlags & PROC_VACUUM_STATE_MASK)
     {
         proc->statusFlags &= ~PROC_VACUUM_STATE_MASK;
         ProcGlobal->statusFlags[proc->pgxactoff] = proc->statusFlags;
     }
 
     /* Clear the subtransaction-XID cache too while holding the lock */
     Assert(ProcGlobal->subxidStates[pgxactoff].count == proc->subxidStatus.count &&
            ProcGlobal->subxidStates[pgxactoff].overflowed == proc->subxidStatus.overflowed);
     if (proc->subxidStatus.count > 0 || proc->subxidStatus.overflowed)
     {
         ProcGlobal->subxidStates[pgxactoff].count = 0;
         ProcGlobal->subxidStates[pgxactoff].overflowed = false;
         proc->subxidStatus.count = 0;
         proc->subxidStatus.overflowed = false;
     }
 
     /* Also advance global latestCompletedXid while holding the lock */
     MaintainLatestCompletedXid(latestXid);
 
     /* Same with xactCompletionCount  */
     ShmemVariableCache->xactCompletionCount++;
 }

◆ ProcArrayGetReplicationSlotXmin()

void ProcArrayGetReplicationSlotXmin	(	TransactionId *	xmin,
		TransactionId *	catalog_xmin
	)

Definition at line 3819 of file procarray.c.

References LW_SHARED, LWLockAcquire(), LWLockRelease(), ProcArrayStruct::replication_slot_catalog_xmin, and ProcArrayStruct::replication_slot_xmin.

Referenced by logical_begin_heap_rewrite().

 {
     LWLockAcquire(ProcArrayLock, LW_SHARED);
 
     if (xmin != NULL)
         *xmin = procArray->replication_slot_xmin;
 
     if (catalog_xmin != NULL)
         *catalog_xmin = procArray->replication_slot_catalog_xmin;
 
     LWLockRelease(ProcArrayLock);
 }

◆ ProcArrayGroupClearXid()

static void ProcArrayGroupClearXid	(	PGPROC *	proc,
		TransactionId	latestXid
	)

static

Definition at line 739 of file procarray.c.

References Assert, INVALID_PGPROCNO, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MyProc, pg_atomic_compare_exchange_u32(), pg_atomic_exchange_u32(), pg_atomic_read_u32(), pg_atomic_write_u32(), pg_write_barrier, PGPROC::pgprocno, PGSemaphoreLock(), PGSemaphoreUnlock(), pgstat_report_wait_end(), pgstat_report_wait_start(), ProcArrayEndTransactionInternal(), PROC_HDR::procArrayGroupFirst, PGPROC::procArrayGroupMember, PGPROC::procArrayGroupMemberXid, PGPROC::procArrayGroupNext, ProcGlobal, PGPROC::sem, TransactionIdIsValid, WAIT_EVENT_PROCARRAY_GROUP_UPDATE, and PGPROC::xid.

Referenced by ProcArrayEndTransaction().

 {
     PROC_HDR   *procglobal = ProcGlobal;
     uint32      nextidx;
     uint32      wakeidx;
 
     /* We should definitely have an XID to clear. */
     Assert(TransactionIdIsValid(proc->xid));
 
     /* Add ourselves to the list of processes needing a group XID clear. */
     proc->procArrayGroupMember = true;
     proc->procArrayGroupMemberXid = latestXid;
     nextidx = pg_atomic_read_u32(&procglobal->procArrayGroupFirst);
     while (true)
     {
         pg_atomic_write_u32(&proc->procArrayGroupNext, nextidx);
 
         if (pg_atomic_compare_exchange_u32(&procglobal->procArrayGroupFirst,
                                            &nextidx,
                                            (uint32) proc->pgprocno))
             break;
     }
 
     /*
      * If the list was not empty, the leader will clear our XID.  It is
      * impossible to have followers without a leader because the first process
      * that has added itself to the list will always have nextidx as
      * INVALID_PGPROCNO.
      */
     if (nextidx != INVALID_PGPROCNO)
     {
         int         extraWaits = 0;
 
         /* Sleep until the leader clears our XID. */
         pgstat_report_wait_start(WAIT_EVENT_PROCARRAY_GROUP_UPDATE);
         for (;;)
         {
             /* acts as a read barrier */
             PGSemaphoreLock(proc->sem);
             if (!proc->procArrayGroupMember)
                 break;
             extraWaits++;
         }
         pgstat_report_wait_end();
 
         Assert(pg_atomic_read_u32(&proc->procArrayGroupNext) == INVALID_PGPROCNO);
 
         /* Fix semaphore count for any absorbed wakeups */
         while (extraWaits-- > 0)
             PGSemaphoreUnlock(proc->sem);
         return;
     }
 
     /* We are the leader.  Acquire the lock on behalf of everyone. */
     LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
 
     /*
      * Now that we've got the lock, clear the list of processes waiting for
      * group XID clearing, saving a pointer to the head of the list.  Trying
      * to pop elements one at a time could lead to an ABA problem.
      */
     nextidx = pg_atomic_exchange_u32(&procglobal->procArrayGroupFirst,
                                      INVALID_PGPROCNO);
 
     /* Remember head of list so we can perform wakeups after dropping lock. */
     wakeidx = nextidx;
 
     /* Walk the list and clear all XIDs. */
     while (nextidx != INVALID_PGPROCNO)
     {
         PGPROC     *proc = &allProcs[nextidx];
 
         ProcArrayEndTransactionInternal(proc, proc->procArrayGroupMemberXid);
 
         /* Move to next proc in list. */
         nextidx = pg_atomic_read_u32(&proc->procArrayGroupNext);
     }
 
     /* We're done with the lock now. */
     LWLockRelease(ProcArrayLock);
 
     /*
      * Now that we've released the lock, go back and wake everybody up.  We
      * don't do this under the lock so as to keep lock hold times to a
      * minimum.  The system calls we need to perform to wake other processes
      * up are probably much slower than the simple memory writes we did while
      * holding the lock.
      */
     while (wakeidx != INVALID_PGPROCNO)
     {
         PGPROC     *proc = &allProcs[wakeidx];
 
         wakeidx = pg_atomic_read_u32(&proc->procArrayGroupNext);
         pg_atomic_write_u32(&proc->procArrayGroupNext, INVALID_PGPROCNO);
 
         /* ensure all previous writes are visible before follower continues. */
         pg_write_barrier();
 
         proc->procArrayGroupMember = false;
 
         if (proc != MyProc)
             PGSemaphoreUnlock(proc->sem);
     }
 }

Data Structures

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ MAXAUTOVACPIDS

◆ PROCARRAY_MAXPROCS

◆ TOTAL_MAX_CACHED_SUBXIDS

◆ UINT32_ACCESS_ONCE

◆ xc_by_child_xid_inc

◆ xc_by_known_assigned_inc

◆ xc_by_known_xact_inc

◆ xc_by_latest_xid_inc

◆ xc_by_main_xid_inc

◆ xc_by_my_xact_inc

◆ xc_by_recent_xmin_inc

◆ xc_no_overflow_inc

◆ xc_slow_answer_inc

Typedef Documentation

◆ ComputeXidHorizonsResult

◆ ProcArrayStruct

Function Documentation

◆ BackendPidGetProc()

◆ BackendPidGetProcWithLock()

◆ BackendXidGetPid()

◆ CancelDBBackends()

◆ CancelVirtualTransaction()

◆ ComputeXidHorizons()

◆ CountDBBackends()

◆ CountDBConnections()

◆ CountOtherDBBackends()

◆ CountUserBackends()

◆ CreateSharedProcArray()

◆ ExpireAllKnownAssignedTransactionIds()

◆ ExpireOldKnownAssignedTransactionIds()

◆ ExpireTreeKnownAssignedTransactionIds()

◆ FullXidRelativeTo()

◆ GetConflictingVirtualXIDs()

◆ GetCurrentVirtualXIDs()

◆ GetMaxSnapshotSubxidCount()

◆ GetMaxSnapshotXidCount()

◆ GetOldestActiveTransactionId()

◆ GetOldestNonRemovableTransactionId()

◆ GetOldestSafeDecodingTransactionId()

◆ GetOldestTransactionIdConsideredRunning()

◆ GetReplicationHorizons()

◆ GetRunningTransactionData()

◆ GetSnapshotData()

◆ GetSnapshotDataInitOldSnapshot()

◆ GetSnapshotDataReuse()

◆ GetVirtualXIDsDelayingChkpt()

◆ GlobalVisCheckRemovableFullXid()

◆ GlobalVisCheckRemovableXid()

◆ GlobalVisTestFor()

◆ GlobalVisTestIsRemovableFullXid()

◆ GlobalVisTestIsRemovableXid()

◆ GlobalVisTestNonRemovableFullHorizon()

◆ GlobalVisTestNonRemovableHorizon()

◆ GlobalVisTestShouldUpdate()

◆ GlobalVisUpdate()

◆ GlobalVisUpdateApply()

◆ HaveVirtualXIDsDelayingChkpt()

◆ IsBackendPid()

◆ KnownAssignedXidExists()

◆ KnownAssignedXidsAdd()

◆ KnownAssignedXidsCompress()

◆ KnownAssignedXidsDisplay()

◆ KnownAssignedXidsGet()

◆ KnownAssignedXidsGetAndSetXmin()

◆ KnownAssignedXidsGetOldestXmin()

◆ KnownAssignedXidsRemove()

◆ KnownAssignedXidsRemovePreceding()

◆ KnownAssignedXidsRemoveTree()

◆ KnownAssignedXidsReset()

◆ KnownAssignedXidsSearch()

◆ MaintainLatestCompletedXid()

◆ MaintainLatestCompletedXidRecovery()

◆ MinimumActiveBackends()

◆ ProcArrayAdd()