PostgreSQL Source Code git master
Data Structures | Macros | Typedefs | Functions | Variables
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 "access/xloginsert.h"
#include "access/xlogutils.h"
#include "funcapi.h"
#include "miscadmin.h"
#include "storage/shmem.h"
#include "utils/fmgrprotos.h"
#include "utils/guc_hooks.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  TransactionIdToCTsEntry(xid)    ((xid) % (TransactionId) COMMIT_TS_XACTS_PER_PAGE)
 
#define  CommitTsCtl   (&CommitTsCtlData)
 

Typedefs

typedef struct CommitTimestampEntry  CommitTimestampEntry
 
typedef struct CommitTimestampShared  CommitTimestampShared
 

Functions

static int64  TransactionIdToCTsPage (TransactionId xid)
 
static void  SetXidCommitTsInPage (TransactionId xid, int nsubxids, TransactionId *subxids, TimestampTz ts, RepOriginId nodeid, int64 pageno)
 
static void  TransactionIdSetCommitTs (TransactionId xid, TimestampTz ts, RepOriginId nodeid, int slotno)
 
static void  error_commit_ts_disabled (void)
 
static bool  CommitTsPagePrecedes (int64 page1, int64 page2)
 
static void  ActivateCommitTs (void)
 
static void  DeactivateCommitTs (void)
 
static void  WriteTruncateXlogRec (int64 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)
 
static int  CommitTsShmemBuffers (void)
 
Size  CommitTsShmemSize (void)
 
void  CommitTsShmemInit (void)
 
bool  check_commit_ts_buffers (int *newval, void **extra, GucSource source)
 
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
 
static CommitTimestampShared *  commitTsShared
 
bool  track_commit_timestamp
 

Macro Definition Documentation

◆ COMMIT_TS_XACTS_PER_PAGE

#define COMMIT_TS_XACTS_PER_PAGE    (BLCKSZ / SizeOfCommitTimestampEntry)

Definition at line 63 of file commit_ts.c.

◆ CommitTsCtl

#define CommitTsCtl   (&CommitTsCtlData)

Definition at line 85 of file commit_ts.c.

◆ SizeOfCommitTimestampEntry

#define SizeOfCommitTimestampEntry
Value:
(offsetof(CommitTimestampEntry, nodeid) + \
sizeof(RepOriginId))
uint16 RepOriginId
Definition: xlogdefs.h:68

Definition at line 60 of file commit_ts.c.

◆ TransactionIdToCTsEntry

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

Definition at line 77 of file commit_ts.c.

Typedef Documentation

◆ CommitTimestampEntry

typedef struct CommitTimestampEntry CommitTimestampEntry

◆ CommitTimestampShared

typedef struct CommitTimestampShared CommitTimestampShared

Function Documentation

◆ ActivateCommitTs()

static void ActivateCommitTs ( void  )
static

Definition at line 681 of file commit_ts.c.

682{
683 TransactionId xid;
684 int64 pageno;
685
686 /*
687 * During bootstrap, we should not register commit timestamps so skip the
688 * activation in this case.
689 */
691 return;
692
693 /* If we've done this already, there's nothing to do */
694 LWLockAcquire(CommitTsLock, LW_EXCLUSIVE);
696 {
697 LWLockRelease(CommitTsLock);
698 return;
699 }
700 LWLockRelease(CommitTsLock);
701
703 pageno = TransactionIdToCTsPage(xid);
704
705 /*
706 * Re-Initialize our idea of the latest page number.
707 */
708 pg_atomic_write_u64(&CommitTsCtl->shared->latest_page_number, pageno);
709
710 /*
711 * If CommitTs is enabled, but it wasn't in the previous server run, we
712 * need to set the oldest and newest values to the next Xid; that way, we
713 * will not try to read data that might not have been set.
714 *
715 * XXX does this have a problem if a server is started with commitTs
716 * enabled, then started with commitTs disabled, then restarted with it
717 * enabled again? It doesn't look like it does, because there should be a
718 * checkpoint that sets the value to InvalidTransactionId at end of
719 * recovery; and so any chance of injecting new transactions without
720 * CommitTs values would occur after the oldestCommitTsXid has been set to
721 * Invalid temporarily.
722 */
723 LWLockAcquire(CommitTsLock, LW_EXCLUSIVE);
725 {
728 }
729 LWLockRelease(CommitTsLock);
730
731 /* Create the current segment file, if necessary */
734
735 /* Change the activation status in shared memory. */
736 LWLockAcquire(CommitTsLock, LW_EXCLUSIVE);
738 LWLockRelease(CommitTsLock);
739}
static void pg_atomic_write_u64(volatile pg_atomic_uint64 *ptr, uint64 val)
Definition: atomics.h:483
int64_t int64
Definition: c.h:535
uint32 TransactionId
Definition: c.h:657
static CommitTimestampShared * commitTsShared
Definition: commit_ts.c:105
static int64 TransactionIdToCTsPage(TransactionId xid)
Definition: commit_ts.c:72
#define CommitTsCtl
Definition: commit_ts.c:85
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 IsBootstrapProcessingMode()
Definition: miscadmin.h:476
bool SimpleLruDoesPhysicalPageExist(SlruCtl ctl, int64 pageno)
Definition: slru.c:771
void SimpleLruZeroAndWritePage(SlruCtl ctl, int64 pageno)
Definition: slru.c:444
TransactionId oldestCommitTsXid
Definition: transam.h:232
TransactionId newestCommitTsXid
Definition: transam.h:233
FullTransactionId nextXid
Definition: transam.h:220
static TransactionId ReadNextTransactionId(void)
Definition: transam.h:315
#define InvalidTransactionId
Definition: transam.h:31
#define XidFromFullTransactionId(x)
Definition: transam.h:48
TransamVariablesData * TransamVariables
Definition: varsup.c:34

