#include "access/transam.h"
#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:

Go to the source code of 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	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)

void	GetMultiXactInfo (uint32 multixacts, MultiXactOffset nextOffset, MultiXactId oldestMultiXactId, MultiXactOffset oldestOffset)

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 (FullTransactionId fxid)

Size	MultiXactShmemSize (void)

void	MultiXactShmemInit (void)

void	BootStrapMultiXact (void)

void	StartupMultiXact (void)

void	TrimMultiXact (void)

void	SetMultiXactIdLimit (MultiXactId oldest_datminmxid, Oid oldest_datoid)

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 (FullTransactionId fxid, uint16 info, void *recdata, uint32 len)

void	multixact_twophase_postcommit (FullTransactionId fxid, uint16 info, void *recdata, uint32 len)

void	multixact_twophase_postabort (FullTransactionId fxid, 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)

char *	mxstatus_to_string (MultiXactStatus status)

Macro Definition Documentation

◆ FirstMultiXactId

#define FirstMultiXactId ((MultiXactId) 1)

Definition at line 26 of file multixact.h.

◆ InvalidMultiXactId

#define InvalidMultiXactId ((MultiXactId) 0)

Definition at line 25 of file multixact.h.

◆ ISUPDATE_from_mxstatus

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

Definition at line 51 of file multixact.h.

{
    TransactionId xid;
    MultiXactStatus status;
} MultiXactMember;
 
 
/* ----------------
 *      multixact-related XLOG entries
 * ----------------
 */
 
#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
 
typedef struct xl_multixact_create
{
    MultiXactId mid;            /* new MultiXact's ID */
    MultiXactOffset moff;       /* its starting offset in members file */
    int32       nmembers;       /* number of member XIDs */
    MultiXactMember members[FLEXIBLE_ARRAY_MEMBER];
} xl_multixact_create;
 
#define SizeOfMultiXactCreate (offsetof(xl_multixact_create, members))
 
typedef struct xl_multixact_truncate
{
    Oid         oldestMultiDB;
 
    /* truncate multixact offsets older than this */
    MultiXactId oldestMulti;
 
    /* truncate multixact members older than this */
    MultiXactOffset oldestOffset;
} xl_multixact_truncate;
 
#define SizeOfMultiXactTruncate (sizeof(xl_multixact_truncate))
 
 
extern MultiXactId MultiXactIdCreate(TransactionId xid1,
                                     MultiXactStatus status1, TransactionId xid2,
                                     MultiXactStatus status2);
extern MultiXactId MultiXactIdExpand(MultiXactId multi, TransactionId xid,
                                     MultiXactStatus status);
extern MultiXactId MultiXactIdCreateFromMembers(int nmembers,
                                                MultiXactMember *members);
 
extern MultiXactId ReadNextMultiXactId(void);
extern void ReadMultiXactIdRange(MultiXactId *oldest, MultiXactId *next);
extern bool MultiXactIdIsRunning(MultiXactId multi, bool isLockOnly);
extern void MultiXactIdSetOldestMember(void);
extern int  GetMultiXactIdMembers(MultiXactId multi, MultiXactMember **members,
                                  bool from_pgupgrade, bool isLockOnly);
extern void GetMultiXactInfo(uint32 *multixacts, MultiXactOffset *nextOffset,
                             MultiXactId *oldestMultiXactId,
                             MultiXactOffset *oldestOffset);
extern bool MultiXactIdPrecedes(MultiXactId multi1, MultiXactId multi2);
extern bool MultiXactIdPrecedesOrEquals(MultiXactId multi1,
                                        MultiXactId multi2);
 
extern int  multixactoffsetssyncfiletag(const FileTag *ftag, char *path);
extern int  multixactmemberssyncfiletag(const FileTag *ftag, char *path);
 
extern void AtEOXact_MultiXact(void);
extern void AtPrepare_MultiXact(void);
extern void PostPrepare_MultiXact(FullTransactionId fxid);
 
extern Size MultiXactShmemSize(void);
extern void MultiXactShmemInit(void);
extern void BootStrapMultiXact(void);
extern void StartupMultiXact(void);
extern void TrimMultiXact(void);
extern void SetMultiXactIdLimit(MultiXactId oldest_datminmxid,
                                Oid oldest_datoid);
extern void MultiXactGetCheckptMulti(bool is_shutdown,
                                     MultiXactId *nextMulti,
                                     MultiXactOffset *nextMultiOffset,
                                     MultiXactId *oldestMulti,
                                     Oid *oldestMultiDB);
extern void CheckPointMultiXact(void);
extern MultiXactId GetOldestMultiXactId(void);
extern void TruncateMultiXact(MultiXactId newOldestMulti,
                              Oid newOldestMultiDB);
extern void MultiXactSetNextMXact(MultiXactId nextMulti,
                                  MultiXactOffset nextMultiOffset);
