PostgreSQL Source Code  git master
commit_ts.c File Reference
#include "postgres.h"
#include "access/commit_ts.h"
#include "access/htup_details.h"
#include "access/slru.h"
#include "access/transam.h"
#include "catalog/pg_type.h"
#include "funcapi.h"
#include "miscadmin.h"
#include "pg_trace.h"
#include "storage/shmem.h"
#include "utils/builtins.h"
#include "utils/snapmgr.h"
#include "utils/timestamp.h"
Include dependency graph for commit_ts.c:

Go to the source code of this file.

Data Structures

struct  CommitTimestampEntry
 
struct  CommitTimestampShared
 

Macros

#define SizeOfCommitTimestampEntry
 
#define COMMIT_TS_XACTS_PER_PAGE   (BLCKSZ / SizeOfCommitTimestampEntry)
 
#define TransactionIdToCTsPage(xid)   ((xid) / (TransactionId) COMMIT_TS_XACTS_PER_PAGE)
 
#define TransactionIdToCTsEntry(xid)   ((xid) % (TransactionId) COMMIT_TS_XACTS_PER_PAGE)
 
#define CommitTsCtl   (&CommitTsCtlData)
 

Typedefs

typedef struct CommitTimestampEntry CommitTimestampEntry
 
typedef struct CommitTimestampShared CommitTimestampShared
 

Functions

static void SetXidCommitTsInPage (TransactionId xid, int nsubxids, TransactionId *subxids, TimestampTz ts, RepOriginId nodeid, int pageno)
 
static void TransactionIdSetCommitTs (TransactionId xid, TimestampTz ts, RepOriginId nodeid, int slotno)
 
static void error_commit_ts_disabled (void)
 
static int ZeroCommitTsPage (int pageno, bool writeXlog)
 
static bool CommitTsPagePrecedes (int page1, int page2)
 
static void ActivateCommitTs (void)
 
static void DeactivateCommitTs (void)
 
static void WriteZeroPageXlogRec (int pageno)
 
static void WriteTruncateXlogRec (int pageno, TransactionId oldestXid)
 
void TransactionTreeSetCommitTsData (TransactionId xid, int nsubxids, TransactionId *subxids, TimestampTz timestamp, RepOriginId nodeid)
 
bool TransactionIdGetCommitTsData (TransactionId xid, TimestampTz *ts, RepOriginId *nodeid)
 
TransactionId GetLatestCommitTsData (TimestampTz *ts, RepOriginId *nodeid)
 
Datum pg_xact_commit_timestamp (PG_FUNCTION_ARGS)
 
Datum pg_last_committed_xact (PG_FUNCTION_ARGS)
 
Datum pg_xact_commit_timestamp_origin (PG_FUNCTION_ARGS)
 
Size CommitTsShmemBuffers (void)
 
Size CommitTsShmemSize (void)
 
void CommitTsShmemInit (void)
 
void BootStrapCommitTs (void)
 
void StartupCommitTs (void)
 
void CompleteCommitTsInitialization (void)
 
void CommitTsParameterChange (bool newvalue, bool oldvalue)
 
void CheckPointCommitTs (void)
 
void ExtendCommitTs (TransactionId newestXact)
 
void TruncateCommitTs (TransactionId oldestXact)
 
void SetCommitTsLimit (TransactionId oldestXact, TransactionId newestXact)
 
void AdvanceOldestCommitTsXid (TransactionId oldestXact)
 
void commit_ts_redo (XLogReaderState *record)
 
int committssyncfiletag (const FileTag *ftag, char *path)
 

Variables

static SlruCtlData CommitTsCtlData
 
CommitTimestampSharedcommitTsShared
 
bool track_commit_timestamp
 

Macro Definition Documentation

◆ COMMIT_TS_XACTS_PER_PAGE

#define COMMIT_TS_XACTS_PER_PAGE   (BLCKSZ / SizeOfCommitTimestampEntry)

Definition at line 66 of file commit_ts.c.

Referenced by CommitTsPagePrecedes(), and CommitTsShmemInit().

◆ CommitTsCtl

◆ SizeOfCommitTimestampEntry

#define SizeOfCommitTimestampEntry
Value:
sizeof(RepOriginId))
uint16 RepOriginId
Definition: xlogdefs.h:65
#define offsetof(type, field)
Definition: c.h:727

Definition at line 63 of file commit_ts.c.

Referenced by TransactionIdGetCommitTsData(), and TransactionIdSetCommitTs().

◆ TransactionIdToCTsEntry

#define TransactionIdToCTsEntry (   xid)    ((xid) % (TransactionId) COMMIT_TS_XACTS_PER_PAGE)

◆ TransactionIdToCTsPage

#define TransactionIdToCTsPage (   xid)    ((xid) / (TransactionId) COMMIT_TS_XACTS_PER_PAGE)

Typedef Documentation

◆ CommitTimestampEntry

◆ CommitTimestampShared

Function Documentation

◆ ActivateCommitTs()

static void ActivateCommitTs ( void  )
static

Definition at line 678 of file commit_ts.c.

References Assert, CommitTimestampShared::commitTsActive, CommitTsCtl, InvalidTransactionId, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), VariableCacheData::newestCommitTsXid, VariableCacheData::nextXid, VariableCacheData::oldestCommitTsXid, ReadNextTransactionId(), ShmemVariableCache, SimpleLruDoesPhysicalPageExist(), SimpleLruWritePage(), TransactionIdToCTsPage, XidFromFullTransactionId, and ZeroCommitTsPage().

Referenced by CommitTsParameterChange(), CompleteCommitTsInitialization(), and StartupCommitTs().

