transam.h File Reference

#include "access/xlogdefs.h"

Include dependency graph for transam.h:

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

Go to the source code of this file.

Data Structures
struct	FullTransactionId
struct	TransamVariablesData

Macros
#define	InvalidTransactionId   ((TransactionId) 0)
#define	BootstrapTransactionId   ((TransactionId) 1)
#define	FrozenTransactionId   ((TransactionId) 2)
#define	FirstNormalTransactionId   ((TransactionId) 3)
#define	MaxTransactionId   ((TransactionId) 0xFFFFFFFF)
#define	TransactionIdIsValid(xid)   ((xid) != InvalidTransactionId)
#define	TransactionIdIsNormal(xid)   ((xid) >= FirstNormalTransactionId)
#define	TransactionIdEquals(id1, id2)   ((id1) == (id2))
#define	TransactionIdStore(xid, dest)   (*(dest) = (xid))
#define	StoreInvalidTransactionId(dest)   (*(dest) = InvalidTransactionId)
#define	EpochFromFullTransactionId(x)   ((uint32) ((x).value >> 32))
#define	XidFromFullTransactionId(x)   ((uint32) (x).value)
#define	U64FromFullTransactionId(x)   ((x).value)
#define	FullTransactionIdEquals(a, b)   ((a).value == (b).value)
#define	FullTransactionIdPrecedes(a, b)   ((a).value < (b).value)
#define	FullTransactionIdPrecedesOrEquals(a, b)   ((a).value <= (b).value)
#define	FullTransactionIdFollows(a, b)   ((a).value > (b).value)
#define	FullTransactionIdFollowsOrEquals(a, b)   ((a).value >= (b).value)
#define	FullTransactionIdIsValid(x)   TransactionIdIsValid(XidFromFullTransactionId(x))
#define	InvalidFullTransactionId   FullTransactionIdFromEpochAndXid(0, InvalidTransactionId)
#define	FirstNormalFullTransactionId   FullTransactionIdFromEpochAndXid(0, FirstNormalTransactionId)
#define	FullTransactionIdIsNormal(x)   FullTransactionIdFollowsOrEquals(x, FirstNormalFullTransactionId)
#define	TransactionIdAdvance(dest)
#define	TransactionIdRetreat(dest)
#define	NormalTransactionIdPrecedes(id1, id2)
#define	NormalTransactionIdFollows(id1, id2)
#define	FirstGenbkiObjectId   10000
#define	FirstUnpinnedObjectId   12000
#define	FirstNormalObjectId   16384
#define	AssertTransactionIdInAllowableRange(xid)   ((void)true)

Typedefs
typedef struct FullTransactionId	FullTransactionId
typedef struct TransamVariablesData	TransamVariablesData

Functions
static FullTransactionId	FullTransactionIdFromEpochAndXid (uint32 epoch, TransactionId xid)
static FullTransactionId	FullTransactionIdFromU64 (uint64 value)
static void	FullTransactionIdRetreat (FullTransactionId *dest)
static void	FullTransactionIdAdvance (FullTransactionId *dest)
static bool	TransactionIdPrecedes (TransactionId id1, TransactionId id2)
static bool	TransactionIdPrecedesOrEquals (TransactionId id1, TransactionId id2)
static bool	TransactionIdFollows (TransactionId id1, TransactionId id2)
static bool	TransactionIdFollowsOrEquals (TransactionId id1, TransactionId id2)
bool	TransactionStartedDuringRecovery (void)
bool	TransactionIdDidCommit (TransactionId transactionId)
bool	TransactionIdDidAbort (TransactionId transactionId)
void	TransactionIdCommitTree (TransactionId xid, int nxids, TransactionId *xids)
void	TransactionIdAsyncCommitTree (TransactionId xid, int nxids, TransactionId *xids, XLogRecPtr lsn)
void	TransactionIdAbortTree (TransactionId xid, int nxids, TransactionId *xids)
TransactionId	TransactionIdLatest (TransactionId mainxid, int nxids, const TransactionId *xids)
XLogRecPtr	TransactionIdGetCommitLSN (TransactionId xid)
Size	VarsupShmemSize (void)
void	VarsupShmemInit (void)
FullTransactionId	GetNewTransactionId (bool isSubXact)
void	AdvanceNextFullTransactionIdPastXid (TransactionId xid)
FullTransactionId	ReadNextFullTransactionId (void)
void	SetTransactionIdLimit (TransactionId oldest_datfrozenxid, Oid oldest_datoid)
void	AdvanceOldestClogXid (TransactionId oldest_datfrozenxid)
bool	ForceTransactionIdLimitUpdate (void)
Oid	GetNewObjectId (void)
void	StopGeneratingPinnedObjectIds (void)
static TransactionId	ReadNextTransactionId (void)
static TransactionId	TransactionIdRetreatedBy (TransactionId xid, uint32 amount)
static TransactionId	TransactionIdOlder (TransactionId a, TransactionId b)
static TransactionId	NormalTransactionIdOlder (TransactionId a, TransactionId b)
static FullTransactionId	FullTransactionIdNewer (FullTransactionId a, FullTransactionId b)
static FullTransactionId	FullTransactionIdFromAllowableAt (FullTransactionId nextFullXid, TransactionId xid)

Variables
PGDLLIMPORT TransamVariablesData *	TransamVariables

Macro Definition Documentation

AssertTransactionIdInAllowableRange

#define AssertTransactionIdInAllowableRange

(

xid

)

((void)true)

Definition at line 363 of file transam.h.

BootstrapTransactionId

#define BootstrapTransactionId   ((TransactionId) 1)

Definition at line 32 of file transam.h.

EpochFromFullTransactionId

#define EpochFromFullTransactionId

(

x

)

((uint32) ((x).value >> 32))

Definition at line 47 of file transam.h.

FirstGenbkiObjectId

#define FirstGenbkiObjectId   10000

Definition at line 195 of file transam.h.

FirstNormalFullTransactionId

#define FirstNormalFullTransactionId   FullTransactionIdFromEpochAndXid(0, FirstNormalTransactionId)

Definition at line 57 of file transam.h.

FirstNormalObjectId

#define FirstNormalObjectId   16384

Definition at line 197 of file transam.h.

FirstNormalTransactionId

#define FirstNormalTransactionId   ((TransactionId) 3)

Definition at line 34 of file transam.h.

FirstUnpinnedObjectId

#define FirstUnpinnedObjectId   12000

Definition at line 196 of file transam.h.

FrozenTransactionId

#define FrozenTransactionId   ((TransactionId) 2)

Definition at line 33 of file transam.h.

FullTransactionIdEquals

#define FullTransactionIdEquals	(		a,
			b
	)		((a).value == (b).value)

Definition at line 50 of file transam.h.

FullTransactionIdFollows

#define FullTransactionIdFollows	(		a,
			b
	)		((a).value > (b).value)

Definition at line 53 of file transam.h.

FullTransactionIdFollowsOrEquals

#define FullTransactionIdFollowsOrEquals	(		a,
			b
	)		((a).value >= (b).value)

Definition at line 54 of file transam.h.

FullTransactionIdIsNormal

#define FullTransactionIdIsNormal

(

x

)

FullTransactionIdFollowsOrEquals(x, FirstNormalFullTransactionId)

Definition at line 58 of file transam.h.

FullTransactionIdIsValid

#define FullTransactionIdIsValid

(

x

)

TransactionIdIsValid(XidFromFullTransactionId(x))

Definition at line 55 of file transam.h.

FullTransactionIdPrecedes

#define FullTransactionIdPrecedes	(		a,
			b
	)		((a).value < (b).value)

Definition at line 51 of file transam.h.

FullTransactionIdPrecedesOrEquals

#define FullTransactionIdPrecedesOrEquals	(		a,
			b
	)		((a).value <= (b).value)

Definition at line 52 of file transam.h.

InvalidFullTransactionId

#define InvalidFullTransactionId   FullTransactionIdFromEpochAndXid(0, InvalidTransactionId)

Definition at line 56 of file transam.h.

InvalidTransactionId

#define InvalidTransactionId   ((TransactionId) 0)

Definition at line 31 of file transam.h.

MaxTransactionId

#define MaxTransactionId   ((TransactionId) 0xFFFFFFFF)

Definition at line 35 of file transam.h.

NormalTransactionIdFollows

#define NormalTransactionIdFollows	(		id1,
			id2
	)

Value:

    (AssertMacro(TransactionIdIsNormal(id1) && TransactionIdIsNormal(id2)), \
    (int32) ((id1) - (id2)) > 0)

Definition at line 152 of file transam.h.

