#include "access/xlogreader.h"
#include "lib/stringinfo.h"
#include "storage/sync.h"

Include dependency graph for multixact.h:

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

Data Structures
struct	MultiXactMember

struct	xl_multixact_create

struct	xl_multixact_truncate

Macros
#define	InvalidMultiXactId ((MultiXactId) 0)

#define	FirstMultiXactId ((MultiXactId) 1)

#define	MaxMultiXactId ((MultiXactId) 0xFFFFFFFF)

#define	MultiXactIdIsValid(multi) ((multi) != InvalidMultiXactId)

#define	MaxMultiXactOffset ((MultiXactOffset) 0xFFFFFFFF)

#define	MaxMultiXactStatus MultiXactStatusUpdate

#define	ISUPDATE_from_mxstatus(status) ((status) > MultiXactStatusForUpdate)

#define	XLOG_MULTIXACT_ZERO_OFF_PAGE 0x00

#define	XLOG_MULTIXACT_ZERO_MEM_PAGE 0x10

#define	XLOG_MULTIXACT_CREATE_ID 0x20

#define	XLOG_MULTIXACT_TRUNCATE_ID 0x30

#define	SizeOfMultiXactCreate (offsetof(xl_multixact_create, members))

#define	SizeOfMultiXactTruncate (sizeof(xl_multixact_truncate))

Typedefs
typedef struct MultiXactMember	MultiXactMember

typedef struct xl_multixact_create	xl_multixact_create

typedef struct xl_multixact_truncate	xl_multixact_truncate

Enumerations
enum	MultiXactStatus { MultiXactStatusForKeyShare = 0x00 , MultiXactStatusForShare = 0x01 , MultiXactStatusForNoKeyUpdate = 0x02 , MultiXactStatusForUpdate = 0x03 , MultiXactStatusNoKeyUpdate = 0x04 , MultiXactStatusUpdate = 0x05 }

Functions
MultiXactId	MultiXactIdCreate (TransactionId xid1, MultiXactStatus status1, TransactionId xid2, MultiXactStatus status2)

MultiXactId	MultiXactIdExpand (MultiXactId multi, TransactionId xid, MultiXactStatus status)

MultiXactId	MultiXactIdCreateFromMembers (int nmembers, MultiXactMember *members)

MultiXactId	ReadNextMultiXactId (void)

void	ReadMultiXactIdRange (MultiXactId oldest, MultiXactId next)

bool	MultiXactIdIsRunning (MultiXactId multi, bool isLockOnly)

void	MultiXactIdSetOldestMember (void)

int	GetMultiXactIdMembers (MultiXactId multi, MultiXactMember **members, bool from_pgupgrade, bool isLockOnly)

bool	MultiXactIdPrecedes (MultiXactId multi1, MultiXactId multi2)

bool	MultiXactIdPrecedesOrEquals (MultiXactId multi1, MultiXactId multi2)

int	multixactoffsetssyncfiletag (const FileTag ftag, char path)

int	multixactmemberssyncfiletag (const FileTag ftag, char path)

void	AtEOXact_MultiXact (void)

void	AtPrepare_MultiXact (void)

void	PostPrepare_MultiXact (TransactionId xid)

Size	MultiXactShmemSize (void)

void	MultiXactShmemInit (void)

void	BootStrapMultiXact (void)

void	StartupMultiXact (void)

void	TrimMultiXact (void)

void	SetMultiXactIdLimit (MultiXactId oldest_datminmxid, Oid oldest_datoid, bool is_startup)

void	MultiXactGetCheckptMulti (bool is_shutdown, MultiXactId nextMulti, MultiXactOffset nextMultiOffset, MultiXactId oldestMulti, Oid oldestMultiDB)

void	CheckPointMultiXact (void)

MultiXactId	GetOldestMultiXactId (void)

void	TruncateMultiXact (MultiXactId newOldestMulti, Oid newOldestMultiDB)

void	MultiXactSetNextMXact (MultiXactId nextMulti, MultiXactOffset nextMultiOffset)

void	MultiXactAdvanceNextMXact (MultiXactId minMulti, MultiXactOffset minMultiOffset)

void	MultiXactAdvanceOldest (MultiXactId oldestMulti, Oid oldestMultiDB)

int	MultiXactMemberFreezeThreshold (void)

void	multixact_twophase_recover (TransactionId xid, uint16 info, void *recdata, uint32 len)

void	multixact_twophase_postcommit (TransactionId xid, uint16 info, void *recdata, uint32 len)

void	multixact_twophase_postabort (TransactionId xid, uint16 info, void *recdata, uint32 len)

void	multixact_redo (XLogReaderState *record)

void	multixact_desc (StringInfo buf, XLogReaderState *record)

const char *	multixact_identify (uint8 info)

char *	mxid_to_string (MultiXactId multi, int nmembers, MultiXactMember *members)

Macro Definition Documentation

◆ FirstMultiXactId

#define FirstMultiXactId ((MultiXactId) 1)

Definition at line 25 of file multixact.h.

◆ InvalidMultiXactId

#define InvalidMultiXactId ((MultiXactId) 0)

Definition at line 24 of file multixact.h.

◆ ISUPDATE_from_mxstatus

#define ISUPDATE_from_mxstatus ( status ) ((status) > MultiXactStatusForUpdate)

Definition at line 52 of file multixact.h.

◆ MaxMultiXactId

#define MaxMultiXactId ((MultiXactId) 0xFFFFFFFF)

Definition at line 26 of file multixact.h.

◆ MaxMultiXactOffset

#define MaxMultiXactOffset ((MultiXactOffset) 0xFFFFFFFF)

Definition at line 30 of file multixact.h.

◆ MaxMultiXactStatus

#define MaxMultiXactStatus MultiXactStatusUpdate

Definition at line 49 of file multixact.h.

◆ MultiXactIdIsValid

#define MultiXactIdIsValid ( multi ) ((multi) != InvalidMultiXactId)

Definition at line 28 of file multixact.h.

◆ SizeOfMultiXactCreate

#define SizeOfMultiXactCreate (offsetof(xl_multixact_create, members))

Definition at line 81 of file multixact.h.

◆ SizeOfMultiXactTruncate

#define SizeOfMultiXactTruncate (sizeof(xl_multixact_truncate))

Definition at line 96 of file multixact.h.

◆ XLOG_MULTIXACT_CREATE_ID

#define XLOG_MULTIXACT_CREATE_ID 0x20

Definition at line 70 of file multixact.h.

◆ XLOG_MULTIXACT_TRUNCATE_ID

#define XLOG_MULTIXACT_TRUNCATE_ID 0x30

Definition at line 71 of file multixact.h.

◆ XLOG_MULTIXACT_ZERO_MEM_PAGE

#define XLOG_MULTIXACT_ZERO_MEM_PAGE 0x10

Definition at line 69 of file multixact.h.

◆ XLOG_MULTIXACT_ZERO_OFF_PAGE

#define XLOG_MULTIXACT_ZERO_OFF_PAGE 0x00

Definition at line 68 of file multixact.h.

Typedef Documentation

◆ MultiXactMember

typedef struct MultiXactMember MultiXactMember

◆ xl_multixact_create

typedef struct xl_multixact_create xl_multixact_create

◆ xl_multixact_truncate

typedef struct xl_multixact_truncate xl_multixact_truncate

Enumeration Type Documentation

◆ MultiXactStatus

enum MultiXactStatus

Enumerator
MultiXactStatusForKeyShare
MultiXactStatusForShare
MultiXactStatusForNoKeyUpdate
MultiXactStatusForUpdate
MultiXactStatusNoKeyUpdate
MultiXactStatusUpdate

Definition at line 37 of file multixact.h.

 {
     MultiXactStatusForKeyShare = 0x00,
     MultiXactStatusForShare = 0x01,
     MultiXactStatusForNoKeyUpdate = 0x02,
     MultiXactStatusForUpdate = 0x03,
     /* an update that doesn't touch "key" columns */
     MultiXactStatusNoKeyUpdate = 0x04,
     /* other updates, and delete */
     MultiXactStatusUpdate = 0x05,
 } MultiXactStatus;

Function Documentation

◆ AtEOXact_MultiXact()

void AtEOXact_MultiXact ( void )

Definition at line 1808 of file multixact.c.

 {
     /*
      * Reset our OldestMemberMXactId and OldestVisibleMXactId values, both of
      * which should only be valid while within a transaction.
      *
      * We assume that storing a MultiXactId is atomic and so we need not take
      * MultiXactGenLock to do this.
      */
     OldestMemberMXactId[MyProcNumber] = InvalidMultiXactId;
     OldestVisibleMXactId[MyProcNumber] = InvalidMultiXactId;
  
     /*
      * Discard the local MultiXactId cache.  Since MXactContext was created as
      * a child of TopTransactionContext, we needn't delete it explicitly.
      */
     MXactContext = NULL;
     dclist_init(&MXactCache);
 }

References dclist_init(), InvalidMultiXactId, MXactCache, MXactContext, MyProcNumber, OldestMemberMXactId, and OldestVisibleMXactId.

Referenced by AbortTransaction(), CommitTransaction(), and test_read_multixact().

◆ AtPrepare_MultiXact()

void AtPrepare_MultiXact ( void )

Definition at line 1836 of file multixact.c.

 {
     MultiXactId myOldestMember = OldestMemberMXactId[MyProcNumber];
  
     if (MultiXactIdIsValid(myOldestMember))
         RegisterTwoPhaseRecord(TWOPHASE_RM_MULTIXACT_ID, 0,
                                &myOldestMember, sizeof(MultiXactId));
 }

References MultiXactIdIsValid, MyProcNumber, OldestMemberMXactId, RegisterTwoPhaseRecord(), and TWOPHASE_RM_MULTIXACT_ID.

Referenced by PrepareTransaction().

◆ BootStrapMultiXact()

void BootStrapMultiXact ( void )

