multixact.c File Reference

#include "postgres.h"
#include "access/multixact.h"
#include "access/multixact_internal.h"
#include "access/slru.h"
#include "access/twophase.h"
#include "access/twophase_rmgr.h"
#include "access/xlog.h"
#include "access/xloginsert.h"
#include "access/xlogutils.h"
#include "miscadmin.h"
#include "pg_trace.h"
#include "pgstat.h"
#include "postmaster/autovacuum.h"
#include "storage/pmsignal.h"
#include "storage/proc.h"
#include "storage/procarray.h"
#include "utils/guc_hooks.h"
#include "utils/injection_point.h"
#include "utils/lsyscache.h"
#include "utils/memutils.h"

Include dependency graph for multixact.c:

Go to the source code of this file.

Data Structures
struct	MultiXactStateData
struct	mXactCacheEnt

Macros
#define	MULTIXACT_MEMBER_LOW_THRESHOLD   UINT64CONST(2000000000)
#define	MULTIXACT_MEMBER_HIGH_THRESHOLD   UINT64CONST(4000000000)
#define	MultiXactOffsetCtl   (&MultiXactOffsetCtlData)
#define	MultiXactMemberCtl   (&MultiXactMemberCtlData)
#define	MaxOldestSlot   (MaxBackends + max_prepared_xacts)
#define	MAX_CACHE_ENTRIES   256
#define	debug_elog2(a, b)
#define	debug_elog3(a, b, c)
#define	debug_elog4(a, b, c, d)
#define	debug_elog5(a, b, c, d, e)
#define	debug_elog6(a, b, c, d, e, f)
#define	SHARED_MULTIXACT_STATE_SIZE

Typedefs
typedef struct MultiXactStateData	MultiXactStateData
typedef struct mXactCacheEnt	mXactCacheEnt

Functions
static MultiXactId	NextMultiXactId (MultiXactId multi)
static MultiXactId	PreviousMultiXactId (MultiXactId multi)
static void	MultiXactIdSetOldestVisible (void)
static void	RecordNewMultiXact (MultiXactId multi, MultiXactOffset offset, int nmembers, MultiXactMember *members)
static MultiXactId	GetNewMultiXactId (int nmembers, MultiXactOffset *offset)
static int	mxactMemberComparator (const void *arg1, const void *arg2)
static MultiXactId	mXactCacheGetBySet (int nmembers, MultiXactMember *members)
static int	mXactCacheGetById (MultiXactId multi, MultiXactMember **members)
static void	mXactCachePut (MultiXactId multi, int nmembers, MultiXactMember *members)
static bool	MultiXactOffsetPagePrecedes (int64 page1, int64 page2)
static bool	MultiXactMemberPagePrecedes (int64 page1, int64 page2)
static void	ExtendMultiXactOffset (MultiXactId multi)
static void	ExtendMultiXactMember (MultiXactOffset offset, int nmembers)
static void	SetOldestOffset (void)
static bool	find_multixact_start (MultiXactId multi, MultiXactOffset *result)
static void	WriteMTruncateXlogRec (Oid oldestMultiDB, MultiXactId endTruncOff, MultiXactOffset endTruncMemb)
MultiXactId	MultiXactIdCreate (TransactionId xid1, MultiXactStatus status1, TransactionId xid2, MultiXactStatus status2)
MultiXactId	MultiXactIdExpand (MultiXactId multi, TransactionId xid, MultiXactStatus status)
bool	MultiXactIdIsRunning (MultiXactId multi, bool isLockOnly)
void	MultiXactIdSetOldestMember (void)
MultiXactId	ReadNextMultiXactId (void)
void	ReadMultiXactIdRange (MultiXactId *oldest, MultiXactId *next)
MultiXactId	MultiXactIdCreateFromMembers (int nmembers, MultiXactMember *members)
int	GetMultiXactIdMembers (MultiXactId multi, MultiXactMember **members, bool from_pgupgrade, bool isLockOnly)
char *	mxstatus_to_string (MultiXactStatus status)
char *	mxid_to_string (MultiXactId multi, int nmembers, MultiXactMember *members)
void	AtEOXact_MultiXact (void)
void	AtPrepare_MultiXact (void)
void	PostPrepare_MultiXact (FullTransactionId fxid)
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)
Size	MultiXactShmemSize (void)
void	MultiXactShmemInit (void)
bool	check_multixact_offset_buffers (int *newval, void **extra, GucSource source)
bool	check_multixact_member_buffers (int *newval, void **extra, GucSource source)
void	BootStrapMultiXact (void)
void	StartupMultiXact (void)
void	TrimMultiXact (void)
void	MultiXactGetCheckptMulti (bool is_shutdown, MultiXactId *nextMulti, MultiXactOffset *nextMultiOffset, MultiXactId *oldestMulti, Oid *oldestMultiDB)
void	CheckPointMultiXact (void)
void	MultiXactSetNextMXact (MultiXactId nextMulti, MultiXactOffset nextMultiOffset)
void	SetMultiXactIdLimit (MultiXactId oldest_datminmxid, Oid oldest_datoid)
void	MultiXactAdvanceNextMXact (MultiXactId minMulti, MultiXactOffset minMultiOffset)
void	MultiXactAdvanceOldest (MultiXactId oldestMulti, Oid oldestMultiDB)
MultiXactId	GetOldestMultiXactId (void)
void	GetMultiXactInfo (uint32 *multixacts, MultiXactOffset *nextOffset, MultiXactId *oldestMultiXactId, MultiXactOffset *oldestOffset)
int	MultiXactMemberFreezeThreshold (void)
static void	PerformMembersTruncation (MultiXactOffset newOldestOffset)
static void	PerformOffsetsTruncation (MultiXactId newOldestMulti)
void	TruncateMultiXact (MultiXactId newOldestMulti, Oid newOldestMultiDB)
bool	MultiXactIdPrecedes (MultiXactId multi1, MultiXactId multi2)
bool	MultiXactIdPrecedesOrEquals (MultiXactId multi1, MultiXactId multi2)
void	multixact_redo (XLogReaderState *record)
int	multixactoffsetssyncfiletag (const FileTag *ftag, char *path)
int	multixactmemberssyncfiletag (const FileTag *ftag, char *path)

