#include "storage/lock.h"
#include "storage/standby.h"
#include "utils/relcache.h"
#include "utils/snapshot.h"

Include dependency graph for procarray.h:

This graph shows which files directly or indirectly include this file:

Macros
#define	PROCARRAY_VACUUM_FLAG

#define	PROCARRAY_ANALYZE_FLAG

#define	PROCARRAY_LOGICAL_DECODING_FLAG

#define	PROCARRAY_SLOTS_XMIN

#define	PROCARRAY_PROC_FLAGS_MASK

#define	PROCARRAY_FLAGS_DEFAULT PROCARRAY_LOGICAL_DECODING_FLAG

#define	PROCARRAY_FLAGS_VACUUM PROCARRAY_FLAGS_DEFAULT \| PROCARRAY_VACUUM_FLAG

#define	PROCARRAY_FLAGS_ANALYZE PROCARRAY_FLAGS_DEFAULT \| PROCARRAY_ANALYZE_FLAG

#define	PROCARRAY_FLAGS_VACUUM_ANALYZE PROCARRAY_FLAGS_DEFAULT \| PROCARRAY_VACUUM_FLAG \| PROCARRAY_ANALYZE_FLAG

Functions
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)

void	RecordKnownAssignedTransactionIds (TransactionId xid)

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

void	ExpireAllKnownAssignedTransactionIds (void)

void	ExpireOldKnownAssignedTransactionIds (TransactionId xid)

int	GetMaxSnapshotXidCount (void)

int	GetMaxSnapshotSubxidCount (void)

Snapshot	GetSnapshotData (Snapshot snapshot)

bool	ProcArrayInstallImportedXmin (TransactionId xmin, VirtualTransactionId *sourcevxid)

bool	ProcArrayInstallRestoredXmin (TransactionId xmin, PGPROC *proc)

RunningTransactions	GetRunningTransactionData (void)

bool	TransactionIdIsInProgress (TransactionId xid)

bool	TransactionIdIsActive (TransactionId xid)

TransactionId	GetOldestXmin (Relation rel, int flags)

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)

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	XidCacheRemoveRunningXids (TransactionId xid, int nxids, const TransactionId *xids, TransactionId latestXid)

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

void	ProcArrayGetReplicationSlotXmin (TransactionId xmin, TransactionId catalog_xmin)

Macro Definition Documentation

◆ PROCARRAY_ANALYZE_FLAG

#define PROCARRAY_ANALYZE_FLAG

Value:

0x04 /* currently running

* analyze */

Definition at line 32 of file procarray.h.

◆ PROCARRAY_FLAGS_ANALYZE

#define PROCARRAY_FLAGS_ANALYZE PROCARRAY_FLAGS_DEFAULT | PROCARRAY_ANALYZE_FLAG

Definition at line 54 of file procarray.h.

◆ PROCARRAY_FLAGS_DEFAULT

#define PROCARRAY_FLAGS_DEFAULT PROCARRAY_LOGICAL_DECODING_FLAG

Definition at line 50 of file procarray.h.

Referenced by CreateCheckPoint(), CreateRestartPoint(), and XLogWalRcvSendHSFeedback().

◆ PROCARRAY_FLAGS_VACUUM

#define PROCARRAY_FLAGS_VACUUM PROCARRAY_FLAGS_DEFAULT | PROCARRAY_VACUUM_FLAG

Definition at line 52 of file procarray.h.

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

◆ PROCARRAY_FLAGS_VACUUM_ANALYZE

#define PROCARRAY_FLAGS_VACUUM_ANALYZE PROCARRAY_FLAGS_DEFAULT | PROCARRAY_VACUUM_FLAG | PROCARRAY_ANALYZE_FLAG

Definition at line 56 of file procarray.h.

◆ PROCARRAY_LOGICAL_DECODING_FLAG

#define PROCARRAY_LOGICAL_DECODING_FLAG

Value:

0x10 /* currently doing logical

* decoding outside xact */

Definition at line 34 of file procarray.h.

◆ PROCARRAY_PROC_FLAGS_MASK

#define PROCARRAY_PROC_FLAGS_MASK

Value:

(PROCARRAY_VACUUM_FLAG | \
                                         PROCARRAY_ANALYZE_FLAG | \
                                         PROCARRAY_LOGICAL_DECODING_FLAG)

Definition at line 44 of file procarray.h.

Referenced by GetOldestXmin().

◆ PROCARRAY_SLOTS_XMIN

#define PROCARRAY_SLOTS_XMIN

Value:

0x20 /* replication slot xmin,

* catalog_xmin */

Definition at line 37 of file procarray.h.

Referenced by GetOldestXmin(), and XLogWalRcvSendHSFeedback().

◆ PROCARRAY_VACUUM_FLAG

#define PROCARRAY_VACUUM_FLAG

Value:

0x02 /* currently running lazy

* vacuum */

Definition at line 30 of file procarray.h.

Function Documentation

◆ BackendPidGetProc()

PGPROC* BackendPidGetProc ( int pid )

Definition at line 2365 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(), 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 2388 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 2425 of file procarray.c.

References InvalidTransactionId, LW_SHARED, LWLockAcquire(), LWLockRelease(), ProcArrayStruct::numProcs, ProcArrayStruct::pgprocnos, PGPROC::pid, procArray, and PGXACT::xid.

Referenced by pgrowlocks().

 {
     int         result = 0;
     ProcArrayStruct *arrayP = procArray;
     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];
         PGXACT     *pgxact = &allPgXact[pgprocno];
 
         if (pgxact->xid == xid)
         {
             result = proc->pid;
             break;
         }
     }
 
     LWLockRelease(ProcArrayLock);
 
     return result;
 }

◆ CancelDBBackends()

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

Definition at line 2819 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;
     pid_t       pid = 0;
 
     /* 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;
 
             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 2656 of file procarray.c.

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

Referenced by ResolveRecoveryConflictWithVirtualXIDs().

 {
     ProcArrayStruct *arrayP = procArray;
     int         index;
     pid_t       pid = 0;
 
     LWLockAcquire(ProcArrayLock, LW_SHARED);
 
     for (index = 0; index < arrayP->numProcs; index++)
     {
         int         pgprocno = arrayP->pgprocnos[index];
         PGPROC     *proc = &allProcs[pgprocno];
         VirtualTransactionId procvxid;
 
         GET_VXID_FROM_PGPROC(procvxid, *proc);
 
         if (procvxid.backendId == vxid.backendId &&
             procvxid.localTransactionId == vxid.localTransactionId)
         {
             proc->recoveryConflictPending = true;
             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, vxid.backendId);
             }
             break;
         }
     }
 
     LWLockRelease(ProcArrayLock);
 
     return pid;
 }

◆ CountDBBackends()

int CountDBBackends ( Oid databaseid )

Definition at line 2758 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 2788 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 2909 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, and PGXACT::vacuumFlags.

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];
             PGXACT     *pgxact = &allPgXact[pgprocno];
 
             if (proc->databaseId != databaseId)
                 continue;
             if (proc == MyProc)
                 continue;
 
             found = true;
 
             if (proc->pid == 0)
                 (*nprepared)++;
             else
             {
                 (*nbackends)++;
                 if ((pgxact->vacuumFlags & 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 2859 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 222 of file procarray.c.

References add_size(), PROC_HDR::allPgXact, PROC_HDR::allProcs, EnableHotStandby, ProcArrayStruct::headKnownAssignedXids, InvalidTransactionId, ProcArrayStruct::known_assigned_xids_lck, KnownAssignedXids, KnownAssignedXidsValid, ProcArrayStruct::lastOverflowedXid, LWLockRegisterTranche(), LWTRANCHE_PROC, 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(), SpinLockInit, ProcArrayStruct::tailKnownAssignedXids, and TOTAL_MAX_CACHED_SUBXIDS.

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;
     }
 
     allProcs = ProcGlobal->allProcs;
     allPgXact = ProcGlobal->allPgXact;
 
     /* 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);
     }
 
     /* Register and initialize fields of ProcLWLockTranche */
     LWLockRegisterTranche(LWTRANCHE_PROC, "proc");
 }

