subtrans.c File Reference

#include "postgres.h"
#include "access/slru.h"
#include "access/subtrans.h"
#include "access/transam.h"
#include "miscadmin.h"
#include "pg_trace.h"
#include "utils/guc_hooks.h"
#include "utils/snapmgr.h"

Include dependency graph for subtrans.c:

Go to the source code of this file.

Macros
#define	SUBTRANS_XACTS_PER_PAGE   (BLCKSZ / sizeof(TransactionId))
#define	TransactionIdToEntry(xid)   ((xid) % (TransactionId) SUBTRANS_XACTS_PER_PAGE)
#define	SubTransCtl   (&SubTransCtlData)

Functions
static int64	TransactionIdToPage (TransactionId xid)
static bool	SubTransPagePrecedes (int64 page1, int64 page2)
static int	subtrans_errdetail_for_io_error (const void *opaque_data)
void	SubTransSetParent (TransactionId xid, TransactionId parent)
TransactionId	SubTransGetParent (TransactionId xid)
TransactionId	SubTransGetTopmostTransaction (TransactionId xid)
static int	SUBTRANSShmemBuffers (void)
Size	SUBTRANSShmemSize (void)
void	SUBTRANSShmemInit (void)
bool	check_subtrans_buffers (int *newval, void **extra, GucSource source)
void	BootStrapSUBTRANS (void)
void	StartupSUBTRANS (TransactionId oldestActiveXID)
void	CheckPointSUBTRANS (void)
void	ExtendSUBTRANS (TransactionId newestXact)
void	TruncateSUBTRANS (TransactionId oldestXact)

Variables
static SlruCtlData	SubTransCtlData

Macro Definition Documentation

SUBTRANS_XACTS_PER_PAGE

#define SUBTRANS_XACTS_PER_PAGE   (BLCKSZ / sizeof(TransactionId))

Definition at line 54 of file subtrans.c.

SubTransCtl

#define SubTransCtl   (&SubTransCtlData)

Definition at line 74 of file subtrans.c.

TransactionIdToEntry

#define TransactionIdToEntry

(

xid

)

((xid) % (TransactionId) SUBTRANS_XACTS_PER_PAGE)

Definition at line 66 of file subtrans.c.

Function Documentation

BootStrapSUBTRANS()

void BootStrapSUBTRANS

(

void

)

Definition at line 271 of file subtrans.c.

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

References SimpleLruZeroAndWritePage(), and SubTransCtl.

Referenced by BootStrapXLOG().

check_subtrans_buffers()

bool check_subtrans_buffers	(	int *	newval,
		void **	extra,
		GucSource	source
	)

Definition at line 255 of file subtrans.c.

{
    return check_slru_buffers("subtransaction_buffers", newval);
}

References check_slru_buffers(), and newval.

CheckPointSUBTRANS()

void CheckPointSUBTRANS

(

void

)

Definition at line 331 of file subtrans.c.

{
    /*
     * Write dirty SUBTRANS pages to disk
     *
     * This is not actually necessary from a correctness point of view. We do
     * it merely to improve the odds that writing of dirty pages is done by
     * the checkpoint process and not by backends.
     */
    TRACE_POSTGRESQL_SUBTRANS_CHECKPOINT_START(true);
    SimpleLruWriteAll(SubTransCtl, true);
    TRACE_POSTGRESQL_SUBTRANS_CHECKPOINT_DONE(true);
}

References fb(), SimpleLruWriteAll(), and SubTransCtl.

Referenced by CheckPointGuts().

ExtendSUBTRANS()

void ExtendSUBTRANS

(

TransactionId

newestXact

)

Definition at line 355 of file subtrans.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 (TransactionIdToEntry(newestXact) != 0 &&
        !TransactionIdEquals(newestXact, FirstNormalTransactionId))
        return;
 
    pageno = TransactionIdToPage(newestXact);
 
    lock = SimpleLruGetBankLock(SubTransCtl, pageno);
    LWLockAcquire(lock, LW_EXCLUSIVE);
 
    /* Zero the page */
    SimpleLruZeroPage(SubTransCtl, pageno);
 
    LWLockRelease(lock);
}