extern void MultiXactAdvanceNextMXact(MultiXactId minMulti,
                                      MultiXactOffset minMultiOffset);
extern void MultiXactAdvanceOldest(MultiXactId oldestMulti, Oid oldestMultiDB);
extern int  MultiXactMemberFreezeThreshold(void);
 
extern void multixact_twophase_recover(FullTransactionId fxid, uint16 info,
                                       void *recdata, uint32 len);
extern void multixact_twophase_postcommit(FullTransactionId fxid, uint16 info,
                                          void *recdata, uint32 len);
extern void multixact_twophase_postabort(FullTransactionId fxid, uint16 info,
                                         void *recdata, uint32 len);
 
extern void multixact_redo(XLogReaderState *record);
extern void multixact_desc(StringInfo buf, XLogReaderState *record);
extern const char *multixact_identify(uint8 info);
extern char *mxid_to_string(MultiXactId multi, int nmembers,
                            MultiXactMember *members);
extern char *mxstatus_to_string(MultiXactStatus status);
 
#endif                          /* MULTIXACT_H */

◆ MaxMultiXactId

#define MaxMultiXactId ((MultiXactId) 0xFFFFFFFF)

Definition at line 27 of file multixact.h.

◆ MaxMultiXactStatus

#define MaxMultiXactStatus MultiXactStatusUpdate

Definition at line 48 of file multixact.h.

◆ MultiXactIdIsValid

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

Definition at line 29 of file multixact.h.

◆ SizeOfMultiXactCreate

#define SizeOfMultiXactCreate (offsetof(xl_multixact_create, members))

Definition at line 80 of file multixact.h.

◆ SizeOfMultiXactTruncate

#define SizeOfMultiXactTruncate (sizeof(xl_multixact_truncate))

Definition at line 93 of file multixact.h.

◆ XLOG_MULTIXACT_CREATE_ID

#define XLOG_MULTIXACT_CREATE_ID 0x20

Definition at line 69 of file multixact.h.

◆ XLOG_MULTIXACT_TRUNCATE_ID

#define XLOG_MULTIXACT_TRUNCATE_ID 0x30

Definition at line 70 of file multixact.h.

◆ XLOG_MULTIXACT_ZERO_MEM_PAGE

#define XLOG_MULTIXACT_ZERO_MEM_PAGE 0x10

Definition at line 68 of file multixact.h.

◆ XLOG_MULTIXACT_ZERO_OFF_PAGE

#define XLOG_MULTIXACT_ZERO_OFF_PAGE 0x00

Definition at line 67 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 36 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 )

extern

Definition at line 1568 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(), fb(), InvalidMultiXactId, MXactCache, MXactContext, MyProcNumber, OldestMemberMXactId, and OldestVisibleMXactId.

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

◆ AtPrepare_MultiXact()

void AtPrepare_MultiXact ( void )

extern

Definition at line 1596 of file multixact.c.

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

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

Referenced by PrepareTransaction().

◆ BootStrapMultiXact()

void BootStrapMultiXact ( void )

extern

Definition at line 1793 of file multixact.c.

{
    /* Zero the initial pages and flush them to disk */
    SimpleLruZeroAndWritePage(MultiXactOffsetCtl, 0);
    SimpleLruZeroAndWritePage(MultiXactMemberCtl, 0);
}

References MultiXactMemberCtl, MultiXactOffsetCtl, and SimpleLruZeroAndWritePage().

Referenced by BootStrapXLOG().

◆ CheckPointMultiXact()

void CheckPointMultiXact ( void )

extern

Definition at line 1968 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 fb(), MultiXactMemberCtl, MultiXactOffsetCtl, and SimpleLruWriteAll().

Referenced by CheckPointGuts().

◆ GetMultiXactIdMembers()

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

extern

Definition at line 1113 of file multixact.c.