Variables
static SlruCtlData	MultiXactOffsetCtlData
static SlruCtlData	MultiXactMemberCtlData
static MultiXactStateData *	MultiXactState
static MultiXactId *	OldestMemberMXactId
static MultiXactId *	OldestVisibleMXactId
static dclist_head	MXactCache = DCLIST_STATIC_INIT(MXactCache)
static MemoryContext	MXactContext = NULL

Macro Definition Documentation

debug_elog2

#define debug_elog2	(		a,
			b
	)

Definition at line 257 of file multixact.c.

debug_elog3

#define debug_elog3	(		a,
			b,
			c
	)

Definition at line 258 of file multixact.c.

debug_elog4

#define debug_elog4	(		a,
			b,
			c,
			d
	)

Definition at line 259 of file multixact.c.

debug_elog5

#define debug_elog5	(		a,
			b,
			c,
			d,
			e
	)

Definition at line 260 of file multixact.c.

debug_elog6

#define debug_elog6	(		a,
			b,
			c,
			d,
			e,
			f
	)

Definition at line 261 of file multixact.c.

MAX_CACHE_ENTRIES

#define MAX_CACHE_ENTRIES   256

Definition at line 246 of file multixact.c.

MaxOldestSlot

#define MaxOldestSlot   (MaxBackends + max_prepared_xacts)

Definition at line 213 of file multixact.c.

MULTIXACT_MEMBER_HIGH_THRESHOLD

#define MULTIXACT_MEMBER_HIGH_THRESHOLD   UINT64CONST(4000000000)

Definition at line 99 of file multixact.c.

MULTIXACT_MEMBER_LOW_THRESHOLD

#define MULTIXACT_MEMBER_LOW_THRESHOLD   UINT64CONST(2000000000)

Definition at line 98 of file multixact.c.

MultiXactMemberCtl

#define MultiXactMemberCtl   (&MultiXactMemberCtlData)

Definition at line 120 of file multixact.c.

MultiXactOffsetCtl

#define MultiXactOffsetCtl   (&MultiXactOffsetCtlData)

Definition at line 119 of file multixact.c.

SHARED_MULTIXACT_STATE_SIZE

#define SHARED_MULTIXACT_STATE_SIZE

Value:

    add_size(offsetof(MultiXactStateData, perBackendXactIds), \
             mul_size(sizeof(MultiXactId) * 2, MaxOldestSlot))

Typedef Documentation

MultiXactStateData

typedef struct MultiXactStateData MultiXactStateData

mXactCacheEnt

typedef struct mXactCacheEnt mXactCacheEnt

Function Documentation

AtEOXact_MultiXact()

void AtEOXact_MultiXact

(

void

)

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

)

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

)

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().

check_multixact_member_buffers()

bool check_multixact_member_buffers	(	int *	newval,
		void **	extra,
		GucSource	source
	)

Definition at line 1782 of file multixact.c.

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

References check_slru_buffers(), and newval.

check_multixact_offset_buffers()

bool check_multixact_offset_buffers	(	int *	newval,
		void **	extra,
		GucSource	source
	)

Definition at line 1773 of file multixact.c.

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

References check_slru_buffers(), and newval.

CheckPointMultiXact()

void CheckPointMultiXact

(

void

)

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().

ExtendMultiXactMember()

static void ExtendMultiXactMember ( MultiXactOffset  offset, int  nmembers  )

static

Definition at line 2242 of file multixact.c.

{
    /*
     * It's possible that the members span more than one page of the members
     * file, so we loop to ensure we consider each page.  The coding is not
     * optimal if the members span several pages, but that seems unusual
     * enough to not worry much about.
     */
    while (nmembers > 0)
    {
        int         flagsoff;
        int         flagsbit;
        uint32      difference;
 
        /*
         * Only zero when at first entry of a page.
         */
        flagsoff = MXOffsetToFlagsOffset(offset);
        flagsbit = MXOffsetToFlagsBitShift(offset);
        if (flagsoff == 0 && flagsbit == 0)
        {
            int64       pageno;
            LWLock     *lock;
 
            pageno = MXOffsetToMemberPage(offset);
            lock = SimpleLruGetBankLock(MultiXactMemberCtl, pageno);
 
            LWLockAcquire(lock, LW_EXCLUSIVE);
 
            /* Zero the page and make a WAL entry about it */
            SimpleLruZeroPage(MultiXactMemberCtl, pageno);
            XLogSimpleInsertInt64(RM_MULTIXACT_ID,
                                  XLOG_MULTIXACT_ZERO_MEM_PAGE, pageno);
 
            LWLockRelease(lock);
        }
 
        /* Compute the number of items till end of current page. */
        difference = MULTIXACT_MEMBERS_PER_PAGE - offset % MULTIXACT_MEMBERS_PER_PAGE;
 
        /*
         * Advance to next page.  OK if nmembers goes negative.
         */
        nmembers -= difference;
        offset += difference;
    }
}

References difference(), fb(), LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MULTIXACT_MEMBERS_PER_PAGE, MultiXactMemberCtl, MXOffsetToFlagsBitShift(), MXOffsetToFlagsOffset(), MXOffsetToMemberPage(), SimpleLruGetBankLock(), SimpleLruZeroPage(), XLOG_MULTIXACT_ZERO_MEM_PAGE, and XLogSimpleInsertInt64().

Referenced by GetNewMultiXactId().

ExtendMultiXactOffset()

static void ExtendMultiXactOffset ( MultiXactId  multi )

static

Definition at line 2208 of file multixact.c.