◆ ExpireAllKnownAssignedTransactionIds()

void ExpireAllKnownAssignedTransactionIds ( void )

Definition at line 3294 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 3306 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 3269 of file procarray.c.

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

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 */
     if (TransactionIdPrecedes(ShmemVariableCache->latestCompletedXid,
                               max_xid))
         ShmemVariableCache->latestCompletedXid = max_xid;
 
     LWLockRelease(ProcArrayLock);
 }

◆ GetConflictingVirtualXIDs()

VirtualTransactionId* GetConflictingVirtualXIDs	(	TransactionId	limitXmin,
		Oid	dbOid
	)

Definition at line 2581 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 PGXACT::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];
         PGXACT     *pgxact = &allPgXact[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(pgxact->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 2493 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, TransactionIdIsValid, TransactionIdPrecedesOrEquals(), UINT32_ACCESS_ONCE, PGXACT::vacuumFlags, VirtualTransactionIdIsValid, and PGXACT::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];
         PGXACT     *pgxact = &allPgXact[pgprocno];
 
         if (proc == MyProc)
             continue;
 
         if (excludeVacuum & pgxact->vacuumFlags)
             continue;
 
         if (allDbs || proc->databaseId == MyDatabaseId)
         {
             /* Fetch xmin just once - might change on us */
             TransactionId pxmin = UINT32_ACCESS_ONCE(pgxact->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 1463 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 1452 of file procarray.c.

References ProcArrayStruct::maxProcs.

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

 {
     return procArray->maxProcs;
 }

◆ GetOldestActiveTransactionId()

TransactionId GetOldestActiveTransactionId ( void )

Definition at line 2111 of file procarray.c.

References Assert, LW_SHARED, LWLockAcquire(), LWLockRelease(), VariableCacheData::nextFullXid, ProcArrayStruct::numProcs, ProcArrayStruct::pgprocnos, procArray, RecoveryInProgress(), ShmemVariableCache, TransactionIdIsNormal, TransactionIdPrecedes(), UINT32_ACCESS_ONCE, PGXACT::xid, and XidFromFullTransactionId.

Referenced by CreateCheckPoint().

 {
     ProcArrayStruct *arrayP = procArray;
     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->nextFullXid);
     LWLockRelease(XidGenLock);
 
     /*
      * Spin over procArray collecting all xids and subxids.
      */
     LWLockAcquire(ProcArrayLock, LW_SHARED);
     for (index = 0; index < arrayP->numProcs; index++)
     {
         int         pgprocno = arrayP->pgprocnos[index];
         PGXACT     *pgxact = &allPgXact[pgprocno];
         TransactionId xid;
 
         /* Fetch xid just once - see GetNewTransactionId */
         xid = UINT32_ACCESS_ONCE(pgxact->xid);
 
         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;
 }

◆ GetOldestSafeDecodingTransactionId()

TransactionId GetOldestSafeDecodingTransactionId ( bool catalogOnly )

Definition at line 2177 of file procarray.c.

References Assert, LW_SHARED, LWLockAcquire(), LWLockHeldByMe(), LWLockRelease(), VariableCacheData::nextFullXid, ProcArrayStruct::numProcs, ProcArrayStruct::pgprocnos, procArray, RecoveryInProgress(), ProcArrayStruct::replication_slot_catalog_xmin, ProcArrayStruct::replication_slot_xmin, ShmemVariableCache, TransactionIdIsNormal, TransactionIdIsValid, TransactionIdPrecedes(), UINT32_ACCESS_ONCE, PGXACT::xid, and XidFromFullTransactionId.

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->nextFullXid);
 
     /*
      * 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
      * PGXACT->xid 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)
     {
         /*
          * Spin over procArray collecting all min(PGXACT->xid)
          */
         for (index = 0; index < arrayP->numProcs; index++)
         {
             int         pgprocno = arrayP->pgprocnos[index];
             PGXACT     *pgxact = &allPgXact[pgprocno];
             TransactionId xid;
 
             /* Fetch xid just once - see GetNewTransactionId */
             xid = UINT32_ACCESS_ONCE(pgxact->xid);
 
             if (!TransactionIdIsNormal(xid))
                 continue;
 
             if (TransactionIdPrecedes(xid, oldestSafeXid))
                 oldestSafeXid = xid;
         }
     }
 
     LWLockRelease(XidGenLock);
 
     return oldestSafeXid;
 }

◆ GetOldestXmin()

TransactionId GetOldestXmin	(	Relation	rel,
		int	flags
	)

Definition at line 1307 of file procarray.c.

References Assert, PGPROC::databaseId, FirstNormalTransactionId, InvalidTransactionId, KnownAssignedXidsGetOldestXmin(), VariableCacheData::latestCompletedXid, LW_SHARED, LWLockAcquire(), LWLockRelease(), MyDatabaseId, NormalTransactionIdPrecedes, ProcArrayStruct::numProcs, ProcArrayStruct::pgprocnos, procArray, PROCARRAY_PROC_FLAGS_MASK, PROCARRAY_SLOTS_XMIN, RelationData::rd_rel, RecoveryInProgress(), RelationIsAccessibleInLogicalDecoding, ProcArrayStruct::replication_slot_catalog_xmin, ProcArrayStruct::replication_slot_xmin, ShmemVariableCache, TransactionIdAdvance, TransactionIdIsNormal, TransactionIdIsValid, TransactionIdPrecedes(), UINT32_ACCESS_ONCE, vacuum_defer_cleanup_age, PGXACT::vacuumFlags, PGXACT::xid, and PGXACT::xmin.

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

 {
     ProcArrayStruct *arrayP = procArray;
     TransactionId result;
     int         index;
     bool        allDbs;
 
     TransactionId replication_slot_xmin = InvalidTransactionId;
     TransactionId replication_slot_catalog_xmin = InvalidTransactionId;
 
     /*
      * If we're not computing a relation specific limit, or if a shared
      * relation has been passed in, backends in all databases have to be
      * considered.
      */
     allDbs = rel == NULL || rel->rd_rel->relisshared;
 
     /* Cannot look for individual databases during recovery */
     Assert(allDbs || !RecoveryInProgress());
 
     LWLockAcquire(ProcArrayLock, LW_SHARED);
 
     /*
      * 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.
      */
     result = ShmemVariableCache->latestCompletedXid;
     Assert(TransactionIdIsNormal(result));
     TransactionIdAdvance(result);
 
     for (index = 0; index < arrayP->numProcs; index++)
     {
         int         pgprocno = arrayP->pgprocnos[index];
         PGPROC     *proc = &allProcs[pgprocno];
         PGXACT     *pgxact = &allPgXact[pgprocno];
 
         if (pgxact->vacuumFlags & (flags & PROCARRAY_PROC_FLAGS_MASK))
             continue;
 
         if (allDbs ||
             proc->databaseId == MyDatabaseId ||
             proc->databaseId == 0)  /* always include WalSender */
         {
             /* Fetch xid just once - see GetNewTransactionId */
             TransactionId xid = UINT32_ACCESS_ONCE(pgxact->xid);
 
             /* First consider the transaction's own Xid, if any */
             if (TransactionIdIsNormal(xid) &&
                 TransactionIdPrecedes(xid, result))
                 result = xid;
 
             /*
              * Also consider the transaction's Xmin, if set.
              *
              * We must check both Xid and Xmin 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.
              */
             xid = UINT32_ACCESS_ONCE(pgxact->xmin);
             if (TransactionIdIsNormal(xid) &&
                 TransactionIdPrecedes(xid, result))
                 result = xid;
         }
     }
 
     /*
      * 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 (RecoveryInProgress())
     {
         /*
          * Check to see whether KnownAssignedXids contains an xid value older
          * than the main procarray.
          */
         TransactionId kaxmin = KnownAssignedXidsGetOldestXmin();
 
         LWLockRelease(ProcArrayLock);
 
         if (TransactionIdIsNormal(kaxmin) &&
             TransactionIdPrecedes(kaxmin, result))
             result = kaxmin;
     }
     else
     {
         /*
          * No other information needed, so release the lock immediately.
          */
         LWLockRelease(ProcArrayLock);
 
         /*
          * Compute the cutoff XID by subtracting vacuum_defer_cleanup_age,
          * being careful not to generate a "permanent" XID.
          *
          * 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 master 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.
          */
         result -= vacuum_defer_cleanup_age;
         if (!TransactionIdIsNormal(result))
             result = FirstNormalTransactionId;
     }
 
     /*
      * Check whether there are replication slots requiring an older xmin.
      */
     if (!(flags & PROCARRAY_SLOTS_XMIN) &&
         TransactionIdIsValid(replication_slot_xmin) &&
         NormalTransactionIdPrecedes(replication_slot_xmin, result))
         result = replication_slot_xmin;
 
     /*
      * After locks have been released and defer_cleanup_age has been applied,
      * check whether we need to back up further to make logical decoding
      * possible. We need to do so if we're computing the global limit (rel =
      * NULL) or if the passed relation is a catalog relation of some kind.
      */
     if (!(flags & PROCARRAY_SLOTS_XMIN) &&
         (rel == NULL ||
          RelationIsAccessibleInLogicalDecoding(rel)) &&
         TransactionIdIsValid(replication_slot_catalog_xmin) &&
         NormalTransactionIdPrecedes(replication_slot_catalog_xmin, result))
         result = replication_slot_catalog_xmin;
 
     return result;
 }