{
    int64       pageno;
    int64       prev_pageno;
    int         entryno;
    int         slotno;
    MultiXactOffset *offptr;
    MultiXactOffset offset;
    MultiXactOffset nextMXOffset;
    int         length;
    MultiXactId oldestMXact;
    MultiXactId nextMXact;
    MultiXactMember *ptr;
    LWLock     *lock;
 
    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.
     */
    LWLockAcquire(MultiXactGenLock, LW_SHARED);
 
    oldestMXact = MultiXactState->oldestMultiXactId;
    nextMXact = MultiXactState->nextMXact;
 
    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.
     */
    pageno = MultiXactIdToOffsetPage(multi);
    entryno = MultiXactIdToOffsetEntry(multi);
 
    /* Acquire the bank lock for the page we need. */
    lock = SimpleLruGetBankLock(MultiXactOffsetCtl, pageno);
    LWLockAcquire(lock, LW_EXCLUSIVE);
 
    /* read this multi's offset */
    slotno = SimpleLruReadPage(MultiXactOffsetCtl, pageno, true, multi);
    offptr = (MultiXactOffset *) MultiXactOffsetCtl->shared->page_buffer[slotno];
    offptr += entryno;
    offset = *offptr;
 
    if (offset == 0)
        ereport(ERROR,
                (errcode(ERRCODE_DATA_CORRUPTED),
                 errmsg("MultiXact %u has invalid offset", multi)));
 
    /* read next multi's offset */
    {
        MultiXactId tmpMXact;
 
        /* handle wraparound if needed */
        tmpMXact = NextMultiXactId(multi);
 
        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;
    }
 
    LWLockRelease(lock);
    lock = NULL;
 
    /* Sanity check the next offset */
    if (nextMXOffset == 0)
        ereport(ERROR,
                (errcode(ERRCODE_DATA_CORRUPTED),
                 errmsg("MultiXact %u has invalid next offset", multi)));
    if (nextMXOffset == offset)
        ereport(ERROR,
                (errcode(ERRCODE_DATA_CORRUPTED),
                 errmsg("MultiXact %u with offset (%" PRIu64 ") has zero members",
                        multi, offset)));
    if (nextMXOffset < offset)
        ereport(ERROR,
                (errcode(ERRCODE_DATA_CORRUPTED),
                 errmsg("MultiXact %u has offset (%" PRIu64 ") greater than its next offset (%" PRIu64 ")",
                        multi, offset, nextMXOffset)));
    if (nextMXOffset - offset > INT32_MAX)
        ereport(ERROR,
                (errcode(ERRCODE_DATA_CORRUPTED),
                 errmsg("MultiXact %u has too many members (%" PRIu64 ")",
                        multi, nextMXOffset - offset)));
    length = nextMXOffset - offset;
 
    /* read the members */
    ptr = (MultiXactMember *) palloc(length * sizeof(MultiXactMember));
    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);
        Assert(TransactionIdIsValid(*xactptr));
 
        flagsoff = MXOffsetToFlagsOffset(offset);
        bshift = MXOffsetToFlagsBitShift(offset);
        flagsptr = (uint32 *) (MultiXactMemberCtl->shared->page_buffer[slotno] + flagsoff);
 
        ptr[i].xid = *xactptr;
        ptr[i].status = (*flagsptr >> bshift) & MXACT_MEMBER_XACT_BITMASK;
    }
 
    LWLockRelease(lock);
 
    /*
     * Copy the result into the local cache.
     */
    mXactCachePut(multi, length, ptr);
 
    debug_elog3(DEBUG2, "GetMembers: no cache for %s",
                mxid_to_string(multi, length, ptr));
    *members = ptr;
    return length;
}

References Assert, DEBUG2, debug_elog2, debug_elog3, ereport, errcode(), ERRCODE_DATA_CORRUPTED, errmsg(), ERROR, fb(), i, 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, NextMultiXactId(), MultiXactStateData::nextMXact, 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().

◆ GetMultiXactInfo()

void GetMultiXactInfo	(	uint32 *	multixacts,
		MultiXactOffset *	nextOffset,
		MultiXactId *	oldestMultiXactId,
		MultiXactOffset *	oldestOffset
	)

extern

Definition at line 2467 of file multixact.c.

{
    MultiXactId nextMultiXactId;
 
    LWLockAcquire(MultiXactGenLock, LW_SHARED);
    *nextOffset = MultiXactState->nextOffset;
    *oldestMultiXactId = MultiXactState->oldestMultiXactId;
    nextMultiXactId = MultiXactState->nextMXact;
    *oldestOffset = MultiXactState->oldestOffset;
    LWLockRelease(MultiXactGenLock);
 
    *multixacts = nextMultiXactId - *oldestMultiXactId;
}

References fb(), LW_SHARED, LWLockAcquire(), LWLockRelease(), MultiXactState, MultiXactStateData::nextMXact, MultiXactStateData::nextOffset, MultiXactStateData::oldestMultiXactId, and MultiXactStateData::oldestOffset.

Referenced by MultiXactMemberFreezeThreshold(), and pg_get_multixact_stats().

◆ GetOldestMultiXactId()

MultiXactId GetOldestMultiXactId ( void )

extern

Definition at line 2303 of file multixact.c.

{
    MultiXactId oldestMXact;
    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);
    oldestMXact = MultiXactState->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 fb(), 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
	)

extern

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, "%" PRId64, pageno);
    }
    else if (info == XLOG_MULTIXACT_CREATE_ID)
    {
        xl_multixact_create *xlrec = (xl_multixact_create *) rec;
        int         i;
 
        appendStringInfo(buf, "%u offset %" PRIu64 " 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, "oldestMulti %u, oldestOffset %" PRIu64,
                         xlrec->oldestMulti, xlrec->oldestOffset);
    }
}