References CommitTimestampShared::commitTsActive, CommitTsCtl, commitTsShared, InvalidTransactionId, IsBootstrapProcessingMode, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), TransamVariablesData::newestCommitTsXid, TransamVariablesData::nextXid, TransamVariablesData::oldestCommitTsXid, pg_atomic_write_u64(), ReadNextTransactionId(), SimpleLruDoesPhysicalPageExist(), SimpleLruZeroAndWritePage(), TransactionIdToCTsPage(), TransamVariables, and XidFromFullTransactionId.

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

◆ AdvanceOldestCommitTsXid()

void AdvanceOldestCommitTsXid ( TransactionId  oldestXact )

Definition at line 914 of file commit_ts.c.

915{
916 LWLockAcquire(CommitTsLock, LW_EXCLUSIVE);
920 LWLockRelease(CommitTsLock);
921}
bool TransactionIdPrecedes(TransactionId id1, TransactionId id2)
Definition: transam.c:280

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

Referenced by commit_ts_redo(), and vac_truncate_clog().

◆ BootStrapCommitTs()

void BootStrapCommitTs ( void  )

Definition at line 594 of file commit_ts.c.

595{
596 /*
597 * Nothing to do here at present, unlike most other SLRU modules; segments
598 * are created when the server is started with this module enabled. See
599 * ActivateCommitTs.
600 */
601}

Referenced by BootStrapXLOG().

◆ check_commit_ts_buffers()

bool check_commit_ts_buffers ( int *  newval,
void **  extra,
GucSource  source 
)

Definition at line 582 of file commit_ts.c.

583{
584 return check_slru_buffers("commit_timestamp_buffers", newval);
585}
#define newval
bool check_slru_buffers(const char *name, int *newval)
Definition: slru.c:355

References check_slru_buffers(), and newval.

◆ CheckPointCommitTs()

void CheckPointCommitTs ( void  )

Definition at line 794 of file commit_ts.c.

795{
796 /*
797 * Write dirty CommitTs pages to disk. This may result in sync requests
798 * queued for later handling by ProcessSyncRequests(), as part of the
799 * checkpoint.
800 */
802}
void SimpleLruWriteAll(SlruCtl ctl, bool allow_redirtied)
Definition: slru.c:1347

References CommitTsCtl, and SimpleLruWriteAll().

Referenced by CheckPointGuts().

◆ commit_ts_redo()

void commit_ts_redo ( XLogReaderState *  record )

Definition at line 983 of file commit_ts.c.

984{
985 uint8 info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
986
987 /* Backup blocks are not used in commit_ts records */
989
990 if (info == COMMIT_TS_ZEROPAGE)
991 {
992 int64 pageno;
993
994 memcpy(&pageno, XLogRecGetData(record), sizeof(pageno));
996 }
997 else if (info == COMMIT_TS_TRUNCATE)
998 {
1000
1002
1003 /*
1004 * During XLOG replay, latest_page_number isn't set up yet; insert a
1005 * suitable value to bypass the sanity test in SimpleLruTruncate.
1006 */
1007 pg_atomic_write_u64(&CommitTsCtl->shared->latest_page_number,
1008 trunc->pageno);
1009
1011 }
1012 else
1013 elog(PANIC, "commit_ts_redo: unknown op code %u", info);
1014}
uint8_t uint8
Definition: c.h:536
void AdvanceOldestCommitTsXid(TransactionId oldestXact)
Definition: commit_ts.c:914
#define COMMIT_TS_ZEROPAGE
Definition: commit_ts.h:46
#define COMMIT_TS_TRUNCATE
Definition: commit_ts.h:47
#define PANIC
Definition: elog.h:42
#define elog(elevel,...)
Definition: elog.h:226
Assert(PointerIsAligned(start, uint64))
void SimpleLruTruncate(SlruCtl ctl, int64 cutoffPage)
Definition: slru.c:1433
Definition: commit_ts.h:50
TransactionId oldestXid
Definition: commit_ts.h:52
int64 pageno
Definition: commit_ts.h:51
#define XLogRecGetInfo(decoder)
Definition: xlogreader.h:410
#define XLogRecGetData(decoder)
Definition: xlogreader.h:415
#define XLogRecHasAnyBlockRefs(decoder)
Definition: xlogreader.h:417

