multixact.c File Reference

#include "postgres.h"
#include "access/multixact.h"
#include "access/slru.h"
#include "access/transam.h"
#include "access/twophase.h"
#include "access/twophase_rmgr.h"
#include "access/xact.h"
#include "access/xlog.h"
#include "access/xloginsert.h"
#include "catalog/pg_type.h"
#include "commands/dbcommands.h"
#include "funcapi.h"
#include "lib/ilist.h"
#include "miscadmin.h"
#include "pg_trace.h"
#include "postmaster/autovacuum.h"
#include "storage/lmgr.h"
#include "storage/pmsignal.h"
#include "storage/proc.h"
#include "storage/procarray.h"
#include "utils/builtins.h"
#include "utils/memutils.h"
#include "utils/snapmgr.h"

Include dependency graph for multixact.c:

Go to the source code of this file.

Data Structures
struct	MultiXactStateData
struct	mXactCacheEnt
struct	mxtruncinfo

Macros
#define	MULTIXACT_OFFSETS_PER_PAGE   (BLCKSZ / sizeof(MultiXactOffset))
#define	MultiXactIdToOffsetPage(xid)   ((xid) / (MultiXactOffset) MULTIXACT_OFFSETS_PER_PAGE)
#define	MultiXactIdToOffsetEntry(xid)   ((xid) % (MultiXactOffset) MULTIXACT_OFFSETS_PER_PAGE)
#define	MultiXactIdToOffsetSegment(xid)   (MultiXactIdToOffsetPage(xid) / SLRU_PAGES_PER_SEGMENT)
#define	MXACT_MEMBER_BITS_PER_XACT   8
#define	MXACT_MEMBER_FLAGS_PER_BYTE   1
#define	MXACT_MEMBER_XACT_BITMASK   ((1 << MXACT_MEMBER_BITS_PER_XACT) - 1)
#define	MULTIXACT_FLAGBYTES_PER_GROUP   4
#define	MULTIXACT_MEMBERS_PER_MEMBERGROUP   (MULTIXACT_FLAGBYTES_PER_GROUP * MXACT_MEMBER_FLAGS_PER_BYTE)
#define	MULTIXACT_MEMBERGROUP_SIZE   (sizeof(TransactionId) * MULTIXACT_MEMBERS_PER_MEMBERGROUP + MULTIXACT_FLAGBYTES_PER_GROUP)
#define	MULTIXACT_MEMBERGROUPS_PER_PAGE   (BLCKSZ / MULTIXACT_MEMBERGROUP_SIZE)
#define	MULTIXACT_MEMBERS_PER_PAGE   (MULTIXACT_MEMBERGROUPS_PER_PAGE * MULTIXACT_MEMBERS_PER_MEMBERGROUP)
#define	MAX_MEMBERS_IN_LAST_MEMBERS_PAGE   ((uint32) ((0xFFFFFFFF % MULTIXACT_MEMBERS_PER_PAGE) + 1))
#define	MXOffsetToMemberPage(xid)   ((xid) / (TransactionId) MULTIXACT_MEMBERS_PER_PAGE)
#define	MXOffsetToMemberSegment(xid)   (MXOffsetToMemberPage(xid) / SLRU_PAGES_PER_SEGMENT)
#define	MXOffsetToFlagsOffset(xid)
#define	MXOffsetToFlagsBitShift(xid)
#define	MXOffsetToMemberOffset(xid)
#define	MULTIXACT_MEMBER_SAFE_THRESHOLD   (MaxMultiXactOffset / 2)
#define	MULTIXACT_MEMBER_DANGER_THRESHOLD   (MaxMultiXactOffset - MaxMultiXactOffset / 4)
#define	PreviousMultiXactId(xid)   ((xid) == FirstMultiXactId ? MaxMultiXactId : (xid) - 1)
#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	OFFSET_WARN_SEGMENTS   20
#define	SHARED_MULTIXACT_STATE_SIZE

Typedefs
typedef struct MultiXactStateData	MultiXactStateData
typedef struct mXactCacheEnt	mXactCacheEnt
typedef struct mxtruncinfo	mxtruncinfo

Functions
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 char *	mxstatus_to_string (MultiXactStatus status)
static int	ZeroMultiXactOffsetPage (int pageno, bool writeXlog)
static int	ZeroMultiXactMemberPage (int pageno, bool writeXlog)
static bool	MultiXactOffsetPagePrecedes (int page1, int page2)
static bool	MultiXactMemberPagePrecedes (int page1, int page2)
static bool	MultiXactOffsetPrecedes (MultiXactOffset offset1, MultiXactOffset offset2)
static void	ExtendMultiXactOffset (MultiXactId multi)
static void	ExtendMultiXactMember (MultiXactOffset offset, int nmembers)
static bool	MultiXactOffsetWouldWrap (MultiXactOffset boundary, MultiXactOffset start, uint32 distance)
static bool	SetOffsetVacuumLimit (bool is_startup)
static bool	find_multixact_start (MultiXactId multi, MultiXactOffset *result)
static void	WriteMZeroPageXlogRec (int pageno, uint8 info)
static void	WriteMTruncateXlogRec (Oid oldestMultiDB, MultiXactId startOff, MultiXactId endOff, MultiXactOffset startMemb, MultiXactOffset endMemb)
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)
MultiXactId	MultiXactIdCreateFromMembers (int nmembers, MultiXactMember *members)
int	GetMultiXactIdMembers (MultiXactId multi, MultiXactMember **members, bool from_pgupgrade, bool onlyLock)
char *	mxid_to_string (MultiXactId multi, int nmembers, MultiXactMember *members)
void	AtEOXact_MultiXact (void)
void	AtPrepare_MultiXact (void)
void	PostPrepare_MultiXact (TransactionId xid)
void	multixact_twophase_recover (TransactionId xid, uint16 info, void *recdata, uint32 len)
void	multixact_twophase_postcommit (TransactionId xid, uint16 info, void *recdata, uint32 len)
void	multixact_twophase_postabort (TransactionId xid, uint16 info, void *recdata, uint32 len)
Size	MultiXactShmemSize (void)
void	MultiXactShmemInit (void)
void	BootStrapMultiXact (void)
static void	MaybeExtendOffsetSlru (void)
void	StartupMultiXact (void)
void	TrimMultiXact (void)
void	ShutdownMultiXact (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, bool is_startup)
void	MultiXactAdvanceNextMXact (MultiXactId minMulti, MultiXactOffset minMultiOffset)
void	MultiXactAdvanceOldest (MultiXactId oldestMulti, Oid oldestMultiDB)
MultiXactId	GetOldestMultiXactId (void)
static bool	ReadMultiXactCounts (uint32 *multixacts, MultiXactOffset *members)
int	MultiXactMemberFreezeThreshold (void)
static bool	SlruScanDirCbFindEarliest (SlruCtl ctl, char *filename, int segpage, void *data)
static void	PerformMembersTruncation (MultiXactOffset oldestOffset, MultiXactOffset newOldestOffset)
static void	PerformOffsetsTruncation (MultiXactId oldestMulti, 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)
Datum	pg_get_multixact_members (PG_FUNCTION_ARGS)

Variables
static SlruCtlData	MultiXactOffsetCtlData
static SlruCtlData	MultiXactMemberCtlData
static MultiXactStateData *	MultiXactState
static MultiXactId *	OldestMemberMXactId
static MultiXactId *	OldestVisibleMXactId
static dlist_head	MXactCache = DLIST_STATIC_INIT(MXactCache)
static int	MXactCacheMembers = 0
static MemoryContext	MXactContext = NULL

Macro Definition Documentation

#define debug_elog2	(		a,
			b
	)

Definition at line 333 of file multixact.c.

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

#define debug_elog3	(		a,
			b,
			c
	)

Definition at line 334 of file multixact.c.

Referenced by GetMultiXactIdMembers(), GetNewMultiXactId(), MultiXactAdvanceNextMXact(), MultiXactIdCreate(), MultiXactIdCreateFromMembers(), MultiXactIdExpand(), MultiXactIdIsRunning(), mXactCacheGetById(), mXactCacheGetBySet(), and mXactCachePut().

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

Definition at line 335 of file multixact.c.

Referenced by GetNewMultiXactId(), MultiXactIdExpand(), MultiXactIdIsRunning(), MultiXactIdSetOldestMember(), MultiXactIdSetOldestVisible(), and MultiXactSetNextMXact().

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

Definition at line 336 of file multixact.c.

Referenced by MultiXactIdExpand().

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

Definition at line 337 of file multixact.c.

Referenced by MultiXactGetCheckptMulti().

#define MAX_CACHE_ENTRIES   256

Definition at line 321 of file multixact.c.

Referenced by mXactCachePut().

#define MAX_MEMBERS_IN_LAST_MEMBERS_PAGE   ((uint32) ((0xFFFFFFFF % MULTIXACT_MEMBERS_PER_PAGE) + 1))

Definition at line 155 of file multixact.c.

Referenced by ExtendMultiXactMember().

#define MaxOldestSlot   (MaxBackends + max_prepared_xacts)

Definition at line 288 of file multixact.c.

Referenced by GetOldestMultiXactId(), MultiXactIdSetOldestVisible(), and MultiXactShmemInit().

#define MULTIXACT_FLAGBYTES_PER_GROUP   4

Definition at line 135 of file multixact.c.

#define MULTIXACT_MEMBER_DANGER_THRESHOLD   (MaxMultiXactOffset - MaxMultiXactOffset / 4)

Definition at line 178 of file multixact.c.

Referenced by MultiXactMemberFreezeThreshold().

#define MULTIXACT_MEMBER_SAFE_THRESHOLD   (MaxMultiXactOffset / 2)

Definition at line 177 of file multixact.c.

Referenced by GetNewMultiXactId(), MultiXactMemberFreezeThreshold(), and SetOffsetVacuumLimit().

#define MULTIXACT_MEMBERGROUP_SIZE   (sizeof(TransactionId) * MULTIXACT_MEMBERS_PER_MEMBERGROUP + MULTIXACT_FLAGBYTES_PER_GROUP)

Definition at line 139 of file multixact.c.

#define MULTIXACT_MEMBERGROUPS_PER_PAGE   (BLCKSZ / MULTIXACT_MEMBERGROUP_SIZE)

Definition at line 141 of file multixact.c.

#define MULTIXACT_MEMBERS_PER_MEMBERGROUP   (MULTIXACT_FLAGBYTES_PER_GROUP * MXACT_MEMBER_FLAGS_PER_BYTE)

Definition at line 136 of file multixact.c.

#define MULTIXACT_MEMBERS_PER_PAGE   (MULTIXACT_MEMBERGROUPS_PER_PAGE * MULTIXACT_MEMBERS_PER_MEMBERGROUP)

Definition at line 142 of file multixact.c.

Referenced by ExtendMultiXactMember(), GetNewMultiXactId(), MultiXactMemberPagePrecedes(), and SetOffsetVacuumLimit().

#define MULTIXACT_OFFSETS_PER_PAGE   (BLCKSZ / sizeof(MultiXactOffset))

Definition at line 109 of file multixact.c.

Referenced by MultiXactOffsetPagePrecedes(), and TruncateMultiXact().

#define MultiXactIdToOffsetEntry

(

xid

)

((xid) % (MultiXactOffset) MULTIXACT_OFFSETS_PER_PAGE)

Definition at line 113 of file multixact.c.

Referenced by ExtendMultiXactOffset(), find_multixact_start(), GetMultiXactIdMembers(), RecordNewMultiXact(), and TrimMultiXact().

#define MultiXactIdToOffsetPage

(

xid

)

((xid) / (MultiXactOffset) MULTIXACT_OFFSETS_PER_PAGE)

Definition at line 111 of file multixact.c.

Referenced by ExtendMultiXactOffset(), find_multixact_start(), GetMultiXactIdMembers(), MaybeExtendOffsetSlru(), multixact_redo(), PerformOffsetsTruncation(), RecordNewMultiXact(), StartupMultiXact(), and TrimMultiXact().