References appendStringInfo(), buf, fb(), i, out_member(), XLOG_MULTIXACT_CREATE_ID, XLOG_MULTIXACT_TRUNCATE_ID, XLOG_MULTIXACT_ZERO_MEM_PAGE, XLOG_MULTIXACT_ZERO_OFF_PAGE, XLogRecGetData, and XLogRecGetInfo.

◆ multixact_identify()

const char * multixact_identify ( uint8 info )

extern

Definition at line 83 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 fb(), 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 )

extern

Definition at line 2815 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;
 
        memcpy(&pageno, XLogRecGetData(record), sizeof(pageno));
        SimpleLruZeroAndWritePage(MultiXactOffsetCtl, pageno);
    }
    else if (info == XLOG_MULTIXACT_ZERO_MEM_PAGE)
    {
        int64       pageno;
 
        memcpy(&pageno, XLogRecGetData(record), sizeof(pageno));
        SimpleLruZeroAndWritePage(MultiXactMemberCtl, pageno);
    }
    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(NextMultiXactId(xlrec->mid),
                                  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: "
             "oldestMulti %u (offsets segment %" PRIx64 "), "
             "oldestOffset %" PRIu64 " (members segment %" PRIx64 ")",
             xlrec.oldestMulti,
             MultiXactIdToOffsetSegment(xlrec.oldestMulti),
             xlrec.oldestOffset,
             MXOffsetToMemberSegment(xlrec.oldestOffset));
 
        /* 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.oldestMulti, xlrec.oldestMultiDB);
 
        PerformMembersTruncation(xlrec.oldestOffset);
 
        /*
         * 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.oldestMulti);
        pg_atomic_write_u64(&MultiXactOffsetCtl->shared->latest_page_number,
                            pageno);
        PerformOffsetsTruncation(xlrec.oldestMulti);
 
        LWLockRelease(MultiXactTruncationLock);
    }
    else
        elog(PANIC, "multixact_redo: unknown op code %u", info);
}

References AdvanceNextFullTransactionIdPastXid(), Assert, DEBUG1, elog, fb(), i, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MultiXactAdvanceNextMXact(), MultiXactIdToOffsetPage(), MultiXactIdToOffsetSegment(), MultiXactMemberCtl, MultiXactOffsetCtl, MXOffsetToMemberSegment(), NextMultiXactId(), PANIC, PerformMembersTruncation(), PerformOffsetsTruncation(), pg_atomic_write_u64(), RecordNewMultiXact(), SetMultiXactIdLimit(), SimpleLruZeroAndWritePage(), SizeOfMultiXactTruncate, TransactionIdPrecedes(), XLOG_MULTIXACT_CREATE_ID, XLOG_MULTIXACT_TRUNCATE_ID, XLOG_MULTIXACT_ZERO_MEM_PAGE, XLOG_MULTIXACT_ZERO_OFF_PAGE, XLogRecGetData, XLogRecGetInfo, XLogRecGetXid, and XLogRecHasAnyBlockRefs.

◆ multixact_twophase_postabort()

void multixact_twophase_postabort	(	FullTransactionId	fxid,
		uint16	info,
		void *	recdata,
		uint32	len
	)

extern

Definition at line 1695 of file multixact.c.

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

References fb(), len, and multixact_twophase_postcommit().

◆ multixact_twophase_postcommit()

void multixact_twophase_postcommit	(	FullTransactionId	fxid,
		uint16	info,
		void *	recdata,
		uint32	len
	)

extern

Definition at line 1680 of file multixact.c.

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

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

Referenced by multixact_twophase_postabort().

◆ multixact_twophase_recover()

void multixact_twophase_recover	(	FullTransactionId	fxid,
		uint16	info,
		void *	recdata,
		uint32	len
	)

extern

Definition at line 1659 of file multixact.c.

{
    ProcNumber  dummyProcNumber = TwoPhaseGetDummyProcNumber(fxid, 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, fb(), len, OldestMemberMXactId, and TwoPhaseGetDummyProcNumber().

◆ MultiXactAdvanceNextMXact()

void MultiXactAdvanceNextMXact	(	MultiXactId	minMulti,
		MultiXactOffset	minMultiOffset
	)

extern

Definition at line 2164 of file multixact.c.

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

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

Referenced by multixact_redo(), and xlog_redo().

◆ MultiXactAdvanceOldest()

void MultiXactAdvanceOldest	(	MultiXactId	oldestMulti,
		Oid	oldestMultiDB
	)

extern

Definition at line 2191 of file multixact.c.

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

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
	)

extern

Definition at line 1946 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 %" PRIu64 ", oldestMulti %u in DB %u",
                *nextMulti, *nextMultiOffset, *oldestMulti, *oldestMultiDB);
}

References DEBUG2, debug_elog6, fb(), 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
	)

extern

Definition at line 299 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, fb(), 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
	)

extern

Definition at line 656 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", NULL);
 
    /* 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(&xlrec, SizeOfMultiXactCreate);
    XLogRegisterData(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, fb(), GetNewMultiXactId(), i, INJECTION_POINT_CACHED, INJECTION_POINT_LOAD, InvalidMultiXactId, ISUPDATE_from_mxstatus, MultiXactIdIsValid, mXactCacheGetBySet(), mXactCachePut(), mxid_to_string(), 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
	)

extern

Definition at line 352 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 = palloc_array(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, fb(), GetMultiXactIdMembers(), i, ISUPDATE_from_mxstatus, j, MultiXactIdCreateFromMembers(), MultiXactIdIsValid, mxstatus_to_string(), MyProcNumber, OldestMemberMXactId, palloc_array, pfree(), MultiXactMember::status, TransactionIdDidCommit(), TransactionIdEquals, TransactionIdIsInProgress(), TransactionIdIsValid, and MultiXactMember::xid.

Referenced by compute_new_xmax_infomask().

◆ MultiXactIdIsRunning()

bool MultiXactIdIsRunning	(	MultiXactId	multi,
		bool	isLockOnly
	)

extern

Definition at line 463 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, fb(), GetMultiXactIdMembers(), i, pfree(), TransactionIdIsCurrentTransactionId(), and TransactionIdIsInProgress().

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

◆ MultiXactIdPrecedes()

bool MultiXactIdPrecedes	(	MultiXactId	multi1,
		MultiXactId	multi2
	)

extern

Definition at line 2765 of file multixact.c.

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

References fb().

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

◆ MultiXactIdPrecedesOrEquals()

bool MultiXactIdPrecedesOrEquals	(	MultiXactId	multi1,
		MultiXactId	multi2
	)

extern

Definition at line 2779 of file multixact.c.

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

References fb().

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

◆ MultiXactIdSetOldestMember()

void MultiXactIdSetOldestMember ( void )

extern

Definition at line 537 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);
 
        nextMXact = MultiXactState->nextMXact;
 
        OldestMemberMXactId[MyProcNumber] = nextMXact;
 
        LWLockRelease(MultiXactGenLock);
 
        debug_elog4(DEBUG2, "MultiXact: setting OldestMember[%d] = %u",
                    MyProcNumber, nextMXact);
    }
}

References DEBUG2, debug_elog4, fb(), 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 )

extern

Definition at line 2511 of file multixact.c.

{
    uint32      multixacts;
    uint32      victim_multixacts;
    double      fraction;
    int         result;
    MultiXactId oldestMultiXactId;
    MultiXactOffset oldestOffset;
    MultiXactOffset nextOffset;
    uint64      members;
 
    /* Read the current offsets and multixact usage. */
    GetMultiXactInfo(&multixacts, &nextOffset, &oldestMultiXactId, &oldestOffset);
    members = nextOffset - oldestOffset;
 
    /* If member space utilization is low, no special action is required. */
    if (members <= MULTIXACT_MEMBER_LOW_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_LOW_THRESHOLD.
     *
     * The way this formula works is that when members is exactly at the low
     * threshold, fraction = 0.0, and we set freeze_max_age equal to
     * mxid_age(oldestMultiXactId).  As members grows further, towards the
     * high threshold, fraction grows linearly from 0.0 to 1.0, and the result
     * shrinks from mxid_age(oldestMultiXactId) to 0.  Beyond the high
     * threshold, fraction > 1.0 and the result is clamped to 0.
     */
    fraction = (double) (members - MULTIXACT_MEMBER_LOW_THRESHOLD) /
        (MULTIXACT_MEMBER_HIGH_THRESHOLD - MULTIXACT_MEMBER_LOW_THRESHOLD);
 
    /* fraction could be > 1.0, but lowest possible freeze age is zero */
    if (fraction >= 1.0)
        return 0;
 
    victim_multixacts = multixacts * fraction;
    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, fb(), GetMultiXactInfo(), Min, MULTIXACT_MEMBER_HIGH_THRESHOLD, and MULTIXACT_MEMBER_LOW_THRESHOLD.

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

◆ multixactmemberssyncfiletag()

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

extern

Definition at line 2921 of file multixact.c.

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

References MultiXactMemberCtl, and SlruSyncFileTag().

◆ multixactoffsetssyncfiletag()

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

extern

Definition at line 2912 of file multixact.c.

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

References MultiXactOffsetCtl, and SlruSyncFileTag().

◆ MultiXactSetNextMXact()

void MultiXactSetNextMXact	(	MultiXactId	nextMulti,
		MultiXactOffset	nextMultiOffset
	)

extern

Definition at line 1992 of file multixact.c.

{
    Assert(MultiXactIdIsValid(nextMulti));
    debug_elog4(DEBUG2, "MultiXact: setting next multi to %u offset %" PRIu64,
                nextMulti, nextMultiOffset);
 
    LWLockAcquire(MultiXactGenLock, LW_EXCLUSIVE);
    MultiXactState->nextMXact = nextMulti;
    MultiXactState->nextOffset = nextMultiOffset;
    LWLockRelease(MultiXactGenLock);
}

References Assert, DEBUG2, debug_elog4, fb(), LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MultiXactIdIsValid, MultiXactState, MultiXactStateData::nextMXact, and MultiXactStateData::nextOffset.

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

◆ MultiXactShmemInit()

void MultiXactShmemInit ( void )

extern

Definition at line 1724 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,
                  true);
    /* 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);
    }
    else
        Assert(found);
 
    /*
     * Set up array pointers.
     */
    OldestMemberMXactId = MultiXactState->perBackendXactIds;
    OldestVisibleMXactId = OldestMemberMXactId + MaxOldestSlot;
}

