clog.c File Reference

#include "postgres.h"
#include "access/clog.h"
#include "access/slru.h"
#include "access/transam.h"
#include "access/xlog.h"
#include "access/xloginsert.h"
#include "access/xlogutils.h"
#include "miscadmin.h"
#include "pg_trace.h"
#include "pgstat.h"
#include "storage/proc.h"
#include "storage/sync.h"

Include dependency graph for clog.c:

Go to the source code of this file.

Macros
#define	CLOG_BITS_PER_XACT   2
#define	CLOG_XACTS_PER_BYTE   4
#define	CLOG_XACTS_PER_PAGE   (BLCKSZ * CLOG_XACTS_PER_BYTE)
#define	CLOG_XACT_BITMASK   ((1 << CLOG_BITS_PER_XACT) - 1)
#define	TransactionIdToPage(xid)   ((xid) / (TransactionId) CLOG_XACTS_PER_PAGE)
#define	TransactionIdToPgIndex(xid)   ((xid) % (TransactionId) CLOG_XACTS_PER_PAGE)
#define	TransactionIdToByte(xid)   (TransactionIdToPgIndex(xid) / CLOG_XACTS_PER_BYTE)
#define	TransactionIdToBIndex(xid)   ((xid) % (TransactionId) CLOG_XACTS_PER_BYTE)
#define	CLOG_XACTS_PER_LSN_GROUP   32 /* keep this a power of 2 */
#define	CLOG_LSNS_PER_PAGE   (CLOG_XACTS_PER_PAGE / CLOG_XACTS_PER_LSN_GROUP)
#define	GetLSNIndex(slotno, xid)
#define	THRESHOLD_SUBTRANS_CLOG_OPT   5
#define	XactCtl   (&XactCtlData)

Functions
static int	ZeroCLOGPage (int pageno, bool writeXlog)
static bool	CLOGPagePrecedes (int page1, int page2)
static void	WriteZeroPageXlogRec (int pageno)
static void	WriteTruncateXlogRec (int pageno, TransactionId oldestXact, Oid oldestXactDb)
static void	TransactionIdSetPageStatus (TransactionId xid, int nsubxids, TransactionId *subxids, XidStatus status, XLogRecPtr lsn, int pageno, bool all_xact_same_page)
static void	TransactionIdSetStatusBit (TransactionId xid, XidStatus status, XLogRecPtr lsn, int slotno)
static void	set_status_by_pages (int nsubxids, TransactionId *subxids, XidStatus status, XLogRecPtr lsn)
static bool	TransactionGroupUpdateXidStatus (TransactionId xid, XidStatus status, XLogRecPtr lsn, int pageno)
static void	TransactionIdSetPageStatusInternal (TransactionId xid, int nsubxids, TransactionId *subxids, XidStatus status, XLogRecPtr lsn, int pageno)
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)
void	clog_redo (XLogReaderState *record)
int	clogsyncfiletag (const FileTag *ftag, char *path)

Variables
static SlruCtlData	XactCtlData

Macro Definition Documentation

CLOG_BITS_PER_XACT

#define CLOG_BITS_PER_XACT   2

Definition at line 60 of file clog.c.

CLOG_LSNS_PER_PAGE

#define CLOG_LSNS_PER_PAGE   (CLOG_XACTS_PER_PAGE / CLOG_XACTS_PER_LSN_GROUP)

Definition at line 72 of file clog.c.

CLOG_XACT_BITMASK

#define CLOG_XACT_BITMASK   ((1 << CLOG_BITS_PER_XACT) - 1)

Definition at line 63 of file clog.c.

CLOG_XACTS_PER_BYTE

#define CLOG_XACTS_PER_BYTE   4

Definition at line 61 of file clog.c.

CLOG_XACTS_PER_LSN_GROUP

#define CLOG_XACTS_PER_LSN_GROUP   32 /* keep this a power of 2 */