#define MultiXactIdToOffsetSegment

(

xid

)

(MultiXactIdToOffsetPage(xid) / SLRU_PAGES_PER_SEGMENT)

Definition at line 115 of file multixact.c.

Referenced by multixact_redo(), and TruncateMultiXact().

#define MultiXactMemberCtl   (&MultiXactMemberCtlData)

Definition at line 191 of file multixact.c.

Referenced by BootStrapMultiXact(), CheckPointMultiXact(), find_multixact_start(), GetMultiXactIdMembers(), multixact_redo(), MultiXactShmemInit(), PerformMembersTruncation(), RecordNewMultiXact(), ShutdownMultiXact(), StartupMultiXact(), TrimMultiXact(), and ZeroMultiXactMemberPage().

#define MultiXactOffsetCtl   (&MultiXactOffsetCtlData)

Definition at line 190 of file multixact.c.

Referenced by BootStrapMultiXact(), CheckPointMultiXact(), find_multixact_start(), GetMultiXactIdMembers(), MaybeExtendOffsetSlru(), multixact_redo(), MultiXactShmemInit(), PerformOffsetsTruncation(), RecordNewMultiXact(), ShutdownMultiXact(), StartupMultiXact(), TrimMultiXact(), TruncateMultiXact(), and ZeroMultiXactOffsetPage().

#define MXACT_MEMBER_BITS_PER_XACT   8

Definition at line 130 of file multixact.c.

Referenced by RecordNewMultiXact().

#define MXACT_MEMBER_FLAGS_PER_BYTE   1

Definition at line 131 of file multixact.c.

#define MXACT_MEMBER_XACT_BITMASK   ((1 << MXACT_MEMBER_BITS_PER_XACT) - 1)

Definition at line 132 of file multixact.c.

Referenced by GetMultiXactIdMembers().

#define MXOffsetToFlagsBitShift

(

xid

)

Value:

(((xid) % (TransactionId) MULTIXACT_MEMBERS_PER_MEMBERGROUP) * \
     MXACT_MEMBER_BITS_PER_XACT)

Definition at line 167 of file multixact.c.

Referenced by ExtendMultiXactMember(), GetMultiXactIdMembers(), and RecordNewMultiXact().

#define MXOffsetToFlagsOffset

(

xid

)

Value:

((((xid) / (TransactionId) MULTIXACT_MEMBERS_PER_MEMBERGROUP) % \
      (TransactionId) MULTIXACT_MEMBERGROUPS_PER_PAGE) * \
     (TransactionId) MULTIXACT_MEMBERGROUP_SIZE)

Definition at line 163 of file multixact.c.

Referenced by ExtendMultiXactMember(), GetMultiXactIdMembers(), RecordNewMultiXact(), and TrimMultiXact().

#define MXOffsetToMemberOffset

(

xid

)

Value:

(MXOffsetToFlagsOffset(xid) + MULTIXACT_FLAGBYTES_PER_GROUP + \
     ((xid) % MULTIXACT_MEMBERS_PER_MEMBERGROUP) * sizeof(TransactionId))

Definition at line 172 of file multixact.c.

Referenced by GetMultiXactIdMembers(), RecordNewMultiXact(), and TrimMultiXact().

#define MXOffsetToMemberPage

(

xid

)

((xid) / (TransactionId) MULTIXACT_MEMBERS_PER_PAGE)

Definition at line 159 of file multixact.c.

Referenced by ExtendMultiXactMember(), GetMultiXactIdMembers(), GetNewMultiXactId(), RecordNewMultiXact(), StartupMultiXact(), and TrimMultiXact().

#define MXOffsetToMemberSegment

(

xid

)

(MXOffsetToMemberPage(xid) / SLRU_PAGES_PER_SEGMENT)

Definition at line 160 of file multixact.c.

Referenced by multixact_redo(), PerformMembersTruncation(), and TruncateMultiXact().

#define OFFSET_WARN_SEGMENTS   20

Referenced by GetNewMultiXactId().

#define PreviousMultiXactId

(

xid

)

((xid) == FirstMultiXactId ? MaxMultiXactId : (xid) - 1)

Definition at line 181 of file multixact.c.

Referenced by PerformOffsetsTruncation().

#define SHARED_MULTIXACT_STATE_SIZE

Value:

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

Referenced by MultiXactShmemInit(), and MultiXactShmemSize().

Typedef Documentation

typedef struct MultiXactStateData MultiXactStateData

typedef struct mXactCacheEnt mXactCacheEnt

typedef struct mxtruncinfo mxtruncinfo

Function Documentation

void AtEOXact_MultiXact

(

void

)

Definition at line 1662 of file multixact.c.

References dlist_init(), InvalidMultiXactId, MXactCacheMembers, MyBackendId, NULL, OldestMemberMXactId, and OldestVisibleMXactId.

Referenced by AbortTransaction(), and CommitTransaction().

{
    /*
     * 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[MyBackendId] = InvalidMultiXactId;
    OldestVisibleMXactId[MyBackendId] = InvalidMultiXactId;

    /*
     * Discard the local MultiXactId cache.  Since MXactContext was created as
     * a child of TopTransactionContext, we needn't delete it explicitly.
     */
    MXactContext = NULL;
    dlist_init(&MXactCache);
    MXactCacheMembers = 0;
}

void AtPrepare_MultiXact

(

void

)

Definition at line 1691 of file multixact.c.

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

Referenced by PrepareTransaction().

{
    MultiXactId myOldestMember = OldestMemberMXactId[MyBackendId];

    if (MultiXactIdIsValid(myOldestMember))
        RegisterTwoPhaseRecord(TWOPHASE_RM_MULTIXACT_ID, 0,
                               &myOldestMember, sizeof(MultiXactId));
}

void BootStrapMultiXact

(

void

)

Definition at line 1866 of file multixact.c.

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

Referenced by BootStrapXLOG().

{
    int         slotno;

    LWLockAcquire(MultiXactOffsetControlLock, LW_EXCLUSIVE);

    /* Create and zero the first page of the offsets log */
    slotno = ZeroMultiXactOffsetPage(0, false);

    /* Make sure it's written out */
    SimpleLruWritePage(MultiXactOffsetCtl, slotno);
    Assert(!MultiXactOffsetCtl->shared->page_dirty[slotno]);

    LWLockRelease(MultiXactOffsetControlLock);

    LWLockAcquire(MultiXactMemberControlLock, LW_EXCLUSIVE);

    /* Create and zero the first page of the members log */
    slotno = ZeroMultiXactMemberPage(0, false);

    /* Make sure it's written out */
    SimpleLruWritePage(MultiXactMemberCtl, slotno);
    Assert(!MultiXactMemberCtl->shared->page_dirty[slotno]);

    LWLockRelease(MultiXactMemberControlLock);
}

void CheckPointMultiXact

(

void

)

Definition at line 2140 of file multixact.c.

References MultiXactMemberCtl, MultiXactOffsetCtl, and SimpleLruFlush().

Referenced by CheckPointGuts().

{
    TRACE_POSTGRESQL_MULTIXACT_CHECKPOINT_START(true);

    /* Flush dirty MultiXact pages to disk */
    SimpleLruFlush(MultiXactOffsetCtl, true);
    SimpleLruFlush(MultiXactMemberCtl, true);

    TRACE_POSTGRESQL_MULTIXACT_CHECKPOINT_DONE(true);
}

static void ExtendMultiXactMember ( MultiXactOffset  offset, int  nmembers  )

static

Definition at line 2419 of file multixact.c.

References difference(), LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MAX_MEMBERS_IN_LAST_MEMBERS_PAGE, MaxMultiXactOffset, MULTIXACT_MEMBERS_PER_PAGE, MXOffsetToFlagsBitShift, MXOffsetToFlagsOffset, MXOffsetToMemberPage, and ZeroMultiXactMemberPage().

Referenced by GetNewMultiXactId().

{
    /*
     * 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)
        {
            int         pageno;

            pageno = MXOffsetToMemberPage(offset);

            LWLockAcquire(MultiXactMemberControlLock, LW_EXCLUSIVE);

            /* Zero the page and make an XLOG entry about it */
            ZeroMultiXactMemberPage(pageno, true);

            LWLockRelease(MultiXactMemberControlLock);
        }

        /*
         * Compute the number of items till end of current page.  Careful: if
         * addition of unsigned ints wraps around, we're at the last page of
         * the last segment; since that page holds a different number of items
         * than other pages, we need to do it differently.
         */
        if (offset + MAX_MEMBERS_IN_LAST_MEMBERS_PAGE < offset)
        {
            /*
             * This is the last page of the last segment; we can compute the
             * number of items left to allocate in it without modulo
             * arithmetic.
             */
            difference = MaxMultiXactOffset - offset + 1;
        }
        else
            difference = MULTIXACT_MEMBERS_PER_PAGE - offset % MULTIXACT_MEMBERS_PER_PAGE;

        /*
         * Advance to next page, taking care to properly handle the wraparound
         * case.  OK if nmembers goes negative.
         */
        nmembers -= difference;
        offset += difference;
    }
}

static void ExtendMultiXactOffset ( MultiXactId  multi )

static

Definition at line 2389 of file multixact.c.

References FirstMultiXactId, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MultiXactIdToOffsetEntry, MultiXactIdToOffsetPage, and ZeroMultiXactOffsetPage().

Referenced by GetNewMultiXactId().

{
    int         pageno;

    /*
     * 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);

    LWLockAcquire(MultiXactOffsetControlLock, LW_EXCLUSIVE);

    /* Zero the page and make an XLOG entry about it */
    ZeroMultiXactOffsetPage(pageno, true);

    LWLockRelease(MultiXactOffsetControlLock);
}

static bool find_multixact_start ( MultiXactId  multi, MultiXactOffset *  result  )

static

Definition at line 2719 of file multixact.c.

References Assert, MultiXactStateData::finishedStartup, LWLockRelease(), MultiXactIdToOffsetEntry, MultiXactIdToOffsetPage, MultiXactMemberCtl, MultiXactOffsetCtl, SimpleLruDoesPhysicalPageExist(), SimpleLruFlush(), and SimpleLruReadPage_ReadOnly().

Referenced by SetOffsetVacuumLimit(), and TruncateMultiXact().

