procarray.c File Reference

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

Include dependency graph for procarray.c:

Go to the source code of this file.

Data Structures
struct	ProcArrayStruct
struct	GlobalVisState
struct	ComputeXidHorizonsResult

Macros
#define	UINT32_ACCESS_ONCE(var)   ((uint32)(*((volatile uint32 *)&(var))))
#define	xc_by_recent_xmin_inc()   ((void) 0)
#define	xc_by_known_xact_inc()   ((void) 0)
#define	xc_by_my_xact_inc()   ((void) 0)
#define	xc_by_latest_xid_inc()   ((void) 0)
#define	xc_by_main_xid_inc()   ((void) 0)
#define	xc_by_child_xid_inc()   ((void) 0)
#define	xc_by_known_assigned_inc()   ((void) 0)
#define	xc_no_overflow_inc()   ((void) 0)
#define	xc_slow_answer_inc()   ((void) 0)
#define	PROCARRAY_MAXPROCS   (MaxBackends + max_prepared_xacts)
#define	TOTAL_MAX_CACHED_SUBXIDS    ((PGPROC_MAX_CACHED_SUBXIDS + 1) * PROCARRAY_MAXPROCS)
#define	MAXAUTOVACPIDS   10 /* max autovacs to SIGTERM per iteration */
#define	KAX_COMPRESS_FREQUENCY   128 /* in transactions */
#define	KAX_COMPRESS_IDLE_INTERVAL   1000 /* in ms */

Typedefs
typedef struct ProcArrayStruct	ProcArrayStruct
typedef struct ComputeXidHorizonsResult	ComputeXidHorizonsResult
typedef enum GlobalVisHorizonKind	GlobalVisHorizonKind
typedef enum KAXCompressReason	KAXCompressReason

Enumerations
enum	GlobalVisHorizonKind { VISHORIZON_SHARED , VISHORIZON_CATALOG , VISHORIZON_DATA , VISHORIZON_TEMP }
enum	KAXCompressReason { KAX_NO_SPACE , KAX_PRUNE , KAX_TRANSACTION_END , KAX_STARTUP_PROCESS_IDLE }

Functions
static void	KnownAssignedXidsCompress (KAXCompressReason reason, bool haveLock)
static void	KnownAssignedXidsAdd (TransactionId from_xid, TransactionId to_xid, bool exclusive_lock)
static bool	KnownAssignedXidsSearch (TransactionId xid, bool remove)
static bool	KnownAssignedXidExists (TransactionId xid)
static void	KnownAssignedXidsRemove (TransactionId xid)
static void	KnownAssignedXidsRemoveTree (TransactionId xid, int nsubxids, TransactionId *subxids)
static void	KnownAssignedXidsRemovePreceding (TransactionId removeXid)
static int	KnownAssignedXidsGet (TransactionId *xarray, TransactionId xmax)
static int	KnownAssignedXidsGetAndSetXmin (TransactionId *xarray, TransactionId *xmin, TransactionId xmax)
static TransactionId	KnownAssignedXidsGetOldestXmin (void)
static void	KnownAssignedXidsDisplay (int trace_level)
static void	KnownAssignedXidsReset (void)
static void	ProcArrayEndTransactionInternal (PGPROC *proc, TransactionId latestXid)
static void	ProcArrayGroupClearXid (PGPROC *proc, TransactionId latestXid)
static void	MaintainLatestCompletedXid (TransactionId latestXid)
static void	MaintainLatestCompletedXidRecovery (TransactionId latestXid)
static FullTransactionId	FullXidRelativeTo (FullTransactionId rel, TransactionId xid)
static void	GlobalVisUpdateApply (ComputeXidHorizonsResult *horizons)
Size	ProcArrayShmemSize (void)
void	CreateSharedProcArray (void)
void	ProcArrayAdd (PGPROC *proc)
void	ProcArrayRemove (PGPROC *proc, TransactionId latestXid)
void	ProcArrayEndTransaction (PGPROC *proc, TransactionId latestXid)
void	ProcArrayClearTransaction (PGPROC *proc)
void	ProcArrayInitRecovery (TransactionId initializedUptoXID)
void	ProcArrayApplyRecoveryInfo (RunningTransactions running)
void	ProcArrayApplyXidAssignment (TransactionId topxid, int nsubxids, TransactionId *subxids)
bool	TransactionIdIsInProgress (TransactionId xid)
bool	TransactionIdIsActive (TransactionId xid)
static void	ComputeXidHorizons (ComputeXidHorizonsResult *h)
static GlobalVisHorizonKind	GlobalVisHorizonKindForRel (Relation rel)
TransactionId	GetOldestNonRemovableTransactionId (Relation rel)
TransactionId	GetOldestTransactionIdConsideredRunning (void)
void	GetReplicationHorizons (TransactionId *xmin, TransactionId *catalog_xmin)
int	GetMaxSnapshotXidCount (void)
int	GetMaxSnapshotSubxidCount (void)
static bool	GetSnapshotDataReuse (Snapshot snapshot)
Snapshot	GetSnapshotData (Snapshot snapshot)
bool	ProcArrayInstallImportedXmin (TransactionId xmin, VirtualTransactionId *sourcevxid)
bool	ProcArrayInstallRestoredXmin (TransactionId xmin, PGPROC *proc)
RunningTransactions	GetRunningTransactionData (void)
TransactionId	GetOldestActiveTransactionId (void)
TransactionId	GetOldestSafeDecodingTransactionId (bool catalogOnly)
VirtualTransactionId *	GetVirtualXIDsDelayingChkpt (int *nvxids, int type)
bool	HaveVirtualXIDsDelayingChkpt (VirtualTransactionId *vxids, int nvxids, int type)
PGPROC *	BackendPidGetProc (int pid)
PGPROC *	BackendPidGetProcWithLock (int pid)
int	BackendXidGetPid (TransactionId xid)
bool	IsBackendPid (int pid)
VirtualTransactionId *	GetCurrentVirtualXIDs (TransactionId limitXmin, bool excludeXmin0, bool allDbs, int excludeVacuum, int *nvxids)
VirtualTransactionId *	GetConflictingVirtualXIDs (TransactionId limitXmin, Oid dbOid)
pid_t	CancelVirtualTransaction (VirtualTransactionId vxid, ProcSignalReason sigmode)
pid_t	SignalVirtualTransaction (VirtualTransactionId vxid, ProcSignalReason sigmode, bool conflictPending)
bool	MinimumActiveBackends (int min)
int	CountDBBackends (Oid databaseid)
int	CountDBConnections (Oid databaseid)
void	CancelDBBackends (Oid databaseid, ProcSignalReason sigmode, bool conflictPending)
int	CountUserBackends (Oid roleid)
bool	CountOtherDBBackends (Oid databaseId, int *nbackends, int *nprepared)
void	TerminateOtherDBBackends (Oid databaseId)
void	ProcArraySetReplicationSlotXmin (TransactionId xmin, TransactionId catalog_xmin, bool already_locked)
void	ProcArrayGetReplicationSlotXmin (TransactionId *xmin, TransactionId *catalog_xmin)
void	XidCacheRemoveRunningXids (TransactionId xid, int nxids, const TransactionId *xids, TransactionId latestXid)
GlobalVisState *	GlobalVisTestFor (Relation rel)
static bool	GlobalVisTestShouldUpdate (GlobalVisState *state)
static void	GlobalVisUpdate (void)
bool	GlobalVisTestIsRemovableFullXid (GlobalVisState *state, FullTransactionId fxid)
bool	GlobalVisTestIsRemovableXid (GlobalVisState *state, TransactionId xid)
FullTransactionId	GlobalVisTestNonRemovableFullHorizon (GlobalVisState *state)
TransactionId	GlobalVisTestNonRemovableHorizon (GlobalVisState *state)
bool	GlobalVisCheckRemovableFullXid (Relation rel, FullTransactionId fxid)
bool	GlobalVisCheckRemovableXid (Relation rel, TransactionId xid)
void	RecordKnownAssignedTransactionIds (TransactionId xid)
void	ExpireTreeKnownAssignedTransactionIds (TransactionId xid, int nsubxids, TransactionId *subxids, TransactionId max_xid)
void	ExpireAllKnownAssignedTransactionIds (void)
void	ExpireOldKnownAssignedTransactionIds (TransactionId xid)
void	KnownAssignedTransactionIdsIdleMaintenance (void)