◆ GetRunningTransactionData()

RunningTransactions GetRunningTransactionData ( void )

Definition at line 1937 of file procarray.c.

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

Referenced by LogStandbySnapshot().

 {
     /* result workspace */
     static RunningTransactionsData CurrentRunningXactsData;
 
     ProcArrayStruct *arrayP = procArray;
     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 = ShmemVariableCache->latestCompletedXid;
 
     oldestRunningXid = XidFromFullTransactionId(ShmemVariableCache->nextFullXid);
 
     /*
      * Spin over procArray collecting all xids
      */
     for (index = 0; index < arrayP->numProcs; index++)
     {
         int         pgprocno = arrayP->pgprocnos[index];
         PGXACT     *pgxact = &allPgXact[pgprocno];
         TransactionId xid;
 
         /* Fetch xid just once - see GetNewTransactionId */
         xid = UINT32_ACCESS_ONCE(pgxact->xid);
 
         /*
          * 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 (pgxact->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)
     {
         for (index = 0; index < arrayP->numProcs; index++)
         {
             int         pgprocno = arrayP->pgprocnos[index];
             PGPROC     *proc = &allProcs[pgprocno];
             PGXACT     *pgxact = &allPgXact[pgprocno];
             int         nxids;
 
             /*
              * Save subtransaction XIDs. Other backends can't add or remove
              * entries while we're holding XidGenLock.
              */
             nxids = pgxact->nxids;
             if (nxids > 0)
             {
                 /* barrier not really required, as XidGenLock is held, but ... */
                 pg_read_barrier();  /* pairs with GetNewTransactionId */
 
                 memcpy(&xids[count], (void *) proc->subxids.xids,
                        nxids * sizeof(TransactionId));
                 count += nxids;
                 subcount += nxids;
 
                 /*
                  * 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->nextFullXid);
     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 1505 of file procarray.c.

References SnapshotData::active_count, Assert, SnapshotData::copied, SnapshotData::curcid, ereport, errcode(), errmsg(), ERROR, FirstNormalTransactionId, GetCurrentCommandId(), GetMaxSnapshotSubxidCount(), GetMaxSnapshotXidCount(), GetSnapshotCurrentTimestamp(), GetXLogInsertRecPtr(), InvalidTransactionId, InvalidXLogRecPtr, KnownAssignedXidsGetAndSetXmin(), ProcArrayStruct::lastOverflowedXid, VariableCacheData::latestCompletedXid, SnapshotData::lsn, LW_SHARED, LWLockAcquire(), LWLockRelease(), MaintainOldSnapshotTimeMapping(), malloc, MyPgXact, NormalTransactionIdPrecedes, ProcArrayStruct::numProcs, PGXACT::nxids, old_snapshot_threshold, PGXACT::overflowed, pg_read_barrier, ProcArrayStruct::pgprocnos, PROC_IN_LOGICAL_DECODING, PROC_IN_VACUUM, procArray, RecentGlobalDataXmin, RecentGlobalXmin, RecentXmin, RecoveryInProgress(), SnapshotData::regd_count, ProcArrayStruct::replication_slot_catalog_xmin, ProcArrayStruct::replication_slot_xmin, ShmemVariableCache, SnapshotData::suboverflowed, SnapshotData::subxcnt, PGPROC::subxids, SnapshotData::subxip, SnapshotData::takenDuringRecovery, TransactionIdAdvance, TransactionIdIsNormal, TransactionIdIsValid, TransactionIdPrecedes(), TransactionIdPrecedesOrEquals(), TransactionXmin, UINT32_ACCESS_ONCE, vacuum_defer_cleanup_age, PGXACT::vacuumFlags, SnapshotData::whenTaken, SnapshotData::xcnt, PGXACT::xid, XidCache::xids, SnapshotData::xip, SnapshotData::xmax, SnapshotData::xmin, and PGXACT::xmin.

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

 {
     ProcArrayStruct *arrayP = procArray;
     TransactionId xmin;
     TransactionId xmax;
     TransactionId globalxmin;
     int         index;
     int         count = 0;
     int         subcount = 0;
     bool        suboverflowed = false;
     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 MyPgXact->xmin.
      */
     LWLockAcquire(ProcArrayLock, LW_SHARED);
 
     /* xmax is always latestCompletedXid + 1 */
     xmax = ShmemVariableCache->latestCompletedXid;
     Assert(TransactionIdIsNormal(xmax));
     TransactionIdAdvance(xmax);
 
     /* initialize xmin calculation with xmax */
     globalxmin = xmin = xmax;
 
     snapshot->takenDuringRecovery = RecoveryInProgress();
 
     if (!snapshot->takenDuringRecovery)
     {
         int        *pgprocnos = arrayP->pgprocnos;
         int         numProcs;
 
         /*
          * Spin over procArray checking xid, xmin, and subxids.  The goal is
          * to gather all active xids, find the lowest xmin, and try to record
          * subxids.
          */
         numProcs = arrayP->numProcs;
         for (index = 0; index < numProcs; index++)
         {
             int         pgprocno = pgprocnos[index];
             PGXACT     *pgxact = &allPgXact[pgprocno];
             TransactionId xid;
 
             /*
              * Skip over backends doing logical decoding which manages xmin
              * separately (check below) and ones running LAZY VACUUM.
              */
             if (pgxact->vacuumFlags &
                 (PROC_IN_LOGICAL_DECODING | PROC_IN_VACUUM))
                 continue;
 
             /* Update globalxmin to be the smallest valid xmin */
             xid = UINT32_ACCESS_ONCE(pgxact->xmin);
             if (TransactionIdIsNormal(xid) &&
                 NormalTransactionIdPrecedes(xid, globalxmin))
                 globalxmin = xid;
 
             /* Fetch xid just once - see GetNewTransactionId */
             xid = UINT32_ACCESS_ONCE(pgxact->xid);
 
             /*
              * If the transaction has no XID assigned, we can skip it; it
              * won't have sub-XIDs either.  If the XID is >= xmax, we can also
              * skip it; such transactions will be treated as running anyway
              * (and any sub-XIDs will also be >= xmax).
              */
             if (!TransactionIdIsNormal(xid)
                 || !NormalTransactionIdPrecedes(xid, xmax))
                 continue;
 
             /*
              * We don't include our own XIDs (if any) in the snapshot, but we
              * must include them in xmin.
              */
             if (NormalTransactionIdPrecedes(xid, xmin))
                 xmin = xid;
             if (pgxact == MyPgXact)
                 continue;
 
             /* Add XID to snapshot. */
             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 (pgxact->overflowed)
                     suboverflowed = true;
                 else
                 {
                     int         nxids = pgxact->nxids;
 
                     if (nxids > 0)
                     {
                         PGPROC     *proc = &allProcs[pgprocno];
 
                         pg_read_barrier();  /* pairs with GetNewTransactionId */
 
                         memcpy(snapshot->subxip + subcount,
                                (void *) proc->subxids.xids,
                                nxids * sizeof(TransactionId));
                         subcount += nxids;
                     }
                 }
             }
         }
     }
     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(MyPgXact->xmin))
         MyPgXact->xmin = TransactionXmin = xmin;
 
     LWLockRelease(ProcArrayLock);
 
     /*
      * Update globalxmin to include actual process xids.  This is a slightly
      * different way of computing it than GetOldestXmin uses, but should give
      * the same result.
      */
     if (TransactionIdPrecedes(xmin, globalxmin))
         globalxmin = xmin;
 
     /* Update global variables too */
     RecentGlobalXmin = globalxmin - vacuum_defer_cleanup_age;
     if (!TransactionIdIsNormal(RecentGlobalXmin))
         RecentGlobalXmin = FirstNormalTransactionId;
 
     /* Check whether there's a replication slot requiring an older xmin. */
     if (TransactionIdIsValid(replication_slot_xmin) &&
         NormalTransactionIdPrecedes(replication_slot_xmin, RecentGlobalXmin))
         RecentGlobalXmin = replication_slot_xmin;
 
     /* Non-catalog tables can be vacuumed if older than this xid */
     RecentGlobalDataXmin = RecentGlobalXmin;
 
     /*
      * Check whether there's a replication slot requiring an older catalog
      * xmin.
      */
     if (TransactionIdIsNormal(replication_slot_catalog_xmin) &&
         NormalTransactionIdPrecedes(replication_slot_catalog_xmin, RecentGlobalXmin))
         RecentGlobalXmin = replication_slot_catalog_xmin;
 
     RecentXmin = xmin;
 
     snapshot->xmin = xmin;
     snapshot->xmax = xmax;
     snapshot->xcnt = count;
     snapshot->subxcnt = subcount;
     snapshot->suboverflowed = suboverflowed;
 
     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;
 
     if (old_snapshot_threshold < 0)
     {
         /*
          * 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, xmin);
     }
 
     return snapshot;
 }

◆ GetVirtualXIDsDelayingChkpt()

VirtualTransactionId* GetVirtualXIDsDelayingChkpt ( int * nvxids )

Definition at line 2273 of file procarray.c.

References PGXACT::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];
         PGXACT     *pgxact = &allPgXact[pgprocno];
 
         if (pgxact->delayChkpt)
         {
             VirtualTransactionId vxid;
 
             GET_VXID_FROM_PGPROC(vxid, *proc);
             if (VirtualTransactionIdIsValid(vxid))
                 vxids[count++] = vxid;
         }
     }
 
     LWLockRelease(ProcArrayLock);
 
     *nvxids = count;
     return vxids;
 }

◆ HaveVirtualXIDsDelayingChkpt()

bool HaveVirtualXIDsDelayingChkpt	(	VirtualTransactionId *	vxids,
		int	nvxids
	)

Definition at line 2318 of file procarray.c.

References PGXACT::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];
         PGXACT     *pgxact = &allPgXact[pgprocno];
         VirtualTransactionId vxid;
 
         GET_VXID_FROM_PGPROC(vxid, *proc);
 
         if (pgxact->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 2460 of file procarray.c.

References BackendPidGetProc().

Referenced by pg_stat_get_subscription().

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

◆ MinimumActiveBackends()

bool MinimumActiveBackends ( int min )

Definition at line 2704 of file procarray.c.

References InvalidTransactionId, MyProc, ProcArrayStruct::numProcs, ProcArrayStruct::pgprocnos, PGPROC::pid, procArray, PGPROC::waitLock, and PGXACT::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];
         PGXACT     *pgxact = &allPgXact[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 (pgxact->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 276 of file procarray.c.

References ereport, errcode(), errmsg(), FATAL, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), ProcArrayStruct::maxProcs, memmove, ProcArrayStruct::numProcs, PGPROC::pgprocno, ProcArrayStruct::pgprocnos, and procArray.

Referenced by InitProcessPhase2(), and MarkAsPrepared().

 {
     ProcArrayStruct *arrayP = procArray;
     int         index;
 
     LWLockAcquire(ProcArrayLock, 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.)
          */
         LWLockRelease(ProcArrayLock);
         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(int));
     arrayP->pgprocnos[index] = proc->pgprocno;
     arrayP->numProcs++;
 
     LWLockRelease(ProcArrayLock);
 }