{
    MultiXactOffset offset;
    int         pageno;
    int         entryno;
    int         slotno;
    MultiXactOffset *offptr;

    Assert(MultiXactState->finishedStartup);

    pageno = MultiXactIdToOffsetPage(multi);
    entryno = MultiXactIdToOffsetEntry(multi);

    /*
     * Flush out dirty data, so PhysicalPageExists can work correctly.
     * SimpleLruFlush() is a pretty big hammer for that.  Alternatively we
     * could add a in-memory version of page exists, but find_multixact_start
     * is called infrequently, and it doesn't seem bad to flush buffers to
     * disk before truncation.
     */
    SimpleLruFlush(MultiXactOffsetCtl, true);
    SimpleLruFlush(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(MultiXactOffsetControlLock);

    *result = offset;
    return true;
}

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

Definition at line 1202 of file multixact.c.

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

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

{
    int         pageno;
    int         prev_pageno;
    int         entryno;
    int         slotno;
    MultiXactOffset *offptr;
    MultiXactOffset offset;
    int         length;
    int         truelength;
    int         i;
    MultiXactId oldestMXact;
    MultiXactId nextMXact;
    MultiXactId tmpMXact;
    MultiXactOffset nextOffset;
    MultiXactMember *ptr;

    debug_elog3(DEBUG2, "GetMembers: asked for %u", multi);

    if (!MultiXactIdIsValid(multi) || from_pgupgrade)
        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 (onlyLock &&
        MultiXactIdPrecedes(multi, OldestVisibleMXactId[MyBackendId]))
    {
        debug_elog2(DEBUG2, "GetMembers: a locker-only multi is too old");
        *members = NULL;
        return -1;
    }

    /*
     * We check known limits on MultiXact before resorting to the SLRU area.
     *
     * An ID older than MultiXactState->oldestMultiXactId cannot possibly be
     * useful; it has already been removed, or will be removed shortly, by
     * truncation.  If one is passed, an error is raised.
     *
     * Also, an ID >= nextMXact shouldn't ever be seen here; if it is seen, it
     * implies undetected ID wraparound has occurred.  This raises a hard
     * error.
     *
     * Shared lock is enough here since we aren't modifying any global state.
     * Acquire it just long enough to grab the current counter values.  We may
     * need both nextMXact and nextOffset; see below.
     */
    LWLockAcquire(MultiXactGenLock, LW_SHARED);

    oldestMXact = MultiXactState->oldestMultiXactId;
    nextMXact = MultiXactState->nextMXact;
    nextOffset = MultiXactState->nextOffset;

    LWLockRelease(MultiXactGenLock);

    if (MultiXactIdPrecedes(multi, oldestMXact))
    {
        ereport(ERROR,
                (errcode(ERRCODE_INTERNAL_ERROR),
                 errmsg("MultiXactId %u does no longer exist -- apparent wraparound",
                        multi)));
        return -1;
    }

    if (!MultiXactIdPrecedes(multi, nextMXact))
        ereport(ERROR,
                (errcode(ERRCODE_INTERNAL_ERROR),
                 errmsg("MultiXactId %u has not been created yet -- apparent wraparound",
                        multi)));

    /*
     * Find out the offset at which we need to start reading MultiXactMembers
     * and the number of members in the multixact.  We determine the latter as
     * the difference between this multixact's starting offset and the next
     * one's.  However, there are some corner cases to worry about:
     *
     * 1. This multixact may be the latest one created, in which case there is
     * no next one to look at.  In this case the nextOffset value we just
     * saved is the correct endpoint.
     *
     * 2. The next multixact may still be in process of being filled in: that
     * is, another process may have done GetNewMultiXactId but not yet written
     * the offset entry for that ID.  In that scenario, it is guaranteed that
     * the offset entry for that multixact exists (because GetNewMultiXactId
     * won't release MultiXactGenLock until it does) but contains zero
     * (because we are careful to pre-zero offset pages). Because
     * GetNewMultiXactId will never return zero as the starting offset for a
     * multixact, when we read zero as the next multixact's offset, we know we
     * have this case.  We sleep for a bit and try again.
     *
     * 3. Because GetNewMultiXactId increments offset zero to offset one to
     * handle case #2, there is an ambiguity near the point of offset
     * wraparound.  If we see next multixact's offset is one, is that our
     * multixact's actual endpoint, or did it end at zero with a subsequent
     * increment?  We handle this using the knowledge that if the zero'th
     * member slot wasn't filled, it'll contain zero, and zero isn't a valid
     * transaction ID so it can't be a multixact member.  Therefore, if we
     * read a zero from the members array, just ignore it.
     *
     * This is all pretty messy, but the mess occurs only in infrequent corner
     * cases, so it seems better than holding the MultiXactGenLock for a long
     * time on every multixact creation.
     */
retry:
    LWLockAcquire(MultiXactOffsetControlLock, LW_EXCLUSIVE);

    pageno = MultiXactIdToOffsetPage(multi);
    entryno = MultiXactIdToOffsetEntry(multi);

    slotno = SimpleLruReadPage(MultiXactOffsetCtl, pageno, true, multi);
    offptr = (MultiXactOffset *) MultiXactOffsetCtl->shared->page_buffer[slotno];
    offptr += entryno;
    offset = *offptr;

    Assert(offset != 0);

    /*
     * Use the same increment rule as GetNewMultiXactId(), that is, don't
     * handle wraparound explicitly until needed.
     */
    tmpMXact = multi + 1;

    if (nextMXact == tmpMXact)
    {
        /* Corner case 1: there is no next multixact */
        length = nextOffset - offset;
    }
    else
    {
        MultiXactOffset nextMXOffset;

        /* handle wraparound if needed */
        if (tmpMXact < FirstMultiXactId)
            tmpMXact = FirstMultiXactId;

        prev_pageno = pageno;

        pageno = MultiXactIdToOffsetPage(tmpMXact);
        entryno = MultiXactIdToOffsetEntry(tmpMXact);

        if (pageno != prev_pageno)
            slotno = SimpleLruReadPage(MultiXactOffsetCtl, pageno, true, tmpMXact);

        offptr = (MultiXactOffset *) MultiXactOffsetCtl->shared->page_buffer[slotno];
        offptr += entryno;
        nextMXOffset = *offptr;

        if (nextMXOffset == 0)
        {
            /* Corner case 2: next multixact is still being filled in */
            LWLockRelease(MultiXactOffsetControlLock);
            CHECK_FOR_INTERRUPTS();
            pg_usleep(1000L);
            goto retry;
        }

        length = nextMXOffset - offset;
    }

    LWLockRelease(MultiXactOffsetControlLock);

    ptr = (MultiXactMember *) palloc(length * sizeof(MultiXactMember));
    *members = ptr;

    /* Now get the members themselves. */
    LWLockAcquire(MultiXactMemberControlLock, LW_EXCLUSIVE);

    truelength = 0;
    prev_pageno = -1;
    for (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)
        {
            slotno = SimpleLruReadPage(MultiXactMemberCtl, pageno, true, multi);
            prev_pageno = pageno;
        }

        xactptr = (TransactionId *)
            (MultiXactMemberCtl->shared->page_buffer[slotno] + memberoff);

        if (!TransactionIdIsValid(*xactptr))
        {
            /* Corner case 3: we must be looking at unused slot zero */
            Assert(offset == 0);
            continue;
        }

        flagsoff = MXOffsetToFlagsOffset(offset);
        bshift = MXOffsetToFlagsBitShift(offset);
        flagsptr = (uint32 *) (MultiXactMemberCtl->shared->page_buffer[slotno] + flagsoff);

        ptr[truelength].xid = *xactptr;
        ptr[truelength].status = (*flagsptr >> bshift) & MXACT_MEMBER_XACT_BITMASK;
        truelength++;
    }

    LWLockRelease(MultiXactMemberControlLock);

    /*
     * Copy the result into the local cache.
     */
    mXactCachePut(multi, truelength, ptr);

    debug_elog3(DEBUG2, "GetMembers: no cache for %s",
                mxid_to_string(multi, truelength, ptr));
    return truelength;
}

static MultiXactId GetNewMultiXactId ( int  nmembers, MultiXactOffset *  offset  )

static

Definition at line 935 of file multixact.c.

References DEBUG2, debug_elog3, debug_elog4, elog, ereport, errcode(), errdetail_plural(), errhint(), errmsg(), errmsg_plural(), ERROR, ExtendMultiXactMember(), ExtendMultiXactOffset(), FirstMultiXactId, get_database_name(), IsUnderPostmaster, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MultiXactStateData::multiStopLimit, MultiXactStateData::multiVacLimit, MultiXactStateData::multiWarnLimit, MultiXactStateData::multiWrapLimit, MULTIXACT_MEMBER_SAFE_THRESHOLD, MULTIXACT_MEMBERS_PER_PAGE, MultiXactIdPrecedes(), MultiXactOffsetWouldWrap(), MXOffsetToMemberPage, MultiXactStateData::nextMXact, MultiXactStateData::nextOffset, OFFSET_WARN_SEGMENTS, MultiXactStateData::offsetStopLimit, MultiXactStateData::oldestMultiXactDB, MultiXactStateData::oldestOffset, MultiXactStateData::oldestOffsetKnown, PMSIGNAL_START_AUTOVAC_LAUNCHER, RecoveryInProgress(), result, SendPostmasterSignal(), SLRU_PAGES_PER_SEGMENT, START_CRIT_SECTION, and WARNING.

Referenced by MultiXactIdCreateFromMembers().

{
    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);

    /* Handle wraparound of the nextMXact counter */
    if (MultiXactState->nextMXact < FirstMultiXactId)
        MultiXactState->nextMXact = FirstMultiXactId;

    /* 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 generate 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.")));
            else
                ereport(ERROR,
                        (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                         errmsg("database is not accepting commands that generate 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.")));
        }

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

        /* Re-acquire lock and start over */
        LWLockAcquire(MultiXactGenLock, LW_EXCLUSIVE);
        result = MultiXactState->nextMXact;
        if (result < FirstMultiXactId)
            result = FirstMultiXactId;
    }

    /* Make sure there is room for the MXID in the file.  */
    ExtendMultiXactOffset(result);

    /*
     * Reserve the members space, similarly to above.  Also, be careful not to
     * return zero as the starting offset for any multixact. See
     * GetMultiXactIdMembers() for motivation.
     */
    nextOffset = MultiXactState->nextOffset;
    if (nextOffset == 0)
    {
        *offset = 1;
        nmembers++;             /* allocate member slot 0 too */
    }
    else
        *offset = nextOffset;

    /*----------
     * Protect against overrun of the members space as well, with the
     * following rules:
     *
     * If we're past offsetStopLimit, refuse to generate more multis.
     * If we're close to offsetStopLimit, emit a warning.
     *
     * Arbitrarily, we start emitting warnings when we're 20 segments or less
     * from offsetStopLimit.
     *
     * Note we haven't updated the shared state yet, so if we fail at this
     * point, the multixact ID we grabbed can still be used by the next guy.
     *
     * Note that there is no point in forcing autovacuum runs here: the
     * multixact freeze settings would have to be reduced for that to have any
     * effect.
     *----------
     */
#define OFFSET_WARN_SEGMENTS    20
    if (MultiXactState->oldestOffsetKnown &&
        MultiXactOffsetWouldWrap(MultiXactState->offsetStopLimit, nextOffset,
                                 nmembers))
    {
        /* see comment in the corresponding offsets wraparound case */
        SendPostmasterSignal(PMSIGNAL_START_AUTOVAC_LAUNCHER);

        ereport(ERROR,
                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                 errmsg("multixact \"members\" limit exceeded"),
                 errdetail_plural("This command would create a multixact with %u members, but the remaining space is only enough for %u member.",
                                  "This command would create a multixact with %u members, but the remaining space is only enough for %u members.",
                                  MultiXactState->offsetStopLimit - nextOffset - 1,
                                  nmembers,
                                  MultiXactState->offsetStopLimit - nextOffset - 1),
                 errhint("Execute a database-wide VACUUM in database with OID %u with reduced vacuum_multixact_freeze_min_age and vacuum_multixact_freeze_table_age settings.",
                         MultiXactState->oldestMultiXactDB)));
    }

    /*
     * Check whether we should kick autovacuum into action, to prevent members
     * wraparound. NB we use a much larger window to trigger autovacuum than
     * just the warning limit. The warning is just a measure of last resort -
     * this is in line with GetNewTransactionId's behaviour.
     */
    if (!MultiXactState->oldestOffsetKnown ||
        (MultiXactState->nextOffset - MultiXactState->oldestOffset
         > MULTIXACT_MEMBER_SAFE_THRESHOLD))
    {
        /*
         * To avoid swamping the postmaster with signals, we issue the autovac
         * request only when crossing a segment boundary. With default
         * compilation settings that's roughly after 50k members.  This still
         * gives plenty of chances before we get into real trouble.
         */
        if ((MXOffsetToMemberPage(nextOffset) / SLRU_PAGES_PER_SEGMENT) !=
            (MXOffsetToMemberPage(nextOffset + nmembers) / SLRU_PAGES_PER_SEGMENT))
            SendPostmasterSignal(PMSIGNAL_START_AUTOVAC_LAUNCHER);
    }

    if (MultiXactState->oldestOffsetKnown &&
        MultiXactOffsetWouldWrap(MultiXactState->offsetStopLimit,
                                 nextOffset,
                                 nmembers + MULTIXACT_MEMBERS_PER_PAGE * SLRU_PAGES_PER_SEGMENT * OFFSET_WARN_SEGMENTS))
        ereport(WARNING,
                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                 errmsg_plural("database with OID %u must be vacuumed before %d more multixact member is used",
                               "database with OID %u must be vacuumed before %d more multixact members are used",
                               MultiXactState->offsetStopLimit - nextOffset + nmembers,
                               MultiXactState->oldestMultiXactDB,
                               MultiXactState->offsetStopLimit - nextOffset + nmembers),
                 errhint("Execute a database-wide VACUUM in that database with reduced vacuum_multixact_freeze_min_age and vacuum_multixact_freeze_table_age settings.")));

    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!
     *
     * We don't care about MultiXactId wraparound here; it will be handled by
     * the next iteration.  But note that nextMXact may be InvalidMultiXactId
     * or the first value on a segment-beginning page after this routine
     * exits, so anyone else looking at the variable must be prepared to deal
     * with either case.  Similarly, nextOffset may be zero, but we won't use
     * that as the actual start offset of the next multixact.
     */
    (MultiXactState->nextMXact)++;

    MultiXactState->nextOffset += nmembers;

    LWLockRelease(MultiXactGenLock);

    debug_elog4(DEBUG2, "GetNew: returning %u offset %u", result, *offset);
    return result;
}

