PostgreSQL Source Code  git master
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)
 
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)
 
bool TransactionIdPrecedes (TransactionId id1, TransactionId id2)
 
bool TransactionIdPrecedesOrEquals (TransactionId id1, TransactionId id2)
 
bool TransactionIdFollows (TransactionId id1, TransactionId id2)
 
bool TransactionIdFollowsOrEquals (TransactionId id1, TransactionId id2)
 
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)
 

Variables

PGDLLIMPORT TransamVariablesDataTransamVariables
 

Macro Definition Documentation

◆ AssertTransactionIdInAllowableRange

#define AssertTransactionIdInAllowableRange (   xid)    ((void)true)

Definition at line 301 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:
(int32) ((id1) - (id2)) > 0)
#define AssertMacro(condition)
Definition: c.h:848
signed int int32
Definition: c.h:483
#define TransactionIdIsNormal(xid)
Definition: transam.h:42

Definition at line 152 of file transam.h.

◆ NormalTransactionIdPrecedes

#define NormalTransactionIdPrecedes (   id1,
  id2 
)
Value:
(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)++; \
} while(0)
#define FirstNormalTransactionId
Definition: transam.h:34

Definition at line 91 of file transam.h.

◆ 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)--; \

Definition at line 141 of file transam.h.

◆ 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

◆ TransamVariablesData

Function Documentation

◆ AdvanceNextFullTransactionIdPastXid()

void AdvanceNextFullTransactionIdPastXid ( TransactionId  xid)

Definition at line 304 of file varsup.c.

305 {
306  FullTransactionId newNextFullXid;
307  TransactionId next_xid;
308  uint32 epoch;
309 
310  /*
311  * It is safe to read nextXid without a lock, because this is only called
312  * from the startup process or single-process mode, meaning that no other
313  * process can modify it.
314  */
316 
317  /* Fast return if this isn't an xid high enough to move the needle. */
319  if (!TransactionIdFollowsOrEquals(xid, next_xid))
320  return;
321 
322  /*
323  * Compute the FullTransactionId that comes after the given xid. To do
324  * this, we preserve the existing epoch, but detect when we've wrapped
325  * into a new epoch. This is necessary because WAL records and 2PC state
326  * currently contain 32 bit xids. The wrap logic is safe in those cases
327  * because the span of active xids cannot exceed one epoch at any given
328  * point in the WAL stream.
329  */
332  if (unlikely(xid < next_xid))
333  ++epoch;
334  newNextFullXid = FullTransactionIdFromEpochAndXid(epoch, xid);
335 
336  /*
337  * We still need to take a lock to modify the value when there are
338  * concurrent readers.
339  */
340  LWLockAcquire(XidGenLock, LW_EXCLUSIVE);
341  TransamVariables->nextXid = newNextFullXid;
342  LWLockRelease(XidGenLock);
343 }
unsigned int uint32
Definition: c.h:495
#define unlikely(x)
Definition: c.h:300
uint32 TransactionId
Definition: c.h:641
bool IsUnderPostmaster
Definition: globals.c:116
Assert(fmt[strlen(fmt) - 1] !='\n')
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1168
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1781
@ LW_EXCLUSIVE
Definition: lwlock.h:116
#define AmStartupProcess()
Definition: miscadmin.h:454
FullTransactionId nextXid
Definition: transam.h:220
bool TransactionIdFollowsOrEquals(TransactionId id1, TransactionId id2)
Definition: transam.c:329
#define EpochFromFullTransactionId(x)
Definition: transam.h:47
#define XidFromFullTransactionId(x)
Definition: transam.h:48
static FullTransactionId FullTransactionIdFromEpochAndXid(uint32 epoch, TransactionId xid)
Definition: transam.h:71
#define TransactionIdAdvance(dest)
Definition: transam.h:91
TransamVariablesData * TransamVariables
Definition: varsup.c:34
static const unsigned __int64 epoch

References AmStartupProcess, Assert(), epoch, EpochFromFullTransactionId, 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)

Definition at line 355 of file varsup.c.

356 {
357  LWLockAcquire(XactTruncationLock, LW_EXCLUSIVE);
359  oldest_datfrozenxid))
360  {
361  TransamVariables->oldestClogXid = oldest_datfrozenxid;
362  }
363  LWLockRelease(XactTruncationLock);
364 }
TransactionId oldestClogXid
Definition: transam.h:253
bool TransactionIdPrecedes(TransactionId id1, TransactionId id2)
Definition: transam.c:280

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

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

◆ ForceTransactionIdLimitUpdate()

bool ForceTransactionIdLimitUpdate ( void  )

Definition at line 517 of file varsup.c.