Definition at line 2034 of file multixact.c.

 {
     int         slotno;
     LWLock     *lock;
  
     lock = SimpleLruGetBankLock(MultiXactOffsetCtl, 0);
     LWLockAcquire(lock, LW_EXCLUSIVE);
  
     /* Create and zero the first page of the offsets log */
     slotno = ZeroMultiXactOffsetPage(0, false);
  
     /* Make sure it's written out */
     SimpleLruWritePage(MultiXactOffsetCtl, slotno);
     Assert(!MultiXactOffsetCtl->shared->page_dirty[slotno]);
  
     LWLockRelease(lock);
  
     lock = SimpleLruGetBankLock(MultiXactMemberCtl, 0);
     LWLockAcquire(lock, LW_EXCLUSIVE);
  
     /* Create and zero the first page of the members log */
     slotno = ZeroMultiXactMemberPage(0, false);
  
     /* Make sure it's written out */
     SimpleLruWritePage(MultiXactMemberCtl, slotno);
     Assert(!MultiXactMemberCtl->shared->page_dirty[slotno]);
  
     LWLockRelease(lock);
 }

References Assert, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MultiXactMemberCtl, MultiXactOffsetCtl, SimpleLruGetBankLock(), SimpleLruWritePage(), ZeroMultiXactMemberPage(), and ZeroMultiXactOffsetPage().

Referenced by BootStrapXLOG().

◆ CheckPointMultiXact()

void CheckPointMultiXact ( void )

Definition at line 2304 of file multixact.c.

 {
     TRACE_POSTGRESQL_MULTIXACT_CHECKPOINT_START(true);
  
     /*
      * Write dirty MultiXact pages to disk.  This may result in sync requests
      * queued for later handling by ProcessSyncRequests(), as part of the
      * checkpoint.
      */
     SimpleLruWriteAll(MultiXactOffsetCtl, true);
     SimpleLruWriteAll(MultiXactMemberCtl, true);
  
     TRACE_POSTGRESQL_MULTIXACT_CHECKPOINT_DONE(true);
 }

References MultiXactMemberCtl, MultiXactOffsetCtl, and SimpleLruWriteAll().

Referenced by CheckPointGuts().

◆ GetMultiXactIdMembers()

int GetMultiXactIdMembers	(	MultiXactId	multi,
		MultiXactMember **	members,
		bool	from_pgupgrade,
		bool	isLockOnly
	)

Definition at line 1299 of file multixact.c.

 {
     int64       pageno;
     int64       prev_pageno;
     int         entryno;
     int         slotno;
     MultiXactOffset *offptr;
     MultiXactOffset offset;
     int         length;
     int         truelength;
     MultiXactId oldestMXact;
     MultiXactId nextMXact;
     MultiXactId tmpMXact;
     MultiXactOffset nextOffset;
     MultiXactMember *ptr;
     LWLock     *lock;
     bool        slept = false;
  
     debug_elog3(DEBUG2, "GetMembers: asked for %u", multi);
  
     if (!MultiXactIdIsValid(multi) || from_pgupgrade)
     {
         *members = NULL;
         return -1;
     }
  
     /* See if the MultiXactId is in the local cache */
     length = mXactCacheGetById(multi, members);
     if (length >= 0)
     {
         debug_elog3(DEBUG2, "GetMembers: found %s in the cache",
                     mxid_to_string(multi, length, *members));
         return length;
     }
  
     /* Set our OldestVisibleMXactId[] entry if we didn't already */
     MultiXactIdSetOldestVisible();
  
     /*
      * If we know the multi is used only for locking and not for updates, then
      * we can skip checking if the value is older than our oldest visible
      * multi.  It cannot possibly still be running.
      */
     if (isLockOnly &&
         MultiXactIdPrecedes(multi, OldestVisibleMXactId[MyProcNumber]))
     {
         debug_elog2(DEBUG2, "GetMembers: a locker-only multi is too old");
         *members = NULL;
         return -1;
     }
  
     /*
      * We check known limits on MultiXact before resorting to the SLRU area.
      *
      * An ID older than MultiXactState->oldestMultiXactId cannot possibly be
      * useful; it has already been removed, or will be removed shortly, by
      * truncation.  If one is passed, an error is raised.
      *
      * Also, an ID >= nextMXact shouldn't ever be seen here; if it is seen, it
      * implies undetected ID wraparound has occurred.  This raises a hard
      * error.
      *
      * Shared lock is enough here since we aren't modifying any global state.
      * Acquire it just long enough to grab the current counter values.  We may
      * need both nextMXact and nextOffset; see below.
      */
     LWLockAcquire(MultiXactGenLock, LW_SHARED);
  
     oldestMXact = MultiXactState->oldestMultiXactId;
     nextMXact = MultiXactState->nextMXact;
     nextOffset = MultiXactState->nextOffset;
  
     LWLockRelease(MultiXactGenLock);
  
     if (MultiXactIdPrecedes(multi, oldestMXact))
         ereport(ERROR,
                 (errcode(ERRCODE_INTERNAL_ERROR),
                  errmsg("MultiXactId %u does no longer exist -- apparent wraparound",
                         multi)));
  
     if (!MultiXactIdPrecedes(multi, nextMXact))
         ereport(ERROR,
                 (errcode(ERRCODE_INTERNAL_ERROR),
                  errmsg("MultiXactId %u has not been created yet -- apparent wraparound",
                         multi)));
  
     /*
      * Find out the offset at which we need to start reading MultiXactMembers
      * and the number of members in the multixact.  We determine the latter as
      * the difference between this multixact's starting offset and the next
      * one's.  However, there are some corner cases to worry about:
      *
      * 1. This multixact may be the latest one created, in which case there is
      * no next one to look at.  In this case the nextOffset value we just
      * saved is the correct endpoint.
      *
      * 2. The next multixact may still be in process of being filled in: that
      * is, another process may have done GetNewMultiXactId but not yet written
      * the offset entry for that ID.  In that scenario, it is guaranteed that
      * the offset entry for that multixact exists (because GetNewMultiXactId
      * won't release MultiXactGenLock until it does) but contains zero
      * (because we are careful to pre-zero offset pages). Because
      * GetNewMultiXactId will never return zero as the starting offset for a
      * multixact, when we read zero as the next multixact's offset, we know we
      * have this case.  We handle this by sleeping on the condition variable
      * we have just for this; the process in charge will signal the CV as soon
      * as it has finished writing the multixact offset.
      *
      * 3. Because GetNewMultiXactId increments offset zero to offset one to
      * handle case #2, there is an ambiguity near the point of offset
      * wraparound.  If we see next multixact's offset is one, is that our
      * multixact's actual endpoint, or did it end at zero with a subsequent
      * increment?  We handle this using the knowledge that if the zero'th
      * member slot wasn't filled, it'll contain zero, and zero isn't a valid
      * transaction ID so it can't be a multixact member.  Therefore, if we
      * read a zero from the members array, just ignore it.
      *
      * This is all pretty messy, but the mess occurs only in infrequent corner
      * cases, so it seems better than holding the MultiXactGenLock for a long
      * time on every multixact creation.
      */
 retry:
     pageno = MultiXactIdToOffsetPage(multi);
     entryno = MultiXactIdToOffsetEntry(multi);
  
     /* Acquire the bank lock for the page we need. */
     lock = SimpleLruGetBankLock(MultiXactOffsetCtl, pageno);
     LWLockAcquire(lock, LW_EXCLUSIVE);
  
     slotno = SimpleLruReadPage(MultiXactOffsetCtl, pageno, true, multi);
     offptr = (MultiXactOffset *) MultiXactOffsetCtl->shared->page_buffer[slotno];
     offptr += entryno;
     offset = *offptr;
  
     Assert(offset != 0);
  
     /*
      * Use the same increment rule as GetNewMultiXactId(), that is, don't
      * handle wraparound explicitly until needed.
      */
     tmpMXact = multi + 1;
  
     if (nextMXact == tmpMXact)
     {
         /* Corner case 1: there is no next multixact */
         length = nextOffset - offset;
     }
     else
     {
         MultiXactOffset nextMXOffset;
  
         /* handle wraparound if needed */
         if (tmpMXact < FirstMultiXactId)
             tmpMXact = FirstMultiXactId;
  
         prev_pageno = pageno;
  
         pageno = MultiXactIdToOffsetPage(tmpMXact);
         entryno = MultiXactIdToOffsetEntry(tmpMXact);
  
         if (pageno != prev_pageno)
         {
             LWLock     *newlock;
  
             /*
              * Since we're going to access a different SLRU page, if this page
              * falls under a different bank, release the old bank's lock and
              * acquire the lock of the new bank.
              */
             newlock = SimpleLruGetBankLock(MultiXactOffsetCtl, pageno);
             if (newlock != lock)
             {
                 LWLockRelease(lock);
                 LWLockAcquire(newlock, LW_EXCLUSIVE);
                 lock = newlock;
             }
             slotno = SimpleLruReadPage(MultiXactOffsetCtl, pageno, true, tmpMXact);
         }
  
         offptr = (MultiXactOffset *) MultiXactOffsetCtl->shared->page_buffer[slotno];
         offptr += entryno;
         nextMXOffset = *offptr;
  
         if (nextMXOffset == 0)
         {
             /* Corner case 2: next multixact is still being filled in */
             LWLockRelease(lock);
             CHECK_FOR_INTERRUPTS();
  
             INJECTION_POINT("multixact-get-members-cv-sleep");
  
             ConditionVariableSleep(&MultiXactState->nextoff_cv,
                                    WAIT_EVENT_MULTIXACT_CREATION);
             slept = true;
             goto retry;
         }
  
         length = nextMXOffset - offset;
     }
  
     LWLockRelease(lock);
     lock = NULL;
  
     /*
      * If we slept above, clean up state; it's no longer needed.
      */
     if (slept)
         ConditionVariableCancelSleep();
  
     ptr = (MultiXactMember *) palloc(length * sizeof(MultiXactMember));
  
     truelength = 0;
     prev_pageno = -1;
     for (int i = 0; i < length; i++, offset++)
     {
         TransactionId *xactptr;
         uint32     *flagsptr;
         int         flagsoff;
         int         bshift;
         int         memberoff;
  
         pageno = MXOffsetToMemberPage(offset);
         memberoff = MXOffsetToMemberOffset(offset);
  
         if (pageno != prev_pageno)
         {
             LWLock     *newlock;
  
             /*
              * Since we're going to access a different SLRU page, if this page
              * falls under a different bank, release the old bank's lock and
              * acquire the lock of the new bank.
              */
             newlock = SimpleLruGetBankLock(MultiXactMemberCtl, pageno);
             if (newlock != lock)
             {
                 if (lock)
                     LWLockRelease(lock);
                 LWLockAcquire(newlock, LW_EXCLUSIVE);
                 lock = newlock;
             }
  
             slotno = SimpleLruReadPage(MultiXactMemberCtl, pageno, true, multi);
             prev_pageno = pageno;
         }
  
         xactptr = (TransactionId *)
             (MultiXactMemberCtl->shared->page_buffer[slotno] + memberoff);
  
         if (!TransactionIdIsValid(*xactptr))
         {
             /* Corner case 3: we must be looking at unused slot zero */
             Assert(offset == 0);
             continue;
         }
  
         flagsoff = MXOffsetToFlagsOffset(offset);
         bshift = MXOffsetToFlagsBitShift(offset);
         flagsptr = (uint32 *) (MultiXactMemberCtl->shared->page_buffer[slotno] + flagsoff);
  
         ptr[truelength].xid = *xactptr;
         ptr[truelength].status = (*flagsptr >> bshift) & MXACT_MEMBER_XACT_BITMASK;
         truelength++;
     }
  
     LWLockRelease(lock);
  
     /* A multixid with zero members should not happen */
     Assert(truelength > 0);
  
     /*
      * Copy the result into the local cache.
      */
     mXactCachePut(multi, truelength, ptr);
  
     debug_elog3(DEBUG2, "GetMembers: no cache for %s",
                 mxid_to_string(multi, truelength, ptr));
     *members = ptr;
     return truelength;
 }