References AdvanceOldestCommitTsXid(), Assert(), COMMIT_TS_TRUNCATE, COMMIT_TS_ZEROPAGE, CommitTsCtl, elog, xl_commit_ts_truncate::oldestXid, xl_commit_ts_truncate::pageno, PANIC, pg_atomic_write_u64(), SimpleLruTruncate(), SimpleLruZeroAndWritePage(), XLogRecGetData, XLogRecGetInfo, and XLogRecHasAnyBlockRefs.

◆ CommitTsPagePrecedes()

static bool CommitTsPagePrecedes ( int64  page1,
int64  page2 
)
static

Definition at line 948 of file commit_ts.c.

949{
950 TransactionId xid1;
951 TransactionId xid2;
952
953 xid1 = ((TransactionId) page1) * COMMIT_TS_XACTS_PER_PAGE;
954 xid1 += FirstNormalTransactionId + 1;
955 xid2 = ((TransactionId) page2) * COMMIT_TS_XACTS_PER_PAGE;
956 xid2 += FirstNormalTransactionId + 1;
957
958 return (TransactionIdPrecedes(xid1, xid2) &&
960}
#define COMMIT_TS_XACTS_PER_PAGE
Definition: commit_ts.c:63
#define FirstNormalTransactionId
Definition: transam.h:34

References COMMIT_TS_XACTS_PER_PAGE, FirstNormalTransactionId, and TransactionIdPrecedes().

Referenced by CommitTsShmemInit().

◆ CommitTsParameterChange()

void CommitTsParameterChange ( bool  newvalue,
bool  oldvalue 
)

Definition at line 640 of file commit_ts.c.

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

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

Referenced by xlog_redo().

◆ CommitTsShmemBuffers()

static int CommitTsShmemBuffers ( void  )
static

Definition at line 504 of file commit_ts.c.

505{
506 /* auto-tune based on shared buffers */
508 return SimpleLruAutotuneBuffers(512, 1024);
509
511}
#define Min(x, y)
Definition: c.h:1003
#define Max(x, y)
Definition: c.h:997
int commit_timestamp_buffers
Definition: globals.c:161
int SimpleLruAutotuneBuffers(int divisor, int max)
Definition: slru.c:231
#define SLRU_MAX_ALLOWED_BUFFERS
Definition: slru.h:24

References commit_timestamp_buffers, Max, Min, SimpleLruAutotuneBuffers(), and SLRU_MAX_ALLOWED_BUFFERS.

Referenced by CommitTsShmemInit(), and CommitTsShmemSize().

◆ CommitTsShmemInit()

void CommitTsShmemInit ( void  )

Definition at line 528 of file commit_ts.c.

529{
530 bool found;
531
532 /* If auto-tuning is requested, now is the time to do it */
534 {
535 char buf[32];
536
537 snprintf(buf, sizeof(buf), "%d", CommitTsShmemBuffers());
538 SetConfigOption("commit_timestamp_buffers", buf, PGC_POSTMASTER,
540
541 /*
542 * We prefer to report this value's source as PGC_S_DYNAMIC_DEFAULT.
543 * However, if the DBA explicitly set commit_timestamp_buffers = 0 in
544 * the config file, then PGC_S_DYNAMIC_DEFAULT will fail to override
545 * that and we must force the matter with PGC_S_OVERRIDE.
546 */
547 if (commit_timestamp_buffers == 0) /* failed to apply it? */
548 SetConfigOption("commit_timestamp_buffers", buf, PGC_POSTMASTER,
550 }
552
553 CommitTsCtl->PagePrecedes = CommitTsPagePrecedes;
554 SimpleLruInit(CommitTsCtl, "commit_timestamp", CommitTsShmemBuffers(), 0,
555 "pg_commit_ts", LWTRANCHE_COMMITTS_BUFFER,
556 LWTRANCHE_COMMITTS_SLRU,
558 false);
560
561 commitTsShared = ShmemInitStruct("CommitTs shared",
562 sizeof(CommitTimestampShared),
563 &found);
564
566 {
567 Assert(!found);
568
573 }
574 else
575 Assert(found);
576}
static int CommitTsShmemBuffers(void)
Definition: commit_ts.c:504
static bool CommitTsPagePrecedes(int64 page1, int64 page2)
Definition: commit_ts.c:948
#define TIMESTAMP_NOBEGIN(j)
Definition: timestamp.h:159
bool IsUnderPostmaster
Definition: globals.c:120
void SetConfigOption(const char *name, const char *value, GucContext context, GucSource source)
Definition: guc.c:4338
@ PGC_S_DYNAMIC_DEFAULT
Definition: guc.h:114
@ PGC_S_OVERRIDE
Definition: guc.h:123
@ PGC_POSTMASTER
Definition: guc.h:74
#define InvalidRepOriginId
Definition: origin.h:33
static char * buf
Definition: pg_test_fsync.c:72
#define snprintf
Definition: port.h:239
void * ShmemInitStruct(const char *name, Size size, bool *foundPtr)
Definition: shmem.c:387
void SimpleLruInit(SlruCtl ctl, const char *name, int nslots, int nlsns, const char *subdir, int buffer_tranche_id, int bank_tranche_id, SyncRequestHandler sync_handler, bool long_segment_names)
Definition: slru.c:252
#define SlruPagePrecedesUnitTests(ctl, per_page)
Definition: slru.h:200
TimestampTz time
Definition: commit_ts.c:56
RepOriginId nodeid
Definition: commit_ts.c:57
CommitTimestampEntry dataLastCommit
Definition: commit_ts.c:101
TransactionId xidLastCommit
Definition: commit_ts.c:100
@ SYNC_HANDLER_COMMIT_TS
Definition: sync.h:39

References Assert(), buf, commit_timestamp_buffers, COMMIT_TS_XACTS_PER_PAGE, CommitTimestampShared::commitTsActive, CommitTsCtl, CommitTsPagePrecedes(), commitTsShared, CommitTsShmemBuffers(), CommitTimestampShared::dataLastCommit, InvalidRepOriginId, InvalidTransactionId, IsUnderPostmaster, CommitTimestampEntry::nodeid, PGC_POSTMASTER, PGC_S_DYNAMIC_DEFAULT, PGC_S_OVERRIDE, SetConfigOption(), ShmemInitStruct(), SimpleLruInit(), SlruPagePrecedesUnitTests, snprintf, SYNC_HANDLER_COMMIT_TS, CommitTimestampEntry::time, TIMESTAMP_NOBEGIN, and CommitTimestampShared::xidLastCommit.

Referenced by CreateOrAttachShmemStructs().

◆ CommitTsShmemSize()

Size CommitTsShmemSize ( void  )

Definition at line 517 of file commit_ts.c.

518{
520 sizeof(CommitTimestampShared);
521}
struct CommitTimestampShared CommitTimestampShared
Size SimpleLruShmemSize(int nslots, int nlsns)
Definition: slru.c:198

References CommitTsShmemBuffers(), and SimpleLruShmemSize().

Referenced by CalculateShmemSize().

◆ committssyncfiletag()

int committssyncfiletag ( const FileTag *  ftag,
char *  path 
)

Definition at line 1020 of file commit_ts.c.

1021{
1022 return SlruSyncFileTag(CommitTsCtl, ftag, path);
1023}
int SlruSyncFileTag(SlruCtl ctl, const FileTag *ftag, char *path)
Definition: slru.c:1856

References CommitTsCtl, and SlruSyncFileTag().

◆ CompleteCommitTsInitialization()

void CompleteCommitTsInitialization ( void  )

Definition at line 618 of file commit_ts.c.

619{
620 /*
621 * If the feature is not enabled, turn it off for good. This also removes
622 * any leftover data.
623 *
624 * Conversely, we activate the module if the feature is enabled. This is
625 * necessary for primary and standby as the activation depends on the
626 * control file contents at the beginning of recovery or when a
627 * XLOG_PARAMETER_CHANGE is replayed.
628 */
631 else
633}
bool track_commit_timestamp
Definition: commit_ts.c:109

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

Referenced by StartupXLOG().

◆ DeactivateCommitTs()

static void DeactivateCommitTs ( void  )
static

Definition at line 752 of file commit_ts.c.

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 /*
772 * Remove *all* files. This is necessary so that there are no leftover
773 * files; in the case where this feature is later enabled after running
774 * with it disabled for some time there may be a gap in the file sequence.
775 * (We can probably tolerate out-of-sequence files, as they are going to
776 * be overwritten anyway when we wrap around, but it seems better to be
777 * tidy.)
778 *
779 * Note that we do this with CommitTsLock acquired in exclusive mode. This
780 * is very heavy-handed, but since this routine can only be called in the
781 * replica and should happen very rarely, we don't worry too much about
782 * it. Note also that no process should be consulting this SLRU if we
783 * have just deactivated it.
784 */
786
787 LWLockRelease(CommitTsLock);
788}
bool SlruScanDirectory(SlruCtl ctl, SlruScanCallback callback, void *data)
Definition: slru.c:1816
bool SlruScanDirCbDeleteAll(SlruCtl ctl, char *filename, int64 segpage, void *data)
Definition: slru.c:1769

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

Referenced by CommitTsParameterChange(), and CompleteCommitTsInitialization().

◆ error_commit_ts_disabled()

static void error_commit_ts_disabled ( void  )
static

Definition at line 379 of file commit_ts.c.

380{
382 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
383 errmsg("could not get commit timestamp data"),
385 errhint("Make sure the configuration parameter \"%s\" is set on the primary server.",
386 "track_commit_timestamp") :
387 errhint("Make sure the configuration parameter \"%s\" is set.",
388 "track_commit_timestamp")));
389}
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 ERROR
Definition: elog.h:39
#define ereport(elevel,...)
Definition: elog.h:150
bool RecoveryInProgress(void)
Definition: xlog.c:6386

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