Definition at line 71 of file clog.c.

CLOG_XACTS_PER_PAGE

#define CLOG_XACTS_PER_PAGE   (BLCKSZ * CLOG_XACTS_PER_BYTE)

Definition at line 62 of file clog.c.

GetLSNIndex

#define GetLSNIndex	(		slotno,
			xid
	)

Value:

    ((slotno) * CLOG_LSNS_PER_PAGE + \
    ((xid) % (TransactionId) CLOG_XACTS_PER_PAGE) / CLOG_XACTS_PER_LSN_GROUP)

Definition at line 74 of file clog.c.

THRESHOLD_SUBTRANS_CLOG_OPT

#define THRESHOLD_SUBTRANS_CLOG_OPT   5

Definition at line 82 of file clog.c.

TransactionIdToBIndex

#define TransactionIdToBIndex

(

xid

)

((xid) % (TransactionId) CLOG_XACTS_PER_BYTE)

Definition at line 68 of file clog.c.

TransactionIdToByte

#define TransactionIdToByte

(

xid

)

(TransactionIdToPgIndex(xid) / CLOG_XACTS_PER_BYTE)

Definition at line 67 of file clog.c.

TransactionIdToPage

#define TransactionIdToPage

(

xid

)

((xid) / (TransactionId) CLOG_XACTS_PER_PAGE)

Definition at line 65 of file clog.c.

TransactionIdToPgIndex

#define TransactionIdToPgIndex

(

xid

)

((xid) % (TransactionId) CLOG_XACTS_PER_PAGE)

Definition at line 66 of file clog.c.

XactCtl

#define XactCtl   (&XactCtlData)

Definition at line 89 of file clog.c.

Function Documentation

BootStrapCLOG()

void BootStrapCLOG

(

void

)

Definition at line 711 of file clog.c.

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

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

Referenced by BootStrapXLOG().

CheckPointCLOG()

void CheckPointCLOG

(

void

)

Definition at line 817 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_redo()

void clog_redo

(

XLogReaderState *

record

)

Definition at line 985 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)
    {
        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);
}

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

CLOGPagePrecedes()

static bool CLOGPagePrecedes ( int  page1, int  page2  )

static

Definition at line 933 of file clog.c.

{
    TransactionId xid1;
    TransactionId xid2;
 
    xid1 = ((TransactionId) page1) * CLOG_XACTS_PER_PAGE;
    xid1 += FirstNormalTransactionId + 1;
    xid2 = ((TransactionId) page2) * CLOG_XACTS_PER_PAGE;
    xid2 += FirstNormalTransactionId + 1;
 
    return (TransactionIdPrecedes(xid1, xid2) &&
            TransactionIdPrecedes(xid1, xid2 + CLOG_XACTS_PER_PAGE - 1));
}

References CLOG_XACTS_PER_PAGE, FirstNormalTransactionId, and TransactionIdPrecedes().

Referenced by CLOGShmemInit().

CLOGShmemBuffers()

Size CLOGShmemBuffers

(

void

)

Definition at line 680 of file clog.c.

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

References Max, Min, and NBuffers.

Referenced by CLOGShmemInit(), and CLOGShmemSize().

CLOGShmemInit()

void CLOGShmemInit

(

void

)

Definition at line 695 of file clog.c.

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

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

Referenced by CreateSharedMemoryAndSemaphores().

CLOGShmemSize()

Size CLOGShmemSize

(

void

)

Definition at line 689 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 1025 of file clog.c.

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

References SlruSyncFileTag(), and XactCtl.

ExtendCLOG()

void ExtendCLOG

(

TransactionId

newestXact

)

Definition at line 839 of file clog.c.

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

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

Referenced by GetNewTransactionId().

set_status_by_pages()

static void set_status_by_pages ( int  nsubxids, TransactionId *  subxids, XidStatus  status, XLogRecPtr  lsn  )