{
    int64       pageno;
    LWLock     *lock;
 
    /*
     * No work except at first MultiXactId of a page.  But beware: just after
     * wraparound, the first MultiXactId of page zero is FirstMultiXactId.
     */
    if (MultiXactIdToOffsetEntry(multi) != 0 &&
        multi != FirstMultiXactId)
        return;
 
    pageno = MultiXactIdToOffsetPage(multi);
    lock = SimpleLruGetBankLock(MultiXactOffsetCtl, pageno);
 
    LWLockAcquire(lock, LW_EXCLUSIVE);
 
    /* Zero the page and make a WAL entry about it */
    SimpleLruZeroPage(MultiXactOffsetCtl, pageno);
    XLogSimpleInsertInt64(RM_MULTIXACT_ID, XLOG_MULTIXACT_ZERO_OFF_PAGE,
                          pageno);
 
    LWLockRelease(lock);
}

References fb(), FirstMultiXactId, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MultiXactIdToOffsetEntry(), MultiXactIdToOffsetPage(), MultiXactOffsetCtl, SimpleLruGetBankLock(), SimpleLruZeroPage(), XLOG_MULTIXACT_ZERO_OFF_PAGE, and XLogSimpleInsertInt64().

Referenced by GetNewMultiXactId().

find_multixact_start()

static bool find_multixact_start ( MultiXactId  multi, MultiXactOffset *  result  )

static

Definition at line 2424 of file multixact.c.

{
    MultiXactOffset offset;
    int64       pageno;
    int         entryno;
    int         slotno;
    MultiXactOffset *offptr;
 
    Assert(MultiXactState->finishedStartup);
 
    pageno = MultiXactIdToOffsetPage(multi);
    entryno = MultiXactIdToOffsetEntry(multi);
 
    /*
     * Write out dirty data, so PhysicalPageExists can work correctly.
     */
    SimpleLruWriteAll(MultiXactOffsetCtl, true);
    SimpleLruWriteAll(MultiXactMemberCtl, true);
 
    if (!SimpleLruDoesPhysicalPageExist(MultiXactOffsetCtl, pageno))
        return false;
 
    /* lock is acquired by SimpleLruReadPage_ReadOnly */
    slotno = SimpleLruReadPage_ReadOnly(MultiXactOffsetCtl, pageno, multi);
    offptr = (MultiXactOffset *) MultiXactOffsetCtl->shared->page_buffer[slotno];
    offptr += entryno;
    offset = *offptr;
    LWLockRelease(SimpleLruGetBankLock(MultiXactOffsetCtl, pageno));
 
    *result = offset;
    return true;
}

References Assert, fb(), MultiXactStateData::finishedStartup, LWLockRelease(), MultiXactIdToOffsetEntry(), MultiXactIdToOffsetPage(), MultiXactMemberCtl, MultiXactOffsetCtl, MultiXactState, SimpleLruDoesPhysicalPageExist(), SimpleLruGetBankLock(), SimpleLruReadPage_ReadOnly(), and SimpleLruWriteAll().

Referenced by SetOldestOffset(), and TruncateMultiXact().

GetMultiXactIdMembers()

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

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
	)

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().

GetNewMultiXactId()

static MultiXactId GetNewMultiXactId ( int  nmembers, MultiXactOffset *  offset  )

static

Definition at line 924 of file multixact.c.

