#include "access/xlogreader.h"
#include "storage/sync.h"
#include "lib/stringinfo.h"

Include dependency graph for clog.h:

This graph shows which files directly or indirectly include this file:

Data Structures
struct	xl_clog_truncate

Macros
#define	TRANSACTION_STATUS_IN_PROGRESS 0x00

#define	TRANSACTION_STATUS_COMMITTED 0x01

#define	TRANSACTION_STATUS_ABORTED 0x02

#define	TRANSACTION_STATUS_SUB_COMMITTED 0x03

#define	CLOG_ZEROPAGE 0x00

#define	CLOG_TRUNCATE 0x10

Typedefs
typedef int	XidStatus

typedef struct xl_clog_truncate	xl_clog_truncate

Functions
void	TransactionIdSetTreeStatus (TransactionId xid, int nsubxids, TransactionId *subxids, XidStatus status, XLogRecPtr lsn)

XidStatus	TransactionIdGetStatus (TransactionId xid, XLogRecPtr *lsn)

Size	CLOGShmemSize (void)

void	CLOGShmemInit (void)

void	BootStrapCLOG (void)

void	StartupCLOG (void)

void	TrimCLOG (void)

void	CheckPointCLOG (void)

void	ExtendCLOG (TransactionId newestXact)

void	TruncateCLOG (TransactionId oldestXact, Oid oldestxid_datoid)

int	clogsyncfiletag (const FileTag ftag, char path)

void	clog_redo (XLogReaderState *record)

void	clog_desc (StringInfo buf, XLogReaderState *record)

const char *	clog_identify (uint8 info)

Macro Definition Documentation

◆ CLOG_TRUNCATE

#define CLOG_TRUNCATE 0x10

Definition at line 56 of file clog.h.

◆ CLOG_ZEROPAGE

#define CLOG_ZEROPAGE 0x00

Definition at line 55 of file clog.h.

◆ TRANSACTION_STATUS_ABORTED

#define TRANSACTION_STATUS_ABORTED 0x02

Definition at line 29 of file clog.h.

◆ TRANSACTION_STATUS_COMMITTED

#define TRANSACTION_STATUS_COMMITTED 0x01

Definition at line 28 of file clog.h.

◆ TRANSACTION_STATUS_IN_PROGRESS

#define TRANSACTION_STATUS_IN_PROGRESS 0x00

Definition at line 27 of file clog.h.

◆ TRANSACTION_STATUS_SUB_COMMITTED

#define TRANSACTION_STATUS_SUB_COMMITTED 0x03

Definition at line 30 of file clog.h.

Typedef Documentation

◆ XidStatus

typedef int XidStatus

Definition at line 25 of file clog.h.

◆ xl_clog_truncate

typedef struct xl_clog_truncate xl_clog_truncate

Function Documentation

◆ BootStrapCLOG()

void BootStrapCLOG ( void )

Definition at line 833 of file clog.c.

 {
     int         slotno;
     LWLock     *lock = SimpleLruGetBankLock(XactCtl, 0);
  
     LWLockAcquire(lock, LW_EXCLUSIVE);
  
     /* Create and zero the first page of the commit log */
     slotno = ZeroCLOGPage(0, false);
  
     /* Make sure it's written out */
     SimpleLruWritePage(XactCtl, slotno);
     Assert(!XactCtl->shared->page_dirty[slotno]);
  
     LWLockRelease(lock);
 }

References Assert, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), SimpleLruGetBankLock(), SimpleLruWritePage(), XactCtl, and ZeroCLOGPage().

Referenced by BootStrapXLOG().

◆ CheckPointCLOG()

void CheckPointCLOG ( void )

Definition at line 937 of file clog.c.

 {
     /*
      * Write dirty CLOG pages to disk.  This may result in sync requests
      * queued for later handling by ProcessSyncRequests(), as part of the
      * checkpoint.
      */
     TRACE_POSTGRESQL_CLOG_CHECKPOINT_START(true);
     SimpleLruWriteAll(XactCtl, true);
     TRACE_POSTGRESQL_CLOG_CHECKPOINT_DONE(true);
 }

References SimpleLruWriteAll(), and XactCtl.

Referenced by CheckPointGuts().

◆ clog_desc()

void clog_desc	(	StringInfo	buf,
		XLogReaderState *	record
	)

