/*
* Make sure that CommitTs has room for a newly-allocated XID.
*
* NB: this is called while holding XidGenLock. We want it to be very fast
* most of the time; even when it's not so fast, no actual I/O need happen
* unless we're forced to write out a dirty CommitTs or xlog page to make room
* in shared memory.
*
* NB: the current implementation relies on track_commit_timestamp being
* PGC_POSTMASTER.
*/
void
ExtendCommitTs(TransactionId newestXact)
{
int pageno;
/*
* Nothing to do if module not enabled. Note we do an unlocked read of
* the flag here, which is okay because this routine is only called from
* GetNewTransactionId, which is never called in a standby.
*/
Assert(!InRecovery);
if (!commitTsShared->commitTsActive)
return;
/*
* No work except at first XID of a page. But beware: just after
* wraparound, the first XID of page zero is FirstNormalTransactionId.
*/
if (TransactionIdToCTsEntry(newestXact) != 0 &&
!TransactionIdEquals(newestXact, FirstNormalTransactionId))
return;
pageno = TransactionIdToCTsPage(newestXact);
LWLockAcquire(CommitTsControlLock, LW_EXCLUSIVE);
/* Zero the page and make an XLOG entry about it */
ZeroCommitTsPage(pageno, !InRecovery);
LWLockRelease(CommitTsControlLock);
}
/*
* Sets the commit timestamp of a single transaction.
*
* Must be called with CommitTsControlLock held
*/
static void
TransactionIdSetCommitTs(TransactionId xid, TimestampTz ts,
RepOriginId nodeid, int slotno)
{
int entryno = TransactionIdToCTsEntry(xid);
CommitTimestampEntry entry;
Assert(TransactionIdIsNormal(xid));
entry.time = ts;
entry.nodeid = nodeid;
memcpy(CommitTsCtl->shared->page_buffer[slotno] +
SizeOfCommitTimestampEntry * entryno,
&entry, SizeOfCommitTimestampEntry);
}
/*
* Interrogate the commit timestamp of a transaction.
*
* The return value indicates whether a commit timestamp record was found for
* the given xid. The timestamp value is returned in *ts (which may not be
* null), and the origin node for the Xid is returned in *nodeid, if it's not
* null.
*/
bool
TransactionIdGetCommitTsData(TransactionId xid, TimestampTz *ts,
RepOriginId *nodeid)
{
int pageno = TransactionIdToCTsPage(xid);
int entryno = TransactionIdToCTsEntry(xid);
int slotno;
CommitTimestampEntry entry;
TransactionId oldestCommitTsXid;
TransactionId newestCommitTsXid;
if (!TransactionIdIsValid(xid))
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("cannot retrieve commit timestamp for transaction %u", xid)));
else if (!TransactionIdIsNormal(xid))
{
/* frozen and bootstrap xids are always committed far in the past */
*ts = 0;
if (nodeid)
*nodeid = 0;
return false;
}
LWLockAcquire(CommitTsLock, LW_SHARED);
/* Error if module not enabled */
if (!commitTsShared->commitTsActive)
error_commit_ts_disabled();
/*
* If we're asked for the cached value, return that. Otherwise, fall
* through to read from SLRU.
*/
if (commitTsShared->xidLastCommit == xid)
{
*ts = commitTsShared->dataLastCommit.time;
if (nodeid)
*nodeid = commitTsShared->dataLastCommit.nodeid;
LWLockRelease(CommitTsLock);
return *ts != 0;
}
oldestCommitTsXid = ShmemVariableCache->oldestCommitTsXid;
newestCommitTsXid = ShmemVariableCache->newestCommitTsXid;
/* neither is invalid, or both are */
Assert(TransactionIdIsValid(oldestCommitTsXid) == TransactionIdIsValid(newestCommitTsXid));
LWLockRelease(CommitTsLock);
/*
* Return empty if the requested value is outside our valid range.
*/
if (!TransactionIdIsValid(oldestCommitTsXid) ||
TransactionIdPrecedes(xid, oldestCommitTsXid) ||
TransactionIdPrecedes(newestCommitTsXid, xid))
{
*ts = 0;
if (nodeid)
*nodeid = InvalidRepOriginId;
return false;
}
/* lock is acquired by SimpleLruReadPage_ReadOnly */
slotno = SimpleLruReadPage_ReadOnly(CommitTsCtl, pageno, xid);
memcpy(&entry,
CommitTsCtl->shared->page_buffer[slotno] +
SizeOfCommitTimestampEntry * entryno,
SizeOfCommitTimestampEntry);
*ts = entry.time;
if (nodeid)
*nodeid = entry.nodeid;
LWLockRelease(CommitTsControlLock);
return *ts != 0;
}
/*
* Interrogate the commit timestamp of a transaction.
*
* The return value indicates whether a commit timestamp record was found for
* the given xid. The timestamp value is returned in *ts (which may not be
* null), and the origin node for the Xid is returned in *nodeid, if it's not
* null.
*/
bool
TransactionIdGetCommitTsData(TransactionId xid, TimestampTz *ts,
RepOriginId *nodeid)
{
int pageno = TransactionIdToCTsPage(xid);
int entryno = TransactionIdToCTsEntry(xid);
int slotno;
CommitTimestampEntry entry;
TransactionId oldestCommitTs;
TransactionId newestCommitTs;
/* error if the given Xid doesn't normally commit */
if (!TransactionIdIsNormal(xid))
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("cannot retrieve commit timestamp for transaction %u", xid)));
LWLockAcquire(CommitTsLock, LW_SHARED);
/* Error if module not enabled */
if (!commitTsShared->commitTsActive)
ereport(ERROR,
(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
errmsg("could not get commit timestamp data"),
errhint("Make sure the configuration parameter \"%s\" is set.",
"track_commit_timestamp")));
/*
* If we're asked for the cached value, return that. Otherwise, fall
* through to read from SLRU.
*/
if (commitTsShared->xidLastCommit == xid)
{
*ts = commitTsShared->dataLastCommit.time;
if (nodeid)
*nodeid = commitTsShared->dataLastCommit.nodeid;
LWLockRelease(CommitTsLock);
return *ts != 0;
}
oldestCommitTs = ShmemVariableCache->oldestCommitTs;
newestCommitTs = ShmemVariableCache->newestCommitTs;
/* neither is invalid, or both are */
Assert(TransactionIdIsValid(oldestCommitTs) == TransactionIdIsValid(newestCommitTs));
LWLockRelease(CommitTsLock);
/*
* Return empty if the requested value is outside our valid range.
*/
if (!TransactionIdIsValid(oldestCommitTs) ||
TransactionIdPrecedes(xid, oldestCommitTs) ||
TransactionIdPrecedes(newestCommitTs, xid))
{
*ts = 0;
if (nodeid)
*nodeid = InvalidRepOriginId;
return false;
}
/* lock is acquired by SimpleLruReadPage_ReadOnly */
slotno = SimpleLruReadPage_ReadOnly(CommitTsCtl, pageno, xid);
memcpy(&entry,
CommitTsCtl->shared->page_buffer[slotno] +
SizeOfCommitTimestampEntry * entryno,
SizeOfCommitTimestampEntry);
*ts = entry.time;
if (nodeid)
*nodeid = entry.nodeid;
LWLockRelease(CommitTsControlLock);
return *ts != 0;
}