Variables
static ProcArrayStruct *	procArray
static PGPROC *	allProcs
static TransactionId	cachedXidIsNotInProgress = InvalidTransactionId
static TransactionId *	KnownAssignedXids
static bool *	KnownAssignedXidsValid
static TransactionId	latestObservedXid = InvalidTransactionId
static TransactionId	standbySnapshotPendingXmin
static GlobalVisState	GlobalVisSharedRels
static GlobalVisState	GlobalVisCatalogRels
static GlobalVisState	GlobalVisDataRels
static GlobalVisState	GlobalVisTempRels
static TransactionId	ComputeXidHorizonsResultLastXmin

Macro Definition Documentation

KAX_COMPRESS_FREQUENCY

#define KAX_COMPRESS_FREQUENCY   128 /* in transactions */

KAX_COMPRESS_IDLE_INTERVAL

#define KAX_COMPRESS_IDLE_INTERVAL   1000 /* in ms */

MAXAUTOVACPIDS

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

PROCARRAY_MAXPROCS

#define PROCARRAY_MAXPROCS   (MaxBackends + max_prepared_xacts)

TOTAL_MAX_CACHED_SUBXIDS

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

UINT32_ACCESS_ONCE

#define UINT32_ACCESS_ONCE

(

var

)

((uint32)(*((volatile uint32 *)&(var))))

Definition at line 69 of file procarray.c.

xc_by_child_xid_inc

#define xc_by_child_xid_inc

(

)

((void) 0)

Definition at line 341 of file procarray.c.

xc_by_known_assigned_inc

#define xc_by_known_assigned_inc

(

)

((void) 0)

Definition at line 342 of file procarray.c.

xc_by_known_xact_inc

#define xc_by_known_xact_inc

(

)

((void) 0)

Definition at line 337 of file procarray.c.

xc_by_latest_xid_inc

#define xc_by_latest_xid_inc

(

)

((void) 0)

Definition at line 339 of file procarray.c.

xc_by_main_xid_inc

#define xc_by_main_xid_inc

(

)

((void) 0)

Definition at line 340 of file procarray.c.

xc_by_my_xact_inc

#define xc_by_my_xact_inc

(

)

((void) 0)

Definition at line 338 of file procarray.c.

xc_by_recent_xmin_inc

#define xc_by_recent_xmin_inc

(

)

((void) 0)

Definition at line 336 of file procarray.c.

xc_no_overflow_inc

#define xc_no_overflow_inc

(

)

((void) 0)

Definition at line 343 of file procarray.c.

xc_slow_answer_inc

#define xc_slow_answer_inc

(

)

((void) 0)

Definition at line 344 of file procarray.c.

Typedef Documentation

ComputeXidHorizonsResult

typedef struct ComputeXidHorizonsResult ComputeXidHorizonsResult

GlobalVisHorizonKind

typedef enum GlobalVisHorizonKind GlobalVisHorizonKind

KAXCompressReason

typedef enum KAXCompressReason KAXCompressReason

ProcArrayStruct

typedef struct ProcArrayStruct ProcArrayStruct

Enumeration Type Documentation

GlobalVisHorizonKind

enum GlobalVisHorizonKind

Enumerator
VISHORIZON_SHARED
VISHORIZON_CATALOG
VISHORIZON_DATA
VISHORIZON_TEMP

Definition at line 250 of file procarray.c.

{
    VISHORIZON_SHARED,
    VISHORIZON_CATALOG,
    VISHORIZON_DATA,
    VISHORIZON_TEMP
} GlobalVisHorizonKind;

KAXCompressReason

enum KAXCompressReason

Enumerator
KAX_NO_SPACE
KAX_PRUNE
KAX_TRANSACTION_END
KAX_STARTUP_PROCESS_IDLE

Definition at line 261 of file procarray.c.

{
    KAX_NO_SPACE,               /* need to free up space at array end */
    KAX_PRUNE,                  /* we just pruned old entries */
    KAX_TRANSACTION_END,        /* we just committed/removed some XIDs */
    KAX_STARTUP_PROCESS_IDLE    /* startup process is about to sleep */
} KAXCompressReason;

Function Documentation

BackendPidGetProc()

PGPROC* BackendPidGetProc

(

int

pid

)

Definition at line 3103 of file procarray.c.

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

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

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

BackendPidGetProcWithLock()

PGPROC* BackendPidGetProcWithLock

(

int

pid

)

Definition at line 3126 of file procarray.c.

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

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

Referenced by BackendPidGetProc(), and GetBlockerStatusData().

BackendXidGetPid()

int BackendXidGetPid

(

TransactionId

xid

)

Definition at line 3163 of file procarray.c.

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

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

Referenced by pgrowlocks().

CancelDBBackends()

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

Definition at line 3567 of file procarray.c.

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

References allProcs, 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().

CancelVirtualTransaction()

pid_t CancelVirtualTransaction	(	VirtualTransactionId	vxid,
		ProcSignalReason	sigmode
	)

Definition at line 3398 of file procarray.c.

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

References SignalVirtualTransaction().

Referenced by ResolveRecoveryConflictWithVirtualXIDs().

ComputeXidHorizons()

static void ComputeXidHorizons ( ComputeXidHorizonsResult *  h )

static

Definition at line 1716 of file procarray.c.

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

References allProcs, Assert(), ComputeXidHorizonsResult::catalog_oldest_nonremovable, ComputeXidHorizonsResult::data_oldest_nonremovable, PGPROC::databaseId, GlobalVisUpdateApply(), InvalidOid, InvalidTransactionId, KnownAssignedXidsGetOldestXmin(), ComputeXidHorizonsResult::latest_completed, VariableCacheData::latestCompletedXid, LW_SHARED, LWLockAcquire(), LWLockRelease(), MyDatabaseId, MyProc, ProcArrayStruct::numProcs, ComputeXidHorizonsResult::oldest_considered_running, ProcArrayStruct::pgprocnos, PROC_AFFECTS_ALL_HORIZONS, PROC_IN_LOGICAL_DECODING, PROC_IN_VACUUM, procArray, ProcGlobal, RecoveryInProgress(), ProcArrayStruct::replication_slot_catalog_xmin, ProcArrayStruct::replication_slot_xmin, ComputeXidHorizonsResult::shared_oldest_nonremovable, ComputeXidHorizonsResult::shared_oldest_nonremovable_raw, ShmemVariableCache, ComputeXidHorizonsResult::slot_catalog_xmin, ComputeXidHorizonsResult::slot_xmin, PROC_HDR::statusFlags, ComputeXidHorizonsResult::temp_oldest_nonremovable, TransactionIdAdvance, TransactionIdIsValid, TransactionIdOlder(), TransactionIdPrecedesOrEquals(), UINT32_ACCESS_ONCE, PGPROC::xid, XidFromFullTransactionId, PROC_HDR::xids, and PGPROC::xmin.

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

CountDBBackends()

int CountDBBackends

(

Oid

databaseid

)

Definition at line 3506 of file procarray.c.

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

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

Referenced by ResolveRecoveryConflictWithDatabase().

CountDBConnections()

int CountDBConnections

(

Oid

databaseid

)

Definition at line 3536 of file procarray.c.

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

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