References Assert, CHECK_FOR_INTERRUPTS, ConditionVariableCancelSleep(), ConditionVariableSleep(), DEBUG2, debug_elog2, debug_elog3, ereport, errcode(), errmsg(), ERROR, FirstMultiXactId, i, if(), INJECTION_POINT, LW_EXCLUSIVE, LW_SHARED, LWLockAcquire(), LWLockRelease(), MultiXactIdIsValid, MultiXactIdPrecedes(), MultiXactIdSetOldestVisible(), MultiXactIdToOffsetEntry(), MultiXactIdToOffsetPage(), MultiXactMemberCtl, MultiXactOffsetCtl, MultiXactState, MXACT_MEMBER_XACT_BITMASK, mXactCacheGetById(), mXactCachePut(), mxid_to_string(), MXOffsetToFlagsBitShift(), MXOffsetToFlagsOffset(), MXOffsetToMemberOffset(), MXOffsetToMemberPage(), MyProcNumber, MultiXactStateData::nextMXact, MultiXactStateData::nextoff_cv, MultiXactStateData::nextOffset, MultiXactStateData::oldestMultiXactId, OldestVisibleMXactId, palloc(), SimpleLruGetBankLock(), SimpleLruReadPage(), MultiXactMember::status, TransactionIdIsValid, and MultiXactMember::xid.

Referenced by Do_MultiXactIdWait(), DoesMultiXactIdConflict(), FreezeMultiXactId(), GetMultiXactIdHintBits(), heap_lock_tuple(), heap_lock_updated_tuple_rec(), heap_tuple_should_freeze(), MultiXactIdExpand(), MultiXactIdGetUpdateXid(), MultiXactIdIsRunning(), pg_get_multixact_members(), pgrowlocks(), and test_read_multixact().

◆ GetOldestMultiXactId()

MultiXactId GetOldestMultiXactId ( void )

Definition at line 2660 of file multixact.c.

 {
     MultiXactId oldestMXact;
     MultiXactId nextMXact;
     int         i;
  
     /*
      * This is the oldest valid value among all the OldestMemberMXactId[] and
      * OldestVisibleMXactId[] entries, or nextMXact if none are valid.
      */
     LWLockAcquire(MultiXactGenLock, LW_SHARED);
  
     /*
      * We have to beware of the possibility that nextMXact is in the
      * wrapped-around state.  We don't fix the counter itself here, but we
      * must be sure to use a valid value in our calculation.
      */
     nextMXact = MultiXactState->nextMXact;
     if (nextMXact < FirstMultiXactId)
         nextMXact = FirstMultiXactId;
  
     oldestMXact = nextMXact;
     for (i = 0; i < MaxOldestSlot; i++)
     {
         MultiXactId thisoldest;
  
         thisoldest = OldestMemberMXactId[i];
         if (MultiXactIdIsValid(thisoldest) &&
             MultiXactIdPrecedes(thisoldest, oldestMXact))
             oldestMXact = thisoldest;
         thisoldest = OldestVisibleMXactId[i];
         if (MultiXactIdIsValid(thisoldest) &&
             MultiXactIdPrecedes(thisoldest, oldestMXact))
             oldestMXact = thisoldest;
     }
  
     LWLockRelease(MultiXactGenLock);
  
     return oldestMXact;
 }

References FirstMultiXactId, i, LW_SHARED, LWLockAcquire(), LWLockRelease(), MaxOldestSlot, MultiXactIdIsValid, MultiXactIdPrecedes(), MultiXactState, MultiXactStateData::nextMXact, OldestMemberMXactId, and OldestVisibleMXactId.

Referenced by heapam_relation_set_new_filelocator(), vac_update_datfrozenxid(), and vacuum_get_cutoffs().

◆ multixact_desc()

void multixact_desc	(	StringInfo	buf,
		XLogReaderState *	record
	)

Definition at line 50 of file mxactdesc.c.

 {
     char       *rec = XLogRecGetData(record);
     uint8       info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
  
     if (info == XLOG_MULTIXACT_ZERO_OFF_PAGE ||
         info == XLOG_MULTIXACT_ZERO_MEM_PAGE)
     {
         int64       pageno;
  
         memcpy(&pageno, rec, sizeof(pageno));
         appendStringInfo(buf, "%lld", (long long) pageno);
     }
     else if (info == XLOG_MULTIXACT_CREATE_ID)
     {
         xl_multixact_create *xlrec = (xl_multixact_create *) rec;
         int         i;
  
         appendStringInfo(buf, "%u offset %u nmembers %d: ", xlrec->mid,
                          xlrec->moff, xlrec->nmembers);
         for (i = 0; i < xlrec->nmembers; i++)
             out_member(buf, &xlrec->members[i]);
     }
     else if (info == XLOG_MULTIXACT_TRUNCATE_ID)
     {
         xl_multixact_truncate *xlrec = (xl_multixact_truncate *) rec;
  
         appendStringInfo(buf, "offsets [%u, %u), members [%u, %u)",
                          xlrec->startTruncOff, xlrec->endTruncOff,
                          xlrec->startTruncMemb, xlrec->endTruncMemb);
     }
 }

References appendStringInfo(), buf, xl_multixact_truncate::endTruncMemb, xl_multixact_truncate::endTruncOff, i, xl_multixact_create::members, xl_multixact_create::mid, xl_multixact_create::moff, xl_multixact_create::nmembers, out_member(), xl_multixact_truncate::startTruncMemb, xl_multixact_truncate::startTruncOff, XLOG_MULTIXACT_CREATE_ID, XLOG_MULTIXACT_TRUNCATE_ID, XLOG_MULTIXACT_ZERO_MEM_PAGE, XLOG_MULTIXACT_ZERO_OFF_PAGE, XLogRecGetData, XLogRecGetInfo, and XLR_INFO_MASK.

◆ multixact_identify()

const char* multixact_identify ( uint8 info )

Definition at line 84 of file mxactdesc.c.

 {
     const char *id = NULL;
  
     switch (info & ~XLR_INFO_MASK)
     {
         case XLOG_MULTIXACT_ZERO_OFF_PAGE:
             id = "ZERO_OFF_PAGE";
             break;
         case XLOG_MULTIXACT_ZERO_MEM_PAGE:
             id = "ZERO_MEM_PAGE";
             break;
         case XLOG_MULTIXACT_CREATE_ID:
             id = "CREATE_ID";
             break;
         case XLOG_MULTIXACT_TRUNCATE_ID:
             id = "TRUNCATE_ID";
             break;
     }
  
     return id;
 }

References XLOG_MULTIXACT_CREATE_ID, XLOG_MULTIXACT_TRUNCATE_ID, XLOG_MULTIXACT_ZERO_MEM_PAGE, XLOG_MULTIXACT_ZERO_OFF_PAGE, and XLR_INFO_MASK.

◆ multixact_redo()

void multixact_redo ( XLogReaderState * record )

