PostgreSQL Source Code git master
Macros | Functions | Variables
varsup.c File Reference
#include "postgres.h"
#include "access/clog.h"
#include "access/commit_ts.h"
#include "access/subtrans.h"
#include "access/transam.h"
#include "access/xact.h"
#include "access/xlogutils.h"
#include "miscadmin.h"
#include "postmaster/autovacuum.h"
#include "storage/pmsignal.h"
#include "storage/proc.h"
#include "utils/lsyscache.h"
#include "utils/syscache.h"
Include dependency graph for varsup.c:

Go to the source code of this file.

Macros

#define  VAR_OID_PREFETCH   8192
 

Functions

Size  VarsupShmemSize (void)
 
void  VarsupShmemInit (void)
 
FullTransactionId  GetNewTransactionId (bool isSubXact)
 
FullTransactionId  ReadNextFullTransactionId (void)
 
void  AdvanceNextFullTransactionIdPastXid (TransactionId xid)
 
void  AdvanceOldestClogXid (TransactionId oldest_datfrozenxid)
 
void  SetTransactionIdLimit (TransactionId oldest_datfrozenxid, Oid oldest_datoid)
 
bool  ForceTransactionIdLimitUpdate (void)
 
Oid  GetNewObjectId (void)
 
static void  SetNextObjectId (Oid nextOid)
 
void  StopGeneratingPinnedObjectIds (void)
 

Variables

TransamVariablesData *  TransamVariables = NULL
 

Macro Definition Documentation

◆ VAR_OID_PREFETCH

#define VAR_OID_PREFETCH   8192

Definition at line 31 of file varsup.c.

Function Documentation

◆ AdvanceNextFullTransactionIdPastXid()

void AdvanceNextFullTransactionIdPastXid ( TransactionId  xid )

Definition at line 304 of file varsup.c.

305{
306 FullTransactionId newNextFullXid;
307 TransactionId next_xid;
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}
#define unlikely(x)
Definition: c.h:402
uint32_t uint32
Definition: c.h:538
uint32 TransactionId
Definition: c.h:657
bool IsUnderPostmaster
Definition: globals.c:120
Assert(PointerIsAligned(start, uint64))
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1174
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1894
@ LW_EXCLUSIVE
Definition: lwlock.h:112
#define AmStartupProcess()
Definition: miscadmin.h:389
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:113
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:262
unsigned int Oid
Definition: postgres_ext.h:32
TransactionId xidVacLimit
Definition: transam.h:223
TransactionId oldestXid
Definition: transam.h:222
#define SearchSysCacheExists1(cacheId, key1)
Definition: syscache.h:100
#define TransactionIdIsValid(xid)
Definition: transam.h:41
#define TransactionIdIsNormal(xid)
Definition: transam.h:42

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().

◆ 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
#define elog(elevel,...)
Definition: elog.h:226
bool IsPostmasterEnvironment
Definition: globals.c:119
uint32 oidCount
Definition: transam.h:215
#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:6386
void XLogPutNextOid(Oid nextOid)
Definition: xlog.c:8073

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)
155 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
156 errmsg("database is not accepting commands that assign new transaction IDs 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
162 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
163 errmsg("database is not accepting commands that assign new transaction IDs 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 transaction ID 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;
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:155
void ExtendCLOG(TransactionId newestXact)
Definition: clog.c:924
void ExtendCommitTs(TransactionId newestXact)
Definition: commit_ts.c:816
int errhint(const char *fmt,...)
Definition: elog.c:1321
int errcode(int sqlerrcode)
Definition: elog.c:854
int errmsg(const char *fmt,...)
Definition: elog.c:1071
#define WARNING
Definition: elog.h:36
#define ereport(elevel,...)
Definition: elog.h:150
char * get_database_name(Oid dbid)
Definition: lsyscache.c:1259
#define IsBootstrapProcessingMode()
Definition: miscadmin.h:476
void SendPostmasterSignal(PMSignalReason reason)
Definition: pmsignal.c:165
@ PMSIGNAL_START_AUTOVAC_LAUNCHER
Definition: pmsignal.h:39
#define PGPROC_MAX_CACHED_SUBXIDS
Definition: proc.h:39
PGPROC * MyProc
Definition: proc.c:66
PROC_HDR * ProcGlobal
Definition: proc.c:78
int pgxactoff
Definition: proc.h:201
XidCacheStatus subxidStatus
Definition: proc.h:280
TransactionId xid
Definition: proc.h:189
struct XidCache subxids
Definition: proc.h:282
XidCacheStatus * subxidStates
Definition: proc.h:397
TransactionId * xids
Definition: proc.h:391
TransactionId xidStopLimit
Definition: transam.h:225
TransactionId xidWarnLimit
Definition: transam.h:224
TransactionId xidWrapLimit
Definition: transam.h:226
bool overflowed
Definition: proc.h:46
uint8 count
Definition: proc.h:44
TransactionId xids[PGPROC_MAX_CACHED_SUBXIDS]
Definition: proc.h:51
void ExtendSUBTRANS(TransactionId newestXact)
Definition: subtrans.c:353
#define BootstrapTransactionId
Definition: transam.h:32
static void FullTransactionIdAdvance(FullTransactionId *dest)
Definition: transam.h:128
bool IsInParallelMode(void)
Definition: xact.c:1089

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().

◆ ReadNextFullTransactionId()

FullTransactionId ReadNextFullTransactionId ( void  )

Definition at line 288 of file varsup.c.

289{
290 FullTransactionId fullXid;
291
292 LWLockAcquire(XidGenLock, LW_SHARED);
293 fullXid = TransamVariables->nextXid;
294 LWLockRelease(XidGenLock);
295
296 return fullXid;
297}

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

◆ SetNextObjectId()

static void SetNextObjectId ( Oid  nextOid )
static

Definition at line 623 of file varsup.c.

624{
625 /* Safety check, this is only allowable during initdb */
627 elog(ERROR, "cannot advance OID counter anymore");
628
629 /* Taking the lock is, therefore, just pro forma; but do it anyway */
630 LWLockAcquire(OidGenLock, LW_EXCLUSIVE);
631
632 if (TransamVariables->nextOid > nextOid)
633 elog(ERROR, "too late to advance OID counter to %u, it is now %u",
634 nextOid, TransamVariables->nextOid);
635
636 TransamVariables->nextOid = nextOid;
638
639 LWLockRelease(OidGenLock);
640}

References elog, ERROR, IsPostmasterEnvironment, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), TransamVariablesData::nextOid, TransamVariablesData::oidCount, and TransamVariables.

Referenced by StopGeneratingPinnedObjectIds().

◆ 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 */
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:129
int errmsg_internal(const char *fmt,...)
Definition: elog.c:1161
#define DEBUG1
Definition: elog.h:30
#define FirstNormalTransactionId
Definition: transam.h:34
#define MaxTransactionId
Definition: transam.h:35
bool IsTransactionState(void)
Definition: xact.c:387
bool InRecovery
Definition: xlogutils.c:50

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().

◆ 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",
54 &found);
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:387

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

TransamVariablesData* TransamVariables = NULL

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().

AltStyle によって変換されたページ (->オリジナル) /