518 {
519  TransactionId nextXid;
520  TransactionId xidVacLimit;
521  TransactionId oldestXid;
522  Oid oldestXidDB;
523 
524  /* Locking is probably not really necessary, but let's be careful */
525  LWLockAcquire(XidGenLock, LW_SHARED);
527  xidVacLimit = TransamVariables->xidVacLimit;
528  oldestXid = TransamVariables->oldestXid;
529  oldestXidDB = TransamVariables->oldestXidDB;
530  LWLockRelease(XidGenLock);
531 
532  if (!TransactionIdIsNormal(oldestXid))
533  return true; /* shouldn't happen, but just in case */
534  if (!TransactionIdIsValid(xidVacLimit))
535  return true; /* this shouldn't happen anymore either */
536  if (TransactionIdFollowsOrEquals(nextXid, xidVacLimit))
537  return true; /* past xidVacLimit, don't delay updating */
538  if (!SearchSysCacheExists1(DATABASEOID, ObjectIdGetDatum(oldestXidDB)))
539  return true; /* could happen, per comments above */
540  return false;
541 }
@ LW_SHARED
Definition: lwlock.h:117
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:252
unsigned int Oid
Definition: postgres_ext.h:31
TransactionId xidVacLimit
Definition: transam.h:223
TransactionId oldestXid
Definition: transam.h:222
#define SearchSysCacheExists1(cacheId, key1)
Definition: syscache.h:95
#define TransactionIdIsValid(xid)
Definition: transam.h:41

References 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.

129 {
130  dest->value++;
131 
132  /* see FullTransactionIdAdvance() */
134  return;
135 
137  dest->value++;
138 }
#define FirstNormalFullTransactionId
Definition: transam.h:57
#define FullTransactionIdPrecedes(a, b)
Definition: transam.h:51

References generate_unaccent_rules::dest, FirstNormalFullTransactionId, FirstNormalTransactionId, FullTransactionIdPrecedes, and XidFromFullTransactionId.

Referenced by GetNewTransactionId(), and GetSnapshotData().

◆ FullTransactionIdFromEpochAndXid()

static FullTransactionId FullTransactionIdFromEpochAndXid ( uint32  epoch,
TransactionId  xid 
)
inlinestatic

◆ FullTransactionIdFromU64()

static FullTransactionId FullTransactionIdFromU64 ( uint64  value)
inlinestatic

Definition at line 81 of file transam.h.

82 {
83  FullTransactionId result;
84 
85  result.value = value;
86 
87  return result;
88 }
static struct @148 value

References FullTransactionId::value, and value.

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

◆ FullTransactionIdNewer()

static FullTransactionId FullTransactionIdNewer ( FullTransactionId  a,
FullTransactionId  b 
)
inlinestatic

Definition at line 360 of file transam.h.

361 {
363  return b;
364 
366  return a;
367 
369  return a;
370  return b;
371 }
int b
Definition: isn.c:70
int a
Definition: isn.c:69
#define FullTransactionIdFollows(a, b)
Definition: transam.h:53
#define FullTransactionIdIsValid(x)
Definition: transam.h:55

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.

104 {
105  dest->value--;
106 
107  /*
108  * In contrast to 32bit XIDs don't step over the "actual" special xids.
109  * For 64bit xids these can't be reached as part of a wraparound as they
110  * can in the 32bit case.
111  */
113  return;
114 
115  /*
116  * But we do need to step over XIDs that'd appear special only for 32bit
117  * XIDs.
118  */
120  dest->value--;
121 }

References generate_unaccent_rules::dest, FirstNormalFullTransactionId, FirstNormalTransactionId, FullTransactionIdPrecedes, and XidFromFullTransactionId.

Referenced by StartupXLOG().

◆ GetNewObjectId()

Oid GetNewObjectId ( void  )

Definition at line 555 of file varsup.c.

556 {
557  Oid result;
558 
559  /* safety check, we should never get this far in a HS standby */
560  if (RecoveryInProgress())
561  elog(ERROR, "cannot assign OIDs during recovery");
562 
563  LWLockAcquire(OidGenLock, LW_EXCLUSIVE);
564 
565  /*
566  * Check for wraparound of the OID counter. We *must* not return 0
567  * (InvalidOid), and in normal operation we mustn't return anything below
568  * FirstNormalObjectId since that range is reserved for initdb (see
569  * IsCatalogRelationOid()). Note we are relying on unsigned comparison.
570  *
571  * During initdb, we start the OID generator at FirstGenbkiObjectId, so we
572  * only wrap if before that point when in bootstrap or standalone mode.
573  * The first time through this routine after normal postmaster start, the
574  * counter will be forced up to FirstNormalObjectId. This mechanism
575  * leaves the OIDs between FirstGenbkiObjectId and FirstNormalObjectId
576  * available for automatic assignment during initdb, while ensuring they
577  * will never conflict with user-assigned OIDs.
578  */
580  {
582  {
583  /* wraparound, or first post-initdb assignment, in normal mode */
586  }
587  else
588  {
589  /* we may be bootstrapping, so don't enforce the full range */
591  {
592  /* wraparound in standalone mode (unlikely but possible) */
595  }
596  }
597  }
598 
599  /* If we run out of logged for use oids then we must log more */
600  if (TransamVariables->oidCount == 0)
601  {
604  }
605 
606  result = TransamVariables->nextOid;
607 
610 
611  LWLockRelease(OidGenLock);
612 
613  return result;
614 }
#define ERROR
Definition: elog.h:39
bool IsPostmasterEnvironment
Definition: globals.c:115
#define FirstGenbkiObjectId
Definition: transam.h:195
#define FirstNormalObjectId
Definition: transam.h:197
#define VAR_OID_PREFETCH
Definition: varsup.c:31
bool RecoveryInProgress(void)
Definition: xlog.c:6211
void XLogPutNextOid(Oid nextOid)
Definition: xlog.c:7863