MultiXactId GetOldestMultiXactId

(

void

)

Definition at line 2491 of file multixact.c.

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

Referenced by AddNewRelationTuple(), ExecuteTruncate(), vac_update_datfrozenxid(), and vacuum_set_xid_limits().

{
    MultiXactId oldestMXact;
    MultiXactId nextMXact;
    int         i;

    /*
     * This is the oldest valid value among all the OldestMemberMXactId[] and
     * OldestVisibleMXactId[] entries, or nextMXact if none are valid.
     */
    LWLockAcquire(MultiXactGenLock, LW_SHARED);

    /*
     * We have to beware of the possibility that nextMXact is in the
     * wrapped-around state.  We don't fix the counter itself here, but we
     * must be sure to use a valid value in our calculation.
     */
    nextMXact = MultiXactState->nextMXact;
    if (nextMXact < FirstMultiXactId)
        nextMXact = FirstMultiXactId;

    oldestMXact = nextMXact;
    for (i = 1; 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;
}

static void MaybeExtendOffsetSlru ( void  )

static

Definition at line 1947 of file multixact.c.

References LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MultiXactIdToOffsetPage, MultiXactOffsetCtl, MultiXactStateData::nextMXact, SimpleLruDoesPhysicalPageExist(), SimpleLruWritePage(), and ZeroMultiXactOffsetPage().

Referenced by MultiXactSetNextMXact().

{
    int         pageno;

    pageno = MultiXactIdToOffsetPage(MultiXactState->nextMXact);

    LWLockAcquire(MultiXactOffsetControlLock, LW_EXCLUSIVE);

    if (!SimpleLruDoesPhysicalPageExist(MultiXactOffsetCtl, pageno))
    {
        int         slotno;

        /*
         * Fortunately for us, SimpleLruWritePage is already prepared to deal
         * with creating a new segment file even if the page we're writing is
         * not the first in it, so this is enough.
         */
        slotno = ZeroMultiXactOffsetPage(pageno, false);
        SimpleLruWritePage(MultiXactOffsetCtl, slotno);
    }

    LWLockRelease(MultiXactOffsetControlLock);
}

void multixact_redo

(

XLogReaderState *

record

)

Definition at line 3217 of file multixact.c.

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

{
    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)
    {
        int         pageno;
        int         slotno;

        memcpy(&pageno, XLogRecGetData(record), sizeof(int));

        LWLockAcquire(MultiXactOffsetControlLock, LW_EXCLUSIVE);

        slotno = ZeroMultiXactOffsetPage(pageno, false);
        SimpleLruWritePage(MultiXactOffsetCtl, slotno);
        Assert(!MultiXactOffsetCtl->shared->page_dirty[slotno]);

        LWLockRelease(MultiXactOffsetControlLock);
    }
    else if (info == XLOG_MULTIXACT_ZERO_MEM_PAGE)
    {
        int         pageno;
        int         slotno;

        memcpy(&pageno, XLogRecGetData(record), sizeof(int));

        LWLockAcquire(MultiXactMemberControlLock, LW_EXCLUSIVE);

        slotno = ZeroMultiXactMemberPage(pageno, false);
        SimpleLruWritePage(MultiXactMemberCtl, slotno);
        Assert(!MultiXactMemberCtl->shared->page_dirty[slotno]);

        LWLockRelease(MultiXactMemberControlLock);
    }
    else if (info == XLOG_MULTIXACT_CREATE_ID)
    {
        xl_multixact_create *xlrec =
        (xl_multixact_create *) XLogRecGetData(record);
        TransactionId max_xid;
        int         i;

        /* Store the data back into the SLRU files */
        RecordNewMultiXact(xlrec->mid, xlrec->moff, xlrec->nmembers,
                           xlrec->members);

        /* Make sure nextMXact/nextOffset are beyond what this record has */
        MultiXactAdvanceNextMXact(xlrec->mid + 1,
                                  xlrec->moff + xlrec->nmembers);

        /*
         * Make sure nextXid is beyond any XID mentioned in the record. This
         * should be unnecessary, since any XID found here ought to have other
         * evidence in the XLOG, but let's be safe.
         */
        max_xid = XLogRecGetXid(record);
        for (i = 0; i < xlrec->nmembers; i++)
        {
            if (TransactionIdPrecedes(max_xid, xlrec->members[i].xid))
                max_xid = xlrec->members[i].xid;
        }

        /*
         * We don't expect anyone else to modify nextXid, hence startup
         * process doesn't need to hold a lock while checking this. We still
         * acquire the lock to modify it, though.
         */
        if (TransactionIdFollowsOrEquals(max_xid,
                                         ShmemVariableCache->nextXid))
        {
            LWLockAcquire(XidGenLock, LW_EXCLUSIVE);
            ShmemVariableCache->nextXid = max_xid;
            TransactionIdAdvance(ShmemVariableCache->nextXid);
            LWLockRelease(XidGenLock);
        }
    }
    else if (info == XLOG_MULTIXACT_TRUNCATE_ID)
    {
        xl_multixact_truncate xlrec;
        int         pageno;

        memcpy(&xlrec, XLogRecGetData(record),
               SizeOfMultiXactTruncate);

        elog(DEBUG1, "replaying multixact truncation: "
             "offsets [%u, %u), offsets segments [%x, %x), "
             "members [%u, %u), members segments [%x, %x)",
             xlrec.startTruncOff, xlrec.endTruncOff,
             MultiXactIdToOffsetSegment(xlrec.startTruncOff),
             MultiXactIdToOffsetSegment(xlrec.endTruncOff),
             xlrec.startTruncMemb, xlrec.endTruncMemb,
             MXOffsetToMemberSegment(xlrec.startTruncMemb),
             MXOffsetToMemberSegment(xlrec.endTruncMemb));

        /* should not be required, but more than cheap enough */
        LWLockAcquire(MultiXactTruncationLock, LW_EXCLUSIVE);

        /*
         * Advance the horizon values, so they're current at the end of
         * recovery.
         */
        SetMultiXactIdLimit(xlrec.endTruncOff, xlrec.oldestMultiDB, false);

        PerformMembersTruncation(xlrec.startTruncMemb, xlrec.endTruncMemb);

        /*
         * During XLOG replay, latest_page_number isn't necessarily set up
         * yet; insert a suitable value to bypass the sanity test in
         * SimpleLruTruncate.
         */
        pageno = MultiXactIdToOffsetPage(xlrec.endTruncOff);
        MultiXactOffsetCtl->shared->latest_page_number = pageno;
        PerformOffsetsTruncation(xlrec.startTruncOff, xlrec.endTruncOff);

        LWLockRelease(MultiXactTruncationLock);
    }
    else
        elog(PANIC, "multixact_redo: unknown op code %u", info);
}

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

Definition at line 1791 of file multixact.c.

References multixact_twophase_postcommit().

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

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

Definition at line 1776 of file multixact.c.

References Assert, InvalidMultiXactId, OldestMemberMXactId, and TwoPhaseGetDummyBackendId().

Referenced by multixact_twophase_postabort().

{
    BackendId   dummyBackendId = TwoPhaseGetDummyBackendId(xid);

    Assert(len == sizeof(MultiXactId));

    OldestMemberMXactId[dummyBackendId] = InvalidMultiXactId;
}

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

Definition at line 1755 of file multixact.c.

References Assert, OldestMemberMXactId, and TwoPhaseGetDummyBackendId().

{
    BackendId   dummyBackendId = TwoPhaseGetDummyBackendId(xid);
    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[dummyBackendId] = oldestMember;
}

void MultiXactAdvanceNextMXact	(	MultiXactId	minMulti,
		MultiXactOffset	minMultiOffset
	)

Definition at line 2347 of file multixact.c.

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

Referenced by multixact_redo(), and xlog_redo().

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

void MultiXactAdvanceOldest	(	MultiXactId	oldestMulti,
		Oid	oldestMultiDB
	)

Definition at line 2372 of file multixact.c.

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

Referenced by xlog_redo().

