multixact.h File Reference

#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 1617 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.
     */
    *MyOldestMemberMXactIdSlot() = InvalidMultiXactId;
    *MyOldestVisibleMXactIdSlot() = 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, MyOldestMemberMXactIdSlot(), and MyOldestVisibleMXactIdSlot().

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

AtPrepare_MultiXact()

void AtPrepare_MultiXact ( void  )

extern

Definition at line 1645 of file multixact.c.

{
    MultiXactId myOldestMember = *MyOldestMemberMXactIdSlot();
 
    if (MultiXactIdIsValid(myOldestMember))
        RegisterTwoPhaseRecord(TWOPHASE_RM_MULTIXACT_ID, 0,
                               &myOldestMember, sizeof(MultiXactId));
}

References fb(), MultiXactIdIsValid, MyOldestMemberMXactIdSlot(), RegisterTwoPhaseRecord(), and TWOPHASE_RM_MULTIXACT_ID.

Referenced by PrepareTransaction().

BootStrapMultiXact()

void BootStrapMultiXact ( void  )

extern

Definition at line 1855 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 2031 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 1161 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, *MyOldestVisibleMXactIdSlot()))
    {
        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)
        {
            MultiXactMemberSlruReadContext slru_read_context = {multi, offset};
            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,
                                       &slru_read_context);
            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(), MyOldestVisibleMXactIdSlot(), NextMultiXactId(), MultiXactStateData::nextMXact, MultiXactStateData::oldestMultiXactId, 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 2538 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 2370 of file multixact.c.

{
    MultiXactId oldestMXact;
 
    /*
     * 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 (int i = 0; i < NumMemberSlots; i++)
    {
        MultiXactId thisoldest;
 
        thisoldest = OldestMemberMXactId[i];
        if (MultiXactIdIsValid(thisoldest) &&
            MultiXactIdPrecedes(thisoldest, oldestMXact))
            oldestMXact = thisoldest;
    }
    for (int i = 0; i < NumVisibleSlots; i++)
    {
        MultiXactId thisoldest;
 
        thisoldest = OldestVisibleMXactId[i];
        if (MultiXactIdIsValid(thisoldest) &&
            MultiXactIdPrecedes(thisoldest, oldestMXact))
            oldestMXact = thisoldest;
    }
 
    LWLockRelease(MultiXactGenLock);
 
    return oldestMXact;
}

References fb(), i, LW_SHARED, LWLockAcquire(), LWLockRelease(), MultiXactIdIsValid, MultiXactIdPrecedes(), MultiXactState, MultiXactStateData::nextMXact, NumMemberSlots, NumVisibleSlots, 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 2907 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 1744 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 1729 of file multixact.c.

{
    ProcNumber  dummyProcNumber = TwoPhaseGetDummyProcNumber(fxid, true);
 
    Assert(len == sizeof(MultiXactId));
 
    *PreparedXactOldestMemberMXactIdSlot(dummyProcNumber) = InvalidMultiXactId;
}

References Assert, fb(), InvalidMultiXactId, len, PreparedXactOldestMemberMXactIdSlot(), 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 1708 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);
 
    *PreparedXactOldestMemberMXactIdSlot(dummyProcNumber) = oldestMember;
}

References Assert, fb(), len, PreparedXactOldestMemberMXactIdSlot(), and TwoPhaseGetDummyProcNumber().

MultiXactAdvanceNextMXact()

void MultiXactAdvanceNextMXact ( MultiXactId  minMulti, MultiXactOffset  minMultiOffset  )

extern

Definition at line 2231 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 2258 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 2009 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 347 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(*MyOldestMemberMXactIdSlot()));
 
    /*
     * 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(), MyOldestMemberMXactIdSlot(), 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 704 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 400 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(*MyOldestMemberMXactIdSlot()));
 
    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(), MyOldestMemberMXactIdSlot(), 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 511 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 2857 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 2871 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 585 of file multixact.c.

{
    if (!MultiXactIdIsValid(*MyOldestMemberMXactIdSlot()))
    {
        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;
 
        *MyOldestMemberMXactIdSlot() = nextMXact;
 
        LWLockRelease(MultiXactGenLock);
 
        debug_elog4(DEBUG2, "MultiXact: setting OldestMember[%d] = %u",
                    MyProcNumber, nextMXact);
    }
}

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

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 2582 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 3013 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 3004 of file multixact.c.

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

References MultiXactOffsetCtl, and SlruSyncFileTag().

MultiXactSetNextMXact()

void MultiXactSetNextMXact ( MultiXactId  nextMulti, MultiXactOffset  nextMultiOffset  )

extern

Definition at line 2055 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 1784 of file multixact.c.

{
    bool        found;
 
    debug_elog2(DEBUG2, "Shared Memory Init for MultiXact");
 
    MultiXactOffsetCtl->PagePrecedes = MultiXactOffsetPagePrecedes;
    MultiXactMemberCtl->PagePrecedes = MultiXactMemberPagePrecedes;
    MultiXactOffsetCtl->errdetail_for_io_error = MultiXactOffsetIoErrorDetail;
    MultiXactMemberCtl->errdetail_for_io_error = MultiXactMemberIoErrorDetail;
 
    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",
                                     MultiXactSharedStateShmemSize(),
                                     &found);
    if (!IsUnderPostmaster)
    {
        Assert(!found);
 
        /* Make sure we zero out the per-backend state */
        MemSet(MultiXactState, 0, MultiXactSharedStateShmemSize());
    }
    else
        Assert(found);
 
    /*
     * Set up array pointers.
     */
    OldestMemberMXactId = MultiXactState->perBackendXactIds;
    OldestVisibleMXactId = OldestMemberMXactId + NumMemberSlots;
}