Definition at line 3394 of file multixact.c.

 {
     uint8       info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
  
     /* Backup blocks are not used in multixact records */
     Assert(!XLogRecHasAnyBlockRefs(record));
  
     if (info == XLOG_MULTIXACT_ZERO_OFF_PAGE)
     {
         int64       pageno;
         int         slotno;
         LWLock     *lock;
  
         memcpy(&pageno, XLogRecGetData(record), sizeof(pageno));
  
         lock = SimpleLruGetBankLock(MultiXactOffsetCtl, pageno);
         LWLockAcquire(lock, LW_EXCLUSIVE);
  
         slotno = ZeroMultiXactOffsetPage(pageno, false);
         SimpleLruWritePage(MultiXactOffsetCtl, slotno);
         Assert(!MultiXactOffsetCtl->shared->page_dirty[slotno]);
  
         LWLockRelease(lock);
     }
     else if (info == XLOG_MULTIXACT_ZERO_MEM_PAGE)
     {
         int64       pageno;
         int         slotno;
         LWLock     *lock;
  
         memcpy(&pageno, XLogRecGetData(record), sizeof(pageno));
  
         lock = SimpleLruGetBankLock(MultiXactMemberCtl, pageno);
         LWLockAcquire(lock, LW_EXCLUSIVE);
  
         slotno = ZeroMultiXactMemberPage(pageno, false);
         SimpleLruWritePage(MultiXactMemberCtl, slotno);
         Assert(!MultiXactMemberCtl->shared->page_dirty[slotno]);
  
         LWLockRelease(lock);
     }
     else if (info == XLOG_MULTIXACT_CREATE_ID)
     {
         xl_multixact_create *xlrec =
             (xl_multixact_create *) XLogRecGetData(record);
         TransactionId max_xid;
         int         i;
  
         /* Store the data back into the SLRU files */
         RecordNewMultiXact(xlrec->mid, xlrec->moff, xlrec->nmembers,
                            xlrec->members);
  
         /* Make sure nextMXact/nextOffset are beyond what this record has */
         MultiXactAdvanceNextMXact(xlrec->mid + 1,
                                   xlrec->moff + xlrec->nmembers);
  
         /*
          * Make sure nextXid is beyond any XID mentioned in the record. This
          * should be unnecessary, since any XID found here ought to have other
          * evidence in the XLOG, but let's be safe.
          */
         max_xid = XLogRecGetXid(record);
         for (i = 0; i < xlrec->nmembers; i++)
         {
             if (TransactionIdPrecedes(max_xid, xlrec->members[i].xid))
                 max_xid = xlrec->members[i].xid;
         }
  
         AdvanceNextFullTransactionIdPastXid(max_xid);
     }
     else if (info == XLOG_MULTIXACT_TRUNCATE_ID)
     {
         xl_multixact_truncate xlrec;
         int64       pageno;
  
         memcpy(&xlrec, XLogRecGetData(record),
                SizeOfMultiXactTruncate);
  
         elog(DEBUG1, "replaying multixact truncation: "
              "offsets [%u, %u), offsets segments [%llx, %llx), "
              "members [%u, %u), members segments [%llx, %llx)",
              xlrec.startTruncOff, xlrec.endTruncOff,
              (unsigned long long) MultiXactIdToOffsetSegment(xlrec.startTruncOff),
              (unsigned long long) MultiXactIdToOffsetSegment(xlrec.endTruncOff),
              xlrec.startTruncMemb, xlrec.endTruncMemb,
              (unsigned long long) MXOffsetToMemberSegment(xlrec.startTruncMemb),
              (unsigned long long) MXOffsetToMemberSegment(xlrec.endTruncMemb));
  
         /* should not be required, but more than cheap enough */
         LWLockAcquire(MultiXactTruncationLock, LW_EXCLUSIVE);
  
         /*
          * Advance the horizon values, so they're current at the end of
          * recovery.
          */
         SetMultiXactIdLimit(xlrec.endTruncOff, xlrec.oldestMultiDB, false);
  
         PerformMembersTruncation(xlrec.startTruncMemb, xlrec.endTruncMemb);
  
         /*
          * During XLOG replay, latest_page_number isn't necessarily set up
          * yet; insert a suitable value to bypass the sanity test in
          * SimpleLruTruncate.
          */
         pageno = MultiXactIdToOffsetPage(xlrec.endTruncOff);
         pg_atomic_write_u64(&MultiXactOffsetCtl->shared->latest_page_number,
                             pageno);
         PerformOffsetsTruncation(xlrec.startTruncOff, xlrec.endTruncOff);
  
         LWLockRelease(MultiXactTruncationLock);
     }
     else
         elog(PANIC, "multixact_redo: unknown op code %u", info);
 }

References AdvanceNextFullTransactionIdPastXid(), Assert, DEBUG1, elog, xl_multixact_truncate::endTruncMemb, xl_multixact_truncate::endTruncOff, i, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), xl_multixact_create::members, xl_multixact_create::mid, xl_multixact_create::moff, MultiXactAdvanceNextMXact(), MultiXactIdToOffsetPage(), MultiXactIdToOffsetSegment(), MultiXactMemberCtl, MultiXactOffsetCtl, MXOffsetToMemberSegment(), xl_multixact_create::nmembers, xl_multixact_truncate::oldestMultiDB, PANIC, PerformMembersTruncation(), PerformOffsetsTruncation(), pg_atomic_write_u64(), RecordNewMultiXact(), SetMultiXactIdLimit(), SimpleLruGetBankLock(), SimpleLruWritePage(), SizeOfMultiXactTruncate, xl_multixact_truncate::startTruncMemb, xl_multixact_truncate::startTruncOff, TransactionIdPrecedes(), MultiXactMember::xid, XLOG_MULTIXACT_CREATE_ID, XLOG_MULTIXACT_TRUNCATE_ID, XLOG_MULTIXACT_ZERO_MEM_PAGE, XLOG_MULTIXACT_ZERO_OFF_PAGE, XLogRecGetData, XLogRecGetInfo, XLogRecGetXid, XLogRecHasAnyBlockRefs, XLR_INFO_MASK, ZeroMultiXactMemberPage(), and ZeroMultiXactOffsetPage().

◆ multixact_twophase_postabort()

void multixact_twophase_postabort	(	TransactionId	xid,
		uint16	info,
		void *	recdata,
		uint32	len
	)

Definition at line 1935 of file multixact.c.

 {
     multixact_twophase_postcommit(xid, info, recdata, len);
 }

References len, and multixact_twophase_postcommit().

◆ multixact_twophase_postcommit()

void multixact_twophase_postcommit	(	TransactionId	xid,
		uint16	info,
		void *	recdata,
		uint32	len
	)

Definition at line 1920 of file multixact.c.

 {
     ProcNumber  dummyProcNumber = TwoPhaseGetDummyProcNumber(xid, true);
  
     Assert(len == sizeof(MultiXactId));
  
     OldestMemberMXactId[dummyProcNumber] = InvalidMultiXactId;
 }

References Assert, InvalidMultiXactId, len, OldestMemberMXactId, and TwoPhaseGetDummyProcNumber().

Referenced by multixact_twophase_postabort().

◆ multixact_twophase_recover()

void multixact_twophase_recover	(	TransactionId	xid,
		uint16	info,
		void *	recdata,
		uint32	len
	)

Definition at line 1899 of file multixact.c.

 {
     ProcNumber  dummyProcNumber = TwoPhaseGetDummyProcNumber(xid, false);
     MultiXactId oldestMember;
  
     /*
      * Get the oldest member XID from the state file record, and set it in the
      * OldestMemberMXactId slot reserved for this prepared transaction.
      */
     Assert(len == sizeof(MultiXactId));
     oldestMember = *((MultiXactId *) recdata);
  
     OldestMemberMXactId[dummyProcNumber] = oldestMember;
 }

References Assert, len, OldestMemberMXactId, and TwoPhaseGetDummyProcNumber().

◆ MultiXactAdvanceNextMXact()

void MultiXactAdvanceNextMXact	(	MultiXactId	minMulti,
		MultiXactOffset	minMultiOffset
	)

Definition at line 2511 of file multixact.c.

 {
     LWLockAcquire(MultiXactGenLock, LW_EXCLUSIVE);
     if (MultiXactIdPrecedes(MultiXactState->nextMXact, minMulti))
     {
         debug_elog3(DEBUG2, "MultiXact: setting next multi to %u", minMulti);
         MultiXactState->nextMXact = minMulti;
     }
     if (MultiXactOffsetPrecedes(MultiXactState->nextOffset, minMultiOffset))
     {
         debug_elog3(DEBUG2, "MultiXact: setting next offset to %u",
                     minMultiOffset);
         MultiXactState->nextOffset = minMultiOffset;
     }
     LWLockRelease(MultiXactGenLock);
 }

References DEBUG2, debug_elog3, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MultiXactIdPrecedes(), MultiXactOffsetPrecedes(), MultiXactState, MultiXactStateData::nextMXact, and MultiXactStateData::nextOffset.

Referenced by multixact_redo(), and xlog_redo().

◆ MultiXactAdvanceOldest()

void MultiXactAdvanceOldest	(	MultiXactId	oldestMulti,
		Oid	oldestMultiDB
	)

Definition at line 2536 of file multixact.c.

 {
     Assert(InRecovery);
  
     if (MultiXactIdPrecedes(MultiXactState->oldestMultiXactId, oldestMulti))
         SetMultiXactIdLimit(oldestMulti, oldestMultiDB, false);
 }

References Assert, InRecovery, MultiXactIdPrecedes(), MultiXactState, MultiXactStateData::oldestMultiXactId, and SetMultiXactIdLimit().

Referenced by xlog_redo().

◆ MultiXactGetCheckptMulti()

void MultiXactGetCheckptMulti	(	bool	is_shutdown,
		MultiXactId *	nextMulti,
		MultiXactOffset *	nextMultiOffset,
		MultiXactId *	oldestMulti,
		Oid *	oldestMultiDB
	)

Definition at line 2282 of file multixact.c.

 {
     LWLockAcquire(MultiXactGenLock, LW_SHARED);
     *nextMulti = MultiXactState->nextMXact;
     *nextMultiOffset = MultiXactState->nextOffset;
     *oldestMulti = MultiXactState->oldestMultiXactId;
     *oldestMultiDB = MultiXactState->oldestMultiXactDB;
     LWLockRelease(MultiXactGenLock);
  
     debug_elog6(DEBUG2,
                 "MultiXact: checkpoint is nextMulti %u, nextOffset %u, oldestMulti %u in DB %u",
                 *nextMulti, *nextMultiOffset, *oldestMulti, *oldestMultiDB);
 }

References DEBUG2, debug_elog6, LW_SHARED, LWLockAcquire(), LWLockRelease(), MultiXactState, MultiXactStateData::nextMXact, MultiXactStateData::nextOffset, MultiXactStateData::oldestMultiXactDB, and MultiXactStateData::oldestMultiXactId.

Referenced by CreateCheckPoint().

◆ MultiXactIdCreate()

MultiXactId MultiXactIdCreate	(	TransactionId	xid1,
		MultiXactStatus	status1,
		TransactionId	xid2,
		MultiXactStatus	status2
	)

