#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 832 of file clog.c.

{
    /* Zero the initial page and flush it to disk */
    SimpleLruZeroAndWritePage(XactCtl, 0);
}

References SimpleLruZeroAndWritePage(), and XactCtl.

Referenced by BootStrapXLOG().

◆ CheckPointCLOG()

void CheckPointCLOG ( void )

Definition at line 903 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 %" PRId64, pageno);
    }
    else if (info == CLOG_TRUNCATE)
    {
        xl_clog_truncate xlrec;
 
        memcpy(&xlrec, rec, sizeof(xl_clog_truncate));
        appendStringInfo(buf, "page %" PRId64 "; oldestXact %u",
                         xlrec.pageno, xlrec.oldestXact);
    }
}

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

◆ 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 1063 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;
 
        memcpy(&pageno, XLogRecGetData(record), sizeof(pageno));
        SimpleLruZeroAndWritePage(XactCtl, pageno);
    }
    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, xl_clog_truncate::oldestXact, xl_clog_truncate::pageno, PANIC, SimpleLruTruncate(), SimpleLruZeroAndWritePage(), XactCtl, XLogRecGetData, XLogRecGetInfo, and XLogRecHasAnyBlockRefs.

◆ CLOGShmemInit()

void CLOGShmemInit ( void )

Definition at line 786 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(), 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 780 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 1095 of file clog.c.

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

References SlruSyncFileTag(), and XactCtl.

◆ ExtendCLOG()

void ExtendCLOG ( TransactionId newestXact )

Definition at line 925 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 a WAL entry about it */
    SimpleLruZeroPage(XactCtl, pageno);
    XLogSimpleInsertInt64(RM_CLOG_ID, CLOG_ZEROPAGE, pageno);
 
    LWLockRelease(lock);
}

References CLOG_ZEROPAGE, FirstNormalTransactionId, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), SimpleLruGetBankLock(), SimpleLruZeroPage(), TransactionIdEquals, TransactionIdToPage(), TransactionIdToPgIndex, XactCtl, and XLogSimpleInsertInt64().

Referenced by GetNewTransactionId().

◆ StartupCLOG()

void StartupCLOG ( void )

Definition at line 843 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 734 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 181 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 858 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.