{
    Assert(InRecovery);

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

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

Definition at line 2118 of file multixact.c.

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

Referenced by CreateCheckPoint().

{
    LWLockAcquire(MultiXactGenLock, LW_SHARED);
    *nextMulti = MultiXactState->nextMXact;
    *nextMultiOffset = MultiXactState->nextOffset;
    *oldestMulti = MultiXactState->oldestMultiXactId;
    *oldestMultiDB = MultiXactState->oldestMultiXactDB;
    LWLockRelease(MultiXactGenLock);

    debug_elog6(DEBUG2,
                "MultiXact: checkpoint is nextMulti %u, nextOffset %u, oldestMulti %u in DB %u",
                *nextMulti, *nextMultiOffset, *oldestMulti, *oldestMultiDB);
}

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

Definition at line 384 of file multixact.c.

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

Referenced by compute_new_xmax_infomask().

{
    MultiXactId newMulti;
    MultiXactMember members[2];

    AssertArg(TransactionIdIsValid(xid1));
    AssertArg(TransactionIdIsValid(xid2));

    Assert(!TransactionIdEquals(xid1, xid2) || (status1 != status2));

    /* MultiXactIdSetOldestMember() must have been called already. */
    Assert(MultiXactIdIsValid(OldestMemberMXactId[MyBackendId]));

    /*
     * 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;
}

MultiXactId MultiXactIdCreateFromMembers	(	int	nmembers,
		MultiXactMember *	members
	)

Definition at line 746 of file multixact.c.

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

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

{
    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");
                has_update = true;
            }
        }
    }

    /*
     * 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);

    /* Make an XLOG entry describing the new MXID. */
    xlrec.mid = multi;
    xlrec.moff = offset;
    xlrec.nmembers = nmembers;

    /*
     * XXX Note: there's a lot of padding space in MultiXactMember.  We could
     * find a more compact representation of this Xlog record -- perhaps all
     * the status flags in one XLogRecData, then all the xids in another one?
     * Not clear that it's worth the trouble though.
     */
    XLogBeginInsert();
    XLogRegisterData((char *) (&xlrec), SizeOfMultiXactCreate);
    XLogRegisterData((char *) members, nmembers * sizeof(MultiXactMember));

    (void) XLogInsert(RM_MULTIXACT_ID, XLOG_MULTIXACT_CREATE_ID);

    /* Now enter the information into the OFFSETs and MEMBERs logs */
    RecordNewMultiXact(multi, offset, nmembers, members);

    /* Done with critical section */
    END_CRIT_SECTION();

    /* Store the new MultiXactId in the local cache, too */
    mXactCachePut(multi, nmembers, members);

    debug_elog2(DEBUG2, "Create: all done");

    return multi;
}

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

Definition at line 437 of file multixact.c.

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

Referenced by compute_new_xmax_infomask().

{
    MultiXactId newMulti;
    MultiXactMember *members;
    MultiXactMember *newMembers;
    int         nmembers;
    int         i;
    int         j;

    AssertArg(MultiXactIdIsValid(multi));
    AssertArg(TransactionIdIsValid(xid));

    /* MultiXactIdSetOldestMember() must have been called already. */
    Assert(MultiXactIdIsValid(OldestMemberMXactId[MyBackendId]));

    debug_elog5(DEBUG2, "Expand: received multi %u, xid %u status %s",
                multi, xid, mxstatus_to_string(status));

    /*
     * Note: we don't allow for old multis here.  The reason is that the only
     * caller of this function does a check that the multixact is no longer
     * running.
     */
    nmembers = GetMultiXactIdMembers(multi, &members, false, false);

    if (nmembers < 0)
    {
        MultiXactMember member;

        /*
         * The MultiXactId is obsolete.  This can only happen if all the
         * MultiXactId members stop running between the caller checking and
         * passing it to us.  It would be better to return that fact to the
         * caller, but it would complicate the API and it's unlikely to happen
         * too often, so just deal with it by creating a singleton MultiXact.
         */
        member.xid = xid;
        member.status = status;
        newMulti = MultiXactIdCreateFromMembers(1, &member);

        debug_elog4(DEBUG2, "Expand: %u has no members, create singleton %u",
                    multi, newMulti);
        return newMulti;
    }

    /*
     * If the TransactionId is already a member of the MultiXactId with the
     * same status, just return the existing MultiXactId.
     */
    for (i = 0; i < nmembers; i++)
    {
        if (TransactionIdEquals(members[i].xid, xid) &&
            (members[i].status == status))
        {
            debug_elog4(DEBUG2, "Expand: %u is already a member of %u",
                        xid, multi);
            pfree(members);
            return multi;
        }
    }

    /*
     * Determine which of the members of the MultiXactId are still of
     * interest. This is any running transaction, and also any transaction
     * that grabbed something stronger than just a lock and was committed. (An
     * update that aborted is of no interest here; and having more than one
     * update Xid in a multixact would cause errors elsewhere.)
     *
     * Removing dead members is not just an optimization: freezing of tuples
     * whose Xmax are multis depends on this behavior.
     *
     * Note we have the same race condition here as above: j could be 0 at the
     * end of the loop.
     */
    newMembers = (MultiXactMember *)
        palloc(sizeof(MultiXactMember) * (nmembers + 1));

    for (i = 0, j = 0; i < nmembers; i++)
    {
        if (TransactionIdIsInProgress(members[i].xid) ||
            (ISUPDATE_from_mxstatus(members[i].status) &&
             TransactionIdDidCommit(members[i].xid)))
        {
            newMembers[j].xid = members[i].xid;
            newMembers[j++].status = members[i].status;
        }
    }

    newMembers[j].xid = xid;
    newMembers[j++].status = status;
    newMulti = MultiXactIdCreateFromMembers(j, newMembers);

    pfree(members);
    pfree(newMembers);

    debug_elog3(DEBUG2, "Expand: returning new multi %u", newMulti);

    return newMulti;
}

bool MultiXactIdIsRunning	(	MultiXactId	multi,
		bool	isLockOnly
	)

Definition at line 549 of file multixact.c.

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

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

{
    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;
}

bool MultiXactIdPrecedes	(	MultiXactId	multi1,
		MultiXactId	multi2
	)

Definition at line 3140 of file multixact.c.

Referenced by copy_heap_data(), do_start_worker(), FreezeMultiXactId(), GetMultiXactIdMembers(), GetNewMultiXactId(), GetOldestMultiXactId(), heap_tuple_needs_freeze(), MultiXactAdvanceNextMXact(), MultiXactAdvanceOldest(), MultiXactIdSetOldestVisible(), MultiXactOffsetPagePrecedes(), relation_needs_vacanalyze(), SetMultiXactIdLimit(), TruncateMultiXact(), vac_truncate_clog(), vac_update_datfrozenxid(), vac_update_relstats(), and vacuum_set_xid_limits().

{
    int32       diff = (int32) (multi1 - multi2);

    return (diff < 0);
}

bool MultiXactIdPrecedesOrEquals	(	MultiXactId	multi1,
		MultiXactId	multi2
	)

Definition at line 3154 of file multixact.c.

Referenced by lazy_vacuum_rel(), and TruncateMultiXact().

{
    int32       diff = (int32) (multi1 - multi2);

    return (diff <= 0);
}

void MultiXactIdSetOldestMember

(

void

)

Definition at line 623 of file multixact.c.

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

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

{
    if (!MultiXactIdIsValid(OldestMemberMXactId[MyBackendId]))
    {
        MultiXactId nextMXact;

        /*
         * You might think we don't need to acquire a lock here, since
         * fetching and storing of TransactionIds is probably atomic, but in
         * fact we do: suppose we pick up nextMXact and then lose the CPU for
         * a long time.  Someone else could advance nextMXact, and then
         * another someone else could compute an OldestVisibleMXactId that
         * would be after the value we are going to store when we get control
         * back.  Which would be wrong.
         *
         * Note that a shared lock is sufficient, because it's enough to stop
         * someone from advancing nextMXact; and nobody else could be trying
         * to write to our OldestMember entry, only reading (and we assume
         * storing it is atomic.)
         */
        LWLockAcquire(MultiXactGenLock, LW_SHARED);

        /*
         * We have to beware of the possibility that nextMXact is in the
         * wrapped-around state.  We don't fix the counter itself here, but we
         * must be sure to store a valid value in our array entry.
         */
        nextMXact = MultiXactState->nextMXact;
        if (nextMXact < FirstMultiXactId)
            nextMXact = FirstMultiXactId;

        OldestMemberMXactId[MyBackendId] = nextMXact;

        LWLockRelease(MultiXactGenLock);

        debug_elog4(DEBUG2, "MultiXact: setting OldestMember[%d] = %u",
                    MyBackendId, nextMXact);
    }
}

static void MultiXactIdSetOldestVisible ( void  )

static

Definition at line 680 of file multixact.c.

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

Referenced by GetMultiXactIdMembers().

{
    if (!MultiXactIdIsValid(OldestVisibleMXactId[MyBackendId]))
    {
        MultiXactId oldestMXact;
        int         i;

        LWLockAcquire(MultiXactGenLock, LW_EXCLUSIVE);

        /*
         * We have to beware of the possibility that nextMXact is in the
         * wrapped-around state.  We don't fix the counter itself here, but we
         * must be sure to store a valid value in our array entry.
         */
        oldestMXact = MultiXactState->nextMXact;
        if (oldestMXact < FirstMultiXactId)
            oldestMXact = FirstMultiXactId;

        for (i = 1; i <= MaxOldestSlot; i++)
        {
            MultiXactId thisoldest = OldestMemberMXactId[i];

            if (MultiXactIdIsValid(thisoldest) &&
                MultiXactIdPrecedes(thisoldest, oldestMXact))
                oldestMXact = thisoldest;
        }

        OldestVisibleMXactId[MyBackendId] = oldestMXact;

        LWLockRelease(MultiXactGenLock);

        debug_elog4(DEBUG2, "MultiXact: setting OldestVisible[%d] = %u",
                    MyBackendId, oldestMXact);
    }
}

int MultiXactMemberFreezeThreshold

(

void

)

Definition at line 2817 of file multixact.c.

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

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

{
    MultiXactOffset members;
    uint32      multixacts;
    uint32      victim_multixacts;
    double      fraction;

    /* If we can't determine member space utilization, assume the worst. */
    if (!ReadMultiXactCounts(&multixacts, &members))
        return 0;

    /* If member space utilization is low, no special action is required. */
    if (members <= MULTIXACT_MEMBER_SAFE_THRESHOLD)
        return autovacuum_multixact_freeze_max_age;

    /*
     * Compute a target for relminmxid advancement.  The number of multixacts
     * we try to eliminate from the system is based on how far we are past
     * MULTIXACT_MEMBER_SAFE_THRESHOLD.
     */
    fraction = (double) (members - MULTIXACT_MEMBER_SAFE_THRESHOLD) /
        (MULTIXACT_MEMBER_DANGER_THRESHOLD - MULTIXACT_MEMBER_SAFE_THRESHOLD);
    victim_multixacts = multixacts * fraction;

    /* fraction could be > 1.0, but lowest possible freeze age is zero */
    if (victim_multixacts > multixacts)
        return 0;
    return multixacts - victim_multixacts;
}

static bool MultiXactMemberPagePrecedes ( int  page1, int  page2  )

static

Definition at line 3122 of file multixact.c.

References MULTIXACT_MEMBERS_PER_PAGE, and MultiXactOffsetPrecedes().

Referenced by MultiXactShmemInit().

{
    MultiXactOffset offset1;
    MultiXactOffset offset2;

    offset1 = ((MultiXactOffset) page1) * MULTIXACT_MEMBERS_PER_PAGE;
    offset2 = ((MultiXactOffset) page2) * MULTIXACT_MEMBERS_PER_PAGE;

    return MultiXactOffsetPrecedes(offset1, offset2);
}

static bool MultiXactOffsetPagePrecedes ( int  page1, int  page2  )

static

Definition at line 3104 of file multixact.c.

References FirstMultiXactId, MULTIXACT_OFFSETS_PER_PAGE, and MultiXactIdPrecedes().

Referenced by MultiXactShmemInit().

{
    MultiXactId multi1;
    MultiXactId multi2;

    multi1 = ((MultiXactId) page1) * MULTIXACT_OFFSETS_PER_PAGE;
    multi1 += FirstMultiXactId;
    multi2 = ((MultiXactId) page2) * MULTIXACT_OFFSETS_PER_PAGE;
    multi2 += FirstMultiXactId;

    return MultiXactIdPrecedes(multi1, multi2);
}

static bool MultiXactOffsetPrecedes ( MultiXactOffset  offset1, MultiXactOffset  offset2  )

static

Definition at line 3166 of file multixact.c.

Referenced by MultiXactAdvanceNextMXact(), and MultiXactMemberPagePrecedes().

{
    int32       diff = (int32) (offset1 - offset2);

    return (diff < 0);
}

static bool MultiXactOffsetWouldWrap ( MultiXactOffset  boundary, MultiXactOffset  start, uint32  distance  )

static

Definition at line 2671 of file multixact.c.

Referenced by GetNewMultiXactId().

{
    MultiXactOffset finish;

    /*
     * Note that offset number 0 is not used (see GetMultiXactIdMembers), so
     * if the addition wraps around the UINT_MAX boundary, skip that value.
     */
    finish = start + distance;
    if (finish < start)
        finish++;

    /*-----------------------------------------------------------------------
     * When the boundary is numerically greater than the starting point, any
     * value numerically between the two is not wrapped:
     *
     *  <----S----B---->
     *  [---)            = F wrapped past B (and UINT_MAX)
     *       [---)       = F not wrapped
     *            [----] = F wrapped past B
     *
     * When the boundary is numerically less than the starting point (i.e. the
     * UINT_MAX wraparound occurs somewhere in between) then all values in
     * between are wrapped:
     *
     *  <----B----S---->
     *  [---)            = F not wrapped past B (but wrapped past UINT_MAX)
     *       [---)       = F wrapped past B (and UINT_MAX)
     *            [----] = F not wrapped
     *-----------------------------------------------------------------------
     */
    if (start < boundary)
        return finish >= boundary || finish < start;
    else
        return finish >= boundary && finish < start;
}

void MultiXactSetNextMXact	(	MultiXactId	nextMulti,
		MultiXactOffset	nextMultiOffset
	)

Definition at line 2160 of file multixact.c.

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

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

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

    /*
     * During a binary upgrade, make sure that the offsets SLRU is large
     * enough to contain the next value that would be created.
     *
     * We need to do this pretty early during the first startup in binary
     * upgrade mode: before StartupMultiXact() in fact, because this routine
     * is called even before that by StartupXLOG().  And we can't do it
     * earlier than at this point, because during that first call of this
     * routine we determine the MultiXactState->nextMXact value that
     * MaybeExtendOffsetSlru needs.
     */
    if (IsBinaryUpgrade)
        MaybeExtendOffsetSlru();
}