Definition at line 21 of file clogdesc.c.

 {
     char       *rec = XLogRecGetData(record);
     uint8       info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
  
     if (info == CLOG_ZEROPAGE)
     {
         int64       pageno;
  
         memcpy(&pageno, rec, sizeof(pageno));
         appendStringInfo(buf, "page %lld", (long long) pageno);
     }
     else if (info == CLOG_TRUNCATE)
     {
         xl_clog_truncate xlrec;
  
         memcpy(&xlrec, rec, sizeof(xl_clog_truncate));
         appendStringInfo(buf, "page %lld; oldestXact %u",
                          (long long) xlrec.pageno, xlrec.oldestXact);
     }
 }

References appendStringInfo(), buf, CLOG_TRUNCATE, CLOG_ZEROPAGE, xl_clog_truncate::oldestXact, xl_clog_truncate::pageno, XLogRecGetData, XLogRecGetInfo, and XLR_INFO_MASK.

◆ clog_identify()

const char* clog_identify ( uint8 info )

Definition at line 44 of file clogdesc.c.

 {
     const char *id = NULL;
  
     switch (info & ~XLR_INFO_MASK)
     {
         case CLOG_ZEROPAGE:
             id = "ZEROPAGE";
             break;
         case CLOG_TRUNCATE:
             id = "TRUNCATE";
             break;
     }
  
     return id;
 }

References CLOG_TRUNCATE, CLOG_ZEROPAGE, and XLR_INFO_MASK.

◆ clog_redo()

void clog_redo ( XLogReaderState * record )

Definition at line 1107 of file clog.c.

 {
     uint8       info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
  
     /* Backup blocks are not used in clog records */
     Assert(!XLogRecHasAnyBlockRefs(record));
  
     if (info == CLOG_ZEROPAGE)
     {
         int64       pageno;
         int         slotno;
         LWLock     *lock;
  
         memcpy(&pageno, XLogRecGetData(record), sizeof(pageno));
  
         lock = SimpleLruGetBankLock(XactCtl, pageno);
         LWLockAcquire(lock, LW_EXCLUSIVE);
  
         slotno = ZeroCLOGPage(pageno, false);
         SimpleLruWritePage(XactCtl, slotno);
         Assert(!XactCtl->shared->page_dirty[slotno]);
  
         LWLockRelease(lock);
     }
     else if (info == CLOG_TRUNCATE)
     {
         xl_clog_truncate xlrec;
  
         memcpy(&xlrec, XLogRecGetData(record), sizeof(xl_clog_truncate));
  
         AdvanceOldestClogXid(xlrec.oldestXact);
  
         SimpleLruTruncate(XactCtl, xlrec.pageno);
     }
     else
         elog(PANIC, "clog_redo: unknown op code %u", info);
 }

References AdvanceOldestClogXid(), Assert, CLOG_TRUNCATE, CLOG_ZEROPAGE, elog, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), xl_clog_truncate::oldestXact, xl_clog_truncate::pageno, PANIC, SimpleLruGetBankLock(), SimpleLruTruncate(), SimpleLruWritePage(), XactCtl, XLogRecGetData, XLogRecGetInfo, XLogRecHasAnyBlockRefs, XLR_INFO_MASK, and ZeroCLOGPage().

◆ CLOGShmemInit()

void CLOGShmemInit ( void )

Definition at line 787 of file clog.c.

 {
     /* If auto-tuning is requested, now is the time to do it */
     if (transaction_buffers == 0)
     {
         char        buf[32];
  
         snprintf(buf, sizeof(buf), "%d", CLOGShmemBuffers());
         SetConfigOption("transaction_buffers", buf, PGC_POSTMASTER,
                         PGC_S_DYNAMIC_DEFAULT);
  
         /*
          * We prefer to report this value's source as PGC_S_DYNAMIC_DEFAULT.
          * However, if the DBA explicitly set transaction_buffers = 0 in the
          * config file, then PGC_S_DYNAMIC_DEFAULT will fail to override that
          * and we must force the matter with PGC_S_OVERRIDE.
          */
         if (transaction_buffers == 0)   /* failed to apply it? */
             SetConfigOption("transaction_buffers", buf, PGC_POSTMASTER,
                             PGC_S_OVERRIDE);
     }
     Assert(transaction_buffers != 0);
  
     XactCtl->PagePrecedes = CLOGPagePrecedes;
     SimpleLruInit(XactCtl, "transaction", CLOGShmemBuffers(), CLOG_LSNS_PER_PAGE,
                   "pg_xact", LWTRANCHE_XACT_BUFFER,
                   LWTRANCHE_XACT_SLRU, SYNC_HANDLER_CLOG, false);
     SlruPagePrecedesUnitTests(XactCtl, CLOG_XACTS_PER_PAGE);
 }