static

Definition at line 236 of file clog.c.

{
    int         pageno = TransactionIdToPage(subxids[0]);
    int         offset = 0;
    int         i = 0;
 
    Assert(nsubxids > 0);       /* else the pageno fetch above is unsafe */
 
    while (i < nsubxids)
    {
        int         num_on_page = 0;
        int         nextpageno;
 
        do
        {
            nextpageno = TransactionIdToPage(subxids[i]);
            if (nextpageno != pageno)
                break;
            num_on_page++;
            i++;
        } while (i < nsubxids);
 
        TransactionIdSetPageStatus(InvalidTransactionId,
                                   num_on_page, subxids + offset,
                                   status, lsn, pageno, false);
        offset = i;
        pageno = nextpageno;
    }
}

References Assert(), i, InvalidTransactionId, TransactionIdSetPageStatus(), and TransactionIdToPage.

Referenced by TransactionIdSetTreeStatus().

StartupCLOG()

void StartupCLOG

(

void

)

Definition at line 754 of file clog.c.

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

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

Referenced by StartupXLOG().

TransactionGroupUpdateXidStatus()

static bool TransactionGroupUpdateXidStatus ( TransactionId  xid, XidStatus  status, XLogRecPtr  lsn, int  pageno  )

static

Definition at line 413 of file clog.c.