Referenced by CheckMyDatabase().

CountOtherDBBackends()

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

Definition at line 3657 of file procarray.c.

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

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

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

CountUserBackends()

int CountUserBackends

(

Oid

roleid

)

Definition at line 3607 of file procarray.c.

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

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

Referenced by InitializeSessionUserId().

CreateSharedProcArray()

void CreateSharedProcArray

(

void

)

Definition at line 419 of file procarray.c.

{
    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;
        procArray->lastOverflowedXid = InvalidTransactionId;
        procArray->replication_slot_xmin = InvalidTransactionId;
        procArray->replication_slot_catalog_xmin = InvalidTransactionId;
        ShmemVariableCache->xactCompletionCount = 1;
    }
 
    allProcs = ProcGlobal->allProcs;
 
    /* Create or attach to the KnownAssignedXids arrays too, if needed */
    if (EnableHotStandby)
    {
        KnownAssignedXids = (TransactionId *)
            ShmemInitStruct("KnownAssignedXids",
                            mul_size(sizeof(TransactionId),
                                     TOTAL_MAX_CACHED_SUBXIDS),
                            &found);
        KnownAssignedXidsValid = (bool *)
            ShmemInitStruct("KnownAssignedXidsValid",
                            mul_size(sizeof(bool), TOTAL_MAX_CACHED_SUBXIDS),
                            &found);
    }
}

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

Referenced by CreateSharedMemoryAndSemaphores().

ExpireAllKnownAssignedTransactionIds()

void ExpireAllKnownAssignedTransactionIds

(

void

)

Definition at line 4432 of file procarray.c.

{
    LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
    KnownAssignedXidsRemovePreceding(InvalidTransactionId);
 
    /*
     * Reset lastOverflowedXid.  Currently, lastOverflowedXid has no use after
     * the call of this function.  But do this for unification with what
     * ExpireOldKnownAssignedTransactionIds() do.
     */
    procArray->lastOverflowedXid = InvalidTransactionId;
    LWLockRelease(ProcArrayLock);
}

References InvalidTransactionId, KnownAssignedXidsRemovePreceding(), ProcArrayStruct::lastOverflowedXid, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), and procArray.

Referenced by ShutdownRecoveryTransactionEnvironment().

ExpireOldKnownAssignedTransactionIds()

void ExpireOldKnownAssignedTransactionIds

(

TransactionId

xid

)

Definition at line 4452 of file procarray.c.

{
    LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
 
    /*
     * Reset lastOverflowedXid if we know all transactions that have been
     * possibly running are being gone.  Not doing so could cause an incorrect
     * lastOverflowedXid value, which makes extra snapshots be marked as
     * suboverflowed.
     */
    if (TransactionIdPrecedes(procArray->lastOverflowedXid, xid))
        procArray->lastOverflowedXid = InvalidTransactionId;
    KnownAssignedXidsRemovePreceding(xid);
    LWLockRelease(ProcArrayLock);
}

References InvalidTransactionId, KnownAssignedXidsRemovePreceding(), ProcArrayStruct::lastOverflowedXid, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), procArray, and TransactionIdPrecedes().

Referenced by ProcArrayApplyRecoveryInfo().

ExpireTreeKnownAssignedTransactionIds()

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

Definition at line 4406 of file procarray.c.

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

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

Referenced by xact_redo_abort(), and xact_redo_commit().

FullXidRelativeTo()

static FullTransactionId FullXidRelativeTo ( FullTransactionId  rel, TransactionId  xid  )

inlinestatic

Definition at line 4255 of file procarray.c.

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

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

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

GetConflictingVirtualXIDs()

VirtualTransactionId* GetConflictingVirtualXIDs	(	TransactionId	limitXmin,
		Oid	dbOid
	)

Definition at line 3324 of file procarray.c.

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

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

Referenced by ResolveRecoveryConflictWithSnapshot(), and ResolveRecoveryConflictWithTablespace().

GetCurrentVirtualXIDs()

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

Definition at line 3231 of file procarray.c.

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

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

Referenced by WaitForOlderSnapshots().

GetMaxSnapshotSubxidCount()

int GetMaxSnapshotSubxidCount

(

void

)

Definition at line 2061 of file procarray.c.

{
    return TOTAL_MAX_CACHED_SUBXIDS;
}

References TOTAL_MAX_CACHED_SUBXIDS.

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

GetMaxSnapshotXidCount()

int GetMaxSnapshotXidCount

(

void

)

Definition at line 2050 of file procarray.c.

{
    return procArray->maxProcs;
}

References ProcArrayStruct::maxProcs, and procArray.

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

GetOldestActiveTransactionId()

TransactionId GetOldestActiveTransactionId

(

void

)

Definition at line 2845 of file procarray.c.

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

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

Referenced by CreateCheckPoint().

GetOldestNonRemovableTransactionId()

TransactionId GetOldestNonRemovableTransactionId

(

Relation

rel

)

Definition at line 1986 of file procarray.c.

{
    ComputeXidHorizonsResult horizons;
 
    ComputeXidHorizons(&horizons);
 
    switch (GlobalVisHorizonKindForRel(rel))
    {
        case VISHORIZON_SHARED:
            return horizons.shared_oldest_nonremovable;
        case VISHORIZON_CATALOG:
            return horizons.catalog_oldest_nonremovable;
        case VISHORIZON_DATA:
            return horizons.data_oldest_nonremovable;
        case VISHORIZON_TEMP:
            return horizons.temp_oldest_nonremovable;
    }
 
    /* just to prevent compiler warnings */
    return InvalidTransactionId;
}

References ComputeXidHorizonsResult::catalog_oldest_nonremovable, ComputeXidHorizons(), ComputeXidHorizonsResult::data_oldest_nonremovable, GlobalVisHorizonKindForRel(), InvalidTransactionId, ComputeXidHorizonsResult::shared_oldest_nonremovable, ComputeXidHorizonsResult::temp_oldest_nonremovable, VISHORIZON_CATALOG, VISHORIZON_DATA, VISHORIZON_SHARED, and VISHORIZON_TEMP.

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

GetOldestSafeDecodingTransactionId()

TransactionId GetOldestSafeDecodingTransactionId

(

bool

catalogOnly

)

Definition at line 2910 of file procarray.c.

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

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

Referenced by CreateInitDecodingContext(), and SnapBuildInitialSnapshot().

GetOldestTransactionIdConsideredRunning()

TransactionId GetOldestTransactionIdConsideredRunning

(

void

)

Definition at line 2015 of file procarray.c.

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

References ComputeXidHorizons(), and ComputeXidHorizonsResult::oldest_considered_running.

Referenced by CreateCheckPoint(), and CreateRestartPoint().

GetReplicationHorizons()

void GetReplicationHorizons	(	TransactionId *	xmin,
		TransactionId *	catalog_xmin
	)

Definition at line 2028 of file procarray.c.

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

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

Referenced by XLogWalRcvSendHSFeedback().

GetRunningTransactionData()

RunningTransactions GetRunningTransactionData

(

void

)

Definition at line 2670 of file procarray.c.

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

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

Referenced by LogStandbySnapshot().

GetSnapshotData()

Snapshot GetSnapshotData

(

Snapshot

snapshot

)

Definition at line 2159 of file procarray.c.

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

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

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

GetSnapshotDataReuse()

static bool GetSnapshotDataReuse ( Snapshot  snapshot )

static

Definition at line 2076 of file procarray.c.

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

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

Referenced by GetSnapshotData().

GetVirtualXIDsDelayingChkpt()

VirtualTransactionId* GetVirtualXIDsDelayingChkpt	(	int *	nvxids,
		int	type
	)

Definition at line 3008 of file procarray.c.

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