References Assert, buf, CLOG_LSNS_PER_PAGE, CLOG_XACTS_PER_PAGE, CLOGPagePrecedes(), CLOGShmemBuffers(), LWTRANCHE_XACT_BUFFER, LWTRANCHE_XACT_SLRU, PGC_POSTMASTER, PGC_S_DYNAMIC_DEFAULT, PGC_S_OVERRIDE, SetConfigOption(), SimpleLruInit(), SlruPagePrecedesUnitTests, snprintf, SYNC_HANDLER_CLOG, transaction_buffers, and XactCtl.

Referenced by CreateOrAttachShmemStructs().

◆ CLOGShmemSize()

Size CLOGShmemSize ( void )

Definition at line 781 of file clog.c.

 {
     return SimpleLruShmemSize(CLOGShmemBuffers(), CLOG_LSNS_PER_PAGE);
 }

References CLOG_LSNS_PER_PAGE, CLOGShmemBuffers(), and SimpleLruShmemSize().

Referenced by CalculateShmemSize().

◆ clogsyncfiletag()

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

Definition at line 1149 of file clog.c.

 {
     return SlruSyncFileTag(XactCtl, ftag, path);
 }

References SlruSyncFileTag(), and XactCtl.

◆ ExtendCLOG()

void ExtendCLOG ( TransactionId newestXact )

Definition at line 959 of file clog.c.

 {
     int64       pageno;
     LWLock     *lock;
  
     /*
      * No work except at first XID of a page.  But beware: just after
      * wraparound, the first XID of page zero is FirstNormalTransactionId.
      */
     if (TransactionIdToPgIndex(newestXact) != 0 &&
         !TransactionIdEquals(newestXact, FirstNormalTransactionId))
         return;
  
     pageno = TransactionIdToPage(newestXact);
     lock = SimpleLruGetBankLock(XactCtl, pageno);
  
     LWLockAcquire(lock, LW_EXCLUSIVE);
  
     /* Zero the page and make an XLOG entry about it */
     ZeroCLOGPage(pageno, true);
  
     LWLockRelease(lock);
 }

References FirstNormalTransactionId, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), SimpleLruGetBankLock(), TransactionIdEquals, TransactionIdToPage(), TransactionIdToPgIndex, XactCtl, and ZeroCLOGPage().

Referenced by GetNewTransactionId().

◆ StartupCLOG()

void StartupCLOG ( void )

Definition at line 877 of file clog.c.

 {
     TransactionId xid = XidFromFullTransactionId(TransamVariables->nextXid);
     int64       pageno = TransactionIdToPage(xid);
  
     /*
      * Initialize our idea of the latest page number.
      */
     pg_atomic_write_u64(&XactCtl->shared->latest_page_number, pageno);
 }

References TransamVariablesData::nextXid, pg_atomic_write_u64(), TransactionIdToPage(), TransamVariables, XactCtl, and XidFromFullTransactionId.

Referenced by StartupXLOG().

◆ TransactionIdGetStatus()

XidStatus TransactionIdGetStatus	(	TransactionId	xid,
		XLogRecPtr *	lsn
	)

Definition at line 735 of file clog.c.

 {
     int64       pageno = TransactionIdToPage(xid);
     int         byteno = TransactionIdToByte(xid);
     int         bshift = TransactionIdToBIndex(xid) * CLOG_BITS_PER_XACT;
     int         slotno;
     int         lsnindex;
     char       *byteptr;
     XidStatus   status;
  
     /* lock is acquired by SimpleLruReadPage_ReadOnly */
  
     slotno = SimpleLruReadPage_ReadOnly(XactCtl, pageno, xid);
     byteptr = XactCtl->shared->page_buffer[slotno] + byteno;
  
     status = (*byteptr >> bshift) & CLOG_XACT_BITMASK;
  
     lsnindex = GetLSNIndex(slotno, xid);
     *lsn = XactCtl->shared->group_lsn[lsnindex];
  
     LWLockRelease(SimpleLruGetBankLock(XactCtl, pageno));
  
     return status;
 }

References CLOG_BITS_PER_XACT, CLOG_XACT_BITMASK, GetLSNIndex, LWLockRelease(), SimpleLruGetBankLock(), SimpleLruReadPage_ReadOnly(), TransactionIdToBIndex, TransactionIdToByte, TransactionIdToPage(), and XactCtl.

Referenced by TransactionIdGetCommitLSN(), and TransactionLogFetch().

◆ TransactionIdSetTreeStatus()

void TransactionIdSetTreeStatus	(	TransactionId	xid,
		int	nsubxids,
		TransactionId *	subxids,
		XidStatus	status,
		XLogRecPtr	lsn
	)