Referenced by GetLatestCommitTsData(), and TransactionIdGetCommitTsData().

◆ ExtendCommitTs()

void ExtendCommitTs ( TransactionId  newestXact )

Definition at line 816 of file commit_ts.c.

817{
818 int64 pageno;
819 LWLock *lock;
820
821 /*
822 * Nothing to do if module not enabled. Note we do an unlocked read of
823 * the flag here, which is okay because this routine is only called from
824 * GetNewTransactionId, which is never called in a standby.
825 */
828 return;
829
830 /*
831 * No work except at first XID of a page. But beware: just after
832 * wraparound, the first XID of page zero is FirstNormalTransactionId.
833 */
834 if (TransactionIdToCTsEntry(newestXact) != 0 &&
836 return;
837
838 pageno = TransactionIdToCTsPage(newestXact);
839
840 lock = SimpleLruGetBankLock(CommitTsCtl, pageno);
841
843
844 /* Zero the page ... */
846
847 /* and make a WAL entry about that, unless we're in REDO */
848 if (!InRecovery)
849 XLogSimpleInsertInt64(RM_COMMIT_TS_ID, COMMIT_TS_ZEROPAGE, pageno);
850
851 LWLockRelease(lock);
852}
#define TransactionIdToCTsEntry(xid)
Definition: commit_ts.c:77
int SimpleLruZeroPage(SlruCtl ctl, int64 pageno)
Definition: slru.c:375
static LWLock * SimpleLruGetBankLock(SlruCtl ctl, int64 pageno)
Definition: slru.h:175
Definition: lwlock.h:42
#define TransactionIdEquals(id1, id2)
Definition: transam.h:43
XLogRecPtr XLogSimpleInsertInt64(RmgrId rmid, uint8 info, int64 value)
Definition: xloginsert.c:537
bool InRecovery
Definition: xlogutils.c:50

References Assert(), COMMIT_TS_ZEROPAGE, CommitTimestampShared::commitTsActive, CommitTsCtl, commitTsShared, FirstNormalTransactionId, InRecovery, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), SimpleLruGetBankLock(), SimpleLruZeroPage(), TransactionIdEquals, TransactionIdToCTsEntry, TransactionIdToCTsPage(), and XLogSimpleInsertInt64().