◆ ProcArrayApplyRecoveryInfo()

void ProcArrayApplyRecoveryInfo ( RunningTransactions running )

Definition at line 663 of file procarray.c.

References AdvanceNextFullTransactionIdPastXid(), Assert, DEBUG1, DEBUG3, elog, ERROR, ExpireOldKnownAssignedTransactionIds(), ExtendSUBTRANS(), FullTransactionIdIsValid, i, InvalidTransactionId, KnownAssignedXidsAdd(), KnownAssignedXidsDisplay(), KnownAssignedXidsReset(), ProcArrayStruct::lastOverflowedXid, RunningTransactionsData::latestCompletedXid, VariableCacheData::latestCompletedXid, latestObservedXid, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), VariableCacheData::nextFullXid, RunningTransactionsData::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);
 
     /*
      * OK, we need to initialise from the RunningTransactionsData record.
      *
      * 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 RunningXacts 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.
      */
     if (TransactionIdPrecedes(ShmemVariableCache->latestCompletedXid,
                               running->latestCompletedXid))
         ShmemVariableCache->latestCompletedXid = running->latestCompletedXid;
 
     Assert(TransactionIdIsNormal(ShmemVariableCache->latestCompletedXid));
 
     LWLockRelease(ProcArrayLock);
 
     /* ShmemVariableCache->nextFullXid must be beyond any observed xid. */
     AdvanceNextFullTransactionIdPastXid(latestObservedXid);
 
     Assert(FullTransactionIdIsValid(ShmemVariableCache->nextFullXid));
 
     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 904 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 600 of file procarray.c.

References PGXACT::delayChkpt, InvalidLocalTransactionId, InvalidTransactionId, PGPROC::lxid, PGXACT::nxids, PGXACT::overflowed, PGPROC::pgprocno, PROC_VACUUM_STATE_MASK, PGPROC::recoveryConflictPending, PGXACT::vacuumFlags, PGXACT::xid, and PGXACT::xmin.