679 {
680  TransactionId xid;
681  int pageno;
682 
683  /* If we've done this already, there's nothing to do */
684  LWLockAcquire(CommitTsLock, LW_EXCLUSIVE);
686  {
687  LWLockRelease(CommitTsLock);
688  return;
689  }
690  LWLockRelease(CommitTsLock);
691 
693  pageno = TransactionIdToCTsPage(xid);
694 
695  /*
696  * Re-Initialize our idea of the latest page number.
697  */
698  LWLockAcquire(CommitTsSLRULock, LW_EXCLUSIVE);
699  CommitTsCtl->shared->latest_page_number = pageno;
700  LWLockRelease(CommitTsSLRULock);
701 
702  /*
703  * If CommitTs is enabled, but it wasn't in the previous server run, we
704  * need to set the oldest and newest values to the next Xid; that way, we
705  * will not try to read data that might not have been set.
706  *
707  * XXX does this have a problem if a server is started with commitTs
708  * enabled, then started with commitTs disabled, then restarted with it
709  * enabled again? It doesn't look like it does, because there should be a
710  * checkpoint that sets the value to InvalidTransactionId at end of
711  * recovery; and so any chance of injecting new transactions without
712  * CommitTs values would occur after the oldestCommitTsXid has been set to
713  * Invalid temporarily.
714  */
715  LWLockAcquire(CommitTsLock, LW_EXCLUSIVE);
717  {
720  }
721  LWLockRelease(CommitTsLock);
722 
723  /* Create the current segment file, if necessary */
725  {
726  int slotno;
727 
728  LWLockAcquire(CommitTsSLRULock, LW_EXCLUSIVE);
729  slotno = ZeroCommitTsPage(pageno, false);
731  Assert(!CommitTsCtl->shared->page_dirty[slotno]);
732  LWLockRelease(CommitTsSLRULock);
733  }
734 
735  /* Change the activation status in shared memory. */
736  LWLockAcquire(CommitTsLock, LW_EXCLUSIVE);
738  LWLockRelease(CommitTsLock);
739 }
uint32 TransactionId
Definition: c.h:587
#define CommitTsCtl
Definition: commit_ts.c:79
static int ZeroCommitTsPage(int pageno, bool writeXlog)
Definition: commit_ts.c:588
static TransactionId ReadNextTransactionId(void)
Definition: transam.h:308
FullTransactionId nextXid
Definition: transam.h:213
#define XidFromFullTransactionId(x)
Definition: transam.h:48
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1816
VariableCache ShmemVariableCache
Definition: varsup.c:34
#define InvalidTransactionId
Definition: transam.h:31
bool SimpleLruDoesPhysicalPageExist(SlruCtl ctl, int pageno)
Definition: slru.c:625
void SimpleLruWritePage(SlruCtl ctl, int slotno)
Definition: slru.c:613
TransactionId oldestCommitTsXid
Definition: transam.h:225
#define TransactionIdToCTsPage(xid)
Definition: commit_ts.c:69
#define Assert(condition)
Definition: c.h:804
TransactionId newestCommitTsXid
Definition: transam.h:226
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1203
CommitTimestampShared * commitTsShared
Definition: commit_ts.c:99

◆ AdvanceOldestCommitTsXid()

void AdvanceOldestCommitTsXid ( TransactionId  oldestXact)

Definition at line 903 of file commit_ts.c.

References InvalidTransactionId, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), VariableCacheData::oldestCommitTsXid, ShmemVariableCache, and TransactionIdPrecedes().

Referenced by commit_ts_redo(), and vac_truncate_clog().

904 {
905  LWLockAcquire(CommitTsLock, LW_EXCLUSIVE);
909  LWLockRelease(CommitTsLock);
910 }
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1816
VariableCache ShmemVariableCache
Definition: varsup.c:34
#define InvalidTransactionId
Definition: transam.h:31
TransactionId oldestCommitTsXid
Definition: transam.h:225
bool TransactionIdPrecedes(TransactionId id1, TransactionId id2)
Definition: transam.c:300
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1203

◆ BootStrapCommitTs()

void BootStrapCommitTs ( void  )

Definition at line 569 of file commit_ts.c.

Referenced by BootStrapXLOG().

570 {
571  /*
572  * Nothing to do here at present, unlike most other SLRU modules; segments
573  * are created when the server is started with this module enabled. See
574  * ActivateCommitTs.
575  */
576 }

◆ CheckPointCommitTs()

void CheckPointCommitTs ( void  )

Definition at line 790 of file commit_ts.c.

References CommitTsCtl, and SimpleLruWriteAll().

Referenced by CheckPointGuts().

791 {
792  /*
793  * Write dirty CommitTs pages to disk. This may result in sync requests
794  * queued for later handling by ProcessSyncRequests(), as part of the
795  * checkpoint.
796  */
798 }
#define CommitTsCtl
Definition: commit_ts.c:79
void SimpleLruWriteAll(SlruCtl ctl, bool allow_redirtied)
Definition: slru.c:1155

◆ commit_ts_redo()

void commit_ts_redo ( XLogReaderState record)

Definition at line 983 of file commit_ts.c.

References AdvanceOldestCommitTsXid(), Assert, COMMIT_TS_TRUNCATE, COMMIT_TS_ZEROPAGE, CommitTsCtl, elog, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), xl_commit_ts_truncate::oldestXid, xl_commit_ts_truncate::pageno, PANIC, SimpleLruTruncate(), SimpleLruWritePage(), XLogRecGetData, XLogRecGetInfo, XLogRecHasAnyBlockRefs, XLR_INFO_MASK, and ZeroCommitTsPage().

984 {
985  uint8 info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
986 
987  /* Backup blocks are not used in commit_ts records */
988  Assert(!XLogRecHasAnyBlockRefs(record));
989 
990  if (info == COMMIT_TS_ZEROPAGE)
991  {
992  int pageno;
993  int slotno;
994 
995  memcpy(&pageno, XLogRecGetData(record), sizeof(int));
996 
997  LWLockAcquire(CommitTsSLRULock, LW_EXCLUSIVE);
998 
999  slotno = ZeroCommitTsPage(pageno, false);
1001  Assert(!CommitTsCtl->shared->page_dirty[slotno]);
1002 
1003  LWLockRelease(CommitTsSLRULock);
1004  }
1005  else if (info == COMMIT_TS_TRUNCATE)
1006  {
1008 
1010 
1011  /*
1012  * During XLOG replay, latest_page_number isn't set up yet; insert a
1013  * suitable value to bypass the sanity test in SimpleLruTruncate.
1014  */
1015  CommitTsCtl->shared->latest_page_number = trunc->pageno;
1016 
1018  }
1019  else
1020  elog(PANIC, "commit_ts_redo: unknown op code %u", info);
1021 }
#define COMMIT_TS_ZEROPAGE
Definition: commit_ts.h:51
#define CommitTsCtl
Definition: commit_ts.c:79
static int ZeroCommitTsPage(int pageno, bool writeXlog)
Definition: commit_ts.c:588
void SimpleLruTruncate(SlruCtl ctl, int cutoffPage)
Definition: slru.c:1225
unsigned char uint8
Definition: c.h:439
#define PANIC
Definition: elog.h:50
void AdvanceOldestCommitTsXid(TransactionId oldestXact)
Definition: commit_ts.c:903
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1816
#define XLogRecGetData(decoder)
Definition: xlogreader.h:310
TransactionId oldestXid
Definition: commit_ts.h:68
void SimpleLruWritePage(SlruCtl ctl, int slotno)
Definition: slru.c:613
#define XLogRecGetInfo(decoder)
Definition: xlogreader.h:305
#define COMMIT_TS_TRUNCATE
Definition: commit_ts.h:52
#define Assert(condition)
Definition: c.h:804
#define XLR_INFO_MASK
Definition: xlogrecord.h:62
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1203
#define elog(elevel,...)
Definition: elog.h:232
#define XLogRecHasAnyBlockRefs(decoder)
Definition: xlogreader.h:312