References Assert, DEBUG2, debug_elog2, fb(), IsUnderPostmaster, MaxOldestSlot, MemSet, multixact_member_buffers, multixact_offset_buffers, MULTIXACT_OFFSETS_PER_PAGE, MultiXactMemberCtl, MultiXactMemberPagePrecedes(), MultiXactOffsetCtl, MultiXactOffsetPagePrecedes(), MultiXactState, 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 )

extern

Definition at line 1707 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, and SimpleLruShmemSize().

Referenced by CalculateShmemSize().

◆ mxid_to_string()

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

extern

Definition at line 1537 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, fb(), i, initStringInfo(), MemoryContextStrdup(), mxstatus_to_string(), pfree(), str, and TopMemoryContext.

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

◆ mxstatus_to_string()

char * mxstatus_to_string ( MultiXactStatus status )

extern

Definition at line 1514 of file multixact.c.

{
    switch (status)
    {
        case MultiXactStatusForKeyShare:
            return "keysh";
        case MultiXactStatusForShare:
            return "sh";
        case MultiXactStatusForNoKeyUpdate:
            return "fornokeyupd";
        case MultiXactStatusForUpdate:
            return "forupd";
        case MultiXactStatusNoKeyUpdate:
            return "nokeyupd";
        case MultiXactStatusUpdate:
            return "upd";
        default:
            elog(ERROR, "unrecognized multixact status %d", status);
            return "";
    }
}