Referenced by PrepareTransaction().

 {
     PGXACT     *pgxact = &allPgXact[proc->pgprocno];
 
     /*
      * We can skip locking ProcArrayLock here, because 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.
      */
     pgxact->xid = InvalidTransactionId;
     proc->lxid = InvalidLocalTransactionId;
     pgxact->xmin = InvalidTransactionId;
     proc->recoveryConflictPending = false;
 
     /* redundant, but just in case */
     pgxact->vacuumFlags &= ~PROC_VACUUM_STATE_MASK;
     pgxact->delayChkpt = false;
 
     /* Clear the subtransaction-XID cache too */
     pgxact->nxids = 0;
     pgxact->overflowed = false;
 }

◆ ProcArrayEndTransaction()

void ProcArrayEndTransaction	(	PGPROC *	proc,
		TransactionId	latestXid
	)

Definition at line 397 of file procarray.c.

References Assert, PGXACT::delayChkpt, InvalidLocalTransactionId, InvalidTransactionId, LW_EXCLUSIVE, LWLockConditionalAcquire(), LWLockRelease(), PGPROC::lxid, PGXACT::nxids, PGXACT::overflowed, PGPROC::pgprocno, PROC_VACUUM_STATE_MASK, ProcArrayEndTransactionInternal(), ProcArrayGroupClearXid(), PGPROC::recoveryConflictPending, TransactionIdIsValid, PGXACT::vacuumFlags, PGXACT::xid, and PGXACT::xmin.

Referenced by AbortTransaction(), and CommitTransaction().

 {
     PGXACT     *pgxact = &allPgXact[proc->pgprocno];
 
     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(allPgXact[proc->pgprocno].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, pgxact, 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(allPgXact[proc->pgprocno].xid));
 
         proc->lxid = InvalidLocalTransactionId;
         pgxact->xmin = InvalidTransactionId;
         /* must be cleared with xid/xmin: */
         pgxact->vacuumFlags &= ~PROC_VACUUM_STATE_MASK;
         pgxact->delayChkpt = false; /* be sure this is cleared in abort */
         proc->recoveryConflictPending = false;
 
         Assert(pgxact->nxids == 0);
         Assert(pgxact->overflowed == false);
     }
 }

◆ ProcArrayGetReplicationSlotXmin()

void ProcArrayGetReplicationSlotXmin	(	TransactionId *	xmin,
		TransactionId *	catalog_xmin
	)

Definition at line 3005 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(), and XLogWalRcvSendHSFeedback().

 {
     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);
 }

◆ ProcArrayInitRecovery()

void ProcArrayInitRecovery ( TransactionId initializedUptoXID )

Definition at line 632 of file procarray.c.

References Assert, latestObservedXid, STANDBY_INITIALIZED, standbyState, TransactionIdIsNormal, and TransactionIdRetreat.

Referenced by StartupXLOG().

 {
     Assert(standbyState == STANDBY_INITIALIZED);
     Assert(TransactionIdIsNormal(initializedUptoXID));
 
     /*
      * we set latestObservedXid to the xid SUBTRANS has been initialized up
      * to, so we can extend it from that point onwards in
      * RecordKnownAssignedTransactionIds, and when we get consistent in
      * ProcArrayApplyRecoveryInfo().
      */
     latestObservedXid = initializedUptoXID;
     TransactionIdRetreat(latestObservedXid);
 }

◆ ProcArrayInstallImportedXmin()

bool ProcArrayInstallImportedXmin	(	TransactionId	xmin,
		VirtualTransactionId *	sourcevxid
	)

Definition at line 1796 of file procarray.c.

References Assert, VirtualTransactionId::backendId, PGPROC::backendId, PGPROC::databaseId, VirtualTransactionId::localTransactionId, LW_SHARED, LWLockAcquire(), LWLockRelease(), PGPROC::lxid, MyDatabaseId, MyPgXact, ProcArrayStruct::numProcs, ProcArrayStruct::pgprocnos, PROC_IN_VACUUM, procArray, TransactionIdIsNormal, TransactionIdPrecedesOrEquals(), TransactionXmin, UINT32_ACCESS_ONCE, PGXACT::vacuumFlags, and PGXACT::xmin.

Referenced by GetSerializableTransactionSnapshotInt(), and SetTransactionSnapshot().

 {
     bool        result = false;
     ProcArrayStruct *arrayP = procArray;
     int         index;
 
     Assert(TransactionIdIsNormal(xmin));
     if (!sourcevxid)
         return false;
 
     /* Get lock so source xact can't end while we're doing this */
     LWLockAcquire(ProcArrayLock, LW_SHARED);
 
     for (index = 0; index < arrayP->numProcs; index++)
     {
         int         pgprocno = arrayP->pgprocnos[index];
         PGPROC     *proc = &allProcs[pgprocno];
         PGXACT     *pgxact = &allPgXact[pgprocno];
         TransactionId xid;
 
         /* Ignore procs running LAZY VACUUM */
         if (pgxact->vacuumFlags & PROC_IN_VACUUM)
             continue;
 
         /* We are only interested in the specific virtual transaction. */
         if (proc->backendId != sourcevxid->backendId)
             continue;
         if (proc->lxid != sourcevxid->localTransactionId)
             continue;
 
         /*
          * We check the transaction's database ID for paranoia's sake: if it's
          * in another DB then its xmin does not cover us.  Caller should have
          * detected this already, so we just treat any funny cases as
          * "transaction not found".
          */
         if (proc->databaseId != MyDatabaseId)
             continue;
 
         /*
          * Likewise, let's just make real sure its xmin does cover us.
          */
         xid = UINT32_ACCESS_ONCE(pgxact->xmin);
         if (!TransactionIdIsNormal(xid) ||
             !TransactionIdPrecedesOrEquals(xid, xmin))
             continue;
 
         /*
          * We're good.  Install the new xmin.  As in GetSnapshotData, set
          * TransactionXmin too.  (Note that because snapmgr.c called
          * GetSnapshotData first, we'll be overwriting a valid xmin here, so
          * we don't check that.)
          */
         MyPgXact->xmin = TransactionXmin = xmin;
 
         result = true;
         break;
     }
 
     LWLockRelease(ProcArrayLock);
 
     return result;
 }

◆ ProcArrayInstallRestoredXmin()

bool ProcArrayInstallRestoredXmin	(	TransactionId	xmin,
		PGPROC *	proc
	)

Definition at line 1871 of file procarray.c.

References Assert, PGPROC::databaseId, LW_SHARED, LWLockAcquire(), LWLockRelease(), MyDatabaseId, MyPgXact, PGPROC::pgprocno, TransactionIdIsNormal, TransactionIdPrecedesOrEquals(), TransactionXmin, UINT32_ACCESS_ONCE, and PGXACT::xmin.

Referenced by SetTransactionSnapshot().

 {
     bool        result = false;
     TransactionId xid;
     PGXACT     *pgxact;
 
     Assert(TransactionIdIsNormal(xmin));
     Assert(proc != NULL);
 
     /* Get lock so source xact can't end while we're doing this */
     LWLockAcquire(ProcArrayLock, LW_SHARED);
 
     pgxact = &allPgXact[proc->pgprocno];
 
     /*
      * Be certain that the referenced PGPROC has an advertised xmin which is
      * no later than the one we're installing, so that the system-wide xmin
      * can't go backwards.  Also, make sure it's running in the same database,
      * so that the per-database xmin cannot go backwards.
      */
     xid = UINT32_ACCESS_ONCE(pgxact->xmin);
     if (proc->databaseId == MyDatabaseId &&
         TransactionIdIsNormal(xid) &&
         TransactionIdPrecedesOrEquals(xid, xmin))
     {
         MyPgXact->xmin = TransactionXmin = xmin;
         result = true;
     }
 
     LWLockRelease(ProcArrayLock);
 
     return result;
 }