Definition at line 434 of file multixact.c.

 {
     MultiXactId newMulti;
     MultiXactMember members[2];
  
     Assert(TransactionIdIsValid(xid1));
     Assert(TransactionIdIsValid(xid2));
  
     Assert(!TransactionIdEquals(xid1, xid2) || (status1 != status2));
  
     /* MultiXactIdSetOldestMember() must have been called already. */
     Assert(MultiXactIdIsValid(OldestMemberMXactId[MyProcNumber]));
  
     /*
      * Note: unlike MultiXactIdExpand, we don't bother to check that both XIDs
      * are still running.  In typical usage, xid2 will be our own XID and the
      * caller just did a check on xid1, so it'd be wasted effort.
      */
  
     members[0].xid = xid1;
     members[0].status = status1;
     members[1].xid = xid2;
     members[1].status = status2;
  
     newMulti = MultiXactIdCreateFromMembers(2, members);
  
     debug_elog3(DEBUG2, "Create: %s",
                 mxid_to_string(newMulti, 2, members));
  
     return newMulti;
 }

References Assert, DEBUG2, debug_elog3, MultiXactIdCreateFromMembers(), MultiXactIdIsValid, mxid_to_string(), MyProcNumber, OldestMemberMXactId, MultiXactMember::status, TransactionIdEquals, TransactionIdIsValid, and MultiXactMember::xid.

Referenced by compute_new_xmax_infomask(), and test_create_multixact().

◆ MultiXactIdCreateFromMembers()

MultiXactId MultiXactIdCreateFromMembers	(	int	nmembers,
		MultiXactMember *	members
	)

Definition at line 815 of file multixact.c.

 {
     MultiXactId multi;
     MultiXactOffset offset;
     xl_multixact_create xlrec;
  
     debug_elog3(DEBUG2, "Create: %s",
                 mxid_to_string(InvalidMultiXactId, nmembers, members));
  
     /*
      * See if the same set of members already exists in our cache; if so, just
      * re-use that MultiXactId.  (Note: it might seem that looking in our
      * cache is insufficient, and we ought to search disk to see if a
      * duplicate definition already exists.  But since we only ever create
      * MultiXacts containing our own XID, in most cases any such MultiXacts
      * were in fact created by us, and so will be in our cache.  There are
      * corner cases where someone else added us to a MultiXact without our
      * knowledge, but it's not worth checking for.)
      */
     multi = mXactCacheGetBySet(nmembers, members);
     if (MultiXactIdIsValid(multi))
     {
         debug_elog2(DEBUG2, "Create: in cache!");
         return multi;
     }
  
     /* Verify that there is a single update Xid among the given members. */
     {
         int         i;
         bool        has_update = false;
  
         for (i = 0; i < nmembers; i++)
         {
             if (ISUPDATE_from_mxstatus(members[i].status))
             {
                 if (has_update)
                     elog(ERROR, "new multixact has more than one updating member: %s",
                          mxid_to_string(InvalidMultiXactId, nmembers, members));
                 has_update = true;
             }
         }
     }
  
     /* Load the injection point before entering the critical section */
     INJECTION_POINT_LOAD("multixact-create-from-members");
  
     /*
      * Assign the MXID and offsets range to use, and make sure there is space
      * in the OFFSETs and MEMBERs files.  NB: this routine does
      * START_CRIT_SECTION().
      *
      * Note: unlike MultiXactIdCreate and MultiXactIdExpand, we do not check
      * that we've called MultiXactIdSetOldestMember here.  This is because
      * this routine is used in some places to create new MultiXactIds of which
      * the current backend is not a member, notably during freezing of multis
      * in vacuum.  During vacuum, in particular, it would be unacceptable to
      * keep OldestMulti set, in case it runs for long.
      */
     multi = GetNewMultiXactId(nmembers, &offset);
  
     INJECTION_POINT_CACHED("multixact-create-from-members");
  
     /* Make an XLOG entry describing the new MXID. */
     xlrec.mid = multi;
     xlrec.moff = offset;
     xlrec.nmembers = nmembers;
  
     /*
      * XXX Note: there's a lot of padding space in MultiXactMember.  We could
      * find a more compact representation of this Xlog record -- perhaps all
      * the status flags in one XLogRecData, then all the xids in another one?
      * Not clear that it's worth the trouble though.
      */
     XLogBeginInsert();
     XLogRegisterData((char *) (&xlrec), SizeOfMultiXactCreate);
     XLogRegisterData((char *) members, nmembers * sizeof(MultiXactMember));
  
     (void) XLogInsert(RM_MULTIXACT_ID, XLOG_MULTIXACT_CREATE_ID);
  
     /* Now enter the information into the OFFSETs and MEMBERs logs */
     RecordNewMultiXact(multi, offset, nmembers, members);
  
     /* Done with critical section */
     END_CRIT_SECTION();
  
     /* Store the new MultiXactId in the local cache, too */
     mXactCachePut(multi, nmembers, members);
  
     debug_elog2(DEBUG2, "Create: all done");
  
     return multi;
 }

References DEBUG2, debug_elog2, debug_elog3, elog, END_CRIT_SECTION, ERROR, GetNewMultiXactId(), i, INJECTION_POINT_CACHED, INJECTION_POINT_LOAD, InvalidMultiXactId, ISUPDATE_from_mxstatus, xl_multixact_create::mid, xl_multixact_create::moff, MultiXactIdIsValid, mXactCacheGetBySet(), mXactCachePut(), mxid_to_string(), xl_multixact_create::nmembers, RecordNewMultiXact(), SizeOfMultiXactCreate, XLOG_MULTIXACT_CREATE_ID, XLogBeginInsert(), XLogInsert(), and XLogRegisterData().

Referenced by FreezeMultiXactId(), MultiXactIdCreate(), and MultiXactIdExpand().

◆ MultiXactIdExpand()

MultiXactId MultiXactIdExpand	(	MultiXactId	multi,
		TransactionId	xid,
		MultiXactStatus	status
	)

Definition at line 487 of file multixact.c.

 {
     MultiXactId newMulti;
     MultiXactMember *members;
     MultiXactMember *newMembers;
     int         nmembers;
     int         i;
     int         j;
  
     Assert(MultiXactIdIsValid(multi));
     Assert(TransactionIdIsValid(xid));
  
     /* MultiXactIdSetOldestMember() must have been called already. */
     Assert(MultiXactIdIsValid(OldestMemberMXactId[MyProcNumber]));
  
     debug_elog5(DEBUG2, "Expand: received multi %u, xid %u status %s",
                 multi, xid, mxstatus_to_string(status));
  
     /*
      * Note: we don't allow for old multis here.  The reason is that the only
      * caller of this function does a check that the multixact is no longer
      * running.
      */
     nmembers = GetMultiXactIdMembers(multi, &members, false, false);
  
     if (nmembers < 0)
     {
         MultiXactMember member;
  
         /*
          * The MultiXactId is obsolete.  This can only happen if all the
          * MultiXactId members stop running between the caller checking and
          * passing it to us.  It would be better to return that fact to the
          * caller, but it would complicate the API and it's unlikely to happen
          * too often, so just deal with it by creating a singleton MultiXact.
          */
         member.xid = xid;
         member.status = status;
         newMulti = MultiXactIdCreateFromMembers(1, &member);
  
         debug_elog4(DEBUG2, "Expand: %u has no members, create singleton %u",
                     multi, newMulti);
         return newMulti;
     }
  
     /*
      * If the TransactionId is already a member of the MultiXactId with the
      * same status, just return the existing MultiXactId.
      */
     for (i = 0; i < nmembers; i++)
     {
         if (TransactionIdEquals(members[i].xid, xid) &&
             (members[i].status == status))
         {
             debug_elog4(DEBUG2, "Expand: %u is already a member of %u",
                         xid, multi);
             pfree(members);
             return multi;
         }
     }
  
     /*
      * Determine which of the members of the MultiXactId are still of
      * interest. This is any running transaction, and also any transaction
      * that grabbed something stronger than just a lock and was committed. (An
      * update that aborted is of no interest here; and having more than one
      * update Xid in a multixact would cause errors elsewhere.)
      *
      * Removing dead members is not just an optimization: freezing of tuples
      * whose Xmax are multis depends on this behavior.
      *
      * Note we have the same race condition here as above: j could be 0 at the
      * end of the loop.
      */
     newMembers = (MultiXactMember *)
         palloc(sizeof(MultiXactMember) * (nmembers + 1));
  
     for (i = 0, j = 0; i < nmembers; i++)
     {
         if (TransactionIdIsInProgress(members[i].xid) ||
             (ISUPDATE_from_mxstatus(members[i].status) &&
              TransactionIdDidCommit(members[i].xid)))
         {
             newMembers[j].xid = members[i].xid;
             newMembers[j++].status = members[i].status;
         }
     }
  
     newMembers[j].xid = xid;
     newMembers[j++].status = status;
     newMulti = MultiXactIdCreateFromMembers(j, newMembers);
  
     pfree(members);
     pfree(newMembers);
  
     debug_elog3(DEBUG2, "Expand: returning new multi %u", newMulti);
  
     return newMulti;
 }

References Assert, DEBUG2, debug_elog3, debug_elog4, debug_elog5, GetMultiXactIdMembers(), i, ISUPDATE_from_mxstatus, j, MultiXactIdCreateFromMembers(), MultiXactIdIsValid, mxstatus_to_string(), MyProcNumber, OldestMemberMXactId, palloc(), pfree(), MultiXactMember::status, TransactionIdDidCommit(), TransactionIdEquals, TransactionIdIsInProgress(), TransactionIdIsValid, and MultiXactMember::xid.

Referenced by compute_new_xmax_infomask().

◆ MultiXactIdIsRunning()

bool MultiXactIdIsRunning	(	MultiXactId	multi,
		bool	isLockOnly
	)