◆ CommitTsPagePrecedes()

static bool CommitTsPagePrecedes ( int  page1,
int  page2 
)
static

Definition at line 937 of file commit_ts.c.

References COMMIT_TS_XACTS_PER_PAGE, FirstNormalTransactionId, and TransactionIdPrecedes().

Referenced by CommitTsShmemInit().

938 {
939  TransactionId xid1;
940  TransactionId xid2;
941 
942  xid1 = ((TransactionId) page1) * COMMIT_TS_XACTS_PER_PAGE;
943  xid1 += FirstNormalTransactionId + 1;
944  xid2 = ((TransactionId) page2) * COMMIT_TS_XACTS_PER_PAGE;
945  xid2 += FirstNormalTransactionId + 1;
946 
947  return (TransactionIdPrecedes(xid1, xid2) &&
949 }
uint32 TransactionId
Definition: c.h:587
#define FirstNormalTransactionId
Definition: transam.h:34
#define COMMIT_TS_XACTS_PER_PAGE
Definition: commit_ts.c:66
bool TransactionIdPrecedes(TransactionId id1, TransactionId id2)
Definition: transam.c:300

◆ CommitTsParameterChange()

void CommitTsParameterChange ( bool  newvalue,
bool  oldvalue 
)

Definition at line 637 of file commit_ts.c.

References ActivateCommitTs(), CommitTimestampShared::commitTsActive, and DeactivateCommitTs().

Referenced by xlog_redo().

638 {
639  /*
640  * If the commit_ts module is disabled in this server and we get word from
641  * the primary server that it is enabled there, activate it so that we can
642  * replay future WAL records involving it; also mark it as active on
643  * pg_control. If the old value was already set, we already did this, so
644  * don't do anything.
645  *
646  * If the module is disabled in the primary, disable it here too, unless
647  * the module is enabled locally.
648  *
649  * Note this only runs in the recovery process, so an unlocked read is
650  * fine.
651  */
652  if (newvalue)
653  {
656  }
657  else if (commitTsShared->commitTsActive)
659 }
static void ActivateCommitTs(void)
Definition: commit_ts.c:678
static void DeactivateCommitTs(void)
Definition: commit_ts.c:752
CommitTimestampShared * commitTsShared
Definition: commit_ts.c:99

◆ CommitTsShmemBuffers()

Size CommitTsShmemBuffers ( void  )

Definition at line 514 of file commit_ts.c.

References Max, Min, and NBuffers.

Referenced by CommitTsShmemInit(), and CommitTsShmemSize().

515 {
516  return Min(16, Max(4, NBuffers / 1024));
517 }
#define Min(x, y)
Definition: c.h:986
#define Max(x, y)
Definition: c.h:980
int NBuffers
Definition: globals.c:135

◆ CommitTsShmemInit()

void CommitTsShmemInit ( void  )

Definition at line 534 of file commit_ts.c.

References Assert, COMMIT_TS_XACTS_PER_PAGE, CommitTimestampShared::commitTsActive, CommitTsCtl, CommitTsPagePrecedes(), CommitTsShmemBuffers(), CommitTimestampShared::dataLastCommit, InvalidRepOriginId, InvalidTransactionId, IsUnderPostmaster, LWTRANCHE_COMMITTS_BUFFER, CommitTimestampEntry::nodeid, ShmemInitStruct(), SimpleLruInit(), SlruPagePrecedesUnitTests, SYNC_HANDLER_COMMIT_TS, CommitTimestampEntry::time, TIMESTAMP_NOBEGIN, and CommitTimestampShared::xidLastCommit.

Referenced by CreateSharedMemoryAndSemaphores().

535 {
536  bool found;
537 
538  CommitTsCtl->PagePrecedes = CommitTsPagePrecedes;
540  CommitTsSLRULock, "pg_commit_ts",
544 
545  commitTsShared = ShmemInitStruct("CommitTs shared",
546  sizeof(CommitTimestampShared),
547  &found);
548 
549  if (!IsUnderPostmaster)
550  {
551  Assert(!found);
552 
557  }
558  else
559  Assert(found);
560 }
CommitTimestampEntry dataLastCommit
Definition: commit_ts.c:95
#define CommitTsCtl
Definition: commit_ts.c:79
Size CommitTsShmemBuffers(void)
Definition: commit_ts.c:514
void SimpleLruInit(SlruCtl ctl, const char *name, int nslots, int nlsns, LWLock *ctllock, const char *subdir, int tranche_id, SyncRequestHandler sync_handler)
Definition: slru.c:186
#define COMMIT_TS_XACTS_PER_PAGE
Definition: commit_ts.c:66
void * ShmemInitStruct(const char *name, Size size, bool *foundPtr)
Definition: shmem.c:396
bool IsUnderPostmaster
Definition: globals.c:112
#define InvalidTransactionId
Definition: transam.h:31
#define TIMESTAMP_NOBEGIN(j)
Definition: timestamp.h:112
TimestampTz time
Definition: commit_ts.c:59
static bool CommitTsPagePrecedes(int page1, int page2)
Definition: commit_ts.c:937
TransactionId xidLastCommit
Definition: commit_ts.c:94
#define Assert(condition)
Definition: c.h:804
#define InvalidRepOriginId
Definition: origin.h:33
#define SlruPagePrecedesUnitTests(ctl, per_page)
Definition: slru.h:156
RepOriginId nodeid
Definition: commit_ts.c:60
CommitTimestampShared * commitTsShared
Definition: commit_ts.c:99

◆ CommitTsShmemSize()

Size CommitTsShmemSize ( void  )

Definition at line 523 of file commit_ts.c.

References CommitTsShmemBuffers(), and SimpleLruShmemSize().

Referenced by CreateSharedMemoryAndSemaphores().

524 {
526  sizeof(CommitTimestampShared);
527 }
Size SimpleLruShmemSize(int nslots, int nlsns)
Definition: slru.c:155
Size CommitTsShmemBuffers(void)
Definition: commit_ts.c:514
struct CommitTimestampShared CommitTimestampShared

◆ committssyncfiletag()

int committssyncfiletag ( const FileTag ftag,
char *  path 
)

Definition at line 1027 of file commit_ts.c.

References CommitTsCtl, and SlruSyncFileTag().

1028 {
1029  return SlruSyncFileTag(CommitTsCtl, ftag, path);
1030 }
int SlruSyncFileTag(SlruCtl ctl, const FileTag *ftag, char *path)
Definition: slru.c:1592
#define CommitTsCtl
Definition: commit_ts.c:79

◆ CompleteCommitTsInitialization()

void CompleteCommitTsInitialization ( void  )

Definition at line 615 of file commit_ts.c.

References ActivateCommitTs(), DeactivateCommitTs(), and track_commit_timestamp.

Referenced by StartupXLOG().

616 {
617  /*
618  * If the feature is not enabled, turn it off for good. This also removes
619  * any leftover data.
620  *
621  * Conversely, we activate the module if the feature is enabled. This is
622  * necessary for primary and standby as the activation depends on the
623  * control file contents at the beginning of recovery or when a
624  * XLOG_PARAMETER_CHANGE is replayed.
625  */
628  else
630 }
bool track_commit_timestamp
Definition: commit_ts.c:103
static void ActivateCommitTs(void)
Definition: commit_ts.c:678
static void DeactivateCommitTs(void)
Definition: commit_ts.c:752

◆ DeactivateCommitTs()

static void DeactivateCommitTs ( void  )
static

Definition at line 752 of file commit_ts.c.

References CommitTimestampShared::commitTsActive, CommitTsCtl, CommitTimestampShared::dataLastCommit, InvalidRepOriginId, InvalidTransactionId, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), VariableCacheData::newestCommitTsXid, CommitTimestampEntry::nodeid, VariableCacheData::oldestCommitTsXid, ShmemVariableCache, SlruScanDirCbDeleteAll(), SlruScanDirectory(), CommitTimestampEntry::time, TIMESTAMP_NOBEGIN, and CommitTimestampShared::xidLastCommit.