References allProcs, Assert(), PGPROC::delayChkptFlags, GET_VXID_FROM_PGPROC, LW_SHARED, LWLockAcquire(), LWLockRelease(), ProcArrayStruct::maxProcs, ProcArrayStruct::numProcs, palloc(), ProcArrayStruct::pgprocnos, procArray, type, and VirtualTransactionIdIsValid.

Referenced by CreateCheckPoint().

GlobalVisCheckRemovableFullXid()

bool GlobalVisCheckRemovableFullXid	(	Relation	rel,
		FullTransactionId	fxid
	)

Definition at line 4220 of file procarray.c.

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

References GlobalVisTestFor(), and GlobalVisTestIsRemovableFullXid().

Referenced by _bt_pendingfsm_finalize(), BTPageIsRecyclable(), and gistPageRecyclable().

GlobalVisCheckRemovableXid()

bool GlobalVisCheckRemovableXid	(	Relation	rel,
		TransactionId	xid
	)

Definition at line 4234 of file procarray.c.

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

References GlobalVisTestFor(), and GlobalVisTestIsRemovableXid().

Referenced by GinPageIsRecyclable().

GlobalVisHorizonKindForRel()

static GlobalVisHorizonKind GlobalVisHorizonKindForRel ( Relation  rel )

inlinestatic

Definition at line 1952 of file procarray.c.

{
    /*
     * Other relkinds currently don't contain xids, nor always the necessary
     * logical decoding markers.
     */
    Assert(!rel ||
           rel->rd_rel->relkind == RELKIND_RELATION ||
           rel->rd_rel->relkind == RELKIND_MATVIEW ||
           rel->rd_rel->relkind == RELKIND_TOASTVALUE);
 
    if (rel == NULL || rel->rd_rel->relisshared || RecoveryInProgress())
        return VISHORIZON_SHARED;
    else if (IsCatalogRelation(rel) ||
             RelationIsAccessibleInLogicalDecoding(rel))
        return VISHORIZON_CATALOG;
    else if (!RELATION_IS_LOCAL(rel))
        return VISHORIZON_DATA;
    else
        return VISHORIZON_TEMP;
}

References Assert(), IsCatalogRelation(), RelationData::rd_rel, RecoveryInProgress(), RELATION_IS_LOCAL, RelationIsAccessibleInLogicalDecoding, VISHORIZON_CATALOG, VISHORIZON_DATA, VISHORIZON_SHARED, and VISHORIZON_TEMP.

Referenced by GetOldestNonRemovableTransactionId(), and GlobalVisTestFor().

GlobalVisTestFor()

GlobalVisState* GlobalVisTestFor

(

Relation

rel

)

Definition at line 4011 of file procarray.c.

{
    GlobalVisState *state = NULL;
 
    /* XXX: we should assert that a snapshot is pushed or registered */
    Assert(RecentXmin);
 
    switch (GlobalVisHorizonKindForRel(rel))
    {
        case VISHORIZON_SHARED:
            state = &GlobalVisSharedRels;
            break;
        case VISHORIZON_CATALOG:
            state = &GlobalVisCatalogRels;
            break;
        case VISHORIZON_DATA:
            state = &GlobalVisDataRels;
            break;
        case VISHORIZON_TEMP:
            state = &GlobalVisTempRels;
            break;
    }
 
    Assert(FullTransactionIdIsValid(state->definitely_needed) &&
           FullTransactionIdIsValid(state->maybe_needed));
 
    return state;
}

References Assert(), FullTransactionIdIsValid, GlobalVisCatalogRels, GlobalVisDataRels, GlobalVisHorizonKindForRel(), GlobalVisSharedRels, GlobalVisTempRels, RecentXmin, VISHORIZON_CATALOG, VISHORIZON_DATA, VISHORIZON_SHARED, and VISHORIZON_TEMP.

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

GlobalVisTestIsRemovableFullXid()

bool GlobalVisTestIsRemovableFullXid	(	GlobalVisState *	state,
		FullTransactionId	fxid
	)

Definition at line 4126 of file procarray.c.

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

References Assert(), FullTransactionIdFollowsOrEquals, FullTransactionIdPrecedes, GlobalVisTestShouldUpdate(), and GlobalVisUpdate().

Referenced by GlobalVisCheckRemovableFullXid(), and GlobalVisTestIsRemovableXid().

GlobalVisTestIsRemovableXid()

bool GlobalVisTestIsRemovableXid	(	GlobalVisState *	state,
		TransactionId	xid
	)

Definition at line 4168 of file procarray.c.

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

References FullXidRelativeTo(), and GlobalVisTestIsRemovableFullXid().

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

GlobalVisTestNonRemovableFullHorizon()

FullTransactionId GlobalVisTestNonRemovableFullHorizon

(

GlobalVisState *

state

)

Definition at line 4195 of file procarray.c.

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

References GlobalVisTestShouldUpdate(), and GlobalVisUpdate().

Referenced by GlobalVisTestNonRemovableHorizon().

GlobalVisTestNonRemovableHorizon()

TransactionId GlobalVisTestNonRemovableHorizon

(

GlobalVisState *

state

)

Definition at line 4206 of file procarray.c.

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

References GlobalVisTestNonRemovableFullHorizon(), and XidFromFullTransactionId.

GlobalVisTestShouldUpdate()

static bool GlobalVisTestShouldUpdate ( GlobalVisState *  state )

static

Definition at line 4051 of file procarray.c.

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

References ComputeXidHorizonsResultLastXmin, FullTransactionIdFollowsOrEquals, RecentXmin, and TransactionIdIsValid.

Referenced by GlobalVisTestIsRemovableFullXid(), and GlobalVisTestNonRemovableFullHorizon().

GlobalVisUpdate()

static void GlobalVisUpdate ( void  )

static

Definition at line 4109 of file procarray.c.

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

References ComputeXidHorizons().

Referenced by GlobalVisTestIsRemovableFullXid(), and GlobalVisTestNonRemovableFullHorizon().

GlobalVisUpdateApply()

static void GlobalVisUpdateApply ( ComputeXidHorizonsResult *  horizons )

static

Definition at line 4070 of file procarray.c.

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

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

Referenced by ComputeXidHorizons().

HaveVirtualXIDsDelayingChkpt()

bool HaveVirtualXIDsDelayingChkpt	(	VirtualTransactionId *	vxids,
		int	nvxids,
		int	type
	)

Definition at line 3054 of file procarray.c.