void MultiXactShmemInit

(

void

)

Definition at line 1820 of file multixact.c.

References Assert, DEBUG2, debug_elog2, IsUnderPostmaster, LWTRANCHE_MXACTMEMBER_BUFFERS, LWTRANCHE_MXACTOFFSET_BUFFERS, MaxOldestSlot, MemSet, MultiXactMemberCtl, MultiXactMemberPagePrecedes(), MultiXactOffsetCtl, MultiXactOffsetPagePrecedes(), NUM_MXACTMEMBER_BUFFERS, NUM_MXACTOFFSET_BUFFERS, OldestMemberMXactId, OldestVisibleMXactId, MultiXactStateData::perBackendXactIds, SHARED_MULTIXACT_STATE_SIZE, ShmemInitStruct(), and SimpleLruInit().

Referenced by CreateSharedMemoryAndSemaphores().

{
    bool        found;

    debug_elog2(DEBUG2, "Shared Memory Init for MultiXact");

    MultiXactOffsetCtl->PagePrecedes = MultiXactOffsetPagePrecedes;
    MultiXactMemberCtl->PagePrecedes = MultiXactMemberPagePrecedes;

    SimpleLruInit(MultiXactOffsetCtl,
                  "multixact_offset", NUM_MXACTOFFSET_BUFFERS, 0,
                  MultiXactOffsetControlLock, "pg_multixact/offsets",
                  LWTRANCHE_MXACTOFFSET_BUFFERS);
    SimpleLruInit(MultiXactMemberCtl,
                  "multixact_member", NUM_MXACTMEMBER_BUFFERS, 0,
                  MultiXactMemberControlLock, "pg_multixact/members",
                  LWTRANCHE_MXACTMEMBER_BUFFERS);

    /* 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.  Note that perBackendXactIds[0] is wasted space
     * since we only use indexes 1..MaxOldestSlot in each array.
     */
    OldestMemberMXactId = MultiXactState->perBackendXactIds;
    OldestVisibleMXactId = OldestMemberMXactId + MaxOldestSlot;
}

Size MultiXactShmemSize

(

void

)

Definition at line 1803 of file multixact.c.

References add_size(), NUM_MXACTMEMBER_BUFFERS, NUM_MXACTOFFSET_BUFFERS, SHARED_MULTIXACT_STATE_SIZE, and SimpleLruShmemSize().

Referenced by CreateSharedMemoryAndSemaphores().

{
    Size        size;

    /* We need 2*MaxOldestSlot + 1 perBackendXactIds[] entries */
#define SHARED_MULTIXACT_STATE_SIZE \
    add_size(offsetof(MultiXactStateData, perBackendXactIds) + sizeof(MultiXactId), \
             mul_size(sizeof(MultiXactId) * 2, MaxOldestSlot))

    size = SHARED_MULTIXACT_STATE_SIZE;
    size = add_size(size, SimpleLruShmemSize(NUM_MXACTOFFSET_BUFFERS, 0));
    size = add_size(size, SimpleLruShmemSize(NUM_MXACTMEMBER_BUFFERS, 0));

    return size;
}

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

static

Definition at line 1515 of file multixact.c.

References dlist_iter::cur, DEBUG2, debug_elog2, debug_elog3, dlist_container, dlist_foreach, dlist_move_head(), mXactCacheEnt::members, mXactCacheEnt::multi, mxid_to_string(), mXactCacheEnt::nmembers, and palloc().

Referenced by GetMultiXactIdMembers().

{
    dlist_iter  iter;

    debug_elog3(DEBUG2, "CacheGet: looking for %u", multi);

    dlist_foreach(iter, &MXactCache)
    {
        mXactCacheEnt *entry = dlist_container(mXactCacheEnt, node, iter.cur);

        if (entry->multi == multi)
        {
            MultiXactMember *ptr;
            Size        size;

            size = sizeof(MultiXactMember) * entry->nmembers;
            ptr = (MultiXactMember *) palloc(size);
            *members = ptr;

            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.
             */
            dlist_move_head(&MXactCache, iter.cur);

            return entry->nmembers;
        }
    }

    debug_elog2(DEBUG2, "CacheGet: not found");
    return -1;
}

static MultiXactId mXactCacheGetBySet ( int  nmembers, MultiXactMember *  members  )

static

Definition at line 1473 of file multixact.c.

References dlist_iter::cur, DEBUG2, debug_elog2, debug_elog3, dlist_container, dlist_foreach, dlist_move_head(), InvalidMultiXactId, mXactCacheEnt::members, mXactCacheEnt::multi, mxactMemberComparator(), mxid_to_string(), mXactCacheEnt::nmembers, and qsort.

Referenced by MultiXactIdCreateFromMembers().

{
    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);

    dlist_foreach(iter, &MXactCache)
    {
        mXactCacheEnt *entry = dlist_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);
            dlist_move_head(&MXactCache, iter.cur);
            return entry->multi;
        }
    }

    debug_elog2(DEBUG2, "CacheGet: not found :-(");
    return InvalidMultiXactId;
}

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

static

Definition at line 1561 of file multixact.c.

References ALLOCSET_SMALL_SIZES, AllocSetContextCreate(), DEBUG2, debug_elog2, debug_elog3, dlist_container, dlist_delete(), dlist_push_head(), dlist_tail_node(), MAX_CACHE_ENTRIES, mXactCacheEnt::members, MemoryContextAlloc(), mXactCacheEnt::multi, MXactCacheMembers, mxactMemberComparator(), mxid_to_string(), mXactCacheEnt::nmembers, mXactCacheEnt::node, NULL, offsetof, pfree(), qsort, and TopTransactionContext.

Referenced by GetMultiXactIdMembers(), and MultiXactIdCreateFromMembers().

{
    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);

    dlist_push_head(&MXactCache, &entry->node);
    if (MXactCacheMembers++ >= MAX_CACHE_ENTRIES)
    {
        dlist_node *node;
        mXactCacheEnt *entry;

        node = dlist_tail_node(&MXactCache);
        dlist_delete(node);
        MXactCacheMembers--;

        entry = dlist_container(mXactCacheEnt, node, node);
        debug_elog3(DEBUG2, "CachePut: pruning cached multi %u",
                    entry->multi);

        pfree(entry);
    }
}

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

static

Definition at line 1443 of file multixact.c.

References MultiXactMember::status, and MultiXactMember::xid.

Referenced by mXactCacheGetBySet(), and mXactCachePut().

{
    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;
}

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

Definition at line 1631 of file multixact.c.

References appendStringInfo(), appendStringInfoChar(), buf, StringInfoData::data, i, initStringInfo(), MemoryContextStrdup(), mxstatus_to_string(), NULL, pfree(), status(), and TopMemoryContext.

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

{
    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;
}

static char * mxstatus_to_string ( MultiXactStatus  status )

static

Definition at line 1608 of file multixact.c.

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

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

{
    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 "";
    }
}

static void PerformMembersTruncation ( MultiXactOffset  oldestOffset, MultiXactOffset  newOldestOffset  )

static

Definition at line 2880 of file multixact.c.

References DEBUG2, elog, MaxMultiXactOffset, MultiXactMemberCtl, MXOffsetToMemberSegment, and SlruDeleteSegment().

Referenced by multixact_redo(), and TruncateMultiXact().

{
    const int   maxsegment = MXOffsetToMemberSegment(MaxMultiXactOffset);
    int         startsegment = MXOffsetToMemberSegment(oldestOffset);
    int         endsegment = MXOffsetToMemberSegment(newOldestOffset);
    int         segment = startsegment;

    /*
     * Delete all the segments but the last one. The last segment can still
     * contain, possibly partially, valid data.
     */
    while (segment != endsegment)
    {
        elog(DEBUG2, "truncating multixact members segment %x", segment);
        SlruDeleteSegment(MultiXactMemberCtl, segment);

        /* move to next segment, handling wraparound correctly */
        if (segment == maxsegment)
            segment = 0;
        else
            segment += 1;
    }
}

static void PerformOffsetsTruncation ( MultiXactId  oldestMulti, MultiXactId  newOldestMulti  )

static

Definition at line 2908 of file multixact.c.

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

Referenced by multixact_redo(), and TruncateMultiXact().

{
    /*
     * 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)));
}

Datum pg_get_multixact_members

(

PG_FUNCTION_ARGS

)

Definition at line 3340 of file multixact.c.

References FuncCallContext::attinmeta, BuildTupleFromCStrings(), CreateTemplateTupleDesc(), ereport, errcode(), errmsg(), ERROR, FirstMultiXactId, GetMultiXactIdMembers(), HeapTupleGetDatum, MemoryContextSwitchTo(), FuncCallContext::multi_call_memory_ctx, mxstatus_to_string(), palloc(), pfree(), PG_GETARG_UINT32, psprintf(), SRF_FIRSTCALL_INIT, SRF_IS_FIRSTCALL, SRF_PERCALL_SETUP, SRF_RETURN_DONE, SRF_RETURN_NEXT, TEXTOID, TupleDescGetAttInMetadata(), TupleDescInitEntry(), FuncCallContext::user_fctx, values, and XIDOID.

{
    typedef struct
    {
        MultiXactMember *members;
        int         nmembers;
        int         iter;
    } mxact;
    MultiXactId mxid = PG_GETARG_UINT32(0);
    mxact      *multi;
    FuncCallContext *funccxt;

    if (mxid < FirstMultiXactId)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("invalid MultiXactId: %u", mxid)));

    if (SRF_IS_FIRSTCALL())
    {
        MemoryContext oldcxt;
        TupleDesc   tupdesc;

        funccxt = SRF_FIRSTCALL_INIT();
        oldcxt = MemoryContextSwitchTo(funccxt->multi_call_memory_ctx);

        multi = palloc(sizeof(mxact));
        /* no need to allow for old values here */
        multi->nmembers = GetMultiXactIdMembers(mxid, &multi->members, false,
                                                false);
        multi->iter = 0;

        tupdesc = CreateTemplateTupleDesc(2, false);
        TupleDescInitEntry(tupdesc, (AttrNumber) 1, "xid",
                           XIDOID, -1, 0);
        TupleDescInitEntry(tupdesc, (AttrNumber) 2, "mode",
                           TEXTOID, -1, 0);

        funccxt->attinmeta = TupleDescGetAttInMetadata(tupdesc);
        funccxt->user_fctx = multi;

        MemoryContextSwitchTo(oldcxt);
    }

    funccxt = SRF_PERCALL_SETUP();
    multi = (mxact *) funccxt->user_fctx;

    while (multi->iter < multi->nmembers)
    {
        HeapTuple   tuple;
        char       *values[2];

        values[0] = psprintf("%u", multi->members[multi->iter].xid);
        values[1] = mxstatus_to_string(multi->members[multi->iter].status);

        tuple = BuildTupleFromCStrings(funccxt->attinmeta, values);

        multi->iter++;
        pfree(values[0]);
        SRF_RETURN_NEXT(funccxt, HeapTupleGetDatum(tuple));
    }

    if (multi->nmembers > 0)
        pfree(multi->members);
    pfree(multi);

    SRF_RETURN_DONE(funccxt);
}

void PostPrepare_MultiXact

(

TransactionId

xid

)

Definition at line 1705 of file multixact.c.

References dlist_init(), InvalidMultiXactId, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MultiXactIdIsValid, MXactCacheMembers, MyBackendId, NULL, OldestMemberMXactId, OldestVisibleMXactId, and TwoPhaseGetDummyBackendId().

Referenced by PrepareTransaction().