{
    /*
     * These fields are protected by OidGenLock.
     */
    Oid         nextOid;        /* next OID to assign */
    uint32      oidCount;       /* OIDs available before must do XLOG work */
 
    /*
     * These fields are protected by XidGenLock.
     */
    FullTransactionId nextXid;  /* next XID to assign */
 
    TransactionId oldestXid;    /* cluster-wide minimum datfrozenxid */
    TransactionId xidVacLimit;  /* start forcing autovacuums here */
    TransactionId xidWarnLimit; /* start complaining here */
    TransactionId xidStopLimit; /* refuse to advance nextXid beyond here */
    TransactionId xidWrapLimit; /* where the world ends */
    Oid         oldestXidDB;    /* database with minimum datfrozenxid */
 
    /*
     * These fields are protected by CommitTsLock
     */
    TransactionId oldestCommitTsXid;
    TransactionId newestCommitTsXid;
 
    /*
     * These fields are protected by ProcArrayLock.
     */
    FullTransactionId latestCompletedXid;   /* newest full XID that has
                                             * committed or aborted */
 
    /*
     * Number of top-level transactions with xids (i.e. which may have
     * modified the database) that completed in some form since the start of
     * the server. This currently is solely used to check whether
     * GetSnapshotData() needs to recompute the contents of the snapshot, or
     * not. There are likely other users of this.  Always above 1.
     */
    uint64      xactCompletionCount;
 
    /*
     * These fields are protected by XactTruncationLock
     */
    TransactionId oldestClogXid;    /* oldest it's safe to look up in clog */
 
} TransamVariablesData;
 
 
 
/*
 * TransactionIdPrecedes --- is id1 logically < id2?
 */
static inline bool
TransactionIdPrecedes(TransactionId id1, TransactionId id2)
{
    /*
     * If either ID is a permanent XID then we can just do unsigned
     * comparison.  If both are normal, do a modulo-2^32 comparison.
     */
    int32       diff;
 
    if (!TransactionIdIsNormal(id1) || !TransactionIdIsNormal(id2))
        return (id1 < id2);
 
    diff = (int32) (id1 - id2);
    return (diff < 0);
}
 
/*
 * TransactionIdPrecedesOrEquals --- is id1 logically <= id2?
 */
static inline bool
TransactionIdPrecedesOrEquals(TransactionId id1, TransactionId id2)
{
    int32       diff;
 
    if (!TransactionIdIsNormal(id1) || !TransactionIdIsNormal(id2))
        return (id1 <= id2);
 
    diff = (int32) (id1 - id2);
    return (diff <= 0);
}
 
/*
 * TransactionIdFollows --- is id1 logically > id2?
 */
static inline bool
TransactionIdFollows(TransactionId id1, TransactionId id2)
{
    int32       diff;
 
    if (!TransactionIdIsNormal(id1) || !TransactionIdIsNormal(id2))
        return (id1 > id2);
 
    diff = (int32) (id1 - id2);
    return (diff > 0);
}
 
/*
 * TransactionIdFollowsOrEquals --- is id1 logically >= id2?
 */
static inline bool
TransactionIdFollowsOrEquals(TransactionId id1, TransactionId id2)
{
    int32       diff;
 
    if (!TransactionIdIsNormal(id1) || !TransactionIdIsNormal(id2))
        return (id1 >= id2);
 
    diff = (int32) (id1 - id2);
    return (diff >= 0);
}
 
 
/* ----------------
 *      extern declarations
 * ----------------
 */
 
/* in transam/xact.c */
extern bool TransactionStartedDuringRecovery(void);
 
/* in transam/varsup.c */
extern PGDLLIMPORT TransamVariablesData *TransamVariables;
 
/*
 * prototypes for functions in transam/transam.c
 */
extern bool TransactionIdDidCommit(TransactionId transactionId);
extern bool TransactionIdDidAbort(TransactionId transactionId);
extern void TransactionIdCommitTree(TransactionId xid, int nxids, TransactionId *xids);
extern void TransactionIdAsyncCommitTree(TransactionId xid, int nxids, TransactionId *xids, XLogRecPtr lsn);
extern void TransactionIdAbortTree(TransactionId xid, int nxids, TransactionId *xids);
extern TransactionId TransactionIdLatest(TransactionId mainxid,
                                         int nxids, const TransactionId *xids);
extern XLogRecPtr TransactionIdGetCommitLSN(TransactionId xid);
 
/* in transam/varsup.c */
extern Size VarsupShmemSize(void);
extern void VarsupShmemInit(void);
extern FullTransactionId GetNewTransactionId(bool isSubXact);
extern void AdvanceNextFullTransactionIdPastXid(TransactionId xid);
extern FullTransactionId ReadNextFullTransactionId(void);
extern void SetTransactionIdLimit(TransactionId oldest_datfrozenxid,
                                  Oid oldest_datoid);
extern void AdvanceOldestClogXid(TransactionId oldest_datfrozenxid);
extern bool ForceTransactionIdLimitUpdate(void);
extern Oid  GetNewObjectId(void);
extern void StopGeneratingPinnedObjectIds(void);
 
#ifdef USE_ASSERT_CHECKING
extern void AssertTransactionIdInAllowableRange(TransactionId xid);
#else
#define AssertTransactionIdInAllowableRange(xid) ((void)true)
#endif
 
/*
 * Some frontend programs include this header.  For compilers that emit static
 * inline functions even when they're unused, that leads to unsatisfied
 * external references; hence hide them with #ifndef FRONTEND.
 */
#ifndef FRONTEND
 
/*
 * For callers that just need the XID part of the next transaction ID.
 */
static inline TransactionId
ReadNextTransactionId(void)
{
    return XidFromFullTransactionId(ReadNextFullTransactionId());
}
 
/* return transaction ID backed up by amount, handling wraparound correctly */
static inline TransactionId
TransactionIdRetreatedBy(TransactionId xid, uint32 amount)
{
    xid -= amount;
 
    while (xid < FirstNormalTransactionId)
        xid--;
 
    return xid;
}
 
/* return the older of the two IDs */
static inline TransactionId
TransactionIdOlder(TransactionId a, TransactionId b)
{
    if (!TransactionIdIsValid(a))
        return b;
 
    if (!TransactionIdIsValid(b))
        return a;
 
    if (TransactionIdPrecedes(a, b))
        return a;
    return b;
}
 
/* return the older of the two IDs, assuming they're both normal */
static inline TransactionId
NormalTransactionIdOlder(TransactionId a, TransactionId b)
{
    Assert(TransactionIdIsNormal(a));
    Assert(TransactionIdIsNormal(b));
    if (NormalTransactionIdPrecedes(a, b))
        return a;
    return b;
}
 
/* return the newer of the two IDs */
static inline FullTransactionId
FullTransactionIdNewer(FullTransactionId a, FullTransactionId b)
{
    if (!FullTransactionIdIsValid(a))
        return b;
 
    if (!FullTransactionIdIsValid(b))
        return a;
 
    if (FullTransactionIdFollows(a, b))
        return a;
    return b;
}
 
/*
 * Compute FullTransactionId for the given TransactionId, assuming xid was
 * between [oldestXid, nextXid] at the time when TransamVariables->nextXid was
 * nextFullXid.  When adding calls, evaluate what prevents xid from preceding
 * oldestXid if SetTransactionIdLimit() runs between the collection of xid and
 * the collection of nextFullXid.
 */
static inline FullTransactionId
FullTransactionIdFromAllowableAt(FullTransactionId nextFullXid,
                                 TransactionId xid)
{
    uint32      epoch;
 
    /* Special transaction ID. */
    if (!TransactionIdIsNormal(xid))
        return FullTransactionIdFromEpochAndXid(0, xid);
 
    Assert(TransactionIdPrecedesOrEquals(xid,
                                         XidFromFullTransactionId(nextFullXid)));
 
    /*
     * The 64 bit result must be <= nextFullXid, since nextFullXid hadn't been
     * issued yet when xid was in the past.  The xid must therefore be from
     * the epoch of nextFullXid or the epoch before.  We know this because we
     * must remove (by freezing) an XID before assigning the XID half an epoch
     * ahead of it.
     *
     * The unlikely() branch hint is dubious.  It's perfect for the first 2^32
     * XIDs of a cluster's life.  Right at 2^32 XIDs, misprediction shoots to
     * 100%, then improves until perfection returns 2^31 XIDs later.  Since
     * current callers pass relatively-recent XIDs, expect >90% prediction
     * accuracy overall.  This favors average latency over tail latency.
     */
    epoch = EpochFromFullTransactionId(nextFullXid);
    if (unlikely(xid > XidFromFullTransactionId(nextFullXid)))
    {
        Assert(epoch != 0);
        epoch--;
    }
 
    return FullTransactionIdFromEpochAndXid(epoch, xid);
}
 
#endif                          /* FRONTEND */
 
#endif                          /* TRANSAM_H */

NormalTransactionIdPrecedes

#define NormalTransactionIdPrecedes	(		id1,
			id2
	)

Value:

    (AssertMacro(TransactionIdIsNormal(id1) && TransactionIdIsNormal(id2)), \
    (int32) ((id1) - (id2)) < 0)

Definition at line 147 of file transam.h.

StoreInvalidTransactionId

#define StoreInvalidTransactionId