{
    volatile PROC_HDR *procglobal = ProcGlobal;
    PGPROC     *proc = MyProc;
    uint32      nextidx;
    uint32      wakeidx;
 
    /* We should definitely have an XID whose status needs to be updated. */
    Assert(TransactionIdIsValid(xid));
 
    /*
     * Add ourselves to the list of processes needing a group XID status
     * update.
     */
    proc->clogGroupMember = true;
    proc->clogGroupMemberXid = xid;
    proc->clogGroupMemberXidStatus = status;
    proc->clogGroupMemberPage = pageno;
    proc->clogGroupMemberLsn = lsn;
 
    nextidx = pg_atomic_read_u32(&procglobal->clogGroupFirst);
 
    while (true)
    {
        /*
         * Add the proc to list, if the clog page where we need to update the
         * current transaction status is same as group leader's clog page.
         *
         * There is a race condition here, which is that after doing the below
         * check and before adding this proc's clog update to a group, the
         * group leader might have already finished the group update for this
         * page and becomes group leader of another group. This will lead to a
         * situation where a single group can have different clog page
         * updates.  This isn't likely and will still work, just maybe a bit
         * less efficiently.
         */
        if (nextidx != INVALID_PGPROCNO &&
            ProcGlobal->allProcs[nextidx].clogGroupMemberPage != proc->clogGroupMemberPage)
        {
            /*
             * Ensure that this proc is not a member of any clog group that
             * needs an XID status update.
             */
            proc->clogGroupMember = false;
            pg_atomic_write_u32(&proc->clogGroupNext, INVALID_PGPROCNO);
            return false;
        }
 
        pg_atomic_write_u32(&proc->clogGroupNext, nextidx);
 
        if (pg_atomic_compare_exchange_u32(&procglobal->clogGroupFirst,
                                           &nextidx,
                                           (uint32) proc->pgprocno))
            break;
    }
 
    /*
     * If the list was not empty, the leader will update the status of our
     * XID. It is impossible to have followers without a leader because the
     * first process that has added itself to the list will always have
     * nextidx as INVALID_PGPROCNO.
     */
    if (nextidx != INVALID_PGPROCNO)
    {
        int         extraWaits = 0;
 
        /* Sleep until the leader updates our XID status. */
        pgstat_report_wait_start(WAIT_EVENT_XACT_GROUP_UPDATE);
        for (;;)
        {
            /* acts as a read barrier */
            PGSemaphoreLock(proc->sem);
            if (!proc->clogGroupMember)
                break;
            extraWaits++;
        }
        pgstat_report_wait_end();
 
        Assert(pg_atomic_read_u32(&proc->clogGroupNext) == INVALID_PGPROCNO);
 
        /* Fix semaphore count for any absorbed wakeups */
        while (extraWaits-- > 0)
            PGSemaphoreUnlock(proc->sem);
        return true;
    }
 
    /* We are the leader.  Acquire the lock on behalf of everyone. */
    LWLockAcquire(XactSLRULock, LW_EXCLUSIVE);
 
    /*
     * Now that we've got the lock, clear the list of processes waiting for
     * group XID status update, saving a pointer to the head of the list.
     * Trying to pop elements one at a time could lead to an ABA problem.
     */
    nextidx = pg_atomic_exchange_u32(&procglobal->clogGroupFirst,
                                     INVALID_PGPROCNO);
 
    /* Remember head of list so we can perform wakeups after dropping lock. */
    wakeidx = nextidx;
 
    /* Walk the list and update the status of all XIDs. */
    while (nextidx != INVALID_PGPROCNO)
    {
        PGPROC     *nextproc = &ProcGlobal->allProcs[nextidx];
 
        /*
         * Transactions with more than THRESHOLD_SUBTRANS_CLOG_OPT sub-XIDs
         * should not use group XID status update mechanism.
         */
        Assert(nextproc->subxidStatus.count <= THRESHOLD_SUBTRANS_CLOG_OPT);
 
        TransactionIdSetPageStatusInternal(nextproc->clogGroupMemberXid,
                                           nextproc->subxidStatus.count,
                                           nextproc->subxids.xids,
                                           nextproc->clogGroupMemberXidStatus,
                                           nextproc->clogGroupMemberLsn,
                                           nextproc->clogGroupMemberPage);
 
        /* Move to next proc in list. */
        nextidx = pg_atomic_read_u32(&nextproc->clogGroupNext);
    }
 
    /* We're done with the lock now. */
    LWLockRelease(XactSLRULock);
 
    /*
     * Now that we've released the lock, go back and wake everybody up.  We
     * don't do this under the lock so as to keep lock hold times to a
     * minimum.
     */
    while (wakeidx != INVALID_PGPROCNO)
    {
        PGPROC     *wakeproc = &ProcGlobal->allProcs[wakeidx];
 
        wakeidx = pg_atomic_read_u32(&wakeproc->clogGroupNext);
        pg_atomic_write_u32(&wakeproc->clogGroupNext, INVALID_PGPROCNO);
 
        /* ensure all previous writes are visible before follower continues. */
        pg_write_barrier();
 
        wakeproc->clogGroupMember = false;
 
        if (wakeproc != MyProc)
            PGSemaphoreUnlock(wakeproc->sem);
    }
 
    return true;
}

References PROC_HDR::allProcs, Assert(), PROC_HDR::clogGroupFirst, PGPROC::clogGroupMember, PGPROC::clogGroupMemberLsn, PGPROC::clogGroupMemberPage, PGPROC::clogGroupMemberXid, PGPROC::clogGroupMemberXidStatus, PGPROC::clogGroupNext, XidCacheStatus::count, INVALID_PGPROCNO, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MyProc, pg_atomic_compare_exchange_u32(), pg_atomic_exchange_u32(), pg_atomic_read_u32(), pg_atomic_write_u32(), pg_write_barrier, PGPROC::pgprocno, PGSemaphoreLock(), PGSemaphoreUnlock(), pgstat_report_wait_end(), pgstat_report_wait_start(), ProcGlobal, PGPROC::sem, PGPROC::subxids, PGPROC::subxidStatus, THRESHOLD_SUBTRANS_CLOG_OPT, TransactionIdIsValid, TransactionIdSetPageStatusInternal(), and XidCache::xids.

Referenced by TransactionIdSetPageStatus().

TransactionIdGetStatus()