{
    MultiXactId myOldestMember;

    /*
     * Transfer our OldestMemberMXactId value to the slot reserved for the
     * prepared transaction.
     */
    myOldestMember = OldestMemberMXactId[MyBackendId];
    if (MultiXactIdIsValid(myOldestMember))
    {
        BackendId   dummyBackendId = TwoPhaseGetDummyBackendId(xid);

        /*
         * 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[dummyBackendId] = myOldestMember;
        OldestMemberMXactId[MyBackendId] = 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[MyBackendId] = InvalidMultiXactId;

    /*
     * Discard the local MultiXactId cache like in AtEOX_MultiXact
     */
    MXactContext = NULL;
    dlist_init(&MXactCache);
    MXactCacheMembers = 0;
}

static bool ReadMultiXactCounts ( uint32 *  multixacts, MultiXactOffset *  members  )

static

Definition at line 2761 of file multixact.c.

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

Referenced by MultiXactMemberFreezeThreshold().

{
    MultiXactOffset nextOffset;
    MultiXactOffset oldestOffset;
    MultiXactId oldestMultiXactId;
    MultiXactId nextMultiXactId;
    bool        oldestOffsetKnown;

    LWLockAcquire(MultiXactGenLock, LW_SHARED);
    nextOffset = MultiXactState->nextOffset;
    oldestMultiXactId = MultiXactState->oldestMultiXactId;
    nextMultiXactId = MultiXactState->nextMXact;
    oldestOffset = MultiXactState->oldestOffset;
    oldestOffsetKnown = MultiXactState->oldestOffsetKnown;
    LWLockRelease(MultiXactGenLock);

    if (!oldestOffsetKnown)
        return false;

    *members = nextOffset - oldestOffset;
    *multixacts = nextMultiXactId - oldestMultiXactId;
    return true;
}

MultiXactId ReadNextMultiXactId

(

void

)

Definition at line 721 of file multixact.c.

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

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

{
    MultiXactId mxid;

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

    if (mxid < FirstMultiXactId)
        mxid = FirstMultiXactId;

    return mxid;
}

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

static

Definition at line 841 of file multixact.c.

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

Referenced by multixact_redo(), and MultiXactIdCreateFromMembers().

{
    int         pageno;
    int         prev_pageno;
    int         entryno;
    int         slotno;
    MultiXactOffset *offptr;
    int         i;

    LWLockAcquire(MultiXactOffsetControlLock, LW_EXCLUSIVE);

    pageno = MultiXactIdToOffsetPage(multi);
    entryno = MultiXactIdToOffsetEntry(multi);

    /*
     * 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;

    *offptr = offset;

    MultiXactOffsetCtl->shared->page_dirty[slotno] = true;

    /* Exchange our lock */
    LWLockRelease(MultiXactOffsetControlLock);

    LWLockAcquire(MultiXactMemberControlLock, LW_EXCLUSIVE);

    prev_pageno = -1;

    for (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)
        {
            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;
    }

    LWLockRelease(MultiXactMemberControlLock);
}

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

Definition at line 2194 of file multixact.c.

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

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

{
    MultiXactId multiVacLimit;
    MultiXactId multiWarnLimit;
    MultiXactId multiStopLimit;
    MultiXactId multiWrapLimit;
    MultiXactId curMulti;
    bool        needs_offset_vacuum;

    Assert(MultiXactIdIsValid(oldest_datminmxid));

    /*
     * We pretend that a wrap will happen halfway through the multixact ID
     * space, but that's not really true, because multixacts wrap differently
     * from transaction IDs.  Note that, separately from any concern about
     * multixact IDs wrapping, we must ensure that multixact members do not
     * wrap.  Limits for that are set in DetermineSafeOldestOffset, not here.
     */
    multiWrapLimit = oldest_datminmxid + (MaxMultiXactId >> 1);
    if (multiWrapLimit < FirstMultiXactId)
        multiWrapLimit += FirstMultiXactId;

    /*
     * We'll refuse to continue assigning MultiXactIds once we get within 100
     * multi of data loss.
     *
     * Note: This differs from the magic number used in
     * SetTransactionIdLimit() since vacuum itself will never generate new
     * multis.  XXX actually it does, if it needs to freeze old multis.
     */
    multiStopLimit = multiWrapLimit - 100;
    if (multiStopLimit < FirstMultiXactId)
        multiStopLimit -= FirstMultiXactId;

    /*
     * We'll start complaining loudly when we get within 10M multis of the
     * stop point.   This is kind of arbitrary, but if you let your gas gauge
     * get down to 1% 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 = multiStopLimit - 10000000;
    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("MultiXactId wrap limit is %u, limited by database with OID %u",
                    multiWrapLimit, oldest_datoid)));

    /*
     * Computing the actual limits is only possible once the data directory is
     * in a consistent state. There's no need to compute the limits while
     * still replaying WAL - no decisions about new multis are made even
     * though multixact creations might be replayed. So we'll only do further
     * checks after TrimMultiXact() has been called.
     */
    if (!MultiXactState->finishedStartup)
        return;

    Assert(!InRecovery);

    /* Set limits for offset vacuum. */
    needs_offset_vacuum = SetOffsetVacuumLimit(is_startup);

    /*
     * If past the autovacuum force point, immediately signal an autovac
     * request.  The reason for this is that autovac only processes one
     * database per invocation.  Once it's finished cleaning up the oldest
     * database, it'll call here, and we'll signal the postmaster to start
     * another iteration immediately if there are still any old databases.
     */
    if ((MultiXactIdPrecedes(multiVacLimit, curMulti) ||
         needs_offset_vacuum) && IsUnderPostmaster)
        SendPostmasterSignal(PMSIGNAL_START_AUTOVAC_LAUNCHER);

    /* Give an immediate warning if past the wrap warn point */
    if (MultiXactIdPrecedes(multiWarnLimit, curMulti))
    {
        char       *oldest_datname;

        /*
         * We can be called when not inside a transaction, for example during
         * StartupXLOG().  In such a case we cannot do database access, so we
         * must just report the oldest DB's OID.
         *
         * Note: it's also possible that get_database_name fails and returns
         * NULL, for example because the database just got dropped.  We'll
         * still warn, even though the warning might now be unnecessary.
         */
        if (IsTransactionState())
            oldest_datname = get_database_name(oldest_datoid);
        else
            oldest_datname = NULL;

        if (oldest_datname)
            ereport(WARNING,
                    (errmsg_plural("database \"%s\" must be vacuumed before %u more MultiXactId is used",
                                   "database \"%s\" must be vacuumed before %u more MultiXactIds are used",
                                   multiWrapLimit - curMulti,
                                   oldest_datname,
                                   multiWrapLimit - curMulti),
                     errhint("To avoid a database shutdown, execute a database-wide VACUUM in that database.\n"
                             "You might also need to commit or roll back old prepared transactions.")));
        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 a database shutdown, execute a database-wide VACUUM in that database.\n"
                             "You might also need to commit or roll back old prepared transactions.")));
    }
}

static bool SetOffsetVacuumLimit ( bool  is_startup )

static

Definition at line 2544 of file multixact.c.

References Assert, DEBUG1, ereport, errmsg(), find_multixact_start(), MultiXactStateData::finishedStartup, LOG, LW_EXCLUSIVE, LW_SHARED, LWLockAcquire(), LWLockRelease(), MULTIXACT_MEMBER_SAFE_THRESHOLD, MULTIXACT_MEMBERS_PER_PAGE, MultiXactStateData::nextMXact, MultiXactStateData::nextOffset, MultiXactStateData::offsetStopLimit, MultiXactStateData::oldestMultiXactId, MultiXactStateData::oldestOffset, MultiXactStateData::oldestOffsetKnown, and SLRU_PAGES_PER_SEGMENT.

Referenced by SetMultiXactIdLimit().

{
    MultiXactId oldestMultiXactId;
    MultiXactId nextMXact;
    MultiXactOffset oldestOffset = 0;   /* placate compiler */
    MultiXactOffset prevOldestOffset;
    MultiXactOffset nextOffset;
    bool        oldestOffsetKnown = false;
    bool        prevOldestOffsetKnown;
    MultiXactOffset offsetStopLimit = 0;
    MultiXactOffset prevOffsetStopLimit;

    /*
     * NB: Have to prevent concurrent truncation, we might otherwise try to
     * lookup a 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;
    prevOldestOffsetKnown = MultiXactState->oldestOffsetKnown;
    prevOldestOffset = MultiXactState->oldestOffset;
    prevOffsetStopLimit = MultiXactState->offsetStopLimit;
    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
    {
        /*
         * Figure out where the oldest existing multixact's offsets are
         * stored. Due to bugs in early release of PostgreSQL 9.3.X and 9.4.X,
         * the supposedly-earliest multixact might not really exist.  We are
         * careful not to fail in that case.
         */
        oldestOffsetKnown =
            find_multixact_start(oldestMultiXactId, &oldestOffset);

        if (oldestOffsetKnown)
            ereport(DEBUG1,
                    (errmsg("oldest MultiXactId member is at offset %u",
                            oldestOffset)));
        else
            ereport(LOG,
                    (errmsg("MultiXact member wraparound protections are disabled because oldest checkpointed MultiXact %u does not exist on disk",
                            oldestMultiXactId)));
    }

    LWLockRelease(MultiXactTruncationLock);

    /*
     * If we can, compute limits (and install them MultiXactState) to prevent
     * overrun of old data in the members SLRU area. We can only do so if the
     * oldest offset is known though.
     */
    if (oldestOffsetKnown)
    {
        /* move back to start of the corresponding segment */
        offsetStopLimit = oldestOffset - (oldestOffset %
                                          (MULTIXACT_MEMBERS_PER_PAGE * SLRU_PAGES_PER_SEGMENT));

        /* always leave one segment before the wraparound point */
        offsetStopLimit -= (MULTIXACT_MEMBERS_PER_PAGE * SLRU_PAGES_PER_SEGMENT);

        if (!prevOldestOffsetKnown && !is_startup)
            ereport(LOG,
                    (errmsg("MultiXact member wraparound protections are now enabled")));

        ereport(DEBUG1,
                (errmsg("MultiXact member stop limit is now %u based on MultiXact %u",
                        offsetStopLimit, oldestMultiXactId)));
    }
    else if (prevOldestOffsetKnown)
    {
        /*
         * If we failed to get the oldest offset this time, but we have a
         * value from a previous pass through this function, use the old
         * values rather than automatically forcing an emergency autovacuum
         * cycle again.
         */
        oldestOffset = prevOldestOffset;
        oldestOffsetKnown = true;
        offsetStopLimit = prevOffsetStopLimit;
    }

    /* Install the computed values */
    LWLockAcquire(MultiXactGenLock, LW_EXCLUSIVE);
    MultiXactState->oldestOffset = oldestOffset;
    MultiXactState->oldestOffsetKnown = oldestOffsetKnown;
    MultiXactState->offsetStopLimit = offsetStopLimit;
    LWLockRelease(MultiXactGenLock);

    /*
     * Do we need an emergency autovacuum?  If we're not sure, assume yes.
     */
    return !oldestOffsetKnown ||
        (nextOffset - oldestOffset > MULTIXACT_MEMBER_SAFE_THRESHOLD);
}

void ShutdownMultiXact

(

void

)

Definition at line 2105 of file multixact.c.

References MultiXactMemberCtl, MultiXactOffsetCtl, and SimpleLruFlush().

Referenced by ShutdownXLOG().

{
    /* Flush dirty MultiXact pages to disk */
    TRACE_POSTGRESQL_MULTIXACT_CHECKPOINT_START(false);
    SimpleLruFlush(MultiXactOffsetCtl, false);
    SimpleLruFlush(MultiXactMemberCtl, false);
    TRACE_POSTGRESQL_MULTIXACT_CHECKPOINT_DONE(false);
}

static bool SlruScanDirCbFindEarliest ( SlruCtl  ctl, char *  filename, int  segpage, void *  data  )

static

Definition at line 2857 of file multixact.c.

References mxtruncinfo::earliestExistingPage, and SlruCtlData::PagePrecedes.

Referenced by TruncateMultiXact().