(

dest

)

(*(dest) = InvalidTransactionId)

Definition at line 45 of file transam.h.

TransactionIdAdvance

#define TransactionIdAdvance

(

dest

)

Value:

    do { \
        (dest)++; \
		if ((dest) < FirstNormalTransactionId) \
            (dest) = FirstNormalTransactionId; \
    } while(0)

Definition at line 91 of file transam.h.

       { \
        (dest)++; \
		if ((dest) < FirstNormalTransactionId) \
            (dest) = FirstNormalTransactionId; \
    } while(0)

TransactionIdEquals

#define TransactionIdEquals	(		id1,
			id2
	)		((id1) == (id2))

Definition at line 43 of file transam.h.

TransactionIdIsNormal

#define TransactionIdIsNormal

(

xid

)

((xid) >= FirstNormalTransactionId)

Definition at line 42 of file transam.h.

TransactionIdIsValid

#define TransactionIdIsValid

(

xid

)

((xid) != InvalidTransactionId)

Definition at line 41 of file transam.h.

TransactionIdRetreat

#define TransactionIdRetreat

(

dest

)

Value:

    do { \
        (dest)--; \
    } while ((dest) < FirstNormalTransactionId)

Definition at line 141 of file transam.h.

       { \
        (dest)--; \
    } while ((dest) < FirstNormalTransactionId)

TransactionIdStore

#define TransactionIdStore	(		xid,
			dest
	)		(*(dest) = (xid))

Definition at line 44 of file transam.h.

U64FromFullTransactionId

#define U64FromFullTransactionId

(

x

)

((x).value)

Definition at line 49 of file transam.h.

XidFromFullTransactionId

#define XidFromFullTransactionId

(

x

)

((uint32) (x).value)

Definition at line 48 of file transam.h.

Typedef Documentation

FullTransactionId

typedef struct FullTransactionId FullTransactionId

TransamVariablesData

typedef struct TransamVariablesData TransamVariablesData

Function Documentation

AdvanceNextFullTransactionIdPastXid()

void AdvanceNextFullTransactionIdPastXid ( TransactionId  xid )

extern

Definition at line 304 of file varsup.c.

{
    FullTransactionId newNextFullXid;
    TransactionId next_xid;
    uint32      epoch;
 
    /*
     * It is safe to read nextXid without a lock, because this is only called
     * from the startup process or single-process mode, meaning that no other
     * process can modify it.
     */
    Assert(AmStartupProcess() || !IsUnderPostmaster);
 
    /* Fast return if this isn't an xid high enough to move the needle. */
    next_xid = XidFromFullTransactionId(TransamVariables->nextXid);
    if (!TransactionIdFollowsOrEquals(xid, next_xid))
        return;
 
    /*
     * Compute the FullTransactionId that comes after the given xid.  To do
     * this, we preserve the existing epoch, but detect when we've wrapped
     * into a new epoch.  This is necessary because WAL records and 2PC state
     * currently contain 32 bit xids.  The wrap logic is safe in those cases
     * because the span of active xids cannot exceed one epoch at any given
     * point in the WAL stream.
     */
    TransactionIdAdvance(xid);
    epoch = EpochFromFullTransactionId(TransamVariables->nextXid);
    if (unlikely(xid < next_xid))
        ++epoch;
    newNextFullXid = FullTransactionIdFromEpochAndXid(epoch, xid);
 
    /*
     * We still need to take a lock to modify the value when there are
     * concurrent readers.
     */
    LWLockAcquire(XidGenLock, LW_EXCLUSIVE);
    TransamVariables->nextXid = newNextFullXid;
    LWLockRelease(XidGenLock);
}

References AmStartupProcess, Assert, epoch, EpochFromFullTransactionId, fb(), FullTransactionIdFromEpochAndXid(), IsUnderPostmaster, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), TransamVariablesData::nextXid, TransactionIdAdvance, TransactionIdFollowsOrEquals(), TransamVariables, unlikely, and XidFromFullTransactionId.

Referenced by ApplyWalRecord(), multixact_redo(), ProcArrayApplyRecoveryInfo(), ProcessTwoPhaseBuffer(), RecordKnownAssignedTransactionIds(), xact_redo_abort(), and xact_redo_commit().

AdvanceOldestClogXid()

void AdvanceOldestClogXid ( TransactionId  oldest_datfrozenxid )

extern

Definition at line 355 of file varsup.c.

{
    LWLockAcquire(XactTruncationLock, LW_EXCLUSIVE);
    if (TransactionIdPrecedes(TransamVariables->oldestClogXid,
                              oldest_datfrozenxid))
    {
        TransamVariables->oldestClogXid = oldest_datfrozenxid;
    }
    LWLockRelease(XactTruncationLock);
}

References fb(), LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), TransamVariablesData::oldestClogXid, TransactionIdPrecedes(), and TransamVariables.

Referenced by BootStrapXLOG(), clog_redo(), StartupXLOG(), and TruncateCLOG().

ForceTransactionIdLimitUpdate()

bool ForceTransactionIdLimitUpdate ( void  )

extern

Definition at line 517 of file varsup.c.

{
    TransactionId nextXid;
    TransactionId xidVacLimit;
    TransactionId oldestXid;
    Oid         oldestXidDB;
 
    /* Locking is probably not really necessary, but let's be careful */
    LWLockAcquire(XidGenLock, LW_SHARED);
    nextXid = XidFromFullTransactionId(TransamVariables->nextXid);
    xidVacLimit = TransamVariables->xidVacLimit;
    oldestXid = TransamVariables->oldestXid;
    oldestXidDB = TransamVariables->oldestXidDB;
    LWLockRelease(XidGenLock);
 
    if (!TransactionIdIsNormal(oldestXid))
        return true;            /* shouldn't happen, but just in case */
    if (!TransactionIdIsValid(xidVacLimit))
        return true;            /* this shouldn't happen anymore either */
    if (TransactionIdFollowsOrEquals(nextXid, xidVacLimit))
        return true;            /* past xidVacLimit, don't delay updating */
    if (!SearchSysCacheExists1(DATABASEOID, ObjectIdGetDatum(oldestXidDB)))
        return true;            /* could happen, per comments above */
    return false;
}

References fb(), LW_SHARED, LWLockAcquire(), LWLockRelease(), TransamVariablesData::nextXid, ObjectIdGetDatum(), TransamVariablesData::oldestXid, TransamVariablesData::oldestXidDB, SearchSysCacheExists1, TransactionIdFollowsOrEquals(), TransactionIdIsNormal, TransactionIdIsValid, TransamVariables, XidFromFullTransactionId, and TransamVariablesData::xidVacLimit.

Referenced by vac_update_datfrozenxid().

FullTransactionIdAdvance()

static void FullTransactionIdAdvance ( FullTransactionId *  dest )

inlinestatic

Definition at line 128 of file transam.h.

{
    dest->value++;
 
    /* see FullTransactionIdAdvance() */
    if (FullTransactionIdPrecedes(*dest, FirstNormalFullTransactionId))
        return;
 
    while (XidFromFullTransactionId(*dest) < FirstNormalTransactionId)
        dest->value++;
}

References FirstNormalFullTransactionId, FirstNormalTransactionId, FullTransactionIdPrecedes, and XidFromFullTransactionId.

Referenced by GetNewTransactionId(), and GetSnapshotData().

FullTransactionIdFromAllowableAt()

static FullTransactionId FullTransactionIdFromAllowableAt ( FullTransactionId  nextFullXid, TransactionId  xid  )

inlinestatic

Definition at line 443 of file transam.h.

{
    uint32      epoch;
 
    /* Special transaction ID. */
    if (!TransactionIdIsNormal(xid))
        return FullTransactionIdFromEpochAndXid(0, xid);
 
    Assert(TransactionIdPrecedesOrEquals(xid,
                                         XidFromFullTransactionId(nextFullXid)));
 
    /*
     * The 64 bit result must be <= nextFullXid, since nextFullXid hadn't been
     * issued yet when xid was in the past.  The xid must therefore be from
     * the epoch of nextFullXid or the epoch before.  We know this because we
     * must remove (by freezing) an XID before assigning the XID half an epoch
     * ahead of it.
     *
     * The unlikely() branch hint is dubious.  It's perfect for the first 2^32
     * XIDs of a cluster's life.  Right at 2^32 XIDs, misprediction shoots to
     * 100%, then improves until perfection returns 2^31 XIDs later.  Since
     * current callers pass relatively-recent XIDs, expect >90% prediction
     * accuracy overall.  This favors average latency over tail latency.
     */
    epoch = EpochFromFullTransactionId(nextFullXid);
    if (unlikely(xid > XidFromFullTransactionId(nextFullXid)))
    {
        Assert(epoch != 0);
        epoch--;
    }
 
    return FullTransactionIdFromEpochAndXid(epoch, xid);
}

