89 #include "utils/fmgrprotos.h"
108 #define MULTIXACT_OFFSETS_PER_PAGE (BLCKSZ / sizeof(MultiXactOffset))
110 #define MultiXactIdToOffsetPage(xid) \
111 ((xid) / (MultiXactOffset) MULTIXACT_OFFSETS_PER_PAGE)
112 #define MultiXactIdToOffsetEntry(xid) \
113 ((xid) % (MultiXactOffset) MULTIXACT_OFFSETS_PER_PAGE)
114 #define MultiXactIdToOffsetSegment(xid) (MultiXactIdToOffsetPage(xid) / SLRU_PAGES_PER_SEGMENT)
129 #define MXACT_MEMBER_BITS_PER_XACT 8
130 #define MXACT_MEMBER_FLAGS_PER_BYTE 1
131 #define MXACT_MEMBER_XACT_BITMASK ((1 << MXACT_MEMBER_BITS_PER_XACT) - 1)
134 #define MULTIXACT_FLAGBYTES_PER_GROUP 4
135 #define MULTIXACT_MEMBERS_PER_MEMBERGROUP \
136 (MULTIXACT_FLAGBYTES_PER_GROUP * MXACT_MEMBER_FLAGS_PER_BYTE)
138 #define MULTIXACT_MEMBERGROUP_SIZE \
139 (sizeof(TransactionId) * MULTIXACT_MEMBERS_PER_MEMBERGROUP + MULTIXACT_FLAGBYTES_PER_GROUP)
140 #define MULTIXACT_MEMBERGROUPS_PER_PAGE (BLCKSZ / MULTIXACT_MEMBERGROUP_SIZE)
141 #define MULTIXACT_MEMBERS_PER_PAGE \
142 (MULTIXACT_MEMBERGROUPS_PER_PAGE * MULTIXACT_MEMBERS_PER_MEMBERGROUP)
154 #define MAX_MEMBERS_IN_LAST_MEMBERS_PAGE \
155 ((uint32) ((0xFFFFFFFF % MULTIXACT_MEMBERS_PER_PAGE) + 1))
158 #define MXOffsetToMemberPage(xid) ((xid) / (TransactionId) MULTIXACT_MEMBERS_PER_PAGE)
159 #define MXOffsetToMemberSegment(xid) (MXOffsetToMemberPage(xid) / SLRU_PAGES_PER_SEGMENT)
162 #define MXOffsetToFlagsOffset(xid) \
163 ((((xid) / (TransactionId) MULTIXACT_MEMBERS_PER_MEMBERGROUP) % \
164 (TransactionId) MULTIXACT_MEMBERGROUPS_PER_PAGE) * \
165 (TransactionId) MULTIXACT_MEMBERGROUP_SIZE)
166 #define MXOffsetToFlagsBitShift(xid) \
167 (((xid) % (TransactionId) MULTIXACT_MEMBERS_PER_MEMBERGROUP) * \
168 MXACT_MEMBER_BITS_PER_XACT)
171 #define MXOffsetToMemberOffset(xid) \
172 (MXOffsetToFlagsOffset(xid) + MULTIXACT_FLAGBYTES_PER_GROUP + \
173 ((xid) % MULTIXACT_MEMBERS_PER_MEMBERGROUP) * sizeof(TransactionId))
176 #define MULTIXACT_MEMBER_SAFE_THRESHOLD (MaxMultiXactOffset / 2)
177 #define MULTIXACT_MEMBER_DANGER_THRESHOLD \
178 (MaxMultiXactOffset - MaxMultiXactOffset / 4)
180 #define PreviousMultiXactId(xid) \
181 ((xid) == FirstMultiXactId ? MaxMultiXactId : (xid) - 1)
189 #define MultiXactOffsetCtl (&MultiXactOffsetCtlData)
190 #define MultiXactMemberCtl (&MultiXactMemberCtlData)
288 #define MaxOldestSlot (MaxBackends + max_prepared_xacts)
321 #define MAX_CACHE_ENTRIES 256
325 #ifdef MULTIXACT_DEBUG
326 #define debug_elog2(a,b) elog(a,b)
327 #define debug_elog3(a,b,c) elog(a,b,c)
328 #define debug_elog4(a,b,c,d) elog(a,b,c,d)
329 #define debug_elog5(a,b,c,d,e) elog(a,b,c,d,e)
330 #define debug_elog6(a,b,c,d,e,f) elog(a,b,c,d,e,f)
332 #define debug_elog2(a,b)
333 #define debug_elog3(a,b,c)
334 #define debug_elog4(a,b,c,d)
335 #define debug_elog5(a,b,c,d,e)
336 #define debug_elog6(a,b,c,d,e,f)
405 members[0].
xid = xid1;
406 members[0].
status = status1;
407 members[1].
xid = xid2;
408 members[1].
status = status2;
487 for (
i = 0;
i < nmembers;
i++)
490 (members[
i].status == status))
515 for (
i = 0,
j = 0;
i < nmembers;
i++)
526 newMembers[
j].
xid = xid;
527 newMembers[
j++].
status = status;
577 for (
i = 0;
i < nmembers;
i++)
592 for (
i = 0;
i < nmembers;
i++)
705 oldestMXact = thisoldest;
795 bool has_update =
false;
797 for (
i = 0;
i < nmembers;
i++)
802 elog(
ERROR,
"new multixact has more than one updating member: %s",
900 for (
i = 0;
i < nmembers;
i++, offset++)
916 if (pageno != prev_pageno)
924 if (lock != prevlock)
926 if (prevlock != NULL)
933 prev_pageno = pageno;
939 *memberptr = members[
i].
xid;
944 flagsval = *flagsptr;
946 flagsval |= (members[
i].
status << bshift);
947 *flagsptr = flagsval;
952 if (prevlock != NULL)
981 elog(
ERROR,
"cannot assign MultiXactIds during recovery");
1036 (
errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
1037 errmsg(
"database is not accepting commands that assign new MultiXactIds to avoid wraparound data loss in database \"%s\"",
1039 errhint(
"Execute a database-wide VACUUM in that database.\n"
1040 "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
1043 (
errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
1044 errmsg(
"database is not accepting commands that assign new MultiXactIds to avoid wraparound data loss in database with OID %u",
1046 errhint(
"Execute a database-wide VACUUM in that database.\n"
1047 "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
1065 (
errmsg_plural(
"database \"%s\" must be vacuumed before %u more MultiXactId is used",
1066 "database \"%s\" must be vacuumed before %u more MultiXactIds are used",
1067 multiWrapLimit - result,
1069 multiWrapLimit - result),
1070 errhint(
"Execute a database-wide VACUUM in that database.\n"
1071 "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
1074 (
errmsg_plural(
"database with OID %u must be vacuumed before %u more MultiXactId is used",
1075 "database with OID %u must be vacuumed before %u more MultiXactIds are used",
1076 multiWrapLimit - result,
1078 multiWrapLimit - result),
1079 errhint(
"Execute a database-wide VACUUM in that database.\n"
1080 "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
1099 if (nextOffset == 0)
1105 *offset = nextOffset;
1125 #define OFFSET_WARN_SEGMENTS 20
1134 (
errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
1135 errmsg(
"multixact \"members\" limit exceeded"),
1136 errdetail_plural(
"This command would create a multixact with %u members, but the remaining space is only enough for %u member.",
1137 "This command would create a multixact with %u members, but the remaining space is only enough for %u members.",
1141 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.",
1171 (
errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
1172 errmsg_plural(
"database with OID %u must be vacuumed before %d more multixact member is used",
1173 "database with OID %u must be vacuumed before %d more multixact members are used",
1177 errhint(
"Execute a database-wide VACUUM in that database with reduced vacuum_multixact_freeze_min_age and vacuum_multixact_freeze_table_age settings.")));
1240 bool from_pgupgrade,
bool isLockOnly)
1315 (
errcode(ERRCODE_INTERNAL_ERROR),
1316 errmsg(
"MultiXactId %u does no longer exist -- apparent wraparound",
1321 (
errcode(ERRCODE_INTERNAL_ERROR),
1322 errmsg(
"MultiXactId %u has not been created yet -- apparent wraparound",
1377 tmpMXact = multi + 1;
1379 if (nextMXact == tmpMXact)
1382 length = nextOffset - offset;
1392 prev_pageno = pageno;
1397 if (pageno != prev_pageno)
1407 if (newlock != lock)
1418 nextMXOffset = *offptr;
1420 if (nextMXOffset == 0)
1429 length = nextMXOffset - offset;
1439 for (
int i = 0;
i < length;
i++, offset++)
1450 if (pageno != prev_pageno)
1460 if (newlock != lock)
1469 prev_pageno = pageno;
1486 ptr[truelength].
xid = *xactptr;
1520 if (member1.
xid > member2.
xid)
1522 if (member1.
xid < member2.
xid)
1571 return entry->
multi;
1599 if (entry->
multi == multi)
1647 "MultiXact cache context",
1656 entry->
multi = multi;
1689 return "fornokeyupd";
1697 elog(
ERROR,
"unrecognized multixact status %d", status);
1705 static char *
str = NULL;
1717 for (
i = 1;
i < nmembers;
i++)
1878 #define SHARED_MULTIXACT_STATE_SIZE \
1879 add_size(offsetof(MultiXactStateData, perBackendXactIds), \
1880 mul_size(sizeof(MultiXactId) * 2, MaxOldestSlot))
2182 MemSet(xidptr, 0, BLCKSZ - memberoff);
2221 "MultiXact: checkpoint is nextMulti %u, nextOffset %u, oldestMulti %u in DB %u",
2222 *nextMulti, *nextMultiOffset, *oldestMulti, *oldestMultiDB);
2231 TRACE_POSTGRESQL_MULTIXACT_CHECKPOINT_START(
true);
2241 TRACE_POSTGRESQL_MULTIXACT_CHECKPOINT_DONE(
true);
2257 nextMulti, nextMultiOffset);
2295 bool needs_offset_vacuum;
2314 multiStopLimit = multiWrapLimit - 3000000;
2328 multiWarnLimit = multiWrapLimit - 40000000;
2357 (
errmsg_internal(
"MultiXactId wrap limit is %u, limited by database with OID %u",
2358 multiWrapLimit, oldest_datoid)));
2389 char *oldest_datname;
2403 oldest_datname = NULL;
2407 (
errmsg_plural(
"database \"%s\" must be vacuumed before %u more MultiXactId is used",
2408 "database \"%s\" must be vacuumed before %u more MultiXactIds are used",
2409 multiWrapLimit - curMulti,
2411 multiWrapLimit - curMulti),
2412 errhint(
"To avoid MultiXactId assignment failures, execute a database-wide VACUUM in that database.\n"
2413 "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
2416 (
errmsg_plural(
"database with OID %u must be vacuumed before %u more MultiXactId is used",
2417 "database with OID %u must be vacuumed before %u more MultiXactIds are used",
2418 multiWrapLimit - curMulti,
2420 multiWrapLimit - curMulti),
2421 errhint(
"To avoid MultiXactId assignment failures, execute a database-wide VACUUM in that database.\n"
2422 "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
2518 while (nmembers > 0)
2529 if (flagsoff == 0 && flagsbit == 0)
2606 oldestMXact = nextMXact;
2614 oldestMXact = thisoldest;
2618 oldestMXact = thisoldest;
2645 bool oldestOffsetKnown =
false;
2646 bool prevOldestOffsetKnown;
2674 if (oldestMultiXactId == nextMXact)
2680 oldestOffset = nextOffset;
2681 oldestOffsetKnown =
true;
2694 if (oldestOffsetKnown)
2700 (
errmsg(
"MultiXact member wraparound protections are disabled because oldest checkpointed MultiXact %u does not exist on disk",
2701 oldestMultiXactId)));
2711 if (oldestOffsetKnown)
2714 offsetStopLimit = oldestOffset - (oldestOffset %
2720 if (!prevOldestOffsetKnown && !is_startup)
2722 (
errmsg(
"MultiXact member wraparound protections are now enabled")));
2725 (
errmsg_internal(
"MultiXact member stop limit is now %u based on MultiXact %u",
2726 offsetStopLimit, oldestMultiXactId)));
2728 else if (prevOldestOffsetKnown)
2736 oldestOffset = prevOldestOffset;
2737 oldestOffsetKnown =
true;
2738 offsetStopLimit = prevOffsetStopLimit;
2751 return !oldestOffsetKnown ||
2774 finish = start + distance;
2797 if (start < boundary)
2798 return finish >= boundary || finish < start;
2800 return finish >= boundary && finish < start;
2857 bool oldestOffsetKnown;
2867 if (!oldestOffsetKnown)
2870 *members = nextOffset - oldestOffset;
2871 *multixacts = nextMultiXactId - oldestMultiXactId;
2907 uint32 victim_multixacts;
2925 victim_multixacts = multixacts * fraction;
2928 if (victim_multixacts > multixacts)
2930 return multixacts - victim_multixacts;
2971 int segment = startsegment;
2977 while (segment != endsegment)
2979 elog(
DEBUG2,
"truncating multixact members segment %x", segment);
2983 if (segment == maxsegment)
3097 if (oldestMulti == nextMulti)
3100 oldestOffset = nextOffset;
3105 (
errmsg(
"oldest MultiXact %u not found, earliest MultiXact %u, skipping truncation",
3106 oldestMulti, earliest)));
3115 if (newOldestMulti == nextMulti)
3118 newOldestOffset = nextOffset;
3123 (
errmsg(
"cannot truncate up to MultiXact %u because it does not exist on disk, skipping truncation",
3129 elog(
DEBUG1,
"performing multixact truncation: "
3130 "offsets [%u, %u), offsets segments [%x, %x), "
3131 "members [%u, %u), members segments [%x, %x)",
3132 oldestMulti, newOldestMulti,
3135 oldestOffset, newOldestOffset,
3158 oldestMulti, newOldestMulti,
3159 oldestOffset, newOldestOffset);
3389 elog(
DEBUG1,
"replaying multixact truncation: "
3390 "offsets [%u, %u), offsets segments [%x, %x), "
3391 "members [%u, %u), members segments [%x, %x)",
3423 elog(
PANIC,
"multixact_redo: unknown op code %u", info);
3441 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
3442 errmsg(
"invalid MultiXactId: %u", mxid)));
3452 multi =
palloc(
sizeof(mxact));
3459 elog(
ERROR,
"return type must be a row type");
3470 while (multi->iter < multi->nmembers)
static void pg_atomic_write_u64(volatile pg_atomic_uint64 *ptr, uint64 val)
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)
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)
int multixact_offset_buffers
int multixact_member_buffers
#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_MULTIXACTOFFSET_SLRU
@ LWTRANCHE_MULTIXACTMEMBER_SLRU
@ 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 bool MultiXactMemberPagePrecedes(int64 page1, int64 page2)
static MultiXactId GetNewMultiXactId(int nmembers, MultiXactOffset *offset)
static int mXactCacheGetById(MultiXactId multi, MultiXactMember **members)
MultiXactId MultiXactIdExpand(MultiXactId multi, TransactionId xid, MultiXactStatus status)
static int ZeroMultiXactMemberPage(int64 pageno, bool writeXlog)
#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 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
static bool SlruScanDirCbFindEarliest(SlruCtl ctl, char *filename, int64 segpage, void *data)
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 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)
static void WriteMZeroPageXlogRec(int64 pageno, uint8 info)
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)
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 MultiXactOffsetPagePrecedes(int64 page1, int64 page2)
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 int ZeroMultiXactOffsetPage(int64 pageno, bool writeXlog)
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)
void TruncateMultiXact(MultiXactId newOldestMulti, Oid newOldestMultiDB)
#define MULTIXACT_MEMBER_DANGER_THRESHOLD
bool check_multixact_offset_buffers(int *newval, void **extra, GucSource source)
static bool MultiXactOffsetPrecedes(MultiXactOffset offset1, MultiXactOffset offset2)
#define MultiXactIdToOffsetSegment(xid)
bool check_multixact_member_buffers(int *newval, void **extra, GucSource source)
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
@ 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
struct MultiXactMember MultiXactMember
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
static rewind_source * source
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)
static pg_noinline void Size size
void SimpleLruInit(SlruCtl ctl, const char *name, int nslots, int nlsns, const char *subdir, int buffer_tranche_id, int bank_tranche_id, SyncRequestHandler sync_handler, bool long_segment_names)
int SimpleLruReadPage_ReadOnly(SlruCtl ctl, int64 pageno, TransactionId xid)
void SimpleLruWritePage(SlruCtl ctl, int slotno)
void SimpleLruWriteAll(SlruCtl ctl, bool allow_redirtied)
bool SimpleLruDoesPhysicalPageExist(SlruCtl ctl, int64 pageno)
void SlruDeleteSegment(SlruCtl ctl, int64 segno)
bool SlruScanDirectory(SlruCtl ctl, SlruScanCallback callback, void *data)
int SimpleLruReadPage(SlruCtl ctl, int64 pageno, bool write_ok, TransactionId xid)
int SlruSyncFileTag(SlruCtl ctl, const FileTag *ftag, char *path)
int SimpleLruZeroPage(SlruCtl ctl, int64 pageno)
void SimpleLruTruncate(SlruCtl ctl, int64 cutoffPage)
Size SimpleLruShmemSize(int nslots, int nlsns)
bool check_slru_buffers(const char *name, int *newval)
static LWLock * SimpleLruGetBankLock(SlruCtl ctl, int64 pageno)
#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)(int64, int64)
MultiXactMember members[FLEXIBLE_ARRAY_MEMBER]
int64 earliestExistingPage
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)
ProcNumber TwoPhaseGetDummyProcNumber(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)