{
    MultiXactId result;
    MultiXactOffset nextOffset;
 
    debug_elog3(DEBUG2, "GetNew: for %d xids", nmembers);
 
    /* safety check, we should never get this far in a HS standby */
    if (RecoveryInProgress())
        elog(ERROR, "cannot assign MultiXactIds during recovery");
 
    LWLockAcquire(MultiXactGenLock, LW_EXCLUSIVE);
 
    /* Assign the MXID */
    result = MultiXactState->nextMXact;
 
    /*----------
     * Check to see if it's safe to assign another MultiXactId.  This protects
     * against catastrophic data loss due to multixact wraparound.  The basic
     * rules are:
     *
     * If we're past multiVacLimit or the safe threshold for member storage
     * space, or we don't know what the safe threshold for member storage is,
     * start trying to force autovacuum cycles.
     * If we're past multiWarnLimit, start issuing warnings.
     * If we're past multiStopLimit, refuse to create new MultiXactIds.
     *
     * Note these are pretty much the same protections in GetNewTransactionId.
     *----------
     */
    if (!MultiXactIdPrecedes(result, MultiXactState->multiVacLimit))
    {
        /*
         * For safety's sake, we release MultiXactGenLock while sending
         * signals, warnings, etc.  This is not so much because we care about
         * preserving concurrency in this situation, as to avoid any
         * possibility of deadlock while doing get_database_name(). First,
         * copy all the shared values we'll need in this path.
         */
        MultiXactId multiWarnLimit = MultiXactState->multiWarnLimit;
        MultiXactId multiStopLimit = MultiXactState->multiStopLimit;
        MultiXactId multiWrapLimit = MultiXactState->multiWrapLimit;
        Oid         oldest_datoid = MultiXactState->oldestMultiXactDB;
 
        LWLockRelease(MultiXactGenLock);
 
        if (IsUnderPostmaster &&
            !MultiXactIdPrecedes(result, multiStopLimit))
        {
            char       *oldest_datname = get_database_name(oldest_datoid);
 
            /*
             * Immediately kick autovacuum into action as we're already in
             * ERROR territory.
             */
            SendPostmasterSignal(PMSIGNAL_START_AUTOVAC_LAUNCHER);
 
            /* complain even if that DB has disappeared */
            if (oldest_datname)
                ereport(ERROR,
                        (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                         errmsg("database is not accepting commands that assign new MultiXactIds to avoid wraparound data loss in database \"%s\"",
                                oldest_datname),
                         errhint("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(ERROR,
                        (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                         errmsg("database is not accepting commands that assign new MultiXactIds to avoid wraparound data loss in database with OID %u",
                                oldest_datoid),
                         errhint("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.")));
        }
 
        /*
         * To avoid swamping the postmaster with signals, we issue the autovac
         * request only once per 64K multis generated.  This still gives
         * plenty of chances before we get into real trouble.
         */
        if (IsUnderPostmaster && ((result % 65536) == 0 || result == FirstMultiXactId))
            SendPostmasterSignal(PMSIGNAL_START_AUTOVAC_LAUNCHER);
 
        if (!MultiXactIdPrecedes(result, multiWarnLimit))
        {
            char       *oldest_datname = get_database_name(oldest_datoid);
 
            /* complain even if that DB has disappeared */
            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 - result,
                                       oldest_datname,
                                       multiWrapLimit - result),
                         errhint("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 - result,
                                       oldest_datoid,
                                       multiWrapLimit - result),
                         errhint("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.")));
        }
 
        /* Re-acquire lock and start over */
        LWLockAcquire(MultiXactGenLock, LW_EXCLUSIVE);
        result = MultiXactState->nextMXact;
    }
 
    /*
     * Make sure there is room for the next MXID in the file.  Assigning this
     * MXID sets the next MXID's offset already.
     */
    ExtendMultiXactOffset(NextMultiXactId(result));
 
    /*
     * Reserve the members space, similarly to above.
     */
    nextOffset = MultiXactState->nextOffset;
 
    /*
     * Offsets are 64-bit integers and will never wrap around.  Firstly, it
     * would take an unrealistic amount of time and resources to consume 2^64
     * offsets.  Secondly, multixid creation is WAL-logged, so you would run
     * out of LSNs before reaching offset wraparound.  Nevertheless, check for
     * wraparound as a sanity check.
     */
    if (nextOffset + nmembers < nextOffset)
        ereport(ERROR,
                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                 errmsg("MultiXact members would wrap around")));
    *offset = nextOffset;
 
    ExtendMultiXactMember(nextOffset, nmembers);
 
    /*
     * Critical section from here until caller has written the data into the
     * just-reserved SLRU space; we don't want to error out with a partly
     * written MultiXact structure.  (In particular, failing to write our
     * start offset after advancing nextMXact would effectively corrupt the
     * previous MultiXact.)
     */
    START_CRIT_SECTION();
 
    /*
     * Advance counters.  As in GetNewTransactionId(), this must not happen
     * until after file extension has succeeded!
     */
    MultiXactState->nextMXact = NextMultiXactId(result);
    MultiXactState->nextOffset += nmembers;
 
    LWLockRelease(MultiXactGenLock);
 
    debug_elog4(DEBUG2, "GetNew: returning %u offset %" PRIu64,
                result, *offset);
    return result;
}

References DEBUG2, debug_elog3, debug_elog4, elog, ereport, errcode(), errhint(), errmsg(), errmsg_plural(), ERROR, ExtendMultiXactMember(), ExtendMultiXactOffset(), fb(), FirstMultiXactId, get_database_name(), IsUnderPostmaster, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MultiXactStateData::multiStopLimit, MultiXactStateData::multiVacLimit, MultiXactStateData::multiWarnLimit, MultiXactStateData::multiWrapLimit, MultiXactIdPrecedes(), MultiXactState, NextMultiXactId(), MultiXactStateData::nextMXact, MultiXactStateData::nextOffset, MultiXactStateData::oldestMultiXactDB, PMSIGNAL_START_AUTOVAC_LAUNCHER, RecoveryInProgress(), SendPostmasterSignal(), START_CRIT_SECTION, and WARNING.

Referenced by MultiXactIdCreateFromMembers().

GetOldestMultiXactId()

MultiXactId GetOldestMultiXactId

(

void

)

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_redo()

void multixact_redo

(

XLogReaderState *

record

)

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
	)

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
	)

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
	)

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
	)

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
	)

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
	)

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
	)

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
	)

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
	)

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
	)

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
	)

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
	)

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

)

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().

MultiXactIdSetOldestVisible()

static void MultiXactIdSetOldestVisible ( void  )

static

Definition at line 587 of file multixact.c.

{
    if (!MultiXactIdIsValid(OldestVisibleMXactId[MyProcNumber]))
    {
        MultiXactId oldestMXact;
        int         i;
 
        LWLockAcquire(MultiXactGenLock, LW_EXCLUSIVE);
 
        oldestMXact = MultiXactState->nextMXact;
        for (i = 0; i < MaxOldestSlot; i++)
        {
            MultiXactId thisoldest = OldestMemberMXactId[i];
 
            if (MultiXactIdIsValid(thisoldest) &&
                MultiXactIdPrecedes(thisoldest, oldestMXact))
                oldestMXact = thisoldest;
        }
 
        OldestVisibleMXactId[MyProcNumber] = oldestMXact;
 
        LWLockRelease(MultiXactGenLock);
 
        debug_elog4(DEBUG2, "MultiXact: setting OldestVisible[%d] = %u",
                    MyProcNumber, oldestMXact);
    }
}

References DEBUG2, debug_elog4, fb(), i, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MaxOldestSlot, MultiXactIdIsValid, MultiXactIdPrecedes(), MultiXactState, MyProcNumber, MultiXactStateData::nextMXact, OldestMemberMXactId, and OldestVisibleMXactId.

Referenced by GetMultiXactIdMembers().

MultiXactMemberFreezeThreshold()

int MultiXactMemberFreezeThreshold

(

void

)

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().

MultiXactMemberPagePrecedes()

static bool MultiXactMemberPagePrecedes ( int64  page1, int64  page2  )

static

Definition at line 2753 of file multixact.c.

{
    return page1 < page2;
}

References fb().

Referenced by MultiXactShmemInit().

multixactmemberssyncfiletag()

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

Definition at line 2921 of file multixact.c.

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