References fb(), FirstNormalTransactionId, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), SimpleLruGetBankLock(), SimpleLruZeroPage(), SubTransCtl, TransactionIdEquals, TransactionIdToEntry, and TransactionIdToPage().

Referenced by GetNewTransactionId(), ProcArrayApplyRecoveryInfo(), and RecordKnownAssignedTransactionIds().

StartupSUBTRANS()

void StartupSUBTRANS

(

TransactionId

oldestActiveXID

)

Definition at line 285 of file subtrans.c.

{
    FullTransactionId nextXid;
    int64       startPage;
    int64       endPage;
    LWLock     *prevlock = NULL;
    LWLock     *lock;
 
    /*
     * Since we don't expect pg_subtrans to be valid across crashes, we
     * initialize the currently-active page(s) to zeroes during startup.
     * Whenever we advance into a new page, ExtendSUBTRANS will likewise zero
     * the new page without regard to whatever was previously on disk.
     */
    startPage = TransactionIdToPage(oldestActiveXID);
    nextXid = TransamVariables->nextXid;
    endPage = TransactionIdToPage(XidFromFullTransactionId(nextXid));
 
    for (;;)
    {
        lock = SimpleLruGetBankLock(SubTransCtl, startPage);
        if (prevlock != lock)
        {
            if (prevlock)
                LWLockRelease(prevlock);
            LWLockAcquire(lock, LW_EXCLUSIVE);
            prevlock = lock;
        }
 
        (void) SimpleLruZeroPage(SubTransCtl, startPage);
        if (startPage == endPage)
            break;
 
        startPage++;
        /* must account for wraparound */
        if (startPage > TransactionIdToPage(MaxTransactionId))
            startPage = 0;
    }
 
    LWLockRelease(lock);
}

References fb(), LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MaxTransactionId, TransamVariablesData::nextXid, SimpleLruGetBankLock(), SimpleLruZeroPage(), SubTransCtl, TransactionIdToPage(), TransamVariables, and XidFromFullTransactionId.

Referenced by StartupXLOG().

subtrans_errdetail_for_io_error()

static int subtrans_errdetail_for_io_error ( const void *  opaque_data )

static

Definition at line 426 of file subtrans.c.

{
    TransactionId xid = *(const TransactionId *) opaque_data;
 
    return errdetail("Could not access subtransaction status of transaction %u.", xid);
}

References errdetail(), and fb().

Referenced by SUBTRANSShmemInit().

SubTransGetParent()

TransactionId SubTransGetParent

(

TransactionId

xid

)

Definition at line 122 of file subtrans.c.

{
    int64       pageno = TransactionIdToPage(xid);
    int         entryno = TransactionIdToEntry(xid);
    int         slotno;
    TransactionId *ptr;
    TransactionId parent;
 
    /* Can't ask about stuff that might not be around anymore */
    Assert(TransactionIdFollowsOrEquals(xid, TransactionXmin));
 
    /* Bootstrap and frozen XIDs have no parent */
    if (!TransactionIdIsNormal(xid))
        return InvalidTransactionId;
 
    /* lock is acquired by SimpleLruReadPage_ReadOnly */
 
    slotno = SimpleLruReadPage_ReadOnly(SubTransCtl, pageno, &xid);
    ptr = (TransactionId *) SubTransCtl->shared->page_buffer[slotno];
    ptr += entryno;
 
    parent = *ptr;
 
    LWLockRelease(SimpleLruGetBankLock(SubTransCtl, pageno));
 
    return parent;
}

References Assert, fb(), InvalidTransactionId, LWLockRelease(), SimpleLruGetBankLock(), SimpleLruReadPage_ReadOnly(), SubTransCtl, TransactionIdFollowsOrEquals(), TransactionIdIsNormal, TransactionIdToEntry, TransactionIdToPage(), and TransactionXmin.