{
    mxtruncinfo *trunc = (mxtruncinfo *) data;

    if (trunc->earliestExistingPage == -1 ||
        ctl->PagePrecedes(segpage, trunc->earliestExistingPage))
    {
        trunc->earliestExistingPage = segpage;
    }

    return false;               /* keep going */
}

void StartupMultiXact

(

void

)

Definition at line 1980 of file multixact.c.

References MultiXactIdToOffsetPage, MultiXactMemberCtl, MultiXactOffsetCtl, MXOffsetToMemberPage, MultiXactStateData::nextMXact, and MultiXactStateData::nextOffset.

Referenced by StartupXLOG().

{
    MultiXactId multi = MultiXactState->nextMXact;
    MultiXactOffset offset = MultiXactState->nextOffset;
    int         pageno;

    /*
     * Initialize offset's idea of the latest page number.
     */
    pageno = MultiXactIdToOffsetPage(multi);
    MultiXactOffsetCtl->shared->latest_page_number = pageno;

    /*
     * Initialize member's idea of the latest page number.
     */
    pageno = MXOffsetToMemberPage(offset);
    MultiXactMemberCtl->shared->latest_page_number = pageno;
}

void TrimMultiXact

(

void

)

Definition at line 2003 of file multixact.c.

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

Referenced by StartupXLOG().

{
    MultiXactId nextMXact;
    MultiXactOffset offset;
    MultiXactId oldestMXact;
    Oid         oldestMXactDB;
    int         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 */
    LWLockAcquire(MultiXactOffsetControlLock, LW_EXCLUSIVE);

    /*
     * (Re-)Initialize our idea of the latest page number for offsets.
     */
    pageno = MultiXactIdToOffsetPage(nextMXact);
    MultiXactOffsetCtl->shared->latest_page_number = pageno;

    /*
     * Zero out the remainder of the current offsets page.  See notes in
     * TrimCLOG() for background.  Unlike CLOG, some WAL record covers every
     * pg_multixact SLRU mutation.  Since, also unlike CLOG, we ignore the WAL
     * rule "write xlog before data," nextMXact successors may carry obsolete,
     * nonzero offset values.  Zero those so case 2 of GetMultiXactIdMembers()
     * operates normally.
     */
    entryno = MultiXactIdToOffsetEntry(nextMXact);
    if (entryno != 0)
    {
        int         slotno;
        MultiXactOffset *offptr;

        slotno = SimpleLruReadPage(MultiXactOffsetCtl, pageno, true, nextMXact);
        offptr = (MultiXactOffset *) MultiXactOffsetCtl->shared->page_buffer[slotno];
        offptr += entryno;

        MemSet(offptr, 0, BLCKSZ - (entryno * sizeof(MultiXactOffset)));

        MultiXactOffsetCtl->shared->page_dirty[slotno] = true;
    }

    LWLockRelease(MultiXactOffsetControlLock);

    /* And the same for members */
    LWLockAcquire(MultiXactMemberControlLock, LW_EXCLUSIVE);

    /*
     * (Re-)Initialize our idea of the latest page number for members.
     */
    pageno = MXOffsetToMemberPage(offset);
    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;

        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(MultiXactMemberControlLock);

    /* signal that we're officially up */
    LWLockAcquire(MultiXactGenLock, LW_EXCLUSIVE);
    MultiXactState->finishedStartup = true;
    LWLockRelease(MultiXactGenLock);

    /* Now compute how far away the next members wraparound is. */
    SetMultiXactIdLimit(oldestMXact, oldestMXactDB, true);
}

void TruncateMultiXact	(	MultiXactId	newOldestMulti,
		Oid	newOldestMultiDB
	)

Definition at line 2933 of file multixact.c.

References Assert, DEBUG1, PGXACT::delayChkpt, mxtruncinfo::earliestExistingPage, elog, END_CRIT_SECTION, ereport, errmsg(), find_multixact_start(), MultiXactStateData::finishedStartup, FirstMultiXactId, LOG, LW_EXCLUSIVE, LW_SHARED, LWLockAcquire(), LWLockRelease(), MULTIXACT_OFFSETS_PER_PAGE, MultiXactIdIsValid, MultiXactIdPrecedes(), MultiXactIdPrecedesOrEquals(), MultiXactIdToOffsetSegment, MultiXactOffsetCtl, MXOffsetToMemberSegment, MyPgXact, MultiXactStateData::nextMXact, MultiXactStateData::nextOffset, MultiXactStateData::oldestMultiXactDB, MultiXactStateData::oldestMultiXactId, PerformMembersTruncation(), PerformOffsetsTruncation(), RecoveryInProgress(), SlruScanDirCbFindEarliest(), SlruScanDirectory(), START_CRIT_SECTION, and WriteMTruncateXlogRec().

Referenced by vac_truncate_clog().

{
    MultiXactId oldestMulti;
    MultiXactId nextMulti;
    MultiXactOffset newOldestOffset;
    MultiXactOffset oldestOffset;
    MultiXactOffset nextOffset;
    mxtruncinfo trunc;
    MultiXactId earliest;

    Assert(!RecoveryInProgress());
    Assert(MultiXactState->finishedStartup);

    /*
     * 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);
    Assert(MultiXactIdIsValid(oldestMulti));

    /*
     * 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;
    }

    /*
     * Note we can't just plow ahead with the truncation; it's possible that
     * there are no segments to truncate, which is a problem because we are
     * going to attempt to read the offsets page to determine where to
     * truncate the members SLRU.  So we first scan the directory to determine
     * the earliest offsets page number that we can read without error.
     *
     * NB: It's also possible that the page that oldestMulti is on has already
     * been truncated away, and we crashed before updating oldestMulti.
     */
    trunc.earliestExistingPage = -1;
    SlruScanDirectory(MultiXactOffsetCtl, SlruScanDirCbFindEarliest, &trunc);
    earliest = trunc.earliestExistingPage * MULTIXACT_OFFSETS_PER_PAGE;
    if (earliest < FirstMultiXactId)
        earliest = FirstMultiXactId;

    /* If there's nothing to remove, we can bail out early. */
    if (MultiXactIdPrecedes(oldestMulti, earliest))
    {
        LWLockRelease(MultiXactTruncationLock);
        return;
    }

    /*
     * First, compute the safe truncation point for MultiXactMember. This is
     * the starting offset of the oldest multixact.
     *
     * Hopefully, find_multixact_start will always work here, because we've
     * already checked that it doesn't precede the earliest MultiXact on disk.
     * But if it fails, don't truncate anything, and log a message.
     */
    if (oldestMulti == nextMulti)
    {
        /* there are NO MultiXacts */
        oldestOffset = nextOffset;
    }
    else if (!find_multixact_start(oldestMulti, &oldestOffset))
    {
        ereport(LOG,
                (errmsg("oldest MultiXact %u not found, earliest MultiXact %u, skipping truncation",
                        oldestMulti, earliest)));
        LWLockRelease(MultiXactTruncationLock);
        return;
    }

    /*
     * Secondly compute up to where to truncate. 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;
    }

    elog(DEBUG1, "performing multixact truncation: "
         "offsets [%u, %u), offsets segments [%x, %x), "
         "members [%u, %u), members segments [%x, %x)",
         oldestMulti, newOldestMulti,
         MultiXactIdToOffsetSegment(oldestMulti),
         MultiXactIdToOffsetSegment(newOldestMulti),
         oldestOffset, newOldestOffset,
         MXOffsetToMemberSegment(oldestOffset),
         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(!MyPgXact->delayChkpt);
    MyPgXact->delayChkpt = true;

    /* WAL log truncation */
    WriteMTruncateXlogRec(newOldestMultiDB,
                          oldestMulti, newOldestMulti,
                          oldestOffset, 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;
    LWLockRelease(MultiXactGenLock);

    /* First truncate members */
    PerformMembersTruncation(oldestOffset, newOldestOffset);

    /* Then offsets */
    PerformOffsetsTruncation(oldestMulti, newOldestMulti);

    MyPgXact->delayChkpt = false;

    END_CRIT_SECTION();
    LWLockRelease(MultiXactTruncationLock);
}

static void WriteMTruncateXlogRec ( Oid  oldestMultiDB, MultiXactId  startOff, MultiXactId  endOff, MultiXactOffset  startMemb, MultiXactOffset  endMemb  )

static

Definition at line 3192 of file multixact.c.

References xl_multixact_truncate::endTruncMemb, xl_multixact_truncate::endTruncOff, xl_multixact_truncate::oldestMultiDB, SizeOfMultiXactTruncate, xl_multixact_truncate::startTruncMemb, xl_multixact_truncate::startTruncOff, XLOG_MULTIXACT_TRUNCATE_ID, XLogBeginInsert(), XLogFlush(), XLogInsert(), and XLogRegisterData().

Referenced by TruncateMultiXact().

{
    XLogRecPtr  recptr;
    xl_multixact_truncate xlrec;

    xlrec.oldestMultiDB = oldestMultiDB;

    xlrec.startTruncOff = startTruncOff;
    xlrec.endTruncOff = endTruncOff;

    xlrec.startTruncMemb = startTruncMemb;
    xlrec.endTruncMemb = endTruncMemb;

    XLogBeginInsert();
    XLogRegisterData((char *) (&xlrec), SizeOfMultiXactTruncate);
    recptr = XLogInsert(RM_MULTIXACT_ID, XLOG_MULTIXACT_TRUNCATE_ID);
    XLogFlush(recptr);
}

static void WriteMZeroPageXlogRec ( int  pageno, uint8  info  )

static

Definition at line 3178 of file multixact.c.

References XLogBeginInsert(), XLogInsert(), and XLogRegisterData().

Referenced by ZeroMultiXactMemberPage(), and ZeroMultiXactOffsetPage().

{
    XLogBeginInsert();
    XLogRegisterData((char *) (&pageno), sizeof(int));
    (void) XLogInsert(RM_MULTIXACT_ID, info);
}

static int ZeroMultiXactMemberPage ( int  pageno, bool  writeXlog  )

static

Definition at line 1919 of file multixact.c.

References MultiXactMemberCtl, SimpleLruZeroPage(), WriteMZeroPageXlogRec(), and XLOG_MULTIXACT_ZERO_MEM_PAGE.

Referenced by BootStrapMultiXact(), ExtendMultiXactMember(), and multixact_redo().

{
    int         slotno;

    slotno = SimpleLruZeroPage(MultiXactMemberCtl, pageno);

    if (writeXlog)
        WriteMZeroPageXlogRec(pageno, XLOG_MULTIXACT_ZERO_MEM_PAGE);

    return slotno;
}

static int ZeroMultiXactOffsetPage ( int  pageno, bool  writeXlog  )

static

Definition at line 1903 of file multixact.c.

References MultiXactOffsetCtl, SimpleLruZeroPage(), WriteMZeroPageXlogRec(), and XLOG_MULTIXACT_ZERO_OFF_PAGE.

Referenced by BootStrapMultiXact(), ExtendMultiXactOffset(), MaybeExtendOffsetSlru(), and multixact_redo().

{
    int         slotno;

    slotno = SimpleLruZeroPage(MultiXactOffsetCtl, pageno);

    if (writeXlog)
        WriteMZeroPageXlogRec(pageno, XLOG_MULTIXACT_ZERO_OFF_PAGE);

    return slotno;
}

Variable Documentation

SlruCtlData MultiXactMemberCtlData

static

Definition at line 188 of file multixact.c.

SlruCtlData MultiXactOffsetCtlData

static

Definition at line 187 of file multixact.c.

MultiXactStateData* MultiXactState

static

Definition at line 291 of file multixact.c.

dlist_head MXactCache = DLIST_STATIC_INIT(MXactCache)

static

Definition at line 322 of file multixact.c.

int MXactCacheMembers = 0

static

Definition at line 323 of file multixact.c.

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

MemoryContext MXactContext = NULL

static

Definition at line 324 of file multixact.c.

MultiXactId* OldestMemberMXactId

static

Definition at line 292 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().

MultiXactId* OldestVisibleMXactId

static

Definition at line 293 of file multixact.c.

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