typedef struct HeapCheckContext
{
/*
- * Cached copies of values from ShmemVariableCache and computed values
- * from them.
+ * Cached copies of values from TransamVariables and computed values from
+ * them.
*/
- FullTransactionId next_fxid; /* ShmemVariableCache->nextXid */
+ FullTransactionId next_fxid; /* TransamVariables->nextXid */
TransactionId next_xid; /* 32-bit version of next_fxid */
- TransactionId oldest_xid; /* ShmemVariableCache->oldestXid */
+ TransactionId oldest_xid; /* TransamVariables->oldestXid */
FullTransactionId oldest_fxid; /* 64-bit version of oldest_xid, computed
* relative to next_fxid */
TransactionId safe_xmin; /* this XID and newer ones can't become
{
/* Make cached copies */
LWLockAcquire(XidGenLock, LW_SHARED);
- ctx->next_fxid = ShmemVariableCache->nextXid;
- ctx->oldest_xid = ShmemVariableCache->oldestXid;
+ ctx->next_fxid = TransamVariables->nextXid;
+ ctx->oldest_xid = TransamVariables->oldestXid;
LWLockRelease(XidGenLock);
/* And compute alternate versions of the same */
*status = XID_COMMITTED;
LWLockAcquire(XactTruncationLock, LW_SHARED);
clog_horizon =
- FullTransactionIdFromXidAndCtx(ShmemVariableCache->oldestClogXid,
+ FullTransactionIdFromXidAndCtx(TransamVariables->oldestClogXid,
ctx);
if (FullTransactionIdPrecedesOrEquals(clog_horizon, fxid))
{
/*
* This must be called ONCE during postmaster or standalone-backend startup,
- * after StartupXLOG has initialized ShmemVariableCache->nextXid.
+ * after StartupXLOG has initialized TransamVariables->nextXid.
*/
void
StartupCLOG(void)
{
- TransactionId xid = XidFromFullTransactionId(ShmemVariableCache->nextXid);
+ TransactionId xid = XidFromFullTransactionId(TransamVariables->nextXid);
int64 pageno = TransactionIdToPage(xid);
LWLockAcquire(XactSLRULock, LW_EXCLUSIVE);
void
TrimCLOG(void)
{
- TransactionId xid = XidFromFullTransactionId(ShmemVariableCache->nextXid);
+ TransactionId xid = XidFromFullTransactionId(TransamVariables->nextXid);
int64 pageno = TransactionIdToPage(xid);
LWLockAcquire(XactSLRULock, LW_EXCLUSIVE);
commitTsShared->dataLastCommit.nodeid = nodeid;
/* and move forwards our endpoint, if needed */
- if (TransactionIdPrecedes(ShmemVariableCache->newestCommitTsXid, newestXact))
- ShmemVariableCache->newestCommitTsXid = newestXact;
+ if (TransactionIdPrecedes(TransamVariables->newestCommitTsXid, newestXact))
+ TransamVariables->newestCommitTsXid = newestXact;
LWLockRelease(CommitTsLock);
}
return *ts != 0;
}
- oldestCommitTsXid = ShmemVariableCache->oldestCommitTsXid;
- newestCommitTsXid = ShmemVariableCache->newestCommitTsXid;
+ oldestCommitTsXid = TransamVariables->oldestCommitTsXid;
+ newestCommitTsXid = TransamVariables->newestCommitTsXid;
/* neither is invalid, or both are */
Assert(TransactionIdIsValid(oldestCommitTsXid) == TransactionIdIsValid(newestCommitTsXid));
LWLockRelease(CommitTsLock);
/*
* This must be called ONCE during postmaster or standalone-backend startup,
- * after StartupXLOG has initialized ShmemVariableCache->nextXid.
+ * after StartupXLOG has initialized TransamVariables->nextXid.
*/
void
StartupCommitTs(void)
}
LWLockRelease(CommitTsLock);
- xid = XidFromFullTransactionId(ShmemVariableCache->nextXid);
+ xid = XidFromFullTransactionId(TransamVariables->nextXid);
pageno = TransactionIdToCTsPage(xid);
/*
* Invalid temporarily.
*/
LWLockAcquire(CommitTsLock, LW_EXCLUSIVE);
- if (ShmemVariableCache->oldestCommitTsXid == InvalidTransactionId)
+ if (TransamVariables->oldestCommitTsXid == InvalidTransactionId)
{
- ShmemVariableCache->oldestCommitTsXid =
- ShmemVariableCache->newestCommitTsXid = ReadNextTransactionId();
+ TransamVariables->oldestCommitTsXid =
+ TransamVariables->newestCommitTsXid = ReadNextTransactionId();
}
LWLockRelease(CommitTsLock);
TIMESTAMP_NOBEGIN(commitTsShared->dataLastCommit.time);
commitTsShared->dataLastCommit.nodeid = InvalidRepOriginId;
- ShmemVariableCache->oldestCommitTsXid = InvalidTransactionId;
- ShmemVariableCache->newestCommitTsXid = InvalidTransactionId;
+ TransamVariables->oldestCommitTsXid = InvalidTransactionId;
+ TransamVariables->newestCommitTsXid = InvalidTransactionId;
LWLockRelease(CommitTsLock);
* "future" or signal a disabled committs.
*/
LWLockAcquire(CommitTsLock, LW_EXCLUSIVE);
- if (ShmemVariableCache->oldestCommitTsXid != InvalidTransactionId)
+ if (TransamVariables->oldestCommitTsXid != InvalidTransactionId)
{
- if (TransactionIdPrecedes(ShmemVariableCache->oldestCommitTsXid, oldestXact))
- ShmemVariableCache->oldestCommitTsXid = oldestXact;
- if (TransactionIdPrecedes(newestXact, ShmemVariableCache->newestCommitTsXid))
- ShmemVariableCache->newestCommitTsXid = newestXact;
+ if (TransactionIdPrecedes(TransamVariables->oldestCommitTsXid, oldestXact))
+ TransamVariables->oldestCommitTsXid = oldestXact;
+ if (TransactionIdPrecedes(newestXact, TransamVariables->newestCommitTsXid))
+ TransamVariables->newestCommitTsXid = newestXact;
}
else
{
- Assert(ShmemVariableCache->newestCommitTsXid == InvalidTransactionId);
- ShmemVariableCache->oldestCommitTsXid = oldestXact;
- ShmemVariableCache->newestCommitTsXid = newestXact;
+ Assert(TransamVariables->newestCommitTsXid == InvalidTransactionId);
+ TransamVariables->oldestCommitTsXid = oldestXact;
+ TransamVariables->newestCommitTsXid = newestXact;
}
LWLockRelease(CommitTsLock);
}
AdvanceOldestCommitTsXid(TransactionId oldestXact)
{
LWLockAcquire(CommitTsLock, LW_EXCLUSIVE);
- if (ShmemVariableCache->oldestCommitTsXid != InvalidTransactionId &&
- TransactionIdPrecedes(ShmemVariableCache->oldestCommitTsXid, oldestXact))
- ShmemVariableCache->oldestCommitTsXid = oldestXact;
+ if (TransamVariables->oldestCommitTsXid != InvalidTransactionId &&
+ TransactionIdPrecedes(TransamVariables->oldestCommitTsXid, oldestXact))
+ TransamVariables->oldestCommitTsXid = oldestXact;
LWLockRelease(CommitTsLock);
}
/*
* This must be called ONCE during postmaster or standalone-backend startup,
- * after StartupXLOG has initialized ShmemVariableCache->nextXid.
+ * after StartupXLOG has initialized TransamVariables->nextXid.
*
* oldestActiveXID is the oldest XID of any prepared transaction, or nextXid
* if there are none.
LWLockAcquire(SubtransSLRULock, LW_EXCLUSIVE);
startPage = TransactionIdToPage(oldestActiveXID);
- nextXid = ShmemVariableCache->nextXid;
+ nextXid = TransamVariables->nextXid;
endPage = TransactionIdToPage(XidFromFullTransactionId(nextXid));
while (startPage != endPage)
Assert(TransactionIdIsValid(xid));
LWLockAcquire(XidGenLock, LW_SHARED);
- nextFullXid = ShmemVariableCache->nextXid;
+ nextFullXid = TransamVariables->nextXid;
LWLockRelease(XidGenLock);
nextXid = XidFromFullTransactionId(nextFullXid);
*
* Scan the shared memory entries of TwoPhaseState and determine the range
* of valid XIDs present. This is run during database startup, after we
- * have completed reading WAL. ShmemVariableCache->nextXid has been set to
+ * have completed reading WAL. TransamVariables->nextXid has been set to
* one more than the highest XID for which evidence exists in WAL.
*
* We throw away any prepared xacts with main XID beyond nextXid --- if any
* backup should be rolled in.
*
* Our other responsibility is to determine and return the oldest valid XID
- * among the prepared xacts (if none, return ShmemVariableCache->nextXid).
+ * among the prepared xacts (if none, return TransamVariables->nextXid).
* This is needed to synchronize pg_subtrans startup properly.
*
* If xids_p and nxids_p are not NULL, pointer to a palloc'd array of all
TransactionId
PrescanPreparedTransactions(TransactionId **xids_p, int *nxids_p)
{
- FullTransactionId nextXid = ShmemVariableCache->nextXid;
+ FullTransactionId nextXid = TransamVariables->nextXid;
TransactionId origNextXid = XidFromFullTransactionId(nextXid);
TransactionId result = origNextXid;
TransactionId *xids = NULL;
*
* If setParent is true, set up subtransaction parent linkages.
*
- * If setNextXid is true, set ShmemVariableCache->nextXid to the newest
+ * If setNextXid is true, set TransamVariables->nextXid to the newest
* value scanned.
*/
static char *
bool fromdisk,
bool setParent, bool setNextXid)
{
- FullTransactionId nextXid = ShmemVariableCache->nextXid;
+ FullTransactionId nextXid = TransamVariables->nextXid;
TransactionId origNextXid = XidFromFullTransactionId(nextXid);
TransactionId *subxids;
char *buf;
/* Number of OIDs to prefetch (preallocate) per XLOG write */
#define VAR_OID_PREFETCH 8192
-/* pointer to "variable cache" in shared memory (set up by shmem.c) */
-VariableCache ShmemVariableCache = NULL;
+/* pointer to variables struct in shared memory */
+TransamVariablesData *TransamVariables = NULL;
/*
- * Initialization of shared memory for ShmemVariableCache.
+ * Initialization of shared memory for TransamVariables.
*/
Size
VarsupShmemSize(void)
{
- return sizeof(VariableCacheData);
+ return sizeof(TransamVariablesData);
}
void
bool found;
/* Initialize our shared state struct */
- ShmemVariableCache = ShmemInitStruct("ShmemVariableCache",
- sizeof(VariableCacheData),
- &found);
+ TransamVariables = ShmemInitStruct("TransamVariables",
+ sizeof(TransamVariablesData),
+ &found);
if (!IsUnderPostmaster)
{
Assert(!found);
- memset(ShmemVariableCache, 0, sizeof(VariableCacheData));
+ memset(TransamVariables, 0, sizeof(TransamVariablesData));
}
else
Assert(found);
LWLockAcquire(XidGenLock, LW_EXCLUSIVE);
- full_xid = ShmemVariableCache->nextXid;
+ full_xid = TransamVariables->nextXid;
xid = XidFromFullTransactionId(full_xid);
/*----------
* Note that this coding also appears in GetNewMultiXactId.
*----------
*/
- if (TransactionIdFollowsOrEquals(xid, ShmemVariableCache->xidVacLimit))
+ if (TransactionIdFollowsOrEquals(xid, TransamVariables->xidVacLimit))
{
/*
* For safety's sake, we release XidGenLock while sending signals,
* possibility of deadlock while doing get_database_name(). First,
* copy all the shared values we'll need in this path.
*/
- TransactionId xidWarnLimit = ShmemVariableCache->xidWarnLimit;
- TransactionId xidStopLimit = ShmemVariableCache->xidStopLimit;
- TransactionId xidWrapLimit = ShmemVariableCache->xidWrapLimit;
- Oid oldest_datoid = ShmemVariableCache->oldestXidDB;
+ TransactionId xidWarnLimit = TransamVariables->xidWarnLimit;
+ TransactionId xidStopLimit = TransamVariables->xidStopLimit;
+ TransactionId xidWrapLimit = TransamVariables->xidWrapLimit;
+ Oid oldest_datoid = TransamVariables->oldestXidDB;
LWLockRelease(XidGenLock);
/* Re-acquire lock and start over */
LWLockAcquire(XidGenLock, LW_EXCLUSIVE);
- full_xid = ShmemVariableCache->nextXid;
+ full_xid = TransamVariables->nextXid;
xid = XidFromFullTransactionId(full_xid);
}
* want the next incoming transaction to try it again. We cannot assign
* more XIDs until there is CLOG space for them.
*/
- FullTransactionIdAdvance(&ShmemVariableCache->nextXid);
+ FullTransactionIdAdvance(&TransamVariables->nextXid);
/*
* We must store the new XID into the shared ProcArray before releasing
FullTransactionId fullXid;
LWLockAcquire(XidGenLock, LW_SHARED);
- fullXid = ShmemVariableCache->nextXid;
+ fullXid = TransamVariables->nextXid;
LWLockRelease(XidGenLock);
return fullXid;
Assert(AmStartupProcess() || !IsUnderPostmaster);
/* Fast return if this isn't an xid high enough to move the needle. */
- next_xid = XidFromFullTransactionId(ShmemVariableCache->nextXid);
+ next_xid = XidFromFullTransactionId(TransamVariables->nextXid);
if (!TransactionIdFollowsOrEquals(xid, next_xid))
return;
* point in the WAL stream.
*/
TransactionIdAdvance(xid);
- epoch = EpochFromFullTransactionId(ShmemVariableCache->nextXid);
+ epoch = EpochFromFullTransactionId(TransamVariables->nextXid);
if (unlikely(xid < next_xid))
++epoch;
newNextFullXid = FullTransactionIdFromEpochAndXid(epoch, xid);
* concurrent readers.
*/
LWLockAcquire(XidGenLock, LW_EXCLUSIVE);
- ShmemVariableCache->nextXid = newNextFullXid;
+ TransamVariables->nextXid = newNextFullXid;
LWLockRelease(XidGenLock);
}
AdvanceOldestClogXid(TransactionId oldest_datfrozenxid)
{
LWLockAcquire(XactTruncationLock, LW_EXCLUSIVE);
- if (TransactionIdPrecedes(ShmemVariableCache->oldestClogXid,
+ if (TransactionIdPrecedes(TransamVariables->oldestClogXid,
oldest_datfrozenxid))
{
- ShmemVariableCache->oldestClogXid = oldest_datfrozenxid;
+ TransamVariables->oldestClogXid = oldest_datfrozenxid;
}
LWLockRelease(XactTruncationLock);
}
/* Grab lock for just long enough to set the new limit values */
LWLockAcquire(XidGenLock, LW_EXCLUSIVE);
- ShmemVariableCache->oldestXid = oldest_datfrozenxid;
- ShmemVariableCache->xidVacLimit = xidVacLimit;
- ShmemVariableCache->xidWarnLimit = xidWarnLimit;
- ShmemVariableCache->xidStopLimit = xidStopLimit;
- ShmemVariableCache->xidWrapLimit = xidWrapLimit;
- ShmemVariableCache->oldestXidDB = oldest_datoid;
- curXid = XidFromFullTransactionId(ShmemVariableCache->nextXid);
+ 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 */
/* Locking is probably not really necessary, but let's be careful */
LWLockAcquire(XidGenLock, LW_SHARED);
- nextXid = XidFromFullTransactionId(ShmemVariableCache->nextXid);
- xidVacLimit = ShmemVariableCache->xidVacLimit;
- oldestXid = ShmemVariableCache->oldestXid;
- oldestXidDB = ShmemVariableCache->oldestXidDB;
+ nextXid = XidFromFullTransactionId(TransamVariables->nextXid);
+ xidVacLimit = TransamVariables->xidVacLimit;
+ oldestXid = TransamVariables->oldestXid;
+ oldestXidDB = TransamVariables->oldestXidDB;
LWLockRelease(XidGenLock);
if (!TransactionIdIsNormal(oldestXid))
* available for automatic assignment during initdb, while ensuring they
* will never conflict with user-assigned OIDs.
*/
- if (ShmemVariableCache->nextOid < ((Oid) FirstNormalObjectId))
+ if (TransamVariables->nextOid < ((Oid) FirstNormalObjectId))
{
if (IsPostmasterEnvironment)
{
/* wraparound, or first post-initdb assignment, in normal mode */
- ShmemVariableCache->nextOid = FirstNormalObjectId;
- ShmemVariableCache->oidCount = 0;
+ TransamVariables->nextOid = FirstNormalObjectId;
+ TransamVariables->oidCount = 0;
}
else
{
/* we may be bootstrapping, so don't enforce the full range */
- if (ShmemVariableCache->nextOid < ((Oid) FirstGenbkiObjectId))
+ if (TransamVariables->nextOid < ((Oid) FirstGenbkiObjectId))
{
/* wraparound in standalone mode (unlikely but possible) */
- ShmemVariableCache->nextOid = FirstNormalObjectId;
- ShmemVariableCache->oidCount = 0;
+ TransamVariables->nextOid = FirstNormalObjectId;
+ TransamVariables->oidCount = 0;
}
}
}
/* If we run out of logged for use oids then we must log more */
- if (ShmemVariableCache->oidCount == 0)
+ if (TransamVariables->oidCount == 0)
{
- XLogPutNextOid(ShmemVariableCache->nextOid + VAR_OID_PREFETCH);
- ShmemVariableCache->oidCount = VAR_OID_PREFETCH;
+ XLogPutNextOid(TransamVariables->nextOid + VAR_OID_PREFETCH);
+ TransamVariables->oidCount = VAR_OID_PREFETCH;
}
- result = ShmemVariableCache->nextOid;
+ result = TransamVariables->nextOid;
- (ShmemVariableCache->nextOid)++;
- (ShmemVariableCache->oidCount)--;
+ (TransamVariables->nextOid)++;
+ (TransamVariables->oidCount)--;
LWLockRelease(OidGenLock);
/* Taking the lock is, therefore, just pro forma; but do it anyway */
LWLockAcquire(OidGenLock, LW_EXCLUSIVE);
- if (ShmemVariableCache->nextOid > nextOid)
+ if (TransamVariables->nextOid > nextOid)
elog(ERROR, "too late to advance OID counter to %u, it is now %u",
- nextOid, ShmemVariableCache->nextOid);
+ nextOid, TransamVariables->nextOid);
- ShmemVariableCache->nextOid = nextOid;
- ShmemVariableCache->oidCount = 0;
+ TransamVariables->nextOid = nextOid;
+ TransamVariables->oidCount = 0;
LWLockRelease(OidGenLock);
}
* Assert that xid is between [oldestXid, nextXid], which is the range we
* expect XIDs coming from tables etc to be in.
*
- * As ShmemVariableCache->oldestXid could change just after this call without
+ * As TransamVariables->oldestXid could change just after this call without
* further precautions, and as a wrapped-around xid could again fall within
* the valid range, this assertion can only detect if something is definitely
* wrong, but not establish correctness.
* before we see the updated nextXid value.
*/
pg_memory_barrier();
- oldest_xid = ShmemVariableCache->oldestXid;
- next_xid = XidFromFullTransactionId(ShmemVariableCache->nextXid);
+ oldest_xid = TransamVariables->oldestXid;
+ next_xid = XidFromFullTransactionId(TransamVariables->nextXid);
Assert(TransactionIdFollowsOrEquals(xid, oldest_xid) ||
TransactionIdPrecedesOrEquals(xid, next_xid));
checkPoint.time = (pg_time_t) time(NULL);
checkPoint.oldestActiveXid = InvalidTransactionId;
- ShmemVariableCache->nextXid = checkPoint.nextXid;
- ShmemVariableCache->nextOid = checkPoint.nextOid;
- ShmemVariableCache->oidCount = 0;
+ TransamVariables->nextXid = checkPoint.nextXid;
+ TransamVariables->nextOid = checkPoint.nextOid;
+ TransamVariables->oidCount = 0;
MultiXactSetNextMXact(checkPoint.nextMulti, checkPoint.nextMultiOffset);
AdvanceOldestClogXid(checkPoint.oldestXid);
SetTransactionIdLimit(checkPoint.oldestXid, checkPoint.oldestXidDB);
checkPoint = ControlFile->checkPointCopy;
/* initialize shared memory variables from the checkpoint record */
- ShmemVariableCache->nextXid = checkPoint.nextXid;
- ShmemVariableCache->nextOid = checkPoint.nextOid;
- ShmemVariableCache->oidCount = 0;
+ TransamVariables->nextXid = checkPoint.nextXid;
+ TransamVariables->nextOid = checkPoint.nextOid;
+ TransamVariables->oidCount = 0;
MultiXactSetNextMXact(checkPoint.nextMulti, checkPoint.nextMultiOffset);
AdvanceOldestClogXid(checkPoint.oldestXid);
SetTransactionIdLimit(checkPoint.oldestXid, checkPoint.oldestXidDB);
StartupReorderBuffer();
/*
- * Startup CLOG. This must be done after ShmemVariableCache->nextXid has
+ * Startup CLOG. This must be done after TransamVariables->nextXid has
* been initialized and before we accept connections or begin WAL replay.
*/
StartupCLOG();
Assert(TransactionIdIsValid(oldestActiveXID));
/* Tell procarray about the range of xids it has to deal with */
- ProcArrayInitRecovery(XidFromFullTransactionId(ShmemVariableCache->nextXid));
+ ProcArrayInitRecovery(XidFromFullTransactionId(TransamVariables->nextXid));
/*
* Startup subtrans only. CLOG, MultiXact and commit timestamp
/* also initialize latestCompletedXid, to nextXid - 1 */
LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
- ShmemVariableCache->latestCompletedXid = ShmemVariableCache->nextXid;
- FullTransactionIdRetreat(&ShmemVariableCache->latestCompletedXid);
+ TransamVariables->latestCompletedXid = TransamVariables->nextXid;
+ FullTransactionIdRetreat(&TransamVariables->latestCompletedXid);
LWLockRelease(ProcArrayLock);
/*
* there.
*/
LWLockAcquire(XidGenLock, LW_SHARED);
- checkPoint.nextXid = ShmemVariableCache->nextXid;
- checkPoint.oldestXid = ShmemVariableCache->oldestXid;
- checkPoint.oldestXidDB = ShmemVariableCache->oldestXidDB;
+ checkPoint.nextXid = TransamVariables->nextXid;
+ checkPoint.oldestXid = TransamVariables->oldestXid;
+ checkPoint.oldestXidDB = TransamVariables->oldestXidDB;
LWLockRelease(XidGenLock);
LWLockAcquire(CommitTsLock, LW_SHARED);
- checkPoint.oldestCommitTsXid = ShmemVariableCache->oldestCommitTsXid;
- checkPoint.newestCommitTsXid = ShmemVariableCache->newestCommitTsXid;
+ checkPoint.oldestCommitTsXid = TransamVariables->oldestCommitTsXid;
+ checkPoint.newestCommitTsXid = TransamVariables->newestCommitTsXid;
LWLockRelease(CommitTsLock);
LWLockAcquire(OidGenLock, LW_SHARED);
- checkPoint.nextOid = ShmemVariableCache->nextOid;
+ checkPoint.nextOid = TransamVariables->nextOid;
if (!shutdown)
- checkPoint.nextOid += ShmemVariableCache->oidCount;
+ checkPoint.nextOid += TransamVariables->oidCount;
LWLockRelease(OidGenLock);
MultiXactGetCheckptMulti(shutdown,
Oid nextOid;
/*
- * We used to try to take the maximum of ShmemVariableCache->nextOid
- * and the recorded nextOid, but that fails if the OID counter wraps
+ * We used to try to take the maximum of TransamVariables->nextOid and
+ * the recorded nextOid, but that fails if the OID counter wraps
* around. Since no OID allocation should be happening during replay
* anyway, better to just believe the record exactly. We still take
* OidGenLock while setting the variable, just in case.
*/
memcpy(&nextOid, XLogRecGetData(record), sizeof(Oid));
LWLockAcquire(OidGenLock, LW_EXCLUSIVE);
- ShmemVariableCache->nextOid = nextOid;
- ShmemVariableCache->oidCount = 0;
+ TransamVariables->nextOid = nextOid;
+ TransamVariables->oidCount = 0;
LWLockRelease(OidGenLock);
}
else if (info == XLOG_CHECKPOINT_SHUTDOWN)
memcpy(&checkPoint, XLogRecGetData(record), sizeof(CheckPoint));
/* In a SHUTDOWN checkpoint, believe the counters exactly */
LWLockAcquire(XidGenLock, LW_EXCLUSIVE);
- ShmemVariableCache->nextXid = checkPoint.nextXid;
+ TransamVariables->nextXid = checkPoint.nextXid;
LWLockRelease(XidGenLock);
LWLockAcquire(OidGenLock, LW_EXCLUSIVE);
- ShmemVariableCache->nextOid = checkPoint.nextOid;
- ShmemVariableCache->oidCount = 0;
+ TransamVariables->nextOid = checkPoint.nextOid;
+ TransamVariables->oidCount = 0;
LWLockRelease(OidGenLock);
MultiXactSetNextMXact(checkPoint.nextMulti,
checkPoint.nextMultiOffset);
memcpy(&checkPoint, XLogRecGetData(record), sizeof(CheckPoint));
/* In an ONLINE checkpoint, treat the XID counter as a minimum */
LWLockAcquire(XidGenLock, LW_EXCLUSIVE);
- if (FullTransactionIdPrecedes(ShmemVariableCache->nextXid,
+ if (FullTransactionIdPrecedes(TransamVariables->nextXid,
checkPoint.nextXid))
- ShmemVariableCache->nextXid = checkPoint.nextXid;
+ TransamVariables->nextXid = checkPoint.nextXid;
LWLockRelease(XidGenLock);
/*
*/
MultiXactAdvanceOldest(checkPoint.oldestMulti,
checkPoint.oldestMultiDB);
- if (TransactionIdPrecedes(ShmemVariableCache->oldestXid,
+ if (TransactionIdPrecedes(TransamVariables->oldestXid,
checkPoint.oldestXid))
SetTransactionIdLimit(checkPoint.oldestXid,
checkPoint.oldestXidDB);
Assert(AmStartupProcess() || !IsUnderPostmaster);
xid = XLogRecGetXid(record);
- next_xid = XidFromFullTransactionId(ShmemVariableCache->nextXid);
- epoch = EpochFromFullTransactionId(ShmemVariableCache->nextXid);
+ next_xid = XidFromFullTransactionId(TransamVariables->nextXid);
+ epoch = EpochFromFullTransactionId(TransamVariables->nextXid);
/*
* If xid is numerically greater than next_xid, it has to be from the last
error_context_stack = &errcallback;
/*
- * ShmemVariableCache->nextXid must be beyond record's xid.
+ * TransamVariables->nextXid must be beyond record's xid.
*/
AdvanceNextFullTransactionIdPastXid(record->xl_xid);
*
* Even if we didn't vacuum anything, it may still be important to do
* this, because one indirect effect of vac_update_datfrozenxid() is to
- * update ShmemVariableCache->xidVacLimit. That might need to be done
- * even if we haven't vacuumed anything, because relations with older
+ * update TransamVariables->xidVacLimit. That might need to be done even
+ * if we haven't vacuumed anything, because relations with older
* relfrozenxid values or other databases with older datfrozenxid values
* might have been dropped, allowing xidVacLimit to advance.
*
typedef struct ComputeXidHorizonsResult
{
/*
- * The value of ShmemVariableCache->latestCompletedXid when
+ * The value of TransamVariables->latestCompletedXid when
* ComputeXidHorizons() held ProcArrayLock.
*/
FullTransactionId latest_completed;
procArray->lastOverflowedXid = InvalidTransactionId;
procArray->replication_slot_xmin = InvalidTransactionId;
procArray->replication_slot_catalog_xmin = InvalidTransactionId;
- ShmemVariableCache->xactCompletionCount = 1;
+ TransamVariables->xactCompletionCount = 1;
}
allProcs = ProcGlobal->allProcs;
MaintainLatestCompletedXid(latestXid);
/* Same with xactCompletionCount */
- ShmemVariableCache->xactCompletionCount++;
+ TransamVariables->xactCompletionCount++;
ProcGlobal->xids[myoff] = InvalidTransactionId;
ProcGlobal->subxidStates[myoff].overflowed = false;
MaintainLatestCompletedXid(latestXid);
/* Same with xactCompletionCount */
- ShmemVariableCache->xactCompletionCount++;
+ TransamVariables->xactCompletionCount++;
}
/*
* otherwise could end up reusing the snapshot later. Which would be bad,
* because it might not count the prepared transaction as running.
*/
- ShmemVariableCache->xactCompletionCount++;
+ TransamVariables->xactCompletionCount++;
/* Clear the subtransaction-XID cache too */
Assert(ProcGlobal->subxidStates[pgxactoff].count == proc->subxidStatus.count &&
}
/*
- * Update ShmemVariableCache->latestCompletedXid to point to latestXid if
+ * Update TransamVariables->latestCompletedXid to point to latestXid if
* currently older.
*/
static void
MaintainLatestCompletedXid(TransactionId latestXid)
{
- FullTransactionId cur_latest = ShmemVariableCache->latestCompletedXid;
+ FullTransactionId cur_latest = TransamVariables->latestCompletedXid;
Assert(FullTransactionIdIsValid(cur_latest));
Assert(!RecoveryInProgress());
if (TransactionIdPrecedes(XidFromFullTransactionId(cur_latest), latestXid))
{
- ShmemVariableCache->latestCompletedXid =
+ TransamVariables->latestCompletedXid =
FullXidRelativeTo(cur_latest, latestXid);
}
Assert(IsBootstrapProcessingMode() ||
- FullTransactionIdIsNormal(ShmemVariableCache->latestCompletedXid));
+ FullTransactionIdIsNormal(TransamVariables->latestCompletedXid));
}
/*
static void
MaintainLatestCompletedXidRecovery(TransactionId latestXid)
{
- FullTransactionId cur_latest = ShmemVariableCache->latestCompletedXid;
+ FullTransactionId cur_latest = TransamVariables->latestCompletedXid;
FullTransactionId rel;
Assert(AmStartupProcess() || !IsUnderPostmaster);
* latestCompletedXid to be initialized in recovery. But in recovery it's
* safe to access nextXid without a lock for the startup process.
*/
- rel = ShmemVariableCache->nextXid;
- Assert(FullTransactionIdIsValid(ShmemVariableCache->nextXid));
+ rel = TransamVariables->nextXid;
+ Assert(FullTransactionIdIsValid(TransamVariables->nextXid));
if (!FullTransactionIdIsValid(cur_latest) ||
TransactionIdPrecedes(XidFromFullTransactionId(cur_latest), latestXid))
{
- ShmemVariableCache->latestCompletedXid =
+ TransamVariables->latestCompletedXid =
FullXidRelativeTo(rel, latestXid);
}
- Assert(FullTransactionIdIsNormal(ShmemVariableCache->latestCompletedXid));
+ Assert(FullTransactionIdIsNormal(TransamVariables->latestCompletedXid));
}
/*
MaintainLatestCompletedXidRecovery(running->latestCompletedXid);
/*
- * NB: No need to increment ShmemVariableCache->xactCompletionCount here,
+ * NB: No need to increment TransamVariables->xactCompletionCount here,
* nobody can see it yet.
*/
LWLockRelease(ProcArrayLock);
- /* ShmemVariableCache->nextXid must be beyond any observed xid. */
+ /* TransamVariables->nextXid must be beyond any observed xid. */
AdvanceNextFullTransactionIdPastXid(latestObservedXid);
- Assert(FullTransactionIdIsValid(ShmemVariableCache->nextXid));
+ Assert(FullTransactionIdIsValid(TransamVariables->nextXid));
KnownAssignedXidsDisplay(trace_recovery(DEBUG3));
if (standbyState == STANDBY_SNAPSHOT_READY)
* target Xid is after that, it's surely still running.
*/
latestCompletedXid =
- XidFromFullTransactionId(ShmemVariableCache->latestCompletedXid);
+ XidFromFullTransactionId(TransamVariables->latestCompletedXid);
if (TransactionIdPrecedes(latestCompletedXid, xid))
{
LWLockRelease(ProcArrayLock);
LWLockAcquire(ProcArrayLock, LW_SHARED);
- h->latest_completed = ShmemVariableCache->latestCompletedXid;
+ h->latest_completed = TransamVariables->latestCompletedXid;
/*
* We initialize the MIN() calculation with latestCompletedXid + 1. This
if (unlikely(snapshot->snapXactCompletionCount == 0))
return false;
- curXactCompletionCount = ShmemVariableCache->xactCompletionCount;
+ curXactCompletionCount = TransamVariables->xactCompletionCount;
if (curXactCompletionCount != snapshot->snapXactCompletionCount)
return false;
return snapshot;
}
- latest_completed = ShmemVariableCache->latestCompletedXid;
+ latest_completed = TransamVariables->latestCompletedXid;
mypgxactoff = MyProc->pgxactoff;
myxid = other_xids[mypgxactoff];
Assert(myxid == MyProc->xid);
- oldestxid = ShmemVariableCache->oldestXid;
- curXactCompletionCount = ShmemVariableCache->xactCompletionCount;
+ oldestxid = TransamVariables->oldestXid;
+ curXactCompletionCount = TransamVariables->xactCompletionCount;
/* xmax is always latestCompletedXid + 1 */
xmax = XidFromFullTransactionId(latest_completed);
/*
* Check if we know that we can initialize or increase the lower
* bound. Currently the only cheap way to do so is to use
- * ShmemVariableCache->oldestXid as input.
+ * TransamVariables->oldestXid as input.
*
* We should definitely be able to do better. We could e.g. put a
- * global lower bound value into ShmemVariableCache.
+ * global lower bound value into TransamVariables.
*/
GlobalVisSharedRels.maybe_needed =
FullTransactionIdNewer(GlobalVisSharedRels.maybe_needed,
LWLockAcquire(XidGenLock, LW_SHARED);
latestCompletedXid =
- XidFromFullTransactionId(ShmemVariableCache->latestCompletedXid);
+ XidFromFullTransactionId(TransamVariables->latestCompletedXid);
oldestRunningXid =
- XidFromFullTransactionId(ShmemVariableCache->nextXid);
+ XidFromFullTransactionId(TransamVariables->nextXid);
/*
* Spin over procArray collecting all xids
CurrentRunningXacts->xcnt = count - subcount;
CurrentRunningXacts->subxcnt = subcount;
CurrentRunningXacts->subxid_overflow = suboverflowed;
- CurrentRunningXacts->nextXid = XidFromFullTransactionId(ShmemVariableCache->nextXid);
+ CurrentRunningXacts->nextXid = XidFromFullTransactionId(TransamVariables->nextXid);
CurrentRunningXacts->oldestRunningXid = oldestRunningXid;
CurrentRunningXacts->latestCompletedXid = latestCompletedXid;
* have already completed), when we spin over it.
*/
LWLockAcquire(XidGenLock, LW_SHARED);
- oldestRunningXid = XidFromFullTransactionId(ShmemVariableCache->nextXid);
+ oldestRunningXid = XidFromFullTransactionId(TransamVariables->nextXid);
LWLockRelease(XidGenLock);
/*
* a safe, albeit pessimal, value.
*/
LWLockAcquire(XidGenLock, LW_SHARED);
- oldestSafeXid = XidFromFullTransactionId(ShmemVariableCache->nextXid);
+ oldestSafeXid = XidFromFullTransactionId(TransamVariables->nextXid);
/*
* If there's already a slot pegging the xmin horizon, we can start with
MaintainLatestCompletedXid(latestXid);
/* ... and xactCompletionCount */
- ShmemVariableCache->xactCompletionCount++;
+ TransamVariables->xactCompletionCount++;
LWLockRelease(ProcArrayLock);
}
*/
latestObservedXid = xid;
- /* ShmemVariableCache->nextXid must be beyond any observed xid */
+ /* TransamVariables->nextXid must be beyond any observed xid */
AdvanceNextFullTransactionIdPastXid(latestObservedXid);
}
}
MaintainLatestCompletedXidRecovery(max_xid);
/* ... and xactCompletionCount */
- ShmemVariableCache->xactCompletionCount++;
+ TransamVariables->xactCompletionCount++;
LWLockRelease(ProcArrayLock);
}
* transaction to complete before freeing some RAM; correctness of visible
* behavior is not affected.
*/
- MySerializableXact->finishedBefore = XidFromFullTransactionId(ShmemVariableCache->nextXid);
+ MySerializableXact->finishedBefore = XidFromFullTransactionId(TransamVariables->nextXid);
/*
* If it's not a commit it's either a rollback or a read-only transaction
(unsigned long long) U64FromFullTransactionId(fxid))));
/*
- * ShmemVariableCache->oldestClogXid is protected by XactTruncationLock,
- * but we don't acquire that lock here. Instead, we require the caller to
+ * TransamVariables->oldestClogXid is protected by XactTruncationLock, but
+ * we don't acquire that lock here. Instead, we require the caller to
* acquire it, because the caller is presumably going to look up the
* returned XID. If we took and released the lock within this function, a
* CLOG truncation could occur before the caller finished with the XID.
/*
* If the transaction ID has wrapped around, it's definitely too old to
* determine the commit status. Otherwise, we can compare it to
- * ShmemVariableCache->oldestClogXid to determine whether the relevant
- * CLOG entry is guaranteed to still exist.
+ * TransamVariables->oldestClogXid to determine whether the relevant CLOG
+ * entry is guaranteed to still exist.
*/
if (xid_epoch + 1 < now_epoch
|| (xid_epoch + 1 == now_epoch && xid < now_epoch_next_xid)
- || TransactionIdPrecedes(xid, ShmemVariableCache->oldestClogXid))
+ || TransactionIdPrecedes(xid, TransamVariables->oldestClogXid))
return false;
return true;
#define FirstNormalObjectId 16384
/*
- * VariableCache is a data structure in shared memory that is used to track
+ * TransamVariables is a data structure in shared memory that is used to track
* OID and XID assignment state. For largely historical reasons, there is
* just one struct with different fields that are protected by different
* LWLocks.
* used just to generate useful messages when xidWarnLimit or xidStopLimit
* are exceeded.
*/
-typedef struct VariableCacheData
+typedef struct TransamVariablesData
{
/*
* These fields are protected by OidGenLock.
*/
TransactionId oldestClogXid; /* oldest it's safe to look up in clog */
-} VariableCacheData;
-
-typedef VariableCacheData *VariableCache;
+} TransamVariablesData;
/* ----------------
extern bool TransactionStartedDuringRecovery(void);
/* in transam/varsup.c */
-extern PGDLLIMPORT VariableCache ShmemVariableCache;
+extern PGDLLIMPORT TransamVariablesData *TransamVariables;
/*
* prototypes for functions in transam/transam.c
int xcnt; /* # of xact ids in xids[] */
int subxcnt; /* # of subxact ids in xids[] */
bool subxid_overflow; /* snapshot overflowed, subxids missing */
- TransactionId nextXid; /* xid from ShmemVariableCache->nextXid */
+ TransactionId nextXid; /* xid from TransamVariables->nextXid */
TransactionId oldestRunningXid; /* *not* oldestXmin */
TransactionId latestCompletedXid; /* so we can set xmax */
int xcnt; /* # of xact ids in xids[] */
int subxcnt; /* # of subxact ids in xids[] */
bool subxid_overflow; /* snapshot overflowed, subxids missing */
- TransactionId nextXid; /* xid from ShmemVariableCache->nextXid */
+ TransactionId nextXid; /* xid from TransamVariables->nextXid */
TransactionId oldestRunningXid; /* *not* oldestXmin */
TransactionId latestCompletedXid; /* so we can set xmax */
uint32 consumed;
LWLockAcquire(XidGenLock, LW_EXCLUSIVE);
- nextXid = ShmemVariableCache->nextXid;
+ nextXid = TransamVariables->nextXid;
/*
* Go slow near the "interesting values". The interesting zones include 5
*/
consumed = XidSkip(nextXid);
if (consumed > 0)
- ShmemVariableCache->nextXid.value += (uint64) consumed;
+ TransamVariables->nextXid.value += (uint64) consumed;
LWLockRelease(XidGenLock);
TokenAuxData
TokenizedAuthLine
TrackItem
+TransamVariablesData
TransApplyAction
TransInvalidationInfo
TransState
VarStringSortSupport
Variable
VariableAssignHook
-VariableCache
-VariableCacheData
VariableSetKind
VariableSetStmt
VariableShowStmt
projects / postgresql.git / commitdiff