Definition at line 599 of file multixact.c.

 {
     MultiXactMember *members;
     int         nmembers;
     int         i;
  
     debug_elog3(DEBUG2, "IsRunning %u?", multi);
  
     /*
      * "false" here means we assume our callers have checked that the given
      * multi cannot possibly come from a pg_upgraded database.
      */
     nmembers = GetMultiXactIdMembers(multi, &members, false, isLockOnly);
  
     if (nmembers <= 0)
     {
         debug_elog2(DEBUG2, "IsRunning: no members");
         return false;
     }
  
     /*
      * Checking for myself is cheap compared to looking in shared memory;
      * return true if any live subtransaction of the current top-level
      * transaction is a member.
      *
      * This is not needed for correctness, it's just a fast path.
      */
     for (i = 0; i < nmembers; i++)
     {
         if (TransactionIdIsCurrentTransactionId(members[i].xid))
         {
             debug_elog3(DEBUG2, "IsRunning: I (%d) am running!", i);
             pfree(members);
             return true;
         }
     }
  
     /*
      * This could be made faster by having another entry point in procarray.c,
      * walking the PGPROC array only once for all the members.  But in most
      * cases nmembers should be small enough that it doesn't much matter.
      */
     for (i = 0; i < nmembers; i++)
     {
         if (TransactionIdIsInProgress(members[i].xid))
         {
             debug_elog4(DEBUG2, "IsRunning: member %d (%u) is running",
                         i, members[i].xid);
             pfree(members);
             return true;
         }
     }
  
     pfree(members);
  
     debug_elog3(DEBUG2, "IsRunning: %u is not running", multi);
  
     return false;
 }

References DEBUG2, debug_elog2, debug_elog3, debug_elog4, GetMultiXactIdMembers(), i, pfree(), TransactionIdIsCurrentTransactionId(), and TransactionIdIsInProgress().

Referenced by compute_new_xmax_infomask(), FreezeMultiXactId(), HeapTupleSatisfiesUpdate(), and HeapTupleSatisfiesVacuumHorizon().

◆ MultiXactIdPrecedes()

bool MultiXactIdPrecedes	(	MultiXactId	multi1,
		MultiXactId	multi2
	)

Definition at line 3317 of file multixact.c.

 {
     int32       diff = (int32) (multi1 - multi2);
  
     return (diff < 0);
 }

Referenced by check_mxid_in_range(), copy_table_data(), do_start_worker(), FreezeMultiXactId(), GetMultiXactIdMembers(), GetNewMultiXactId(), GetOldestMultiXactId(), heap_prepare_freeze_tuple(), heap_tuple_should_freeze(), MultiXactAdvanceNextMXact(), MultiXactAdvanceOldest(), MultiXactIdSetOldestVisible(), MultiXactOffsetPagePrecedes(), relation_needs_vacanalyze(), SetMultiXactIdLimit(), TruncateMultiXact(), vac_truncate_clog(), vac_update_datfrozenxid(), vac_update_relstats(), vacuum_get_cutoffs(), and vacuum_xid_failsafe_check().

◆ MultiXactIdPrecedesOrEquals()

bool MultiXactIdPrecedesOrEquals	(	MultiXactId	multi1,
		MultiXactId	multi2
	)

Definition at line 3331 of file multixact.c.

 {
     int32       diff = (int32) (multi1 - multi2);
  
     return (diff <= 0);
 }

Referenced by check_mxid_in_range(), heap_tuple_should_freeze(), heap_vacuum_rel(), TruncateMultiXact(), and vacuum_get_cutoffs().

◆ MultiXactIdSetOldestMember()

void MultiXactIdSetOldestMember ( void )

Definition at line 673 of file multixact.c.

 {
     if (!MultiXactIdIsValid(OldestMemberMXactId[MyProcNumber]))
     {
         MultiXactId nextMXact;
  
         /*
          * You might think we don't need to acquire a lock here, since
          * fetching and storing of TransactionIds is probably atomic, but in
          * fact we do: suppose we pick up nextMXact and then lose the CPU for
          * a long time.  Someone else could advance nextMXact, and then
          * another someone else could compute an OldestVisibleMXactId that
          * would be after the value we are going to store when we get control
          * back.  Which would be wrong.
          *
          * Note that a shared lock is sufficient, because it's enough to stop
          * someone from advancing nextMXact; and nobody else could be trying
          * to write to our OldestMember entry, only reading (and we assume
          * storing it is atomic.)
          */
         LWLockAcquire(MultiXactGenLock, LW_SHARED);
  
         /*
          * We have to beware of the possibility that nextMXact is in the
          * wrapped-around state.  We don't fix the counter itself here, but we
          * must be sure to store a valid value in our array entry.
          */
         nextMXact = MultiXactState->nextMXact;
         if (nextMXact < FirstMultiXactId)
             nextMXact = FirstMultiXactId;
  
         OldestMemberMXactId[MyProcNumber] = nextMXact;
  
         LWLockRelease(MultiXactGenLock);
  
         debug_elog4(DEBUG2, "MultiXact: setting OldestMember[%d] = %u",
                     MyProcNumber, nextMXact);
     }
 }

References DEBUG2, debug_elog4, FirstMultiXactId, LW_SHARED, LWLockAcquire(), LWLockRelease(), MultiXactIdIsValid, MultiXactState, MyProcNumber, MultiXactStateData::nextMXact, and OldestMemberMXactId.

Referenced by heap_delete(), heap_lock_tuple(), heap_lock_updated_tuple(), heap_update(), and test_create_multixact().

◆ MultiXactMemberFreezeThreshold()

int MultiXactMemberFreezeThreshold ( void )

Definition at line 2978 of file multixact.c.

 {
     MultiXactOffset members;
     uint32      multixacts;
     uint32      victim_multixacts;
     double      fraction;
     int         result;
  
     /* If we can't determine member space utilization, assume the worst. */
     if (!ReadMultiXactCounts(&multixacts, &members))
         return 0;
  
     /* If member space utilization is low, no special action is required. */
     if (members <= MULTIXACT_MEMBER_SAFE_THRESHOLD)
         return autovacuum_multixact_freeze_max_age;
  
     /*
      * Compute a target for relminmxid advancement.  The number of multixacts
      * we try to eliminate from the system is based on how far we are past
      * MULTIXACT_MEMBER_SAFE_THRESHOLD.
      */
     fraction = (double) (members - MULTIXACT_MEMBER_SAFE_THRESHOLD) /
         (MULTIXACT_MEMBER_DANGER_THRESHOLD - MULTIXACT_MEMBER_SAFE_THRESHOLD);
     victim_multixacts = multixacts * fraction;
  
     /* fraction could be > 1.0, but lowest possible freeze age is zero */
     if (victim_multixacts > multixacts)
         return 0;
     result = multixacts - victim_multixacts;
  
     /*
      * Clamp to autovacuum_multixact_freeze_max_age, so that we never make
      * autovacuum less aggressive than it would otherwise be.
      */
     return Min(result, autovacuum_multixact_freeze_max_age);
 }

References autovacuum_multixact_freeze_max_age, Min, MULTIXACT_MEMBER_DANGER_THRESHOLD, MULTIXACT_MEMBER_SAFE_THRESHOLD, and ReadMultiXactCounts().

Referenced by do_autovacuum(), do_start_worker(), and vacuum_get_cutoffs().

◆ multixactmemberssyncfiletag()

int multixactmemberssyncfiletag	(	const FileTag *	ftag,
		char *	path
	)

Definition at line 3584 of file multixact.c.

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

References MultiXactMemberCtl, and SlruSyncFileTag().

◆ multixactoffsetssyncfiletag()

int multixactoffsetssyncfiletag	(	const FileTag *	ftag,
		char *	path
	)

Definition at line 3575 of file multixact.c.

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

References MultiXactOffsetCtl, and SlruSyncFileTag().

◆ MultiXactSetNextMXact()

void MultiXactSetNextMXact	(	MultiXactId	nextMulti,
		MultiXactOffset	nextMultiOffset
	)

Definition at line 2328 of file multixact.c.

 {
     debug_elog4(DEBUG2, "MultiXact: setting next multi to %u offset %u",
                 nextMulti, nextMultiOffset);
     LWLockAcquire(MultiXactGenLock, LW_EXCLUSIVE);
     MultiXactState->nextMXact = nextMulti;
     MultiXactState->nextOffset = nextMultiOffset;
     LWLockRelease(MultiXactGenLock);
  
     /*
      * During a binary upgrade, make sure that the offsets SLRU is large
      * enough to contain the next value that would be created.
      *
      * We need to do this pretty early during the first startup in binary
      * upgrade mode: before StartupMultiXact() in fact, because this routine
      * is called even before that by StartupXLOG().  And we can't do it
      * earlier than at this point, because during that first call of this
      * routine we determine the MultiXactState->nextMXact value that
      * MaybeExtendOffsetSlru needs.
      */
     if (IsBinaryUpgrade)
         MaybeExtendOffsetSlru();
 }

References DEBUG2, debug_elog4, IsBinaryUpgrade, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MaybeExtendOffsetSlru(), MultiXactState, MultiXactStateData::nextMXact, and MultiXactStateData::nextOffset.

Referenced by BootStrapXLOG(), StartupXLOG(), and xlog_redo().

◆ MultiXactShmemInit()

void MultiXactShmemInit ( void )