Referenced by CommitTsParameterChange(), and CompleteCommitTsInitialization().

753 {
754  /*
755  * Cleanup the status in the shared memory.
756  *
757  * We reset everything in the commitTsShared record to prevent user from
758  * getting confusing data about last committed transaction on the standby
759  * when the module was activated repeatedly on the primary.
760  */
761  LWLockAcquire(CommitTsLock, LW_EXCLUSIVE);
762 
767 
770 
771  LWLockRelease(CommitTsLock);
772 
773  /*
774  * Remove *all* files. This is necessary so that there are no leftover
775  * files; in the case where this feature is later enabled after running
776  * with it disabled for some time there may be a gap in the file sequence.
777  * (We can probably tolerate out-of-sequence files, as they are going to
778  * be overwritten anyway when we wrap around, but it seems better to be
779  * tidy.)
780  */
781  LWLockAcquire(CommitTsSLRULock, LW_EXCLUSIVE);
783  LWLockRelease(CommitTsSLRULock);
784 }
CommitTimestampEntry dataLastCommit
Definition: commit_ts.c:95
bool SlruScanDirCbDeleteAll(SlruCtl ctl, char *filename, int segpage, void *data)
Definition: slru.c:1529
#define CommitTsCtl
Definition: commit_ts.c:79
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1816
VariableCache ShmemVariableCache
Definition: varsup.c:34
#define InvalidTransactionId
Definition: transam.h:31
#define TIMESTAMP_NOBEGIN(j)
Definition: timestamp.h:112
TransactionId oldestCommitTsXid
Definition: transam.h:225
TimestampTz time
Definition: commit_ts.c:59
TransactionId xidLastCommit
Definition: commit_ts.c:94
bool SlruScanDirectory(SlruCtl ctl, SlruScanCallback callback, void *data)
Definition: slru.c:1552
TransactionId newestCommitTsXid
Definition: transam.h:226
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1203
#define InvalidRepOriginId
Definition: origin.h:33
RepOriginId nodeid
Definition: commit_ts.c:60
CommitTimestampShared * commitTsShared
Definition: commit_ts.c:99

◆ error_commit_ts_disabled()

static void error_commit_ts_disabled ( void  )
static

Definition at line 372 of file commit_ts.c.

References ereport, errcode(), errhint(), errmsg(), ERROR, and RecoveryInProgress().

Referenced by GetLatestCommitTsData(), and TransactionIdGetCommitTsData().

373 {
374  ereport(ERROR,
375  (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
376  errmsg("could not get commit timestamp data"),
378  errhint("Make sure the configuration parameter \"%s\" is set on the primary server.",
379  "track_commit_timestamp") :
380  errhint("Make sure the configuration parameter \"%s\" is set.",
381  "track_commit_timestamp")));
382 }
int errhint(const char *fmt,...)
Definition: elog.c:1156
int errcode(int sqlerrcode)
Definition: elog.c:698
bool RecoveryInProgress(void)
Definition: xlog.c:8212
#define ERROR
Definition: elog.h:46
#define ereport(elevel,...)
Definition: elog.h:157
int errmsg(const char *fmt,...)
Definition: elog.c:909

◆ ExtendCommitTs()

void ExtendCommitTs ( TransactionId  newestXact)

Definition at line 812 of file commit_ts.c.

References Assert, CommitTimestampShared::commitTsActive, FirstNormalTransactionId, InRecovery, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), TransactionIdEquals, TransactionIdToCTsEntry, TransactionIdToCTsPage, and ZeroCommitTsPage().

Referenced by GetNewTransactionId().