Referenced by GetNewTransactionId().

◆ GetLatestCommitTsData()

TransactionId GetLatestCommitTsData ( TimestampTz *  ts,
RepOriginId *  nodeid 
)

Definition at line 358 of file commit_ts.c.

359{
360 TransactionId xid;
361
362 LWLockAcquire(CommitTsLock, LW_SHARED);
363
364 /* Error if module not enabled */
367
369 if (ts)
371 if (nodeid)
373 LWLockRelease(CommitTsLock);
374
375 return xid;
376}
static void error_commit_ts_disabled(void)
Definition: commit_ts.c:379
@ LW_SHARED
Definition: lwlock.h:113

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

Referenced by pg_last_committed_xact().

◆ pg_last_committed_xact()

Datum pg_last_committed_xact ( PG_FUNCTION_ARGS  )

Definition at line 418 of file commit_ts.c.

419{
420 TransactionId xid;
421 RepOriginId nodeid;
422 TimestampTz ts;
423 Datum values[3];
424 bool nulls[3];
425 TupleDesc tupdesc;
426 HeapTuple htup;
427
428 /* and construct a tuple with our data */
429 xid = GetLatestCommitTsData(&ts, &nodeid);
430
431 if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
432 elog(ERROR, "return type must be a row type");
433
434 if (!TransactionIdIsNormal(xid))
435 {
436 memset(nulls, true, sizeof(nulls));
437 }
438 else
439 {
441 nulls[0] = false;
442
444 nulls[1] = false;
445
446 values[2] = ObjectIdGetDatum((Oid) nodeid);
447 nulls[2] = false;
448 }
449
450 htup = heap_form_tuple(tupdesc, values, nulls);
451
453}
static Datum values[MAXATTR]
Definition: bootstrap.c:153
TransactionId GetLatestCommitTsData(TimestampTz *ts, RepOriginId *nodeid)
Definition: commit_ts.c:358
int64 TimestampTz
Definition: timestamp.h:39
#define PG_RETURN_DATUM(x)
Definition: fmgr.h:353
TypeFuncClass get_call_result_type(FunctionCallInfo fcinfo, Oid *resultTypeId, TupleDesc *resultTupleDesc)
Definition: funcapi.c:276
@ TYPEFUNC_COMPOSITE
Definition: funcapi.h:149
static Datum HeapTupleGetDatum(const HeapTupleData *tuple)
Definition: funcapi.h:230
HeapTuple heap_form_tuple(TupleDesc tupleDescriptor, const Datum *values, const bool *isnull)
Definition: heaptuple.c:1117
static Datum TransactionIdGetDatum(TransactionId X)
Definition: postgres.h:282
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:262
uint64_t Datum
Definition: postgres.h:70
unsigned int Oid
Definition: postgres_ext.h:32
#define TransactionIdIsNormal(xid)
Definition: transam.h:42
static Datum TimestampTzGetDatum(TimestampTz X)
Definition: timestamp.h:52