Definition at line 1964 of file multixact.c.

 {
     bool        found;
  
     debug_elog2(DEBUG2, "Shared Memory Init for MultiXact");
  
     MultiXactOffsetCtl->PagePrecedes = MultiXactOffsetPagePrecedes;
     MultiXactMemberCtl->PagePrecedes = MultiXactMemberPagePrecedes;
  
     SimpleLruInit(MultiXactOffsetCtl,
                   "multixact_offset", multixact_offset_buffers, 0,
                   "pg_multixact/offsets", LWTRANCHE_MULTIXACTOFFSET_BUFFER,
                   LWTRANCHE_MULTIXACTOFFSET_SLRU,
                   SYNC_HANDLER_MULTIXACT_OFFSET,
                   false);
     SlruPagePrecedesUnitTests(MultiXactOffsetCtl, MULTIXACT_OFFSETS_PER_PAGE);
     SimpleLruInit(MultiXactMemberCtl,
                   "multixact_member", multixact_member_buffers, 0,
                   "pg_multixact/members", LWTRANCHE_MULTIXACTMEMBER_BUFFER,
                   LWTRANCHE_MULTIXACTMEMBER_SLRU,
                   SYNC_HANDLER_MULTIXACT_MEMBER,
                   false);
     /* doesn't call SimpleLruTruncate() or meet criteria for unit tests */
  
     /* Initialize our shared state struct */
     MultiXactState = ShmemInitStruct("Shared MultiXact State",
                                      SHARED_MULTIXACT_STATE_SIZE,
                                      &found);
     if (!IsUnderPostmaster)
     {
         Assert(!found);
  
         /* Make sure we zero out the per-backend state */
         MemSet(MultiXactState, 0, SHARED_MULTIXACT_STATE_SIZE);
         ConditionVariableInit(&MultiXactState->nextoff_cv);
     }
     else
         Assert(found);
  
     /*
      * Set up array pointers.
      */
     OldestMemberMXactId = MultiXactState->perBackendXactIds;
     OldestVisibleMXactId = OldestMemberMXactId + MaxOldestSlot;
 }

References Assert, ConditionVariableInit(), DEBUG2, debug_elog2, IsUnderPostmaster, LWTRANCHE_MULTIXACTMEMBER_BUFFER, LWTRANCHE_MULTIXACTMEMBER_SLRU, LWTRANCHE_MULTIXACTOFFSET_BUFFER, LWTRANCHE_MULTIXACTOFFSET_SLRU, MaxOldestSlot, MemSet, multixact_member_buffers, multixact_offset_buffers, MULTIXACT_OFFSETS_PER_PAGE, MultiXactMemberCtl, MultiXactMemberPagePrecedes(), MultiXactOffsetCtl, MultiXactOffsetPagePrecedes(), MultiXactState, MultiXactStateData::nextoff_cv, OldestMemberMXactId, OldestVisibleMXactId, MultiXactStateData::perBackendXactIds, SHARED_MULTIXACT_STATE_SIZE, ShmemInitStruct(), SimpleLruInit(), SlruPagePrecedesUnitTests, SYNC_HANDLER_MULTIXACT_MEMBER, and SYNC_HANDLER_MULTIXACT_OFFSET.

Referenced by CreateOrAttachShmemStructs().

◆ MultiXactShmemSize()

Size MultiXactShmemSize ( void )

Definition at line 1947 of file multixact.c.

 {
     Size        size;
  
     /* We need 2*MaxOldestSlot perBackendXactIds[] entries */
 #define SHARED_MULTIXACT_STATE_SIZE \
     add_size(offsetof(MultiXactStateData, perBackendXactIds), \
              mul_size(sizeof(MultiXactId) * 2, MaxOldestSlot))
  
     size = SHARED_MULTIXACT_STATE_SIZE;
     size = add_size(size, SimpleLruShmemSize(multixact_offset_buffers, 0));
     size = add_size(size, SimpleLruShmemSize(multixact_member_buffers, 0));
  
     return size;
 }

References add_size(), multixact_member_buffers, multixact_offset_buffers, SHARED_MULTIXACT_STATE_SIZE, SimpleLruShmemSize(), and size.

Referenced by CalculateShmemSize().

◆ mxid_to_string()

char* mxid_to_string	(	MultiXactId	multi,
		int	nmembers,
		MultiXactMember *	members
	)

Definition at line 1777 of file multixact.c.

 {
     static char *str = NULL;
     StringInfoData buf;
     int         i;
  
     if (str != NULL)
         pfree(str);
  
     initStringInfo(&buf);
  
     appendStringInfo(&buf, "%u %d[%u (%s)", multi, nmembers, members[0].xid,
                      mxstatus_to_string(members[0].status));
  
     for (i = 1; i < nmembers; i++)
         appendStringInfo(&buf, ", %u (%s)", members[i].xid,
                          mxstatus_to_string(members[i].status));
  
     appendStringInfoChar(&buf, ']');
     str = MemoryContextStrdup(TopMemoryContext, buf.data);
     pfree(buf.data);
     return str;
 }

References appendStringInfo(), appendStringInfoChar(), buf, i, initStringInfo(), MemoryContextStrdup(), mxstatus_to_string(), pfree(), str, and TopMemoryContext.

Referenced by GetMultiXactIdMembers(), MultiXactIdCreate(), MultiXactIdCreateFromMembers(), mXactCacheGetById(), mXactCacheGetBySet(), and mXactCachePut().

◆ PostPrepare_MultiXact()

void PostPrepare_MultiXact ( TransactionId xid )

Definition at line 1850 of file multixact.c.

 {
     MultiXactId myOldestMember;
  
     /*
      * Transfer our OldestMemberMXactId value to the slot reserved for the
      * prepared transaction.
      */
     myOldestMember = OldestMemberMXactId[MyProcNumber];
     if (MultiXactIdIsValid(myOldestMember))
     {
         ProcNumber  dummyProcNumber = TwoPhaseGetDummyProcNumber(xid, false);
  
         /*
          * Even though storing MultiXactId is atomic, acquire lock to make
          * sure others see both changes, not just the reset of the slot of the
          * current backend. Using a volatile pointer might suffice, but this
          * isn't a hot spot.
          */
         LWLockAcquire(MultiXactGenLock, LW_EXCLUSIVE);
  
         OldestMemberMXactId[dummyProcNumber] = myOldestMember;
         OldestMemberMXactId[MyProcNumber] = InvalidMultiXactId;
  
         LWLockRelease(MultiXactGenLock);
     }
  
     /*
      * We don't need to transfer OldestVisibleMXactId value, because the
      * transaction is not going to be looking at any more multixacts once it's
      * prepared.
      *
      * We assume that storing a MultiXactId is atomic and so we need not take
      * MultiXactGenLock to do this.
      */
     OldestVisibleMXactId[MyProcNumber] = InvalidMultiXactId;
  
     /*
      * Discard the local MultiXactId cache like in AtEOXact_MultiXact.
      */
     MXactContext = NULL;
     dclist_init(&MXactCache);
 }

References dclist_init(), InvalidMultiXactId, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MultiXactIdIsValid, MXactCache, MXactContext, MyProcNumber, OldestMemberMXactId, OldestVisibleMXactId, and TwoPhaseGetDummyProcNumber().

Referenced by PrepareTransaction().

◆ ReadMultiXactIdRange()

void ReadMultiXactIdRange	(	MultiXactId *	oldest,
		MultiXactId *	next
	)

Definition at line 791 of file multixact.c.

 {
     LWLockAcquire(MultiXactGenLock, LW_SHARED);
     *oldest = MultiXactState->oldestMultiXactId;
     *next = MultiXactState->nextMXact;
     LWLockRelease(MultiXactGenLock);
  
     if (*oldest < FirstMultiXactId)
         *oldest = FirstMultiXactId;
     if (*next < FirstMultiXactId)
         *next = FirstMultiXactId;
 }

References FirstMultiXactId, LW_SHARED, LWLockAcquire(), LWLockRelease(), MultiXactState, next, MultiXactStateData::nextMXact, and MultiXactStateData::oldestMultiXactId.

Referenced by update_cached_mxid_range().

◆ ReadNextMultiXactId()

MultiXactId ReadNextMultiXactId ( void )

Definition at line 771 of file multixact.c.

 {
     MultiXactId mxid;
  
     /* XXX we could presumably do this without a lock. */
     LWLockAcquire(MultiXactGenLock, LW_SHARED);
     mxid = MultiXactState->nextMXact;
     LWLockRelease(MultiXactGenLock);
  
     if (mxid < FirstMultiXactId)
         mxid = FirstMultiXactId;
  
     return mxid;
 }

References FirstMultiXactId, LW_SHARED, LWLockAcquire(), LWLockRelease(), MultiXactState, and MultiXactStateData::nextMXact.

Referenced by ATRewriteTables(), AutoVacWorkerMain(), do_start_worker(), mxid_age(), refresh_by_heap_swap(), vac_update_datfrozenxid(), vac_update_relstats(), vacuum_get_cutoffs(), and vacuum_xid_failsafe_check().

◆ SetMultiXactIdLimit()

void SetMultiXactIdLimit	(	MultiXactId	oldest_datminmxid,
		Oid	oldest_datoid,
		bool	is_startup
	)