XidStatus TransactionIdGetStatus	(	TransactionId	xid,
		XLogRecPtr *	lsn
	)

Definition at line 638 of file clog.c.

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

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

Referenced by TransactionIdGetCommitLSN(), and TransactionLogFetch().

TransactionIdSetPageStatus()

static void TransactionIdSetPageStatus ( TransactionId  xid, int  nsubxids, TransactionId *  subxids, XidStatus  status, XLogRecPtr  lsn, int  pageno, bool  all_xact_same_page  )

static

Definition at line 272 of file clog.c.

{
    /* Can't use group update when PGPROC overflows. */
    StaticAssertDecl(THRESHOLD_SUBTRANS_CLOG_OPT <= PGPROC_MAX_CACHED_SUBXIDS,
                     "group clog threshold less than PGPROC cached subxids");
 
    /*
     * When there is contention on XactSLRULock, we try to group multiple
     * updates; a single leader process will perform transaction status
     * updates for multiple backends so that the number of times XactSLRULock
     * needs to be acquired is reduced.
     *
     * For this optimization to be safe, the XID and subxids in MyProc must be
     * the same as the ones for which we're setting the status.  Check that
     * this is the case.
     *
     * For this optimization to be efficient, we shouldn't have too many
     * sub-XIDs and all of the XIDs for which we're adjusting clog should be
     * on the same page.  Check those conditions, too.
     */
    if (all_xact_same_page && xid == MyProc->xid &&
        nsubxids <= THRESHOLD_SUBTRANS_CLOG_OPT &&
        nsubxids == MyProc->subxidStatus.count &&
        (nsubxids == 0 ||
         memcmp(subxids, MyProc->subxids.xids,
                nsubxids * sizeof(TransactionId)) == 0))
    {
        /*
         * If we can immediately acquire XactSLRULock, we update the status of
         * our own XID and release the lock.  If not, try use group XID
         * update.  If that doesn't work out, fall back to waiting for the
         * lock to perform an update for this transaction only.
         */
        if (LWLockConditionalAcquire(XactSLRULock, LW_EXCLUSIVE))
        {
            /* Got the lock without waiting!  Do the update. */
            TransactionIdSetPageStatusInternal(xid, nsubxids, subxids, status,
                                               lsn, pageno);
            LWLockRelease(XactSLRULock);
            return;
        }
        else if (TransactionGroupUpdateXidStatus(xid, status, lsn, pageno))
        {
            /* Group update mechanism has done the work. */
            return;
        }
 
        /* Fall through only if update isn't done yet. */
    }
 
    /* Group update not applicable, or couldn't accept this page number. */
    LWLockAcquire(XactSLRULock, LW_EXCLUSIVE);
    TransactionIdSetPageStatusInternal(xid, nsubxids, subxids, status,
                                       lsn, pageno);
    LWLockRelease(XactSLRULock);
}

References XidCacheStatus::count, LW_EXCLUSIVE, LWLockAcquire(), LWLockConditionalAcquire(), LWLockRelease(), MyProc, PGPROC_MAX_CACHED_SUBXIDS, StaticAssertDecl, PGPROC::subxids, PGPROC::subxidStatus, THRESHOLD_SUBTRANS_CLOG_OPT, TransactionGroupUpdateXidStatus(), TransactionIdSetPageStatusInternal(), PGPROC::xid, and XidCache::xids.

Referenced by set_status_by_pages(), and TransactionIdSetTreeStatus().

TransactionIdSetPageStatusInternal()

static void TransactionIdSetPageStatusInternal ( TransactionId  xid, int  nsubxids, TransactionId *  subxids, XidStatus  status, XLogRecPtr  lsn, int  pageno  )

static

Definition at line 338 of file clog.c.