References elog, ERROR, get_call_result_type(), GetLatestCommitTsData(), heap_form_tuple(), HeapTupleGetDatum(), ObjectIdGetDatum(), PG_RETURN_DATUM, TimestampTzGetDatum(), TransactionIdGetDatum(), TransactionIdIsNormal, TYPEFUNC_COMPOSITE, and values.

◆ pg_xact_commit_timestamp()

Datum pg_xact_commit_timestamp ( PG_FUNCTION_ARGS  )

Definition at line 395 of file commit_ts.c.

396{
398 TimestampTz ts;
399 bool found;
400
401 found = TransactionIdGetCommitTsData(xid, &ts, NULL);
402
403 if (!found)
405
407}
bool TransactionIdGetCommitTsData(TransactionId xid, TimestampTz *ts, RepOriginId *nodeid)
Definition: commit_ts.c:272
#define PG_RETURN_NULL()
Definition: fmgr.h:345
#define PG_GETARG_TRANSACTIONID(n)
Definition: fmgr.h:279
#define PG_RETURN_TIMESTAMPTZ(x)
Definition: timestamp.h:68

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

◆ pg_xact_commit_timestamp_origin()

Datum pg_xact_commit_timestamp_origin ( PG_FUNCTION_ARGS  )

Definition at line 462 of file commit_ts.c.

463{
465 RepOriginId nodeid;
466 TimestampTz ts;
467 Datum values[2];
468 bool nulls[2];
469 TupleDesc tupdesc;
470 HeapTuple htup;
471 bool found;
472
473 found = TransactionIdGetCommitTsData(xid, &ts, &nodeid);
474
475 if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
476 elog(ERROR, "return type must be a row type");
477
478 if (!found)
479 {
480 memset(nulls, true, sizeof(nulls));
481 }
482 else
483 {
485 nulls[0] = false;
486
487 values[1] = ObjectIdGetDatum((Oid) nodeid);
488 nulls[1] = false;
489 }
490
491 htup = heap_form_tuple(tupdesc, values, nulls);
492
494}

References elog, ERROR, get_call_result_type(), heap_form_tuple(), HeapTupleGetDatum(), ObjectIdGetDatum(), PG_GETARG_TRANSACTIONID, PG_RETURN_DATUM, TimestampTzGetDatum(), TransactionIdGetCommitTsData(), TYPEFUNC_COMPOSITE, and values.

◆ SetCommitTsLimit()

void SetCommitTsLimit ( TransactionId  oldestXact,
TransactionId  newestXact 
)

Definition at line 887 of file commit_ts.c.

888{
889 /*
890 * Be careful not to overwrite values that are either further into the
891 * "future" or signal a disabled committs.
892 */
893 LWLockAcquire(CommitTsLock, LW_EXCLUSIVE);
895 {
900 }
901 else
902 {
906 }
907 LWLockRelease(CommitTsLock);
908}

References Assert(), InvalidTransactionId, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), TransamVariablesData::newestCommitTsXid, TransamVariablesData::oldestCommitTsXid, TransactionIdPrecedes(), and TransamVariables.

Referenced by BootStrapXLOG(), and StartupXLOG().

◆ SetXidCommitTsInPage()

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

Definition at line 220 of file commit_ts.c.

223{
224 LWLock *lock = SimpleLruGetBankLock(CommitTsCtl, pageno);
225 int slotno;
226 int i;
227
229
230 slotno = SimpleLruReadPage(CommitTsCtl, pageno, true, xid);
231
232 TransactionIdSetCommitTs(xid, ts, nodeid, slotno);
233 for (i = 0; i < nsubxids; i++)
234 TransactionIdSetCommitTs(subxids[i], ts, nodeid, slotno);
235
236 CommitTsCtl->shared->page_dirty[slotno] = true;
237
238 LWLockRelease(lock);
239}
static void TransactionIdSetCommitTs(TransactionId xid, TimestampTz ts, RepOriginId nodeid, int slotno)
Definition: commit_ts.c:247
i
int i
Definition: isn.c:77
int SimpleLruReadPage(SlruCtl ctl, int64 pageno, bool write_ok, TransactionId xid)
Definition: slru.c:527

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