References Assert, epoch, EpochFromFullTransactionId, fb(), FullTransactionIdFromEpochAndXid(), TransactionIdIsNormal, TransactionIdPrecedesOrEquals(), unlikely, and XidFromFullTransactionId.

Referenced by AdjustToFullTransactionId(), pg_current_snapshot(), PrepareRedoAdd(), PrepareRedoRemove(), ProcessStandbyPSRequestMessage(), removable_cutoff(), TransactionIdInRecentPast(), and XLogRecGetFullXid().

FullTransactionIdFromEpochAndXid()

static FullTransactionId FullTransactionIdFromEpochAndXid ( uint32  epoch, TransactionId  xid  )

inlinestatic

Definition at line 71 of file transam.h.

{
    FullTransactionId result;
 
    result.value = ((uint64) epoch) << 32 | xid;
 
    return result;
}

References epoch, and FullTransactionId::value.

Referenced by AdvanceNextFullTransactionIdPastXid(), BootStrapXLOG(), FullTransactionIdFromAllowableAt(), FullTransactionIdFromXidAndCtx(), GetNewTransactionId(), GistPageGetDeleteXid(), GuessControlValues(), and main().

FullTransactionIdFromU64()

static FullTransactionId FullTransactionIdFromU64 ( uint64  value )

inlinestatic

Definition at line 81 of file transam.h.

{
    FullTransactionId result;
 
    result.value = value;
 
    return result;
}

References FullTransactionId::value, and value.

Referenced by DatumGetFullTransactionId(), FullTransactionIdFromXidAndCtx(), FullXidRelativeTo(), LogicalRepApplyLoop(), parse_snapshot(), pg_snapshot_recv(), restoreTwoPhaseData(), xid8in(), and xid8recv().

FullTransactionIdNewer()

static FullTransactionId FullTransactionIdNewer ( FullTransactionId  a, FullTransactionId  b  )

inlinestatic

Definition at line 422 of file transam.h.

{
    if (!FullTransactionIdIsValid(a))
        return b;
 
    if (!FullTransactionIdIsValid(b))
        return a;
 
    if (FullTransactionIdFollows(a, b))
        return a;
    return b;
}

References a, b, FullTransactionIdFollows, and FullTransactionIdIsValid.

Referenced by GetSnapshotData(), and GlobalVisUpdateApply().

FullTransactionIdRetreat()

static void FullTransactionIdRetreat ( FullTransactionId *  dest )

inlinestatic

Definition at line 103 of file transam.h.

{
    dest->value--;
 
    /*
     * In contrast to 32bit XIDs don't step over the "actual" special xids.
     * For 64bit xids these can't be reached as part of a wraparound as they
     * can in the 32bit case.
     */
    if (FullTransactionIdPrecedes(*dest, FirstNormalFullTransactionId))
        return;
 
    /*
     * But we do need to step over XIDs that'd appear special only for 32bit
     * XIDs.
     */
    while (XidFromFullTransactionId(*dest) < FirstNormalTransactionId)
        dest->value--;
}

References FirstNormalFullTransactionId, FirstNormalTransactionId, FullTransactionIdPrecedes, and XidFromFullTransactionId.

Referenced by ExpireAllKnownAssignedTransactionIds(), and StartupXLOG().

GetNewObjectId()

Oid GetNewObjectId ( void  )

extern

Definition at line 555 of file varsup.c.

{
    Oid         result;
 
    /* safety check, we should never get this far in a HS standby */
    if (RecoveryInProgress())
        elog(ERROR, "cannot assign OIDs during recovery");
 
    LWLockAcquire(OidGenLock, LW_EXCLUSIVE);
 
    /*
     * Check for wraparound of the OID counter.  We *must* not return 0
     * (InvalidOid), and in normal operation we mustn't return anything below
     * FirstNormalObjectId since that range is reserved for initdb (see
     * IsCatalogRelationOid()).  Note we are relying on unsigned comparison.
     *
     * During initdb, we start the OID generator at FirstGenbkiObjectId, so we
     * only wrap if before that point when in bootstrap or standalone mode.
     * The first time through this routine after normal postmaster start, the
     * counter will be forced up to FirstNormalObjectId.  This mechanism
     * leaves the OIDs between FirstGenbkiObjectId and FirstNormalObjectId
     * available for automatic assignment during initdb, while ensuring they
     * will never conflict with user-assigned OIDs.
     */
    if (TransamVariables->nextOid < ((Oid) FirstNormalObjectId))
    {
        if (IsPostmasterEnvironment)
        {
            /* wraparound, or first post-initdb assignment, in normal mode */
            TransamVariables->nextOid = FirstNormalObjectId;
            TransamVariables->oidCount = 0;
        }
        else
        {
            /* we may be bootstrapping, so don't enforce the full range */
            if (TransamVariables->nextOid < ((Oid) FirstGenbkiObjectId))
            {
                /* wraparound in standalone mode (unlikely but possible) */
                TransamVariables->nextOid = FirstNormalObjectId;
                TransamVariables->oidCount = 0;
            }
        }
    }
 
    /* If we run out of logged for use oids then we must log more */
    if (TransamVariables->oidCount == 0)
    {
        XLogPutNextOid(TransamVariables->nextOid + VAR_OID_PREFETCH);
        TransamVariables->oidCount = VAR_OID_PREFETCH;
    }
 
    result = TransamVariables->nextOid;
 
    (TransamVariables->nextOid)++;
    (TransamVariables->oidCount)--;
 
    LWLockRelease(OidGenLock);
 
    return result;
}

References elog, ERROR, fb(), FirstGenbkiObjectId, FirstNormalObjectId, IsPostmasterEnvironment, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), TransamVariablesData::nextOid, TransamVariablesData::oidCount, RecoveryInProgress(), TransamVariables, VAR_OID_PREFETCH, and XLogPutNextOid().

Referenced by GetNewOidWithIndex(), and GetNewRelFileNumber().

GetNewTransactionId()

FullTransactionId GetNewTransactionId ( bool  isSubXact )

extern

Definition at line 77 of file varsup.c.