{
    bool        result = false;
    ProcArrayStruct *arrayP = procArray;
    int         index;
 
    Assert(type != 0);
 
    LWLockAcquire(ProcArrayLock, LW_SHARED);
 
    for (index = 0; index < arrayP->numProcs; index++)
    {
        int         pgprocno = arrayP->pgprocnos[index];
        PGPROC     *proc = &allProcs[pgprocno];
        VirtualTransactionId vxid;
 
        GET_VXID_FROM_PGPROC(vxid, *proc);
 
        if ((proc->delayChkptFlags & type) != 0 &&
            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;
}

References allProcs, Assert(), PGPROC::delayChkptFlags, GET_VXID_FROM_PGPROC, i, LW_SHARED, LWLockAcquire(), LWLockRelease(), ProcArrayStruct::numProcs, ProcArrayStruct::pgprocnos, procArray, type, VirtualTransactionIdEquals, and VirtualTransactionIdIsValid.

Referenced by CreateCheckPoint().

IsBackendPid()

bool IsBackendPid

(

int

pid

)

Definition at line 3198 of file procarray.c.

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

References BackendPidGetProc().

Referenced by pg_stat_get_subscription().

KnownAssignedTransactionIdsIdleMaintenance()

void KnownAssignedTransactionIdsIdleMaintenance

(

void

)

Definition at line 4474 of file procarray.c.

{
    KnownAssignedXidsCompress(KAX_STARTUP_PROCESS_IDLE, false);
}

References KAX_STARTUP_PROCESS_IDLE, and KnownAssignedXidsCompress().

Referenced by WaitForWALToBecomeAvailable().

KnownAssignedXidExists()

static bool KnownAssignedXidExists ( TransactionId  xid )

static

Definition at line 4884 of file procarray.c.

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

References Assert(), KnownAssignedXidsSearch(), and TransactionIdIsValid.

Referenced by TransactionIdIsInProgress().

KnownAssignedXidsAdd()

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

static

Definition at line 4692 of file procarray.c.

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

References Assert(), elog(), ERROR, ProcArrayStruct::headKnownAssignedXids, i, KAX_NO_SPACE, KnownAssignedXids, KnownAssignedXidsCompress(), KnownAssignedXidsDisplay(), KnownAssignedXidsValid, LOG, ProcArrayStruct::maxKnownAssignedXids, ProcArrayStruct::numKnownAssignedXids, pg_write_barrier, procArray, ProcArrayStruct::tailKnownAssignedXids, TransactionIdAdvance, TransactionIdFollowsOrEquals(), TransactionIdPrecedes(), and TransactionIdPrecedesOrEquals().

Referenced by ProcArrayApplyRecoveryInfo(), and RecordKnownAssignedTransactionIds().

KnownAssignedXidsCompress()

static void KnownAssignedXidsCompress ( KAXCompressReason  reason, bool  haveLock  )

static

Definition at line 4575 of file procarray.c.

{
    ProcArrayStruct *pArray = procArray;
    int         head,
                tail,
                nelements;
    int         compress_index;
    int         i;
 
    /* Counters for compression heuristics */
    static unsigned int transactionEndsCounter;
    static TimestampTz lastCompressTs;
 
    /* Tuning constants */
#define KAX_COMPRESS_FREQUENCY 128  /* in transactions */
#define KAX_COMPRESS_IDLE_INTERVAL 1000 /* in ms */
 
    /*
     * Since only the startup process modifies the head/tail pointers, we
     * don't need a lock to read them here.
     */
    head = pArray->headKnownAssignedXids;
    tail = pArray->tailKnownAssignedXids;
    nelements = head - tail;
 
    /*
     * If we can choose whether to compress, use a heuristic to avoid
     * compressing too often or not often enough.  "Compress" here simply
     * means moving the values to the beginning of the array, so it is not as
     * complex or costly as typical data compression algorithms.
     */
    if (nelements == pArray->numKnownAssignedXids)
    {
        /*
         * When there are no gaps between head and tail, don't bother to
         * compress, except in the KAX_NO_SPACE case where we must compress to
         * create some space after the head.
         */
        if (reason != KAX_NO_SPACE)
            return;
    }
    else if (reason == KAX_TRANSACTION_END)
    {
        /*
         * Consider compressing only once every so many commits.  Frequency
         * determined by benchmarks.
         */
        if ((transactionEndsCounter++) % KAX_COMPRESS_FREQUENCY != 0)
            return;
 
        /*
         * Furthermore, compress only if the used part of the array is less
         * than 50% full (see comments above).
         */
        if (nelements < 2 * pArray->numKnownAssignedXids)
            return;
    }
    else if (reason == KAX_STARTUP_PROCESS_IDLE)
    {
        /*
         * We're about to go idle for lack of new WAL, so we might as well
         * compress.  But not too often, to avoid ProcArray lock contention
         * with readers.
         */
        if (lastCompressTs != 0)
        {
            TimestampTz compress_after;
 
            compress_after = TimestampTzPlusMilliseconds(lastCompressTs,
                                                         KAX_COMPRESS_IDLE_INTERVAL);
            if (GetCurrentTimestamp() < compress_after)
                return;
        }
    }
 
    /* Need to compress, so get the lock if we don't have it. */
    if (!haveLock)
        LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
 
    /*
     * We compress the array by reading the valid values from tail to head,
     * re-aligning data to 0th element.
     */
    compress_index = 0;
    for (i = tail; i < head; i++)
    {
        if (KnownAssignedXidsValid[i])
        {
            KnownAssignedXids[compress_index] = KnownAssignedXids[i];
            KnownAssignedXidsValid[compress_index] = true;
            compress_index++;
        }
    }
    Assert(compress_index == pArray->numKnownAssignedXids);
 
    pArray->tailKnownAssignedXids = 0;
    pArray->headKnownAssignedXids = compress_index;
 
    if (!haveLock)
        LWLockRelease(ProcArrayLock);
 
    /* Update timestamp for maintenance.  No need to hold lock for this. */
    lastCompressTs = GetCurrentTimestamp();
}

References Assert(), GetCurrentTimestamp(), ProcArrayStruct::headKnownAssignedXids, i, KAX_COMPRESS_FREQUENCY, KAX_COMPRESS_IDLE_INTERVAL, KAX_NO_SPACE, KAX_STARTUP_PROCESS_IDLE, KAX_TRANSACTION_END, KnownAssignedXids, KnownAssignedXidsValid, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), ProcArrayStruct::numKnownAssignedXids, procArray, ProcArrayStruct::tailKnownAssignedXids, and TimestampTzPlusMilliseconds.

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

KnownAssignedXidsDisplay()

static void KnownAssignedXidsDisplay ( int  trace_level )

static

Definition at line 5128 of file procarray.c.

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

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

Referenced by KnownAssignedXidsAdd(), and ProcArrayApplyRecoveryInfo().

KnownAssignedXidsGet()

static int KnownAssignedXidsGet ( TransactionId *  xarray, TransactionId  xmax  )

static

Definition at line 5023 of file procarray.c.

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

References InvalidTransactionId, and KnownAssignedXidsGetAndSetXmin().

Referenced by TransactionIdIsInProgress().

KnownAssignedXidsGetAndSetXmin()

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

static

Definition at line 5037 of file procarray.c.

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

References ProcArrayStruct::headKnownAssignedXids, i, KnownAssignedXids, KnownAssignedXidsValid, pg_read_barrier, procArray, ProcArrayStruct::tailKnownAssignedXids, TransactionIdFollowsOrEquals(), TransactionIdIsValid, and TransactionIdPrecedes().

Referenced by GetSnapshotData(), and KnownAssignedXidsGet().

KnownAssignedXidsGetOldestXmin()

static TransactionId KnownAssignedXidsGetOldestXmin ( void  )

static

Definition at line 5093 of file procarray.c.

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

References ProcArrayStruct::headKnownAssignedXids, i, InvalidTransactionId, KnownAssignedXids, KnownAssignedXidsValid, pg_read_barrier, procArray, and ProcArrayStruct::tailKnownAssignedXids.

Referenced by ComputeXidHorizons().

KnownAssignedXidsRemove()

static void KnownAssignedXidsRemove ( TransactionId  xid )

static

Definition at line 4897 of file procarray.c.

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

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

Referenced by KnownAssignedXidsRemoveTree().

KnownAssignedXidsRemovePreceding()

static void KnownAssignedXidsRemovePreceding ( TransactionId  removeXid )

static

Definition at line 4945 of file procarray.c.

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

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

Referenced by ExpireAllKnownAssignedTransactionIds(), and ExpireOldKnownAssignedTransactionIds().

KnownAssignedXidsRemoveTree()

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

static

Definition at line 4923 of file procarray.c.

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

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

Referenced by ExpireTreeKnownAssignedTransactionIds(), and ProcArrayApplyXidAssignment().

KnownAssignedXidsReset()

static void KnownAssignedXidsReset ( void  )

static

Definition at line 5166 of file procarray.c.

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

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

Referenced by ProcArrayApplyRecoveryInfo().

KnownAssignedXidsSearch()

static bool KnownAssignedXidsSearch ( TransactionId  xid, bool  remove  )

static

Definition at line 4796 of file procarray.c.

{
    ProcArrayStruct *pArray = procArray;
    int         first,
                last;
    int         head;
    int         tail;
    int         result_index = -1;
 
    tail = pArray->tailKnownAssignedXids;
    head = pArray->headKnownAssignedXids;
 
    /*
     * Only the startup process removes entries, so we don't need the read
     * barrier in that case.
     */
    if (!remove)
        pg_read_barrier();      /* pairs with KnownAssignedXidsAdd */
 
    /*
     * Standard binary search.  Note we can ignore the KnownAssignedXidsValid
     * array here, since even invalid entries will contain sorted XIDs.
     */
    first = tail;
    last = head - 1;
    while (first <= last)
    {
        int         mid_index;
        TransactionId mid_xid;
 
        mid_index = (first + last) / 2;
        mid_xid = KnownAssignedXids[mid_index];
 
        if (xid == mid_xid)
        {
            result_index = mid_index;
            break;
        }
        else if (TransactionIdPrecedes(xid, mid_xid))
            last = mid_index - 1;
        else
            first = mid_index + 1;
    }
 
    if (result_index < 0)
        return false;           /* not in array */
 
    if (!KnownAssignedXidsValid[result_index])
        return false;           /* in array, but invalid */
 
    if (remove)
    {
        KnownAssignedXidsValid[result_index] = false;
 
        pArray->numKnownAssignedXids--;
        Assert(pArray->numKnownAssignedXids >= 0);
 
        /*
         * If we're removing the tail element then advance tail pointer over
         * any invalid elements.  This will speed future searches.
         */
        if (result_index == tail)
        {
            tail++;
            while (tail < head && !KnownAssignedXidsValid[tail])
                tail++;
            if (tail >= head)
            {
                /* Array is empty, so we can reset both pointers */
                pArray->headKnownAssignedXids = 0;
                pArray->tailKnownAssignedXids = 0;
            }
            else
            {
                pArray->tailKnownAssignedXids = tail;
            }
        }
    }
 
    return true;
}

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

Referenced by KnownAssignedXidExists(), and KnownAssignedXidsRemove().

MaintainLatestCompletedXid()

static void MaintainLatestCompletedXid ( TransactionId  latestXid )

static

Definition at line 966 of file procarray.c.

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

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

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

MaintainLatestCompletedXidRecovery()

static void MaintainLatestCompletedXidRecovery ( TransactionId  latestXid )

static

Definition at line 988 of file procarray.c.

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

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

Referenced by ExpireTreeKnownAssignedTransactionIds(), and ProcArrayApplyRecoveryInfo().

MinimumActiveBackends()

bool MinimumActiveBackends

(

int

min

)

Definition at line 3453 of file procarray.c.

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

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

Referenced by XLogFlush().

ProcArrayAdd()

void ProcArrayAdd

(

PGPROC *

proc

)

Definition at line 469 of file procarray.c.

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

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

Referenced by InitProcessPhase2(), and MarkAsPrepared().

ProcArrayApplyRecoveryInfo()

void ProcArrayApplyRecoveryInfo

(

RunningTransactions

running

)

Definition at line 1053 of file procarray.c.

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

References AdvanceNextFullTransactionIdPastXid(), Assert(), DEBUG1, DEBUG3, elog(), ERROR, ExpireOldKnownAssignedTransactionIds(), ExtendSUBTRANS(), FullTransactionIdIsValid, i, InvalidTransactionId, KnownAssignedXidsAdd(), KnownAssignedXidsDisplay(), KnownAssignedXidsReset(), ProcArrayStruct::lastOverflowedXid, RunningTransactionsData::latestCompletedXid, latestObservedXid, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MaintainLatestCompletedXidRecovery(), VariableCacheData::nextXid, RunningTransactionsData::nextXid, ProcArrayStruct::numKnownAssignedXids, RunningTransactionsData::oldestRunningXid, palloc(), pfree(), procArray, 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, xidLogicalComparator(), and RunningTransactionsData::xids.

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

ProcArrayApplyXidAssignment()

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

Definition at line 1299 of file procarray.c.

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

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

Referenced by xact_redo().

ProcArrayClearTransaction()

void ProcArrayClearTransaction

(

PGPROC *

proc

)

Definition at line 906 of file procarray.c.

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

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

Referenced by PrepareTransaction().

ProcArrayEndTransaction()

void ProcArrayEndTransaction	(	PGPROC *	proc,
		TransactionId	latestXid
	)

Definition at line 667 of file procarray.c.

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

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

Referenced by AbortTransaction(), and CommitTransaction().

ProcArrayEndTransactionInternal()

static void ProcArrayEndTransactionInternal ( PGPROC *  proc, TransactionId  latestXid  )

inlinestatic

Definition at line 731 of file procarray.c.

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

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

Referenced by ProcArrayEndTransaction(), and ProcArrayGroupClearXid().

ProcArrayGetReplicationSlotXmin()

void ProcArrayGetReplicationSlotXmin	(	TransactionId *	xmin,
		TransactionId *	catalog_xmin
	)

Definition at line 3872 of file procarray.c.

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

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

Referenced by logical_begin_heap_rewrite().

ProcArrayGroupClearXid()

static void ProcArrayGroupClearXid ( PGPROC *  proc, TransactionId  latestXid  )

static

Definition at line 792 of file procarray.c.

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

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

Referenced by ProcArrayEndTransaction().

ProcArrayInitRecovery()

void ProcArrayInitRecovery

(

TransactionId

initializedUptoXID

)

Definition at line 1022 of file procarray.c.

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

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

Referenced by StartupXLOG().

ProcArrayInstallImportedXmin()

bool ProcArrayInstallImportedXmin	(	TransactionId	xmin,
		VirtualTransactionId *	sourcevxid
	)

Definition at line 2518 of file procarray.c.

{
    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];
        int         statusFlags = ProcGlobal->statusFlags[index];
        TransactionId xid;
 
        /* Ignore procs running LAZY VACUUM */
        if (statusFlags & 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(proc->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.)
         */
        MyProc->xmin = TransactionXmin = xmin;
 
        result = true;
        break;
    }
 
    LWLockRelease(ProcArrayLock);
 
    return result;
}

