109 #define MULTIXACT_OFFSETS_PER_PAGE (BLCKSZ / sizeof(MultiXactOffset))
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)
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)
135 #define MULTIXACT_FLAGBYTES_PER_GROUP 4
136 #define MULTIXACT_MEMBERS_PER_MEMBERGROUP \
137 (MULTIXACT_FLAGBYTES_PER_GROUP * MXACT_MEMBER_FLAGS_PER_BYTE)
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)
155 #define MAX_MEMBERS_IN_LAST_MEMBERS_PAGE \
156 ((uint32) ((0xFFFFFFFF % MULTIXACT_MEMBERS_PER_PAGE) + 1))
159 #define MXOffsetToMemberPage(xid) ((xid) / (TransactionId) MULTIXACT_MEMBERS_PER_PAGE)
160 #define MXOffsetToMemberSegment(xid) (MXOffsetToMemberPage(xid) / SLRU_PAGES_PER_SEGMENT)
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)
172 #define MXOffsetToMemberOffset(xid) \
173 (MXOffsetToFlagsOffset(xid) + MULTIXACT_FLAGBYTES_PER_GROUP + \
174 ((xid) % MULTIXACT_MEMBERS_PER_MEMBERGROUP) * sizeof(TransactionId))
177 #define MULTIXACT_MEMBER_SAFE_THRESHOLD (MaxMultiXactOffset / 2)
178 #define MULTIXACT_MEMBER_DANGER_THRESHOLD \
179 (MaxMultiXactOffset - MaxMultiXactOffset / 4)
181 #define PreviousMultiXactId(xid) \
182 ((xid) == FirstMultiXactId ? MaxMultiXactId : (xid) - 1)
190 #define MultiXactOffsetCtl (&MultiXactOffsetCtlData)
191 #define MultiXactMemberCtl (&MultiXactMemberCtlData)
290 #define MaxOldestSlot (MaxBackends + max_prepared_xacts)
323 #define MAX_CACHE_ENTRIES 256
327 #ifdef MULTIXACT_DEBUG
328 #define debug_elog2(a,b) elog(a,b)
329 #define debug_elog3(a,b,c) elog(a,b,c)
330 #define debug_elog4(a,b,c,d) elog(a,b,c,d)
331 #define debug_elog5(a,b,c,d,e) elog(a,b,c,d,e)
332 #define debug_elog6(a,b,c,d,e,f) elog(a,b,c,d,e,f)
334 #define debug_elog2(a,b)
335 #define debug_elog3(a,b,c)
336 #define debug_elog4(a,b,c,d)
337 #define debug_elog5(a,b,c,d,e)
338 #define debug_elog6(a,b,c,d,e,f)
407 members[0].
xid = xid1;
408 members[0].
status = status1;
409 members[1].
xid = xid2;
410 members[1].
status = status2;
489 for (
i = 0;
i < nmembers;
i++)
492 (members[
i].status == status))
517 for (
i = 0,
j = 0;
i < nmembers;
i++)
528 newMembers[
j].
xid = xid;
529 newMembers[
j++].
status = status;
579 for (
i = 0;
i < nmembers;
i++)
594 for (
i = 0;
i < nmembers;
i++)
707 oldestMXact = thisoldest;
797 bool has_update =
false;
799 for (
i = 0;
i < nmembers;
i++)
804 elog(
ERROR,
"new multixact has more than one updating member: %s",
901 for (
i = 0;
i < nmembers;
i++, offset++)
917 if (pageno != prev_pageno)
920 prev_pageno = pageno;
926 *memberptr = members[
i].
xid;
931 flagsval = *flagsptr;
933 flagsval |= (members[
i].
status << bshift);
934 *flagsptr = flagsval;
967 elog(
ERROR,
"cannot assign MultiXactIds during recovery");
1022 (
errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
1023 errmsg(
"database is not accepting commands that generate new MultiXactIds to avoid wraparound data loss in database \"%s\"",
1025 errhint(
"Execute a database-wide VACUUM in that database.\n"
1026 "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
1029 (
errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
1030 errmsg(
"database is not accepting commands that generate new MultiXactIds to avoid wraparound data loss in database with OID %u",
1032 errhint(
"Execute a database-wide VACUUM in that database.\n"
1033 "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
1051 (
errmsg_plural(
"database \"%s\" must be vacuumed before %u more MultiXactId is used",
1052 "database \"%s\" must be vacuumed before %u more MultiXactIds are used",
1053 multiWrapLimit - result,
1055 multiWrapLimit - result),
1056 errhint(
"Execute a database-wide VACUUM in that database.\n"
1057 "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
1060 (
errmsg_plural(
"database with OID %u must be vacuumed before %u more MultiXactId is used",
1061 "database with OID %u must be vacuumed before %u more MultiXactIds are used",
1062 multiWrapLimit - result,
1064 multiWrapLimit - result),
1065 errhint(
"Execute a database-wide VACUUM in that database.\n"
1066 "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
1085 if (nextOffset == 0)
1091 *offset = nextOffset;
1111 #define OFFSET_WARN_SEGMENTS 20
1120 (
errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
1121 errmsg(
"multixact \"members\" limit exceeded"),
1122 errdetail_plural(
"This command would create a multixact with %u members, but the remaining space is only enough for %u member.",
1123 "This command would create a multixact with %u members, but the remaining space is only enough for %u members.",
1127 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.",
1157 (
errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
1158 errmsg_plural(
"database with OID %u must be vacuumed before %d more multixact member is used",
1159 "database with OID %u must be vacuumed before %d more multixact members are used",
1163 errhint(
"Execute a database-wide VACUUM in that database with reduced vacuum_multixact_freeze_min_age and vacuum_multixact_freeze_table_age settings.")));
1226 bool from_pgupgrade,
bool isLockOnly)
1301 (
errcode(ERRCODE_INTERNAL_ERROR),
1302 errmsg(
"MultiXactId %u does no longer exist -- apparent wraparound",
1307 (
errcode(ERRCODE_INTERNAL_ERROR),
1308 errmsg(
"MultiXactId %u has not been created yet -- apparent wraparound",
1361 tmpMXact = multi + 1;
1363 if (nextMXact == tmpMXact)
1366 length = nextOffset - offset;
1376 prev_pageno = pageno;
1381 if (pageno != prev_pageno)
1386 nextMXOffset = *offptr;
1388 if (nextMXOffset == 0)
1397 length = nextMXOffset - offset;
1409 for (
i = 0;
i < length;
i++, offset++)
1420 if (pageno != prev_pageno)
1423 prev_pageno = pageno;
1440 ptr[truelength].
xid = *xactptr;
1474 if (member1.
xid > member2.
xid)
1476 if (member1.
xid < member2.
xid)
1525 return entry->
multi;
1553 if (entry->
multi == multi)
1561 memcpy(ptr, entry->
members, size);
1601 "MultiXact cache context",
1610 entry->
multi = multi;
1643 return "fornokeyupd";
1651 elog(
ERROR,
"unrecognized multixact status %d", status);
1659 static char *
str = NULL;
1671 for (
i = 1;
i < nmembers;
i++)
1832 #define SHARED_MULTIXACT_STATE_SIZE \
1833 add_size(offsetof(MultiXactStateData, perBackendXactIds) + sizeof(MultiXactId), \
1834 mul_size(sizeof(MultiXactId) * 2, MaxOldestSlot))
1855 MultiXactOffsetSLRULock,
"pg_multixact/offsets",
1861 MultiXactMemberSLRULock,
"pg_multixact/members",
2107 MemSet(xidptr, 0, BLCKSZ - memberoff);
2147 "MultiXact: checkpoint is nextMulti %u, nextOffset %u, oldestMulti %u in DB %u",
2148 *nextMulti, *nextMultiOffset, *oldestMulti, *oldestMultiDB);
2157 TRACE_POSTGRESQL_MULTIXACT_CHECKPOINT_START(
true);
2167 TRACE_POSTGRESQL_MULTIXACT_CHECKPOINT_DONE(
true);
2183 nextMulti, nextMultiOffset);
2221 bool needs_offset_vacuum;
2240 multiStopLimit = multiWrapLimit - 3000000;
2254 multiWarnLimit = multiWrapLimit - 40000000;
2283 (
errmsg_internal(
"MultiXactId wrap limit is %u, limited by database with OID %u",
2284 multiWrapLimit, oldest_datoid)));
2315 char *oldest_datname;
2329 oldest_datname = NULL;
2333 (
errmsg_plural(
"database \"%s\" must be vacuumed before %u more MultiXactId is used",
2334 "database \"%s\" must be vacuumed before %u more MultiXactIds are used",
2335 multiWrapLimit - curMulti,
2337 multiWrapLimit - curMulti),
2338 errhint(
"To avoid a database shutdown, execute a database-wide VACUUM in that database.\n"
2339 "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
2342 (
errmsg_plural(
"database with OID %u must be vacuumed before %u more MultiXactId is used",
2343 "database with OID %u must be vacuumed before %u more MultiXactIds are used",
2344 multiWrapLimit - curMulti,
2346 multiWrapLimit - curMulti),
2347 errhint(
"To avoid a database shutdown, execute a database-wide VACUUM in that database.\n"
2348 "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
2442 while (nmembers > 0)
2453 if (flagsoff == 0 && flagsbit == 0)
2528 oldestMXact = nextMXact;
2536 oldestMXact = thisoldest;
2540 oldestMXact = thisoldest;
2567 bool oldestOffsetKnown =
false;
2568 bool prevOldestOffsetKnown;
2596 if (oldestMultiXactId == nextMXact)
2602 oldestOffset = nextOffset;
2603 oldestOffsetKnown =
true;
2616 if (oldestOffsetKnown)
2622 (
errmsg(
"MultiXact member wraparound protections are disabled because oldest checkpointed MultiXact %u does not exist on disk",
2623 oldestMultiXactId)));
2633 if (oldestOffsetKnown)
2636 offsetStopLimit = oldestOffset - (oldestOffset %
2642 if (!prevOldestOffsetKnown && !is_startup)
2644 (
errmsg(
"MultiXact member wraparound protections are now enabled")));
2647 (
errmsg_internal(
"MultiXact member stop limit is now %u based on MultiXact %u",
2648 offsetStopLimit, oldestMultiXactId)));
2650 else if (prevOldestOffsetKnown)
2658 oldestOffset = prevOldestOffset;
2659 oldestOffsetKnown =
true;
2660 offsetStopLimit = prevOffsetStopLimit;
2673 return !oldestOffsetKnown ||
2696 finish = start + distance;
2719 if (start < boundary)
2720 return finish >= boundary || finish < start;
2722 return finish >= boundary && finish < start;
2779 bool oldestOffsetKnown;
2789 if (!oldestOffsetKnown)
2792 *members = nextOffset - oldestOffset;
2793 *multixacts = nextMultiXactId - oldestMultiXactId;
2829 uint32 victim_multixacts;
2847 victim_multixacts = multixacts * fraction;
2850 if (victim_multixacts > multixacts)
2852 return multixacts - victim_multixacts;
2893 int segment = startsegment;
2899 while (segment != endsegment)
2901 elog(
DEBUG2,
"truncating multixact members segment %x", segment);
2905 if (segment == maxsegment)
3019 if (oldestMulti == nextMulti)
3022 oldestOffset = nextOffset;
3027 (
errmsg(
"oldest MultiXact %u not found, earliest MultiXact %u, skipping truncation",
3028 oldestMulti, earliest)));
3037 if (newOldestMulti == nextMulti)
3040 newOldestOffset = nextOffset;
3045 (
errmsg(
"cannot truncate up to MultiXact %u because it does not exist on disk, skipping truncation",
3051 elog(
DEBUG1,
"performing multixact truncation: "
3052 "offsets [%u, %u), offsets segments [%x, %x), "
3053 "members [%u, %u), members segments [%x, %x)",
3054 oldestMulti, newOldestMulti,
3057 oldestOffset, newOldestOffset,
3080 oldestMulti, newOldestMulti,
3081 oldestOffset, newOldestOffset);
3307 elog(
DEBUG1,
"replaying multixact truncation: "
3308 "offsets [%u, %u), offsets segments [%x, %x), "
3309 "members [%u, %u), members segments [%x, %x)",
3340 elog(
PANIC,
"multixact_redo: unknown op code %u", info);
3358 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
3359 errmsg(
"invalid MultiXactId: %u", mxid)));
3369 multi =
palloc(
sizeof(mxact));
3376 elog(
ERROR,
"return type must be a row type");
3387 while (multi->iter < multi->nmembers)
int autovacuum_multixact_freeze_max_age
static Datum values[MAXATTR]
TransactionId MultiXactId
#define FLEXIBLE_ARRAY_MEMBER
#define MemSet(start, val, len)
char * get_database_name(Oid dbid)
elog(ERROR, "%s: %s", p2, msg)
int errmsg_plural(const char *fmt_singular, const char *fmt_plural, unsigned long n,...)
int errmsg_internal(const char *fmt,...)
int errdetail_plural(const char *fmt_singular, const char *fmt_plural, unsigned long n,...)
int errhint(const char *fmt,...)
int errcode(int sqlerrcode)
int errmsg(const char *fmt,...)
#define ereport(elevel,...)
HeapTuple BuildTupleFromCStrings(AttInMetadata *attinmeta, char **values)
AttInMetadata * TupleDescGetAttInMetadata(TupleDesc tupdesc)
#define PG_GETARG_TRANSACTIONID(n)
TypeFuncClass get_call_result_type(FunctionCallInfo fcinfo, Oid *resultTypeId, TupleDesc *resultTupleDesc)
#define SRF_IS_FIRSTCALL()
#define SRF_PERCALL_SETUP()
#define SRF_RETURN_NEXT(_funcctx, _result)
#define SRF_FIRSTCALL_INIT()
static Datum HeapTupleGetDatum(const HeapTupleData *tuple)
#define SRF_RETURN_DONE(_funcctx)
Datum difference(PG_FUNCTION_ARGS)
#define dclist_container(type, membername, ptr)
static dlist_node * dclist_tail_node(dclist_head *head)
static uint32 dclist_count(const dclist_head *head)
static void dclist_move_head(dclist_head *head, dlist_node *node)
static void dclist_delete_from(dclist_head *head, dlist_node *node)
#define DCLIST_STATIC_INIT(name)
static void dclist_push_head(dclist_head *head, dlist_node *node)
static void dclist_init(dclist_head *head)
#define dclist_foreach(iter, lhead)
if(TABLE==NULL||TABLE_index==NULL)
Assert(fmt[strlen(fmt) - 1] !='\n')
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
void LWLockRelease(LWLock *lock)
@ LWTRANCHE_MULTIXACTMEMBER_BUFFER
@ LWTRANCHE_MULTIXACTOFFSET_BUFFER
MemoryContext TopTransactionContext
void pfree(void *pointer)
MemoryContext TopMemoryContext
void * MemoryContextAlloc(MemoryContext context, Size size)
char * MemoryContextStrdup(MemoryContext context, const char *string)
#define AllocSetContextCreate
#define ALLOCSET_SMALL_SIZES
#define START_CRIT_SECTION()
#define CHECK_FOR_INTERRUPTS()
#define END_CRIT_SECTION()
#define MXOffsetToMemberPage(xid)
static void WriteMTruncateXlogRec(Oid oldestMultiDB, MultiXactId startTruncOff, MultiXactId endTruncOff, MultiXactOffset startTruncMemb, MultiXactOffset endTruncMemb)
static SlruCtlData MultiXactOffsetCtlData
void MultiXactShmemInit(void)
#define MULTIXACT_MEMBER_SAFE_THRESHOLD
static int ZeroMultiXactMemberPage(int pageno, bool writeXlog)
static MultiXactId GetNewMultiXactId(int nmembers, MultiXactOffset *offset)
static int ZeroMultiXactOffsetPage(int pageno, bool writeXlog)
static int mXactCacheGetById(MultiXactId multi, MultiXactMember **members)
MultiXactId MultiXactIdExpand(MultiXactId multi, TransactionId xid, MultiXactStatus status)
#define MXACT_MEMBER_BITS_PER_XACT
static void ExtendMultiXactMember(MultiXactOffset offset, int nmembers)
void ReadMultiXactIdRange(MultiXactId *oldest, MultiXactId *next)
static void PerformOffsetsTruncation(MultiXactId oldestMulti, MultiXactId newOldestMulti)
#define MXACT_MEMBER_XACT_BITMASK
#define MultiXactIdToOffsetEntry(xid)
bool MultiXactIdPrecedes(MultiXactId multi1, MultiXactId multi2)
void multixact_redo(XLogReaderState *record)
#define MULTIXACT_OFFSETS_PER_PAGE
#define debug_elog5(a, b, c, d, e)
static void MultiXactIdSetOldestVisible(void)
int multixactoffsetssyncfiletag(const FileTag *ftag, char *path)
void multixact_twophase_postcommit(TransactionId xid, uint16 info, void *recdata, uint32 len)
static bool MultiXactOffsetPagePrecedes(int page1, int page2)
static bool find_multixact_start(MultiXactId multi, MultiXactOffset *result)
void MultiXactSetNextMXact(MultiXactId nextMulti, MultiXactOffset nextMultiOffset)
void multixact_twophase_recover(TransactionId xid, uint16 info, void *recdata, uint32 len)
#define MultiXactMemberCtl
void AtPrepare_MultiXact(void)
static bool MultiXactOffsetWouldWrap(MultiXactOffset boundary, MultiXactOffset start, uint32 distance)
bool MultiXactIdPrecedesOrEquals(MultiXactId multi1, MultiXactId multi2)
#define MXOffsetToFlagsBitShift(xid)
void MultiXactAdvanceOldest(MultiXactId oldestMulti, Oid oldestMultiDB)
static bool SlruScanDirCbFindEarliest(SlruCtl ctl, char *filename, int segpage, void *data)
static void mXactCachePut(MultiXactId multi, int nmembers, MultiXactMember *members)
#define MXOffsetToFlagsOffset(xid)
static void MaybeExtendOffsetSlru(void)
bool MultiXactIdIsRunning(MultiXactId multi, bool isLockOnly)
void MultiXactIdSetOldestMember(void)
static void PerformMembersTruncation(MultiXactOffset oldestOffset, MultiXactOffset newOldestOffset)
static MemoryContext MXactContext
#define SHARED_MULTIXACT_STATE_SIZE
static MultiXactId * OldestVisibleMXactId
struct mxtruncinfo mxtruncinfo
static int mxactMemberComparator(const void *arg1, const void *arg2)
struct MultiXactStateData MultiXactStateData
static void ExtendMultiXactOffset(MultiXactId multi)
void PostPrepare_MultiXact(TransactionId xid)
Size MultiXactShmemSize(void)
#define MultiXactOffsetCtl
void multixact_twophase_postabort(TransactionId xid, uint16 info, void *recdata, uint32 len)
#define PreviousMultiXactId(xid)
void MultiXactGetCheckptMulti(bool is_shutdown, MultiXactId *nextMulti, MultiXactOffset *nextMultiOffset, MultiXactId *oldestMulti, Oid *oldestMultiDB)
void SetMultiXactIdLimit(MultiXactId oldest_datminmxid, Oid oldest_datoid, bool is_startup)
static void RecordNewMultiXact(MultiXactId multi, MultiXactOffset offset, int nmembers, MultiXactMember *members)
int multixactmemberssyncfiletag(const FileTag *ftag, char *path)
#define MAX_CACHE_ENTRIES
#define MXOffsetToMemberOffset(xid)
static void WriteMZeroPageXlogRec(int pageno, uint8 info)
MultiXactId GetOldestMultiXactId(void)
void CheckPointMultiXact(void)
MultiXactId MultiXactIdCreateFromMembers(int nmembers, MultiXactMember *members)
static bool ReadMultiXactCounts(uint32 *multixacts, MultiXactOffset *members)
struct mXactCacheEnt mXactCacheEnt
static MultiXactId mXactCacheGetBySet(int nmembers, MultiXactMember *members)
static dclist_head MXactCache
#define MXOffsetToMemberSegment(xid)
char * mxid_to_string(MultiXactId multi, int nmembers, MultiXactMember *members)
#define debug_elog3(a, b, c)
#define debug_elog4(a, b, c, d)
static bool SetOffsetVacuumLimit(bool is_startup)
int MultiXactMemberFreezeThreshold(void)
void MultiXactAdvanceNextMXact(MultiXactId minMulti, MultiXactOffset minMultiOffset)
static MultiXactId * OldestMemberMXactId
#define MAX_MEMBERS_IN_LAST_MEMBERS_PAGE
static MultiXactStateData * MultiXactState
static char * mxstatus_to_string(MultiXactStatus status)
#define OFFSET_WARN_SEGMENTS
Datum pg_get_multixact_members(PG_FUNCTION_ARGS)
MultiXactId ReadNextMultiXactId(void)
void BootStrapMultiXact(void)
#define debug_elog6(a, b, c, d, e, f)
#define MULTIXACT_MEMBERS_PER_PAGE
MultiXactId MultiXactIdCreate(TransactionId xid1, MultiXactStatus status1, TransactionId xid2, MultiXactStatus status2)
static bool MultiXactMemberPagePrecedes(int page1, int page2)
void TruncateMultiXact(MultiXactId newOldestMulti, Oid newOldestMultiDB)
#define MULTIXACT_MEMBER_DANGER_THRESHOLD
static bool MultiXactOffsetPrecedes(MultiXactOffset offset1, MultiXactOffset offset2)
#define MultiXactIdToOffsetSegment(xid)
void AtEOXact_MultiXact(void)
#define MultiXactIdToOffsetPage(xid)
static SlruCtlData MultiXactMemberCtlData
#define debug_elog2(a, b)
void StartupMultiXact(void)
int GetMultiXactIdMembers(MultiXactId multi, MultiXactMember **members, bool from_pgupgrade, bool isLockOnly)
#define MultiXactIdIsValid(multi)
#define XLOG_MULTIXACT_ZERO_MEM_PAGE
#define XLOG_MULTIXACT_ZERO_OFF_PAGE
#define NUM_MULTIXACTOFFSET_BUFFERS
@ MultiXactStatusForShare
@ MultiXactStatusForNoKeyUpdate
@ MultiXactStatusNoKeyUpdate
@ MultiXactStatusForUpdate
@ MultiXactStatusForKeyShare
#define ISUPDATE_from_mxstatus(status)
#define InvalidMultiXactId
#define XLOG_MULTIXACT_TRUNCATE_ID
#define SizeOfMultiXactCreate
#define SizeOfMultiXactTruncate
#define XLOG_MULTIXACT_CREATE_ID
#define MaxMultiXactOffset
#define NUM_MULTIXACTMEMBER_BUFFERS
struct MultiXactMember MultiXactMember
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
void SendPostmasterSignal(PMSignalReason reason)
@ PMSIGNAL_START_AUTOVAC_LAUNCHER
#define qsort(a, b, c, d)
#define DELAY_CHKPT_START
bool TransactionIdIsInProgress(TransactionId xid)
char * psprintf(const char *fmt,...)
Size add_size(Size s1, Size s2)
void * ShmemInitStruct(const char *name, Size size, bool *foundPtr)
void pg_usleep(long microsec)
void SimpleLruWritePage(SlruCtl ctl, int slotno)
void SimpleLruWriteAll(SlruCtl ctl, bool allow_redirtied)
void SimpleLruInit(SlruCtl ctl, const char *name, int nslots, int nlsns, LWLock *ctllock, const char *subdir, int tranche_id, SyncRequestHandler sync_handler)
void SimpleLruTruncate(SlruCtl ctl, int cutoffPage)
bool SlruScanDirectory(SlruCtl ctl, SlruScanCallback callback, void *data)
int SlruSyncFileTag(SlruCtl ctl, const FileTag *ftag, char *path)
int SimpleLruZeroPage(SlruCtl ctl, int pageno)
void SlruDeleteSegment(SlruCtl ctl, int segno)
int SimpleLruReadPage_ReadOnly(SlruCtl ctl, int pageno, TransactionId xid)
bool SimpleLruDoesPhysicalPageExist(SlruCtl ctl, int pageno)
int SimpleLruReadPage(SlruCtl ctl, int pageno, bool write_ok, TransactionId xid)
Size SimpleLruShmemSize(int nslots, int nlsns)
#define SlruPagePrecedesUnitTests(ctl, per_page)
#define SLRU_PAGES_PER_SEGMENT
void appendStringInfo(StringInfo str, const char *fmt,...)
void appendStringInfoChar(StringInfo str, char ch)
void initStringInfo(StringInfo str)
AttInMetadata * attinmeta
MemoryContext multi_call_memory_ctx
MultiXactId multiWrapLimit
MultiXactId multiStopLimit
MultiXactId multiWarnLimit
MultiXactId multiVacLimit
MultiXactOffset offsetStopLimit
MultiXactOffset nextOffset
MultiXactId oldestMultiXactId
MultiXactId perBackendXactIds[FLEXIBLE_ARRAY_MEMBER]
MultiXactOffset oldestOffset
bool(* PagePrecedes)(int, int)
MultiXactMember members[FLEXIBLE_ARRAY_MEMBER]
MultiXactMember members[FLEXIBLE_ARRAY_MEMBER]
MultiXactOffset startTruncMemb
MultiXactOffset endTruncMemb
MultiXactId startTruncOff
@ SYNC_HANDLER_MULTIXACT_MEMBER
@ SYNC_HANDLER_MULTIXACT_OFFSET
bool TransactionIdDidCommit(TransactionId transactionId)
bool TransactionIdPrecedes(TransactionId id1, TransactionId id2)
#define TransactionIdEquals(id1, id2)
#define TransactionIdIsValid(xid)
void RegisterTwoPhaseRecord(TwoPhaseRmgrId rmid, uint16 info, const void *data, uint32 len)
BackendId TwoPhaseGetDummyBackendId(TransactionId xid, bool lock_held)
#define TWOPHASE_RM_MULTIXACT_ID
void AdvanceNextFullTransactionIdPastXid(TransactionId xid)
bool IsTransactionState(void)
bool TransactionIdIsCurrentTransactionId(TransactionId xid)
bool RecoveryInProgress(void)
void XLogFlush(XLogRecPtr record)
void XLogRegisterData(char *data, uint32 len)
XLogRecPtr XLogInsert(RmgrId rmid, uint8 info)
void XLogBeginInsert(void)
#define XLogRecGetInfo(decoder)
#define XLogRecGetData(decoder)
#define XLogRecGetXid(decoder)
#define XLogRecHasAnyBlockRefs(decoder)