clog.h File Reference

#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:

Go to the source code of 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	CLOGShmemBuffers (void)
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 57 of file clog.h.

Referenced by clog_desc(), clog_identify(), clog_redo(), and WriteTruncateXlogRec().

CLOG_ZEROPAGE

#define CLOG_ZEROPAGE   0x00

Definition at line 56 of file clog.h.

Referenced by clog_desc(), clog_identify(), clog_redo(), and WriteZeroPageXlogRec().

TRANSACTION_STATUS_ABORTED

#define TRANSACTION_STATUS_ABORTED   0x02

Definition at line 29 of file clog.h.

Referenced by TransactionIdAbortTree(), TransactionIdDidAbort(), TransactionIdSetPageStatusInternal(), TransactionIdSetTreeStatus(), and TransactionLogFetch().

TRANSACTION_STATUS_COMMITTED

#define TRANSACTION_STATUS_COMMITTED   0x01

Definition at line 28 of file clog.h.

Referenced by TransactionIdAsyncCommitTree(), TransactionIdCommitTree(), TransactionIdDidCommit(), TransactionIdSetPageStatusInternal(), TransactionIdSetStatusBit(), TransactionIdSetTreeStatus(), and TransactionLogFetch().

TRANSACTION_STATUS_IN_PROGRESS

#define TRANSACTION_STATUS_IN_PROGRESS   0x00

Definition at line 27 of file clog.h.

Referenced by InitProcess(), TransactionIdSetStatusBit(), and TransactionLogFetch().

TRANSACTION_STATUS_SUB_COMMITTED

#define TRANSACTION_STATUS_SUB_COMMITTED   0x03

Definition at line 30 of file clog.h.

Referenced by TransactionIdDidAbort(), TransactionIdDidCommit(), TransactionIdSetPageStatusInternal(), TransactionIdSetStatusBit(), TransactionIdSetTreeStatus(), and TransactionLogFetch().

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

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

Referenced by BootStrapXLOG().

{
    int         slotno;

    LWLockAcquire(XactSLRULock, 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(XactSLRULock);
}

CheckPointCLOG()

void CheckPointCLOG

(

void

)

Definition at line 813 of file clog.c.

References SimpleLruWriteAll(), and XactCtl.

Referenced by CheckPointGuts().

{
    /*
     * 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);
}

clog_desc()

void clog_desc	(	StringInfo	buf,
		XLogReaderState *	record
	)

Definition at line 21 of file clogdesc.c.

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

{
    char       *rec = XLogRecGetData(record);
    uint8       info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;

    if (info == CLOG_ZEROPAGE)
    {
        int         pageno;

        memcpy(&pageno, rec, sizeof(int));
        appendStringInfo(buf, "page %d", pageno);
    }
    else if (info == CLOG_TRUNCATE)
    {
        xl_clog_truncate xlrec;

        memcpy(&xlrec, rec, sizeof(xl_clog_truncate));
        appendStringInfo(buf, "page %d; oldestXact %u",
                         xlrec.pageno, xlrec.oldestXact);
    }
}

clog_identify()

const char* clog_identify

(

uint8

info

)

Definition at line 44 of file clogdesc.c.

References CLOG_TRUNCATE, CLOG_ZEROPAGE, and XLR_INFO_MASK.

{
    const char *id = NULL;

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

    return id;
}

clog_redo()

void clog_redo

(

XLogReaderState *

record

)

Definition at line 981 of file clog.c.

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

{
    uint8       info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;

    /* Backup blocks are not used in clog records */
    Assert(!XLogRecHasAnyBlockRefs(record));

    if (info == CLOG_ZEROPAGE)
    {
        int         pageno;
        int         slotno;

        memcpy(&pageno, XLogRecGetData(record), sizeof(int));

        LWLockAcquire(XactSLRULock, LW_EXCLUSIVE);

        slotno = ZeroCLOGPage(pageno, false);
        SimpleLruWritePage(XactCtl, slotno);
        Assert(!XactCtl->shared->page_dirty[slotno]);

        LWLockRelease(XactSLRULock);
    }
    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);
}

CLOGShmemBuffers()

Size CLOGShmemBuffers

(

void

)

Definition at line 676 of file clog.c.

References Max, Min, and NBuffers.

Referenced by CLOGShmemInit(), and CLOGShmemSize().

{
    return Min(128, Max(4, NBuffers / 512));
}

CLOGShmemInit()

void CLOGShmemInit

(

void

)

Definition at line 691 of file clog.c.