◆ ProcArrayRemove()

void ProcArrayRemove	(	PGPROC *	proc,
		TransactionId	latestXid
	)

Definition at line 334 of file procarray.c.

References Assert, elog, VariableCacheData::latestCompletedXid, LOG, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), memmove, ProcArrayStruct::numProcs, PGPROC::pgprocno, ProcArrayStruct::pgprocnos, PGPROC::pid, procArray, ShmemVariableCache, TransactionIdIsValid, TransactionIdPrecedes(), and PGXACT::xid.

Referenced by FinishPreparedTransaction(), and RemoveProcFromArray().

 {
     ProcArrayStruct *arrayP = procArray;
     int         index;
 
 #ifdef XIDCACHE_DEBUG
     /* dump stats at backend shutdown, but not prepared-xact end */
     if (proc->pid != 0)
         DisplayXidCache();
 #endif
 
     LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
 
     if (TransactionIdIsValid(latestXid))
     {
         Assert(TransactionIdIsValid(allPgXact[proc->pgprocno].xid));
 
         /* Advance global latestCompletedXid while holding the lock */
         if (TransactionIdPrecedes(ShmemVariableCache->latestCompletedXid,
                                   latestXid))
             ShmemVariableCache->latestCompletedXid = latestXid;
     }
     else
     {
         /* Shouldn't be trying to remove a live transaction here */
         Assert(!TransactionIdIsValid(allPgXact[proc->pgprocno].xid));
     }
 
     for (index = 0; index < arrayP->numProcs; index++)
     {
         if (arrayP->pgprocnos[index] == proc->pgprocno)
         {
             /* Keep the PGPROC array sorted. See notes above */
             memmove(&arrayP->pgprocnos[index], &arrayP->pgprocnos[index + 1],
                     (arrayP->numProcs - index - 1) * sizeof(int));
             arrayP->pgprocnos[arrayP->numProcs - 1] = -1;   /* for debugging */
             arrayP->numProcs--;
             LWLockRelease(ProcArrayLock);
             return;
         }
     }
 
     /* Oops */
     LWLockRelease(ProcArrayLock);
 
     elog(LOG, "failed to find proc %p in ProcArray", proc);
 }

◆ ProcArraySetReplicationSlotXmin()

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

Definition at line 2983 of file procarray.c.

References Assert, LW_EXCLUSIVE, LWLockAcquire(), LWLockHeldByMe(), LWLockRelease(), ProcArrayStruct::replication_slot_catalog_xmin, and ProcArrayStruct::replication_slot_xmin.

Referenced by ReplicationSlotsComputeRequiredXmin().

 {
     Assert(!already_locked || LWLockHeldByMe(ProcArrayLock));
 
     if (!already_locked)
         LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
 
     procArray->replication_slot_xmin = xmin;
     procArray->replication_slot_catalog_xmin = catalog_xmin;
 
     if (!already_locked)
         LWLockRelease(ProcArrayLock);
 }

◆ ProcArrayShmemSize()

Size ProcArrayShmemSize ( void )

Definition at line 180 of file procarray.c.

References add_size(), EnableHotStandby, mul_size(), offsetof, ProcArrayStruct::pgprocnos, PROCARRAY_MAXPROCS, and TOTAL_MAX_CACHED_SUBXIDS.

Referenced by CreateSharedMemoryAndSemaphores().

 {
     Size        size;
 
     /* Size of the ProcArray structure itself */
 #define PROCARRAY_MAXPROCS  (MaxBackends + max_prepared_xacts)
 
     size = offsetof(ProcArrayStruct, pgprocnos);
     size = add_size(size, mul_size(sizeof(int), PROCARRAY_MAXPROCS));
 
     /*
      * During Hot Standby processing we have a data structure called
      * KnownAssignedXids, created in shared memory. Local data structures are
      * also created in various backends during GetSnapshotData(),
      * TransactionIdIsInProgress() and GetRunningTransactionData(). All of the
      * main structures created in those functions must be identically sized,
      * since we may at times copy the whole of the data structures around. We
      * refer to this size as TOTAL_MAX_CACHED_SUBXIDS.
      *
      * Ideally we'd only create this structure if we were actually doing hot
      * standby in the current run, but we don't know that yet at the time
      * shared memory is being set up.
      */
 #define TOTAL_MAX_CACHED_SUBXIDS \
     ((PGPROC_MAX_CACHED_SUBXIDS + 1) * PROCARRAY_MAXPROCS)
 
     if (EnableHotStandby)
     {
         size = add_size(size,
                         mul_size(sizeof(TransactionId),
                                  TOTAL_MAX_CACHED_SUBXIDS));
         size = add_size(size,
                         mul_size(sizeof(bool), TOTAL_MAX_CACHED_SUBXIDS));
     }
 
     return size;
 }

◆ RecordKnownAssignedTransactionIds()

void RecordKnownAssignedTransactionIds ( TransactionId xid )

Definition at line 3198 of file procarray.c.

References AdvanceNextFullTransactionIdPastXid(), Assert, DEBUG4, elog, ExtendSUBTRANS(), KnownAssignedXidsAdd(), latestObservedXid, STANDBY_INITIALIZED, standbyState, trace_recovery(), TransactionIdAdvance, TransactionIdFollows(), TransactionIdIsValid, and TransactionIdPrecedes().

Referenced by ProcArrayApplyXidAssignment(), StartupXLOG(), xact_redo_abort(), and xact_redo_commit().

 {
     Assert(standbyState >= STANDBY_INITIALIZED);
     Assert(TransactionIdIsValid(xid));
     Assert(TransactionIdIsValid(latestObservedXid));
 
     elog(trace_recovery(DEBUG4), "record known xact %u latestObservedXid %u",
          xid, latestObservedXid);
 
     /*
      * When a newly observed xid arrives, it is frequently the case that it is
      * *not* the next xid in sequence. When this occurs, we must treat the
      * intervening xids as running also.
      */
     if (TransactionIdFollows(xid, latestObservedXid))
     {
         TransactionId next_expected_xid;
 
         /*
          * Extend subtrans like we do in GetNewTransactionId() during normal
          * operation using individual extend steps. Note that we do not need
          * to extend clog since its extensions are WAL logged.
          *
          * This part has to be done regardless of standbyState since we
          * immediately start assigning subtransactions to their toplevel
          * transactions.
          */
         next_expected_xid = latestObservedXid;
         while (TransactionIdPrecedes(next_expected_xid, xid))
         {
             TransactionIdAdvance(next_expected_xid);
             ExtendSUBTRANS(next_expected_xid);
         }
         Assert(next_expected_xid == xid);
 
         /*
          * If the KnownAssignedXids machinery isn't up yet, there's nothing
          * more to do since we don't track assigned xids yet.
          */
         if (standbyState <= STANDBY_INITIALIZED)
         {
             latestObservedXid = xid;
             return;
         }
 
         /*
          * Add (latestObservedXid, xid] onto the KnownAssignedXids array.
          */
         next_expected_xid = latestObservedXid;
         TransactionIdAdvance(next_expected_xid);
         KnownAssignedXidsAdd(next_expected_xid, xid, false);
 
         /*
          * Now we can advance latestObservedXid
          */
         latestObservedXid = xid;
 
         /* ShmemVariableCache->nextFullXid must be beyond any observed xid */
         AdvanceNextFullTransactionIdPastXid(latestObservedXid);
         next_expected_xid = latestObservedXid;
         TransactionIdAdvance(next_expected_xid);
     }
 }