{
    FullTransactionId full_xid;
    TransactionId xid;
 
    /*
     * Workers synchronize transaction state at the beginning of each parallel
     * operation, so we can't account for new XIDs after that point.
     */
    if (IsInParallelMode())
        elog(ERROR, "cannot assign TransactionIds during a parallel operation");
 
    /*
     * During bootstrap initialization, we return the special bootstrap
     * transaction id.
     */
    if (IsBootstrapProcessingMode())
    {
        Assert(!isSubXact);
        MyProc->xid = BootstrapTransactionId;
        ProcGlobal->xids[MyProc->pgxactoff] = BootstrapTransactionId;
        return FullTransactionIdFromEpochAndXid(0, BootstrapTransactionId);
    }
 
    /* safety check, we should never get this far in a HS standby */
    if (RecoveryInProgress())
        elog(ERROR, "cannot assign TransactionIds during recovery");
 
    LWLockAcquire(XidGenLock, LW_EXCLUSIVE);
 
    full_xid = TransamVariables->nextXid;
    xid = XidFromFullTransactionId(full_xid);
 
    /*----------
     * Check to see if it's safe to assign another XID.  This protects against
     * catastrophic data loss due to XID wraparound.  The basic rules are:
     *
     * If we're past xidVacLimit, start trying to force autovacuum cycles.
     * If we're past xidWarnLimit, start issuing warnings.
     * If we're past xidStopLimit, refuse to execute transactions, unless
     * we are running in single-user mode (which gives an escape hatch
     * to the DBA who somehow got past the earlier defenses).
     *
     * Note that this coding also appears in GetNewMultiXactId.
     *----------
     */
    if (TransactionIdFollowsOrEquals(xid, TransamVariables->xidVacLimit))
    {
        /*
         * For safety's sake, we release XidGenLock while sending signals,
         * warnings, etc.  This is not so much because we care about
         * preserving concurrency in this situation, as to avoid any
         * possibility of deadlock while doing get_database_name(). First,
         * copy all the shared values we'll need in this path.
         */
        TransactionId xidWarnLimit = TransamVariables->xidWarnLimit;
        TransactionId xidStopLimit = TransamVariables->xidStopLimit;
        TransactionId xidWrapLimit = TransamVariables->xidWrapLimit;
        Oid         oldest_datoid = TransamVariables->oldestXidDB;
 
        LWLockRelease(XidGenLock);
 
        /*
         * To avoid swamping the postmaster with signals, we issue the autovac
         * request only once per 64K transaction starts.  This still gives
         * plenty of chances before we get into real trouble.
         */
        if (IsUnderPostmaster && (xid % 65536) == 0)
            SendPostmasterSignal(PMSIGNAL_START_AUTOVAC_LAUNCHER);
 
        if (IsUnderPostmaster &&
            TransactionIdFollowsOrEquals(xid, xidStopLimit))
        {
            char       *oldest_datname = get_database_name(oldest_datoid);
 
            /* complain even if that DB has disappeared */
            if (oldest_datname)
                ereport(ERROR,
                        (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                         errmsg("database is not accepting commands that assign new transaction IDs to avoid wraparound data loss in database \"%s\"",
                                oldest_datname),
                         errhint("Execute a database-wide VACUUM in that database.\n"
                                 "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
            else
                ereport(ERROR,
                        (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                         errmsg("database is not accepting commands that assign new transaction IDs to avoid wraparound data loss in database with OID %u",
                                oldest_datoid),
                         errhint("Execute a database-wide VACUUM in that database.\n"
                                 "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
        }
        else if (TransactionIdFollowsOrEquals(xid, xidWarnLimit))
        {
            char       *oldest_datname = get_database_name(oldest_datoid);
 
            /* complain even if that DB has disappeared */
            if (oldest_datname)
                ereport(WARNING,
                        (errmsg("database \"%s\" must be vacuumed within %u transactions",
                                oldest_datname,
                                xidWrapLimit - xid),
                         errhint("To avoid transaction ID assignment failures, execute a database-wide VACUUM in that database.\n"
                                 "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
            else
                ereport(WARNING,
                        (errmsg("database with OID %u must be vacuumed within %u transactions",
                                oldest_datoid,
                                xidWrapLimit - xid),
                         errhint("To avoid XID assignment failures, execute a database-wide VACUUM in that database.\n"
                                 "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
        }
 
        /* Re-acquire lock and start over */
        LWLockAcquire(XidGenLock, LW_EXCLUSIVE);
        full_xid = TransamVariables->nextXid;
        xid = XidFromFullTransactionId(full_xid);
    }
 
    /*
     * If we are allocating the first XID of a new page of the commit log,
     * zero out that commit-log page before returning. We must do this while
     * holding XidGenLock, else another xact could acquire and commit a later
     * XID before we zero the page.  Fortunately, a page of the commit log
     * holds 32K or more transactions, so we don't have to do this very often.
     *
     * Extend pg_subtrans and pg_commit_ts too.
     */
    ExtendCLOG(xid);
    ExtendCommitTs(xid);
    ExtendSUBTRANS(xid);
 
    /*
     * Now advance the nextXid counter.  This must not happen until after we
     * have successfully completed ExtendCLOG() --- if that routine fails, we
     * want the next incoming transaction to try it again.  We cannot assign
     * more XIDs until there is CLOG space for them.
     */
    FullTransactionIdAdvance(&TransamVariables->nextXid);
 
    /*
     * We must store the new XID into the shared ProcArray before releasing
     * XidGenLock.  This ensures that every active XID older than
     * latestCompletedXid is present in the ProcArray, which is essential for
     * correct OldestXmin tracking; see src/backend/access/transam/README.
     *
     * Note that readers of ProcGlobal->xids/PGPROC->xid should be careful to
     * fetch the value for each proc only once, rather than assume they can
     * read a value multiple times and get the same answer each time.  Note we
     * are assuming that TransactionId and int fetch/store are atomic.
     *
     * The same comments apply to the subxact xid count and overflow fields.
     *
     * Use of a write barrier prevents dangerous code rearrangement in this
     * function; other backends could otherwise e.g. be examining my subxids
     * info concurrently, and we don't want them to see an invalid
     * intermediate state, such as an incremented nxids before the array entry
     * is filled.
     *
     * Other processes that read nxids should do so before reading xids
     * elements with a pg_read_barrier() in between, so that they can be sure
     * not to read an uninitialized array element; see
     * src/backend/storage/lmgr/README.barrier.
     *
     * If there's no room to fit a subtransaction XID into PGPROC, set the
     * cache-overflowed flag instead.  This forces readers to look in
     * pg_subtrans to map subtransaction XIDs up to top-level XIDs. There is a
     * race-condition window, in that the new XID will not appear as running
     * until its parent link has been placed into pg_subtrans. However, that
     * will happen before anyone could possibly have a reason to inquire about
     * the status of the XID, so it seems OK.  (Snapshots taken during this
     * window *will* include the parent XID, so they will deliver the correct
     * answer later on when someone does have a reason to inquire.)
     */
    if (!isSubXact)
    {
        Assert(ProcGlobal->subxidStates[MyProc->pgxactoff].count == 0);
        Assert(!ProcGlobal->subxidStates[MyProc->pgxactoff].overflowed);
        Assert(MyProc->subxidStatus.count == 0);
        Assert(!MyProc->subxidStatus.overflowed);
 
        /* LWLockRelease acts as barrier */
        MyProc->xid = xid;
        ProcGlobal->xids[MyProc->pgxactoff] = xid;
    }
    else
    {
        XidCacheStatus *substat = &ProcGlobal->subxidStates[MyProc->pgxactoff];
        int         nxids = MyProc->subxidStatus.count;
 
        Assert(substat->count == MyProc->subxidStatus.count);
        Assert(substat->overflowed == MyProc->subxidStatus.overflowed);
 
        if (nxids < PGPROC_MAX_CACHED_SUBXIDS)
        {
            MyProc->subxids.xids[nxids] = xid;
            pg_write_barrier();
            MyProc->subxidStatus.count = substat->count = nxids + 1;
        }
        else
            MyProc->subxidStatus.overflowed = substat->overflowed = true;
    }
 
    LWLockRelease(XidGenLock);
 
    return full_xid;
}

References Assert, BootstrapTransactionId, XidCacheStatus::count, elog, ereport, errcode(), errhint(), errmsg(), ERROR, ExtendCLOG(), ExtendCommitTs(), ExtendSUBTRANS(), fb(), FullTransactionIdAdvance(), FullTransactionIdFromEpochAndXid(), get_database_name(), IsBootstrapProcessingMode, IsInParallelMode(), IsUnderPostmaster, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MyProc, TransamVariablesData::nextXid, TransamVariablesData::oldestXidDB, XidCacheStatus::overflowed, pg_write_barrier, PGPROC_MAX_CACHED_SUBXIDS, PGPROC::pgxactoff, PMSIGNAL_START_AUTOVAC_LAUNCHER, ProcGlobal, RecoveryInProgress(), SendPostmasterSignal(), PGPROC::subxids, PROC_HDR::subxidStates, PGPROC::subxidStatus, TransactionIdFollowsOrEquals(), TransamVariables, WARNING, PGPROC::xid, XidFromFullTransactionId, XidCache::xids, PROC_HDR::xids, TransamVariablesData::xidStopLimit, TransamVariablesData::xidVacLimit, TransamVariablesData::xidWarnLimit, and TransamVariablesData::xidWrapLimit.

Referenced by AssignTransactionId(), and consume_xids_common().

NormalTransactionIdOlder()

static TransactionId NormalTransactionIdOlder ( TransactionId  a, TransactionId  b  )

inlinestatic

Definition at line 411 of file transam.h.

{
    Assert(TransactionIdIsNormal(a));
    Assert(TransactionIdIsNormal(b));
    if (NormalTransactionIdPrecedes(a, b))
        return a;
    return b;
}

References a, Assert, b, NormalTransactionIdPrecedes, and TransactionIdIsNormal.

ReadNextFullTransactionId()

FullTransactionId ReadNextFullTransactionId ( void  )

extern

Definition at line 288 of file varsup.c.

{
    FullTransactionId fullXid;
 
    LWLockAcquire(XidGenLock, LW_SHARED);
    fullXid = TransamVariables->nextXid;
    LWLockRelease(XidGenLock);
 
    return fullXid;
}

References fb(), LW_SHARED, LWLockAcquire(), LWLockRelease(), TransamVariablesData::nextXid, and TransamVariables.

Referenced by _bt_unlink_halfdead_page(), AdjustToFullTransactionId(), consume_xids(), consume_xids_common(), gistdeletepage(), pg_current_snapshot(), ProcessStandbyPSRequestMessage(), ReadNextTransactionId(), removable_cutoff(), ResolveRecoveryConflictWithSnapshotFullXid(), TransactionIdInRecentPast(), TransactionIdInRecentPast(), and XLogWalRcvSendHSFeedback().

ReadNextTransactionId()

static TransactionId ReadNextTransactionId ( void  )

inlinestatic

Definition at line 377 of file transam.h.

{
    return XidFromFullTransactionId(ReadNextFullTransactionId());
}

References ReadNextFullTransactionId(), and XidFromFullTransactionId.

Referenced by ActivateCommitTs(), AutoVacWorkerMain(), do_start_worker(), GetStableLatestTransactionId(), ginDeletePage(), heap_vacuum_rel(), vac_truncate_clog(), vac_update_datfrozenxid(), vac_update_relstats(), vacuum_get_cutoffs(), and vacuum_xid_failsafe_check().

SetTransactionIdLimit()

void SetTransactionIdLimit ( TransactionId  oldest_datfrozenxid, Oid  oldest_datoid  )

extern

Definition at line 372 of file varsup.c.

{
    TransactionId xidVacLimit;
    TransactionId xidWarnLimit;
    TransactionId xidStopLimit;
    TransactionId xidWrapLimit;
    TransactionId curXid;
 
    Assert(TransactionIdIsNormal(oldest_datfrozenxid));
 
    /*
     * The place where we actually get into deep trouble is halfway around
     * from the oldest potentially-existing XID.  (This calculation is
     * probably off by one or two counts, because the special XIDs reduce the
     * size of the loop a little bit.  But we throw in plenty of slop below,
     * so it doesn't matter.)
     */
    xidWrapLimit = oldest_datfrozenxid + (MaxTransactionId >> 1);
    if (xidWrapLimit < FirstNormalTransactionId)
        xidWrapLimit += FirstNormalTransactionId;
 
    /*
     * We'll refuse to continue assigning XIDs in interactive mode once we get
     * within 3M transactions of data loss.  This leaves lots of room for the
     * DBA to fool around fixing things in a standalone backend, while not
     * being significant compared to total XID space. (VACUUM requires an XID
     * if it truncates at wal_level!=minimal.  "VACUUM (ANALYZE)", which a DBA
     * might do by reflex, assigns an XID.  Hence, we had better be sure
     * there's lots of XIDs left...)  Also, at default BLCKSZ, this leaves two
     * completely-idle segments.  In the event of edge-case bugs involving
     * page or segment arithmetic, idle segments render the bugs unreachable
     * outside of single-user mode.
     */
    xidStopLimit = xidWrapLimit - 3000000;
    if (xidStopLimit < FirstNormalTransactionId)
        xidStopLimit -= FirstNormalTransactionId;
 
    /*
     * We'll start complaining loudly when we get within 40M transactions of
     * data loss.  This is kind of arbitrary, but if you let your gas gauge
     * get down to 2% of full, would you be looking for the next gas station?
     * We need to be fairly liberal about this number because there are lots
     * of scenarios where most transactions are done by automatic clients that
     * won't pay attention to warnings.  (No, we're not gonna make this
     * configurable.  If you know enough to configure it, you know enough to
     * not get in this kind of trouble in the first place.)
     */
    xidWarnLimit = xidWrapLimit - 40000000;
    if (xidWarnLimit < FirstNormalTransactionId)
        xidWarnLimit -= FirstNormalTransactionId;
 
    /*
     * We'll start trying to force autovacuums when oldest_datfrozenxid gets
     * to be more than autovacuum_freeze_max_age transactions old.
     *
     * Note: guc.c ensures that autovacuum_freeze_max_age is in a sane range,
     * so that xidVacLimit will be well before xidWarnLimit.
     *
     * Note: autovacuum_freeze_max_age is a PGC_POSTMASTER parameter so that
     * we don't have to worry about dealing with on-the-fly changes in its
     * value.  It doesn't look practical to update shared state from a GUC
     * assign hook (too many processes would try to execute the hook,
     * resulting in race conditions as well as crashes of those not connected
     * to shared memory).  Perhaps this can be improved someday.  See also
     * SetMultiXactIdLimit.
     */
    xidVacLimit = oldest_datfrozenxid + autovacuum_freeze_max_age;
    if (xidVacLimit < FirstNormalTransactionId)
        xidVacLimit += FirstNormalTransactionId;
 
    /* Grab lock for just long enough to set the new limit values */
    LWLockAcquire(XidGenLock, LW_EXCLUSIVE);
    TransamVariables->oldestXid = oldest_datfrozenxid;
    TransamVariables->xidVacLimit = xidVacLimit;
    TransamVariables->xidWarnLimit = xidWarnLimit;
    TransamVariables->xidStopLimit = xidStopLimit;
    TransamVariables->xidWrapLimit = xidWrapLimit;
    TransamVariables->oldestXidDB = oldest_datoid;
    curXid = XidFromFullTransactionId(TransamVariables->nextXid);
    LWLockRelease(XidGenLock);
 
    /* Log the info */
    ereport(DEBUG1,
            (errmsg_internal("transaction ID wrap limit is %u, limited by database with OID %u",
                             xidWrapLimit, oldest_datoid)));
 
    /*
     * If past the autovacuum force point, immediately signal an autovac
     * request.  The reason for this is that autovac only processes one
     * database per invocation.  Once it's finished cleaning up the oldest
     * database, it'll call here, and we'll signal the postmaster to start
     * another iteration immediately if there are still any old databases.
     */
    if (TransactionIdFollowsOrEquals(curXid, xidVacLimit) &&
        IsUnderPostmaster && !InRecovery)
        SendPostmasterSignal(PMSIGNAL_START_AUTOVAC_LAUNCHER);
 
    /* Give an immediate warning if past the wrap warn point */
    if (TransactionIdFollowsOrEquals(curXid, xidWarnLimit) && !InRecovery)
    {
        char       *oldest_datname;
 
        /*
         * We can be called when not inside a transaction, for example during
         * StartupXLOG().  In such a case we cannot do database access, so we
         * must just report the oldest DB's OID.
         *
         * Note: it's also possible that get_database_name fails and returns
         * NULL, for example because the database just got dropped.  We'll
         * still warn, even though the warning might now be unnecessary.
         */
        if (IsTransactionState())
            oldest_datname = get_database_name(oldest_datoid);
        else
            oldest_datname = NULL;
 
        if (oldest_datname)
            ereport(WARNING,
                    (errmsg("database \"%s\" must be vacuumed within %u transactions",
                            oldest_datname,
                            xidWrapLimit - curXid),
                     errhint("To avoid XID assignment failures, execute a database-wide VACUUM in that database.\n"
                             "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
        else
            ereport(WARNING,
                    (errmsg("database with OID %u must be vacuumed within %u transactions",
                            oldest_datoid,
                            xidWrapLimit - curXid),
                     errhint("To avoid XID assignment failures, execute a database-wide VACUUM in that database.\n"
                             "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
    }
}

References Assert, autovacuum_freeze_max_age, DEBUG1, ereport, errhint(), errmsg(), errmsg_internal(), fb(), FirstNormalTransactionId, get_database_name(), InRecovery, IsTransactionState(), IsUnderPostmaster, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MaxTransactionId, TransamVariablesData::nextXid, TransamVariablesData::oldestXid, TransamVariablesData::oldestXidDB, PMSIGNAL_START_AUTOVAC_LAUNCHER, SendPostmasterSignal(), TransactionIdFollowsOrEquals(), TransactionIdIsNormal, TransamVariables, WARNING, XidFromFullTransactionId, TransamVariablesData::xidStopLimit, TransamVariablesData::xidVacLimit, TransamVariablesData::xidWarnLimit, and TransamVariablesData::xidWrapLimit.

Referenced by BootStrapXLOG(), StartupXLOG(), vac_truncate_clog(), and xlog_redo().

StopGeneratingPinnedObjectIds()

void StopGeneratingPinnedObjectIds ( void  )

extern

Definition at line 652 of file varsup.c.

{
    SetNextObjectId(FirstUnpinnedObjectId);
}

References FirstUnpinnedObjectId, and SetNextObjectId().

Referenced by pg_stop_making_pinned_objects().

TransactionIdAbortTree()

void TransactionIdAbortTree ( TransactionId  xid, int  nxids, TransactionId *  xids  )

extern

Definition at line 270 of file transam.c.

{
    TransactionIdSetTreeStatus(xid, nxids, xids,
                               TRANSACTION_STATUS_ABORTED, InvalidXLogRecPtr);
}

References fb(), InvalidXLogRecPtr, TRANSACTION_STATUS_ABORTED, and TransactionIdSetTreeStatus().

Referenced by RecordTransactionAbort(), RecordTransactionAbortPrepared(), and xact_redo_abort().

TransactionIdAsyncCommitTree()

void TransactionIdAsyncCommitTree ( TransactionId  xid, int  nxids, TransactionId *  xids, XLogRecPtr  lsn  )

extern

Definition at line 252 of file transam.c.

{
    TransactionIdSetTreeStatus(xid, nxids, xids,
                               TRANSACTION_STATUS_COMMITTED, lsn);
}

References fb(), TRANSACTION_STATUS_COMMITTED, and TransactionIdSetTreeStatus().

Referenced by RecordTransactionCommit(), and xact_redo_commit().

TransactionIdCommitTree()

void TransactionIdCommitTree ( TransactionId  xid, int  nxids, TransactionId *  xids  )

extern

Definition at line 240 of file transam.c.

{
    TransactionIdSetTreeStatus(xid, nxids, xids,
                               TRANSACTION_STATUS_COMMITTED,
                               InvalidXLogRecPtr);
}

References fb(), InvalidXLogRecPtr, TRANSACTION_STATUS_COMMITTED, and TransactionIdSetTreeStatus().

Referenced by RecordTransactionCommit(), RecordTransactionCommitPrepared(), and xact_redo_commit().

TransactionIdDidAbort()

bool TransactionIdDidAbort ( TransactionId  transactionId )

extern

Definition at line 188 of file transam.c.

{
    XidStatus   xidstatus;
 
    xidstatus = TransactionLogFetch(transactionId);
 
    /*
     * If it's marked aborted, it's aborted.
     */
    if (xidstatus == TRANSACTION_STATUS_ABORTED)
        return true;
 
    /*
     * If it's marked subcommitted, we have to check the parent recursively.
     * However, if it's older than TransactionXmin, we can't look at
     * pg_subtrans; instead assume that the parent crashed without cleaning up
     * its children.
     */
    if (xidstatus == TRANSACTION_STATUS_SUB_COMMITTED)
    {
        TransactionId parentXid;
 
        if (TransactionIdPrecedes(transactionId, TransactionXmin))
            return true;
        parentXid = SubTransGetParent(transactionId);
        if (!TransactionIdIsValid(parentXid))
        {
            /* see notes in TransactionIdDidCommit */
            elog(WARNING, "no pg_subtrans entry for subcommitted XID %u",
                 transactionId);
            return true;
        }
        return TransactionIdDidAbort(parentXid);
    }
 
    /*
     * It's not aborted.
     */
    return false;
}

References elog, fb(), SubTransGetParent(), TRANSACTION_STATUS_ABORTED, TRANSACTION_STATUS_SUB_COMMITTED, TransactionIdDidAbort(), TransactionIdIsValid, TransactionIdPrecedes(), TransactionLogFetch(), TransactionXmin, and WARNING.

Referenced by DoesMultiXactIdConflict(), heap_lock_updated_tuple_rec(), heap_update(), ProcArrayApplyRecoveryInfo(), ProcessTwoPhaseBuffer(), StandbyAcquireAccessExclusiveLock(), test_lockmode_for_conflict(), TransactionIdDidAbort(), and TransactionIdIsInProgress().

TransactionIdDidCommit()

bool TransactionIdDidCommit ( TransactionId  transactionId )

extern

Definition at line 126 of file transam.c.

{
    XidStatus   xidstatus;
 
    xidstatus = TransactionLogFetch(transactionId);
 
    /*
     * If it's marked committed, it's committed.
     */
    if (xidstatus == TRANSACTION_STATUS_COMMITTED)
        return true;
 
    /*
     * If it's marked subcommitted, we have to check the parent recursively.
     * However, if it's older than TransactionXmin, we can't look at
     * pg_subtrans; instead assume that the parent crashed without cleaning up
     * its children.
     *
     * Originally we Assert'ed that the result of SubTransGetParent was not
     * zero. However with the introduction of prepared transactions, there can
     * be a window just after database startup where we do not have complete
     * knowledge in pg_subtrans of the transactions after TransactionXmin.
     * StartupSUBTRANS() has ensured that any missing information will be
     * zeroed.  Since this case should not happen under normal conditions, it
     * seems reasonable to emit a WARNING for it.
     */
    if (xidstatus == TRANSACTION_STATUS_SUB_COMMITTED)
    {
        TransactionId parentXid;
 
        if (TransactionIdPrecedes(transactionId, TransactionXmin))
            return false;
        parentXid = SubTransGetParent(transactionId);
        if (!TransactionIdIsValid(parentXid))
        {
            elog(WARNING, "no pg_subtrans entry for subcommitted XID %u",
                 transactionId);
            return false;
        }
        return TransactionIdDidCommit(parentXid);
    }
 
    /*
     * It's not committed.
     */
    return false;
}

References elog, fb(), SubTransGetParent(), TRANSACTION_STATUS_COMMITTED, TRANSACTION_STATUS_SUB_COMMITTED, TransactionIdDidCommit(), TransactionIdIsValid, TransactionIdPrecedes(), TransactionLogFetch(), TransactionXmin, and WARNING.

Referenced by AsyncNotifyFreezeXids(), asyncQueueProcessPageEntries(), check_safe_enum_use(), compute_new_xmax_infomask(), FreezeMultiXactId(), get_xid_status(), HandleConcurrentAbort(), heap_pre_freeze_checks(), HeapTupleCleanMoved(), HeapTupleHeaderAdvanceConflictHorizon(), HeapTupleHeaderIsOnlyLocked(), HeapTupleSatisfiesDirty(), HeapTupleSatisfiesHistoricMVCC(), HeapTupleSatisfiesMVCC(), HeapTupleSatisfiesSelf(), HeapTupleSatisfiesUpdate(), HeapTupleSatisfiesVacuumHorizon(), MultiXactIdExpand(), pg_xact_status(), ProcArrayApplyRecoveryInfo(), ProcessTwoPhaseBuffer(), RecordTransactionAbort(), RecordTransactionAbortPrepared(), ReorderBufferCheckAndTruncateAbortedTXN(), SetupCheckXidLive(), StandbyAcquireAccessExclusiveLock(), test_lockmode_for_conflict(), TransactionIdDidCommit(), UpdateLogicalMappings(), and UpdateXmaxHintBits().

TransactionIdFollows()

static bool TransactionIdFollows ( TransactionId  id1, TransactionId  id2  )

inlinestatic

Definition at line 297 of file transam.h.

{
    int32       diff;
 
    if (!TransactionIdIsNormal(id1) || !TransactionIdIsNormal(id2))
        return (id1 > id2);
 
    diff = (int32) (id1 - id2);
    return (diff > 0);
}

References fb(), and TransactionIdIsNormal.

Referenced by find_inheritance_children_extended(), GetConflictingVirtualXIDs(), GetSerializableTransactionSnapshotInt(), heap_page_prune_and_freeze(), heap_page_would_be_all_visible(), heap_prune_record_unchanged_lp_normal(), HeapTupleHeaderAdvanceConflictHorizon(), predicatelock_twophase_recover(), ProcessTwoPhaseBuffer(), RecordKnownAssignedTransactionIds(), SerialAdd(), SerialGetMinConflictCommitSeqNo(), SerialSetActiveSerXmin(), SnapBuildInitialSnapshot(), SnapBuildWaitSnapshot(), SubTransSetParent(), update_local_synced_slot(), and xmin_cmp().

TransactionIdFollowsOrEquals()

static bool TransactionIdFollowsOrEquals ( TransactionId  id1, TransactionId  id2  )

inlinestatic

Definition at line 312 of file transam.h.

{
    int32       diff;
 
    if (!TransactionIdIsNormal(id1) || !TransactionIdIsNormal(id2))
        return (id1 >= id2);
 
    diff = (int32) (id1 - id2);
    return (diff >= 0);
}

References fb(), and TransactionIdIsNormal.

Referenced by AdvanceNextFullTransactionIdPastXid(), ForceTransactionIdLimitUpdate(), GetNewTransactionId(), HeapCheckForSerializableConflictOut(), HeapTupleSatisfiesHistoricMVCC(), KnownAssignedXidsAdd(), KnownAssignedXidsGetAndSetXmin(), KnownAssignedXidsRemovePreceding(), SetTransactionIdLimit(), SnapBuildCommitTxn(), SnapBuildPurgeOlderTxn(), SubTransGetParent(), SubTransGetTopmostTransaction(), vacuumLeafPage(), XidInMVCCSnapshot(), and XidIsConcurrent().

TransactionIdGetCommitLSN()

XLogRecPtr TransactionIdGetCommitLSN ( TransactionId  xid )

extern

Definition at line 318 of file transam.c.

{
    XLogRecPtr  result;
 
    /*
     * Currently, all uses of this function are for xids that were just
     * reported to be committed by TransactionLogFetch, so we expect that
     * checking TransactionLogFetch's cache will usually succeed and avoid an
     * extra trip to shared memory.
     */
    if (TransactionIdEquals(xid, cachedFetchXid))
        return cachedCommitLSN;
 
    /* Special XIDs are always known committed */
    if (!TransactionIdIsNormal(xid))
        return InvalidXLogRecPtr;
 
    /*
     * Get the transaction status.
     */
    (void) TransactionIdGetStatus(xid, &result);
 
    return result;
}

References cachedCommitLSN, cachedFetchXid, fb(), InvalidXLogRecPtr, TransactionIdEquals, TransactionIdGetStatus(), and TransactionIdIsNormal.

Referenced by SetHintBits().

TransactionIdLatest()

TransactionId TransactionIdLatest ( TransactionId  mainxid, int  nxids, const TransactionId *  xids  )

extern

Definition at line 281 of file transam.c.

{
    TransactionId result;
 
    /*
     * In practice it is highly likely that the xids[] array is sorted, and so
     * we could save some cycles by just taking the last child XID, but this
     * probably isn't so performance-critical that it's worth depending on
     * that assumption.  But just to show we're not totally stupid, scan the
     * array back-to-front to avoid useless assignments.
     */
    result = mainxid;
    while (--nxids >= 0)
    {
        if (TransactionIdPrecedes(result, xids[nxids]))
            result = xids[nxids];
    }
    return result;
}

References fb(), and TransactionIdPrecedes().

Referenced by FinishPreparedTransaction(), ProcArrayApplyXidAssignment(), RecordTransactionAbort(), RecordTransactionCommit(), xact_redo_abort(), and xact_redo_commit().

TransactionIdOlder()

static TransactionId TransactionIdOlder ( TransactionId  a, TransactionId  b  )

inlinestatic

Definition at line 396 of file transam.h.

{
    if (!TransactionIdIsValid(a))
        return b;
 
    if (!TransactionIdIsValid(b))
        return a;
 
    if (TransactionIdPrecedes(a, b))
        return a;
    return b;
}

References a, b, TransactionIdIsValid, and TransactionIdPrecedes().

Referenced by ComputeXidHorizons(), and GetSnapshotData().

TransactionIdPrecedes()

static bool TransactionIdPrecedes ( TransactionId  id1, TransactionId  id2  )

inlinestatic

Definition at line 263 of file transam.h.

{
    /*
     * If either ID is a permanent XID then we can just do unsigned
     * comparison.  If both are normal, do a modulo-2^32 comparison.
     */
    int32       diff;
 
    if (!TransactionIdIsNormal(id1) || !TransactionIdIsNormal(id2))
        return (id1 < id2);
 
    diff = (int32) (id1 - id2);
    return (diff < 0);
}

References fb(), and TransactionIdIsNormal.

Referenced by AdvanceOldestClogXid(), AdvanceOldestCommitTsXid(), AsyncNotifyFreezeXids(), bt_check_every_level(), check_exclusion_or_unique_constraint(), check_tuple_visibility(), CheckTargetForConflictsIn(), CLOGPagePrecedes(), collect_corrupt_items(), CommitTsPagePrecedes(), compute_min_nonremovable_xid(), copy_table_data(), do_start_worker(), ExpireOldKnownAssignedTransactionIds(), ExportSnapshot(), FreezeMultiXactId(), get_relation_info(), GetOldestActiveTransactionId(), GetOldestSafeDecodingTransactionId(), GetRunningTransactionData(), heap_abort_speculative(), heap_page_would_be_all_visible(), heap_prepare_freeze_tuple(), heap_prune_record_prunable(), heap_prune_record_unchanged_lp_normal(), heap_tuple_should_freeze(), heap_vacuum_eager_scan_setup(), HeapCheckForSerializableConflictOut(), HeapTupleHeaderAdvanceConflictHorizon(), HeapTupleSatisfiesHistoricMVCC(), HeapTupleSatisfiesVacuum(), IsIndexUsableForFindingDeletedTuple(), KnownAssignedXidsAdd(), KnownAssignedXidsGetAndSetXmin(), KnownAssignedXidsSearch(), logical_rewrite_heap_tuple(), MaintainLatestCompletedXid(), MaintainLatestCompletedXidRecovery(), multixact_redo(), PhysicalReplicationSlotNewXmin(), PrescanPreparedTransactions(), ProcArrayApplyRecoveryInfo(), ProcArrayApplyXidAssignment(), ProcessStandbyHSFeedbackMessage(), ProcessStandbyPSRequestMessage(), RecordKnownAssignedTransactionIds(), relation_needs_vacanalyze(), ReorderBufferAbortOld(), ReplicationSlotsComputeRequiredXmin(), rewrite_heap_tuple(), SerialAdd(), SerialGetMinConflictCommitSeqNo(), SerialPagePrecedesLogically(), SerialSetActiveSerXmin(), SetCommitTsLimit(), SetNewSxactGlobalXmin(), SnapBuildCommitTxn(), SnapBuildProcessChange(), SnapBuildRestore(), SnapshotResetXmin(), StandbyReleaseOldLocks(), SubTransGetTopmostTransaction(), SubTransPagePrecedes(), TransactionIdDidAbort(), TransactionIdDidCommit(), TransactionIdGetCommitTsData(), TransactionIdIsCurrentTransactionId(), TransactionIdIsInProgress(), TransactionIdLatest(), TransactionIdOlder(), TransactionTreeSetCommitTsData(), tuple_all_visible(), TwoPhaseGetOldestXidInCommit(), update_local_synced_slot(), vac_truncate_clog(), vac_update_datfrozenxid(), vac_update_relstats(), vacuum_get_cutoffs(), vacuum_xid_failsafe_check(), vacuumRedirectAndPlaceholder(), XidInMVCCSnapshot(), XidIsConcurrent(), xidLogicalComparator(), xlog_redo(), and xmin_cmp().

TransactionIdPrecedesOrEquals()

static bool TransactionIdPrecedesOrEquals ( TransactionId  id1, TransactionId  id2  )

inlinestatic

Definition at line 282 of file transam.h.

{
    int32       diff;
 
    if (!TransactionIdIsNormal(id1) || !TransactionIdIsNormal(id2))
        return (id1 <= id2);
 
    diff = (int32) (id1 - id2);
    return (diff <= 0);
}

References fb(), and TransactionIdIsNormal.

Referenced by ClearOldPredicateLocks(), ComputeXidHorizons(), DetermineSlotInvalidationCause(), FullTransactionIdFromAllowableAt(), get_candidate_xid(), GetCurrentVirtualXIDs(), GetSnapshotData(), GetSnapshotDataReuse(), heap_prepare_freeze_tuple(), heap_tuple_should_freeze(), heap_vacuum_rel(), KnownAssignedXidsAdd(), LogicalIncreaseXminForSlot(), ProcArrayInstallImportedXmin(), ProcArrayInstallRestoredXmin(), SnapBuildFindSnapshot(), TransactionIdInRecentPast(), TransactionIdIsInProgress(), update_conflict_slot_xmin(), and vacuum_get_cutoffs().

TransactionIdRetreatedBy()

static TransactionId TransactionIdRetreatedBy ( TransactionId  xid, uint32  amount  )

inlinestatic

Definition at line 384 of file transam.h.

{
    xid -= amount;
 
    while (xid < FirstNormalTransactionId)
        xid--;
 
    return xid;
}

References fb(), and FirstNormalTransactionId.

TransactionStartedDuringRecovery()

bool TransactionStartedDuringRecovery ( void  )

extern

Definition at line 1043 of file xact.c.

{
    return CurrentTransactionState->startedInRecovery;
}

References CurrentTransactionState, and TransactionStateData::startedInRecovery.

Referenced by RelationGetIndexScan().

VarsupShmemInit()

void VarsupShmemInit ( void  )

extern

Definition at line 47 of file varsup.c.

{
    bool        found;
 
    /* Initialize our shared state struct */
    TransamVariables = ShmemInitStruct("TransamVariables",
                                       sizeof(TransamVariablesData),
                                       &found);
    if (!IsUnderPostmaster)
    {
        Assert(!found);
        memset(TransamVariables, 0, sizeof(TransamVariablesData));
    }
    else
        Assert(found);
}

References Assert, fb(), IsUnderPostmaster, ShmemInitStruct(), and TransamVariables.

Referenced by CreateOrAttachShmemStructs().

VarsupShmemSize()

Size VarsupShmemSize ( void  )

extern

Definition at line 41 of file varsup.c.

{
    return sizeof(TransamVariablesData);
}

Referenced by CalculateShmemSize().

Variable Documentation

TransamVariables

PGDLLIMPORT TransamVariablesData* TransamVariables

extern

Definition at line 34 of file varsup.c.

Referenced by ActivateCommitTs(), AdvanceNextFullTransactionIdPastXid(), AdvanceOldestClogXid(), AdvanceOldestCommitTsXid(), BootStrapXLOG(), ComputeXidHorizons(), consume_xids_shortcut(), CreateCheckPoint(), DeactivateCommitTs(), ExpireAllKnownAssignedTransactionIds(), ExpireOldKnownAssignedTransactionIds(), ExpireTreeKnownAssignedTransactionIds(), ForceTransactionIdLimitUpdate(), get_xid_status(), GetNewObjectId(), GetNewTransactionId(), GetOldestActiveTransactionId(), GetOldestSafeDecodingTransactionId(), GetRunningTransactionData(), GetSnapshotData(), GetSnapshotDataReuse(), GetStrictOldestNonRemovableTransactionId(), MaintainLatestCompletedXid(), MaintainLatestCompletedXidRecovery(), PrepareRedoAdd(), PrepareRedoRemove(), PrescanPreparedTransactions(), ProcArrayApplyRecoveryInfo(), ProcArrayClearTransaction(), ProcArrayEndTransactionInternal(), ProcArrayRemove(), ProcArrayShmemInit(), ProcessTwoPhaseBuffer(), ReadNextFullTransactionId(), ReleasePredicateLocks(), SetCommitTsLimit(), SetNextObjectId(), SetTransactionIdLimit(), StartupCLOG(), StartupSUBTRANS(), StartupXLOG(), TransactionIdGetCommitTsData(), TransactionIdInRecentPast(), TransactionIdIsInProgress(), TransactionTreeSetCommitTsData(), TrimCLOG(), update_cached_xid_range(), VarsupShmemInit(), XidCacheRemoveRunningXids(), xlog_redo(), and XLogRecGetFullXid().