References MultiXactMemberCtl, and SlruSyncFileTag().

MultiXactOffsetPagePrecedes()

static bool MultiXactOffsetPagePrecedes ( int64  page1, int64  page2  )

static

Definition at line 2732 of file multixact.c.

{
    MultiXactId multi1;
    MultiXactId multi2;
 
    multi1 = ((MultiXactId) page1) * MULTIXACT_OFFSETS_PER_PAGE;
    multi1 += FirstMultiXactId + 1;
    multi2 = ((MultiXactId) page2) * MULTIXACT_OFFSETS_PER_PAGE;
    multi2 += FirstMultiXactId + 1;
 
    return (MultiXactIdPrecedes(multi1, multi2) &&
            MultiXactIdPrecedes(multi1,
                                multi2 + MULTIXACT_OFFSETS_PER_PAGE - 1));
}

References fb(), FirstMultiXactId, MULTIXACT_OFFSETS_PER_PAGE, and MultiXactIdPrecedes().

Referenced by MultiXactShmemInit().

multixactoffsetssyncfiletag()

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

Definition at line 2912 of file multixact.c.

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

References MultiXactOffsetCtl, and SlruSyncFileTag().

MultiXactSetNextMXact()

void MultiXactSetNextMXact	(	MultiXactId	nextMulti,
		MultiXactOffset	nextMultiOffset
	)

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

)

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

)

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().

mXactCacheGetById()

static int mXactCacheGetById ( MultiXactId  multi, MultiXactMember **  members  )

static

Definition at line 1422 of file multixact.c.

{
    dlist_iter  iter;
 
    debug_elog3(DEBUG2, "CacheGet: looking for %u", multi);
 
    dclist_foreach(iter, &MXactCache)
    {
        mXactCacheEnt *entry = dclist_container(mXactCacheEnt, node,
                                                iter.cur);
 
        if (entry->multi == multi)
        {
            MultiXactMember *ptr;
            Size        size;
 
            size = sizeof(MultiXactMember) * entry->nmembers;
            ptr = (MultiXactMember *) palloc(size);
 
            memcpy(ptr, entry->members, size);
 
            debug_elog3(DEBUG2, "CacheGet: found %s",
                        mxid_to_string(multi,
                                       entry->nmembers,
                                       entry->members));
 
            /*
             * Note we modify the list while not using a modifiable iterator.
             * This is acceptable only because we exit the iteration
             * immediately afterwards.
             */
            dclist_move_head(&MXactCache, iter.cur);
 
            *members = ptr;
            return entry->nmembers;
        }
    }
 
    debug_elog2(DEBUG2, "CacheGet: not found");
    return -1;
}

References dlist_iter::cur, dclist_container, dclist_foreach, dclist_move_head(), DEBUG2, debug_elog2, debug_elog3, fb(), mXactCacheEnt::members, mXactCacheEnt::multi, MXactCache, mxid_to_string(), mXactCacheEnt::nmembers, and palloc().

Referenced by GetMultiXactIdMembers().

mXactCacheGetBySet()

static MultiXactId mXactCacheGetBySet ( int  nmembers, MultiXactMember *  members  )

static

Definition at line 1379 of file multixact.c.

{
    dlist_iter  iter;
 
    debug_elog3(DEBUG2, "CacheGet: looking for %s",
                mxid_to_string(InvalidMultiXactId, nmembers, members));
 
    /* sort the array so comparison is easy */
    qsort(members, nmembers, sizeof(MultiXactMember), mxactMemberComparator);
 
    dclist_foreach(iter, &MXactCache)
    {
        mXactCacheEnt *entry = dclist_container(mXactCacheEnt, node,
                                                iter.cur);
 
        if (entry->nmembers != nmembers)
            continue;
 
        /*
         * We assume the cache entries are sorted, and that the unused bits in
         * "status" are zeroed.
         */
        if (memcmp(members, entry->members, nmembers * sizeof(MultiXactMember)) == 0)
        {
            debug_elog3(DEBUG2, "CacheGet: found %u", entry->multi);
            dclist_move_head(&MXactCache, iter.cur);
            return entry->multi;
        }
    }
 
    debug_elog2(DEBUG2, "CacheGet: not found :-(");
    return InvalidMultiXactId;
}

References dlist_iter::cur, dclist_container, dclist_foreach, dclist_move_head(), DEBUG2, debug_elog2, debug_elog3, fb(), InvalidMultiXactId, mXactCacheEnt::members, mXactCacheEnt::multi, MXactCache, mxactMemberComparator(), mxid_to_string(), mXactCacheEnt::nmembers, and qsort.

Referenced by MultiXactIdCreateFromMembers().

mXactCachePut()

static void mXactCachePut ( MultiXactId  multi, int  nmembers, MultiXactMember *  members  )

static

Definition at line 1469 of file multixact.c.

{
    mXactCacheEnt *entry;
 
    debug_elog3(DEBUG2, "CachePut: storing %s",
                mxid_to_string(multi, nmembers, members));
 
    if (MXactContext == NULL)
    {
        /* The cache only lives as long as the current transaction */
        debug_elog2(DEBUG2, "CachePut: initializing memory context");
        MXactContext = AllocSetContextCreate(TopTransactionContext,
                                             "MultiXact cache context",
                                             ALLOCSET_SMALL_SIZES);
    }
 
    entry = (mXactCacheEnt *)
        MemoryContextAlloc(MXactContext,
                           offsetof(mXactCacheEnt, members) +
                           nmembers * sizeof(MultiXactMember));
 
    entry->multi = multi;
    entry->nmembers = nmembers;
    memcpy(entry->members, members, nmembers * sizeof(MultiXactMember));
 
    /* mXactCacheGetBySet assumes the entries are sorted, so sort them */
    qsort(entry->members, nmembers, sizeof(MultiXactMember), mxactMemberComparator);
 
    dclist_push_head(&MXactCache, &entry->node);
    if (dclist_count(&MXactCache) > MAX_CACHE_ENTRIES)
    {
        dlist_node *node;
 
        node = dclist_tail_node(&MXactCache);
        dclist_delete_from(&MXactCache, node);
 
        entry = dclist_container(mXactCacheEnt, node, node);
        debug_elog3(DEBUG2, "CachePut: pruning cached multi %u",
                    entry->multi);
 
        pfree(entry);
    }
}