References elog, ERROR, MultiXactStatusForKeyShare, MultiXactStatusForNoKeyUpdate, MultiXactStatusForShare, MultiXactStatusForUpdate, MultiXactStatusNoKeyUpdate, and MultiXactStatusUpdate.

Referenced by MultiXactIdExpand(), mxid_to_string(), and pg_get_multixact_members().

◆ PostPrepare_MultiXact()

void PostPrepare_MultiXact ( FullTransactionId fxid )

extern

Definition at line 1610 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(fxid, 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(), fb(), InvalidMultiXactId, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MultiXactIdIsValid, MXactCache, MXactContext, MyProcNumber, OldestMemberMXactId, OldestVisibleMXactId, and TwoPhaseGetDummyProcNumber().

Referenced by PrepareTransaction().

◆ ReadMultiXactIdRange()

void ReadMultiXactIdRange	(	MultiXactId *	oldest,
		MultiXactId *	next
	)

extern

Definition at line 637 of file multixact.c.

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

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

Referenced by update_cached_mxid_range().

◆ ReadNextMultiXactId()

MultiXactId ReadNextMultiXactId ( void )

extern

Definition at line 620 of file multixact.c.

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

References fb(), 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
	)

extern

Definition at line 2014 of file multixact.c.

{
    MultiXactId multiVacLimit;
    MultiXactId multiWarnLimit;
    MultiXactId multiStopLimit;
    MultiXactId multiWrapLimit;
    MultiXactId curMulti;
 
    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.
     */
    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);
 
    /*
     * Offsets are 64-bits wide and never wrap around, so we don't need to
     * consider them for emergency autovacuum purposes.  But now that we're in
     * a consistent state, determine MultiXactState->oldestOffset.  It will be
     * used to adjust the freezing cutoff, to keep the offsets disk usage in
     * check.
     */
    SetOldestOffset();
 
    /*
     * 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) && 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 )

extern

Definition at line 1809 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 )

extern

Definition at line 1834 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);
 
    /*
     * Set the offset of nextMXact on the offsets page.  This is normally done
     * in RecordNewMultiXact() of the previous multixact, but let's be sure
     * the next page exists, if the nextMXact was reset with pg_resetwal for
     * example.
     *
     * Zero out the remainder of the 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.
     */
    entryno = MultiXactIdToOffsetEntry(nextMXact);
    {
        int         slotno;
        MultiXactOffset *offptr;
        LWLock     *lock = SimpleLruGetBankLock(MultiXactOffsetCtl, pageno);
 
        LWLockAcquire(lock, LW_EXCLUSIVE);
        if (entryno == 0 || nextMXact == FirstMultiXactId)
            slotno = SimpleLruZeroPage(MultiXactOffsetCtl, pageno);
        else
            slotno = SimpleLruReadPage(MultiXactOffsetCtl, pageno, true, nextMXact);
        offptr = (MultiXactOffset *) MultiXactOffsetCtl->shared->page_buffer[slotno];
        offptr += entryno;
 
        *offptr = offset;
        if (entryno != 0 && (entryno + 1) * sizeof(MultiXactOffset) != BLCKSZ)
            MemSet(offptr + 1, 0, BLCKSZ - (entryno + 1) * 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 multixid wraparound is. */
    SetMultiXactIdLimit(oldestMXact, oldestMXactDB);
}

References fb(), MultiXactStateData::finishedStartup, FirstMultiXactId, 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(), SimpleLruReadPage(), and SimpleLruZeroPage().

Referenced by StartupXLOG().

◆ TruncateMultiXact()

void TruncateMultiXact	(	MultiXactId	newOldestMulti,
		Oid	newOldestMultiDB
	)

extern

Definition at line 2599 of file multixact.c.

{
    MultiXactId oldestMulti;
    MultiXactId nextMulti;
    MultiXactOffset newOldestOffset;
    MultiXactOffset nextOffset;
 
    Assert(!RecoveryInProgress());
    Assert(MultiXactState->finishedStartup);
    Assert(MultiXactIdIsValid(newOldestMulti));
 
    /*
     * We can only allow one truncation to happen at once. Otherwise parts of
     * members might vanish while we're doing lookups or similar. There's no
     * need to have an interlock with creating new multis or such, since those
     * are constrained by the limits (which only grow, never shrink).
     */
    LWLockAcquire(MultiXactTruncationLock, LW_EXCLUSIVE);
 
    LWLockAcquire(MultiXactGenLock, LW_SHARED);
    nextMulti = MultiXactState->nextMXact;
    nextOffset = MultiXactState->nextOffset;
    oldestMulti = MultiXactState->oldestMultiXactId;
    LWLockRelease(MultiXactGenLock);
 
    /*
     * Make sure to only attempt truncation if there's values to truncate
     * away. In normal processing values shouldn't go backwards, but there's
     * some corner cases (due to bugs) where that's possible.
     */
    if (MultiXactIdPrecedesOrEquals(newOldestMulti, oldestMulti))
    {
        LWLockRelease(MultiXactTruncationLock);
        return;
    }
 
    /*
     * Compute up to where to truncate MultiXactMember. Lookup the
     * corresponding member offset for newOldestMulti for that.
     */
    if (newOldestMulti == nextMulti)
    {
        /* there are NO MultiXacts */
        newOldestOffset = nextOffset;
    }
    else if (!find_multixact_start(newOldestMulti, &newOldestOffset))
    {
        ereport(LOG,
                (errmsg("cannot truncate up to MultiXact %u because it does not exist on disk, skipping truncation",
                        newOldestMulti)));
        LWLockRelease(MultiXactTruncationLock);
        return;
    }
 
    /*
     * On crash, MultiXactIdCreateFromMembers() can leave behind multixids
     * that were not yet written out and hence have zero offset on disk. If
     * such a multixid becomes oldestMulti, we won't be able to look up its
     * offset. That should be rare, so we don't try to do anything smart about
     * it. Just skip the truncation, and hope that by the next truncation
     * attempt, oldestMulti has advanced to a valid multixid.
     */
    if (newOldestOffset == 0)
    {
        ereport(LOG,
                (errmsg("cannot truncate up to MultiXact %u because it has invalid offset, skipping truncation",
                        newOldestMulti)));
        LWLockRelease(MultiXactTruncationLock);
        return;
    }
 
    elog(DEBUG1, "performing multixact truncation: "
         "oldestMulti %u (offsets segment %" PRIx64 "), "
         "oldestOffset %" PRIu64 " (members segment %" PRIx64 ")",
         newOldestMulti,
         MultiXactIdToOffsetSegment(newOldestMulti),
         newOldestOffset,
         MXOffsetToMemberSegment(newOldestOffset));
 
    /*
     * Do truncation, and the WAL logging of the truncation, in a critical
     * section. That way offsets/members cannot get out of sync anymore, i.e.
     * once consistent the newOldestMulti will always exist in members, even
     * if we crashed in the wrong moment.
     */
    START_CRIT_SECTION();
 
    /*
     * Prevent checkpoints from being scheduled concurrently. This is critical
     * because otherwise a truncation record might not be replayed after a
     * crash/basebackup, even though the state of the data directory would
     * require it.
     */
    Assert((MyProc->delayChkptFlags & DELAY_CHKPT_START) == 0);
    MyProc->delayChkptFlags |= DELAY_CHKPT_START;
 
    /* WAL log truncation */
    WriteMTruncateXlogRec(newOldestMultiDB, newOldestMulti, newOldestOffset);
 
    /*
     * Update in-memory limits before performing the truncation, while inside
     * the critical section: Have to do it before truncation, to prevent
     * concurrent lookups of those values. Has to be inside the critical
     * section as otherwise a future call to this function would error out,
     * while looking up the oldest member in offsets, if our caller crashes
     * before updating the limits.
     */
    LWLockAcquire(MultiXactGenLock, LW_EXCLUSIVE);
    MultiXactState->oldestMultiXactId = newOldestMulti;
    MultiXactState->oldestMultiXactDB = newOldestMultiDB;
    MultiXactState->oldestOffset = newOldestOffset;
    LWLockRelease(MultiXactGenLock);
 
    /* First truncate members */
    PerformMembersTruncation(newOldestOffset);
 
    /* Then offsets */
    PerformOffsetsTruncation(newOldestMulti);
 
    MyProc->delayChkptFlags &= ~DELAY_CHKPT_START;
 
    END_CRIT_SECTION();
    LWLockRelease(MultiXactTruncationLock);
}

References Assert, DEBUG1, DELAY_CHKPT_START, PGPROC::delayChkptFlags, elog, END_CRIT_SECTION, ereport, errmsg(), fb(), find_multixact_start(), MultiXactStateData::finishedStartup, LOG, LW_EXCLUSIVE, LW_SHARED, LWLockAcquire(), LWLockRelease(), MultiXactIdIsValid, MultiXactIdPrecedesOrEquals(), MultiXactIdToOffsetSegment(), MultiXactState, MXOffsetToMemberSegment(), MyProc, MultiXactStateData::nextMXact, MultiXactStateData::nextOffset, MultiXactStateData::oldestMultiXactDB, MultiXactStateData::oldestMultiXactId, MultiXactStateData::oldestOffset, PerformMembersTruncation(), PerformOffsetsTruncation(), RecoveryInProgress(), START_CRIT_SECTION, and WriteMTruncateXlogRec().

Referenced by vac_truncate_clog().

Data Structures

Macros

Typedefs

Enumerations

Functions

Macro Definition Documentation

◆ FirstMultiXactId

◆ InvalidMultiXactId

◆ ISUPDATE_from_mxstatus

◆ MaxMultiXactId

◆ MaxMultiXactStatus

◆ MultiXactIdIsValid

◆ SizeOfMultiXactCreate

◆ SizeOfMultiXactTruncate

◆ XLOG_MULTIXACT_CREATE_ID

◆ XLOG_MULTIXACT_TRUNCATE_ID

◆ XLOG_MULTIXACT_ZERO_MEM_PAGE

◆ XLOG_MULTIXACT_ZERO_OFF_PAGE

Typedef Documentation

◆ MultiXactMember

◆ xl_multixact_create

◆ xl_multixact_truncate

Enumeration Type Documentation

◆ MultiXactStatus

Function Documentation

◆ AtEOXact_MultiXact()

◆ AtPrepare_MultiXact()

◆ BootStrapMultiXact()

◆ CheckPointMultiXact()

◆ GetMultiXactIdMembers()

◆ GetMultiXactInfo()

◆ GetOldestMultiXactId()

◆ multixact_desc()

◆ multixact_identify()

◆ multixact_redo()

◆ multixact_twophase_postabort()

◆ multixact_twophase_postcommit()

◆ multixact_twophase_recover()

◆ MultiXactAdvanceNextMXact()

◆ MultiXactAdvanceOldest()

◆ MultiXactGetCheckptMulti()

◆ MultiXactIdCreate()

◆ MultiXactIdCreateFromMembers()

◆ MultiXactIdExpand()

◆ MultiXactIdIsRunning()

◆ MultiXactIdPrecedes()

◆ MultiXactIdPrecedesOrEquals()

◆ MultiXactIdSetOldestMember()

◆ MultiXactMemberFreezeThreshold()

◆ multixactmemberssyncfiletag()

◆ multixactoffsetssyncfiletag()

◆ MultiXactSetNextMXact()

◆ MultiXactShmemInit()

◆ MultiXactShmemSize()

◆ mxid_to_string()

◆ mxstatus_to_string()

◆ PostPrepare_MultiXact()

◆ ReadMultiXactIdRange()

◆ ReadNextMultiXactId()

◆ SetMultiXactIdLimit()

◆ StartupMultiXact()

◆ TrimMultiXact()

◆ TruncateMultiXact()