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 "storage/subsystems.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   (&SubTransSlruDesc)

Functions
static int64	TransactionIdToPage (TransactionId xid)
static void	SUBTRANSShmemRequest (void *arg)
static void	SUBTRANSShmemInit (void *arg)
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)
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
const ShmemCallbacks	SUBTRANSShmemCallbacks
static SlruDesc	SubTransSlruDesc

Macro Definition Documentation

SUBTRANS_XACTS_PER_PAGE

#define SUBTRANS_XACTS_PER_PAGE   (BLCKSZ / sizeof(TransactionId))

Definition at line 55 of file subtrans.c.

SubTransCtl

#define SubTransCtl   (&SubTransSlruDesc)

Definition at line 85 of file subtrans.c.

TransactionIdToEntry

#define TransactionIdToEntry

(

xid

)

((xid) % (TransactionId) SUBTRANS_XACTS_PER_PAGE)

Definition at line 67 of file subtrans.c.

Function Documentation

BootStrapSUBTRANS()

void BootStrapSUBTRANS

(

void

)

Definition at line 288 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 272 of file subtrans.c.

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

References check_slru_buffers(), and newval.

CheckPointSUBTRANS()

void CheckPointSUBTRANS

(

void

)

Definition at line 348 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 372 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 302 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 443 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 SUBTRANSShmemRequest().

SubTransGetParent()

TransactionId SubTransGetParent

(

TransactionId

xid

)

Definition at line 129 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 170 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 428 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 SUBTRANSShmemRequest().

SubTransSetParent()

void SubTransSetParent	(	TransactionId	xid,
		TransactionId	parent
	)

Definition at line 92 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 208 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 SUBTRANSShmemRequest().

SUBTRANSShmemInit()

static void SUBTRANSShmemInit ( void *  arg )

static

Definition at line 263 of file subtrans.c.

{
    SlruPagePrecedesUnitTests(SubTransCtl, SUBTRANS_XACTS_PER_PAGE);
}

References SlruPagePrecedesUnitTests, SUBTRANS_XACTS_PER_PAGE, and SubTransCtl.

SUBTRANSShmemRequest()

static void SUBTRANSShmemRequest ( void *  arg )

static

Definition at line 223 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);
 
    SimpleLruRequest(.desc = &SubTransSlruDesc,
                     .name = "subtransaction",
                     .Dir = "pg_subtrans",
                     .long_segment_names = false,
 
                     .nslots = SUBTRANSShmemBuffers(),
 
                     .sync_handler = SYNC_HANDLER_NONE,
                     .PagePrecedes = SubTransPagePrecedes,
                     .errdetail_for_io_error = subtrans_errdetail_for_io_error,
 
                     .buffer_tranche_id = LWTRANCHE_SUBTRANS_BUFFER,
                     .bank_tranche_id = LWTRANCHE_SUBTRANS_SLRU,
        );
}

References Assert, buf, fb(), name, PGC_POSTMASTER, PGC_S_DYNAMIC_DEFAULT, PGC_S_OVERRIDE, SetConfigOption(), SimpleLruRequest, snprintf, subtrans_errdetail_for_io_error(), subtransaction_buffers, SubTransPagePrecedes(), SUBTRANSShmemBuffers(), SubTransSlruDesc, and SYNC_HANDLER_NONE.

TransactionIdToPage()

static int64 TransactionIdToPage ( TransactionId  xid )

inlinestatic

Definition at line 62 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 404 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

SUBTRANSShmemCallbacks

const ShmemCallbacks SUBTRANSShmemCallbacks

Initial value:

= {
    .request_fn = SUBTRANSShmemRequest,
    .init_fn = SUBTRANSShmemInit,
}

Definition at line 75 of file subtrans.c.

                                              {
    .request_fn = SUBTRANSShmemRequest,
    .init_fn = SUBTRANSShmemInit,
};

SubTransSlruDesc

SlruDesc SubTransSlruDesc

static

Definition at line 83 of file subtrans.c.

Referenced by SUBTRANSShmemRequest().