Referenced by SubTransGetTopmostTransaction(), TransactionIdDidAbort(), and TransactionIdDidCommit().

SubTransGetTopmostTransaction()

TransactionId SubTransGetTopmostTransaction

(

TransactionId

xid

)

Definition at line 163 of file subtrans.c.

{
    TransactionId parentXid = xid,
                previousXid = xid;
 
    /* Can't ask about stuff that might not be around anymore */
    Assert(TransactionIdFollowsOrEquals(xid, TransactionXmin));
 
    while (TransactionIdIsValid(parentXid))
    {
        previousXid = parentXid;
        if (TransactionIdPrecedes(parentXid, TransactionXmin))
            break;
        parentXid = SubTransGetParent(parentXid);
 
        /*
         * By convention the parent xid gets allocated first, so should always
         * precede the child xid. Anything else points to a corrupted data
         * structure that could lead to an infinite loop, so exit.
         */
        if (!TransactionIdPrecedes(parentXid, previousXid))
            elog(ERROR, "pg_subtrans contains invalid entry: xid %u points to parent xid %u",
                 previousXid, parentXid);
    }
 
    Assert(TransactionIdIsValid(previousXid));
 
    return previousXid;
}

References Assert, elog, ERROR, fb(), SubTransGetParent(), TransactionIdFollowsOrEquals(), TransactionIdIsValid, TransactionIdPrecedes(), and TransactionXmin.

Referenced by ConditionalXactLockTableWait(), HeapCheckForSerializableConflictOut(), TransactionIdIsInProgress(), XactLockTableWait(), and XidInMVCCSnapshot().

SubTransPagePrecedes()

static bool SubTransPagePrecedes ( int64  page1, int64  page2  )

static

Definition at line 411 of file subtrans.c.

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

References fb(), FirstNormalTransactionId, SUBTRANS_XACTS_PER_PAGE, and TransactionIdPrecedes().

Referenced by SUBTRANSShmemInit().

SubTransSetParent()

void SubTransSetParent	(	TransactionId	xid,
		TransactionId	parent
	)

Definition at line 85 of file subtrans.c.

{
    int64       pageno = TransactionIdToPage(xid);
    int         entryno = TransactionIdToEntry(xid);
    int         slotno;
    LWLock     *lock;
    TransactionId *ptr;
 
    Assert(TransactionIdIsValid(parent));
    Assert(TransactionIdFollows(xid, parent));
 
    lock = SimpleLruGetBankLock(SubTransCtl, pageno);
    LWLockAcquire(lock, LW_EXCLUSIVE);
 
    slotno = SimpleLruReadPage(SubTransCtl, pageno, true, &xid);
    ptr = (TransactionId *) SubTransCtl->shared->page_buffer[slotno];
    ptr += entryno;
 
    /*
     * It's possible we'll try to set the parent xid multiple times but we
     * shouldn't ever be changing the xid from one valid xid to another valid
     * xid, which would corrupt the data structure.
     */
    if (*ptr != parent)
    {
        Assert(*ptr == InvalidTransactionId);
        *ptr = parent;
        SubTransCtl->shared->page_dirty[slotno] = true;
    }
 
    LWLockRelease(lock);
}

References Assert, fb(), InvalidTransactionId, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), SimpleLruGetBankLock(), SimpleLruReadPage(), SubTransCtl, TransactionIdFollows(), TransactionIdIsValid, TransactionIdToEntry, and TransactionIdToPage().

Referenced by AssignTransactionId(), ProcArrayApplyXidAssignment(), and ProcessTwoPhaseBuffer().

SUBTRANSShmemBuffers()

static int SUBTRANSShmemBuffers ( void  )

static

Definition at line 201 of file subtrans.c.

{
    /* auto-tune based on shared buffers */
    if (subtransaction_buffers == 0)
        return SimpleLruAutotuneBuffers(512, 1024);
 
    return Min(Max(16, subtransaction_buffers), SLRU_MAX_ALLOWED_BUFFERS);
}