813 {
814  int pageno;
815 
816  /*
817  * Nothing to do if module not enabled. Note we do an unlocked read of
818  * the flag here, which is okay because this routine is only called from
819  * GetNewTransactionId, which is never called in a standby.
820  */
821  Assert(!InRecovery);
823  return;
824 
825  /*
826  * No work except at first XID of a page. But beware: just after
827  * wraparound, the first XID of page zero is FirstNormalTransactionId.
828  */
829  if (TransactionIdToCTsEntry(newestXact) != 0 &&
831  return;
832 
833  pageno = TransactionIdToCTsPage(newestXact);
834 
835  LWLockAcquire(CommitTsSLRULock, LW_EXCLUSIVE);
836 
837  /* Zero the page and make an XLOG entry about it */
838  ZeroCommitTsPage(pageno, !InRecovery);
839 
840  LWLockRelease(CommitTsSLRULock);
841 }
#define TransactionIdEquals(id1, id2)
Definition: transam.h:43
static int ZeroCommitTsPage(int pageno, bool writeXlog)
Definition: commit_ts.c:588
bool InRecovery
Definition: xlog.c:207
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1816
#define FirstNormalTransactionId
Definition: transam.h:34
#define TransactionIdToCTsPage(xid)
Definition: commit_ts.c:69
#define Assert(condition)
Definition: c.h:804
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1203
#define TransactionIdToCTsEntry(xid)
Definition: commit_ts.c:71
CommitTimestampShared * commitTsShared
Definition: commit_ts.c:99

◆ GetLatestCommitTsData()

TransactionId GetLatestCommitTsData ( TimestampTz ts,
RepOriginId nodeid 
)

Definition at line 351 of file commit_ts.c.

References CommitTimestampShared::commitTsActive, CommitTimestampShared::dataLastCommit, error_commit_ts_disabled(), LW_SHARED, LWLockAcquire(), LWLockRelease(), CommitTimestampEntry::nodeid, CommitTimestampEntry::time, and CommitTimestampShared::xidLastCommit.

Referenced by pg_last_committed_xact().

352 {
353  TransactionId xid;
354 
355  LWLockAcquire(CommitTsLock, LW_SHARED);
356 
357  /* Error if module not enabled */
360 
362  if (ts)
364  if (nodeid)
366  LWLockRelease(CommitTsLock);
367 
368  return xid;
369 }
CommitTimestampEntry dataLastCommit
Definition: commit_ts.c:95
uint32 TransactionId
Definition: c.h:587
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1816
TimestampTz time
Definition: commit_ts.c:59
TransactionId xidLastCommit
Definition: commit_ts.c:94
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1203
RepOriginId nodeid
Definition: commit_ts.c:60
CommitTimestampShared * commitTsShared
Definition: commit_ts.c:99
static void error_commit_ts_disabled(void)
Definition: commit_ts.c:372

◆ pg_last_committed_xact()

Datum pg_last_committed_xact ( PG_FUNCTION_ARGS  )

Definition at line 411 of file commit_ts.c.

References BlessTupleDesc(), CreateTemplateTupleDesc(), GetLatestCommitTsData(), heap_form_tuple(), HeapTupleGetDatum, CommitTimestampEntry::nodeid, ObjectIdGetDatum, PG_RETURN_DATUM, TimestampTzGetDatum, TransactionIdGetDatum, TransactionIdIsNormal, TupleDescInitEntry(), and values.

412 {
413  TransactionId xid;
414  RepOriginId nodeid;
415  TimestampTz ts;
416  Datum values[3];
417  bool nulls[3];
418  TupleDesc tupdesc;
419  HeapTuple htup;
420 
421  /* and construct a tuple with our data */
422  xid = GetLatestCommitTsData(&ts, &nodeid);
423 
424  /*
425  * Construct a tuple descriptor for the result row. This must match this
426  * function's pg_proc entry!
427  */
428  tupdesc = CreateTemplateTupleDesc(3);
429  TupleDescInitEntry(tupdesc, (AttrNumber) 1, "xid",
430  XIDOID, -1, 0);
431  TupleDescInitEntry(tupdesc, (AttrNumber) 2, "timestamp",
432  TIMESTAMPTZOID, -1, 0);
433  TupleDescInitEntry(tupdesc, (AttrNumber) 3, "roident",
434  OIDOID, -1, 0);
435  tupdesc = BlessTupleDesc(tupdesc);
436 
437  if (!TransactionIdIsNormal(xid))
438  {
439  memset(nulls, true, sizeof(nulls));
440  }
441  else
442  {
443  values[0] = TransactionIdGetDatum(xid);
444  nulls[0] = false;
445 
446  values[1] = TimestampTzGetDatum(ts);
447  nulls[1] = false;
448 
449  values[2] = ObjectIdGetDatum((Oid) nodeid);
450  nulls[2] = false;
451  }
452 
453  htup = heap_form_tuple(tupdesc, values, nulls);
454 
456 }
uint32 TransactionId
Definition: c.h:587
TupleDesc CreateTemplateTupleDesc(int natts)
Definition: tupdesc.c:45
int64 TimestampTz
Definition: timestamp.h:39
uint16 RepOriginId
Definition: xlogdefs.h:65
HeapTuple heap_form_tuple(TupleDesc tupleDescriptor, Datum *values, bool *isnull)
Definition: heaptuple.c:1020
unsigned int Oid
Definition: postgres_ext.h:31
#define ObjectIdGetDatum(X)
Definition: postgres.h:551
#define TimestampTzGetDatum(X)
Definition: timestamp.h:32
TupleDesc BlessTupleDesc(TupleDesc tupdesc)
Definition: execTuples.c:2082
void TupleDescInitEntry(TupleDesc desc, AttrNumber attributeNumber, const char *attributeName, Oid oidtypeid, int32 typmod, int attdim)
Definition: tupdesc.c:580
#define TransactionIdGetDatum(X)
Definition: postgres.h:565
uintptr_t Datum
Definition: postgres.h:411
#define PG_RETURN_DATUM(x)
Definition: fmgr.h:353
#define HeapTupleGetDatum(tuple)
Definition: funcapi.h:221
static Datum values[MAXATTR]
Definition: bootstrap.c:166
#define TransactionIdIsNormal(xid)
Definition: transam.h:42
int16 AttrNumber
Definition: attnum.h:21
TransactionId GetLatestCommitTsData(TimestampTz *ts, RepOriginId *nodeid)
Definition: commit_ts.c:351

◆ pg_xact_commit_timestamp()

Datum pg_xact_commit_timestamp ( PG_FUNCTION_ARGS  )

Definition at line 388 of file commit_ts.c.

References PG_GETARG_TRANSACTIONID, PG_RETURN_NULL, PG_RETURN_TIMESTAMPTZ, and TransactionIdGetCommitTsData().

389 {
391  TimestampTz ts;
392  bool found;
393 
394  found = TransactionIdGetCommitTsData(xid, &ts, NULL);
395 
396  if (!found)
397  PG_RETURN_NULL();
398 
400 }
uint32 TransactionId
Definition: c.h:587
int64 TimestampTz
Definition: timestamp.h:39
#define PG_RETURN_TIMESTAMPTZ(x)
Definition: timestamp.h:40
#define PG_GETARG_TRANSACTIONID(n)
Definition: fmgr.h:279
bool TransactionIdGetCommitTsData(TransactionId xid, TimestampTz *ts, RepOriginId *nodeid)
Definition: commit_ts.c:265
#define PG_RETURN_NULL()
Definition: fmgr.h:345

◆ pg_xact_commit_timestamp_origin()

Datum pg_xact_commit_timestamp_origin ( PG_FUNCTION_ARGS  )

Definition at line 465 of file commit_ts.c.

References BlessTupleDesc(), CreateTemplateTupleDesc(), heap_form_tuple(), HeapTupleGetDatum, CommitTimestampEntry::nodeid, ObjectIdGetDatum, PG_GETARG_TRANSACTIONID, PG_RETURN_DATUM, TimestampTzGetDatum, TransactionIdGetCommitTsData(), TupleDescInitEntry(), and values.

466 {
468  RepOriginId nodeid;
469  TimestampTz ts;
470  Datum values[2];
471  bool nulls[2];
472  TupleDesc tupdesc;
473  HeapTuple htup;
474  bool found;
475 
476  found = TransactionIdGetCommitTsData(xid, &ts, &nodeid);
477 
478  /*
479  * Construct a tuple descriptor for the result row. This must match this
480  * function's pg_proc entry!
481  */
482  tupdesc = CreateTemplateTupleDesc(2);
483  TupleDescInitEntry(tupdesc, (AttrNumber) 1, "timestamp",
484  TIMESTAMPTZOID, -1, 0);
485  TupleDescInitEntry(tupdesc, (AttrNumber) 2, "roident",
486  OIDOID, -1, 0);
487  tupdesc = BlessTupleDesc(tupdesc);
488 
489  if (!found)
490  {
491  memset(nulls, true, sizeof(nulls));
492  }
493  else
494  {
495  values[0] = TimestampTzGetDatum(ts);
496  nulls[0] = false;
497 
498  values[1] = ObjectIdGetDatum((Oid) nodeid);
499  nulls[1] = false;
500  }
501 
502  htup = heap_form_tuple(tupdesc, values, nulls);
503 
505 }
uint32 TransactionId
Definition: c.h:587
TupleDesc CreateTemplateTupleDesc(int natts)
Definition: tupdesc.c:45
int64 TimestampTz
Definition: timestamp.h:39
uint16 RepOriginId
Definition: xlogdefs.h:65
HeapTuple heap_form_tuple(TupleDesc tupleDescriptor, Datum *values, bool *isnull)
Definition: heaptuple.c:1020
unsigned int Oid
Definition: postgres_ext.h:31
#define ObjectIdGetDatum(X)
Definition: postgres.h:551
#define TimestampTzGetDatum(X)
Definition: timestamp.h:32
TupleDesc BlessTupleDesc(TupleDesc tupdesc)
Definition: execTuples.c:2082
#define PG_GETARG_TRANSACTIONID(n)
Definition: fmgr.h:279
void TupleDescInitEntry(TupleDesc desc, AttrNumber attributeNumber, const char *attributeName, Oid oidtypeid, int32 typmod, int attdim)
Definition: tupdesc.c:580
bool TransactionIdGetCommitTsData(TransactionId xid, TimestampTz *ts, RepOriginId *nodeid)
Definition: commit_ts.c:265
uintptr_t Datum
Definition: postgres.h:411
#define PG_RETURN_DATUM(x)
Definition: fmgr.h:353
#define HeapTupleGetDatum(tuple)
Definition: funcapi.h:221
static Datum values[MAXATTR]
Definition: bootstrap.c:166
int16 AttrNumber
Definition: attnum.h:21

◆ SetCommitTsLimit()

void SetCommitTsLimit ( TransactionId  oldestXact,
TransactionId  newestXact 
)

Definition at line 876 of file commit_ts.c.

References Assert, InvalidTransactionId, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), VariableCacheData::newestCommitTsXid, VariableCacheData::oldestCommitTsXid, ShmemVariableCache, and TransactionIdPrecedes().