{
    int         slotno;
    int         i;
 
    Assert(status == TRANSACTION_STATUS_COMMITTED ||
           status == TRANSACTION_STATUS_ABORTED ||
           (status == TRANSACTION_STATUS_SUB_COMMITTED && !TransactionIdIsValid(xid)));
    Assert(LWLockHeldByMeInMode(XactSLRULock, LW_EXCLUSIVE));
 
    /*
     * If we're doing an async commit (ie, lsn is valid), then we must wait
     * for any active write on the page slot to complete.  Otherwise our
     * update could reach disk in that write, which will not do since we
     * mustn't let it reach disk until we've done the appropriate WAL flush.
     * But when lsn is invalid, it's OK to scribble on a page while it is
     * write-busy, since we don't care if the update reaches disk sooner than
     * we think.
     */
    slotno = SimpleLruReadPage(XactCtl, pageno, XLogRecPtrIsInvalid(lsn), xid);
 
    /*
     * Set the main transaction id, if any.
     *
     * If we update more than one xid on this page while it is being written
     * out, we might find that some of the bits go to disk and others don't.
     * If we are updating commits on the page with the top-level xid that
     * could break atomicity, so we subcommit the subxids first before we mark
     * the top-level commit.
     */
    if (TransactionIdIsValid(xid))
    {
        /* Subtransactions first, if needed ... */
        if (status == TRANSACTION_STATUS_COMMITTED)
        {
            for (i = 0; i < nsubxids; i++)
            {
                Assert(XactCtl->shared->page_number[slotno] == TransactionIdToPage(subxids[i]));
                TransactionIdSetStatusBit(subxids[i],
                                          TRANSACTION_STATUS_SUB_COMMITTED,
                                          lsn, slotno);
            }
        }
 
        /* ... then the main transaction */
        TransactionIdSetStatusBit(xid, status, lsn, slotno);
    }
 
    /* Set the subtransactions */
    for (i = 0; i < nsubxids; i++)
    {
        Assert(XactCtl->shared->page_number[slotno] == TransactionIdToPage(subxids[i]));
        TransactionIdSetStatusBit(subxids[i], status, lsn, slotno);
    }
 
    XactCtl->shared->page_dirty[slotno] = true;
}

References Assert(), i, LW_EXCLUSIVE, LWLockHeldByMeInMode(), SimpleLruReadPage(), TRANSACTION_STATUS_ABORTED, TRANSACTION_STATUS_COMMITTED, TRANSACTION_STATUS_SUB_COMMITTED, TransactionIdIsValid, TransactionIdSetStatusBit(), TransactionIdToPage, XactCtl, and XLogRecPtrIsInvalid.

Referenced by TransactionGroupUpdateXidStatus(), and TransactionIdSetPageStatus().

TransactionIdSetStatusBit()

static void TransactionIdSetStatusBit ( TransactionId  xid, XidStatus  status, XLogRecPtr  lsn, int  slotno  )

static

Definition at line 569 of file clog.c.

{
    int         byteno = TransactionIdToByte(xid);
    int         bshift = TransactionIdToBIndex(xid) * CLOG_BITS_PER_XACT;
    char       *byteptr;
    char        byteval;
    char        curval;
 
    byteptr = XactCtl->shared->page_buffer[slotno] + byteno;
    curval = (*byteptr >> bshift) & CLOG_XACT_BITMASK;
 
    /*
     * When replaying transactions during recovery we still need to perform
     * the two phases of subcommit and then commit. However, some transactions
     * are already correctly marked, so we just treat those as a no-op which
     * allows us to keep the following Assert as restrictive as possible.
     */
    if (InRecovery && status == TRANSACTION_STATUS_SUB_COMMITTED &&
        curval == TRANSACTION_STATUS_COMMITTED)
        return;
 
    /*
     * Current state change should be from 0 or subcommitted to target state
     * or we should already be there when replaying changes during recovery.
     */
    Assert(curval == 0 ||
           (curval == TRANSACTION_STATUS_SUB_COMMITTED &&
            status != TRANSACTION_STATUS_IN_PROGRESS) ||
           curval == status);
 
    /* note this assumes exclusive access to the clog page */
    byteval = *byteptr;
    byteval &= ~(((1 << CLOG_BITS_PER_XACT) - 1) << bshift);
    byteval |= (status << bshift);
    *byteptr = byteval;
 
    /*
     * Update the group LSN if the transaction completion LSN is higher.
     *
     * Note: lsn will be invalid when supplied during InRecovery processing,
     * so we don't need to do anything special to avoid LSN updates during
     * recovery. After recovery completes the next clog change will set the
     * LSN correctly.
     */
    if (!XLogRecPtrIsInvalid(lsn))
    {
        int         lsnindex = GetLSNIndex(slotno, xid);
 
        if (XactCtl->shared->group_lsn[lsnindex] < lsn)
            XactCtl->shared->group_lsn[lsnindex] = lsn;
    }
}