References elog(), ERROR, 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)

Definition at line 77 of file varsup.c.

78 {
79  FullTransactionId full_xid;
80  TransactionId xid;
81 
82  /*
83  * Workers synchronize transaction state at the beginning of each parallel
84  * operation, so we can't account for new XIDs after that point.
85  */
86  if (IsInParallelMode())
87  elog(ERROR, "cannot assign TransactionIds during a parallel operation");
88 
89  /*
90  * During bootstrap initialization, we return the special bootstrap
91  * transaction id.
92  */
94  {
95  Assert(!isSubXact);
99  }
100 
101  /* safety check, we should never get this far in a HS standby */
102  if (RecoveryInProgress())
103  elog(ERROR, "cannot assign TransactionIds during recovery");
104 
105  LWLockAcquire(XidGenLock, LW_EXCLUSIVE);
106 
107  full_xid = TransamVariables->nextXid;
108  xid = XidFromFullTransactionId(full_xid);
109 
110  /*----------
111  * Check to see if it's safe to assign another XID. This protects against
112  * catastrophic data loss due to XID wraparound. The basic rules are:
113  *
114  * If we're past xidVacLimit, start trying to force autovacuum cycles.
115  * If we're past xidWarnLimit, start issuing warnings.
116  * If we're past xidStopLimit, refuse to execute transactions, unless
117  * we are running in single-user mode (which gives an escape hatch
118  * to the DBA who somehow got past the earlier defenses).
119  *
120  * Note that this coding also appears in GetNewMultiXactId.
121  *----------
122  */
124  {
125  /*
126  * For safety's sake, we release XidGenLock while sending signals,
127  * warnings, etc. This is not so much because we care about
128  * preserving concurrency in this situation, as to avoid any
129  * possibility of deadlock while doing get_database_name(). First,
130  * copy all the shared values we'll need in this path.
131  */
135  Oid oldest_datoid = TransamVariables->oldestXidDB;
136 
137  LWLockRelease(XidGenLock);
138 
139  /*
140  * To avoid swamping the postmaster with signals, we issue the autovac
141  * request only once per 64K transaction starts. This still gives
142  * plenty of chances before we get into real trouble.
143  */
144  if (IsUnderPostmaster && (xid % 65536) == 0)
146 
147  if (IsUnderPostmaster &&
148  TransactionIdFollowsOrEquals(xid, xidStopLimit))
149  {
150  char *oldest_datname = get_database_name(oldest_datoid);
151 
152  /* complain even if that DB has disappeared */
153  if (oldest_datname)
154  ereport(ERROR,
155  (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
156  errmsg("database is not accepting commands that assign new XIDs to avoid wraparound data loss in database \"%s\"",
157  oldest_datname),
158  errhint("Execute a database-wide VACUUM in that database.\n"
159  "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
160  else
161  ereport(ERROR,
162  (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
163  errmsg("database is not accepting commands that assign new XIDs to avoid wraparound data loss in database with OID %u",
164  oldest_datoid),
165  errhint("Execute a database-wide VACUUM in that database.\n"
166  "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
167  }
168  else if (TransactionIdFollowsOrEquals(xid, xidWarnLimit))
169  {
170  char *oldest_datname = get_database_name(oldest_datoid);
171 
172  /* complain even if that DB has disappeared */
173  if (oldest_datname)
175  (errmsg("database \"%s\" must be vacuumed within %u transactions",
176  oldest_datname,
177  xidWrapLimit - xid),
178  errhint("To avoid XID assignment failures, execute a database-wide VACUUM in that database.\n"
179  "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
180  else
182  (errmsg("database with OID %u must be vacuumed within %u transactions",
183  oldest_datoid,
184  xidWrapLimit - xid),
185  errhint("To avoid XID assignment failures, execute a database-wide VACUUM in that database.\n"
186  "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
187  }
188 
189  /* Re-acquire lock and start over */
190  LWLockAcquire(XidGenLock, LW_EXCLUSIVE);
191  full_xid = TransamVariables->nextXid;
192  xid = XidFromFullTransactionId(full_xid);
193  }
194 
195  /*
196  * If we are allocating the first XID of a new page of the commit log,
197  * zero out that commit-log page before returning. We must do this while
198  * holding XidGenLock, else another xact could acquire and commit a later
199  * XID before we zero the page. Fortunately, a page of the commit log
200  * holds 32K or more transactions, so we don't have to do this very often.
201  *
202  * Extend pg_subtrans and pg_commit_ts too.
203  */
204  ExtendCLOG(xid);
205  ExtendCommitTs(xid);
206  ExtendSUBTRANS(xid);
207 
208  /*
209  * Now advance the nextXid counter. This must not happen until after we
210  * have successfully completed ExtendCLOG() --- if that routine fails, we
211  * want the next incoming transaction to try it again. We cannot assign
212  * more XIDs until there is CLOG space for them.
213  */
215 
216  /*
217  * We must store the new XID into the shared ProcArray before releasing
218  * XidGenLock. This ensures that every active XID older than
219  * latestCompletedXid is present in the ProcArray, which is essential for
220  * correct OldestXmin tracking; see src/backend/access/transam/README.
221  *
222  * Note that readers of ProcGlobal->xids/PGPROC->xid should be careful to
223  * fetch the value for each proc only once, rather than assume they can
224  * read a value multiple times and get the same answer each time. Note we
225  * are assuming that TransactionId and int fetch/store are atomic.
226  *
227  * The same comments apply to the subxact xid count and overflow fields.
228  *
229  * Use of a write barrier prevents dangerous code rearrangement in this
230  * function; other backends could otherwise e.g. be examining my subxids
231  * info concurrently, and we don't want them to see an invalid
232  * intermediate state, such as an incremented nxids before the array entry
233  * is filled.
234  *
235  * Other processes that read nxids should do so before reading xids
236  * elements with a pg_read_barrier() in between, so that they can be sure
237  * not to read an uninitialized array element; see
238  * src/backend/storage/lmgr/README.barrier.
239  *
240  * If there's no room to fit a subtransaction XID into PGPROC, set the
241  * cache-overflowed flag instead. This forces readers to look in
242  * pg_subtrans to map subtransaction XIDs up to top-level XIDs. There is a
243  * race-condition window, in that the new XID will not appear as running
244  * until its parent link has been placed into pg_subtrans. However, that
245  * will happen before anyone could possibly have a reason to inquire about
246  * the status of the XID, so it seems OK. (Snapshots taken during this
247  * window *will* include the parent XID, so they will deliver the correct
248  * answer later on when someone does have a reason to inquire.)
249  */
250  if (!isSubXact)
251  {
256 
257  /* LWLockRelease acts as barrier */
258  MyProc->xid = xid;
259  ProcGlobal->xids[MyProc->pgxactoff] = xid;
260  }
261  else
262  {
264  int nxids = MyProc->subxidStatus.count;
265 
266  Assert(substat->count == MyProc->subxidStatus.count);
268 
269  if (nxids < PGPROC_MAX_CACHED_SUBXIDS)
270  {
271  MyProc->subxids.xids[nxids] = xid;
273  MyProc->subxidStatus.count = substat->count = nxids + 1;
274  }
275  else
276  MyProc->subxidStatus.overflowed = substat->overflowed = true;
277  }
278 
279  LWLockRelease(XidGenLock);
280 
281  return full_xid;
282 }
#define pg_write_barrier()
Definition: atomics.h:154
void ExtendCLOG(TransactionId newestXact)
Definition: clog.c:845
void ExtendCommitTs(TransactionId newestXact)
Definition: commit_ts.c:804
char * get_database_name(Oid dbid)
Definition: dbcommands.c:3089
int errhint(const char *fmt,...)
Definition: elog.c:1322
int errcode(int sqlerrcode)
Definition: elog.c:860
int errmsg(const char *fmt,...)
Definition: elog.c:1075
#define WARNING
Definition: elog.h:36
#define ereport(elevel,...)
Definition: elog.h:149
#define IsBootstrapProcessingMode()
Definition: miscadmin.h:415
void SendPostmasterSignal(PMSignalReason reason)
Definition: pmsignal.c:181
@ PMSIGNAL_START_AUTOVAC_LAUNCHER
Definition: pmsignal.h:38
#define PGPROC_MAX_CACHED_SUBXIDS
Definition: proc.h:38
PGPROC * MyProc
Definition: proc.c:67
PROC_HDR * ProcGlobal
Definition: proc.c:79
int pgxactoff
Definition: proc.h:188
XidCacheStatus subxidStatus
Definition: proc.h:254
TransactionId xid
Definition: proc.h:173
struct XidCache subxids
Definition: proc.h:256
XidCacheStatus * subxidStates
Definition: proc.h:371
TransactionId * xids
Definition: proc.h:365
TransactionId xidStopLimit
Definition: transam.h:225
TransactionId xidWarnLimit
Definition: transam.h:224
TransactionId xidWrapLimit
Definition: transam.h:226
bool overflowed
Definition: proc.h:45
uint8 count
Definition: proc.h:43
TransactionId xids[PGPROC_MAX_CACHED_SUBXIDS]
Definition: proc.h:50
void ExtendSUBTRANS(TransactionId newestXact)
Definition: subtrans.c:318
#define BootstrapTransactionId
Definition: transam.h:32
static void FullTransactionIdAdvance(FullTransactionId *dest)
Definition: transam.h:128
bool IsInParallelMode(void)
Definition: xact.c:1069

References Assert(), BootstrapTransactionId, XidCacheStatus::count, elog(), ereport, errcode(), errhint(), errmsg(), ERROR, ExtendCLOG(), ExtendCommitTs(), ExtendSUBTRANS(), 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 349 of file transam.h.

350 {
354  return a;
355  return b;
356 }
#define NormalTransactionIdPrecedes(id1, id2)
Definition: transam.h:147

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

◆ ReadNextFullTransactionId()

◆ ReadNextTransactionId()

◆ SetTransactionIdLimit()

void SetTransactionIdLimit ( TransactionId  oldest_datfrozenxid,
Oid  oldest_datoid 
)

Definition at line 372 of file varsup.c.

373 {
374  TransactionId xidVacLimit;
375  TransactionId xidWarnLimit;
376  TransactionId xidStopLimit;
377  TransactionId xidWrapLimit;
378  TransactionId curXid;
379 
380  Assert(TransactionIdIsNormal(oldest_datfrozenxid));
381 
382  /*
383  * The place where we actually get into deep trouble is halfway around
384  * from the oldest potentially-existing XID. (This calculation is
385  * probably off by one or two counts, because the special XIDs reduce the
386  * size of the loop a little bit. But we throw in plenty of slop below,
387  * so it doesn't matter.)
388  */
389  xidWrapLimit = oldest_datfrozenxid + (MaxTransactionId >> 1);
390  if (xidWrapLimit < FirstNormalTransactionId)
391  xidWrapLimit += FirstNormalTransactionId;
392 
393  /*
394  * We'll refuse to continue assigning XIDs in interactive mode once we get
395  * within 3M transactions of data loss. This leaves lots of room for the
396  * DBA to fool around fixing things in a standalone backend, while not
397  * being significant compared to total XID space. (VACUUM requires an XID
398  * if it truncates at wal_level!=minimal. "VACUUM (ANALYZE)", which a DBA
399  * might do by reflex, assigns an XID. Hence, we had better be sure
400  * there's lots of XIDs left...) Also, at default BLCKSZ, this leaves two
401  * completely-idle segments. In the event of edge-case bugs involving
402  * page or segment arithmetic, idle segments render the bugs unreachable
403  * outside of single-user mode.
404  */
405  xidStopLimit = xidWrapLimit - 3000000;
406  if (xidStopLimit < FirstNormalTransactionId)
407  xidStopLimit -= FirstNormalTransactionId;
408 
409  /*
410  * We'll start complaining loudly when we get within 40M transactions of
411  * data loss. This is kind of arbitrary, but if you let your gas gauge
412  * get down to 2% of full, would you be looking for the next gas station?
413  * We need to be fairly liberal about this number because there are lots
414  * of scenarios where most transactions are done by automatic clients that
415  * won't pay attention to warnings. (No, we're not gonna make this
416  * configurable. If you know enough to configure it, you know enough to
417  * not get in this kind of trouble in the first place.)
418  */
419  xidWarnLimit = xidWrapLimit - 40000000;
420  if (xidWarnLimit < FirstNormalTransactionId)
421  xidWarnLimit -= FirstNormalTransactionId;
422 
423  /*
424  * We'll start trying to force autovacuums when oldest_datfrozenxid gets
425  * to be more than autovacuum_freeze_max_age transactions old.
426  *
427  * Note: guc.c ensures that autovacuum_freeze_max_age is in a sane range,
428  * so that xidVacLimit will be well before xidWarnLimit.
429  *
430  * Note: autovacuum_freeze_max_age is a PGC_POSTMASTER parameter so that
431  * we don't have to worry about dealing with on-the-fly changes in its
432  * value. It doesn't look practical to update shared state from a GUC
433  * assign hook (too many processes would try to execute the hook,
434  * resulting in race conditions as well as crashes of those not connected
435  * to shared memory). Perhaps this can be improved someday. See also
436  * SetMultiXactIdLimit.
437  */
438  xidVacLimit = oldest_datfrozenxid + autovacuum_freeze_max_age;
439  if (xidVacLimit < FirstNormalTransactionId)
440  xidVacLimit += FirstNormalTransactionId;
441 
442  /* Grab lock for just long enough to set the new limit values */
443  LWLockAcquire(XidGenLock, LW_EXCLUSIVE);
444  TransamVariables->oldestXid = oldest_datfrozenxid;
445  TransamVariables->xidVacLimit = xidVacLimit;
446  TransamVariables->xidWarnLimit = xidWarnLimit;
447  TransamVariables->xidStopLimit = xidStopLimit;
448  TransamVariables->xidWrapLimit = xidWrapLimit;
449  TransamVariables->oldestXidDB = oldest_datoid;
451  LWLockRelease(XidGenLock);
452 
453  /* Log the info */
454  ereport(DEBUG1,
455  (errmsg_internal("transaction ID wrap limit is %u, limited by database with OID %u",
456  xidWrapLimit, oldest_datoid)));
457 
458  /*
459  * If past the autovacuum force point, immediately signal an autovac
460  * request. The reason for this is that autovac only processes one
461  * database per invocation. Once it's finished cleaning up the oldest
462  * database, it'll call here, and we'll signal the postmaster to start
463  * another iteration immediately if there are still any old databases.
464  */
465  if (TransactionIdFollowsOrEquals(curXid, xidVacLimit) &&
468 
469  /* Give an immediate warning if past the wrap warn point */
470  if (TransactionIdFollowsOrEquals(curXid, xidWarnLimit) && !InRecovery)
471  {
472  char *oldest_datname;
473 
474  /*
475  * We can be called when not inside a transaction, for example during
476  * StartupXLOG(). In such a case we cannot do database access, so we
477  * must just report the oldest DB's OID.
478  *
479  * Note: it's also possible that get_database_name fails and returns
480  * NULL, for example because the database just got dropped. We'll
481  * still warn, even though the warning might now be unnecessary.
482  */
483  if (IsTransactionState())
484  oldest_datname = get_database_name(oldest_datoid);
485  else
486  oldest_datname = NULL;
487 
488  if (oldest_datname)
490  (errmsg("database \"%s\" must be vacuumed within %u transactions",
491  oldest_datname,
492  xidWrapLimit - curXid),
493  errhint("To avoid XID assignment failures, execute a database-wide VACUUM in that database.\n"
494  "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
495  else
497  (errmsg("database with OID %u must be vacuumed within %u transactions",
498  oldest_datoid,
499  xidWrapLimit - curXid),
500  errhint("To avoid XID assignment failures, execute a database-wide VACUUM in that database.\n"
501  "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
502  }
503 }
int autovacuum_freeze_max_age
Definition: autovacuum.c:127
int errmsg_internal(const char *fmt,...)
Definition: elog.c:1162
#define DEBUG1
Definition: elog.h:30
#define MaxTransactionId
Definition: transam.h:35
bool IsTransactionState(void)
Definition: xact.c:378
bool InRecovery
Definition: xlogutils.c:53

References Assert(), autovacuum_freeze_max_age, DEBUG1, ereport, errhint(), errmsg(), errmsg_internal(), 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  )

Definition at line 652 of file varsup.c.

653 {
655 }
#define FirstUnpinnedObjectId
Definition: transam.h:196
static void SetNextObjectId(Oid nextOid)
Definition: varsup.c:623

References FirstUnpinnedObjectId, and SetNextObjectId().

Referenced by pg_stop_making_pinned_objects().

◆ TransactionIdAbortTree()

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

Definition at line 270 of file transam.c.

271 {
272  TransactionIdSetTreeStatus(xid, nxids, xids,
274 }
void TransactionIdSetTreeStatus(TransactionId xid, int nsubxids, TransactionId *subxids, XidStatus status, XLogRecPtr lsn)
Definition: clog.c:172
#define TRANSACTION_STATUS_ABORTED
Definition: clog.h:29
#define InvalidXLogRecPtr
Definition: xlogdefs.h:28

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

Definition at line 252 of file transam.c.

254 {
255  TransactionIdSetTreeStatus(xid, nxids, xids,
257 }
#define TRANSACTION_STATUS_COMMITTED
Definition: clog.h:28

References TRANSACTION_STATUS_COMMITTED, and TransactionIdSetTreeStatus().

Referenced by RecordTransactionCommit(), and xact_redo_commit().

◆ TransactionIdCommitTree()

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

◆ TransactionIdDidAbort()

bool TransactionIdDidAbort ( TransactionId  transactionId)

Definition at line 188 of file transam.c.

189 {
190  XidStatus xidstatus;
191 
192  xidstatus = TransactionLogFetch(transactionId);
193 
194  /*
195  * If it's marked aborted, it's aborted.
196  */
197  if (xidstatus == TRANSACTION_STATUS_ABORTED)
198  return true;
199 
200  /*
201  * If it's marked subcommitted, we have to check the parent recursively.
202  * However, if it's older than TransactionXmin, we can't look at
203  * pg_subtrans; instead assume that the parent crashed without cleaning up
204  * its children.
205  */
206  if (xidstatus == TRANSACTION_STATUS_SUB_COMMITTED)
207  {
208  TransactionId parentXid;
209 
210  if (TransactionIdPrecedes(transactionId, TransactionXmin))
211  return true;
212  parentXid = SubTransGetParent(transactionId);
213  if (!TransactionIdIsValid(parentXid))
214  {
215  /* see notes in TransactionIdDidCommit */
216  elog(WARNING, "no pg_subtrans entry for subcommitted XID %u",
217  transactionId);
218  return true;
219  }
220  return TransactionIdDidAbort(parentXid);
221  }
222 
223  /*
224  * It's not aborted.
225  */
226  return false;
227 }
int XidStatus
Definition: clog.h:25
#define TRANSACTION_STATUS_SUB_COMMITTED
Definition: clog.h:30
TransactionId TransactionXmin
Definition: snapmgr.c:105
TransactionId SubTransGetParent(TransactionId xid)
Definition: subtrans.c:118
static XidStatus TransactionLogFetch(TransactionId transactionId)
Definition: transam.c:52
bool TransactionIdDidAbort(TransactionId transactionId)
Definition: transam.c:188

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

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

◆ TransactionIdDidCommit()

bool TransactionIdDidCommit ( TransactionId  transactionId)

Definition at line 126 of file transam.c.

127 {
128  XidStatus xidstatus;
129 
130  xidstatus = TransactionLogFetch(transactionId);
131 
132  /*
133  * If it's marked committed, it's committed.
134  */
135  if (xidstatus == TRANSACTION_STATUS_COMMITTED)
136  return true;
137 
138  /*
139  * If it's marked subcommitted, we have to check the parent recursively.
140  * However, if it's older than TransactionXmin, we can't look at
141  * pg_subtrans; instead assume that the parent crashed without cleaning up
142  * its children.
143  *
144  * Originally we Assert'ed that the result of SubTransGetParent was not
145  * zero. However with the introduction of prepared transactions, there can
146  * be a window just after database startup where we do not have complete
147  * knowledge in pg_subtrans of the transactions after TransactionXmin.
148  * StartupSUBTRANS() has ensured that any missing information will be
149  * zeroed. Since this case should not happen under normal conditions, it
150  * seems reasonable to emit a WARNING for it.
151  */
152  if (xidstatus == TRANSACTION_STATUS_SUB_COMMITTED)
153  {
154  TransactionId parentXid;
155 
156  if (TransactionIdPrecedes(transactionId, TransactionXmin))
157  return false;
158  parentXid = SubTransGetParent(transactionId);
159  if (!TransactionIdIsValid(parentXid))
160  {
161  elog(WARNING, "no pg_subtrans entry for subcommitted XID %u",
162  transactionId);
163  return false;
164  }
165  return TransactionIdDidCommit(parentXid);
166  }
167 
168  /*
169  * It's not committed.
170  */
171  return false;
172 }
bool TransactionIdDidCommit(TransactionId transactionId)
Definition: transam.c:126

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

Referenced by asyncQueueProcessPageEntries(), check_safe_enum_use(), compute_new_xmax_infomask(), FreezeMultiXactId(), HandleConcurrentAbort(), heap_freeze_execute_prepared(), HeapTupleHeaderAdvanceConflictHorizon(), HeapTupleHeaderIsOnlyLocked(), HeapTupleSatisfiesDirty(), HeapTupleSatisfiesHistoricMVCC(), HeapTupleSatisfiesMVCC(), HeapTupleSatisfiesSelf(), HeapTupleSatisfiesToast(), HeapTupleSatisfiesUpdate(), HeapTupleSatisfiesVacuumHorizon(), MultiXactIdExpand(), pg_xact_status(), ProcArrayApplyRecoveryInfo(), ProcessTwoPhaseBuffer(), RecordTransactionAbort(), RecordTransactionAbortPrepared(), SetupCheckXidLive(), StandbyAcquireAccessExclusiveLock(), test_lockmode_for_conflict(), UpdateLogicalMappings(), and UpdateXmaxHintBits().

◆ TransactionIdFollows()

◆ TransactionIdFollowsOrEquals()

◆ TransactionIdGetCommitLSN()

XLogRecPtr TransactionIdGetCommitLSN ( TransactionId  xid)

Definition at line 382 of file transam.c.

383 {
384  XLogRecPtr result;
385 
386  /*
387  * Currently, all uses of this function are for xids that were just
388  * reported to be committed by TransactionLogFetch, so we expect that
389  * checking TransactionLogFetch's cache will usually succeed and avoid an
390  * extra trip to shared memory.
391  */
393  return cachedCommitLSN;
394 
395  /* Special XIDs are always known committed */
396  if (!TransactionIdIsNormal(xid))
397  return InvalidXLogRecPtr;
398 
399  /*
400  * Get the transaction status.
401  */
402  (void) TransactionIdGetStatus(xid, &result);
403 
404  return result;
405 }
XidStatus TransactionIdGetStatus(TransactionId xid, XLogRecPtr *lsn)
Definition: clog.c:648
static TransactionId cachedFetchXid
Definition: transam.c:33
static XLogRecPtr cachedCommitLSN
Definition: transam.c:35
#define TransactionIdEquals(id1, id2)
Definition: transam.h:43
uint64 XLogRecPtr
Definition: xlogdefs.h:21

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

Referenced by SetHintBits().

◆ TransactionIdLatest()

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

Definition at line 345 of file transam.c.

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

References 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 334 of file transam.h.

335 {
336  if (!TransactionIdIsValid(a))
337  return b;
338 
339  if (!TransactionIdIsValid(b))
340  return a;
341 
342  if (TransactionIdPrecedes(a, b))
343  return a;
344  return b;
345 }
bool TransactionIdPrecedes(TransactionId id1, TransactionId id2)
Definition: transam.c:280

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

Referenced by ComputeXidHorizons(), and GetSnapshotData().

◆ TransactionIdPrecedes()

bool TransactionIdPrecedes ( TransactionId  id1,
TransactionId  id2 
)

Definition at line 280 of file transam.c.

281 {
282  /*
283  * If either ID is a permanent XID then we can just do unsigned
284  * comparison. If both are normal, do a modulo-2^32 comparison.
285  */
286  int32 diff;
287 
288  if (!TransactionIdIsNormal(id1) || !TransactionIdIsNormal(id2))
289  return (id1 < id2);
290 
291  diff = (int32) (id1 - id2);
292  return (diff < 0);
293 }

References TransactionIdIsNormal.

Referenced by AdvanceOldestClogXid(), AdvanceOldestCommitTsXid(), bt_check_every_level(), check_exclusion_or_unique_constraint(), check_tuple_visibility(), CheckTargetForConflictsIn(), CLOGPagePrecedes(), collect_corrupt_items(), CommitTsPagePrecedes(), copy_table_data(), do_start_worker(), ExpireOldKnownAssignedTransactionIds(), ExportSnapshot(), FreezeMultiXactId(), get_relation_info(), GetOldestActiveTransactionId(), GetOldestSafeDecodingTransactionId(), GetRunningTransactionData(), heap_abort_speculative(), heap_page_is_all_visible(), heap_prepare_freeze_tuple(), heap_prune_record_prunable(), heap_tuple_should_freeze(), HeapCheckForSerializableConflictOut(), HeapTupleHeaderAdvanceConflictHorizon(), HeapTupleSatisfiesHistoricMVCC(), HeapTupleSatisfiesVacuum(), KnownAssignedXidsAdd(), KnownAssignedXidsGetAndSetXmin(), KnownAssignedXidsSearch(), lazy_scan_prune(), logical_rewrite_heap_tuple(), MaintainLatestCompletedXid(), MaintainLatestCompletedXidRecovery(), multixact_redo(), PhysicalReplicationSlotNewXmin(), PrescanPreparedTransactions(), ProcArrayApplyRecoveryInfo(), ProcArrayApplyXidAssignment(), ProcessStandbyHSFeedbackMessage(), RecordKnownAssignedTransactionIds(), relation_needs_vacanalyze(), ReorderBufferAbortOld(), ReplicationSlotsComputeRequiredXmin(), rewrite_heap_tuple(), SerialGetMinConflictCommitSeqNo(), SerialPagePrecedesLogically(), SerialSetActiveSerXmin(), SetCommitTsLimit(), SetNewSxactGlobalXmin(), SnapBuildCommitTxn(), SnapBuildProcessChange(), SnapBuildRestore(), SnapshotResetXmin(), StandbyReleaseOldLocks(), SubTransGetTopmostTransaction(), SubTransPagePrecedes(), TransactionIdDidAbort(), TransactionIdDidCommit(), TransactionIdGetCommitTsData(), TransactionIdIsActive(), TransactionIdIsCurrentTransactionId(), TransactionIdIsInProgress(), TransactionIdLatest(), TransactionIdOlder(), TransactionTreeSetCommitTsData(), tuple_all_visible(), update_and_persist_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()

◆ TransactionIdRetreatedBy()

static TransactionId TransactionIdRetreatedBy ( TransactionId  xid,
uint32  amount 
)
inlinestatic

Definition at line 322 of file transam.h.

323 {
324  xid -= amount;
325 
326  while (xid < FirstNormalTransactionId)
327  xid--;
328 
329  return xid;
330 }

References FirstNormalTransactionId.

◆ TransactionStartedDuringRecovery()

bool TransactionStartedDuringRecovery ( void  )

Definition at line 1027 of file xact.c.

1028 {
1030 }
bool startedInRecovery
Definition: xact.c:207
static TransactionState CurrentTransactionState
Definition: xact.c:254

References CurrentTransactionState, and TransactionStateData::startedInRecovery.

Referenced by RelationGetIndexScan().

◆ VarsupShmemInit()

void VarsupShmemInit ( void  )

Definition at line 47 of file varsup.c.

48 {
49  bool found;
50 
51  /* Initialize our shared state struct */
52  TransamVariables = ShmemInitStruct("TransamVariables",
53  sizeof(TransamVariablesData),
54  &found);
55  if (!IsUnderPostmaster)
56  {
57  Assert(!found);
58  memset(TransamVariables, 0, sizeof(TransamVariablesData));
59  }
60  else
61  Assert(found);
62 }
void * ShmemInitStruct(const char *name, Size size, bool *foundPtr)
Definition: shmem.c:388

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

Referenced by CreateOrAttachShmemStructs().

◆ VarsupShmemSize()

Size VarsupShmemSize ( void  )

Definition at line 41 of file varsup.c.

42 {
43  return sizeof(TransamVariablesData);
44 }
struct TransamVariablesData TransamVariablesData

Referenced by CalculateShmemSize().

Variable Documentation

◆ TransamVariables