Referenced by BootStrapXLOG(), and StartupXLOG().

877 {
878  /*
879  * Be careful not to overwrite values that are either further into the
880  * "future" or signal a disabled committs.
881  */
882  LWLockAcquire(CommitTsLock, LW_EXCLUSIVE);
884  {
889  }
890  else
891  {
895  }
896  LWLockRelease(CommitTsLock);
897 }
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1816
VariableCache ShmemVariableCache
Definition: varsup.c:34
#define InvalidTransactionId
Definition: transam.h:31
TransactionId oldestCommitTsXid
Definition: transam.h:225
bool TransactionIdPrecedes(TransactionId id1, TransactionId id2)
Definition: transam.c:300
#define Assert(condition)
Definition: c.h:804
TransactionId newestCommitTsXid
Definition: transam.h:226
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1203

◆ SetXidCommitTsInPage()

static void SetXidCommitTsInPage ( TransactionId  xid,
int  nsubxids,
TransactionId subxids,
TimestampTz  ts,
RepOriginId  nodeid,
int  pageno 
)
static

Definition at line 214 of file commit_ts.c.

References CommitTsCtl, i, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), SimpleLruReadPage(), and TransactionIdSetCommitTs().

Referenced by TransactionTreeSetCommitTsData().

217 {
218  int slotno;
219  int i;
220 
221  LWLockAcquire(CommitTsSLRULock, LW_EXCLUSIVE);
222 
223  slotno = SimpleLruReadPage(CommitTsCtl, pageno, true, xid);
224 
225  TransactionIdSetCommitTs(xid, ts, nodeid, slotno);
226  for (i = 0; i < nsubxids; i++)
227  TransactionIdSetCommitTs(subxids[i], ts, nodeid, slotno);
228 
229  CommitTsCtl->shared->page_dirty[slotno] = true;
230 
231  LWLockRelease(CommitTsSLRULock);
232 }
#define CommitTsCtl
Definition: commit_ts.c:79
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1816
static void TransactionIdSetCommitTs(TransactionId xid, TimestampTz ts, RepOriginId nodeid, int slotno)
Definition: commit_ts.c:240
int SimpleLruReadPage(SlruCtl ctl, int pageno, bool write_ok, TransactionId xid)
Definition: slru.c:394
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1203
int i

◆ StartupCommitTs()

void StartupCommitTs ( void  )

Definition at line 605 of file commit_ts.c.

References ActivateCommitTs().

Referenced by StartupXLOG().

606 {
608 }
static void ActivateCommitTs(void)
Definition: commit_ts.c:678

◆ TransactionIdGetCommitTsData()

bool TransactionIdGetCommitTsData ( TransactionId  xid,
TimestampTz ts,
RepOriginId nodeid 
)

Definition at line 265 of file commit_ts.c.

References Assert, CommitTimestampShared::commitTsActive, CommitTsCtl, CommitTimestampShared::dataLastCommit, ereport, errcode(), errmsg(), ERROR, error_commit_ts_disabled(), InvalidRepOriginId, LW_SHARED, LWLockAcquire(), LWLockRelease(), VariableCacheData::newestCommitTsXid, CommitTimestampEntry::nodeid, VariableCacheData::oldestCommitTsXid, ShmemVariableCache, SimpleLruReadPage_ReadOnly(), SizeOfCommitTimestampEntry, CommitTimestampEntry::time, TransactionIdIsNormal, TransactionIdIsValid, TransactionIdPrecedes(), TransactionIdToCTsEntry, TransactionIdToCTsPage, and CommitTimestampShared::xidLastCommit.

Referenced by pg_xact_commit_timestamp(), and pg_xact_commit_timestamp_origin().

