This graph shows which files directly or indirectly include this file:

Macros
#define	NUM_SUBTRANS_BUFFERS 32

Functions
void	SubTransSetParent (TransactionId xid, TransactionId parent)

TransactionId	SubTransGetParent (TransactionId xid)

TransactionId	SubTransGetTopmostTransaction (TransactionId xid)

Size	SUBTRANSShmemSize (void)

void	SUBTRANSShmemInit (void)

void	BootStrapSUBTRANS (void)

void	StartupSUBTRANS (TransactionId oldestActiveXID)

void	CheckPointSUBTRANS (void)

void	ExtendSUBTRANS (TransactionId newestXact)

void	TruncateSUBTRANS (TransactionId oldestXact)

Macro Definition Documentation

◆ NUM_SUBTRANS_BUFFERS

#define NUM_SUBTRANS_BUFFERS 32

Definition at line 15 of file subtrans.h.

Function Documentation

◆ BootStrapSUBTRANS()

void BootStrapSUBTRANS ( void )

Definition at line 211 of file subtrans.c.

 {
     int         slotno;
  
     LWLockAcquire(SubtransSLRULock, LW_EXCLUSIVE);
  
     /* Create and zero the first page of the subtrans log */
     slotno = ZeroSUBTRANSPage(0);
  
     /* Make sure it's written out */
     SimpleLruWritePage(SubTransCtl, slotno);
     Assert(!SubTransCtl->shared->page_dirty[slotno]);
  
     LWLockRelease(SubtransSLRULock);
 }

References Assert(), LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), SimpleLruWritePage(), SubTransCtl, and ZeroSUBTRANSPage().

Referenced by BootStrapXLOG().

◆ CheckPointSUBTRANS()

void CheckPointSUBTRANS ( void )

Definition at line 284 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 SimpleLruWriteAll(), and SubTransCtl.

Referenced by CheckPointGuts().

◆ ExtendSUBTRANS()

void ExtendSUBTRANS ( TransactionId newestXact )

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

References FirstNormalTransactionId, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), TransactionIdEquals, TransactionIdToEntry, TransactionIdToPage, and ZeroSUBTRANSPage().

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

◆ StartupSUBTRANS()

void StartupSUBTRANS ( TransactionId oldestActiveXID )

Definition at line 249 of file subtrans.c.

 {
     FullTransactionId nextXid;
     int         startPage;
     int         endPage;
  
     /*
      * 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.
      */
     LWLockAcquire(SubtransSLRULock, LW_EXCLUSIVE);
  
     startPage = TransactionIdToPage(oldestActiveXID);
     nextXid = ShmemVariableCache->nextXid;
     endPage = TransactionIdToPage(XidFromFullTransactionId(nextXid));
  
     while (startPage != endPage)
     {
         (void) ZeroSUBTRANSPage(startPage);
         startPage++;
         /* must account for wraparound */
         if (startPage > TransactionIdToPage(MaxTransactionId))
             startPage = 0;
     }
     (void) ZeroSUBTRANSPage(startPage);
  
     LWLockRelease(SubtransSLRULock);
 }

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

Referenced by StartupXLOG().

◆ SubTransGetParent()

TransactionId SubTransGetParent ( TransactionId xid )

Definition at line 109 of file subtrans.c.

 {
     int         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(SubtransSLRULock);
  
     return parent;
 }

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

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

◆ SubTransGetTopmostTransaction()

TransactionId SubTransGetTopmostTransaction ( TransactionId xid )

Definition at line 150 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, SubTransGetParent(), TransactionIdFollowsOrEquals(), TransactionIdIsValid, TransactionIdPrecedes(), and TransactionXmin.

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

◆ SubTransSetParent()

void SubTransSetParent	(	TransactionId	xid,
		TransactionId	parent
	)

Definition at line 74 of file subtrans.c.

 {
     int         pageno = TransactionIdToPage(xid);
     int         entryno = TransactionIdToEntry(xid);
     int         slotno;
     TransactionId *ptr;
  
     Assert(TransactionIdIsValid(parent));
     Assert(TransactionIdFollows(xid, parent));
  
     LWLockAcquire(SubtransSLRULock, 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(SubtransSLRULock);
 }

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

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

◆ SUBTRANSShmemInit()

void SUBTRANSShmemInit ( void )

Definition at line 191 of file subtrans.c.

 {
     SubTransCtl->PagePrecedes = SubTransPagePrecedes;
     SimpleLruInit(SubTransCtl, "Subtrans", NUM_SUBTRANS_BUFFERS, 0,
                   SubtransSLRULock, "pg_subtrans",
                   LWTRANCHE_SUBTRANS_BUFFER, SYNC_HANDLER_NONE);
     SlruPagePrecedesUnitTests(SubTransCtl, SUBTRANS_XACTS_PER_PAGE);
 }

References LWTRANCHE_SUBTRANS_BUFFER, NUM_SUBTRANS_BUFFERS, SimpleLruInit(), SlruPagePrecedesUnitTests, SUBTRANS_XACTS_PER_PAGE, SubTransCtl, SubTransPagePrecedes(), and SYNC_HANDLER_NONE.

Referenced by CreateSharedMemoryAndSemaphores().

◆ SUBTRANSShmemSize()

Size SUBTRANSShmemSize ( void )

Definition at line 185 of file subtrans.c.

 {
     return SimpleLruShmemSize(NUM_SUBTRANS_BUFFERS, 0);
 }

References NUM_SUBTRANS_BUFFERS, and SimpleLruShmemSize().

Referenced by CalculateShmemSize().

◆ TruncateSUBTRANS()

void TruncateSUBTRANS ( TransactionId oldestXact )

Definition at line 338 of file subtrans.c.

 {
     int         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 SimpleLruTruncate(), SubTransCtl, TransactionIdRetreat, and TransactionIdToPage.

Referenced by CreateCheckPoint(), and CreateRestartPoint().

Macros

Functions