References Max, Min, SimpleLruAutotuneBuffers(), SLRU_MAX_ALLOWED_BUFFERS, and subtransaction_buffers.

Referenced by SUBTRANSShmemInit(), and SUBTRANSShmemSize().

SUBTRANSShmemInit()

void SUBTRANSShmemInit

(

void

)

Definition at line 220 of file subtrans.c.

{
    /* If auto-tuning is requested, now is the time to do it */
    if (subtransaction_buffers == 0)
    {
        char        buf[32];
 
        snprintf(buf, sizeof(buf), "%d", SUBTRANSShmemBuffers());
        SetConfigOption("subtransaction_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 subtransaction_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 (subtransaction_buffers == 0)    /* failed to apply it? */
            SetConfigOption("subtransaction_buffers", buf, PGC_POSTMASTER,
                            PGC_S_OVERRIDE);
    }
    Assert(subtransaction_buffers != 0);
 
    SubTransCtl->PagePrecedes = SubTransPagePrecedes;
    SubTransCtl->errdetail_for_io_error = subtrans_errdetail_for_io_error;
    SimpleLruInit(SubTransCtl, "subtransaction", SUBTRANSShmemBuffers(), 0,
                  "pg_subtrans", LWTRANCHE_SUBTRANS_BUFFER,
                  LWTRANCHE_SUBTRANS_SLRU, SYNC_HANDLER_NONE, false);
    SlruPagePrecedesUnitTests(SubTransCtl, SUBTRANS_XACTS_PER_PAGE);
}

References Assert, buf, fb(), PGC_POSTMASTER, PGC_S_DYNAMIC_DEFAULT, PGC_S_OVERRIDE, SetConfigOption(), SimpleLruInit(), SlruPagePrecedesUnitTests, snprintf, subtrans_errdetail_for_io_error(), SUBTRANS_XACTS_PER_PAGE, subtransaction_buffers, SubTransCtl, SubTransPagePrecedes(), SUBTRANSShmemBuffers(), and SYNC_HANDLER_NONE.

Referenced by CreateOrAttachShmemStructs().

SUBTRANSShmemSize()

Size SUBTRANSShmemSize

(

void

)

Definition at line 214 of file subtrans.c.

{
    return SimpleLruShmemSize(SUBTRANSShmemBuffers(), 0);
}

References SimpleLruShmemSize(), and SUBTRANSShmemBuffers().

Referenced by CalculateShmemSize().

TransactionIdToPage()

static int64 TransactionIdToPage ( TransactionId  xid )

inlinestatic

Definition at line 61 of file subtrans.c.

{
    return xid / (int64) SUBTRANS_XACTS_PER_PAGE;
}

References SUBTRANS_XACTS_PER_PAGE.

Referenced by ExtendSUBTRANS(), StartupSUBTRANS(), SubTransGetParent(), SubTransSetParent(), and TruncateSUBTRANS().

TruncateSUBTRANS()

void TruncateSUBTRANS

(

TransactionId

oldestXact

)

Definition at line 387 of file subtrans.c.

{
    int64       cutoffPage;
 
    /*
     * The cutoff point is the start of the segment containing oldestXact. We
     * pass the *page* containing oldestXact to SimpleLruTruncate.  We step
     * back one transaction to avoid passing a cutoff page that hasn't been
     * created yet in the rare case that oldestXact would be the first item on
     * a page and oldestXact == next XID.  In that case, if we didn't subtract
     * one, we'd trigger SimpleLruTruncate's wraparound detection.
     */
    TransactionIdRetreat(oldestXact);
    cutoffPage = TransactionIdToPage(oldestXact);
 
    SimpleLruTruncate(SubTransCtl, cutoffPage);
}

References fb(), SimpleLruTruncate(), SubTransCtl, TransactionIdRetreat, and TransactionIdToPage().

Referenced by CreateCheckPoint(), and CreateRestartPoint().

Variable Documentation

SubTransCtlData

SlruCtlData SubTransCtlData

static

Definition at line 72 of file subtrans.c.