267 {
268  int pageno = TransactionIdToCTsPage(xid);
269  int entryno = TransactionIdToCTsEntry(xid);
270  int slotno;
271  CommitTimestampEntry entry;
272  TransactionId oldestCommitTsXid;
273  TransactionId newestCommitTsXid;
274 
275  if (!TransactionIdIsValid(xid))
276  ereport(ERROR,
277  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
278  errmsg("cannot retrieve commit timestamp for transaction %u", xid)));
279  else if (!TransactionIdIsNormal(xid))
280  {
281  /* frozen and bootstrap xids are always committed far in the past */
282  *ts = 0;
283  if (nodeid)
284  *nodeid = 0;
285  return false;
286  }
287 
288  LWLockAcquire(CommitTsLock, LW_SHARED);
289 
290  /* Error if module not enabled */
293 
294  /*
295  * If we're asked for the cached value, return that. Otherwise, fall
296  * through to read from SLRU.
297  */
298  if (commitTsShared->xidLastCommit == xid)
299  {
301  if (nodeid)
303 
304  LWLockRelease(CommitTsLock);
305  return *ts != 0;
306  }
307 
308  oldestCommitTsXid = ShmemVariableCache->oldestCommitTsXid;
309  newestCommitTsXid = ShmemVariableCache->newestCommitTsXid;
310  /* neither is invalid, or both are */
311  Assert(TransactionIdIsValid(oldestCommitTsXid) == TransactionIdIsValid(newestCommitTsXid));
312  LWLockRelease(CommitTsLock);
313 
314  /*
315  * Return empty if the requested value is outside our valid range.
316  */
317  if (!TransactionIdIsValid(oldestCommitTsXid) ||
318  TransactionIdPrecedes(xid, oldestCommitTsXid) ||
319  TransactionIdPrecedes(newestCommitTsXid, xid))
320  {
321  *ts = 0;
322  if (nodeid)
323  *nodeid = InvalidRepOriginId;
324  return false;
325  }
326 
327  /* lock is acquired by SimpleLruReadPage_ReadOnly */
328  slotno = SimpleLruReadPage_ReadOnly(CommitTsCtl, pageno, xid);
329  memcpy(&entry,
330  CommitTsCtl->shared->page_buffer[slotno] +
331  SizeOfCommitTimestampEntry * entryno,
333 
334  *ts = entry.time;
335  if (nodeid)
336  *nodeid = entry.nodeid;
337 
338  LWLockRelease(CommitTsSLRULock);
339  return *ts != 0;
340 }
CommitTimestampEntry dataLastCommit
Definition: commit_ts.c:95
uint32 TransactionId
Definition: c.h:587
#define SizeOfCommitTimestampEntry
Definition: commit_ts.c:63
#define CommitTsCtl
Definition: commit_ts.c:79
int errcode(int sqlerrcode)
Definition: elog.c:698
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1816
#define ERROR
Definition: elog.h:46
VariableCache ShmemVariableCache
Definition: varsup.c:34
TransactionId oldestCommitTsXid
Definition: transam.h:225
bool TransactionIdPrecedes(TransactionId id1, TransactionId id2)
Definition: transam.c:300
TimestampTz time
Definition: commit_ts.c:59
#define TransactionIdToCTsPage(xid)
Definition: commit_ts.c:69
TransactionId xidLastCommit
Definition: commit_ts.c:94
int SimpleLruReadPage_ReadOnly(SlruCtl ctl, int pageno, TransactionId xid)
Definition: slru.c:494
#define ereport(elevel,...)
Definition: elog.h:157
#define Assert(condition)
Definition: c.h:804
TransactionId newestCommitTsXid
Definition: transam.h:226
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1203
#define TransactionIdToCTsEntry(xid)
Definition: commit_ts.c:71
#define InvalidRepOriginId
Definition: origin.h:33
int errmsg(const char *fmt,...)
Definition: elog.c:909
#define TransactionIdIsValid(xid)
Definition: transam.h:41
#define TransactionIdIsNormal(xid)
Definition: transam.h:42
RepOriginId nodeid
Definition: commit_ts.c:60
CommitTimestampShared * commitTsShared
Definition: commit_ts.c:99
static void error_commit_ts_disabled(void)
Definition: commit_ts.c:372

◆ TransactionIdSetCommitTs()

static void TransactionIdSetCommitTs ( TransactionId  xid,
TimestampTz  ts,
RepOriginId  nodeid,
int  slotno 
)
static

Definition at line 240 of file commit_ts.c.

References Assert, CommitTsCtl, CommitTimestampEntry::nodeid, SizeOfCommitTimestampEntry, CommitTimestampEntry::time, TransactionIdIsNormal, and TransactionIdToCTsEntry.

Referenced by SetXidCommitTsInPage().

242 {
243  int entryno = TransactionIdToCTsEntry(xid);
244  CommitTimestampEntry entry;
245 
247 
248  entry.time = ts;
249  entry.nodeid = nodeid;
250 
251  memcpy(CommitTsCtl->shared->page_buffer[slotno] +
252  SizeOfCommitTimestampEntry * entryno,
254 }
#define SizeOfCommitTimestampEntry
Definition: commit_ts.c:63
#define CommitTsCtl
Definition: commit_ts.c:79
TimestampTz time
Definition: commit_ts.c:59
#define Assert(condition)
Definition: c.h:804
#define TransactionIdToCTsEntry(xid)
Definition: commit_ts.c:71
#define TransactionIdIsNormal(xid)
Definition: transam.h:42
RepOriginId nodeid
Definition: commit_ts.c:60

◆ TransactionTreeSetCommitTsData()

void TransactionTreeSetCommitTsData ( TransactionId  xid,
int  nsubxids,
TransactionId subxids,
TimestampTz  timestamp,
RepOriginId  nodeid 
)

Definition at line 135 of file commit_ts.c.

References CommitTimestampShared::commitTsActive, CommitTimestampShared::dataLastCommit, i, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), VariableCacheData::newestCommitTsXid, CommitTimestampEntry::nodeid, SetXidCommitTsInPage(), ShmemVariableCache, CommitTimestampEntry::time, TransactionIdPrecedes(), TransactionIdToCTsPage, and CommitTimestampShared::xidLastCommit.

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