References allProcs, Assert(), VirtualTransactionId::backendId, PGPROC::backendId, PGPROC::databaseId, VirtualTransactionId::localTransactionId, LW_SHARED, LWLockAcquire(), LWLockRelease(), PGPROC::lxid, MyDatabaseId, MyProc, ProcArrayStruct::numProcs, ProcArrayStruct::pgprocnos, PROC_IN_VACUUM, procArray, ProcGlobal, PROC_HDR::statusFlags, TransactionIdIsNormal, TransactionIdPrecedesOrEquals(), TransactionXmin, UINT32_ACCESS_ONCE, and PGPROC::xmin.

Referenced by GetSerializableTransactionSnapshotInt(), and SetTransactionSnapshot().

ProcArrayInstallRestoredXmin()

bool ProcArrayInstallRestoredXmin	(	TransactionId	xmin,
		PGPROC *	proc
	)

Definition at line 2597 of file procarray.c.

{
    bool        result = false;
    TransactionId xid;
 
    Assert(TransactionIdIsNormal(xmin));
    Assert(proc != NULL);
 
    /*
     * Get an exclusive lock so that we can copy statusFlags from source proc.
     */
    LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
 
    /*
     * 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(proc->xmin);
    if (proc->databaseId == MyDatabaseId &&
        TransactionIdIsNormal(xid) &&
        TransactionIdPrecedesOrEquals(xid, xmin))
    {
        /*
         * Install xmin and propagate the statusFlags that affect how the
         * value is interpreted by vacuum.
         */
        MyProc->xmin = TransactionXmin = xmin;
        MyProc->statusFlags = (MyProc->statusFlags & ~PROC_XMIN_FLAGS) |
            (proc->statusFlags & PROC_XMIN_FLAGS);
        ProcGlobal->statusFlags[MyProc->pgxactoff] = MyProc->statusFlags;
 
        result = true;
    }
 
    LWLockRelease(ProcArrayLock);
 
    return result;
}