References ALLOCSET_SMALL_SIZES, AllocSetContextCreate, dclist_container, dclist_count(), dclist_delete_from(), dclist_push_head(), dclist_tail_node(), DEBUG2, debug_elog2, debug_elog3, fb(), MAX_CACHE_ENTRIES, mXactCacheEnt::members, MemoryContextAlloc(), mXactCacheEnt::multi, MXactCache, MXactContext, mxactMemberComparator(), mxid_to_string(), mXactCacheEnt::nmembers, mXactCacheEnt::node, pfree(), qsort, and TopTransactionContext.

Referenced by GetMultiXactIdMembers(), and MultiXactIdCreateFromMembers().

mxactMemberComparator()

static int mxactMemberComparator ( const void *  arg1, const void *  arg2  )

static

Definition at line 1349 of file multixact.c.

{
    MultiXactMember member1 = *(const MultiXactMember *) arg1;
    MultiXactMember member2 = *(const MultiXactMember *) arg2;
 
    if (member1.xid > member2.xid)
        return 1;
    if (member1.xid < member2.xid)
        return -1;
    if (member1.status > member2.status)
        return 1;
    if (member1.status < member2.status)
        return -1;
    return 0;
}

References fb().

Referenced by mXactCacheGetBySet(), and mXactCachePut().

mxid_to_string()

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

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

)

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().

NextMultiXactId()

static MultiXactId NextMultiXactId ( MultiXactId  multi )

inlinestatic

Definition at line 102 of file multixact.c.

{
    return multi == MaxMultiXactId ? FirstMultiXactId : multi + 1;
}

References FirstMultiXactId, and MaxMultiXactId.

Referenced by GetMultiXactIdMembers(), GetNewMultiXactId(), multixact_redo(), and RecordNewMultiXact().

PerformMembersTruncation()

static void PerformMembersTruncation ( MultiXactOffset  newOldestOffset )

static

Definition at line 2564 of file multixact.c.

{
    SimpleLruTruncate(MultiXactMemberCtl,
                      MXOffsetToMemberPage(newOldestOffset));
}

References fb(), MultiXactMemberCtl, MXOffsetToMemberPage(), and SimpleLruTruncate().

Referenced by multixact_redo(), and TruncateMultiXact().

PerformOffsetsTruncation()

static void PerformOffsetsTruncation ( MultiXactId  newOldestMulti )

static

Definition at line 2574 of file multixact.c.

{
    /*
     * We step back one multixact to avoid passing a cutoff page that hasn't
     * been created yet in the rare case that oldestMulti would be the first
     * item on a page and oldestMulti == nextMulti.  In that case, if we
     * didn't subtract one, we'd trigger SimpleLruTruncate's wraparound
     * detection.
     */
    SimpleLruTruncate(MultiXactOffsetCtl,
                      MultiXactIdToOffsetPage(PreviousMultiXactId(newOldestMulti)));
}

References fb(), MultiXactIdToOffsetPage(), MultiXactOffsetCtl, PreviousMultiXactId(), and SimpleLruTruncate().

Referenced by multixact_redo(), and TruncateMultiXact().

PostPrepare_MultiXact()

void PostPrepare_MultiXact

(

FullTransactionId

fxid

)

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().

PreviousMultiXactId()

static MultiXactId PreviousMultiXactId ( MultiXactId  multi )

inlinestatic

Definition at line 108 of file multixact.c.

{
    return multi == FirstMultiXactId ? MaxMultiXactId : multi - 1;
}

References FirstMultiXactId, and MaxMultiXactId.

Referenced by PerformOffsetsTruncation().

ReadMultiXactIdRange()

void ReadMultiXactIdRange	(	MultiXactId *	oldest,
		MultiXactId *	next
	)

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

)

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().

RecordNewMultiXact()

static void RecordNewMultiXact ( MultiXactId  multi, MultiXactOffset  offset, int  nmembers, MultiXactMember *  members  )

static

Definition at line 757 of file multixact.c.