138 {
139  int i;
140  TransactionId headxid;
141  TransactionId newestXact;
142 
143  /*
144  * No-op if the module is not active.
145  *
146  * An unlocked read here is fine, because in a standby (the only place
147  * where the flag can change in flight) this routine is only called by the
148  * recovery process, which is also the only process which can change the
149  * flag.
150  */
152  return;
153 
154  /*
155  * Figure out the latest Xid in this batch: either the last subxid if
156  * there's any, otherwise the parent xid.
157  */
158  if (nsubxids > 0)
159  newestXact = subxids[nsubxids - 1];
160  else
161  newestXact = xid;
162 
163  /*
164  * We split the xids to set the timestamp to in groups belonging to the
165  * same SLRU page; the first element in each such set is its head. The
166  * first group has the main XID as the head; subsequent sets use the first
167  * subxid not on the previous page as head. This way, we only have to
168  * lock/modify each SLRU page once.
169  */
170  for (i = 0, headxid = xid;;)
171  {
172  int pageno = TransactionIdToCTsPage(headxid);
173  int j;
174 
175  for (j = i; j < nsubxids; j++)
176  {
177  if (TransactionIdToCTsPage(subxids[j]) != pageno)
178  break;
179  }
180  /* subxids[i..j] are on the same page as the head */
181 
182  SetXidCommitTsInPage(headxid, j - i, subxids + i, timestamp, nodeid,
183  pageno);
184 
185  /* if we wrote out all subxids, we're done. */
186  if (j + 1 >= nsubxids)
187  break;
188 
189  /*
190  * Set the new head and skip over it, as well as over the subxids we
191  * just wrote.
192  */
193  headxid = subxids[j];
194  i += j - i + 1;
195  }
196 
197  /* update the cached value in shared memory */
198  LWLockAcquire(CommitTsLock, LW_EXCLUSIVE);
202 
203  /* and move forwards our endpoint, if needed */
206  LWLockRelease(CommitTsLock);
207 }
CommitTimestampEntry dataLastCommit
Definition: commit_ts.c:95
uint32 TransactionId
Definition: c.h:587
int64 timestamp
static void SetXidCommitTsInPage(TransactionId xid, int nsubxids, TransactionId *subxids, TimestampTz ts, RepOriginId nodeid, int pageno)
Definition: commit_ts.c:214
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1816
VariableCache ShmemVariableCache
Definition: varsup.c:34
bool TransactionIdPrecedes(TransactionId id1, TransactionId id2)
Definition: transam.c:300
TimestampTz time
Definition: commit_ts.c:59
#define TransactionIdToCTsPage(xid)
Definition: commit_ts.c:69
TransactionId xidLastCommit
Definition: commit_ts.c:94
TransactionId newestCommitTsXid
Definition: transam.h:226
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1203
int i
RepOriginId nodeid
Definition: commit_ts.c:60
CommitTimestampShared * commitTsShared
Definition: commit_ts.c:99

◆ TruncateCommitTs()

void TruncateCommitTs ( TransactionId  oldestXact)

Definition at line 850 of file commit_ts.c.

References CommitTsCtl, SimpleLruTruncate(), SlruScanDirCbReportPresence(), SlruScanDirectory(), TransactionIdToCTsPage, and WriteTruncateXlogRec().

Referenced by vac_truncate_clog().

851 {
852  int cutoffPage;
853 
854  /*
855  * The cutoff point is the start of the segment containing oldestXact. We
856  * pass the *page* containing oldestXact to SimpleLruTruncate.
857  */
858  cutoffPage = TransactionIdToCTsPage(oldestXact);
859 
860  /* Check to see if there's any files that could be removed */
862  &cutoffPage))
863  return; /* nothing to remove */
864 
865  /* Write XLOG record */
866  WriteTruncateXlogRec(cutoffPage, oldestXact);
867 
868  /* Now we can remove the old CommitTs segment(s) */
869  SimpleLruTruncate(CommitTsCtl, cutoffPage);
870 }
#define CommitTsCtl
Definition: commit_ts.c:79
void SimpleLruTruncate(SlruCtl ctl, int cutoffPage)
Definition: slru.c:1225
static void WriteTruncateXlogRec(int pageno, TransactionId oldestXid)
Definition: commit_ts.c:967
bool SlruScanDirCbReportPresence(SlruCtl ctl, char *filename, int segpage, void *data)
Definition: slru.c:1499
#define TransactionIdToCTsPage(xid)
Definition: commit_ts.c:69
bool SlruScanDirectory(SlruCtl ctl, SlruScanCallback callback, void *data)
Definition: slru.c:1552

◆ WriteTruncateXlogRec()

static void WriteTruncateXlogRec ( int  pageno,
TransactionId  oldestXid 
)
static

Definition at line 967 of file commit_ts.c.

References COMMIT_TS_TRUNCATE, xl_commit_ts_truncate::oldestXid, xl_commit_ts_truncate::pageno, SizeOfCommitTsTruncate, XLogBeginInsert(), XLogInsert(), and XLogRegisterData().

Referenced by TruncateCommitTs().

968 {
969  xl_commit_ts_truncate xlrec;
970 
971  xlrec.pageno = pageno;
972  xlrec.oldestXid = oldestXid;
973 
974  XLogBeginInsert();
975  XLogRegisterData((char *) (&xlrec), SizeOfCommitTsTruncate);
976  (void) XLogInsert(RM_COMMIT_TS_ID, COMMIT_TS_TRUNCATE);
977 }
TransactionId oldestXid
Definition: commit_ts.h:68
void XLogRegisterData(char *data, int len)
Definition: xloginsert.c:330
XLogRecPtr XLogInsert(RmgrId rmid, uint8 info)
Definition: xloginsert.c:422
#define COMMIT_TS_TRUNCATE
Definition: commit_ts.h:52
void XLogBeginInsert(void)
Definition: xloginsert.c:123
#define SizeOfCommitTsTruncate
Definition: commit_ts.h:71

◆ WriteZeroPageXlogRec()

static void WriteZeroPageXlogRec ( int  pageno)
static

Definition at line 956 of file commit_ts.c.

References COMMIT_TS_ZEROPAGE, XLogBeginInsert(), XLogInsert(), and XLogRegisterData().

Referenced by ZeroCommitTsPage().

957 {
958  XLogBeginInsert();
959  XLogRegisterData((char *) (&pageno), sizeof(int));
960  (void) XLogInsert(RM_COMMIT_TS_ID, COMMIT_TS_ZEROPAGE);
961 }
#define COMMIT_TS_ZEROPAGE
Definition: commit_ts.h:51
void XLogRegisterData(char *data, int len)
Definition: xloginsert.c:330
XLogRecPtr XLogInsert(RmgrId rmid, uint8 info)
Definition: xloginsert.c:422
void XLogBeginInsert(void)
Definition: xloginsert.c:123

◆ ZeroCommitTsPage()

static int ZeroCommitTsPage ( int  pageno,
bool  writeXlog 
)
static

Definition at line 588 of file commit_ts.c.

References CommitTsCtl, SimpleLruZeroPage(), and WriteZeroPageXlogRec().

Referenced by ActivateCommitTs(), commit_ts_redo(), and ExtendCommitTs().

589 {
590  int slotno;
591 
592  slotno = SimpleLruZeroPage(CommitTsCtl, pageno);
593 
594  if (writeXlog)
595  WriteZeroPageXlogRec(pageno);
596 
597  return slotno;
598 }
#define CommitTsCtl
Definition: commit_ts.c:79
static void WriteZeroPageXlogRec(int pageno)
Definition: commit_ts.c:956
int SimpleLruZeroPage(SlruCtl ctl, int pageno)
Definition: slru.c:279

Variable Documentation

◆ CommitTsCtlData

SlruCtlData CommitTsCtlData
static

Definition at line 77 of file commit_ts.c.

◆ commitTsShared

CommitTimestampShared* commitTsShared

Definition at line 99 of file commit_ts.c.

◆ track_commit_timestamp

bool track_commit_timestamp