References CLOG_LSNS_PER_PAGE, CLOG_XACTS_PER_PAGE, CLOGPagePrecedes(), CLOGShmemBuffers(), LWTRANCHE_XACT_BUFFER, SimpleLruInit(), SlruPagePrecedesUnitTests, SYNC_HANDLER_CLOG, and XactCtl.

Referenced by CreateSharedMemoryAndSemaphores().

{
    XactCtl->PagePrecedes = CLOGPagePrecedes;
    SimpleLruInit(XactCtl, "Xact", CLOGShmemBuffers(), CLOG_LSNS_PER_PAGE,
                  XactSLRULock, "pg_xact", LWTRANCHE_XACT_BUFFER,
                  SYNC_HANDLER_CLOG);
    SlruPagePrecedesUnitTests(XactCtl, CLOG_XACTS_PER_PAGE);
}

CLOGShmemSize()

Size CLOGShmemSize

(

void

)

Definition at line 685 of file clog.c.

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

Referenced by CreateSharedMemoryAndSemaphores().

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

clogsyncfiletag()

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

Definition at line 1021 of file clog.c.

References SlruSyncFileTag(), and XactCtl.

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

ExtendCLOG()

void ExtendCLOG

(

TransactionId

newestXact

)

Definition at line 835 of file clog.c.

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

Referenced by GetNewTransactionId().

{
    int         pageno;

    /*
     * 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);

    LWLockAcquire(XactSLRULock, LW_EXCLUSIVE);

    /* Zero the page and make an XLOG entry about it */
    ZeroCLOGPage(pageno, true);

    LWLockRelease(XactSLRULock);
}

StartupCLOG()

void StartupCLOG

(

void

)

Definition at line 750 of file clog.c.

References LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), VariableCacheData::nextXid, ShmemVariableCache, TransactionIdToPage, XactCtl, and XidFromFullTransactionId.

Referenced by StartupXLOG().

{
    TransactionId xid = XidFromFullTransactionId(ShmemVariableCache->nextXid);
    int         pageno = TransactionIdToPage(xid);

    LWLockAcquire(XactSLRULock, LW_EXCLUSIVE);

    /*
     * Initialize our idea of the latest page number.
     */
    XactCtl->shared->latest_page_number = pageno;

    LWLockRelease(XactSLRULock);
}

TransactionIdGetStatus()

XidStatus TransactionIdGetStatus	(	TransactionId	xid,
		XLogRecPtr *	lsn
	)

Definition at line 634 of file clog.c.

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

Referenced by TransactionIdGetCommitLSN(), and TransactionLogFetch().

{
    int         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(XactSLRULock);

    return status;
}

TransactionIdSetTreeStatus()

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

Definition at line 164 of file clog.c.

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().

{
    int         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);
    }
}

TrimCLOG()

void TrimCLOG

(

void

)

Definition at line 769 of file clog.c.

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

Referenced by StartupXLOG().

{
    TransactionId xid = XidFromFullTransactionId(ShmemVariableCache->nextXid);
    int         pageno = TransactionIdToPage(xid);

    LWLockAcquire(XactSLRULock, 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(XactSLRULock);
}

TruncateCLOG()

void TruncateCLOG	(	TransactionId	oldestXact,
		Oid	oldestxid_datoid
	)

Definition at line 874 of file clog.c.

References AdvanceOldestClogXid(), SimpleLruTruncate(), SlruScanDirCbReportPresence(), SlruScanDirectory(), TransactionIdToPage, WriteTruncateXlogRec(), and XactCtl.

Referenced by vac_truncate_clog().

{
    int         cutoffPage;

    /*
     * The cutoff point is the start of the segment containing oldestXact. We
     * pass the *page* containing oldestXact to SimpleLruTruncate.
     */
    cutoffPage = TransactionIdToPage(oldestXact);

    /* Check to see if there's any files that could be removed */
    if (!SlruScanDirectory(XactCtl, SlruScanDirCbReportPresence, &cutoffPage))
        return;                 /* nothing to remove */

    /*
     * Advance oldestClogXid before truncating clog, so concurrent xact status
     * lookups can ensure they don't attempt to access truncated-away clog.
     *
     * It's only necessary to do this if we will actually truncate away clog
     * pages.
     */
    AdvanceOldestClogXid(oldestXact);

    /*
     * Write XLOG record and flush XLOG to disk. We record the oldest xid
     * we're keeping information about here so we can ensure that it's always
     * ahead of clog truncation in case we crash, and so a standby finds out
     * the new valid xid before the next checkpoint.
     */
    WriteTruncateXlogRec(cutoffPage, oldestXact, oldestxid_datoid);

    /* Now we can remove the old CLOG segment(s) */
    SimpleLruTruncate(XactCtl, cutoffPage);
}