{
    int64       pageno;
    int64       prev_pageno;
    int         entryno;
    int         slotno;
    MultiXactOffset *offptr;
    MultiXactId next;
    int64       next_pageno;
    int         next_entryno;
    MultiXactOffset *next_offptr;
    MultiXactOffset next_offset;
    LWLock     *lock;
    LWLock     *prevlock = NULL;
 
    /* position of this multixid in the offsets SLRU area  */
    pageno = MultiXactIdToOffsetPage(multi);
    entryno = MultiXactIdToOffsetEntry(multi);
 
    /* position of the next multixid */
    next = NextMultiXactId(multi);
    next_pageno = MultiXactIdToOffsetPage(next);
    next_entryno = MultiXactIdToOffsetEntry(next);
 
    /*
     * Set the starting offset of this multixid's members.
     *
     * In the common case, it was already be set by the previous
     * RecordNewMultiXact call, as this was the next multixid of the previous
     * multixid.  But if multiple backends are generating multixids
     * concurrently, we might race ahead and get called before the previous
     * multixid.
     */
    lock = SimpleLruGetBankLock(MultiXactOffsetCtl, pageno);
    LWLockAcquire(lock, LW_EXCLUSIVE);
 
    /*
     * Note: we pass the MultiXactId to SimpleLruReadPage as the "transaction"
     * to complain about if there's any I/O error.  This is kinda bogus, but
     * since the errors will always give the full pathname, it should be clear
     * enough that a MultiXactId is really involved.  Perhaps someday we'll
     * take the trouble to generalize the slru.c error reporting code.
     */
    slotno = SimpleLruReadPage(MultiXactOffsetCtl, pageno, true, multi);
    offptr = (MultiXactOffset *) MultiXactOffsetCtl->shared->page_buffer[slotno];
    offptr += entryno;
 
    if (*offptr != offset)
    {
        /* should already be set to the correct value, or not at all */
        Assert(*offptr == 0);
        *offptr = offset;
        MultiXactOffsetCtl->shared->page_dirty[slotno] = true;
    }
 
    /*
     * Set the next multixid's offset to the end of this multixid's members.
     */
    if (next_pageno == pageno)
    {
        next_offptr = offptr + 1;
    }
    else
    {
        /* must be the first entry on the page */
        Assert(next_entryno == 0 || next == FirstMultiXactId);
 
        /* Swap the lock for a lock on the next page */
        LWLockRelease(lock);
        lock = SimpleLruGetBankLock(MultiXactOffsetCtl, next_pageno);
        LWLockAcquire(lock, LW_EXCLUSIVE);
 
        slotno = SimpleLruReadPage(MultiXactOffsetCtl, next_pageno, true, next);
        next_offptr = (MultiXactOffset *) MultiXactOffsetCtl->shared->page_buffer[slotno];
        next_offptr += next_entryno;
    }
 
    /* Like in GetNewMultiXactId(), skip over offset 0 */
    next_offset = offset + nmembers;
    if (next_offset == 0)
        next_offset = 1;
    if (*next_offptr != next_offset)
    {
        /* should already be set to the correct value, or not at all */
        Assert(*next_offptr == 0);
        *next_offptr = next_offset;
        MultiXactOffsetCtl->shared->page_dirty[slotno] = true;
    }
 
    /* Release MultiXactOffset SLRU lock. */
    LWLockRelease(lock);
 
    prev_pageno = -1;
 
    for (int i = 0; i < nmembers; i++, offset++)
    {
        TransactionId *memberptr;
        uint32     *flagsptr;
        uint32      flagsval;
        int         bshift;
        int         flagsoff;
        int         memberoff;
 
        Assert(members[i].status <= MultiXactStatusUpdate);
 
        pageno = MXOffsetToMemberPage(offset);
        memberoff = MXOffsetToMemberOffset(offset);
        flagsoff = MXOffsetToFlagsOffset(offset);
        bshift = MXOffsetToFlagsBitShift(offset);
 
        if (pageno != prev_pageno)
        {
            /*
             * MultiXactMember SLRU page is changed so check if this new page
             * fall into the different SLRU bank then release the old bank's
             * lock and acquire lock on the new bank.
             */
            lock = SimpleLruGetBankLock(MultiXactMemberCtl, pageno);
            if (lock != prevlock)
            {
                if (prevlock != NULL)
                    LWLockRelease(prevlock);
 
                LWLockAcquire(lock, LW_EXCLUSIVE);
                prevlock = lock;
            }
            slotno = SimpleLruReadPage(MultiXactMemberCtl, pageno, true, multi);
            prev_pageno = pageno;
        }
 
        memberptr = (TransactionId *)
            (MultiXactMemberCtl->shared->page_buffer[slotno] + memberoff);
 
        *memberptr = members[i].xid;
 
        flagsptr = (uint32 *)
            (MultiXactMemberCtl->shared->page_buffer[slotno] + flagsoff);
 
        flagsval = *flagsptr;
        flagsval &= ~(((1 << MXACT_MEMBER_BITS_PER_XACT) - 1) << bshift);
        flagsval |= (members[i].status << bshift);
        *flagsptr = flagsval;
 
        MultiXactMemberCtl->shared->page_dirty[slotno] = true;
    }
 
    if (prevlock != NULL)
        LWLockRelease(prevlock);
}

References Assert, fb(), FirstMultiXactId, i, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MultiXactIdToOffsetEntry(), MultiXactIdToOffsetPage(), MultiXactMemberCtl, MultiXactOffsetCtl, MultiXactStatusUpdate, MXACT_MEMBER_BITS_PER_XACT, MXOffsetToFlagsBitShift(), MXOffsetToFlagsOffset(), MXOffsetToMemberOffset(), MXOffsetToMemberPage(), next, NextMultiXactId(), SimpleLruGetBankLock(), SimpleLruReadPage(), MultiXactMember::status, and MultiXactMember::xid.

Referenced by multixact_redo(), and MultiXactIdCreateFromMembers().

SetMultiXactIdLimit()

void SetMultiXactIdLimit	(	MultiXactId	oldest_datminmxid,
		Oid	oldest_datoid
	)

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.")));
    }
}

References Assert, autovacuum_multixact_freeze_max_age, DEBUG1, ereport, 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().

SetOldestOffset()

static void SetOldestOffset ( void  )

static

Definition at line 2338 of file multixact.c.