References Assert(), CLOG_BITS_PER_XACT, CLOG_XACT_BITMASK, GetLSNIndex, InRecovery, TRANSACTION_STATUS_COMMITTED, TRANSACTION_STATUS_IN_PROGRESS, TRANSACTION_STATUS_SUB_COMMITTED, TransactionIdToBIndex, TransactionIdToByte, XactCtl, and XLogRecPtrIsInvalid.

Referenced by TransactionIdSetPageStatusInternal().

TransactionIdSetTreeStatus()

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

Definition at line 162 of file clog.c.

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

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

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

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

Referenced by StartupXLOG().

TruncateCLOG()

void TruncateCLOG	(	TransactionId	oldestXact,
		Oid	oldestxid_datoid
	)

Definition at line 878 of file clog.c.

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

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

Referenced by vac_truncate_clog().

WriteTruncateXlogRec()

static void WriteTruncateXlogRec ( int  pageno, TransactionId  oldestXact, Oid  oldestXactDb  )

static

Definition at line 966 of file clog.c.

{
    XLogRecPtr  recptr;
    xl_clog_truncate xlrec;
 
    xlrec.pageno = pageno;
    xlrec.oldestXact = oldestXact;
    xlrec.oldestXactDb = oldestXactDb;
 
    XLogBeginInsert();
    XLogRegisterData((char *) (&xlrec), sizeof(xl_clog_truncate));
    recptr = XLogInsert(RM_CLOG_ID, CLOG_TRUNCATE);
    XLogFlush(recptr);
}

References CLOG_TRUNCATE, xl_clog_truncate::oldestXact, xl_clog_truncate::oldestXactDb, xl_clog_truncate::pageno, XLogBeginInsert(), XLogFlush(), XLogInsert(), and XLogRegisterData().

Referenced by TruncateCLOG().

WriteZeroPageXlogRec()

static void WriteZeroPageXlogRec ( int  pageno )

static

Definition at line 952 of file clog.c.

{
    XLogBeginInsert();
    XLogRegisterData((char *) (&pageno), sizeof(int));
    (void) XLogInsert(RM_CLOG_ID, CLOG_ZEROPAGE);
}

References CLOG_ZEROPAGE, XLogBeginInsert(), XLogInsert(), and XLogRegisterData().

Referenced by ZeroCLOGPage().

ZeroCLOGPage()

static int ZeroCLOGPage ( int  pageno, bool  writeXlog  )

static

Definition at line 737 of file clog.c.

{
    int         slotno;
 
    slotno = SimpleLruZeroPage(XactCtl, pageno);
 
    if (writeXlog)
        WriteZeroPageXlogRec(pageno);
 
    return slotno;
}

References SimpleLruZeroPage(), WriteZeroPageXlogRec(), and XactCtl.

Referenced by BootStrapCLOG(), clog_redo(), and ExtendCLOG().

Variable Documentation

XactCtlData

SlruCtlData XactCtlData

static

Definition at line 87 of file clog.c.