Referenced by TransactionTreeSetCommitTsData().

◆ StartupCommitTs()

void StartupCommitTs ( void  )

Definition at line 608 of file commit_ts.c.

609{
611}

References ActivateCommitTs().

Referenced by StartupXLOG().

◆ TransactionIdGetCommitTsData()

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

Definition at line 272 of file commit_ts.c.

274{
275 int64 pageno = TransactionIdToCTsPage(xid);
276 int entryno = TransactionIdToCTsEntry(xid);
277 int slotno;
279 TransactionId oldestCommitTsXid;
280 TransactionId newestCommitTsXid;
281
282 if (!TransactionIdIsValid(xid))
284 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
285 errmsg("cannot retrieve commit timestamp for transaction %u", xid)));
286 else if (!TransactionIdIsNormal(xid))
287 {
288 /* frozen and bootstrap xids are always committed far in the past */
289 *ts = 0;
290 if (nodeid)
291 *nodeid = 0;
292 return false;
293 }
294
295 LWLockAcquire(CommitTsLock, LW_SHARED);
296
297 /* Error if module not enabled */
300
301 /*
302 * If we're asked for the cached value, return that. Otherwise, fall
303 * through to read from SLRU.
304 */
305 if (commitTsShared->xidLastCommit == xid)
306 {
308 if (nodeid)
310
311 LWLockRelease(CommitTsLock);
312 return *ts != 0;
313 }
314
315 oldestCommitTsXid = TransamVariables->oldestCommitTsXid;
316 newestCommitTsXid = TransamVariables->newestCommitTsXid;
317 /* neither is invalid, or both are */
318 Assert(TransactionIdIsValid(oldestCommitTsXid) == TransactionIdIsValid(newestCommitTsXid));
319 LWLockRelease(CommitTsLock);
320
321 /*
322 * Return empty if the requested value is outside our valid range.
323 */
324 if (!TransactionIdIsValid(oldestCommitTsXid) ||
325 TransactionIdPrecedes(xid, oldestCommitTsXid) ||
326 TransactionIdPrecedes(newestCommitTsXid, xid))
327 {
328 *ts = 0;
329 if (nodeid)
330 *nodeid = InvalidRepOriginId;
331 return false;
332 }
333
334 /* lock is acquired by SimpleLruReadPage_ReadOnly */
335 slotno = SimpleLruReadPage_ReadOnly(CommitTsCtl, pageno, xid);
336 memcpy(&entry,
337 CommitTsCtl->shared->page_buffer[slotno] +
340
341 *ts = entry.time;
342 if (nodeid)
343 *nodeid = entry.nodeid;
344
346 return *ts != 0;
347}
#define SizeOfCommitTimestampEntry
Definition: commit_ts.c:60
int SimpleLruReadPage_ReadOnly(SlruCtl ctl, int64 pageno, TransactionId xid)
Definition: slru.c:630
#define TransactionIdIsValid(xid)
Definition: transam.h:41

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

Referenced by GetTupleTransactionInfo(), pg_xact_commit_timestamp(), pg_xact_commit_timestamp_origin(), and update_most_recent_deletion_info().

◆ TransactionIdSetCommitTs()

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

Definition at line 247 of file commit_ts.c.