{
    MultiXactId oldestMultiXactId;
    MultiXactId nextMXact;
    MultiXactOffset oldestOffset = 0;   /* placate compiler */
    MultiXactOffset nextOffset;
    bool        oldestOffsetKnown = false;
 
    /*
     * NB: Have to prevent concurrent truncation, we might otherwise try to
     * lookup an oldestMulti that's concurrently getting truncated away.
     */
    LWLockAcquire(MultiXactTruncationLock, LW_SHARED);
 
    /* Read relevant fields from shared memory. */
    LWLockAcquire(MultiXactGenLock, LW_SHARED);
    oldestMultiXactId = MultiXactState->oldestMultiXactId;
    nextMXact = MultiXactState->nextMXact;
    nextOffset = MultiXactState->nextOffset;
    Assert(MultiXactState->finishedStartup);
    LWLockRelease(MultiXactGenLock);
 
    /*
     * Determine the offset of the oldest multixact.  Normally, we can read
     * the offset from the multixact itself, but there's an important special
     * case: if there are no multixacts in existence at all, oldestMXact
     * obviously can't point to one.  It will instead point to the multixact
     * ID that will be assigned the next time one is needed.
     */
    if (oldestMultiXactId == nextMXact)
    {
        /*
         * When the next multixact gets created, it will be stored at the next
         * offset.
         */
        oldestOffset = nextOffset;
        oldestOffsetKnown = true;
    }
    else
    {
        /*
         * Look up the offset at which the oldest existing multixact's members
         * are stored.  If we cannot find it, be careful not to fail, and
         * leave oldestOffset unchanged.  oldestOffset is initialized to zero
         * at system startup, which prevents truncating members until a proper
         * value is calculated.
         *
         * (We had bugs in early releases of PostgreSQL 9.3.X and 9.4.X where
         * the supposedly-earliest multixact might not really exist.  Those
         * should be long gone by now, so this should not fail, but let's
         * still be defensive.)
         */
        oldestOffsetKnown =
            find_multixact_start(oldestMultiXactId, &oldestOffset);
 
        if (oldestOffsetKnown)
            ereport(DEBUG1,
                    (errmsg_internal("oldest MultiXactId member is at offset %" PRIu64,
                                     oldestOffset)));
        else
            ereport(LOG,
                    (errmsg("MultiXact member truncation is disabled because oldest checkpointed MultiXact %u does not exist on disk",
                            oldestMultiXactId)));
    }
 
    LWLockRelease(MultiXactTruncationLock);
 
    /* Install the computed value */
    if (oldestOffsetKnown)
    {
        LWLockAcquire(MultiXactGenLock, LW_EXCLUSIVE);
        MultiXactState->oldestOffset = oldestOffset;
        LWLockRelease(MultiXactGenLock);
    }
}

References Assert, DEBUG1, ereport, errmsg(), errmsg_internal(), fb(), find_multixact_start(), MultiXactStateData::finishedStartup, LOG, LW_EXCLUSIVE, LW_SHARED, LWLockAcquire(), LWLockRelease(), MultiXactState, MultiXactStateData::nextMXact, MultiXactStateData::nextOffset, MultiXactStateData::oldestMultiXactId, and MultiXactStateData::oldestOffset.

Referenced by SetMultiXactIdLimit().

StartupMultiXact()

void StartupMultiXact

(

void

)

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

)

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
	)

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().

WriteMTruncateXlogRec()

static void WriteMTruncateXlogRec ( Oid  oldestMultiDB, MultiXactId  endTruncOff, MultiXactOffset  endTruncMemb  )

static

Definition at line 2794 of file multixact.c.

{
    XLogRecPtr  recptr;
    xl_multixact_truncate xlrec;
 
    xlrec.oldestMultiDB = oldestMultiDB;
    xlrec.oldestMulti = oldestMulti;
    xlrec.oldestOffset = oldestOffset;
 
    XLogBeginInsert();
    XLogRegisterData(&xlrec, SizeOfMultiXactTruncate);
    recptr = XLogInsert(RM_MULTIXACT_ID, XLOG_MULTIXACT_TRUNCATE_ID);
    XLogFlush(recptr);
}

References fb(), xl_multixact_truncate::oldestMultiDB, SizeOfMultiXactTruncate, XLOG_MULTIXACT_TRUNCATE_ID, XLogBeginInsert(), XLogFlush(), XLogInsert(), and XLogRegisterData().

Referenced by TruncateMultiXact().

Variable Documentation

MultiXactMemberCtlData

SlruCtlData MultiXactMemberCtlData

static

Definition at line 117 of file multixact.c.

MultiXactOffsetCtlData

SlruCtlData MultiXactOffsetCtlData

static

Definition at line 116 of file multixact.c.

MultiXactState

MultiXactStateData* MultiXactState

static

Definition at line 216 of file multixact.c.

Referenced by find_multixact_start(), GetMultiXactIdMembers(), GetMultiXactInfo(), GetNewMultiXactId(), GetOldestMultiXactId(), MultiXactAdvanceNextMXact(), MultiXactAdvanceOldest(), MultiXactGetCheckptMulti(), MultiXactIdSetOldestMember(), MultiXactIdSetOldestVisible(), MultiXactSetNextMXact(), MultiXactShmemInit(), ReadMultiXactIdRange(), ReadNextMultiXactId(), SetMultiXactIdLimit(), SetOldestOffset(), StartupMultiXact(), TrimMultiXact(), and TruncateMultiXact().

MXactCache

dclist_head MXactCache = DCLIST_STATIC_INIT(MXactCache)

static

Definition at line 247 of file multixact.c.

Referenced by AtEOXact_MultiXact(), mXactCacheGetById(), mXactCacheGetBySet(), mXactCachePut(), and PostPrepare_MultiXact().

MXactContext

MemoryContext MXactContext = NULL

static

Definition at line 248 of file multixact.c.

Referenced by AtEOXact_MultiXact(), mXactCachePut(), and PostPrepare_MultiXact().

OldestMemberMXactId

MultiXactId* OldestMemberMXactId

static

Definition at line 217 of file multixact.c.

Referenced by AtEOXact_MultiXact(), AtPrepare_MultiXact(), GetOldestMultiXactId(), multixact_twophase_postcommit(), multixact_twophase_recover(), MultiXactIdCreate(), MultiXactIdExpand(), MultiXactIdSetOldestMember(), MultiXactIdSetOldestVisible(), MultiXactShmemInit(), and PostPrepare_MultiXact().

OldestVisibleMXactId

MultiXactId* OldestVisibleMXactId

static

Definition at line 218 of file multixact.c.

Referenced by AtEOXact_MultiXact(), GetMultiXactIdMembers(), GetOldestMultiXactId(), MultiXactIdSetOldestVisible(), MultiXactShmemInit(), and PostPrepare_MultiXact().