References Assert(), PGPROC::databaseId, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MyDatabaseId, MyProc, PGPROC::pgxactoff, PROC_XMIN_FLAGS, ProcGlobal, PGPROC::statusFlags, PROC_HDR::statusFlags, TransactionIdIsNormal, TransactionIdPrecedesOrEquals(), TransactionXmin, UINT32_ACCESS_ONCE, and PGPROC::xmin.

Referenced by SetTransactionSnapshot().

ProcArrayRemove()

void ProcArrayRemove	(	PGPROC *	proc,
		TransactionId	latestXid
	)

Definition at line 565 of file procarray.c.

{
    ProcArrayStruct *arrayP = procArray;
    int         myoff;
    int         movecount;
 
#ifdef XIDCACHE_DEBUG
    /* dump stats at backend shutdown, but not prepared-xact end */
    if (proc->pid != 0)
        DisplayXidCache();
#endif
 
    /* See ProcGlobal comment explaining why both locks are held */
    LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
    LWLockAcquire(XidGenLock, LW_EXCLUSIVE);
 
    myoff = proc->pgxactoff;
 
    Assert(myoff >= 0 && myoff < arrayP->numProcs);
    Assert(ProcGlobal->allProcs[arrayP->pgprocnos[myoff]].pgxactoff == myoff);
 
    if (TransactionIdIsValid(latestXid))
    {
        Assert(TransactionIdIsValid(ProcGlobal->xids[myoff]));
 
        /* Advance global latestCompletedXid while holding the lock */
        MaintainLatestCompletedXid(latestXid);
 
        /* Same with xactCompletionCount  */
        ShmemVariableCache->xactCompletionCount++;
 
        ProcGlobal->xids[myoff] = InvalidTransactionId;
        ProcGlobal->subxidStates[myoff].overflowed = false;
        ProcGlobal->subxidStates[myoff].count = 0;
    }
    else
    {
        /* Shouldn't be trying to remove a live transaction here */
        Assert(!TransactionIdIsValid(ProcGlobal->xids[myoff]));
    }
 
    Assert(!TransactionIdIsValid(ProcGlobal->xids[myoff]));
    Assert(ProcGlobal->subxidStates[myoff].count == 0);
    Assert(ProcGlobal->subxidStates[myoff].overflowed == false);
 
    ProcGlobal->statusFlags[myoff] = 0;
 
    /* Keep the PGPROC array sorted. See notes above */
    movecount = arrayP->numProcs - myoff - 1;
    memmove(&arrayP->pgprocnos[myoff],
            &arrayP->pgprocnos[myoff + 1],
            movecount * sizeof(*arrayP->pgprocnos));
    memmove(&ProcGlobal->xids[myoff],
            &ProcGlobal->xids[myoff + 1],
            movecount * sizeof(*ProcGlobal->xids));
    memmove(&ProcGlobal->subxidStates[myoff],
            &ProcGlobal->subxidStates[myoff + 1],
            movecount * sizeof(*ProcGlobal->subxidStates));
    memmove(&ProcGlobal->statusFlags[myoff],
            &ProcGlobal->statusFlags[myoff + 1],
            movecount * sizeof(*ProcGlobal->statusFlags));
 
    arrayP->pgprocnos[arrayP->numProcs - 1] = -1;   /* for debugging */
    arrayP->numProcs--;
 
    /*
     * Adjust pgxactoff of following procs for removed PGPROC (note that
     * numProcs already has been decremented).
     */
    for (int index = myoff; index < arrayP->numProcs; index++)
    {
        int         procno = arrayP->pgprocnos[index];
 
        Assert(procno >= 0 && procno < (arrayP->maxProcs + NUM_AUXILIARY_PROCS));
        Assert(allProcs[procno].pgxactoff - 1 == index);
 
        allProcs[procno].pgxactoff = index;
    }
 
    /*
     * Release in reversed acquisition order, to reduce frequency of having to
     * wait for XidGenLock while holding ProcArrayLock.
     */
    LWLockRelease(XidGenLock);
    LWLockRelease(ProcArrayLock);
}

References allProcs, PROC_HDR::allProcs, Assert(), XidCacheStatus::count, InvalidTransactionId, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MaintainLatestCompletedXid(), ProcArrayStruct::maxProcs, NUM_AUXILIARY_PROCS, ProcArrayStruct::numProcs, XidCacheStatus::overflowed, ProcArrayStruct::pgprocnos, PGPROC::pgxactoff, PGPROC::pid, procArray, ProcGlobal, ShmemVariableCache, PROC_HDR::statusFlags, PROC_HDR::subxidStates, TransactionIdIsValid, VariableCacheData::xactCompletionCount, and PROC_HDR::xids.

Referenced by FinishPreparedTransaction(), and RemoveProcFromArray().

ProcArraySetReplicationSlotXmin()

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

Definition at line 3847 of file procarray.c.

{
    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);
 
    elog(DEBUG1, "xmin required by slots: data %u, catalog %u",
         xmin, catalog_xmin);
}

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

Referenced by ReplicationSlotsComputeRequiredXmin().

ProcArrayShmemSize()

Size ProcArrayShmemSize

(

void

)

Definition at line 377 of file procarray.c.

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

References add_size(), EnableHotStandby, mul_size(), PROCARRAY_MAXPROCS, and TOTAL_MAX_CACHED_SUBXIDS.

Referenced by CalculateShmemSize().

RecordKnownAssignedTransactionIds()

void RecordKnownAssignedTransactionIds

(

TransactionId

xid

)

Definition at line 4337 of file procarray.c.

{
    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->nextXid must be beyond any observed xid */
        AdvanceNextFullTransactionIdPastXid(latestObservedXid);
    }
}

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

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

SignalVirtualTransaction()

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

Definition at line 3404 of file procarray.c.

{
    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 = 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, vxid.backendId);
            }
            break;
        }
    }
 
    LWLockRelease(ProcArrayLock);
 
    return pid;
}

References allProcs, 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 CancelVirtualTransaction(), and ResolveRecoveryConflictWithLock().

TerminateOtherDBBackends()

void TerminateOtherDBBackends

(

Oid

databaseId

)

Definition at line 3735 of file procarray.c.