249{
250 int entryno = TransactionIdToCTsEntry(xid);
252
254
255 entry.time = ts;
256 entry.nodeid = nodeid;
257
258 memcpy(CommitTsCtl->shared->page_buffer[slotno] +
261}

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

Referenced by SetXidCommitTsInPage().

◆ TransactionIdToCTsPage()

static int64 TransactionIdToCTsPage ( TransactionId  xid )
inlinestatic

Definition at line 72 of file commit_ts.c.

73{
74 return xid / (int64) COMMIT_TS_XACTS_PER_PAGE;
75}

References COMMIT_TS_XACTS_PER_PAGE.

Referenced by ActivateCommitTs(), ExtendCommitTs(), TransactionIdGetCommitTsData(), TransactionTreeSetCommitTsData(), and TruncateCommitTs().

◆ TransactionTreeSetCommitTsData()

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

Definition at line 139 of file commit_ts.c.

142{
143 int i;
144 TransactionId headxid;
145 TransactionId newestXact;
146
147 /*
148 * No-op if the module is not active.
149 *
150 * An unlocked read here is fine, because in a standby (the only place
151 * where the flag can change in flight) this routine is only called by the
152 * recovery process, which is also the only process which can change the
153 * flag.
154 */
156 return;
157
158 /*
159 * Figure out the latest Xid in this batch: either the last subxid if
160 * there's any, otherwise the parent xid.
161 */
162 if (nsubxids > 0)
163 newestXact = subxids[nsubxids - 1];
164 else
165 newestXact = xid;
166
167 /*
168 * We split the xids to set the timestamp to in groups belonging to the
169 * same SLRU page; the first element in each such set is its head. The
170 * first group has the main XID as the head; subsequent sets use the first
171 * subxid not on the previous page as head. This way, we only have to
172 * lock/modify each SLRU page once.
173 */
174 headxid = xid;
175 i = 0;
176 for (;;)
177 {
178 int64 pageno = TransactionIdToCTsPage(headxid);
179 int j;
180
181 for (j = i; j < nsubxids; j++)
182 {
183 if (TransactionIdToCTsPage(subxids[j]) != pageno)
184 break;
185 }
186 /* subxids[i..j] are on the same page as the head */
187
188 SetXidCommitTsInPage(headxid, j - i, subxids + i, timestamp, nodeid,
189 pageno);
190
191 /* if we wrote out all subxids, we're done. */
192 if (j >= nsubxids)
193 break;
194
195 /*
196 * Set the new head and skip over it, as well as over the subxids we
197 * just wrote.
198 */
199 headxid = subxids[j];
200 i = j + 1;
201 }
202
203 /* update the cached value in shared memory */
204 LWLockAcquire(CommitTsLock, LW_EXCLUSIVE);
208
209 /* and move forwards our endpoint, if needed */
212 LWLockRelease(CommitTsLock);
213}
static void SetXidCommitTsInPage(TransactionId xid, int nsubxids, TransactionId *subxids, TimestampTz ts, RepOriginId nodeid, int64 pageno)
Definition: commit_ts.c:220
j
int j
Definition: isn.c:78
int64 timestamp

References CommitTimestampShared::commitTsActive, commitTsShared, CommitTimestampShared::dataLastCommit, i, j, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), TransamVariablesData::newestCommitTsXid, CommitTimestampEntry::nodeid, SetXidCommitTsInPage(), CommitTimestampEntry::time, TransactionIdPrecedes(), TransactionIdToCTsPage(), TransamVariables, and CommitTimestampShared::xidLastCommit.

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

◆ TruncateCommitTs()

void TruncateCommitTs ( TransactionId  oldestXact )

Definition at line 861 of file commit_ts.c.

862{
863 int64 cutoffPage;
864
865 /*
866 * The cutoff point is the start of the segment containing oldestXact. We
867 * pass the *page* containing oldestXact to SimpleLruTruncate.
868 */
869 cutoffPage = TransactionIdToCTsPage(oldestXact);
870
871 /* Check to see if there's any files that could be removed */
873 &cutoffPage))
874 return; /* nothing to remove */
875
876 /* Write XLOG record */
877 WriteTruncateXlogRec(cutoffPage, oldestXact);
878
879 /* Now we can remove the old CommitTs segment(s) */
880 SimpleLruTruncate(CommitTsCtl, cutoffPage);
881}
static void WriteTruncateXlogRec(int64 pageno, TransactionId oldestXid)
Definition: commit_ts.c:967
bool SlruScanDirCbReportPresence(SlruCtl ctl, char *filename, int64 segpage, void *data)
Definition: slru.c:1737

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

Referenced by vac_truncate_clog().

◆ WriteTruncateXlogRec()

static void WriteTruncateXlogRec ( int64  pageno,
TransactionId  oldestXid 
)
static

Definition at line 967 of file commit_ts.c.

968{
970
971 xlrec.pageno = pageno;
972 xlrec.oldestXid = oldestXid;
973
976 (void) XLogInsert(RM_COMMIT_TS_ID, COMMIT_TS_TRUNCATE);
977}
#define SizeOfCommitTsTruncate
Definition: commit_ts.h:55
XLogRecPtr XLogInsert(RmgrId rmid, uint8 info)
Definition: xloginsert.c:474
void XLogRegisterData(const void *data, uint32 len)
Definition: xloginsert.c:364
void XLogBeginInsert(void)
Definition: xloginsert.c:149

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

Referenced by TruncateCommitTs().

Variable Documentation

◆ CommitTsCtlData

SlruCtlData CommitTsCtlData
static

Definition at line 83 of file commit_ts.c.

◆ commitTsShared

CommitTimestampShared* commitTsShared
static

Definition at line 105 of file commit_ts.c.

Referenced by ActivateCommitTs(), CommitTsParameterChange(), CommitTsShmemInit(), DeactivateCommitTs(), ExtendCommitTs(), GetLatestCommitTsData(), TransactionIdGetCommitTsData(), and TransactionTreeSetCommitTsData().

◆ track_commit_timestamp

bool track_commit_timestamp

Definition at line 109 of file commit_ts.c.

Referenced by CheckSubDeadTupleRetention(), CompleteCommitTsInitialization(), FindDeletedTupleInLocalRel(), GetTupleTransactionInfo(), InitControlFile(), and XLogReportParameters().

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