LCOV - code coverage report
Current view: top level - src/backend/access/transam - multixact.c (source / functions) Hit Total Coverage
Test: PostgreSQL 13devel Lines: 559 815 68.6 %
Date: 2019-11-13 22:07:24 Functions: 48 58 82.8 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * multixact.c
       4             :  *      PostgreSQL multi-transaction-log manager
       5             :  *
       6             :  * The pg_multixact manager is a pg_xact-like manager that stores an array of
       7             :  * MultiXactMember for each MultiXactId.  It is a fundamental part of the
       8             :  * shared-row-lock implementation.  Each MultiXactMember is comprised of a
       9             :  * TransactionId and a set of flag bits.  The name is a bit historical:
      10             :  * originally, a MultiXactId consisted of more than one TransactionId (except
      11             :  * in rare corner cases), hence "multi".  Nowadays, however, it's perfectly
      12             :  * legitimate to have MultiXactIds that only include a single Xid.
      13             :  *
      14             :  * The meaning of the flag bits is opaque to this module, but they are mostly
      15             :  * used in heapam.c to identify lock modes that each of the member transactions
      16             :  * is holding on any given tuple.  This module just contains support to store
      17             :  * and retrieve the arrays.
      18             :  *
      19             :  * We use two SLRU areas, one for storing the offsets at which the data
      20             :  * starts for each MultiXactId in the other one.  This trick allows us to
      21             :  * store variable length arrays of TransactionIds.  (We could alternatively
      22             :  * use one area containing counts and TransactionIds, with valid MultiXactId
      23             :  * values pointing at slots containing counts; but that way seems less robust
      24             :  * since it would get completely confused if someone inquired about a bogus
      25             :  * MultiXactId that pointed to an intermediate slot containing an XID.)
      26             :  *
      27             :  * XLOG interactions: this module generates a record whenever a new OFFSETs or
      28             :  * MEMBERs page is initialized to zeroes, as well as an
      29             :  * XLOG_MULTIXACT_CREATE_ID record whenever a new MultiXactId is defined.
      30             :  * This module ignores the WAL rule "write xlog before data," because it
      31             :  * suffices that actions recording a MultiXactId in a heap xmax do follow that
      32             :  * rule.  The only way for the MXID to be referenced from any data page is for
      33             :  * heap_lock_tuple() or heap_update() to have put it there, and each generates
      34             :  * an XLOG record that must follow ours.  The normal LSN interlock between the
      35             :  * data page and that XLOG record will ensure that our XLOG record reaches
      36             :  * disk first.  If the SLRU members/offsets data reaches disk sooner than the
      37             :  * XLOG records, we do not care; after recovery, no xmax will refer to it.  On
      38             :  * the flip side, to ensure that all referenced entries _do_ reach disk, this
      39             :  * module's XLOG records completely rebuild the data entered since the last
      40             :  * checkpoint.  We flush and sync all dirty OFFSETs and MEMBERs pages to disk
      41             :  * before each checkpoint is considered complete.
      42             :  *
      43             :  * Like clog.c, and unlike subtrans.c, we have to preserve state across
      44             :  * crashes and ensure that MXID and offset numbering increases monotonically
      45             :  * across a crash.  We do this in the same way as it's done for transaction
      46             :  * IDs: the WAL record is guaranteed to contain evidence of every MXID we
      47             :  * could need to worry about, and we just make sure that at the end of
      48             :  * replay, the next-MXID and next-offset counters are at least as large as
      49             :  * anything we saw during replay.
      50             :  *
      51             :  * We are able to remove segments no longer necessary by carefully tracking
      52             :  * each table's used values: during vacuum, any multixact older than a certain
      53             :  * value is removed; the cutoff value is stored in pg_class.  The minimum value
      54             :  * across all tables in each database is stored in pg_database, and the global
      55             :  * minimum across all databases is part of pg_control and is kept in shared
      56             :  * memory.  Whenever that minimum is advanced, the SLRUs are truncated.
      57             :  *
      58             :  * When new multixactid values are to be created, care is taken that the
      59             :  * counter does not fall within the wraparound horizon considering the global
      60             :  * minimum value.
      61             :  *
      62             :  * Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
      63             :  * Portions Copyright (c) 1994, Regents of the University of California
      64             :  *
      65             :  * src/backend/access/transam/multixact.c
      66             :  *
      67             :  *-------------------------------------------------------------------------
      68             :  */
      69             : #include "postgres.h"
      70             : 
      71             : #include "access/multixact.h"
      72             : #include "access/slru.h"
      73             : #include "access/transam.h"
      74             : #include "access/twophase.h"
      75             : #include "access/twophase_rmgr.h"
      76             : #include "access/xact.h"
      77             : #include "access/xlog.h"
      78             : #include "access/xloginsert.h"
      79             : #include "catalog/pg_type.h"
      80             : #include "commands/dbcommands.h"
      81             : #include "funcapi.h"
      82             : #include "lib/ilist.h"
      83             : #include "miscadmin.h"
      84             : #include "pg_trace.h"
      85             : #include "postmaster/autovacuum.h"
      86             : #include "storage/lmgr.h"
      87             : #include "storage/pmsignal.h"
      88             : #include "storage/proc.h"
      89             : #include "storage/procarray.h"
      90             : #include "utils/builtins.h"
      91             : #include "utils/memutils.h"
      92             : #include "utils/snapmgr.h"
      93             : 
      94             : 
      95             : /*
      96             :  * Defines for MultiXactOffset page sizes.  A page is the same BLCKSZ as is
      97             :  * used everywhere else in Postgres.
      98             :  *
      99             :  * Note: because MultiXactOffsets are 32 bits and wrap around at 0xFFFFFFFF,
     100             :  * MultiXact page numbering also wraps around at
     101             :  * 0xFFFFFFFF/MULTIXACT_OFFSETS_PER_PAGE, and segment numbering at
     102             :  * 0xFFFFFFFF/MULTIXACT_OFFSETS_PER_PAGE/SLRU_PAGES_PER_SEGMENT.  We need
     103             :  * take no explicit notice of that fact in this module, except when comparing
     104             :  * segment and page numbers in TruncateMultiXact (see
     105             :  * MultiXactOffsetPagePrecedes).
     106             :  */
     107             : 
     108             : /* We need four bytes per offset */
     109             : #define MULTIXACT_OFFSETS_PER_PAGE (BLCKSZ / sizeof(MultiXactOffset))
     110             : 
     111             : #define MultiXactIdToOffsetPage(xid) \
     112             :     ((xid) / (MultiXactOffset) MULTIXACT_OFFSETS_PER_PAGE)
     113             : #define MultiXactIdToOffsetEntry(xid) \
     114             :     ((xid) % (MultiXactOffset) MULTIXACT_OFFSETS_PER_PAGE)
     115             : #define MultiXactIdToOffsetSegment(xid) (MultiXactIdToOffsetPage(xid) / SLRU_PAGES_PER_SEGMENT)
     116             : 
     117             : /*
     118             :  * The situation for members is a bit more complex: we store one byte of
     119             :  * additional flag bits for each TransactionId.  To do this without getting
     120             :  * into alignment issues, we store four bytes of flags, and then the
     121             :  * corresponding 4 Xids.  Each such 5-word (20-byte) set we call a "group", and
     122             :  * are stored as a whole in pages.  Thus, with 8kB BLCKSZ, we keep 409 groups
     123             :  * per page.  This wastes 12 bytes per page, but that's OK -- simplicity (and
     124             :  * performance) trumps space efficiency here.
     125             :  *
     126             :  * Note that the "offset" macros work with byte offset, not array indexes, so
     127             :  * arithmetic must be done using "char *" pointers.
     128             :  */
     129             : /* We need eight bits per xact, so one xact fits in a byte */
     130             : #define MXACT_MEMBER_BITS_PER_XACT          8
     131             : #define MXACT_MEMBER_FLAGS_PER_BYTE         1
     132             : #define MXACT_MEMBER_XACT_BITMASK   ((1 << MXACT_MEMBER_BITS_PER_XACT) - 1)
     133             : 
     134             : /* how many full bytes of flags are there in a group? */
     135             : #define MULTIXACT_FLAGBYTES_PER_GROUP       4
     136             : #define MULTIXACT_MEMBERS_PER_MEMBERGROUP   \
     137             :     (MULTIXACT_FLAGBYTES_PER_GROUP * MXACT_MEMBER_FLAGS_PER_BYTE)
     138             : /* size in bytes of a complete group */
     139             : #define MULTIXACT_MEMBERGROUP_SIZE \
     140             :     (sizeof(TransactionId) * MULTIXACT_MEMBERS_PER_MEMBERGROUP + MULTIXACT_FLAGBYTES_PER_GROUP)
     141             : #define MULTIXACT_MEMBERGROUPS_PER_PAGE (BLCKSZ / MULTIXACT_MEMBERGROUP_SIZE)
     142             : #define MULTIXACT_MEMBERS_PER_PAGE  \
     143             :     (MULTIXACT_MEMBERGROUPS_PER_PAGE * MULTIXACT_MEMBERS_PER_MEMBERGROUP)
     144             : 
     145             : /*
     146             :  * Because the number of items per page is not a divisor of the last item
     147             :  * number (member 0xFFFFFFFF), the last segment does not use the maximum number
     148             :  * of pages, and moreover the last used page therein does not use the same
     149             :  * number of items as previous pages.  (Another way to say it is that the
     150             :  * 0xFFFFFFFF member is somewhere in the middle of the last page, so the page
     151             :  * has some empty space after that item.)
     152             :  *
     153             :  * This constant is the number of members in the last page of the last segment.
     154             :  */
     155             : #define MAX_MEMBERS_IN_LAST_MEMBERS_PAGE \
     156             :         ((uint32) ((0xFFFFFFFF % MULTIXACT_MEMBERS_PER_PAGE) + 1))
     157             : 
     158             : /* page in which a member is to be found */
     159             : #define MXOffsetToMemberPage(xid) ((xid) / (TransactionId) MULTIXACT_MEMBERS_PER_PAGE)
     160             : #define MXOffsetToMemberSegment(xid) (MXOffsetToMemberPage(xid) / SLRU_PAGES_PER_SEGMENT)
     161             : 
     162             : /* Location (byte offset within page) of flag word for a given member */
     163             : #define MXOffsetToFlagsOffset(xid) \
     164             :     ((((xid) / (TransactionId) MULTIXACT_MEMBERS_PER_MEMBERGROUP) % \
     165             :       (TransactionId) MULTIXACT_MEMBERGROUPS_PER_PAGE) * \
     166             :      (TransactionId) MULTIXACT_MEMBERGROUP_SIZE)
     167             : #define MXOffsetToFlagsBitShift(xid) \
     168             :     (((xid) % (TransactionId) MULTIXACT_MEMBERS_PER_MEMBERGROUP) * \
     169             :      MXACT_MEMBER_BITS_PER_XACT)
     170             : 
     171             : /* Location (byte offset within page) of TransactionId of given member */
     172             : #define MXOffsetToMemberOffset(xid) \
     173             :     (MXOffsetToFlagsOffset(xid) + MULTIXACT_FLAGBYTES_PER_GROUP + \
     174             :      ((xid) % MULTIXACT_MEMBERS_PER_MEMBERGROUP) * sizeof(TransactionId))
     175             : 
     176             : /* Multixact members wraparound thresholds. */
     177             : #define MULTIXACT_MEMBER_SAFE_THRESHOLD     (MaxMultiXactOffset / 2)
     178             : #define MULTIXACT_MEMBER_DANGER_THRESHOLD   \
     179             :     (MaxMultiXactOffset - MaxMultiXactOffset / 4)
     180             : 
     181             : #define PreviousMultiXactId(xid) \
     182             :     ((xid) == FirstMultiXactId ? MaxMultiXactId : (xid) - 1)
     183             : 
     184             : /*
     185             :  * Links to shared-memory data structures for MultiXact control
     186             :  */
     187             : static SlruCtlData MultiXactOffsetCtlData;
     188             : static SlruCtlData MultiXactMemberCtlData;
     189             : 
     190             : #define MultiXactOffsetCtl  (&MultiXactOffsetCtlData)
     191             : #define MultiXactMemberCtl  (&MultiXactMemberCtlData)
     192             : 
     193             : /*
     194             :  * MultiXact state shared across all backends.  All this state is protected
     195             :  * by MultiXactGenLock.  (We also use MultiXactOffsetControlLock and
     196             :  * MultiXactMemberControlLock to guard accesses to the two sets of SLRU
     197             :  * buffers.  For concurrency's sake, we avoid holding more than one of these
     198             :  * locks at a time.)
     199             :  */
     200             : typedef struct MultiXactStateData
     201             : {
     202             :     /* next-to-be-assigned MultiXactId */
     203             :     MultiXactId nextMXact;
     204             : 
     205             :     /* next-to-be-assigned offset */
     206             :     MultiXactOffset nextOffset;
     207             : 
     208             :     /* Have we completed multixact startup? */
     209             :     bool        finishedStartup;
     210             : 
     211             :     /*
     212             :      * Oldest multixact that is still potentially referenced by a relation.
     213             :      * Anything older than this should not be consulted.  These values are
     214             :      * updated by vacuum.
     215             :      */
     216             :     MultiXactId oldestMultiXactId;
     217             :     Oid         oldestMultiXactDB;
     218             : 
     219             :     /*
     220             :      * Oldest multixact offset that is potentially referenced by a multixact
     221             :      * referenced by a relation.  We don't always know this value, so there's
     222             :      * a flag here to indicate whether or not we currently do.
     223             :      */
     224             :     MultiXactOffset oldestOffset;
     225             :     bool        oldestOffsetKnown;
     226             : 
     227             :     /* support for anti-wraparound measures */
     228             :     MultiXactId multiVacLimit;
     229             :     MultiXactId multiWarnLimit;
     230             :     MultiXactId multiStopLimit;
     231             :     MultiXactId multiWrapLimit;
     232             : 
     233             :     /* support for members anti-wraparound measures */
     234             :     MultiXactOffset offsetStopLimit;    /* known if oldestOffsetKnown */
     235             : 
     236             :     /*
     237             :      * Per-backend data starts here.  We have two arrays stored in the area
     238             :      * immediately following the MultiXactStateData struct. Each is indexed by
     239             :      * BackendId.
     240             :      *
     241             :      * In both arrays, there's a slot for all normal backends (1..MaxBackends)
     242             :      * followed by a slot for max_prepared_xacts prepared transactions. Valid
     243             :      * BackendIds start from 1; element zero of each array is never used.
     244             :      *
     245             :      * OldestMemberMXactId[k] is the oldest MultiXactId each backend's current
     246             :      * transaction(s) could possibly be a member of, or InvalidMultiXactId
     247             :      * when the backend has no live transaction that could possibly be a
     248             :      * member of a MultiXact.  Each backend sets its entry to the current
     249             :      * nextMXact counter just before first acquiring a shared lock in a given
     250             :      * transaction, and clears it at transaction end. (This works because only
     251             :      * during or after acquiring a shared lock could an XID possibly become a
     252             :      * member of a MultiXact, and that MultiXact would have to be created
     253             :      * during or after the lock acquisition.)
     254             :      *
     255             :      * OldestVisibleMXactId[k] is the oldest MultiXactId each backend's
     256             :      * current transaction(s) think is potentially live, or InvalidMultiXactId
     257             :      * when not in a transaction or not in a transaction that's paid any
     258             :      * attention to MultiXacts yet.  This is computed when first needed in a
     259             :      * given transaction, and cleared at transaction end.  We can compute it
     260             :      * as the minimum of the valid OldestMemberMXactId[] entries at the time
     261             :      * we compute it (using nextMXact if none are valid).  Each backend is
     262             :      * required not to attempt to access any SLRU data for MultiXactIds older
     263             :      * than its own OldestVisibleMXactId[] setting; this is necessary because
     264             :      * the checkpointer could truncate away such data at any instant.
     265             :      *
     266             :      * The oldest valid value among all of the OldestMemberMXactId[] and
     267             :      * OldestVisibleMXactId[] entries is considered by vacuum as the earliest
     268             :      * possible value still having any live member transaction.  Subtracting
     269             :      * vacuum_multixact_freeze_min_age from that value we obtain the freezing
     270             :      * point for multixacts for that table.  Any value older than that is
     271             :      * removed from tuple headers (or "frozen"; see FreezeMultiXactId.  Note
     272             :      * that multis that have member xids that are older than the cutoff point
     273             :      * for xids must also be frozen, even if the multis themselves are newer
     274             :      * than the multixid cutoff point).  Whenever a full table vacuum happens,
     275             :      * the freezing point so computed is used as the new pg_class.relminmxid
     276             :      * value.  The minimum of all those values in a database is stored as
     277             :      * pg_database.datminmxid.  In turn, the minimum of all of those values is
     278             :      * stored in pg_control and used as truncation point for pg_multixact.  At
     279             :      * checkpoint or restartpoint, unneeded segments are removed.
     280             :      */
     281             :     MultiXactId perBackendXactIds[FLEXIBLE_ARRAY_MEMBER];
     282             : } MultiXactStateData;
     283             : 
     284             : /*
     285             :  * Last element of OldestMemberMXactId and OldestVisibleMXactId arrays.
     286             :  * Valid elements are (1..MaxOldestSlot); element 0 is never used.
     287             :  */
     288             : #define MaxOldestSlot   (MaxBackends + max_prepared_xacts)
     289             : 
     290             : /* Pointers to the state data in shared memory */
     291             : static MultiXactStateData *MultiXactState;
     292             : static MultiXactId *OldestMemberMXactId;
     293             : static MultiXactId *OldestVisibleMXactId;
     294             : 
     295             : 
     296             : /*
     297             :  * Definitions for the backend-local MultiXactId cache.
     298             :  *
     299             :  * We use this cache to store known MultiXacts, so we don't need to go to
     300             :  * SLRU areas every time.
     301             :  *
     302             :  * The cache lasts for the duration of a single transaction, the rationale
     303             :  * for this being that most entries will contain our own TransactionId and
     304             :  * so they will be uninteresting by the time our next transaction starts.
     305             :  * (XXX not clear that this is correct --- other members of the MultiXact
     306             :  * could hang around longer than we did.  However, it's not clear what a
     307             :  * better policy for flushing old cache entries would be.)  FIXME actually
     308             :  * this is plain wrong now that multixact's may contain update Xids.
     309             :  *
     310             :  * We allocate the cache entries in a memory context that is deleted at
     311             :  * transaction end, so we don't need to do retail freeing of entries.
     312             :  */
     313             : typedef struct mXactCacheEnt
     314             : {
     315             :     MultiXactId multi;
     316             :     int         nmembers;
     317             :     dlist_node  node;
     318             :     MultiXactMember members[FLEXIBLE_ARRAY_MEMBER];
     319             : } mXactCacheEnt;
     320             : 
     321             : #define MAX_CACHE_ENTRIES   256
     322             : static dlist_head MXactCache = DLIST_STATIC_INIT(MXactCache);
     323             : static int  MXactCacheMembers = 0;
     324             : static MemoryContext MXactContext = NULL;
     325             : 
     326             : #ifdef MULTIXACT_DEBUG
     327             : #define debug_elog2(a,b) elog(a,b)
     328             : #define debug_elog3(a,b,c) elog(a,b,c)
     329             : #define debug_elog4(a,b,c,d) elog(a,b,c,d)
     330             : #define debug_elog5(a,b,c,d,e) elog(a,b,c,d,e)
     331             : #define debug_elog6(a,b,c,d,e,f) elog(a,b,c,d,e,f)
     332             : #else
     333             : #define debug_elog2(a,b)
     334             : #define debug_elog3(a,b,c)
     335             : #define debug_elog4(a,b,c,d)
     336             : #define debug_elog5(a,b,c,d,e)
     337             : #define debug_elog6(a,b,c,d,e,f)
     338             : #endif
     339             : 
     340             : /* internal MultiXactId management */
     341             : static void MultiXactIdSetOldestVisible(void);
     342             : static void RecordNewMultiXact(MultiXactId multi, MultiXactOffset offset,
     343             :                                int nmembers, MultiXactMember *members);
     344             : static MultiXactId GetNewMultiXactId(int nmembers, MultiXactOffset *offset);
     345             : 
     346             : /* MultiXact cache management */
     347             : static int  mxactMemberComparator(const void *arg1, const void *arg2);
     348             : static MultiXactId mXactCacheGetBySet(int nmembers, MultiXactMember *members);
     349             : static int  mXactCacheGetById(MultiXactId multi, MultiXactMember **members);
     350             : static void mXactCachePut(MultiXactId multi, int nmembers,
     351             :                           MultiXactMember *members);
     352             : 
     353             : static char *mxstatus_to_string(MultiXactStatus status);
     354             : 
     355             : /* management of SLRU infrastructure */
     356             : static int  ZeroMultiXactOffsetPage(int pageno, bool writeXlog);
     357             : static int  ZeroMultiXactMemberPage(int pageno, bool writeXlog);
     358             : static bool MultiXactOffsetPagePrecedes(int page1, int page2);
     359             : static bool MultiXactMemberPagePrecedes(int page1, int page2);
     360             : static bool MultiXactOffsetPrecedes(MultiXactOffset offset1,
     361             :                                     MultiXactOffset offset2);
     362             : static void ExtendMultiXactOffset(MultiXactId multi);
     363             : static void ExtendMultiXactMember(MultiXactOffset offset, int nmembers);
     364             : static bool MultiXactOffsetWouldWrap(MultiXactOffset boundary,
     365             :                                      MultiXactOffset start, uint32 distance);
     366             : static bool SetOffsetVacuumLimit(bool is_startup);
     367             : static bool find_multixact_start(MultiXactId multi, MultiXactOffset *result);
     368             : static void WriteMZeroPageXlogRec(int pageno, uint8 info);
     369             : static void WriteMTruncateXlogRec(Oid oldestMultiDB,
     370             :                                   MultiXactId startTruncOff,
     371             :                                   MultiXactId endTruncOff,
     372             :                                   MultiXactOffset startTruncMemb,
     373             :                                   MultiXactOffset endTruncMemb);
     374             : 
     375             : 
     376             : /*
     377             :  * MultiXactIdCreate
     378             :  *      Construct a MultiXactId representing two TransactionIds.
     379             :  *
     380             :  * The two XIDs must be different, or be requesting different statuses.
     381             :  *
     382             :  * NB - we don't worry about our local MultiXactId cache here, because that
     383             :  * is handled by the lower-level routines.
     384             :  */
     385             : MultiXactId
     386        1896 : MultiXactIdCreate(TransactionId xid1, MultiXactStatus status1,
     387             :                   TransactionId xid2, MultiXactStatus status2)
     388             : {
     389             :     MultiXactId newMulti;
     390             :     MultiXactMember members[2];
     391             : 
     392             :     AssertArg(TransactionIdIsValid(xid1));
     393             :     AssertArg(TransactionIdIsValid(xid2));
     394             : 
     395             :     Assert(!TransactionIdEquals(xid1, xid2) || (status1 != status2));
     396             : 
     397             :     /* MultiXactIdSetOldestMember() must have been called already. */
     398             :     Assert(MultiXactIdIsValid(OldestMemberMXactId[MyBackendId]));
     399             : 
     400             :     /*
     401             :      * Note: unlike MultiXactIdExpand, we don't bother to check that both XIDs
     402             :      * are still running.  In typical usage, xid2 will be our own XID and the
     403             :      * caller just did a check on xid1, so it'd be wasted effort.
     404             :      */
     405             : 
     406        1896 :     members[0].xid = xid1;
     407        1896 :     members[0].status = status1;
     408        1896 :     members[1].xid = xid2;
     409        1896 :     members[1].status = status2;
     410             : 
     411        1896 :     newMulti = MultiXactIdCreateFromMembers(2, members);
     412             : 
     413             :     debug_elog3(DEBUG2, "Create: %s",
     414             :                 mxid_to_string(newMulti, 2, members));
     415             : 
     416        1896 :     return newMulti;
     417             : }
     418             : 
     419             : /*
     420             :  * MultiXactIdExpand
     421             :  *      Add a TransactionId to a pre-existing MultiXactId.
     422             :  *
     423             :  * If the TransactionId is already a member of the passed MultiXactId with the
     424             :  * same status, just return it as-is.
     425             :  *
     426             :  * Note that we do NOT actually modify the membership of a pre-existing
     427             :  * MultiXactId; instead we create a new one.  This is necessary to avoid
     428             :  * a race condition against code trying to wait for one MultiXactId to finish;
     429             :  * see notes in heapam.c.
     430             :  *
     431             :  * NB - we don't worry about our local MultiXactId cache here, because that
     432             :  * is handled by the lower-level routines.
     433             :  *
     434             :  * Note: It is critical that MultiXactIds that come from an old cluster (i.e.
     435             :  * one upgraded by pg_upgrade from a cluster older than this feature) are not
     436             :  * passed in.
     437             :  */
     438             : MultiXactId
     439         162 : MultiXactIdExpand(MultiXactId multi, TransactionId xid, MultiXactStatus status)
     440             : {
     441             :     MultiXactId newMulti;
     442             :     MultiXactMember *members;
     443             :     MultiXactMember *newMembers;
     444             :     int         nmembers;
     445             :     int         i;
     446             :     int         j;
     447             : 
     448             :     AssertArg(MultiXactIdIsValid(multi));
     449             :     AssertArg(TransactionIdIsValid(xid));
     450             : 
     451             :     /* MultiXactIdSetOldestMember() must have been called already. */
     452             :     Assert(MultiXactIdIsValid(OldestMemberMXactId[MyBackendId]));
     453             : 
     454             :     debug_elog5(DEBUG2, "Expand: received multi %u, xid %u status %s",
     455             :                 multi, xid, mxstatus_to_string(status));
     456             : 
     457             :     /*
     458             :      * Note: we don't allow for old multis here.  The reason is that the only
     459             :      * caller of this function does a check that the multixact is no longer
     460             :      * running.
     461             :      */
     462         162 :     nmembers = GetMultiXactIdMembers(multi, &members, false, false);
     463             : 
     464         162 :     if (nmembers < 0)
     465             :     {
     466             :         MultiXactMember member;
     467             : 
     468             :         /*
     469             :          * The MultiXactId is obsolete.  This can only happen if all the
     470             :          * MultiXactId members stop running between the caller checking and
     471             :          * passing it to us.  It would be better to return that fact to the
     472             :          * caller, but it would complicate the API and it's unlikely to happen
     473             :          * too often, so just deal with it by creating a singleton MultiXact.
     474             :          */
     475           0 :         member.xid = xid;
     476           0 :         member.status = status;
     477           0 :         newMulti = MultiXactIdCreateFromMembers(1, &member);
     478             : 
     479             :         debug_elog4(DEBUG2, "Expand: %u has no members, create singleton %u",
     480             :                     multi, newMulti);
     481           0 :         return newMulti;
     482             :     }
     483             : 
     484             :     /*
     485             :      * If the TransactionId is already a member of the MultiXactId with the
     486             :      * same status, just return the existing MultiXactId.
     487             :      */
     488         506 :     for (i = 0; i < nmembers; i++)
     489             :     {
     490         434 :         if (TransactionIdEquals(members[i].xid, xid) &&
     491          90 :             (members[i].status == status))
     492             :         {
     493             :             debug_elog4(DEBUG2, "Expand: %u is already a member of %u",
     494             :                         xid, multi);
     495           0 :             pfree(members);
     496           0 :             return multi;
     497             :         }
     498             :     }
     499             : 
     500             :     /*
     501             :      * Determine which of the members of the MultiXactId are still of
     502             :      * interest. This is any running transaction, and also any transaction
     503             :      * that grabbed something stronger than just a lock and was committed. (An
     504             :      * update that aborted is of no interest here; and having more than one
     505             :      * update Xid in a multixact would cause errors elsewhere.)
     506             :      *
     507             :      * Removing dead members is not just an optimization: freezing of tuples
     508             :      * whose Xmax are multis depends on this behavior.
     509             :      *
     510             :      * Note we have the same race condition here as above: j could be 0 at the
     511             :      * end of the loop.
     512             :      */
     513         162 :     newMembers = (MultiXactMember *)
     514         162 :         palloc(sizeof(MultiXactMember) * (nmembers + 1));
     515             : 
     516         506 :     for (i = 0, j = 0; i < nmembers; i++)
     517             :     {
     518         424 :         if (TransactionIdIsInProgress(members[i].xid) ||
     519          90 :             (ISUPDATE_from_mxstatus(members[i].status) &&
     520          10 :              TransactionIdDidCommit(members[i].xid)))
     521             :         {
     522         264 :             newMembers[j].xid = members[i].xid;
     523         264 :             newMembers[j++].status = members[i].status;
     524             :         }
     525             :     }
     526             : 
     527         162 :     newMembers[j].xid = xid;
     528         162 :     newMembers[j++].status = status;
     529         162 :     newMulti = MultiXactIdCreateFromMembers(j, newMembers);
     530             : 
     531         162 :     pfree(members);
     532         162 :     pfree(newMembers);
     533             : 
     534             :     debug_elog3(DEBUG2, "Expand: returning new multi %u", newMulti);
     535             : 
     536         162 :     return newMulti;
     537             : }
     538             : 
     539             : /*
     540             :  * MultiXactIdIsRunning
     541             :  *      Returns whether a MultiXactId is "running".
     542             :  *
     543             :  * We return true if at least one member of the given MultiXactId is still
     544             :  * running.  Note that a "false" result is certain not to change,
     545             :  * because it is not legal to add members to an existing MultiXactId.
     546             :  *
     547             :  * Caller is expected to have verified that the multixact does not come from
     548             :  * a pg_upgraded share-locked tuple.
     549             :  */
     550             : bool
     551        1712 : MultiXactIdIsRunning(MultiXactId multi, bool isLockOnly)
     552             : {
     553             :     MultiXactMember *members;
     554             :     int         nmembers;
     555             :     int         i;
     556             : 
     557             :     debug_elog3(DEBUG2, "IsRunning %u?", multi);
     558             : 
     559             :     /*
     560             :      * "false" here means we assume our callers have checked that the given
     561             :      * multi cannot possibly come from a pg_upgraded database.
     562             :      */
     563        1712 :     nmembers = GetMultiXactIdMembers(multi, &members, false, isLockOnly);
     564             : 
     565        1712 :     if (nmembers <= 0)
     566             :     {
     567             :         debug_elog2(DEBUG2, "IsRunning: no members");
     568        1180 :         return false;
     569             :     }
     570             : 
     571             :     /*
     572             :      * Checking for myself is cheap compared to looking in shared memory;
     573             :      * return true if any live subtransaction of the current top-level
     574             :      * transaction is a member.
     575             :      *
     576             :      * This is not needed for correctness, it's just a fast path.
     577             :      */
     578        1350 :     for (i = 0; i < nmembers; i++)
     579             :     {
     580        1034 :         if (TransactionIdIsCurrentTransactionId(members[i].xid))
     581             :         {
     582             :             debug_elog3(DEBUG2, "IsRunning: I (%d) am running!", i);
     583         216 :             pfree(members);
     584         216 :             return true;
     585             :         }
     586             :     }
     587             : 
     588             :     /*
     589             :      * This could be made faster by having another entry point in procarray.c,
     590             :      * walking the PGPROC array only once for all the members.  But in most
     591             :      * cases nmembers should be small enough that it doesn't much matter.
     592             :      */
     593         590 :     for (i = 0; i < nmembers; i++)
     594             :     {
     595         492 :         if (TransactionIdIsInProgress(members[i].xid))
     596             :         {
     597             :             debug_elog4(DEBUG2, "IsRunning: member %d (%u) is running",
     598             :                         i, members[i].xid);
     599         218 :             pfree(members);
     600         218 :             return true;
     601             :         }
     602             :     }
     603             : 
     604          98 :     pfree(members);
     605             : 
     606             :     debug_elog3(DEBUG2, "IsRunning: %u is not running", multi);
     607             : 
     608          98 :     return false;
     609             : }
     610             : 
     611             : /*
     612             :  * MultiXactIdSetOldestMember
     613             :  *      Save the oldest MultiXactId this transaction could be a member of.
     614             :  *
     615             :  * We set the OldestMemberMXactId for a given transaction the first time it's
     616             :  * going to do some operation that might require a MultiXactId (tuple lock,
     617             :  * update or delete).  We need to do this even if we end up using a
     618             :  * TransactionId instead of a MultiXactId, because there is a chance that
     619             :  * another transaction would add our XID to a MultiXactId.
     620             :  *
     621             :  * The value to set is the next-to-be-assigned MultiXactId, so this is meant to
     622             :  * be called just before doing any such possibly-MultiXactId-able operation.
     623             :  */
     624             : void
     625     1888378 : MultiXactIdSetOldestMember(void)
     626             : {
     627     1888378 :     if (!MultiXactIdIsValid(OldestMemberMXactId[MyBackendId]))
     628             :     {
     629             :         MultiXactId nextMXact;
     630             : 
     631             :         /*
     632             :          * You might think we don't need to acquire a lock here, since
     633             :          * fetching and storing of TransactionIds is probably atomic, but in
     634             :          * fact we do: suppose we pick up nextMXact and then lose the CPU for
     635             :          * a long time.  Someone else could advance nextMXact, and then
     636             :          * another someone else could compute an OldestVisibleMXactId that
     637             :          * would be after the value we are going to store when we get control
     638             :          * back.  Which would be wrong.
     639             :          *
     640             :          * Note that a shared lock is sufficient, because it's enough to stop
     641             :          * someone from advancing nextMXact; and nobody else could be trying
     642             :          * to write to our OldestMember entry, only reading (and we assume
     643             :          * storing it is atomic.)
     644             :          */
     645      133770 :         LWLockAcquire(MultiXactGenLock, LW_SHARED);
     646             : 
     647             :         /*
     648             :          * We have to beware of the possibility that nextMXact is in the
     649             :          * wrapped-around state.  We don't fix the counter itself here, but we
     650             :          * must be sure to store a valid value in our array entry.
     651             :          */
     652      133770 :         nextMXact = MultiXactState->nextMXact;
     653      133770 :         if (nextMXact < FirstMultiXactId)
     654           0 :             nextMXact = FirstMultiXactId;
     655             : 
     656      133770 :         OldestMemberMXactId[MyBackendId] = nextMXact;
     657             : 
     658      133770 :         LWLockRelease(MultiXactGenLock);
     659             : 
     660             :         debug_elog4(DEBUG2, "MultiXact: setting OldestMember[%d] = %u",
     661             :                     MyBackendId, nextMXact);
     662             :     }
     663     1888378 : }
     664             : 
     665             : /*
     666             :  * MultiXactIdSetOldestVisible
     667             :  *      Save the oldest MultiXactId this transaction considers possibly live.
     668             :  *
     669             :  * We set the OldestVisibleMXactId for a given transaction the first time
     670             :  * it's going to inspect any MultiXactId.  Once we have set this, we are
     671             :  * guaranteed that the checkpointer won't truncate off SLRU data for
     672             :  * MultiXactIds at or after our OldestVisibleMXactId.
     673             :  *
     674             :  * The value to set is the oldest of nextMXact and all the valid per-backend
     675             :  * OldestMemberMXactId[] entries.  Because of the locking we do, we can be
     676             :  * certain that no subsequent call to MultiXactIdSetOldestMember can set
     677             :  * an OldestMemberMXactId[] entry older than what we compute here.  Therefore
     678             :  * there is no live transaction, now or later, that can be a member of any
     679             :  * MultiXactId older than the OldestVisibleMXactId we compute here.
     680             :  */
     681             : static void
     682        1544 : MultiXactIdSetOldestVisible(void)
     683             : {
     684        1544 :     if (!MultiXactIdIsValid(OldestVisibleMXactId[MyBackendId]))
     685             :     {
     686             :         MultiXactId oldestMXact;
     687             :         int         i;
     688             : 
     689         376 :         LWLockAcquire(MultiXactGenLock, LW_EXCLUSIVE);
     690             : 
     691             :         /*
     692             :          * We have to beware of the possibility that nextMXact is in the
     693             :          * wrapped-around state.  We don't fix the counter itself here, but we
     694             :          * must be sure to store a valid value in our array entry.
     695             :          */
     696         376 :         oldestMXact = MultiXactState->nextMXact;
     697         376 :         if (oldestMXact < FirstMultiXactId)
     698           0 :             oldestMXact = FirstMultiXactId;
     699             : 
     700       45896 :         for (i = 1; i <= MaxOldestSlot; i++)
     701             :         {
     702       45520 :             MultiXactId thisoldest = OldestMemberMXactId[i];
     703             : 
     704       45992 :             if (MultiXactIdIsValid(thisoldest) &&
     705         472 :                 MultiXactIdPrecedes(thisoldest, oldestMXact))
     706         228 :                 oldestMXact = thisoldest;
     707             :         }
     708             : 
     709         376 :         OldestVisibleMXactId[MyBackendId] = oldestMXact;
     710             : 
     711         376 :         LWLockRelease(MultiXactGenLock);
     712             : 
     713             :         debug_elog4(DEBUG2, "MultiXact: setting OldestVisible[%d] = %u",
     714             :                     MyBackendId, oldestMXact);
     715             :     }
     716        1544 : }
     717             : 
     718             : /*
     719             :  * ReadNextMultiXactId
     720             :  *      Return the next MultiXactId to be assigned, but don't allocate it
     721             :  */
     722             : MultiXactId
     723       89266 : ReadNextMultiXactId(void)
     724             : {
     725             :     MultiXactId mxid;
     726             : 
     727             :     /* XXX we could presumably do this without a lock. */
     728       89266 :     LWLockAcquire(MultiXactGenLock, LW_SHARED);
     729       89266 :     mxid = MultiXactState->nextMXact;
     730       89266 :     LWLockRelease(MultiXactGenLock);
     731             : 
     732       89266 :     if (mxid < FirstMultiXactId)
     733           0 :         mxid = FirstMultiXactId;
     734             : 
     735       89266 :     return mxid;
     736             : }
     737             : 
     738             : /*
     739             :  * MultiXactIdCreateFromMembers
     740             :  *      Make a new MultiXactId from the specified set of members
     741             :  *
     742             :  * Make XLOG, SLRU and cache entries for a new MultiXactId, recording the
     743             :  * given TransactionIds as members.  Returns the newly created MultiXactId.
     744             :  *
     745             :  * NB: the passed members[] array will be sorted in-place.
     746             :  */
     747             : MultiXactId
     748        2060 : MultiXactIdCreateFromMembers(int nmembers, MultiXactMember *members)
     749             : {
     750             :     MultiXactId multi;
     751             :     MultiXactOffset offset;
     752             :     xl_multixact_create xlrec;
     753             : 
     754             :     debug_elog3(DEBUG2, "Create: %s",
     755             :                 mxid_to_string(InvalidMultiXactId, nmembers, members));
     756             : 
     757             :     /*
     758             :      * See if the same set of members already exists in our cache; if so, just
     759             :      * re-use that MultiXactId.  (Note: it might seem that looking in our
     760             :      * cache is insufficient, and we ought to search disk to see if a
     761             :      * duplicate definition already exists.  But since we only ever create
     762             :      * MultiXacts containing our own XID, in most cases any such MultiXacts
     763             :      * were in fact created by us, and so will be in our cache.  There are
     764             :      * corner cases where someone else added us to a MultiXact without our
     765             :      * knowledge, but it's not worth checking for.)
     766             :      */
     767        2060 :     multi = mXactCacheGetBySet(nmembers, members);
     768        2060 :     if (MultiXactIdIsValid(multi))
     769             :     {
     770             :         debug_elog2(DEBUG2, "Create: in cache!");
     771        1566 :         return multi;
     772             :     }
     773             : 
     774             :     /* Verify that there is a single update Xid among the given members. */
     775             :     {
     776             :         int         i;
     777         494 :         bool        has_update = false;
     778             : 
     779        1580 :         for (i = 0; i < nmembers; i++)
     780             :         {
     781        1086 :             if (ISUPDATE_from_mxstatus(members[i].status))
     782             :             {
     783         224 :                 if (has_update)
     784           0 :                     elog(ERROR, "new multixact has more than one updating member");
     785         224 :                 has_update = true;
     786             :             }
     787             :         }
     788             :     }
     789             : 
     790             :     /*
     791             :      * Assign the MXID and offsets range to use, and make sure there is space
     792             :      * in the OFFSETs and MEMBERs files.  NB: this routine does
     793             :      * START_CRIT_SECTION().
     794             :      *
     795             :      * Note: unlike MultiXactIdCreate and MultiXactIdExpand, we do not check
     796             :      * that we've called MultiXactIdSetOldestMember here.  This is because
     797             :      * this routine is used in some places to create new MultiXactIds of which
     798             :      * the current backend is not a member, notably during freezing of multis
     799             :      * in vacuum.  During vacuum, in particular, it would be unacceptable to
     800             :      * keep OldestMulti set, in case it runs for long.
     801             :      */
     802         494 :     multi = GetNewMultiXactId(nmembers, &offset);
     803             : 
     804             :     /* Make an XLOG entry describing the new MXID. */
     805         494 :     xlrec.mid = multi;
     806         494 :     xlrec.moff = offset;
     807         494 :     xlrec.nmembers = nmembers;
     808             : 
     809             :     /*
     810             :      * XXX Note: there's a lot of padding space in MultiXactMember.  We could
     811             :      * find a more compact representation of this Xlog record -- perhaps all
     812             :      * the status flags in one XLogRecData, then all the xids in another one?
     813             :      * Not clear that it's worth the trouble though.
     814             :      */
     815         494 :     XLogBeginInsert();
     816         494 :     XLogRegisterData((char *) (&xlrec), SizeOfMultiXactCreate);
     817         494 :     XLogRegisterData((char *) members, nmembers * sizeof(MultiXactMember));
     818             : 
     819         494 :     (void) XLogInsert(RM_MULTIXACT_ID, XLOG_MULTIXACT_CREATE_ID);
     820             : 
     821             :     /* Now enter the information into the OFFSETs and MEMBERs logs */
     822         494 :     RecordNewMultiXact(multi, offset, nmembers, members);
     823             : 
     824             :     /* Done with critical section */
     825         494 :     END_CRIT_SECTION();
     826             : 
     827             :     /* Store the new MultiXactId in the local cache, too */
     828         494 :     mXactCachePut(multi, nmembers, members);
     829             : 
     830             :     debug_elog2(DEBUG2, "Create: all done");
     831             : 
     832         494 :     return multi;
     833             : }
     834             : 
     835             : /*
     836             :  * RecordNewMultiXact
     837             :  *      Write info about a new multixact into the offsets and members files
     838             :  *
     839             :  * This is broken out of MultiXactIdCreateFromMembers so that xlog replay can
     840             :  * use it.
     841             :  */
     842             : static void
     843         494 : RecordNewMultiXact(MultiXactId multi, MultiXactOffset offset,
     844             :                    int nmembers, MultiXactMember *members)
     845             : {
     846             :     int         pageno;
     847             :     int         prev_pageno;
     848             :     int         entryno;
     849             :     int         slotno;
     850             :     MultiXactOffset *offptr;
     851             :     int         i;
     852             : 
     853         494 :     LWLockAcquire(MultiXactOffsetControlLock, LW_EXCLUSIVE);
     854             : 
     855         494 :     pageno = MultiXactIdToOffsetPage(multi);
     856         494 :     entryno = MultiXactIdToOffsetEntry(multi);
     857             : 
     858             :     /*
     859             :      * Note: we pass the MultiXactId to SimpleLruReadPage as the "transaction"
     860             :      * to complain about if there's any I/O error.  This is kinda bogus, but
     861             :      * since the errors will always give the full pathname, it should be clear
     862             :      * enough that a MultiXactId is really involved.  Perhaps someday we'll
     863             :      * take the trouble to generalize the slru.c error reporting code.
     864             :      */
     865         494 :     slotno = SimpleLruReadPage(MultiXactOffsetCtl, pageno, true, multi);
     866         494 :     offptr = (MultiXactOffset *) MultiXactOffsetCtl->shared->page_buffer[slotno];
     867         494 :     offptr += entryno;
     868             : 
     869         494 :     *offptr = offset;
     870             : 
     871         494 :     MultiXactOffsetCtl->shared->page_dirty[slotno] = true;
     872             : 
     873             :     /* Exchange our lock */
     874         494 :     LWLockRelease(MultiXactOffsetControlLock);
     875             : 
     876         494 :     LWLockAcquire(MultiXactMemberControlLock, LW_EXCLUSIVE);
     877             : 
     878         494 :     prev_pageno = -1;
     879             : 
     880        1580 :     for (i = 0; i < nmembers; i++, offset++)
     881             :     {
     882             :         TransactionId *memberptr;
     883             :         uint32     *flagsptr;
     884             :         uint32      flagsval;
     885             :         int         bshift;
     886             :         int         flagsoff;
     887             :         int         memberoff;
     888             : 
     889             :         Assert(members[i].status <= MultiXactStatusUpdate);
     890             : 
     891        1086 :         pageno = MXOffsetToMemberPage(offset);
     892        1086 :         memberoff = MXOffsetToMemberOffset(offset);
     893        1086 :         flagsoff = MXOffsetToFlagsOffset(offset);
     894        1086 :         bshift = MXOffsetToFlagsBitShift(offset);
     895             : 
     896        1086 :         if (pageno != prev_pageno)
     897             :         {
     898         494 :             slotno = SimpleLruReadPage(MultiXactMemberCtl, pageno, true, multi);
     899         494 :             prev_pageno = pageno;
     900             :         }
     901             : 
     902        1086 :         memberptr = (TransactionId *)
     903        1086 :             (MultiXactMemberCtl->shared->page_buffer[slotno] + memberoff);
     904             : 
     905        1086 :         *memberptr = members[i].xid;
     906             : 
     907        1086 :         flagsptr = (uint32 *)
     908        1086 :             (MultiXactMemberCtl->shared->page_buffer[slotno] + flagsoff);
     909             : 
     910        1086 :         flagsval = *flagsptr;
     911        1086 :         flagsval &= ~(((1 << MXACT_MEMBER_BITS_PER_XACT) - 1) << bshift);
     912        1086 :         flagsval |= (members[i].status << bshift);
     913        1086 :         *flagsptr = flagsval;
     914             : 
     915        1086 :         MultiXactMemberCtl->shared->page_dirty[slotno] = true;
     916             :     }
     917             : 
     918         494 :     LWLockRelease(MultiXactMemberControlLock);
     919         494 : }
     920             : 
     921             : /*
     922             :  * GetNewMultiXactId
     923             :  *      Get the next MultiXactId.
     924             :  *
     925             :  * Also, reserve the needed amount of space in the "members" area.  The
     926             :  * starting offset of the reserved space is returned in *offset.
     927             :  *
     928             :  * This may generate XLOG records for expansion of the offsets and/or members
     929             :  * files.  Unfortunately, we have to do that while holding MultiXactGenLock
     930             :  * to avoid race conditions --- the XLOG record for zeroing a page must appear
     931             :  * before any backend can possibly try to store data in that page!
     932             :  *
     933             :  * We start a critical section before advancing the shared counters.  The
     934             :  * caller must end the critical section after writing SLRU data.
     935             :  */
     936             : static MultiXactId
     937         494 : GetNewMultiXactId(int nmembers, MultiXactOffset *offset)
     938             : {
     939             :     MultiXactId result;
     940             :     MultiXactOffset nextOffset;
     941             : 
     942             :     debug_elog3(DEBUG2, "GetNew: for %d xids", nmembers);
     943             : 
     944             :     /* safety check, we should never get this far in a HS standby */
     945         494 :     if (RecoveryInProgress())
     946           0 :         elog(ERROR, "cannot assign MultiXactIds during recovery");
     947             : 
     948         494 :     LWLockAcquire(MultiXactGenLock, LW_EXCLUSIVE);
     949             : 
     950             :     /* Handle wraparound of the nextMXact counter */
     951         494 :     if (MultiXactState->nextMXact < FirstMultiXactId)
     952           0 :         MultiXactState->nextMXact = FirstMultiXactId;
     953             : 
     954             :     /* Assign the MXID */
     955         494 :     result = MultiXactState->nextMXact;
     956             : 
     957             :     /*----------
     958             :      * Check to see if it's safe to assign another MultiXactId.  This protects
     959             :      * against catastrophic data loss due to multixact wraparound.  The basic
     960             :      * rules are:
     961             :      *
     962             :      * If we're past multiVacLimit or the safe threshold for member storage
     963             :      * space, or we don't know what the safe threshold for member storage is,
     964             :      * start trying to force autovacuum cycles.
     965             :      * If we're past multiWarnLimit, start issuing warnings.
     966             :      * If we're past multiStopLimit, refuse to create new MultiXactIds.
     967             :      *
     968             :      * Note these are pretty much the same protections in GetNewTransactionId.
     969             :      *----------
     970             :      */
     971         494 :     if (!MultiXactIdPrecedes(result, MultiXactState->multiVacLimit))
     972             :     {
     973             :         /*
     974             :          * For safety's sake, we release MultiXactGenLock while sending
     975             :          * signals, warnings, etc.  This is not so much because we care about
     976             :          * preserving concurrency in this situation, as to avoid any
     977             :          * possibility of deadlock while doing get_database_name(). First,
     978             :          * copy all the shared values we'll need in this path.
     979             :          */
     980           0 :         MultiXactId multiWarnLimit = MultiXactState->multiWarnLimit;
     981           0 :         MultiXactId multiStopLimit = MultiXactState->multiStopLimit;
     982           0 :         MultiXactId multiWrapLimit = MultiXactState->multiWrapLimit;
     983           0 :         Oid         oldest_datoid = MultiXactState->oldestMultiXactDB;
     984             : 
     985           0 :         LWLockRelease(MultiXactGenLock);
     986             : 
     987           0 :         if (IsUnderPostmaster &&
     988           0 :             !MultiXactIdPrecedes(result, multiStopLimit))
     989             :         {
     990           0 :             char       *oldest_datname = get_database_name(oldest_datoid);
     991             : 
     992             :             /*
     993             :              * Immediately kick autovacuum into action as we're already in
     994             :              * ERROR territory.
     995             :              */
     996           0 :             SendPostmasterSignal(PMSIGNAL_START_AUTOVAC_LAUNCHER);
     997             : 
     998             :             /* complain even if that DB has disappeared */
     999           0 :             if (oldest_datname)
    1000           0 :                 ereport(ERROR,
    1001             :                         (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
    1002             :                          errmsg("database is not accepting commands that generate new MultiXactIds to avoid wraparound data loss in database \"%s\"",
    1003             :                                 oldest_datname),
    1004             :                          errhint("Execute a database-wide VACUUM in that database.\n"
    1005             :                                  "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
    1006             :             else
    1007           0 :                 ereport(ERROR,
    1008             :                         (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
    1009             :                          errmsg("database is not accepting commands that generate new MultiXactIds to avoid wraparound data loss in database with OID %u",
    1010             :                                 oldest_datoid),
    1011             :                          errhint("Execute a database-wide VACUUM in that database.\n"
    1012             :                                  "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
    1013             :         }
    1014             : 
    1015             :         /*
    1016             :          * To avoid swamping the postmaster with signals, we issue the autovac
    1017             :          * request only once per 64K multis generated.  This still gives
    1018             :          * plenty of chances before we get into real trouble.
    1019             :          */
    1020           0 :         if (IsUnderPostmaster && (result % 65536) == 0)
    1021           0 :             SendPostmasterSignal(PMSIGNAL_START_AUTOVAC_LAUNCHER);
    1022             : 
    1023           0 :         if (!MultiXactIdPrecedes(result, multiWarnLimit))
    1024             :         {
    1025           0 :             char       *oldest_datname = get_database_name(oldest_datoid);
    1026             : 
    1027             :             /* complain even if that DB has disappeared */
    1028           0 :             if (oldest_datname)
    1029           0 :                 ereport(WARNING,
    1030             :                         (errmsg_plural("database \"%s\" must be vacuumed before %u more MultiXactId is used",
    1031             :                                        "database \"%s\" must be vacuumed before %u more MultiXactIds are used",
    1032             :                                        multiWrapLimit - result,
    1033             :                                        oldest_datname,
    1034             :                                        multiWrapLimit - result),
    1035             :                          errhint("Execute a database-wide VACUUM in that database.\n"
    1036             :                                  "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
    1037             :             else
    1038           0 :                 ereport(WARNING,
    1039             :                         (errmsg_plural("database with OID %u must be vacuumed before %u more MultiXactId is used",
    1040             :                                        "database with OID %u must be vacuumed before %u more MultiXactIds are used",
    1041             :                                        multiWrapLimit - result,
    1042             :                                        oldest_datoid,
    1043             :                                        multiWrapLimit - result),
    1044             :                          errhint("Execute a database-wide VACUUM in that database.\n"
    1045             :                                  "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
    1046             :         }
    1047             : 
    1048             :         /* Re-acquire lock and start over */
    1049           0 :         LWLockAcquire(MultiXactGenLock, LW_EXCLUSIVE);
    1050           0 :         result = MultiXactState->nextMXact;
    1051           0 :         if (result < FirstMultiXactId)
    1052           0 :             result = FirstMultiXactId;
    1053             :     }
    1054             : 
    1055             :     /* Make sure there is room for the MXID in the file.  */
    1056         494 :     ExtendMultiXactOffset(result);
    1057             : 
    1058             :     /*
    1059             :      * Reserve the members space, similarly to above.  Also, be careful not to
    1060             :      * return zero as the starting offset for any multixact. See
    1061             :      * GetMultiXactIdMembers() for motivation.
    1062             :      */
    1063         494 :     nextOffset = MultiXactState->nextOffset;
    1064         494 :     if (nextOffset == 0)
    1065             :     {
    1066          12 :         *offset = 1;
    1067          12 :         nmembers++;             /* allocate member slot 0 too */
    1068             :     }
    1069             :     else
    1070         482 :         *offset = nextOffset;
    1071             : 
    1072             :     /*----------
    1073             :      * Protect against overrun of the members space as well, with the
    1074             :      * following rules:
    1075             :      *
    1076             :      * If we're past offsetStopLimit, refuse to generate more multis.
    1077             :      * If we're close to offsetStopLimit, emit a warning.
    1078             :      *
    1079             :      * Arbitrarily, we start emitting warnings when we're 20 segments or less
    1080             :      * from offsetStopLimit.
    1081             :      *
    1082             :      * Note we haven't updated the shared state yet, so if we fail at this
    1083             :      * point, the multixact ID we grabbed can still be used by the next guy.
    1084             :      *
    1085             :      * Note that there is no point in forcing autovacuum runs here: the
    1086             :      * multixact freeze settings would have to be reduced for that to have any
    1087             :      * effect.
    1088             :      *----------
    1089             :      */
    1090             : #define OFFSET_WARN_SEGMENTS    20
    1091         988 :     if (MultiXactState->oldestOffsetKnown &&
    1092         494 :         MultiXactOffsetWouldWrap(MultiXactState->offsetStopLimit, nextOffset,
    1093             :                                  nmembers))
    1094             :     {
    1095             :         /* see comment in the corresponding offsets wraparound case */
    1096           0 :         SendPostmasterSignal(PMSIGNAL_START_AUTOVAC_LAUNCHER);
    1097             : 
    1098           0 :         ereport(ERROR,
    1099             :                 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
    1100             :                  errmsg("multixact \"members\" limit exceeded"),
    1101             :                  errdetail_plural("This command would create a multixact with %u members, but the remaining space is only enough for %u member.",
    1102             :                                   "This command would create a multixact with %u members, but the remaining space is only enough for %u members.",
    1103             :                                   MultiXactState->offsetStopLimit - nextOffset - 1,
    1104             :                                   nmembers,
    1105             :                                   MultiXactState->offsetStopLimit - nextOffset - 1),
    1106             :                  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.",
    1107             :                          MultiXactState->oldestMultiXactDB)));
    1108             :     }
    1109             : 
    1110             :     /*
    1111             :      * Check whether we should kick autovacuum into action, to prevent members
    1112             :      * wraparound. NB we use a much larger window to trigger autovacuum than
    1113             :      * just the warning limit. The warning is just a measure of last resort -
    1114             :      * this is in line with GetNewTransactionId's behaviour.
    1115             :      */
    1116         988 :     if (!MultiXactState->oldestOffsetKnown ||
    1117         494 :         (MultiXactState->nextOffset - MultiXactState->oldestOffset
    1118         494 :          > MULTIXACT_MEMBER_SAFE_THRESHOLD))
    1119             :     {
    1120             :         /*
    1121             :          * To avoid swamping the postmaster with signals, we issue the autovac
    1122             :          * request only when crossing a segment boundary. With default
    1123             :          * compilation settings that's roughly after 50k members.  This still
    1124             :          * gives plenty of chances before we get into real trouble.
    1125             :          */
    1126           0 :         if ((MXOffsetToMemberPage(nextOffset) / SLRU_PAGES_PER_SEGMENT) !=
    1127           0 :             (MXOffsetToMemberPage(nextOffset + nmembers) / SLRU_PAGES_PER_SEGMENT))
    1128           0 :             SendPostmasterSignal(PMSIGNAL_START_AUTOVAC_LAUNCHER);
    1129             :     }
    1130             : 
    1131         988 :     if (MultiXactState->oldestOffsetKnown &&
    1132         494 :         MultiXactOffsetWouldWrap(MultiXactState->offsetStopLimit,
    1133             :                                  nextOffset,
    1134             :                                  nmembers + MULTIXACT_MEMBERS_PER_PAGE * SLRU_PAGES_PER_SEGMENT * OFFSET_WARN_SEGMENTS))
    1135           0 :         ereport(WARNING,
    1136             :                 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
    1137             :                  errmsg_plural("database with OID %u must be vacuumed before %d more multixact member is used",
    1138             :                                "database with OID %u must be vacuumed before %d more multixact members are used",
    1139             :                                MultiXactState->offsetStopLimit - nextOffset + nmembers,
    1140             :                                MultiXactState->oldestMultiXactDB,
    1141             :                                MultiXactState->offsetStopLimit - nextOffset + nmembers),
    1142             :                  errhint("Execute a database-wide VACUUM in that database with reduced vacuum_multixact_freeze_min_age and vacuum_multixact_freeze_table_age settings.")));
    1143             : 
    1144         494 :     ExtendMultiXactMember(nextOffset, nmembers);
    1145             : 
    1146             :     /*
    1147             :      * Critical section from here until caller has written the data into the
    1148             :      * just-reserved SLRU space; we don't want to error out with a partly
    1149             :      * written MultiXact structure.  (In particular, failing to write our
    1150             :      * start offset after advancing nextMXact would effectively corrupt the
    1151             :      * previous MultiXact.)
    1152             :      */
    1153         494 :     START_CRIT_SECTION();
    1154             : 
    1155             :     /*
    1156             :      * Advance counters.  As in GetNewTransactionId(), this must not happen
    1157             :      * until after file extension has succeeded!
    1158             :      *
    1159             :      * We don't care about MultiXactId wraparound here; it will be handled by
    1160             :      * the next iteration.  But note that nextMXact may be InvalidMultiXactId
    1161             :      * or the first value on a segment-beginning page after this routine
    1162             :      * exits, so anyone else looking at the variable must be prepared to deal
    1163             :      * with either case.  Similarly, nextOffset may be zero, but we won't use
    1164             :      * that as the actual start offset of the next multixact.
    1165             :      */
    1166         494 :     (MultiXactState->nextMXact)++;
    1167             : 
    1168         494 :     MultiXactState->nextOffset += nmembers;
    1169             : 
    1170         494 :     LWLockRelease(MultiXactGenLock);
    1171             : 
    1172             :     debug_elog4(DEBUG2, "GetNew: returning %u offset %u", result, *offset);
    1173         494 :     return result;
    1174             : }
    1175             : 
    1176             : /*
    1177             :  * GetMultiXactIdMembers
    1178             :  *      Return the set of MultiXactMembers that make up a MultiXactId
    1179             :  *
    1180             :  * Return value is the number of members found, or -1 if there are none,
    1181             :  * and *members is set to a newly palloc'ed array of members.  It's the
    1182             :  * caller's responsibility to free it when done with it.
    1183             :  *
    1184             :  * from_pgupgrade must be passed as true if and only if only the multixact
    1185             :  * corresponds to a value from a tuple that was locked in a 9.2-or-older
    1186             :  * installation and later pg_upgrade'd (that is, the infomask is
    1187             :  * HEAP_LOCKED_UPGRADED).  In this case, we know for certain that no members
    1188             :  * can still be running, so we return -1 just like for an empty multixact
    1189             :  * without any further checking.  It would be wrong to try to resolve such a
    1190             :  * multixact: either the multixact is within the current valid multixact
    1191             :  * range, in which case the returned result would be bogus, or outside that
    1192             :  * range, in which case an error would be raised.
    1193             :  *
    1194             :  * In all other cases, the passed multixact must be within the known valid
    1195             :  * range, that is, greater to or equal than oldestMultiXactId, and less than
    1196             :  * nextMXact.  Otherwise, an error is raised.
    1197             :  *
    1198             :  * onlyLock must be set to true if caller is certain that the given multi
    1199             :  * is used only to lock tuples; can be false without loss of correctness,
    1200             :  * but passing a true means we can return quickly without checking for
    1201             :  * old updates.
    1202             :  */
    1203             : int
    1204        5104 : GetMultiXactIdMembers(MultiXactId multi, MultiXactMember **members,
    1205             :                       bool from_pgupgrade, bool onlyLock)
    1206             : {
    1207             :     int         pageno;
    1208             :     int         prev_pageno;
    1209             :     int         entryno;
    1210             :     int         slotno;
    1211             :     MultiXactOffset *offptr;
    1212             :     MultiXactOffset offset;
    1213             :     int         length;
    1214             :     int         truelength;
    1215             :     int         i;
    1216             :     MultiXactId oldestMXact;
    1217             :     MultiXactId nextMXact;
    1218             :     MultiXactId tmpMXact;
    1219             :     MultiXactOffset nextOffset;
    1220             :     MultiXactMember *ptr;
    1221             : 
    1222             :     debug_elog3(DEBUG2, "GetMembers: asked for %u", multi);
    1223             : 
    1224        5104 :     if (!MultiXactIdIsValid(multi) || from_pgupgrade)
    1225           0 :         return -1;
    1226             : 
    1227             :     /* See if the MultiXactId is in the local cache */
    1228        5104 :     length = mXactCacheGetById(multi, members);
    1229        5104 :     if (length >= 0)
    1230             :     {
    1231             :         debug_elog3(DEBUG2, "GetMembers: found %s in the cache",
    1232             :                     mxid_to_string(multi, length, *members));
    1233        3560 :         return length;
    1234             :     }
    1235             : 
    1236             :     /* Set our OldestVisibleMXactId[] entry if we didn't already */
    1237        1544 :     MultiXactIdSetOldestVisible();
    1238             : 
    1239             :     /*
    1240             :      * If we know the multi is used only for locking and not for updates, then
    1241             :      * we can skip checking if the value is older than our oldest visible
    1242             :      * multi.  It cannot possibly still be running.
    1243             :      */
    1244        2888 :     if (onlyLock &&
    1245        1344 :         MultiXactIdPrecedes(multi, OldestVisibleMXactId[MyBackendId]))
    1246             :     {
    1247             :         debug_elog2(DEBUG2, "GetMembers: a locker-only multi is too old");
    1248        1182 :         *members = NULL;
    1249        1182 :         return -1;
    1250             :     }
    1251             : 
    1252             :     /*
    1253             :      * We check known limits on MultiXact before resorting to the SLRU area.
    1254             :      *
    1255             :      * An ID older than MultiXactState->oldestMultiXactId cannot possibly be
    1256             :      * useful; it has already been removed, or will be removed shortly, by
    1257             :      * truncation.  If one is passed, an error is raised.
    1258             :      *
    1259             :      * Also, an ID >= nextMXact shouldn't ever be seen here; if it is seen, it
    1260             :      * implies undetected ID wraparound has occurred.  This raises a hard
    1261             :      * error.
    1262             :      *
    1263             :      * Shared lock is enough here since we aren't modifying any global state.
    1264             :      * Acquire it just long enough to grab the current counter values.  We may
    1265             :      * need both nextMXact and nextOffset; see below.
    1266             :      */
    1267         362 :     LWLockAcquire(MultiXactGenLock, LW_SHARED);
    1268             : 
    1269         362 :     oldestMXact = MultiXactState->oldestMultiXactId;
    1270         362 :     nextMXact = MultiXactState->nextMXact;
    1271         362 :     nextOffset = MultiXactState->nextOffset;
    1272             : 
    1273         362 :     LWLockRelease(MultiXactGenLock);
    1274             : 
    1275         362 :     if (MultiXactIdPrecedes(multi, oldestMXact))
    1276             :     {
    1277           0 :         ereport(ERROR,
    1278             :                 (errcode(ERRCODE_INTERNAL_ERROR),
    1279             :                  errmsg("MultiXactId %u does no longer exist -- apparent wraparound",
    1280             :                         multi)));
    1281             :         return -1;
    1282             :     }
    1283             : 
    1284         362 :     if (!MultiXactIdPrecedes(multi, nextMXact))
    1285           0 :         ereport(ERROR,
    1286             :                 (errcode(ERRCODE_INTERNAL_ERROR),
    1287             :                  errmsg("MultiXactId %u has not been created yet -- apparent wraparound",
    1288             :                         multi)));
    1289             : 
    1290             :     /*
    1291             :      * Find out the offset at which we need to start reading MultiXactMembers
    1292             :      * and the number of members in the multixact.  We determine the latter as
    1293             :      * the difference between this multixact's starting offset and the next
    1294             :      * one's.  However, there are some corner cases to worry about:
    1295             :      *
    1296             :      * 1. This multixact may be the latest one created, in which case there is
    1297             :      * no next one to look at.  In this case the nextOffset value we just
    1298             :      * saved is the correct endpoint.
    1299             :      *
    1300             :      * 2. The next multixact may still be in process of being filled in: that
    1301             :      * is, another process may have done GetNewMultiXactId but not yet written
    1302             :      * the offset entry for that ID.  In that scenario, it is guaranteed that
    1303             :      * the offset entry for that multixact exists (because GetNewMultiXactId
    1304             :      * won't release MultiXactGenLock until it does) but contains zero
    1305             :      * (because we are careful to pre-zero offset pages). Because
    1306             :      * GetNewMultiXactId will never return zero as the starting offset for a
    1307             :      * multixact, when we read zero as the next multixact's offset, we know we
    1308             :      * have this case.  We sleep for a bit and try again.
    1309             :      *
    1310             :      * 3. Because GetNewMultiXactId increments offset zero to offset one to
    1311             :      * handle case #2, there is an ambiguity near the point of offset
    1312             :      * wraparound.  If we see next multixact's offset is one, is that our
    1313             :      * multixact's actual endpoint, or did it end at zero with a subsequent
    1314             :      * increment?  We handle this using the knowledge that if the zero'th
    1315             :      * member slot wasn't filled, it'll contain zero, and zero isn't a valid
    1316             :      * transaction ID so it can't be a multixact member.  Therefore, if we
    1317             :      * read a zero from the members array, just ignore it.
    1318             :      *
    1319             :      * This is all pretty messy, but the mess occurs only in infrequent corner
    1320             :      * cases, so it seems better than holding the MultiXactGenLock for a long
    1321             :      * time on every multixact creation.
    1322             :      */
    1323             : retry:
    1324         362 :     LWLockAcquire(MultiXactOffsetControlLock, LW_EXCLUSIVE);
    1325             : 
    1326         362 :     pageno = MultiXactIdToOffsetPage(multi);
    1327         362 :     entryno = MultiXactIdToOffsetEntry(multi);
    1328             : 
    1329         362 :     slotno = SimpleLruReadPage(MultiXactOffsetCtl, pageno, true, multi);
    1330         362 :     offptr = (MultiXactOffset *) MultiXactOffsetCtl->shared->page_buffer[slotno];
    1331         362 :     offptr += entryno;
    1332         362 :     offset = *offptr;
    1333             : 
    1334             :     Assert(offset != 0);
    1335             : 
    1336             :     /*
    1337             :      * Use the same increment rule as GetNewMultiXactId(), that is, don't
    1338             :      * handle wraparound explicitly until needed.
    1339             :      */
    1340         362 :     tmpMXact = multi + 1;
    1341             : 
    1342         362 :     if (nextMXact == tmpMXact)
    1343             :     {
    1344             :         /* Corner case 1: there is no next multixact */
    1345         344 :         length = nextOffset - offset;
    1346             :     }
    1347             :     else
    1348             :     {
    1349             :         MultiXactOffset nextMXOffset;
    1350             : 
    1351             :         /* handle wraparound if needed */
    1352          18 :         if (tmpMXact < FirstMultiXactId)
    1353           0 :             tmpMXact = FirstMultiXactId;
    1354             : 
    1355          18 :         prev_pageno = pageno;
    1356             : 
    1357          18 :         pageno = MultiXactIdToOffsetPage(tmpMXact);
    1358          18 :         entryno = MultiXactIdToOffsetEntry(tmpMXact);
    1359             : 
    1360          18 :         if (pageno != prev_pageno)
    1361           0 :             slotno = SimpleLruReadPage(MultiXactOffsetCtl, pageno, true, tmpMXact);
    1362             : 
    1363          18 :         offptr = (MultiXactOffset *) MultiXactOffsetCtl->shared->page_buffer[slotno];
    1364          18 :         offptr += entryno;
    1365          18 :         nextMXOffset = *offptr;
    1366             : 
    1367          18 :         if (nextMXOffset == 0)
    1368             :         {
    1369             :             /* Corner case 2: next multixact is still being filled in */
    1370           0 :             LWLockRelease(MultiXactOffsetControlLock);
    1371           0 :             CHECK_FOR_INTERRUPTS();
    1372           0 :             pg_usleep(1000L);
    1373           0 :             goto retry;
    1374             :         }
    1375             : 
    1376          18 :         length = nextMXOffset - offset;
    1377             :     }
    1378             : 
    1379         362 :     LWLockRelease(MultiXactOffsetControlLock);
    1380             : 
    1381         362 :     ptr = (MultiXactMember *) palloc(length * sizeof(MultiXactMember));
    1382         362 :     *members = ptr;
    1383             : 
    1384             :     /* Now get the members themselves. */
    1385         362 :     LWLockAcquire(MultiXactMemberControlLock, LW_EXCLUSIVE);
    1386             : 
    1387         362 :     truelength = 0;
    1388         362 :     prev_pageno = -1;
    1389        1260 :     for (i = 0; i < length; i++, offset++)
    1390             :     {
    1391             :         TransactionId *xactptr;
    1392             :         uint32     *flagsptr;
    1393             :         int         flagsoff;
    1394             :         int         bshift;
    1395             :         int         memberoff;
    1396             : 
    1397         898 :         pageno = MXOffsetToMemberPage(offset);
    1398         898 :         memberoff = MXOffsetToMemberOffset(offset);
    1399             : 
    1400         898 :         if (pageno != prev_pageno)
    1401             :         {
    1402         362 :             slotno = SimpleLruReadPage(MultiXactMemberCtl, pageno, true, multi);
    1403         362 :             prev_pageno = pageno;
    1404             :         }
    1405             : 
    1406         898 :         xactptr = (TransactionId *)
    1407         898 :             (MultiXactMemberCtl->shared->page_buffer[slotno] + memberoff);
    1408             : 
    1409         898 :         if (!TransactionIdIsValid(*xactptr))
    1410             :         {
    1411             :             /* Corner case 3: we must be looking at unused slot zero */
    1412             :             Assert(offset == 0);
    1413           0 :             continue;
    1414             :         }
    1415             : 
    1416         898 :         flagsoff = MXOffsetToFlagsOffset(offset);
    1417         898 :         bshift = MXOffsetToFlagsBitShift(offset);
    1418         898 :         flagsptr = (uint32 *) (MultiXactMemberCtl->shared->page_buffer[slotno] + flagsoff);
    1419             : 
    1420         898 :         ptr[truelength].xid = *xactptr;
    1421         898 :         ptr[truelength].status = (*flagsptr >> bshift) & MXACT_MEMBER_XACT_BITMASK;
    1422         898 :         truelength++;
    1423             :     }
    1424             : 
    1425         362 :     LWLockRelease(MultiXactMemberControlLock);
    1426             : 
    1427             :     /*
    1428             :      * Copy the result into the local cache.
    1429             :      */
    1430         362 :     mXactCachePut(multi, truelength, ptr);
    1431             : 
    1432             :     debug_elog3(DEBUG2, "GetMembers: no cache for %s",
    1433             :                 mxid_to_string(multi, truelength, ptr));
    1434         362 :     return truelength;
    1435             : }
    1436             : 
    1437             : /*
    1438             :  * mxactMemberComparator
    1439             :  *      qsort comparison function for MultiXactMember
    1440             :  *
    1441             :  * We can't use wraparound comparison for XIDs because that does not respect
    1442             :  * the triangle inequality!  Any old sort order will do.
    1443             :  */
    1444             : static int
    1445        3310 : mxactMemberComparator(const void *arg1, const void *arg2)
    1446             : {
    1447        3310 :     MultiXactMember member1 = *(const MultiXactMember *) arg1;
    1448        3310 :     MultiXactMember member2 = *(const MultiXactMember *) arg2;
    1449             : 
    1450        3310 :     if (member1.xid > member2.xid)
    1451          52 :         return 1;
    1452        3258 :     if (member1.xid < member2.xid)
    1453        3034 :         return -1;
    1454         224 :     if (member1.status > member2.status)
    1455           0 :         return 1;
    1456         224 :     if (member1.status < member2.status)
    1457         224 :         return -1;
    1458           0 :     return 0;
    1459             : }
    1460             : 
    1461             : /*
    1462             :  * mXactCacheGetBySet
    1463             :  *      returns a MultiXactId from the cache based on the set of
    1464             :  *      TransactionIds that compose it, or InvalidMultiXactId if
    1465             :  *      none matches.
    1466             :  *
    1467             :  * This is helpful, for example, if two transactions want to lock a huge
    1468             :  * table.  By using the cache, the second will use the same MultiXactId
    1469             :  * for the majority of tuples, thus keeping MultiXactId usage low (saving
    1470             :  * both I/O and wraparound issues).
    1471             :  *
    1472             :  * NB: the passed members array will be sorted in-place.
    1473             :  */
    1474             : static MultiXactId
    1475        2060 : mXactCacheGetBySet(int nmembers, MultiXactMember *members)
    1476             : {
    1477             :     dlist_iter  iter;
    1478             : 
    1479             :     debug_elog3(DEBUG2, "CacheGet: looking for %s",
    1480             :                 mxid_to_string(InvalidMultiXactId, nmembers, members));
    1481             : 
    1482             :     /* sort the array so comparison is easy */
    1483        2060 :     qsort(members, nmembers, sizeof(MultiXactMember), mxactMemberComparator);
    1484             : 
    1485        2330 :     dlist_foreach(iter, &MXactCache)
    1486             :     {
    1487        1836 :         mXactCacheEnt *entry = dlist_container(mXactCacheEnt, node, iter.cur);
    1488             : 
    1489        1836 :         if (entry->nmembers != nmembers)
    1490         146 :             continue;
    1491             : 
    1492             :         /*
    1493             :          * We assume the cache entries are sorted, and that the unused bits in
    1494             :          * "status" are zeroed.
    1495             :          */
    1496        1690 :         if (memcmp(members, entry->members, nmembers * sizeof(MultiXactMember)) == 0)
    1497             :         {
    1498             :             debug_elog3(DEBUG2, "CacheGet: found %u", entry->multi);
    1499        1566 :             dlist_move_head(&MXactCache, iter.cur);
    1500        1566 :             return entry->multi;
    1501             :         }
    1502             :     }
    1503             : 
    1504             :     debug_elog2(DEBUG2, "CacheGet: not found :-(");
    1505         494 :     return InvalidMultiXactId;
    1506             : }
    1507             : 
    1508             : /*
    1509             :  * mXactCacheGetById
    1510             :  *      returns the composing MultiXactMember set from the cache for a
    1511             :  *      given MultiXactId, if present.
    1512             :  *
    1513             :  * If successful, *xids is set to the address of a palloc'd copy of the
    1514             :  * MultiXactMember set.  Return value is number of members, or -1 on failure.
    1515             :  */
    1516             : static int
    1517        5104 : mXactCacheGetById(MultiXactId multi, MultiXactMember **members)
    1518             : {
    1519             :     dlist_iter  iter;
    1520             : 
    1521             :     debug_elog3(DEBUG2, "CacheGet: looking for %u", multi);
    1522             : 
    1523        5456 :     dlist_foreach(iter, &MXactCache)
    1524             :     {
    1525        3912 :         mXactCacheEnt *entry = dlist_container(mXactCacheEnt, node, iter.cur);
    1526             : 
    1527        3912 :         if (entry->multi == multi)
    1528             :         {
    1529             :             MultiXactMember *ptr;
    1530             :             Size        size;
    1531             : 
    1532        3560 :             size = sizeof(MultiXactMember) * entry->nmembers;
    1533        3560 :             ptr = (MultiXactMember *) palloc(size);
    1534        3560 :             *members = ptr;
    1535             : 
    1536        3560 :             memcpy(ptr, entry->members, size);
    1537             : 
    1538             :             debug_elog3(DEBUG2, "CacheGet: found %s",
    1539             :                         mxid_to_string(multi,
    1540             :                                        entry->nmembers,
    1541             :                                        entry->members));
    1542             : 
    1543             :             /*
    1544             :              * Note we modify the list while not using a modifiable iterator.
    1545             :              * This is acceptable only because we exit the iteration
    1546             :              * immediately afterwards.
    1547             :              */
    1548        3560 :             dlist_move_head(&MXactCache, iter.cur);
    1549             : 
    1550        3560 :             return entry->nmembers;
    1551             :         }
    1552             :     }
    1553             : 
    1554             :     debug_elog2(DEBUG2, "CacheGet: not found");
    1555        1544 :     return -1;
    1556             : }
    1557             : 
    1558             : /*
    1559             :  * mXactCachePut
    1560             :  *      Add a new MultiXactId and its composing set into the local cache.
    1561             :  */
    1562             : static void
    1563         856 : mXactCachePut(MultiXactId multi, int nmembers, MultiXactMember *members)
    1564             : {
    1565             :     mXactCacheEnt *entry;
    1566             : 
    1567             :     debug_elog3(DEBUG2, "CachePut: storing %s",
    1568             :                 mxid_to_string(multi, nmembers, members));
    1569             : 
    1570         856 :     if (MXactContext == NULL)
    1571             :     {
    1572             :         /* The cache only lives as long as the current transaction */
    1573             :         debug_elog2(DEBUG2, "CachePut: initializing memory context");
    1574         630 :         MXactContext = AllocSetContextCreate(TopTransactionContext,
    1575             :                                              "MultiXact cache context",
    1576             :                                              ALLOCSET_SMALL_SIZES);
    1577             :     }
    1578             : 
    1579         856 :     entry = (mXactCacheEnt *)
    1580         856 :         MemoryContextAlloc(MXactContext,
    1581             :                            offsetof(mXactCacheEnt, members) +
    1582             :                            nmembers * sizeof(MultiXactMember));
    1583             : 
    1584         856 :     entry->multi = multi;
    1585         856 :     entry->nmembers = nmembers;
    1586         856 :     memcpy(entry->members, members, nmembers * sizeof(MultiXactMember));
    1587             : 
    1588             :     /* mXactCacheGetBySet assumes the entries are sorted, so sort them */
    1589         856 :     qsort(entry->members, nmembers, sizeof(MultiXactMember), mxactMemberComparator);
    1590             : 
    1591         856 :     dlist_push_head(&MXactCache, &entry->node);
    1592         856 :     if (MXactCacheMembers++ >= MAX_CACHE_ENTRIES)
    1593             :     {
    1594             :         dlist_node *node;
    1595             :         mXactCacheEnt *entry;
    1596             : 
    1597           0 :         node = dlist_tail_node(&MXactCache);
    1598           0 :         dlist_delete(node);
    1599           0 :         MXactCacheMembers--;
    1600             : 
    1601           0 :         entry = dlist_container(mXactCacheEnt, node, node);
    1602             :         debug_elog3(DEBUG2, "CachePut: pruning cached multi %u",
    1603             :                     entry->multi);
    1604             : 
    1605           0 :         pfree(entry);
    1606             :     }
    1607         856 : }
    1608             : 
    1609             : static char *
    1610           0 : mxstatus_to_string(MultiXactStatus status)
    1611             : {
    1612           0 :     switch (status)
    1613             :     {
    1614             :         case MultiXactStatusForKeyShare:
    1615           0 :             return "keysh";
    1616             :         case MultiXactStatusForShare:
    1617           0 :             return "sh";
    1618             :         case MultiXactStatusForNoKeyUpdate:
    1619           0 :             return "fornokeyupd";
    1620             :         case MultiXactStatusForUpdate:
    1621           0 :             return "forupd";
    1622             :         case MultiXactStatusNoKeyUpdate:
    1623           0 :             return "nokeyupd";
    1624             :         case MultiXactStatusUpdate:
    1625           0 :             return "upd";
    1626             :         default:
    1627           0 :             elog(ERROR, "unrecognized multixact status %d", status);
    1628             :             return "";
    1629             :     }
    1630             : }
    1631             : 
    1632             : char *
    1633           0 : mxid_to_string(MultiXactId multi, int nmembers, MultiXactMember *members)
    1634             : {
    1635             :     static char *str = NULL;
    1636             :     StringInfoData buf;
    1637             :     int         i;
    1638             : 
    1639           0 :     if (str != NULL)
    1640           0 :         pfree(str);
    1641             : 
    1642           0 :     initStringInfo(&buf);
    1643             : 
    1644           0 :     appendStringInfo(&buf, "%u %d[%u (%s)", multi, nmembers, members[0].xid,
    1645             :                      mxstatus_to_string(members[0].status));
    1646             : 
    1647           0 :     for (i = 1; i < nmembers; i++)
    1648           0 :         appendStringInfo(&buf, ", %u (%s)", members[i].xid,
    1649           0 :                          mxstatus_to_string(members[i].status));
    1650             : 
    1651           0 :     appendStringInfoChar(&buf, ']');
    1652           0 :     str = MemoryContextStrdup(TopMemoryContext, buf.data);
    1653           0 :     pfree(buf.data);
    1654           0 :     return str;
    1655             : }
    1656             : 
    1657             : /*
    1658             :  * AtEOXact_MultiXact
    1659             :  *      Handle transaction end for MultiXact
    1660             :  *
    1661             :  * This is called at top transaction commit or abort (we don't care which).
    1662             :  */
    1663             : void
    1664      458666 : AtEOXact_MultiXact(void)
    1665             : {
    1666             :     /*
    1667             :      * Reset our OldestMemberMXactId and OldestVisibleMXactId values, both of
    1668             :      * which should only be valid while within a transaction.
    1669             :      *
    1670             :      * We assume that storing a MultiXactId is atomic and so we need not take
    1671             :      * MultiXactGenLock to do this.
    1672             :      */
    1673      458666 :     OldestMemberMXactId[MyBackendId] = InvalidMultiXactId;
    1674      458666 :     OldestVisibleMXactId[MyBackendId] = InvalidMultiXactId;
    1675             : 
    1676             :     /*
    1677             :      * Discard the local MultiXactId cache.  Since MXactContext was created as
    1678             :      * a child of TopTransactionContext, we needn't delete it explicitly.
    1679             :      */
    1680      458666 :     MXactContext = NULL;
    1681      458666 :     dlist_init(&MXactCache);
    1682      458666 :     MXactCacheMembers = 0;
    1683      458666 : }
    1684             : 
    1685             : /*
    1686             :  * AtPrepare_MultiXact
    1687             :  *      Save multixact state at 2PC transaction prepare
    1688             :  *
    1689             :  * In this phase, we only store our OldestMemberMXactId value in the two-phase
    1690             :  * state file.
    1691             :  */
    1692             : void
    1693          54 : AtPrepare_MultiXact(void)
    1694             : {
    1695          54 :     MultiXactId myOldestMember = OldestMemberMXactId[MyBackendId];
    1696             : 
    1697          54 :     if (MultiXactIdIsValid(myOldestMember))
    1698          20 :         RegisterTwoPhaseRecord(TWOPHASE_RM_MULTIXACT_ID, 0,
    1699             :                                &myOldestMember, sizeof(MultiXactId));
    1700          54 : }
    1701             : 
    1702             : /*
    1703             :  * PostPrepare_MultiXact
    1704             :  *      Clean up after successful PREPARE TRANSACTION
    1705             :  */
    1706             : void
    1707          54 : PostPrepare_MultiXact(TransactionId xid)
    1708             : {
    1709             :     MultiXactId myOldestMember;
    1710             : 
    1711             :     /*
    1712             :      * Transfer our OldestMemberMXactId value to the slot reserved for the
    1713             :      * prepared transaction.
    1714             :      */
    1715          54 :     myOldestMember = OldestMemberMXactId[MyBackendId];
    1716          54 :     if (MultiXactIdIsValid(myOldestMember))
    1717             :     {
    1718          20 :         BackendId   dummyBackendId = TwoPhaseGetDummyBackendId(xid, false);
    1719             : 
    1720             :         /*
    1721             :          * Even though storing MultiXactId is atomic, acquire lock to make
    1722             :          * sure others see both changes, not just the reset of the slot of the
    1723             :          * current backend. Using a volatile pointer might suffice, but this
    1724             :          * isn't a hot spot.
    1725             :          */
    1726          20 :         LWLockAcquire(MultiXactGenLock, LW_EXCLUSIVE);
    1727             : 
    1728          20 :         OldestMemberMXactId[dummyBackendId] = myOldestMember;
    1729          20 :         OldestMemberMXactId[MyBackendId] = InvalidMultiXactId;
    1730             : 
    1731          20 :         LWLockRelease(MultiXactGenLock);
    1732             :     }
    1733             : 
    1734             :     /*
    1735             :      * We don't need to transfer OldestVisibleMXactId value, because the
    1736             :      * transaction is not going to be looking at any more multixacts once it's
    1737             :      * prepared.
    1738             :      *
    1739             :      * We assume that storing a MultiXactId is atomic and so we need not take
    1740             :      * MultiXactGenLock to do this.
    1741             :      */
    1742          54 :     OldestVisibleMXactId[MyBackendId] = InvalidMultiXactId;
    1743             : 
    1744             :     /*
    1745             :      * Discard the local MultiXactId cache like in AtEOX_MultiXact
    1746             :      */
    1747          54 :     MXactContext = NULL;
    1748          54 :     dlist_init(&MXactCache);
    1749          54 :     MXactCacheMembers = 0;
    1750          54 : }
    1751             : 
    1752             : /*
    1753             :  * multixact_twophase_recover
    1754             :  *      Recover the state of a prepared transaction at startup
    1755             :  */
    1756             : void
    1757           8 : multixact_twophase_recover(TransactionId xid, uint16 info,
    1758             :                            void *recdata, uint32 len)
    1759             : {
    1760           8 :     BackendId   dummyBackendId = TwoPhaseGetDummyBackendId(xid, false);
    1761             :     MultiXactId oldestMember;
    1762             : 
    1763             :     /*
    1764             :      * Get the oldest member XID from the state file record, and set it in the
    1765             :      * OldestMemberMXactId slot reserved for this prepared transaction.
    1766             :      */
    1767             :     Assert(len == sizeof(MultiXactId));
    1768           8 :     oldestMember = *((MultiXactId *) recdata);
    1769             : 
    1770           8 :     OldestMemberMXactId[dummyBackendId] = oldestMember;
    1771           8 : }
    1772             : 
    1773             : /*
    1774             :  * multixact_twophase_postcommit
    1775             :  *      Similar to AtEOX_MultiXact but for COMMIT PREPARED
    1776             :  */
    1777             : void
    1778          20 : multixact_twophase_postcommit(TransactionId xid, uint16 info,
    1779             :                               void *recdata, uint32 len)
    1780             : {
    1781          20 :     BackendId   dummyBackendId = TwoPhaseGetDummyBackendId(xid, true);
    1782             : 
    1783             :     Assert(len == sizeof(MultiXactId));
    1784             : 
    1785          20 :     OldestMemberMXactId[dummyBackendId] = InvalidMultiXactId;
    1786          20 : }
    1787             : 
    1788             : /*
    1789             :  * multixact_twophase_postabort
    1790             :  *      This is actually just the same as the COMMIT case.
    1791             :  */
    1792             : void
    1793          10 : multixact_twophase_postabort(TransactionId xid, uint16 info,
    1794             :                              void *recdata, uint32 len)
    1795             : {
    1796          10 :     multixact_twophase_postcommit(xid, info, recdata, len);
    1797          10 : }
    1798             : 
    1799             : /*
    1800             :  * Initialization of shared memory for MultiXact.  We use two SLRU areas,
    1801             :  * thus double memory.  Also, reserve space for the shared MultiXactState
    1802             :  * struct and the per-backend MultiXactId arrays (two of those, too).
    1803             :  */
    1804             : Size
    1805        1894 : MultiXactShmemSize(void)
    1806             : {
    1807             :     Size        size;
    1808             : 
    1809             :     /* We need 2*MaxOldestSlot + 1 perBackendXactIds[] entries */
    1810             : #define SHARED_MULTIXACT_STATE_SIZE \
    1811             :     add_size(offsetof(MultiXactStateData, perBackendXactIds) + sizeof(MultiXactId), \
    1812             :              mul_size(sizeof(MultiXactId) * 2, MaxOldestSlot))
    1813             : 
    1814        1894 :     size = SHARED_MULTIXACT_STATE_SIZE;
    1815        1894 :     size = add_size(size, SimpleLruShmemSize(NUM_MXACTOFFSET_BUFFERS, 0));
    1816        1894 :     size = add_size(size, SimpleLruShmemSize(NUM_MXACTMEMBER_BUFFERS, 0));
    1817             : 
    1818        1894 :     return size;
    1819             : }
    1820             : 
    1821             : void
    1822        1890 : MultiXactShmemInit(void)
    1823             : {
    1824             :     bool        found;
    1825             : 
    1826             :     debug_elog2(DEBUG2, "Shared Memory Init for MultiXact");
    1827             : 
    1828        1890 :     MultiXactOffsetCtl->PagePrecedes = MultiXactOffsetPagePrecedes;
    1829        1890 :     MultiXactMemberCtl->PagePrecedes = MultiXactMemberPagePrecedes;
    1830             : 
    1831        1890 :     SimpleLruInit(MultiXactOffsetCtl,
    1832             :                   "multixact_offset", NUM_MXACTOFFSET_BUFFERS, 0,
    1833        1890 :                   MultiXactOffsetControlLock, "pg_multixact/offsets",
    1834             :                   LWTRANCHE_MXACTOFFSET_BUFFERS);
    1835        1890 :     SimpleLruInit(MultiXactMemberCtl,
    1836             :                   "multixact_member", NUM_MXACTMEMBER_BUFFERS, 0,
    1837        1890 :                   MultiXactMemberControlLock, "pg_multixact/members",
    1838             :                   LWTRANCHE_MXACTMEMBER_BUFFERS);
    1839             : 
    1840             :     /* Initialize our shared state struct */
    1841        1890 :     MultiXactState = ShmemInitStruct("Shared MultiXact State",
    1842        1890 :                                      SHARED_MULTIXACT_STATE_SIZE,
    1843             :                                      &found);
    1844        1890 :     if (!IsUnderPostmaster)
    1845             :     {
    1846             :         Assert(!found);
    1847             : 
    1848             :         /* Make sure we zero out the per-backend state */
    1849        1890 :         MemSet(MultiXactState, 0, SHARED_MULTIXACT_STATE_SIZE);
    1850             :     }
    1851             :     else
    1852             :         Assert(found);
    1853             : 
    1854             :     /*
    1855             :      * Set up array pointers.  Note that perBackendXactIds[0] is wasted space
    1856             :      * since we only use indexes 1..MaxOldestSlot in each array.
    1857             :      */
    1858        1890 :     OldestMemberMXactId = MultiXactState->perBackendXactIds;
    1859        1890 :     OldestVisibleMXactId = OldestMemberMXactId + MaxOldestSlot;
    1860        1890 : }
    1861             : 
    1862             : /*
    1863             :  * This func must be called ONCE on system install.  It creates the initial
    1864             :  * MultiXact segments.  (The MultiXacts directories are assumed to have been
    1865             :  * created by initdb, and MultiXactShmemInit must have been called already.)
    1866             :  */
    1867             : void
    1868         322 : BootStrapMultiXact(void)
    1869             : {
    1870             :     int         slotno;
    1871             : 
    1872         322 :     LWLockAcquire(MultiXactOffsetControlLock, LW_EXCLUSIVE);
    1873             : 
    1874             :     /* Create and zero the first page of the offsets log */
    1875         322 :     slotno = ZeroMultiXactOffsetPage(0, false);
    1876             : 
    1877             :     /* Make sure it's written out */
    1878         322 :     SimpleLruWritePage(MultiXactOffsetCtl, slotno);
    1879             :     Assert(!MultiXactOffsetCtl->shared->page_dirty[slotno]);
    1880             : 
    1881         322 :     LWLockRelease(MultiXactOffsetControlLock);
    1882             : 
    1883         322 :     LWLockAcquire(MultiXactMemberControlLock, LW_EXCLUSIVE);
    1884             : 
    1885             :     /* Create and zero the first page of the members log */
    1886         322 :     slotno = ZeroMultiXactMemberPage(0, false);
    1887             : 
    1888             :     /* Make sure it's written out */
    1889         322 :     SimpleLruWritePage(MultiXactMemberCtl, slotno);
    1890             :     Assert(!MultiXactMemberCtl->shared->page_dirty[slotno]);
    1891             : 
    1892         322 :     LWLockRelease(MultiXactMemberControlLock);
    1893         322 : }
    1894             : 
    1895             : /*
    1896             :  * Initialize (or reinitialize) a page of MultiXactOffset to zeroes.
    1897             :  * If writeXlog is true, also emit an XLOG record saying we did this.
    1898             :  *
    1899             :  * The page is not actually written, just set up in shared memory.
    1900             :  * The slot number of the new page is returned.
    1901             :  *
    1902             :  * Control lock must be held at entry, and will be held at exit.
    1903             :  */
    1904             : static int
    1905         334 : ZeroMultiXactOffsetPage(int pageno, bool writeXlog)
    1906             : {
    1907             :     int         slotno;
    1908             : 
    1909         334 :     slotno = SimpleLruZeroPage(MultiXactOffsetCtl, pageno);
    1910             : 
    1911         334 :     if (writeXlog)
    1912          12 :         WriteMZeroPageXlogRec(pageno, XLOG_MULTIXACT_ZERO_OFF_PAGE);
    1913             : 
    1914         334 :     return slotno;
    1915             : }
    1916             : 
    1917             : /*
    1918             :  * Ditto, for MultiXactMember
    1919             :  */
    1920             : static int
    1921         334 : ZeroMultiXactMemberPage(int pageno, bool writeXlog)
    1922             : {
    1923             :     int         slotno;
    1924             : 
    1925         334 :     slotno = SimpleLruZeroPage(MultiXactMemberCtl, pageno);
    1926             : 
    1927         334 :     if (writeXlog)
    1928          12 :         WriteMZeroPageXlogRec(pageno, XLOG_MULTIXACT_ZERO_MEM_PAGE);
    1929             : 
    1930         334 :     return slotno;
    1931             : }
    1932             : 
    1933             : /*
    1934             :  * MaybeExtendOffsetSlru
    1935             :  *      Extend the offsets SLRU area, if necessary
    1936             :  *
    1937             :  * After a binary upgrade from <= 9.2, the pg_multixact/offsets SLRU area might
    1938             :  * contain files that are shorter than necessary; this would occur if the old
    1939             :  * installation had used multixacts beyond the first page (files cannot be
    1940             :  * copied, because the on-disk representation is different).  pg_upgrade would
    1941             :  * update pg_control to set the next offset value to be at that position, so
    1942             :  * that tuples marked as locked by such MultiXacts would be seen as visible
    1943             :  * without having to consult multixact.  However, trying to create and use a
    1944             :  * new MultiXactId would result in an error because the page on which the new
    1945             :  * value would reside does not exist.  This routine is in charge of creating
    1946             :  * such pages.
    1947             :  */
    1948             : static void
    1949           8 : MaybeExtendOffsetSlru(void)
    1950             : {
    1951             :     int         pageno;
    1952             : 
    1953           8 :     pageno = MultiXactIdToOffsetPage(MultiXactState->nextMXact);
    1954             : 
    1955           8 :     LWLockAcquire(MultiXactOffsetControlLock, LW_EXCLUSIVE);
    1956             : 
    1957           8 :     if (!SimpleLruDoesPhysicalPageExist(MultiXactOffsetCtl, pageno))
    1958             :     {
    1959             :         int         slotno;
    1960             : 
    1961             :         /*
    1962             :          * Fortunately for us, SimpleLruWritePage is already prepared to deal
    1963             :          * with creating a new segment file even if the page we're writing is
    1964             :          * not the first in it, so this is enough.
    1965             :          */
    1966           0 :         slotno = ZeroMultiXactOffsetPage(pageno, false);
    1967           0 :         SimpleLruWritePage(MultiXactOffsetCtl, slotno);
    1968             :     }
    1969             : 
    1970           8 :     LWLockRelease(MultiXactOffsetControlLock);
    1971           8 : }
    1972             : 
    1973             : /*
    1974             :  * This must be called ONCE during postmaster or standalone-backend startup.
    1975             :  *
    1976             :  * StartupXLOG has already established nextMXact/nextOffset by calling
    1977             :  * MultiXactSetNextMXact and/or MultiXactAdvanceNextMXact, and the oldestMulti
    1978             :  * info from pg_control and/or MultiXactAdvanceOldest, but we haven't yet
    1979             :  * replayed WAL.
    1980             :  */
    1981             : void
    1982        1192 : StartupMultiXact(void)
    1983             : {
    1984        1192 :     MultiXactId multi = MultiXactState->nextMXact;
    1985        1192 :     MultiXactOffset offset = MultiXactState->nextOffset;
    1986             :     int         pageno;
    1987             : 
    1988             :     /*
    1989             :      * Initialize offset's idea of the latest page number.
    1990             :      */
    1991        1192 :     pageno = MultiXactIdToOffsetPage(multi);
    1992        1192 :     MultiXactOffsetCtl->shared->latest_page_number = pageno;
    1993             : 
    1994             :     /*
    1995             :      * Initialize member's idea of the latest page number.
    1996             :      */
    1997        1192 :     pageno = MXOffsetToMemberPage(offset);
    1998        1192 :     MultiXactMemberCtl->shared->latest_page_number = pageno;
    1999        1192 : }
    2000             : 
    2001             : /*
    2002             :  * This must be called ONCE at the end of startup/recovery.
    2003             :  */
    2004             : void
    2005        1170 : TrimMultiXact(void)
    2006             : {
    2007             :     MultiXactId nextMXact;
    2008             :     MultiXactOffset offset;
    2009             :     MultiXactId oldestMXact;
    2010             :     Oid         oldestMXactDB;
    2011             :     int         pageno;
    2012             :     int         entryno;
    2013             :     int         flagsoff;
    2014             : 
    2015        1170 :     LWLockAcquire(MultiXactGenLock, LW_SHARED);
    2016        1170 :     nextMXact = MultiXactState->nextMXact;
    2017        1170 :     offset = MultiXactState->nextOffset;
    2018        1170 :     oldestMXact = MultiXactState->oldestMultiXactId;
    2019        1170 :     oldestMXactDB = MultiXactState->oldestMultiXactDB;
    2020        1170 :     LWLockRelease(MultiXactGenLock);
    2021             : 
    2022             :     /* Clean up offsets state */
    2023        1170 :     LWLockAcquire(MultiXactOffsetControlLock, LW_EXCLUSIVE);
    2024             : 
    2025             :     /*
    2026             :      * (Re-)Initialize our idea of the latest page number for offsets.
    2027             :      */
    2028        1170 :     pageno = MultiXactIdToOffsetPage(nextMXact);
    2029        1170 :     MultiXactOffsetCtl->shared->latest_page_number = pageno;
    2030             : 
    2031             :     /*
    2032             :      * Zero out the remainder of the current offsets page.  See notes in
    2033             :      * TrimCLOG() for background.  Unlike CLOG, some WAL record covers every
    2034             :      * pg_multixact SLRU mutation.  Since, also unlike CLOG, we ignore the WAL
    2035             :      * rule "write xlog before data," nextMXact successors may carry obsolete,
    2036             :      * nonzero offset values.  Zero those so case 2 of GetMultiXactIdMembers()
    2037             :      * operates normally.
    2038             :      */
    2039        1170 :     entryno = MultiXactIdToOffsetEntry(nextMXact);
    2040        1170 :     if (entryno != 0)
    2041             :     {
    2042             :         int         slotno;
    2043             :         MultiXactOffset *offptr;
    2044             : 
    2045        1170 :         slotno = SimpleLruReadPage(MultiXactOffsetCtl, pageno, true, nextMXact);
    2046        1170 :         offptr = (MultiXactOffset *) MultiXactOffsetCtl->shared->page_buffer[slotno];
    2047        1170 :         offptr += entryno;
    2048             : 
    2049        1170 :         MemSet(offptr, 0, BLCKSZ - (entryno * sizeof(MultiXactOffset)));
    2050             : 
    2051        1170 :         MultiXactOffsetCtl->shared->page_dirty[slotno] = true;
    2052             :     }
    2053             : 
    2054        1170 :     LWLockRelease(MultiXactOffsetControlLock);
    2055             : 
    2056             :     /* And the same for members */
    2057        1170 :     LWLockAcquire(MultiXactMemberControlLock, LW_EXCLUSIVE);
    2058             : 
    2059             :     /*
    2060             :      * (Re-)Initialize our idea of the latest page number for members.
    2061             :      */
    2062        1170 :     pageno = MXOffsetToMemberPage(offset);
    2063        1170 :     MultiXactMemberCtl->shared->latest_page_number = pageno;
    2064             : 
    2065             :     /*
    2066             :      * Zero out the remainder of the current members page.  See notes in
    2067             :      * TrimCLOG() for motivation.
    2068             :      */
    2069        1170 :     flagsoff = MXOffsetToFlagsOffset(offset);
    2070        1170 :     if (flagsoff != 0)
    2071             :     {
    2072             :         int         slotno;
    2073             :         TransactionId *xidptr;
    2074             :         int         memberoff;
    2075             : 
    2076           8 :         memberoff = MXOffsetToMemberOffset(offset);
    2077           8 :         slotno = SimpleLruReadPage(MultiXactMemberCtl, pageno, true, offset);
    2078           8 :         xidptr = (TransactionId *)
    2079           8 :             (MultiXactMemberCtl->shared->page_buffer[slotno] + memberoff);
    2080             : 
    2081           8 :         MemSet(xidptr, 0, BLCKSZ - memberoff);
    2082             : 
    2083             :         /*
    2084             :          * Note: we don't need to zero out the flag bits in the remaining
    2085             :          * members of the current group, because they are always reset before
    2086             :          * writing.
    2087             :          */
    2088             : 
    2089           8 :         MultiXactMemberCtl->shared->page_dirty[slotno] = true;
    2090             :     }
    2091             : 
    2092        1170 :     LWLockRelease(MultiXactMemberControlLock);
    2093             : 
    2094             :     /* signal that we're officially up */
    2095        1170 :     LWLockAcquire(MultiXactGenLock, LW_EXCLUSIVE);
    2096        1170 :     MultiXactState->finishedStartup = true;
    2097        1170 :     LWLockRelease(MultiXactGenLock);
    2098             : 
    2099             :     /* Now compute how far away the next members wraparound is. */
    2100        1170 :     SetMultiXactIdLimit(oldestMXact, oldestMXactDB, true);
    2101        1170 : }
    2102             : 
    2103             : /*
    2104             :  * This must be called ONCE during postmaster or standalone-backend shutdown
    2105             :  */
    2106             : void
    2107        1024 : ShutdownMultiXact(void)
    2108             : {
    2109             :     /* Flush dirty MultiXact pages to disk */
    2110             :     TRACE_POSTGRESQL_MULTIXACT_CHECKPOINT_START(false);
    2111        1024 :     SimpleLruFlush(MultiXactOffsetCtl, false);
    2112        1024 :     SimpleLruFlush(MultiXactMemberCtl, false);
    2113             :     TRACE_POSTGRESQL_MULTIXACT_CHECKPOINT_DONE(false);
    2114        1024 : }
    2115             : 
    2116             : /*
    2117             :  * Get the MultiXact data to save in a checkpoint record
    2118             :  */
    2119             : void
    2120        2816 : MultiXactGetCheckptMulti(bool is_shutdown,
    2121             :                          MultiXactId *nextMulti,
    2122             :                          MultiXactOffset *nextMultiOffset,
    2123             :                          MultiXactId *oldestMulti,
    2124             :                          Oid *oldestMultiDB)
    2125             : {
    2126        2816 :     LWLockAcquire(MultiXactGenLock, LW_SHARED);
    2127        2816 :     *nextMulti = MultiXactState->nextMXact;
    2128        2816 :     *nextMultiOffset = MultiXactState->nextOffset;
    2129        2816 :     *oldestMulti = MultiXactState->oldestMultiXactId;
    2130        2816 :     *oldestMultiDB = MultiXactState->oldestMultiXactDB;
    2131        2816 :     LWLockRelease(MultiXactGenLock);
    2132             : 
    2133             :     debug_elog6(DEBUG2,
    2134             :                 "MultiXact: checkpoint is nextMulti %u, nextOffset %u, oldestMulti %u in DB %u",
    2135             :                 *nextMulti, *nextMultiOffset, *oldestMulti, *oldestMultiDB);
    2136        2816 : }
    2137             : 
    2138             : /*
    2139             :  * Perform a checkpoint --- either during shutdown, or on-the-fly
    2140             :  */
    2141             : void
    2142        2832 : CheckPointMultiXact(void)
    2143             : {
    2144             :     TRACE_POSTGRESQL_MULTIXACT_CHECKPOINT_START(true);
    2145             : 
    2146             :     /* Flush dirty MultiXact pages to disk */
    2147        2832 :     SimpleLruFlush(MultiXactOffsetCtl, true);
    2148        2832 :     SimpleLruFlush(MultiXactMemberCtl, true);
    2149             : 
    2150             :     TRACE_POSTGRESQL_MULTIXACT_CHECKPOINT_DONE(true);
    2151        2832 : }
    2152             : 
    2153             : /*
    2154             :  * Set the next-to-be-assigned MultiXactId and offset
    2155             :  *
    2156             :  * This is used when we can determine the correct next ID/offset exactly
    2157             :  * from a checkpoint record.  Although this is only called during bootstrap
    2158             :  * and XLog replay, we take the lock in case any hot-standby backends are
    2159             :  * examining the values.
    2160             :  */
    2161             : void
    2162        1546 : MultiXactSetNextMXact(MultiXactId nextMulti,
    2163             :                       MultiXactOffset nextMultiOffset)
    2164             : {
    2165             :     debug_elog4(DEBUG2, "MultiXact: setting next multi to %u offset %u",
    2166             :                 nextMulti, nextMultiOffset);
    2167        1546 :     LWLockAcquire(MultiXactGenLock, LW_EXCLUSIVE);
    2168        1546 :     MultiXactState->nextMXact = nextMulti;
    2169        1546 :     MultiXactState->nextOffset = nextMultiOffset;
    2170        1546 :     LWLockRelease(MultiXactGenLock);
    2171             : 
    2172             :     /*
    2173             :      * During a binary upgrade, make sure that the offsets SLRU is large
    2174             :      * enough to contain the next value that would be created.
    2175             :      *
    2176             :      * We need to do this pretty early during the first startup in binary
    2177             :      * upgrade mode: before StartupMultiXact() in fact, because this routine
    2178             :      * is called even before that by StartupXLOG().  And we can't do it
    2179             :      * earlier than at this point, because during that first call of this
    2180             :      * routine we determine the MultiXactState->nextMXact value that
    2181             :      * MaybeExtendOffsetSlru needs.
    2182             :      */
    2183        1546 :     if (IsBinaryUpgrade)
    2184           8 :         MaybeExtendOffsetSlru();
    2185        1546 : }
    2186             : 
    2187             : /*
    2188             :  * Determine the last safe MultiXactId to allocate given the currently oldest
    2189             :  * datminmxid (ie, the oldest MultiXactId that might exist in any database
    2190             :  * of our cluster), and the OID of the (or a) database with that value.
    2191             :  *
    2192             :  * is_startup is true when we are just starting the cluster, false when we
    2193             :  * are updating state in a running cluster.  This only affects log messages.
    2194             :  */
    2195             : void
    2196        3380 : SetMultiXactIdLimit(MultiXactId oldest_datminmxid, Oid oldest_datoid,
    2197             :                     bool is_startup)
    2198             : {
    2199             :     MultiXactId multiVacLimit;
    2200             :     MultiXactId multiWarnLimit;
    2201             :     MultiXactId multiStopLimit;
    2202             :     MultiXactId multiWrapLimit;
    2203             :     MultiXactId curMulti;
    2204             :     bool        needs_offset_vacuum;
    2205             : 
    2206             :     Assert(MultiXactIdIsValid(oldest_datminmxid));
    2207             : 
    2208             :     /*
    2209             :      * We pretend that a wrap will happen halfway through the multixact ID
    2210             :      * space, but that's not really true, because multixacts wrap differently
    2211             :      * from transaction IDs.  Note that, separately from any concern about
    2212             :      * multixact IDs wrapping, we must ensure that multixact members do not
    2213             :      * wrap.  Limits for that are set in SetOffsetVacuumLimit, not here.
    2214             :      */
    2215        3380 :     multiWrapLimit = oldest_datminmxid + (MaxMultiXactId >> 1);
    2216        3380 :     if (multiWrapLimit < FirstMultiXactId)
    2217           0 :         multiWrapLimit += FirstMultiXactId;
    2218             : 
    2219             :     /*
    2220             :      * We'll refuse to continue assigning MultiXactIds once we get within 100
    2221             :      * multi of data loss.
    2222             :      *
    2223             :      * Note: This differs from the magic number used in
    2224             :      * SetTransactionIdLimit() since vacuum itself will never generate new
    2225             :      * multis.  XXX actually it does, if it needs to freeze old multis.
    2226             :      */
    2227        3380 :     multiStopLimit = multiWrapLimit - 100;
    2228        3380 :     if (multiStopLimit < FirstMultiXactId)
    2229           0 :         multiStopLimit -= FirstMultiXactId;
    2230             : 
    2231             :     /*
    2232             :      * We'll start complaining loudly when we get within 10M multis of the
    2233             :      * stop point.   This is kind of arbitrary, but if you let your gas gauge
    2234             :      * get down to 1% of full, would you be looking for the next gas station?
    2235             :      * We need to be fairly liberal about this number because there are lots
    2236             :      * of scenarios where most transactions are done by automatic clients that
    2237             :      * won't pay attention to warnings. (No, we're not gonna make this
    2238             :      * configurable.  If you know enough to configure it, you know enough to
    2239             :      * not get in this kind of trouble in the first place.)
    2240             :      */
    2241        3380 :     multiWarnLimit = multiStopLimit - 10000000;
    2242        3380 :     if (multiWarnLimit < FirstMultiXactId)
    2243           0 :         multiWarnLimit -= FirstMultiXactId;
    2244             : 
    2245             :     /*
    2246             :      * We'll start trying to force autovacuums when oldest_datminmxid gets to
    2247             :      * be more than autovacuum_multixact_freeze_max_age mxids old.
    2248             :      *
    2249             :      * Note: autovacuum_multixact_freeze_max_age is a PGC_POSTMASTER parameter
    2250             :      * so that we don't have to worry about dealing with on-the-fly changes in
    2251             :      * its value.  See SetTransactionIdLimit.
    2252             :      */
    2253        3380 :     multiVacLimit = oldest_datminmxid + autovacuum_multixact_freeze_max_age;
    2254        3380 :     if (multiVacLimit < FirstMultiXactId)
    2255           0 :         multiVacLimit += FirstMultiXactId;
    2256             : 
    2257             :     /* Grab lock for just long enough to set the new limit values */
    2258        3380 :     LWLockAcquire(MultiXactGenLock, LW_EXCLUSIVE);
    2259        3380 :     MultiXactState->oldestMultiXactId = oldest_datminmxid;
    2260        3380 :     MultiXactState->oldestMultiXactDB = oldest_datoid;
    2261        3380 :     MultiXactState->multiVacLimit = multiVacLimit;
    2262        3380 :     MultiXactState->multiWarnLimit = multiWarnLimit;
    2263        3380 :     MultiXactState->multiStopLimit = multiStopLimit;
    2264        3380 :     MultiXactState->multiWrapLimit = multiWrapLimit;
    2265        3380 :     curMulti = MultiXactState->nextMXact;
    2266        3380 :     LWLockRelease(MultiXactGenLock);
    2267             : 
    2268             :     /* Log the info */
    2269        3380 :     ereport(DEBUG1,
    2270             :             (errmsg("MultiXactId wrap limit is %u, limited by database with OID %u",
    2271             :                     multiWrapLimit, oldest_datoid)));
    2272             : 
    2273             :     /*
    2274             :      * Computing the actual limits is only possible once the data directory is
    2275             :      * in a consistent state. There's no need to compute the limits while
    2276             :      * still replaying WAL - no decisions about new multis are made even
    2277             :      * though multixact creations might be replayed. So we'll only do further
    2278             :      * checks after TrimMultiXact() has been called.
    2279             :      */
    2280        3380 :     if (!MultiXactState->finishedStartup)
    2281        1514 :         return;
    2282             : 
    2283             :     Assert(!InRecovery);
    2284             : 
    2285             :     /* Set limits for offset vacuum. */
    2286        1866 :     needs_offset_vacuum = SetOffsetVacuumLimit(is_startup);
    2287             : 
    2288             :     /*
    2289             :      * If past the autovacuum force point, immediately signal an autovac
    2290             :      * request.  The reason for this is that autovac only processes one
    2291             :      * database per invocation.  Once it's finished cleaning up the oldest
    2292             :      * database, it'll call here, and we'll signal the postmaster to start
    2293             :      * another iteration immediately if there are still any old databases.
    2294             :      */
    2295        1866 :     if ((MultiXactIdPrecedes(multiVacLimit, curMulti) ||
    2296           0 :          needs_offset_vacuum) && IsUnderPostmaster)
    2297           0 :         SendPostmasterSignal(PMSIGNAL_START_AUTOVAC_LAUNCHER);
    2298             : 
    2299             :     /* Give an immediate warning if past the wrap warn point */
    2300        1866 :     if (MultiXactIdPrecedes(multiWarnLimit, curMulti))
    2301             :     {
    2302             :         char       *oldest_datname;
    2303             : 
    2304             :         /*
    2305             :          * We can be called when not inside a transaction, for example during
    2306             :          * StartupXLOG().  In such a case we cannot do database access, so we
    2307             :          * must just report the oldest DB's OID.
    2308             :          *
    2309             :          * Note: it's also possible that get_database_name fails and returns
    2310             :          * NULL, for example because the database just got dropped.  We'll
    2311             :          * still warn, even though the warning might now be unnecessary.
    2312             :          */
    2313           0 :         if (IsTransactionState())
    2314           0 :             oldest_datname = get_database_name(oldest_datoid);
    2315             :         else
    2316           0 :             oldest_datname = NULL;
    2317             : 
    2318           0 :         if (oldest_datname)
    2319           0 :             ereport(WARNING,
    2320             :                     (errmsg_plural("database \"%s\" must be vacuumed before %u more MultiXactId is used",
    2321             :                                    "database \"%s\" must be vacuumed before %u more MultiXactIds are used",
    2322             :                                    multiWrapLimit - curMulti,
    2323             :                                    oldest_datname,
    2324             :                                    multiWrapLimit - curMulti),
    2325             :                      errhint("To avoid a database shutdown, execute a database-wide VACUUM in that database.\n"
    2326             :                              "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
    2327             :         else
    2328           0 :             ereport(WARNING,
    2329             :                     (errmsg_plural("database with OID %u must be vacuumed before %u more MultiXactId is used",
    2330             :                                    "database with OID %u must be vacuumed before %u more MultiXactIds are used",
    2331             :                                    multiWrapLimit - curMulti,
    2332             :                                    oldest_datoid,
    2333             :                                    multiWrapLimit - curMulti),
    2334             :                      errhint("To avoid a database shutdown, execute a database-wide VACUUM in that database.\n"
    2335             :                              "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
    2336             :     }
    2337             : }
    2338             : 
    2339             : /*
    2340             :  * Ensure the next-to-be-assigned MultiXactId is at least minMulti,
    2341             :  * and similarly nextOffset is at least minMultiOffset.
    2342             :  *
    2343             :  * This is used when we can determine minimum safe values from an XLog
    2344             :  * record (either an on-line checkpoint or an mxact creation log entry).
    2345             :  * Although this is only called during XLog replay, we take the lock in case
    2346             :  * any hot-standby backends are examining the values.
    2347             :  */
    2348             : void
    2349         128 : MultiXactAdvanceNextMXact(MultiXactId minMulti,
    2350             :                           MultiXactOffset minMultiOffset)
    2351             : {
    2352         128 :     LWLockAcquire(MultiXactGenLock, LW_EXCLUSIVE);
    2353         128 :     if (MultiXactIdPrecedes(MultiXactState->nextMXact, minMulti))
    2354             :     {
    2355             :         debug_elog3(DEBUG2, "MultiXact: setting next multi to %u", minMulti);
    2356           0 :         MultiXactState->nextMXact = minMulti;
    2357             :     }
    2358         128 :     if (MultiXactOffsetPrecedes(MultiXactState->nextOffset, minMultiOffset))
    2359             :     {
    2360             :         debug_elog3(DEBUG2, "MultiXact: setting next offset to %u",
    2361             :                     minMultiOffset);
    2362           0 :         MultiXactState->nextOffset = minMultiOffset;
    2363             :     }
    2364         128 :     LWLockRelease(MultiXactGenLock);
    2365         128 : }
    2366             : 
    2367             : /*
    2368             :  * Update our oldestMultiXactId value, but only if it's more recent than what
    2369             :  * we had.
    2370             :  *
    2371             :  * This may only be called during WAL replay.
    2372             :  */
    2373             : void
    2374         160 : MultiXactAdvanceOldest(MultiXactId oldestMulti, Oid oldestMultiDB)
    2375             : {
    2376             :     Assert(InRecovery);
    2377             : 
    2378         160 :     if (MultiXactIdPrecedes(MultiXactState->oldestMultiXactId, oldestMulti))
    2379           0 :         SetMultiXactIdLimit(oldestMulti, oldestMultiDB, false);
    2380         160 : }
    2381             : 
    2382             : /*
    2383             :  * Make sure that MultiXactOffset has room for a newly-allocated MultiXactId.
    2384             :  *
    2385             :  * NB: this is called while holding MultiXactGenLock.  We want it to be very
    2386             :  * fast most of the time; even when it's not so fast, no actual I/O need
    2387             :  * happen unless we're forced to write out a dirty log or xlog page to make
    2388             :  * room in shared memory.
    2389             :  */
    2390             : static void
    2391         494 : ExtendMultiXactOffset(MultiXactId multi)
    2392             : {
    2393             :     int         pageno;
    2394             : 
    2395             :     /*
    2396             :      * No work except at first MultiXactId of a page.  But beware: just after
    2397             :      * wraparound, the first MultiXactId of page zero is FirstMultiXactId.
    2398             :      */
    2399         494 :     if (MultiXactIdToOffsetEntry(multi) != 0 &&
    2400             :         multi != FirstMultiXactId)
    2401         482 :         return;
    2402             : 
    2403          12 :     pageno = MultiXactIdToOffsetPage(multi);
    2404             : 
    2405          12 :     LWLockAcquire(MultiXactOffsetControlLock, LW_EXCLUSIVE);
    2406             : 
    2407             :     /* Zero the page and make an XLOG entry about it */
    2408          12 :     ZeroMultiXactOffsetPage(pageno, true);
    2409             : 
    2410          12 :     LWLockRelease(MultiXactOffsetControlLock);
    2411             : }
    2412             : 
    2413             : /*
    2414             :  * Make sure that MultiXactMember has room for the members of a newly-
    2415             :  * allocated MultiXactId.
    2416             :  *
    2417             :  * Like the above routine, this is called while holding MultiXactGenLock;
    2418             :  * same comments apply.
    2419             :  */
    2420             : static void
    2421         494 : ExtendMultiXactMember(MultiXactOffset offset, int nmembers)
    2422             : {
    2423             :     /*
    2424             :      * It's possible that the members span more than one page of the members
    2425             :      * file, so we loop to ensure we consider each page.  The coding is not
    2426             :      * optimal if the members span several pages, but that seems unusual
    2427             :      * enough to not worry much about.
    2428             :      */
    2429        1482 :     while (nmembers > 0)
    2430             :     {
    2431             :         int         flagsoff;
    2432             :         int         flagsbit;
    2433             :         uint32      difference;
    2434             : 
    2435             :         /*
    2436             :          * Only zero when at first entry of a page.
    2437             :          */
    2438         494 :         flagsoff = MXOffsetToFlagsOffset(offset);
    2439         494 :         flagsbit = MXOffsetToFlagsBitShift(offset);
    2440         494 :         if (flagsoff == 0 && flagsbit == 0)
    2441             :         {
    2442             :             int         pageno;
    2443             : 
    2444          12 :             pageno = MXOffsetToMemberPage(offset);
    2445             : 
    2446          12 :             LWLockAcquire(MultiXactMemberControlLock, LW_EXCLUSIVE);
    2447             : 
    2448             :             /* Zero the page and make an XLOG entry about it */
    2449          12 :             ZeroMultiXactMemberPage(pageno, true);
    2450             : 
    2451          12 :             LWLockRelease(MultiXactMemberControlLock);
    2452             :         }
    2453             : 
    2454             :         /*
    2455             :          * Compute the number of items till end of current page.  Careful: if
    2456             :          * addition of unsigned ints wraps around, we're at the last page of
    2457             :          * the last segment; since that page holds a different number of items
    2458             :          * than other pages, we need to do it differently.
    2459             :          */
    2460         494 :         if (offset + MAX_MEMBERS_IN_LAST_MEMBERS_PAGE < offset)
    2461             :         {
    2462             :             /*
    2463             :              * This is the last page of the last segment; we can compute the
    2464             :              * number of items left to allocate in it without modulo
    2465             :              * arithmetic.
    2466             :              */
    2467           0 :             difference = MaxMultiXactOffset - offset + 1;
    2468             :         }
    2469             :         else
    2470         494 :             difference = MULTIXACT_MEMBERS_PER_PAGE - offset % MULTIXACT_MEMBERS_PER_PAGE;
    2471             : 
    2472             :         /*
    2473             :          * Advance to next page, taking care to properly handle the wraparound
    2474             :          * case.  OK if nmembers goes negative.
    2475             :          */
    2476         494 :         nmembers -= difference;
    2477         494 :         offset += difference;
    2478             :     }
    2479         494 : }
    2480             : 
    2481             : /*
    2482             :  * GetOldestMultiXactId
    2483             :  *
    2484             :  * Return the oldest MultiXactId that's still possibly still seen as live by
    2485             :  * any running transaction.  Older ones might still exist on disk, but they no
    2486             :  * longer have any running member transaction.
    2487             :  *
    2488             :  * It's not safe to truncate MultiXact SLRU segments on the value returned by
    2489             :  * this function; however, it can be used by a full-table vacuum to set the
    2490             :  * point at which it will be possible to truncate SLRU for that table.
    2491             :  */
    2492             : MultiXactId
    2493      105454 : GetOldestMultiXactId(void)
    2494             : {
    2495             :     MultiXactId oldestMXact;
    2496             :     MultiXactId nextMXact;
    2497             :     int         i;
    2498             : 
    2499             :     /*
    2500             :      * This is the oldest valid value among all the OldestMemberMXactId[] and
    2501             :      * OldestVisibleMXactId[] entries, or nextMXact if none are valid.
    2502             :      */
    2503      105454 :     LWLockAcquire(MultiXactGenLock, LW_SHARED);
    2504             : 
    2505             :     /*
    2506             :      * We have to beware of the possibility that nextMXact is in the
    2507             :      * wrapped-around state.  We don't fix the counter itself here, but we
    2508             :      * must be sure to use a valid value in our calculation.
    2509             :      */
    2510      105454 :     nextMXact = MultiXactState->nextMXact;
    2511      105454 :     if (nextMXact < FirstMultiXactId)
    2512           0 :         nextMXact = FirstMultiXactId;
    2513             : 
    2514      105454 :     oldestMXact = nextMXact;
    2515    12908990 :     for (i = 1; i <= MaxOldestSlot; i++)
    2516             :     {
    2517             :         MultiXactId thisoldest;
    2518             : 
    2519    12803536 :         thisoldest = OldestMemberMXactId[i];
    2520    12816342 :         if (MultiXactIdIsValid(thisoldest) &&
    2521       12806 :             MultiXactIdPrecedes(thisoldest, oldestMXact))
    2522          30 :             oldestMXact = thisoldest;
    2523    12803536 :         thisoldest = OldestVisibleMXactId[i];
    2524    12803548 :         if (MultiXactIdIsValid(thisoldest) &&
    2525          12 :             MultiXactIdPrecedes(thisoldest, oldestMXact))
    2526           4 :             oldestMXact = thisoldest;
    2527             :     }
    2528             : 
    2529      105454 :     LWLockRelease(MultiXactGenLock);
    2530             : 
    2531      105454 :     return oldestMXact;
    2532             : }
    2533             : 
    2534             : /*
    2535             :  * Determine how aggressively we need to vacuum in order to prevent member
    2536             :  * wraparound.
    2537             :  *
    2538             :  * To do so determine what's the oldest member offset and install the limit
    2539             :  * info in MultiXactState, where it can be used to prevent overrun of old data
    2540             :  * in the members SLRU area.
    2541             :  *
    2542             :  * The return value is true if emergency autovacuum is required and false
    2543             :  * otherwise.
    2544             :  */
    2545             : static bool
    2546        1866 : SetOffsetVacuumLimit(bool is_startup)
    2547             : {
    2548             :     MultiXactId oldestMultiXactId;
    2549             :     MultiXactId nextMXact;
    2550        1866 :     MultiXactOffset oldestOffset = 0;   /* placate compiler */
    2551             :     MultiXactOffset prevOldestOffset;
    2552             :     MultiXactOffset nextOffset;
    2553        1866 :     bool        oldestOffsetKnown = false;
    2554             :     bool        prevOldestOffsetKnown;
    2555        1866 :     MultiXactOffset offsetStopLimit = 0;
    2556             :     MultiXactOffset prevOffsetStopLimit;
    2557             : 
    2558             :     /*
    2559             :      * NB: Have to prevent concurrent truncation, we might otherwise try to
    2560             :      * lookup an oldestMulti that's concurrently getting truncated away.
    2561             :      */
    2562        1866 :     LWLockAcquire(MultiXactTruncationLock, LW_SHARED);
    2563             : 
    2564             :     /* Read relevant fields from shared memory. */
    2565        1866 :     LWLockAcquire(MultiXactGenLock, LW_SHARED);
    2566        1866 :     oldestMultiXactId = MultiXactState->oldestMultiXactId;
    2567        1866 :     nextMXact = MultiXactState->nextMXact;
    2568        1866 :     nextOffset = MultiXactState->nextOffset;
    2569        1866 :     prevOldestOffsetKnown = MultiXactState->oldestOffsetKnown;
    2570        1866 :     prevOldestOffset = MultiXactState->oldestOffset;
    2571        1866 :     prevOffsetStopLimit = MultiXactState->offsetStopLimit;
    2572             :     Assert(MultiXactState->finishedStartup);
    2573        1866 :     LWLockRelease(MultiXactGenLock);
    2574             : 
    2575             :     /*
    2576             :      * Determine the offset of the oldest multixact.  Normally, we can read
    2577             :      * the offset from the multixact itself, but there's an important special
    2578             :      * case: if there are no multixacts in existence at all, oldestMXact
    2579             :      * obviously can't point to one.  It will instead point to the multixact
    2580             :      * ID that will be assigned the next time one is needed.
    2581             :      */
    2582        1866 :     if (oldestMultiXactId == nextMXact)
    2583             :     {
    2584             :         /*
    2585             :          * When the next multixact gets created, it will be stored at the next
    2586             :          * offset.
    2587             :          */
    2588        1856 :         oldestOffset = nextOffset;
    2589        1856 :         oldestOffsetKnown = true;
    2590             :     }
    2591             :     else
    2592             :     {
    2593             :         /*
    2594             :          * Figure out where the oldest existing multixact's offsets are
    2595             :          * stored. Due to bugs in early release of PostgreSQL 9.3.X and 9.4.X,
    2596             :          * the supposedly-earliest multixact might not really exist.  We are
    2597             :          * careful not to fail in that case.
    2598             :          */
    2599          10 :         oldestOffsetKnown =
    2600             :             find_multixact_start(oldestMultiXactId, &oldestOffset);
    2601             : 
    2602          10 :         if (oldestOffsetKnown)
    2603          10 :             ereport(DEBUG1,
    2604             :                     (errmsg("oldest MultiXactId member is at offset %u",
    2605             :                             oldestOffset)));
    2606             :         else
    2607           0 :             ereport(LOG,
    2608             :                     (errmsg("MultiXact member wraparound protections are disabled because oldest checkpointed MultiXact %u does not exist on disk",
    2609             :                             oldestMultiXactId)));
    2610             :     }
    2611             : 
    2612        1866 :     LWLockRelease(MultiXactTruncationLock);
    2613             : 
    2614             :     /*
    2615             :      * If we can, compute limits (and install them MultiXactState) to prevent
    2616             :      * overrun of old data in the members SLRU area. We can only do so if the
    2617             :      * oldest offset is known though.
    2618             :      */
    2619        1866 :     if (oldestOffsetKnown)
    2620             :     {
    2621             :         /* move back to start of the corresponding segment */
    2622        1866 :         offsetStopLimit = oldestOffset - (oldestOffset %
    2623             :                                           (MULTIXACT_MEMBERS_PER_PAGE * SLRU_PAGES_PER_SEGMENT));
    2624             : 
    2625             :         /* always leave one segment before the wraparound point */
    2626        1866 :         offsetStopLimit -= (MULTIXACT_MEMBERS_PER_PAGE * SLRU_PAGES_PER_SEGMENT);
    2627             : 
    2628        1866 :         if (!prevOldestOffsetKnown && !is_startup)
    2629           0 :             ereport(LOG,
    2630             :                     (errmsg("MultiXact member wraparound protections are now enabled")));
    2631             : 
    2632        1866 :         ereport(DEBUG1,
    2633             :                 (errmsg("MultiXact member stop limit is now %u based on MultiXact %u",
    2634             :                         offsetStopLimit, oldestMultiXactId)));
    2635             :     }
    2636           0 :     else if (prevOldestOffsetKnown)
    2637             :     {
    2638             :         /*
    2639             :          * If we failed to get the oldest offset this time, but we have a
    2640             :          * value from a previous pass through this function, use the old
    2641             :          * values rather than automatically forcing an emergency autovacuum
    2642             :          * cycle again.
    2643             :          */
    2644           0 :         oldestOffset = prevOldestOffset;
    2645           0 :         oldestOffsetKnown = true;
    2646           0 :         offsetStopLimit = prevOffsetStopLimit;
    2647             :     }
    2648             : 
    2649             :     /* Install the computed values */
    2650        1866 :     LWLockAcquire(MultiXactGenLock, LW_EXCLUSIVE);
    2651        1866 :     MultiXactState->oldestOffset = oldestOffset;
    2652        1866 :     MultiXactState->oldestOffsetKnown = oldestOffsetKnown;
    2653        1866 :     MultiXactState->offsetStopLimit = offsetStopLimit;
    2654        1866 :     LWLockRelease(MultiXactGenLock);
    2655             : 
    2656             :     /*
    2657             :      * Do we need an emergency autovacuum?  If we're not sure, assume yes.
    2658             :      */
    2659        3732 :     return !oldestOffsetKnown ||
    2660        1866 :         (nextOffset - oldestOffset > MULTIXACT_MEMBER_SAFE_THRESHOLD);
    2661             : }
    2662             : 
    2663             : /*
    2664             :  * Return whether adding "distance" to "start" would move past "boundary".
    2665             :  *
    2666             :  * We use this to determine whether the addition is "wrapping around" the
    2667             :  * boundary point, hence the name.  The reason we don't want to use the regular
    2668             :  * 2^31-modulo arithmetic here is that we want to be able to use the whole of
    2669             :  * the 2^32-1 space here, allowing for more multixacts that would fit
    2670             :  * otherwise.
    2671             :  */
    2672             : static bool
    2673         988 : MultiXactOffsetWouldWrap(MultiXactOffset boundary, MultiXactOffset start,
    2674             :                          uint32 distance)
    2675             : {
    2676             :     MultiXactOffset finish;
    2677             : 
    2678             :     /*
    2679             :      * Note that offset number 0 is not used (see GetMultiXactIdMembers), so
    2680             :      * if the addition wraps around the UINT_MAX boundary, skip that value.
    2681             :      */
    2682         988 :     finish = start + distance;
    2683         988 :     if (finish < start)
    2684           0 :         finish++;
    2685             : 
    2686             :     /*-----------------------------------------------------------------------
    2687             :      * When the boundary is numerically greater than the starting point, any
    2688             :      * value numerically between the two is not wrapped:
    2689             :      *
    2690             :      *  <----S----B---->
    2691             :      *  [---)            = F wrapped past B (and UINT_MAX)
    2692             :      *       [---)       = F not wrapped
    2693             :      *            [----] = F wrapped past B
    2694             :      *
    2695             :      * When the boundary is numerically less than the starting point (i.e. the
    2696             :      * UINT_MAX wraparound occurs somewhere in between) then all values in
    2697             :      * between are wrapped:
    2698             :      *
    2699             :      *  <----B----S---->
    2700             :      *  [---)            = F not wrapped past B (but wrapped past UINT_MAX)
    2701             :      *       [---)       = F wrapped past B (and UINT_MAX)
    2702             :      *            [----] = F not wrapped
    2703             :      *-----------------------------------------------------------------------
    2704             :      */
    2705         988 :     if (start < boundary)
    2706         988 :         return finish >= boundary || finish < start;
    2707             :     else
    2708           0 :         return finish >= boundary && finish < start;
    2709             : }
    2710             : 
    2711             : /*
    2712             :  * Find the starting offset of the given MultiXactId.
    2713             :  *
    2714             :  * Returns false if the file containing the multi does not exist on disk.
    2715             :  * Otherwise, returns true and sets *result to the starting member offset.
    2716             :  *
    2717             :  * This function does not prevent concurrent truncation, so if that's
    2718             :  * required, the caller has to protect against that.
    2719             :  */
    2720             : static bool
    2721          10 : find_multixact_start(MultiXactId multi, MultiXactOffset *result)
    2722             : {
    2723             :     MultiXactOffset offset;
    2724             :     int         pageno;
    2725             :     int         entryno;
    2726             :     int         slotno;
    2727             :     MultiXactOffset *offptr;
    2728             : 
    2729             :     Assert(MultiXactState->finishedStartup);
    2730             : 
    2731          10 :     pageno = MultiXactIdToOffsetPage(multi);
    2732          10 :     entryno = MultiXactIdToOffsetEntry(multi);
    2733             : 
    2734             :     /*
    2735             :      * Flush out dirty data, so PhysicalPageExists can work correctly.
    2736             :      * SimpleLruFlush() is a pretty big hammer for that.  Alternatively we
    2737             :      * could add an in-memory version of page exists, but find_multixact_start
    2738             :      * is called infrequently, and it doesn't seem bad to flush buffers to
    2739             :      * disk before truncation.
    2740             :      */
    2741          10 :     SimpleLruFlush(MultiXactOffsetCtl, true);
    2742          10 :     SimpleLruFlush(MultiXactMemberCtl, true);
    2743             : 
    2744          10 :     if (!SimpleLruDoesPhysicalPageExist(MultiXactOffsetCtl, pageno))
    2745           0 :         return false;
    2746             : 
    2747             :     /* lock is acquired by SimpleLruReadPage_ReadOnly */
    2748          10 :     slotno = SimpleLruReadPage_ReadOnly(MultiXactOffsetCtl, pageno, multi);
    2749          10 :     offptr = (MultiXactOffset *) MultiXactOffsetCtl->shared->page_buffer[slotno];
    2750          10 :     offptr += entryno;
    2751          10 :     offset = *offptr;
    2752          10 :     LWLockRelease(MultiXactOffsetControlLock);
    2753             : 
    2754          10 :     *result = offset;
    2755          10 :     return true;
    2756             : }
    2757             : 
    2758             : /*
    2759             :  * Determine how many multixacts, and how many multixact members, currently
    2760             :  * exist.  Return false if unable to determine.
    2761             :  */
    2762             : static bool
    2763       40502 : ReadMultiXactCounts(uint32 *multixacts, MultiXactOffset *members)
    2764             : {
    2765             :     MultiXactOffset nextOffset;
    2766             :     MultiXactOffset oldestOffset;
    2767             :     MultiXactId oldestMultiXactId;
    2768             :     MultiXactId nextMultiXactId;
    2769             :     bool        oldestOffsetKnown;
    2770             : 
    2771       40502 :     LWLockAcquire(MultiXactGenLock, LW_SHARED);
    2772       40502 :     nextOffset = MultiXactState->nextOffset;
    2773       40502 :     oldestMultiXactId = MultiXactState->oldestMultiXactId;
    2774       40502 :     nextMultiXactId = MultiXactState->nextMXact;
    2775       40502 :     oldestOffset = MultiXactState->oldestOffset;
    2776       40502 :     oldestOffsetKnown = MultiXactState->oldestOffsetKnown;
    2777       40502 :     LWLockRelease(MultiXactGenLock);
    2778             : 
    2779       40502 :     if (!oldestOffsetKnown)
    2780           0 :         return false;
    2781             : 
    2782       40502 :     *members = nextOffset - oldestOffset;
    2783       40502 :     *multixacts = nextMultiXactId - oldestMultiXactId;
    2784       40502 :     return true;
    2785             : }
    2786             : 
    2787             : /*
    2788             :  * Multixact members can be removed once the multixacts that refer to them
    2789             :  * are older than every datminmxid.  autovacuum_multixact_freeze_max_age and
    2790             :  * vacuum_multixact_freeze_table_age work together to make sure we never have
    2791             :  * too many multixacts; we hope that, at least under normal circumstances,
    2792             :  * this will also be sufficient to keep us from using too many offsets.
    2793             :  * However, if the average multixact has many members, we might exhaust the
    2794             :  * members space while still using few enough members that these limits fail
    2795             :  * to trigger full table scans for relminmxid advancement.  At that point,
    2796             :  * we'd have no choice but to start failing multixact-creating operations
    2797             :  * with an error.
    2798             :  *
    2799             :  * To prevent that, if more than a threshold portion of the members space is
    2800             :  * used, we effectively reduce autovacuum_multixact_freeze_max_age and
    2801             :  * to a value just less than the number of multixacts in use.  We hope that
    2802             :  * this will quickly trigger autovacuuming on the table or tables with the
    2803             :  * oldest relminmxid, thus allowing datminmxid values to advance and removing
    2804             :  * some members.
    2805             :  *
    2806             :  * As the fraction of the member space currently in use grows, we become
    2807             :  * more aggressive in clamping this value.  That not only causes autovacuum
    2808             :  * to ramp up, but also makes any manual vacuums the user issues more
    2809             :  * aggressive.  This happens because vacuum_set_xid_limits() clamps the
    2810             :  * freeze table and the minimum freeze age based on the effective
    2811             :  * autovacuum_multixact_freeze_max_age this function returns.  In the worst
    2812             :  * case, we'll claim the freeze_max_age to zero, and every vacuum of any
    2813             :  * table will try to freeze every multixact.
    2814             :  *
    2815             :  * It's possible that these thresholds should be user-tunable, but for now
    2816             :  * we keep it simple.
    2817             :  */
    2818             : int
    2819       40502 : MultiXactMemberFreezeThreshold(void)
    2820             : {
    2821             :     MultiXactOffset members;
    2822             :     uint32      multixacts;
    2823             :     uint32      victim_multixacts;
    2824             :     double      fraction;
    2825             : 
    2826             :     /* If we can't determine member space utilization, assume the worst. */
    2827       40502 :     if (!ReadMultiXactCounts(&multixacts, &members))
    2828           0 :         return 0;
    2829             : 
    2830             :     /* If member space utilization is low, no special action is required. */
    2831       40502 :     if (members <= MULTIXACT_MEMBER_SAFE_THRESHOLD)
    2832       40502 :         return autovacuum_multixact_freeze_max_age;
    2833             : 
    2834             :     /*
    2835             :      * Compute a target for relminmxid advancement.  The number of multixacts
    2836             :      * we try to eliminate from the system is based on how far we are past
    2837             :      * MULTIXACT_MEMBER_SAFE_THRESHOLD.
    2838             :      */
    2839           0 :     fraction = (double) (members - MULTIXACT_MEMBER_SAFE_THRESHOLD) /
    2840             :         (MULTIXACT_MEMBER_DANGER_THRESHOLD - MULTIXACT_MEMBER_SAFE_THRESHOLD);
    2841           0 :     victim_multixacts = multixacts * fraction;
    2842             : 
    2843             :     /* fraction could be > 1.0, but lowest possible freeze age is zero */
    2844           0 :     if (victim_multixacts > multixacts)
    2845           0 :         return 0;
    2846           0 :     return multixacts - victim_multixacts;
    2847             : }
    2848             : 
    2849             : typedef struct mxtruncinfo
    2850             : {
    2851             :     int         earliestExistingPage;
    2852             : } mxtruncinfo;
    2853             : 
    2854             : /*
    2855             :  * SlruScanDirectory callback
    2856             :  *      This callback determines the earliest existing page number.
    2857             :  */
    2858             : static bool
    2859           0 : SlruScanDirCbFindEarliest(SlruCtl ctl, char *filename, int segpage, void *data)
    2860             : {
    2861           0 :     mxtruncinfo *trunc = (mxtruncinfo *) data;
    2862             : 
    2863           0 :     if (trunc->earliestExistingPage == -1 ||
    2864           0 :         ctl->PagePrecedes(segpage, trunc->earliestExistingPage))
    2865             :     {
    2866           0 :         trunc->earliestExistingPage = segpage;
    2867             :     }
    2868             : 
    2869           0 :     return false;               /* keep going */
    2870             : }
    2871             : 
    2872             : 
    2873             : /*
    2874             :  * Delete members segments [oldest, newOldest)
    2875             :  *
    2876             :  * The members SLRU can, in contrast to the offsets one, be filled to almost
    2877             :  * the full range at once. This means SimpleLruTruncate() can't trivially be
    2878             :  * used - instead the to-be-deleted range is computed using the offsets
    2879             :  * SLRU. C.f. TruncateMultiXact().
    2880             :  */
    2881             : static void
    2882           0 : PerformMembersTruncation(MultiXactOffset oldestOffset, MultiXactOffset newOldestOffset)
    2883             : {
    2884           0 :     const int   maxsegment = MXOffsetToMemberSegment(MaxMultiXactOffset);
    2885           0 :     int         startsegment = MXOffsetToMemberSegment(oldestOffset);
    2886           0 :     int         endsegment = MXOffsetToMemberSegment(newOldestOffset);
    2887           0 :     int         segment = startsegment;
    2888             : 
    2889             :     /*
    2890             :      * Delete all the segments but the last one. The last segment can still
    2891             :      * contain, possibly partially, valid data.
    2892             :      */
    2893           0 :     while (segment != endsegment)
    2894             :     {
    2895           0 :         elog(DEBUG2, "truncating multixact members segment %x", segment);
    2896           0 :         SlruDeleteSegment(MultiXactMemberCtl, segment);
    2897             : 
    2898             :         /* move to next segment, handling wraparound correctly */
    2899           0 :         if (segment == maxsegment)
    2900           0 :             segment = 0;
    2901             :         else
    2902           0 :             segment += 1;
    2903             :     }
    2904           0 : }
    2905             : 
    2906             : /*
    2907             :  * Delete offsets segments [oldest, newOldest)
    2908             :  */
    2909             : static void
    2910           0 : PerformOffsetsTruncation(MultiXactId oldestMulti, MultiXactId newOldestMulti)
    2911             : {
    2912             :     /*
    2913             :      * We step back one multixact to avoid passing a cutoff page that hasn't
    2914             :      * been created yet in the rare case that oldestMulti would be the first
    2915             :      * item on a page and oldestMulti == nextMulti.  In that case, if we
    2916             :      * didn't subtract one, we'd trigger SimpleLruTruncate's wraparound
    2917             :      * detection.
    2918             :      */
    2919           0 :     SimpleLruTruncate(MultiXactOffsetCtl,
    2920           0 :                       MultiXactIdToOffsetPage(PreviousMultiXactId(newOldestMulti)));
    2921           0 : }
    2922             : 
    2923             : /*
    2924             :  * Remove all MultiXactOffset and MultiXactMember segments before the oldest
    2925             :  * ones still of interest.
    2926             :  *
    2927             :  * This is only called on a primary as part of vacuum (via
    2928             :  * vac_truncate_clog()). During recovery truncation is done by replaying
    2929             :  * truncation WAL records logged here.
    2930             :  *
    2931             :  * newOldestMulti is the oldest currently required multixact, newOldestMultiDB
    2932             :  * is one of the databases preventing newOldestMulti from increasing.
    2933             :  */
    2934             : void
    2935         696 : TruncateMultiXact(MultiXactId newOldestMulti, Oid newOldestMultiDB)
    2936             : {
    2937             :     MultiXactId oldestMulti;
    2938             :     MultiXactId nextMulti;
    2939             :     MultiXactOffset newOldestOffset;
    2940             :     MultiXactOffset oldestOffset;
    2941             :     MultiXactOffset nextOffset;
    2942             :     mxtruncinfo trunc;
    2943             :     MultiXactId earliest;
    2944             : 
    2945             :     Assert(!RecoveryInProgress());
    2946             :     Assert(MultiXactState->finishedStartup);
    2947             : 
    2948             :     /*
    2949             :      * We can only allow one truncation to happen at once. Otherwise parts of
    2950             :      * members might vanish while we're doing lookups or similar. There's no
    2951             :      * need to have an interlock with creating new multis or such, since those
    2952             :      * are constrained by the limits (which only grow, never shrink).
    2953             :      */
    2954         696 :     LWLockAcquire(MultiXactTruncationLock, LW_EXCLUSIVE);
    2955             : 
    2956         696 :     LWLockAcquire(MultiXactGenLock, LW_SHARED);
    2957         696 :     nextMulti = MultiXactState->nextMXact;
    2958         696 :     nextOffset = MultiXactState->nextOffset;
    2959         696 :     oldestMulti = MultiXactState->oldestMultiXactId;
    2960         696 :     LWLockRelease(MultiXactGenLock);
    2961             :     Assert(MultiXactIdIsValid(oldestMulti));
    2962             : 
    2963             :     /*
    2964             :      * Make sure to only attempt truncation if there's values to truncate
    2965             :      * away. In normal processing values shouldn't go backwards, but there's
    2966             :      * some corner cases (due to bugs) where that's possible.
    2967             :      */
    2968         696 :     if (MultiXactIdPrecedesOrEquals(newOldestMulti, oldestMulti))
    2969             :     {
    2970         696 :         LWLockRelease(MultiXactTruncationLock);
    2971         696 :         return;
    2972             :     }
    2973             : 
    2974             :     /*
    2975             :      * Note we can't just plow ahead with the truncation; it's possible that
    2976             :      * there are no segments to truncate, which is a problem because we are
    2977             :      * going to attempt to read the offsets page to determine where to
    2978             :      * truncate the members SLRU.  So we first scan the directory to determine
    2979             :      * the earliest offsets page number that we can read without error.
    2980             :      *
    2981             :      * NB: It's also possible that the page that oldestMulti is on has already
    2982             :      * been truncated away, and we crashed before updating oldestMulti.
    2983             :      */
    2984           0 :     trunc.earliestExistingPage = -1;
    2985           0 :     SlruScanDirectory(MultiXactOffsetCtl, SlruScanDirCbFindEarliest, &trunc);
    2986           0 :     earliest = trunc.earliestExistingPage * MULTIXACT_OFFSETS_PER_PAGE;
    2987           0 :     if (earliest < FirstMultiXactId)
    2988           0 :         earliest = FirstMultiXactId;
    2989             : 
    2990             :     /* If there's nothing to remove, we can bail out early. */
    2991           0 :     if (MultiXactIdPrecedes(oldestMulti, earliest))
    2992             :     {
    2993           0 :         LWLockRelease(MultiXactTruncationLock);
    2994           0 :         return;
    2995             :     }
    2996             : 
    2997             :     /*
    2998             :      * First, compute the safe truncation point for MultiXactMember. This is
    2999             :      * the starting offset of the oldest multixact.
    3000             :      *
    3001             :      * Hopefully, find_multixact_start will always work here, because we've
    3002             :      * already checked that it doesn't precede the earliest MultiXact on disk.
    3003             :      * But if it fails, don't truncate anything, and log a message.
    3004             :      */
    3005           0 :     if (oldestMulti == nextMulti)
    3006             :     {
    3007             :         /* there are NO MultiXacts */
    3008           0 :         oldestOffset = nextOffset;
    3009             :     }
    3010           0 :     else if (!find_multixact_start(oldestMulti, &oldestOffset))
    3011             :     {
    3012           0 :         ereport(LOG,
    3013             :                 (errmsg("oldest MultiXact %u not found, earliest MultiXact %u, skipping truncation",
    3014             :                         oldestMulti, earliest)));
    3015           0 :         LWLockRelease(MultiXactTruncationLock);
    3016           0 :         return;
    3017             :     }
    3018             : 
    3019             :     /*
    3020             :      * Secondly compute up to where to truncate. Lookup the corresponding
    3021             :      * member offset for newOldestMulti for that.
    3022             :      */
    3023           0 :     if (newOldestMulti == nextMulti)
    3024             :     {
    3025             :         /* there are NO MultiXacts */
    3026           0 :         newOldestOffset = nextOffset;
    3027             :     }
    3028           0 :     else if (!find_multixact_start(newOldestMulti, &newOldestOffset))
    3029             :     {
    3030           0 :         ereport(LOG,
    3031             :                 (errmsg("cannot truncate up to MultiXact %u because it does not exist on disk, skipping truncation",
    3032             :                         newOldestMulti)));
    3033           0 :         LWLockRelease(MultiXactTruncationLock);
    3034           0 :         return;
    3035             :     }
    3036             : 
    3037           0 :     elog(DEBUG1, "performing multixact truncation: "
    3038             :          "offsets [%u, %u), offsets segments [%x, %x), "
    3039             :          "members [%u, %u), members segments [%x, %x)",
    3040             :          oldestMulti, newOldestMulti,
    3041             :          MultiXactIdToOffsetSegment(oldestMulti),
    3042             :          MultiXactIdToOffsetSegment(newOldestMulti),
    3043             :          oldestOffset, newOldestOffset,
    3044             :          MXOffsetToMemberSegment(oldestOffset),
    3045             :          MXOffsetToMemberSegment(newOldestOffset));
    3046             : 
    3047             :     /*
    3048             :      * Do truncation, and the WAL logging of the truncation, in a critical
    3049             :      * section. That way offsets/members cannot get out of sync anymore, i.e.
    3050             :      * once consistent the newOldestMulti will always exist in members, even
    3051             :      * if we crashed in the wrong moment.
    3052             :      */
    3053           0 :     START_CRIT_SECTION();
    3054             : 
    3055             :     /*
    3056             :      * Prevent checkpoints from being scheduled concurrently. This is critical
    3057             :      * because otherwise a truncation record might not be replayed after a
    3058             :      * crash/basebackup, even though the state of the data directory would
    3059             :      * require it.
    3060             :      */
    3061             :     Assert(!MyPgXact->delayChkpt);
    3062           0 :     MyPgXact->delayChkpt = true;
    3063             : 
    3064             :     /* WAL log truncation */
    3065           0 :     WriteMTruncateXlogRec(newOldestMultiDB,
    3066             :                           oldestMulti, newOldestMulti,
    3067             :                           oldestOffset, newOldestOffset);
    3068             : 
    3069             :     /*
    3070             :      * Update in-memory limits before performing the truncation, while inside
    3071             :      * the critical section: Have to do it before truncation, to prevent
    3072             :      * concurrent lookups of those values. Has to be inside the critical
    3073             :      * section as otherwise a future call to this function would error out,
    3074             :      * while looking up the oldest member in offsets, if our caller crashes
    3075             :      * before updating the limits.
    3076             :      */
    3077           0 :     LWLockAcquire(MultiXactGenLock, LW_EXCLUSIVE);
    3078           0 :     MultiXactState->oldestMultiXactId = newOldestMulti;
    3079           0 :     MultiXactState->oldestMultiXactDB = newOldestMultiDB;
    3080           0 :     LWLockRelease(MultiXactGenLock);
    3081             : 
    3082             :     /* First truncate members */
    3083           0 :     PerformMembersTruncation(oldestOffset, newOldestOffset);
    3084             : 
    3085             :     /* Then offsets */
    3086           0 :     PerformOffsetsTruncation(oldestMulti, newOldestMulti);
    3087             : 
    3088           0 :     MyPgXact->delayChkpt = false;
    3089             : 
    3090           0 :     END_CRIT_SECTION();
    3091           0 :     LWLockRelease(MultiXactTruncationLock);
    3092             : }
    3093             : 
    3094             : /*
    3095             :  * Decide which of two MultiXactOffset page numbers is "older" for truncation
    3096             :  * purposes.
    3097             :  *
    3098             :  * We need to use comparison of MultiXactId here in order to do the right
    3099             :  * thing with wraparound.  However, if we are asked about page number zero, we
    3100             :  * don't want to hand InvalidMultiXactId to MultiXactIdPrecedes: it'll get
    3101             :  * weird.  So, offset both multis by FirstMultiXactId to avoid that.
    3102             :  * (Actually, the current implementation doesn't do anything weird with
    3103             :  * InvalidMultiXactId, but there's no harm in leaving this code like this.)
    3104             :  */
    3105             : static bool
    3106           0 : MultiXactOffsetPagePrecedes(int page1, int page2)
    3107             : {
    3108             :     MultiXactId multi1;
    3109             :     MultiXactId multi2;
    3110             : 
    3111           0 :     multi1 = ((MultiXactId) page1) * MULTIXACT_OFFSETS_PER_PAGE;
    3112           0 :     multi1 += FirstMultiXactId;
    3113           0 :     multi2 = ((MultiXactId) page2) * MULTIXACT_OFFSETS_PER_PAGE;
    3114           0 :     multi2 += FirstMultiXactId;
    3115             : 
    3116           0 :     return MultiXactIdPrecedes(multi1, multi2);
    3117             : }
    3118             : 
    3119             : /*
    3120             :  * Decide which of two MultiXactMember page numbers is "older" for truncation
    3121             :  * purposes.  There is no "invalid offset number" so use the numbers verbatim.
    3122             :  */
    3123             : static bool
    3124           0 : MultiXactMemberPagePrecedes(int page1, int page2)
    3125             : {
    3126             :     MultiXactOffset offset1;
    3127             :     MultiXactOffset offset2;
    3128             : 
    3129           0 :     offset1 = ((MultiXactOffset) page1) * MULTIXACT_MEMBERS_PER_PAGE;
    3130           0 :     offset2 = ((MultiXactOffset) page2) * MULTIXACT_MEMBERS_PER_PAGE;
    3131             : 
    3132           0 :     return MultiXactOffsetPrecedes(offset1, offset2);
    3133             : }
    3134             : 
    3135             : /*
    3136             :  * Decide which of two MultiXactIds is earlier.
    3137             :  *
    3138             :  * XXX do we need to do something special for InvalidMultiXactId?
    3139             :  * (Doesn't look like it.)
    3140             :  */
    3141             : bool
    3142      974558 : MultiXactIdPrecedes(MultiXactId multi1, MultiXactId multi2)
    3143             : {
    3144      974558 :     int32       diff = (int32) (multi1 - multi2);
    3145             : 
    3146      974558 :     return (diff < 0);
    3147             : }
    3148             : 
    3149             : /*
    3150             :  * MultiXactIdPrecedesOrEquals -- is multi1 logically <= multi2?
    3151             :  *
    3152             :  * XXX do we need to do something special for InvalidMultiXactId?
    3153             :  * (Doesn't look like it.)
    3154             :  */
    3155             : bool
    3156       40504 : MultiXactIdPrecedesOrEquals(MultiXactId multi1, MultiXactId multi2)
    3157             : {
    3158       40504 :     int32       diff = (int32) (multi1 - multi2);
    3159             : 
    3160       40504 :     return (diff <= 0);
    3161             : }
    3162             : 
    3163             : 
    3164             : /*
    3165             :  * Decide which of two offsets is earlier.
    3166             :  */
    3167             : static bool
    3168         128 : MultiXactOffsetPrecedes(MultiXactOffset offset1, MultiXactOffset offset2)
    3169             : {
    3170         128 :     int32       diff = (int32) (offset1 - offset2);
    3171             : 
    3172         128 :     return (diff < 0);
    3173             : }
    3174             : 
    3175             : /*
    3176             :  * Write an xlog record reflecting the zeroing of either a MEMBERs or
    3177             :  * OFFSETs page (info shows which)
    3178             :  */
    3179             : static void
    3180          24 : WriteMZeroPageXlogRec(int pageno, uint8 info)
    3181             : {
    3182          24 :     XLogBeginInsert();
    3183          24 :     XLogRegisterData((char *) (&pageno), sizeof(int));
    3184          24 :     (void) XLogInsert(RM_MULTIXACT_ID, info);
    3185          24 : }
    3186             : 
    3187             : /*
    3188             :  * Write a TRUNCATE xlog record
    3189             :  *
    3190             :  * We must flush the xlog record to disk before returning --- see notes in
    3191             :  * TruncateCLOG().
    3192             :  */
    3193             : static void
    3194           0 : WriteMTruncateXlogRec(Oid oldestMultiDB,
    3195             :                       MultiXactId startTruncOff, MultiXactId endTruncOff,
    3196             :                       MultiXactOffset startTruncMemb, MultiXactOffset endTruncMemb)
    3197             : {
    3198             :     XLogRecPtr  recptr;
    3199             :     xl_multixact_truncate xlrec;
    3200             : 
    3201           0 :     xlrec.oldestMultiDB = oldestMultiDB;
    3202             : 
    3203           0 :     xlrec.startTruncOff = startTruncOff;
    3204           0 :     xlrec.endTruncOff = endTruncOff;
    3205             : 
    3206           0 :     xlrec.startTruncMemb = startTruncMemb;
    3207           0 :     xlrec.endTruncMemb = endTruncMemb;
    3208             : 
    3209           0 :     XLogBeginInsert();
    3210           0 :     XLogRegisterData((char *) (&xlrec), SizeOfMultiXactTruncate);
    3211           0 :     recptr = XLogInsert(RM_MULTIXACT_ID, XLOG_MULTIXACT_TRUNCATE_ID);
    3212           0 :     XLogFlush(recptr);
    3213           0 : }
    3214             : 
    3215             : /*
    3216             :  * MULTIXACT resource manager's routines
    3217             :  */
    3218             : void
    3219           0 : multixact_redo(XLogReaderState *record)
    3220             : {
    3221           0 :     uint8       info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
    3222             : 
    3223             :     /* Backup blocks are not used in multixact records */
    3224             :     Assert(!XLogRecHasAnyBlockRefs(record));
    3225             : 
    3226           0 :     if (info == XLOG_MULTIXACT_ZERO_OFF_PAGE)
    3227             :     {
    3228             :         int         pageno;
    3229             :         int         slotno;
    3230             : 
    3231           0 :         memcpy(&pageno, XLogRecGetData(record), sizeof(int));
    3232             : 
    3233           0 :         LWLockAcquire(MultiXactOffsetControlLock, LW_EXCLUSIVE);
    3234             : 
    3235           0 :         slotno = ZeroMultiXactOffsetPage(pageno, false);
    3236           0 :         SimpleLruWritePage(MultiXactOffsetCtl, slotno);
    3237             :         Assert(!MultiXactOffsetCtl->shared->page_dirty[slotno]);
    3238             : 
    3239           0 :         LWLockRelease(MultiXactOffsetControlLock);
    3240             :     }
    3241           0 :     else if (info == XLOG_MULTIXACT_ZERO_MEM_PAGE)
    3242             :     {
    3243             :         int         pageno;
    3244             :         int         slotno;
    3245             : 
    3246           0 :         memcpy(&pageno, XLogRecGetData(record), sizeof(int));
    3247             : 
    3248           0 :         LWLockAcquire(MultiXactMemberControlLock, LW_EXCLUSIVE);
    3249             : 
    3250           0 :         slotno = ZeroMultiXactMemberPage(pageno, false);
    3251           0 :         SimpleLruWritePage(MultiXactMemberCtl, slotno);
    3252             :         Assert(!MultiXactMemberCtl->shared->page_dirty[slotno]);
    3253             : 
    3254           0 :         LWLockRelease(MultiXactMemberControlLock);
    3255             :     }
    3256           0 :     else if (info == XLOG_MULTIXACT_CREATE_ID)
    3257             :     {
    3258           0 :         xl_multixact_create *xlrec =
    3259             :         (xl_multixact_create *) XLogRecGetData(record);
    3260             :         TransactionId max_xid;
    3261             :         int         i;
    3262             : 
    3263             :         /* Store the data back into the SLRU files */
    3264           0 :         RecordNewMultiXact(xlrec->mid, xlrec->moff, xlrec->nmembers,
    3265           0 :                            xlrec->members);
    3266             : 
    3267             :         /* Make sure nextMXact/nextOffset are beyond what this record has */
    3268           0 :         MultiXactAdvanceNextMXact(xlrec->mid + 1,
    3269           0 :                                   xlrec->moff + xlrec->nmembers);
    3270             : 
    3271             :         /*
    3272             :          * Make sure nextFullXid is beyond any XID mentioned in the record.
    3273             :          * This should be unnecessary, since any XID found here ought to have
    3274             :          * other evidence in the XLOG, but let's be safe.
    3275             :          */
    3276           0 :         max_xid = XLogRecGetXid(record);
    3277           0 :         for (i = 0; i < xlrec->nmembers; i++)
    3278             :         {
    3279           0 :             if (TransactionIdPrecedes(max_xid, xlrec->members[i].xid))
    3280           0 :                 max_xid = xlrec->members[i].xid;
    3281             :         }
    3282             : 
    3283           0 :         AdvanceNextFullTransactionIdPastXid(max_xid);
    3284             :     }
    3285           0 :     else if (info == XLOG_MULTIXACT_TRUNCATE_ID)
    3286             :     {
    3287             :         xl_multixact_truncate xlrec;
    3288             :         int         pageno;
    3289             : 
    3290           0 :         memcpy(&xlrec, XLogRecGetData(record),
    3291             :                SizeOfMultiXactTruncate);
    3292             : 
    3293           0 :         elog(DEBUG1, "replaying multixact truncation: "
    3294             :              "offsets [%u, %u), offsets segments [%x, %x), "
    3295             :              "members [%u, %u), members segments [%x, %x)",
    3296             :              xlrec.startTruncOff, xlrec.endTruncOff,
    3297             :              MultiXactIdToOffsetSegment(xlrec.startTruncOff),
    3298             :              MultiXactIdToOffsetSegment(xlrec.endTruncOff),
    3299             :              xlrec.startTruncMemb, xlrec.endTruncMemb,
    3300             :              MXOffsetToMemberSegment(xlrec.startTruncMemb),
    3301             :              MXOffsetToMemberSegment(xlrec.endTruncMemb));
    3302             : 
    3303             :         /* should not be required, but more than cheap enough */
    3304           0 :         LWLockAcquire(MultiXactTruncationLock, LW_EXCLUSIVE);
    3305             : 
    3306             :         /*
    3307             :          * Advance the horizon values, so they're current at the end of
    3308             :          * recovery.
    3309             :          */
    3310           0 :         SetMultiXactIdLimit(xlrec.endTruncOff, xlrec.oldestMultiDB, false);
    3311             : 
    3312           0 :         PerformMembersTruncation(xlrec.startTruncMemb, xlrec.endTruncMemb);
    3313             : 
    3314             :         /*
    3315             :          * During XLOG replay, latest_page_number isn't necessarily set up
    3316             :          * yet; insert a suitable value to bypass the sanity test in
    3317             :          * SimpleLruTruncate.
    3318             :          */
    3319           0 :         pageno = MultiXactIdToOffsetPage(xlrec.endTruncOff);
    3320           0 :         MultiXactOffsetCtl->shared->latest_page_number = pageno;
    3321           0 :         PerformOffsetsTruncation(xlrec.startTruncOff, xlrec.endTruncOff);
    3322             : 
    3323           0 :         LWLockRelease(MultiXactTruncationLock);
    3324             :     }
    3325             :     else
    3326           0 :         elog(PANIC, "multixact_redo: unknown op code %u", info);
    3327           0 : }
    3328             : 
    3329             : Datum
    3330           0 : pg_get_multixact_members(PG_FUNCTION_ARGS)
    3331             : {
    3332             :     typedef struct
    3333             :     {
    3334             :         MultiXactMember *members;
    3335             :         int         nmembers;
    3336             :         int         iter;
    3337             :     } mxact;
    3338           0 :     MultiXactId mxid = PG_GETARG_UINT32(0);
    3339             :     mxact      *multi;
    3340             :     FuncCallContext *funccxt;
    3341             : 
    3342           0 :     if (mxid < FirstMultiXactId)
    3343           0 :         ereport(ERROR,
    3344             :                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
    3345             :                  errmsg("invalid MultiXactId: %u", mxid)));
    3346             : 
    3347           0 :     if (SRF_IS_FIRSTCALL())
    3348             :     {
    3349             :         MemoryContext oldcxt;
    3350             :         TupleDesc   tupdesc;
    3351             : 
    3352           0 :         funccxt = SRF_FIRSTCALL_INIT();
    3353           0 :         oldcxt = MemoryContextSwitchTo(funccxt->multi_call_memory_ctx);
    3354             : 
    3355           0 :         multi = palloc(sizeof(mxact));
    3356             :         /* no need to allow for old values here */
    3357           0 :         multi->nmembers = GetMultiXactIdMembers(mxid, &multi->members, false,
    3358             :                                                 false);
    3359           0 :         multi->iter = 0;
    3360             : 
    3361           0 :         tupdesc = CreateTemplateTupleDesc(2);
    3362           0 :         TupleDescInitEntry(tupdesc, (AttrNumber) 1, "xid",
    3363             :                            XIDOID, -1, 0);
    3364           0 :         TupleDescInitEntry(tupdesc, (AttrNumber) 2, "mode",
    3365             :                            TEXTOID, -1, 0);
    3366             : 
    3367           0 :         funccxt->attinmeta = TupleDescGetAttInMetadata(tupdesc);
    3368           0 :         funccxt->user_fctx = multi;
    3369             : 
    3370           0 :         MemoryContextSwitchTo(oldcxt);
    3371             :     }
    3372             : 
    3373           0 :     funccxt = SRF_PERCALL_SETUP();
    3374           0 :     multi = (mxact *) funccxt->user_fctx;
    3375             : 
    3376           0 :     while (multi->iter < multi->nmembers)
    3377             :     {
    3378             :         HeapTuple   tuple;
    3379             :         char       *values[2];
    3380             : 
    3381           0 :         values[0] = psprintf("%u", multi->members[multi->iter].xid);
    3382           0 :         values[1] = mxstatus_to_string(multi->members[multi->iter].status);
    3383             : 
    3384           0 :         tuple = BuildTupleFromCStrings(funccxt->attinmeta, values);
    3385             : 
    3386           0 :         multi->iter++;
    3387           0 :         pfree(values[0]);
    3388           0 :         SRF_RETURN_NEXT(funccxt, HeapTupleGetDatum(tuple));
    3389             :     }
    3390             : 
    3391           0 :     if (multi->nmembers > 0)
    3392           0 :         pfree(multi->members);
    3393           0 :     pfree(multi);
    3394             : 
    3395           0 :     SRF_RETURN_DONE(funccxt);
    3396             : }

Generated by: LCOV version 1.13