References Assert, DEBUG2, debug_elog2, fb(), IsUnderPostmaster, MemSet, multixact_member_buffers, multixact_offset_buffers, MULTIXACT_OFFSETS_PER_PAGE, MultiXactMemberCtl, MultiXactMemberIoErrorDetail(), MultiXactMemberPagePrecedes(), MultiXactOffsetCtl, MultiXactOffsetIoErrorDetail(), MultiXactOffsetPagePrecedes(), MultiXactSharedStateShmemSize(), MultiXactState, NumMemberSlots, OldestMemberMXactId, OldestVisibleMXactId, MultiXactStateData::perBackendXactIds, ShmemInitStruct(), SimpleLruInit(), SlruPagePrecedesUnitTests, SYNC_HANDLER_MULTIXACT_MEMBER, and SYNC_HANDLER_MULTIXACT_OFFSET.

Referenced by CreateOrAttachShmemStructs().

MultiXactShmemSize()

Size MultiXactShmemSize ( void  )

extern

Definition at line 1772 of file multixact.c.

{
    Size        size;
 
    size = MultiXactSharedStateShmemSize();
    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, MultiXactSharedStateShmemSize(), and SimpleLruShmemSize().

Referenced by CalculateShmemSize().

mxid_to_string()

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

extern

Definition at line 1586 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 1563 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 1659 of file multixact.c.

{
    MultiXactId myOldestMember;
 
    /*
     * Transfer our OldestMemberMXactId value to the slot reserved for the
     * prepared transaction.
     */
    myOldestMember = *MyOldestMemberMXactIdSlot();
    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);
 
        *PreparedXactOldestMemberMXactIdSlot(dummyProcNumber) = myOldestMember;
        *MyOldestMemberMXactIdSlot() = 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.
     */
    *MyOldestVisibleMXactIdSlot() = 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, MyOldestMemberMXactIdSlot(), MyOldestVisibleMXactIdSlot(), PreparedXactOldestMemberMXactIdSlot(), and TwoPhaseGetDummyProcNumber().

Referenced by PrepareTransaction().

ReadMultiXactIdRange()

void ReadMultiXactIdRange ( MultiXactId *  oldest, MultiXactId *  next  )

extern

Definition at line 685 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 668 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 2077 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 100M multis of data
     * loss.  This is kind of arbitrary, but if you let your gas gauge get
     * down to 5% 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 - 100000000;
    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),
                     errdetail("Approximately %.2f%% of MultiXactIds are available for use.",
                               (double) (multiWrapLimit - curMulti) / (MaxMultiXactId / 2) * 100),
                     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),
                     errdetail("Approximately %.2f%% of MultiXactIds are available for use.",
                               (double) (multiWrapLimit - curMulti) / (MaxMultiXactId / 2) * 100),
                     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.")));
    }
}

References Assert, autovacuum_multixact_freeze_max_age, DEBUG1, ereport, errdetail(), errhint(), errmsg_internal(), errmsg_plural(), fb(), MultiXactStateData::finishedStartup, FirstMultiXactId, get_database_name(), InRecovery, IsTransactionState(), IsUnderPostmaster, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MaxMultiXactId, MultiXactStateData::multiStopLimit, MultiXactStateData::multiVacLimit, MultiXactStateData::multiWarnLimit, MultiXactStateData::multiWrapLimit, MultiXactIdIsValid, MultiXactIdPrecedes(), MultiXactState, MultiXactStateData::nextMXact, MultiXactStateData::oldestMultiXactDB, MultiXactStateData::oldestMultiXactId, PMSIGNAL_START_AUTOVAC_LAUNCHER, SendPostmasterSignal(), SetOldestOffset(), and WARNING.

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

StartupMultiXact()

void StartupMultiXact ( void  )

extern

Definition at line 1871 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 1896 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)
    {
        MultiXactMemberSlruReadContext slru_read_context = {InvalidMultiXactId, offset};
        int         slotno;
        TransactionId *xidptr;
        int         memberoff;
        LWLock     *lock = SimpleLruGetBankLock(MultiXactMemberCtl, pageno);
 
        LWLockAcquire(lock, LW_EXCLUSIVE);
        memberoff = MXOffsetToMemberOffset(offset);
        slotno = SimpleLruReadPage(MultiXactMemberCtl, pageno, true, &slru_read_context);
        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, InvalidMultiXactId, 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 2670 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().