Definition at line 183 of file clog.c.

 {
     int64       pageno = TransactionIdToPage(xid);  /* get page of parent */
     int         i;
  
     Assert(status == TRANSACTION_STATUS_COMMITTED ||
            status == TRANSACTION_STATUS_ABORTED);
  
     /*
      * See how many subxids, if any, are on the same page as the parent, if
      * any.
      */
     for (i = 0; i < nsubxids; i++)
     {
         if (TransactionIdToPage(subxids[i]) != pageno)
             break;
     }
  
     /*
      * Do all items fit on a single page?
      */
     if (i == nsubxids)
     {
         /*
          * Set the parent and all subtransactions in a single call
          */
         TransactionIdSetPageStatus(xid, nsubxids, subxids, status, lsn,
                                    pageno, true);
     }
     else
     {
         int         nsubxids_on_first_page = i;
  
         /*
          * If this is a commit then we care about doing this correctly (i.e.
          * using the subcommitted intermediate status).  By here, we know
          * we're updating more than one page of clog, so we must mark entries
          * that are *not* on the first page so that they show as subcommitted
          * before we then return to update the status to fully committed.
          *
          * To avoid touching the first page twice, skip marking subcommitted
          * for the subxids on that first page.
          */
         if (status == TRANSACTION_STATUS_COMMITTED)
             set_status_by_pages(nsubxids - nsubxids_on_first_page,
                                 subxids + nsubxids_on_first_page,
                                 TRANSACTION_STATUS_SUB_COMMITTED, lsn);
  
         /*
          * Now set the parent and subtransactions on same page as the parent,
          * if any
          */
         pageno = TransactionIdToPage(xid);
         TransactionIdSetPageStatus(xid, nsubxids_on_first_page, subxids, status,
                                    lsn, pageno, false);
  
         /*
          * Now work through the rest of the subxids one clog page at a time,
          * starting from the second page onwards, like we did above.
          */
         set_status_by_pages(nsubxids - nsubxids_on_first_page,
                             subxids + nsubxids_on_first_page,
                             status, lsn);
     }
 }

References Assert, i, set_status_by_pages(), TRANSACTION_STATUS_ABORTED, TRANSACTION_STATUS_COMMITTED, TRANSACTION_STATUS_SUB_COMMITTED, TransactionIdSetPageStatus(), and TransactionIdToPage().

Referenced by TransactionIdAbortTree(), TransactionIdAsyncCommitTree(), and TransactionIdCommitTree().

◆ TrimCLOG()

void TrimCLOG ( void )

Definition at line 892 of file clog.c.

 {
     TransactionId xid = XidFromFullTransactionId(TransamVariables->nextXid);
     int64       pageno = TransactionIdToPage(xid);
     LWLock     *lock = SimpleLruGetBankLock(XactCtl, pageno);
  
     LWLockAcquire(lock, LW_EXCLUSIVE);
  
     /*
      * Zero out the remainder of the current clog page.  Under normal
      * circumstances it should be zeroes already, but it seems at least
      * theoretically possible that XLOG replay will have settled on a nextXID
      * value that is less than the last XID actually used and marked by the
      * previous database lifecycle (since subtransaction commit writes clog
      * but makes no WAL entry).  Let's just be safe. (We need not worry about
      * pages beyond the current one, since those will be zeroed when first
      * used.  For the same reason, there is no need to do anything when
      * nextXid is exactly at a page boundary; and it's likely that the
      * "current" page doesn't exist yet in that case.)
      */
     if (TransactionIdToPgIndex(xid) != 0)
     {
         int         byteno = TransactionIdToByte(xid);
         int         bshift = TransactionIdToBIndex(xid) * CLOG_BITS_PER_XACT;
         int         slotno;
         char       *byteptr;
  
         slotno = SimpleLruReadPage(XactCtl, pageno, false, xid);
         byteptr = XactCtl->shared->page_buffer[slotno] + byteno;
  
         /* Zero so-far-unused positions in the current byte */
         *byteptr &= (1 << bshift) - 1;
         /* Zero the rest of the page */
         MemSet(byteptr + 1, 0, BLCKSZ - byteno - 1);
  
         XactCtl->shared->page_dirty[slotno] = true;
     }
  
     LWLockRelease(lock);
 }

References CLOG_BITS_PER_XACT, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MemSet, TransamVariablesData::nextXid, SimpleLruGetBankLock(), SimpleLruReadPage(), TransactionIdToBIndex, TransactionIdToByte, TransactionIdToPage(), TransactionIdToPgIndex, TransamVariables, XactCtl, and XidFromFullTransactionId.