◆ TransactionIdIsActive()

bool TransactionIdIsActive ( TransactionId xid )

Definition at line 1208 of file procarray.c.

References i, LW_SHARED, LWLockAcquire(), LWLockRelease(), ProcArrayStruct::numProcs, ProcArrayStruct::pgprocnos, PGPROC::pid, procArray, RecentXmin, TransactionIdEquals, TransactionIdIsValid, TransactionIdPrecedes(), UINT32_ACCESS_ONCE, and PGXACT::xid.

 {
     bool        result = false;
     ProcArrayStruct *arrayP = procArray;
     int         i;
 
     /*
      * Don't bother checking a transaction older than RecentXmin; it could not
      * possibly still be running.
      */
     if (TransactionIdPrecedes(xid, RecentXmin))
         return false;
 
     LWLockAcquire(ProcArrayLock, LW_SHARED);
 
     for (i = 0; i < arrayP->numProcs; i++)
     {
         int         pgprocno = arrayP->pgprocnos[i];
         PGPROC     *proc = &allProcs[pgprocno];
         PGXACT     *pgxact = &allPgXact[pgprocno];
         TransactionId pxid;
 
         /* Fetch xid just once - see GetNewTransactionId */
         pxid = UINT32_ACCESS_ONCE(pgxact->xid);
 
         if (!TransactionIdIsValid(pxid))
             continue;
 
         if (proc->pid == 0)
             continue;           /* ignore prepared transactions */
 
         if (TransactionIdEquals(pxid, xid))
         {
             result = true;
             break;
         }
     }
 
     LWLockRelease(ProcArrayLock);
 
     return result;
 }

◆ TransactionIdIsInProgress()

bool TransactionIdIsInProgress ( TransactionId xid )

Definition at line 988 of file procarray.c.

References Assert, ereport, errcode(), errmsg(), ERROR, i, KnownAssignedXidExists(), KnownAssignedXidsGet(), ProcArrayStruct::lastOverflowedXid, VariableCacheData::latestCompletedXid, LW_SHARED, LWLockAcquire(), LWLockRelease(), malloc, ProcArrayStruct::maxProcs, MyProc, ProcArrayStruct::numProcs, PGXACT::nxids, PGXACT::overflowed, pg_read_barrier, ProcArrayStruct::pgprocnos, procArray, RecentXmin, RecoveryInProgress(), ShmemVariableCache, SubTransGetTopmostTransaction(), PGPROC::subxids, TOTAL_MAX_CACHED_SUBXIDS, TransactionIdDidAbort(), TransactionIdEquals, TransactionIdIsCurrentTransactionId(), TransactionIdIsKnownCompleted(), TransactionIdIsValid, TransactionIdPrecedes(), TransactionIdPrecedesOrEquals(), 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, PGXACT::xid, and XidCache::xids.

Referenced by check_safe_enum_use(), compute_new_xmax_infomask(), ConditionalXactLockTableWait(), Do_MultiXactIdWait(), DoesMultiXactIdConflict(), FreezeMultiXactId(), HeapTupleHeaderIsOnlyLocked(), HeapTupleSatisfiesDirty(), HeapTupleSatisfiesSelf(), HeapTupleSatisfiesToast(), HeapTupleSatisfiesUpdate(), HeapTupleSatisfiesVacuum(), MultiXactIdExpand(), MultiXactIdIsRunning(), test_lockmode_for_conflict(), and XactLockTableWait().

 {
     static TransactionId *xids = NULL;
     int         nxids = 0;
     ProcArrayStruct *arrayP = procArray;
     TransactionId topxid;
     int         i,
                 j;
 
     /*
      * Don't bother checking a transaction older than RecentXmin; it could not
      * possibly still be running.  (Note: in particular, this guarantees that
      * we reject InvalidTransactionId, FrozenTransactionId, etc as not
      * running.)
      */
     if (TransactionIdPrecedes(xid, RecentXmin))
     {
         xc_by_recent_xmin_inc();
         return false;
     }
 
     /*
      * We may have just checked the status of this transaction, so if it is
      * already known to be completed, we can fall out without any access to
      * shared memory.
      */
     if (TransactionIdIsKnownCompleted(xid))
     {
         xc_by_known_xact_inc();
         return false;
     }
 
     /*
      * Also, we can handle our own transaction (and subtransactions) without
      * any access to shared memory.
      */
     if (TransactionIdIsCurrentTransactionId(xid))
     {
         xc_by_my_xact_inc();
         return true;
     }
 
     /*
      * If first time through, get workspace to remember main XIDs in. We
      * malloc it permanently to avoid repeated palloc/pfree overhead.
      */
     if (xids == NULL)
     {
         /*
          * In hot standby mode, reserve enough space to hold all xids in the
          * known-assigned list. If we later finish recovery, we no longer need
          * the bigger array, but we don't bother to shrink it.
          */
         int         maxxids = RecoveryInProgress() ? TOTAL_MAX_CACHED_SUBXIDS : arrayP->maxProcs;
 
         xids = (TransactionId *) malloc(maxxids * sizeof(TransactionId));
         if (xids == NULL)
             ereport(ERROR,
                     (errcode(ERRCODE_OUT_OF_MEMORY),
                      errmsg("out of memory")));
     }
 
     LWLockAcquire(ProcArrayLock, LW_SHARED);
 
     /*
      * Now that we have the lock, we can check latestCompletedXid; if the
      * target Xid is after that, it's surely still running.
      */
     if (TransactionIdPrecedes(ShmemVariableCache->latestCompletedXid, xid))
     {
         LWLockRelease(ProcArrayLock);
         xc_by_latest_xid_inc();
         return true;
     }
 
     /* No shortcuts, gotta grovel through the array */
     for (i = 0; i < arrayP->numProcs; i++)
     {
         int         pgprocno = arrayP->pgprocnos[i];
         PGPROC     *proc = &allProcs[pgprocno];
         PGXACT     *pgxact = &allPgXact[pgprocno];
         TransactionId pxid;
         int         pxids;
 
         /* Ignore my own proc --- dealt with it above */
         if (proc == MyProc)
             continue;
 
         /* Fetch xid just once - see GetNewTransactionId */
         pxid = UINT32_ACCESS_ONCE(pgxact->xid);
 
         if (!TransactionIdIsValid(pxid))
             continue;
 
         /*
          * Step 1: check the main Xid
          */
         if (TransactionIdEquals(pxid, xid))
         {
             LWLockRelease(ProcArrayLock);
             xc_by_main_xid_inc();
             return true;
         }
 
         /*
          * We can ignore main Xids that are younger than the target Xid, since
          * the target could not possibly be their child.
          */
         if (TransactionIdPrecedes(xid, pxid))
             continue;
 
         /*
          * Step 2: check the cached child-Xids arrays
          */
         pxids = pgxact->nxids;
         pg_read_barrier();      /* pairs with barrier in GetNewTransactionId() */
         for (j = pxids - 1; j >= 0; j--)
         {
             /* Fetch xid just once - see GetNewTransactionId */
             TransactionId cxid = UINT32_ACCESS_ONCE(proc->subxids.xids[j]);
 
             if (TransactionIdEquals(cxid, xid))
             {
                 LWLockRelease(ProcArrayLock);
                 xc_by_child_xid_inc();
                 return true;
             }
         }
 
         /*
          * Save the main Xid for step 4.  We only need to remember main Xids
          * that have uncached children.  (Note: there is no race condition
          * here because the overflowed flag cannot be cleared, only set, while
          * we hold ProcArrayLock.  So we can't miss an Xid that we need to
          * worry about.)
          */
         if (pgxact->overflowed)
             xids[nxids++] = pxid;
     }
 
     /*
      * Step 3: in hot standby mode, check the known-assigned-xids list.  XIDs
      * in the list must be treated as running.
      */
     if (RecoveryInProgress())
     {
         /* none of the PGXACT entries should have XIDs in hot standby mode */
         Assert(nxids == 0);
 
         if (KnownAssignedXidExists(xid))
         {
             LWLockRelease(ProcArrayLock);
             xc_by_known_assigned_inc();
             return true;
         }
 
         /*
          * If the KnownAssignedXids overflowed, we have to check pg_subtrans
          * too.  Fetch all xids from KnownAssignedXids that are lower than
          * xid, since if xid is a subtransaction its parent will always have a
          * lower value.  Note we will collect both main and subXIDs here, but
          * there's no help for it.
          */
         if (TransactionIdPrecedesOrEquals(xid, procArray->lastOverflowedXid))
             nxids = KnownAssignedXidsGet(xids, xid);
     }
 
     LWLockRelease(ProcArrayLock);
 
     /*
      * If none of the relevant caches overflowed, we know the Xid is not
      * running without even looking at pg_subtrans.
      */
     if (nxids == 0)
     {
         xc_no_overflow_inc();
         return false;
     }
 
     /*
      * Step 4: have to check pg_subtrans.
      *
      * At this point, we know it's either a subtransaction of one of the Xids
      * in xids[], or it's not running.  If it's an already-failed
      * subtransaction, we want to say "not running" even though its parent may
      * still be running.  So first, check pg_xact to see if it's been aborted.
      */
     xc_slow_answer_inc();
 
     if (TransactionIdDidAbort(xid))
         return false;
 
     /*
      * It isn't aborted, so check whether the transaction tree it belongs to
      * is still running (or, more precisely, whether it was running when we
      * held ProcArrayLock).
      */
     topxid = SubTransGetTopmostTransaction(xid);
     Assert(TransactionIdIsValid(topxid));
     if (!TransactionIdEquals(topxid, xid))
     {
         for (i = 0; i < nxids; i++)
         {
             if (TransactionIdEquals(xids[i], topxid))
                 return true;
         }
     }
 
     return false;
 }