Definition at line 2362 of file multixact.c.

 {
     MultiXactId multiVacLimit;
     MultiXactId multiWarnLimit;
     MultiXactId multiStopLimit;
     MultiXactId multiWrapLimit;
     MultiXactId curMulti;
     bool        needs_offset_vacuum;
  
     Assert(MultiXactIdIsValid(oldest_datminmxid));
  
     /*
      * We pretend that a wrap will happen halfway through the multixact ID
      * space, but that's not really true, because multixacts wrap differently
      * from transaction IDs.  Note that, separately from any concern about
      * multixact IDs wrapping, we must ensure that multixact members do not
      * wrap.  Limits for that are set in SetOffsetVacuumLimit, not here.
      */
     multiWrapLimit = oldest_datminmxid + (MaxMultiXactId >> 1);
     if (multiWrapLimit < FirstMultiXactId)
         multiWrapLimit += FirstMultiXactId;
  
     /*
      * We'll refuse to continue assigning MultiXactIds once we get within 3M
      * multi of data loss.  See SetTransactionIdLimit.
      */
     multiStopLimit = multiWrapLimit - 3000000;
     if (multiStopLimit < FirstMultiXactId)
         multiStopLimit -= FirstMultiXactId;
  
     /*
      * We'll start complaining loudly when we get within 40M multis of data
      * loss.  This is kind of arbitrary, but if you let your gas gauge get
      * down to 2% of full, would you be looking for the next gas station?  We
      * need to be fairly liberal about this number because there are lots of
      * scenarios where most transactions are done by automatic clients that
      * won't pay attention to warnings.  (No, we're not gonna make this
      * configurable.  If you know enough to configure it, you know enough to
      * not get in this kind of trouble in the first place.)
      */
     multiWarnLimit = multiWrapLimit - 40000000;
     if (multiWarnLimit < FirstMultiXactId)
         multiWarnLimit -= FirstMultiXactId;
  
     /*
      * We'll start trying to force autovacuums when oldest_datminmxid gets to
      * be more than autovacuum_multixact_freeze_max_age mxids old.
      *
      * Note: autovacuum_multixact_freeze_max_age is a PGC_POSTMASTER parameter
      * so that we don't have to worry about dealing with on-the-fly changes in
      * its value.  See SetTransactionIdLimit.
      */
     multiVacLimit = oldest_datminmxid + autovacuum_multixact_freeze_max_age;
     if (multiVacLimit < FirstMultiXactId)
         multiVacLimit += FirstMultiXactId;
  
     /* Grab lock for just long enough to set the new limit values */
     LWLockAcquire(MultiXactGenLock, LW_EXCLUSIVE);
     MultiXactState->oldestMultiXactId = oldest_datminmxid;
     MultiXactState->oldestMultiXactDB = oldest_datoid;
     MultiXactState->multiVacLimit = multiVacLimit;
     MultiXactState->multiWarnLimit = multiWarnLimit;
     MultiXactState->multiStopLimit = multiStopLimit;
     MultiXactState->multiWrapLimit = multiWrapLimit;
     curMulti = MultiXactState->nextMXact;
     LWLockRelease(MultiXactGenLock);
  
     /* Log the info */
     ereport(DEBUG1,
             (errmsg_internal("MultiXactId wrap limit is %u, limited by database with OID %u",
                              multiWrapLimit, oldest_datoid)));
  
     /*
      * Computing the actual limits is only possible once the data directory is
      * in a consistent state. There's no need to compute the limits while
      * still replaying WAL - no decisions about new multis are made even
      * though multixact creations might be replayed. So we'll only do further
      * checks after TrimMultiXact() has been called.
      */
     if (!MultiXactState->finishedStartup)
         return;
  
     Assert(!InRecovery);
  
     /* Set limits for offset vacuum. */
     needs_offset_vacuum = SetOffsetVacuumLimit(is_startup);
  
     /*
      * If past the autovacuum force point, immediately signal an autovac
      * request.  The reason for this is that autovac only processes one
      * database per invocation.  Once it's finished cleaning up the oldest
      * database, it'll call here, and we'll signal the postmaster to start
      * another iteration immediately if there are still any old databases.
      */
     if ((MultiXactIdPrecedes(multiVacLimit, curMulti) ||
          needs_offset_vacuum) && IsUnderPostmaster)
         SendPostmasterSignal(PMSIGNAL_START_AUTOVAC_LAUNCHER);
  
     /* Give an immediate warning if past the wrap warn point */
     if (MultiXactIdPrecedes(multiWarnLimit, curMulti))
     {
         char       *oldest_datname;
  
         /*
          * We can be called when not inside a transaction, for example during
          * StartupXLOG().  In such a case we cannot do database access, so we
          * must just report the oldest DB's OID.
          *
          * Note: it's also possible that get_database_name fails and returns
          * NULL, for example because the database just got dropped.  We'll
          * still warn, even though the warning might now be unnecessary.
          */
         if (IsTransactionState())
             oldest_datname = get_database_name(oldest_datoid);
         else
             oldest_datname = NULL;
  
         if (oldest_datname)
             ereport(WARNING,
                     (errmsg_plural("database \"%s\" must be vacuumed before %u more MultiXactId is used",
                                    "database \"%s\" must be vacuumed before %u more MultiXactIds are used",
                                    multiWrapLimit - curMulti,
                                    oldest_datname,
                                    multiWrapLimit - curMulti),
                      errhint("To avoid MultiXactId assignment failures, execute a database-wide VACUUM in that database.\n"
                              "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
         else
             ereport(WARNING,
                     (errmsg_plural("database with OID %u must be vacuumed before %u more MultiXactId is used",
                                    "database with OID %u must be vacuumed before %u more MultiXactIds are used",
                                    multiWrapLimit - curMulti,
                                    oldest_datoid,
                                    multiWrapLimit - curMulti),
                      errhint("To avoid MultiXactId assignment failures, execute a database-wide VACUUM in that database.\n"
                              "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
     }
 }

Referenced by BootStrapXLOG(), multixact_redo(), MultiXactAdvanceOldest(), StartupXLOG(), TrimMultiXact(), and vac_truncate_clog().

◆ StartupMultiXact()

void StartupMultiXact ( void )

Definition at line 2153 of file multixact.c.

 {
     MultiXactId multi = MultiXactState->nextMXact;
     MultiXactOffset offset = MultiXactState->nextOffset;
     int64       pageno;
  
     /*
      * Initialize offset's idea of the latest page number.
      */
     pageno = MultiXactIdToOffsetPage(multi);
     pg_atomic_write_u64(&MultiXactOffsetCtl->shared->latest_page_number,
                         pageno);
  
     /*
      * Initialize member's idea of the latest page number.
      */
     pageno = MXOffsetToMemberPage(offset);
     pg_atomic_write_u64(&MultiXactMemberCtl->shared->latest_page_number,
                         pageno);
 }

References MultiXactIdToOffsetPage(), MultiXactMemberCtl, MultiXactOffsetCtl, MultiXactState, MXOffsetToMemberPage(), MultiXactStateData::nextMXact, MultiXactStateData::nextOffset, and pg_atomic_write_u64().

Referenced by StartupXLOG().

◆ TrimMultiXact()

void TrimMultiXact ( void )

Definition at line 2178 of file multixact.c.

 {
     MultiXactId nextMXact;
     MultiXactOffset offset;
     MultiXactId oldestMXact;
     Oid         oldestMXactDB;
     int64       pageno;
     int         entryno;
     int         flagsoff;
  
     LWLockAcquire(MultiXactGenLock, LW_SHARED);
     nextMXact = MultiXactState->nextMXact;
     offset = MultiXactState->nextOffset;
     oldestMXact = MultiXactState->oldestMultiXactId;
     oldestMXactDB = MultiXactState->oldestMultiXactDB;
     LWLockRelease(MultiXactGenLock);
  
     /* Clean up offsets state */
  
     /*
      * (Re-)Initialize our idea of the latest page number for offsets.
      */
     pageno = MultiXactIdToOffsetPage(nextMXact);
     pg_atomic_write_u64(&MultiXactOffsetCtl->shared->latest_page_number,
                         pageno);
  
     /*
      * Zero out the remainder of the current offsets page.  See notes in
      * TrimCLOG() for background.  Unlike CLOG, some WAL record covers every
      * pg_multixact SLRU mutation.  Since, also unlike CLOG, we ignore the WAL
      * rule "write xlog before data," nextMXact successors may carry obsolete,
      * nonzero offset values.  Zero those so case 2 of GetMultiXactIdMembers()
      * operates normally.
      */
     entryno = MultiXactIdToOffsetEntry(nextMXact);
     if (entryno != 0)
     {
         int         slotno;
         MultiXactOffset *offptr;
         LWLock     *lock = SimpleLruGetBankLock(MultiXactOffsetCtl, pageno);
  
         LWLockAcquire(lock, LW_EXCLUSIVE);
         slotno = SimpleLruReadPage(MultiXactOffsetCtl, pageno, true, nextMXact);
         offptr = (MultiXactOffset *) MultiXactOffsetCtl->shared->page_buffer[slotno];
         offptr += entryno;
  
         MemSet(offptr, 0, BLCKSZ - (entryno * sizeof(MultiXactOffset)));
  
         MultiXactOffsetCtl->shared->page_dirty[slotno] = true;
         LWLockRelease(lock);
     }
  
     /*
      * And the same for members.
      *
      * (Re-)Initialize our idea of the latest page number for members.
      */
     pageno = MXOffsetToMemberPage(offset);
     pg_atomic_write_u64(&MultiXactMemberCtl->shared->latest_page_number,
                         pageno);
  
     /*
      * Zero out the remainder of the current members page.  See notes in
      * TrimCLOG() for motivation.
      */
     flagsoff = MXOffsetToFlagsOffset(offset);
     if (flagsoff != 0)
     {
         int         slotno;
         TransactionId *xidptr;
         int         memberoff;
         LWLock     *lock = SimpleLruGetBankLock(MultiXactMemberCtl, pageno);
  
         LWLockAcquire(lock, LW_EXCLUSIVE);
         memberoff = MXOffsetToMemberOffset(offset);
         slotno = SimpleLruReadPage(MultiXactMemberCtl, pageno, true, offset);
         xidptr = (TransactionId *)
             (MultiXactMemberCtl->shared->page_buffer[slotno] + memberoff);
  
         MemSet(xidptr, 0, BLCKSZ - memberoff);
  
         /*
          * Note: we don't need to zero out the flag bits in the remaining
          * members of the current group, because they are always reset before
          * writing.
          */
  
         MultiXactMemberCtl->shared->page_dirty[slotno] = true;
         LWLockRelease(lock);
     }
  
     /* signal that we're officially up */
     LWLockAcquire(MultiXactGenLock, LW_EXCLUSIVE);
     MultiXactState->finishedStartup = true;
     LWLockRelease(MultiXactGenLock);
  
     /* Now compute how far away the next members wraparound is. */
     SetMultiXactIdLimit(oldestMXact, oldestMXactDB, true);
 }

References MultiXactStateData::finishedStartup, LW_EXCLUSIVE, LW_SHARED, LWLockAcquire(), LWLockRelease(), MemSet, MultiXactIdToOffsetEntry(), MultiXactIdToOffsetPage(), MultiXactMemberCtl, MultiXactOffsetCtl, MultiXactState, MXOffsetToFlagsOffset(), MXOffsetToMemberOffset(), MXOffsetToMemberPage(), MultiXactStateData::nextMXact, MultiXactStateData::nextOffset, MultiXactStateData::oldestMultiXactDB, MultiXactStateData::oldestMultiXactId, pg_atomic_write_u64(), SetMultiXactIdLimit(), SimpleLruGetBankLock(), and SimpleLruReadPage().