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

extern

Definition at line 834 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  )

extern

Definition at line 905 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 fb(), SimpleLruWriteAll(), and XactCtl.

Referenced by CheckPointGuts().

clog_desc()

void clog_desc ( StringInfo  buf, XLogReaderState *  record  )

extern

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, fb(), XLogRecGetData, and XLogRecGetInfo.

clog_identify()

const char * clog_identify ( uint8  info )

extern

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, fb(), and XLR_INFO_MASK.

clog_redo()

void clog_redo ( XLogReaderState *  record )

extern

Definition at line 1073 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, fb(), PANIC, SimpleLruTruncate(), SimpleLruZeroAndWritePage(), XactCtl, XLogRecGetData, XLogRecGetInfo, and XLogRecHasAnyBlockRefs.

CLOGShmemInit()

void CLOGShmemInit ( void  )

extern

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;
    XactCtl->errdetail_for_io_error = clog_errdetail_for_io_error;
    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_errdetail_for_io_error(), CLOG_LSNS_PER_PAGE, CLOG_XACTS_PER_PAGE, CLOGPagePrecedes(), CLOGShmemBuffers(), fb(), 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  )

extern

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  )

extern

Definition at line 1105 of file clog.c.

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

References SlruSyncFileTag(), and XactCtl.

ExtendCLOG()

void ExtendCLOG ( TransactionId  newestXact )

extern

Definition at line 927 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, fb(), FirstNormalTransactionId, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), SimpleLruGetBankLock(), SimpleLruZeroPage(), TransactionIdEquals, TransactionIdToPage(), TransactionIdToPgIndex, XactCtl, and XLogSimpleInsertInt64().

Referenced by GetNewTransactionId().

StartupCLOG()

void StartupCLOG ( void  )

extern

Definition at line 845 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  )

extern

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, fb(), 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  )

extern

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, fb(), 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  )

extern

Definition at line 860 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, fb(), LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MemSet, TransamVariablesData::nextXid, SimpleLruGetBankLock(), SimpleLruReadPage(), TransactionIdToBIndex, TransactionIdToByte, TransactionIdToPage(), TransactionIdToPgIndex, TransamVariables, XactCtl, and XidFromFullTransactionId.

Referenced by StartupXLOG().

TruncateCLOG()

void TruncateCLOG ( TransactionId  oldestXact, Oid  oldestxid_datoid  )

extern

Definition at line 969 of file clog.c.

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

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

Referenced by vac_truncate_clog().