{
    ProcArrayStruct *arrayP = procArray;
    List       *pids = NIL;
    int         nprepared = 0;
    int         i;
 
    LWLockAcquire(ProcArrayLock, LW_SHARED);
 
    for (i = 0; i < procArray->numProcs; i++)
    {
        int         pgprocno = arrayP->pgprocnos[i];
        PGPROC     *proc = &allProcs[pgprocno];
 
        if (proc->databaseId != databaseId)
            continue;
        if (proc == MyProc)
            continue;
 
        if (proc->pid != 0)
            pids = lappend_int(pids, proc->pid);
        else
            nprepared++;
    }
 
    LWLockRelease(ProcArrayLock);
 
    if (nprepared > 0)
        ereport(ERROR,
                (errcode(ERRCODE_OBJECT_IN_USE),
                 errmsg("database \"%s\" is being used by prepared transactions",
                        get_database_name(databaseId)),
                 errdetail_plural("There is %d prepared transaction using the database.",
                                  "There are %d prepared transactions using the database.",
                                  nprepared,
                                  nprepared)));
 
    if (pids)
    {
        ListCell   *lc;
 
        /*
         * Check whether we have the necessary rights to terminate other
         * sessions.  We don't terminate any session until we ensure that we
         * have rights on all the sessions to be terminated.  These checks are
         * the same as we do in pg_terminate_backend.
         *
         * In this case we don't raise some warnings - like "PID %d is not a
         * PostgreSQL server process", because for us already finished session
         * is not a problem.
         */
        foreach(lc, pids)
        {
            int         pid = lfirst_int(lc);
            PGPROC     *proc = BackendPidGetProc(pid);
 
            if (proc != NULL)
            {
                /* Only allow superusers to signal superuser-owned backends. */
                if (superuser_arg(proc->roleId) && !superuser())
                    ereport(ERROR,
                            (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                             errmsg("permission denied to terminate process"),
                             errdetail("Only roles with the %s attribute may terminate processes of roles with the %s attribute.",
                                       "SUPERUSER", "SUPERUSER")));
 
                /* Users can signal backends they have role membership in. */
                if (!has_privs_of_role(GetUserId(), proc->roleId) &&
                    !has_privs_of_role(GetUserId(), ROLE_PG_SIGNAL_BACKEND))
                    ereport(ERROR,
                            (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                             errmsg("permission denied to terminate process"),
                             errdetail("Only roles with privileges of the role whose process is being terminated or with privileges of the \"%s\" role may terminate this process.",
                                       "pg_signal_backend")));
            }
        }
 
        /*
         * There's a race condition here: once we release the ProcArrayLock,
         * it's possible for the session to exit before we issue kill.  That
         * race condition possibility seems too unlikely to worry about.  See
         * pg_signal_backend.
         */
        foreach(lc, pids)
        {
            int         pid = lfirst_int(lc);
            PGPROC     *proc = BackendPidGetProc(pid);
 
            if (proc != NULL)
            {
                /*
                 * If we have setsid(), signal the backend's whole process
                 * group
                 */
#ifdef HAVE_SETSID
                (void) kill(-pid, SIGTERM);
#else
                (void) kill(pid, SIGTERM);
#endif
            }
        }
    }
}

References allProcs, BackendPidGetProc(), PGPROC::databaseId, ereport, errcode(), errdetail(), errdetail_plural(), errmsg(), ERROR, get_database_name(), GetUserId(), has_privs_of_role(), i, kill, lappend_int(), lfirst_int, LW_SHARED, LWLockAcquire(), LWLockRelease(), MyProc, NIL, ProcArrayStruct::numProcs, ProcArrayStruct::pgprocnos, PGPROC::pid, procArray, PGPROC::roleId, superuser(), and superuser_arg().

Referenced by dropdb().

TransactionIdIsActive()

bool TransactionIdIsActive

(

TransactionId

xid

)

Definition at line 1615 of file procarray.c.

{
    bool        result = false;
    ProcArrayStruct *arrayP = procArray;
    TransactionId *other_xids = ProcGlobal->xids;
    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];
        TransactionId pxid;
 
        /* Fetch xid just once - see GetNewTransactionId */
        pxid = UINT32_ACCESS_ONCE(other_xids[i]);
 
        if (!TransactionIdIsValid(pxid))
            continue;
 
        if (proc->pid == 0)
            continue;           /* ignore prepared transactions */
 
        if (TransactionIdEquals(pxid, xid))
        {
            result = true;
            break;
        }
    }
 
    LWLockRelease(ProcArrayLock);
 
    return result;
}

References allProcs, i, LW_SHARED, LWLockAcquire(), LWLockRelease(), ProcArrayStruct::numProcs, ProcArrayStruct::pgprocnos, PGPROC::pid, procArray, ProcGlobal, RecentXmin, TransactionIdEquals, TransactionIdIsValid, TransactionIdPrecedes(), UINT32_ACCESS_ONCE, and PROC_HDR::xids.

TransactionIdIsInProgress()

bool TransactionIdIsInProgress

(

TransactionId

xid

)

Definition at line 1383 of file procarray.c.

{
    static TransactionId *xids = NULL;
    static TransactionId *other_xids;
    XidCacheStatus *other_subxidstates;
    int         nxids = 0;
    ProcArrayStruct *arrayP = procArray;
    TransactionId topxid;
    TransactionId latestCompletedXid;
    int         mypgxactoff;
    int         numProcs;
    int         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 (TransactionIdEquals(cachedXidIsNotInProgress, 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")));
    }
 
    other_xids = ProcGlobal->xids;
    other_subxidstates = ProcGlobal->subxidStates;
 
    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.
     */
    latestCompletedXid =
        XidFromFullTransactionId(ShmemVariableCache->latestCompletedXid);
    if (TransactionIdPrecedes(latestCompletedXid, xid))
    {
        LWLockRelease(ProcArrayLock);
        xc_by_latest_xid_inc();
        return true;
    }
 
    /* No shortcuts, gotta grovel through the array */
    mypgxactoff = MyProc->pgxactoff;
    numProcs = arrayP->numProcs;
    for (int pgxactoff = 0; pgxactoff < numProcs; pgxactoff++)
    {
        int         pgprocno;
        PGPROC     *proc;
        TransactionId pxid;
        int         pxids;
 
        /* Ignore ourselves --- dealt with it above */
        if (pgxactoff == mypgxactoff)
            continue;
 
        /* Fetch xid just once - see GetNewTransactionId */
        pxid = UINT32_ACCESS_ONCE(other_xids[pgxactoff]);
 
        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 = other_subxidstates[pgxactoff].count;
        pg_read_barrier();      /* pairs with barrier in GetNewTransactionId() */
        pgprocno = arrayP->pgprocnos[pgxactoff];
        proc = &allProcs[pgprocno];
        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 (other_subxidstates[pgxactoff].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 PGPROC 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();
        cachedXidIsNotInProgress = xid;
        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))
    {
        cachedXidIsNotInProgress = 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) &&
        pg_lfind32(topxid, xids, nxids))
        return true;
 
    cachedXidIsNotInProgress = xid;
    return false;
}

References allProcs, Assert(), cachedXidIsNotInProgress, XidCacheStatus::count, ereport, errcode(), errmsg(), ERROR, j, KnownAssignedXidExists(), KnownAssignedXidsGet(), ProcArrayStruct::lastOverflowedXid, VariableCacheData::latestCompletedXid, LW_SHARED, LWLockAcquire(), LWLockRelease(), malloc, ProcArrayStruct::maxProcs, MyProc, ProcArrayStruct::numProcs, pg_lfind32(), pg_read_barrier, ProcArrayStruct::pgprocnos, PGPROC::pgxactoff, procArray, ProcGlobal, RecentXmin, RecoveryInProgress(), ShmemVariableCache, SubTransGetTopmostTransaction(), PGPROC::subxids, PROC_HDR::subxidStates, TOTAL_MAX_CACHED_SUBXIDS, TransactionIdDidAbort(), TransactionIdEquals, TransactionIdIsCurrentTransactionId(), 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, XidFromFullTransactionId, XidCache::xids, and PROC_HDR::xids.

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

XidCacheRemoveRunningXids()

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

Definition at line 3895 of file procarray.c.

{
    int         i,
                j;
    XidCacheStatus *mysubxidstat;
 
    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/ProcGlobal->xids[].  But we do have to be
     * careful about our own writes being well ordered.
     */
    LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
 
    mysubxidstat = &ProcGlobal->subxidStates[MyProc->pgxactoff];
 
    /*
     * 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 = MyProc->subxidStatus.count - 1; j >= 0; j--)
        {
            if (TransactionIdEquals(MyProc->subxids.xids[j], anxid))
            {
                MyProc->subxids.xids[j] = MyProc->subxids.xids[MyProc->subxidStatus.count - 1];
                pg_write_barrier();
                mysubxidstat->count--;
                MyProc->subxidStatus.count--;
                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 && !MyProc->subxidStatus.overflowed)
            elog(WARNING, "did not find subXID %u in MyProc", anxid);
    }
 
    for (j =