◆ XidCacheRemoveRunningXids()

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

Definition at line 3036 of file procarray.c.

References Assert, elog, fprintf, i, VariableCacheData::latestCompletedXid, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MyPgXact, MyProc, PGXACT::nxids, ShmemVariableCache, PGPROC::subxids, TransactionIdEquals, TransactionIdIsValid, TransactionIdPrecedes(), WARNING, XidCacheRemove, and XidCache::xids.

Referenced by RecordTransactionAbort().

 {
     int         i,
                 j;
 
     Assert(TransactionIdIsValid(xid));
 
     /*
      * We must hold ProcArrayLock exclusively in order to remove transactions
      * from the PGPROC array.  (See src/backend/access/transam/README.)  It's
      * possible this could be relaxed since we know this routine is only used
      * to abort subtransactions, but pending closer analysis we'd best be
      * conservative.
      *
      * Note that we do not have to be careful about memory ordering of our own
      * reads wrt. GetNewTransactionId() here - only this process can modify
      * relevant fields of MyProc/MyPgXact.  But we do have to be careful about
      * our own writes being well ordered.
      */
     LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
 
     /*
      * Under normal circumstances xid and xids[] will be in increasing order,
      * as will be the entries in subxids.  Scan backwards to avoid O(N^2)
      * behavior when removing a lot of xids.
      */
     for (i = nxids - 1; i >= 0; i--)
     {
         TransactionId anxid = xids[i];
 
         for (j = MyPgXact->nxids - 1; j >= 0; j--)
         {
             if (TransactionIdEquals(MyProc->subxids.xids[j], anxid))
             {
                 XidCacheRemove(j);
                 break;
             }
         }
 
         /*
          * Ordinarily we should have found it, unless the cache has
          * overflowed. However it's also possible for this routine to be
          * invoked multiple times for the same subtransaction, in case of an
          * error during AbortSubTransaction.  So instead of Assert, emit a
          * debug warning.
          */
         if (j < 0 && !MyPgXact->overflowed)
             elog(WARNING, "did not find subXID %u in MyProc", anxid);
     }
 
     for (j = MyPgXact->nxids - 1; j >= 0; j--)
     {
         if (TransactionIdEquals(MyProc->subxids.xids[j], xid))
         {
             XidCacheRemove(j);
             break;
         }
     }
     /* Ordinarily we should have found it, unless the cache has overflowed */
     if (j < 0 && !MyPgXact->overflowed)
         elog(WARNING, "did not find subXID %u in MyProc", xid);
 
     /* Also advance global latestCompletedXid while holding the lock */
     if (TransactionIdPrecedes(ShmemVariableCache->latestCompletedXid,
                               latestXid))
         ShmemVariableCache->latestCompletedXid = latestXid;
 
     LWLockRelease(ProcArrayLock);
 }

Macros

Functions

Macro Definition Documentation

◆ PROCARRAY_ANALYZE_FLAG

◆ PROCARRAY_FLAGS_ANALYZE

◆ PROCARRAY_FLAGS_DEFAULT

◆ PROCARRAY_FLAGS_VACUUM

◆ PROCARRAY_FLAGS_VACUUM_ANALYZE

◆ PROCARRAY_LOGICAL_DECODING_FLAG

◆ PROCARRAY_PROC_FLAGS_MASK

◆ PROCARRAY_SLOTS_XMIN

◆ PROCARRAY_VACUUM_FLAG

Function Documentation

◆ BackendPidGetProc()

◆ BackendPidGetProcWithLock()

◆ BackendXidGetPid()

◆ CancelDBBackends()

◆ CancelVirtualTransaction()

◆ CountDBBackends()

◆ CountDBConnections()

◆ CountOtherDBBackends()

◆ CountUserBackends()

◆ CreateSharedProcArray()

◆ ExpireAllKnownAssignedTransactionIds()

◆ ExpireOldKnownAssignedTransactionIds()

◆ ExpireTreeKnownAssignedTransactionIds()

◆ GetConflictingVirtualXIDs()

◆ GetCurrentVirtualXIDs()

◆ GetMaxSnapshotSubxidCount()

◆ GetMaxSnapshotXidCount()

◆ GetOldestActiveTransactionId()

◆ GetOldestSafeDecodingTransactionId()

◆ GetOldestXmin()

◆ GetRunningTransactionData()

◆ GetSnapshotData()

◆ GetVirtualXIDsDelayingChkpt()

◆ HaveVirtualXIDsDelayingChkpt()

◆ IsBackendPid()

◆ MinimumActiveBackends()

◆ ProcArrayAdd()

◆ ProcArrayApplyRecoveryInfo()

◆ ProcArrayApplyXidAssignment()

◆ ProcArrayClearTransaction()

◆ ProcArrayEndTransaction()

◆ ProcArrayGetReplicationSlotXmin()

◆ ProcArrayInitRecovery()

◆ ProcArrayInstallImportedXmin()

◆ ProcArrayInstallRestoredXmin()

◆ ProcArrayRemove()

◆ ProcArraySetReplicationSlotXmin()

◆ ProcArrayShmemSize()

◆ RecordKnownAssignedTransactionIds()

◆ TransactionIdIsActive()

◆ TransactionIdIsInProgress()

◆ XidCacheRemoveRunningXids()