90 #include "utils/fmgrprotos.h"
109 #define MULTIXACT_OFFSETS_PER_PAGE (BLCKSZ / sizeof(MultiXactOffset))
142 #define MXACT_MEMBER_BITS_PER_XACT 8
143 #define MXACT_MEMBER_FLAGS_PER_BYTE 1
144 #define MXACT_MEMBER_XACT_BITMASK ((1 << MXACT_MEMBER_BITS_PER_XACT) - 1)
147 #define MULTIXACT_FLAGBYTES_PER_GROUP 4
148 #define MULTIXACT_MEMBERS_PER_MEMBERGROUP \
149 (MULTIXACT_FLAGBYTES_PER_GROUP * MXACT_MEMBER_FLAGS_PER_BYTE)
151 #define MULTIXACT_MEMBERGROUP_SIZE \
152 (sizeof(TransactionId) * MULTIXACT_MEMBERS_PER_MEMBERGROUP + MULTIXACT_FLAGBYTES_PER_GROUP)
153 #define MULTIXACT_MEMBERGROUPS_PER_PAGE (BLCKSZ / MULTIXACT_MEMBERGROUP_SIZE)
154 #define MULTIXACT_MEMBERS_PER_PAGE \
155 (MULTIXACT_MEMBERGROUPS_PER_PAGE * MULTIXACT_MEMBERS_PER_MEMBERGROUP)
167 #define MAX_MEMBERS_IN_LAST_MEMBERS_PAGE \
168 ((uint32) ((0xFFFFFFFF % MULTIXACT_MEMBERS_PER_PAGE) + 1))
215 #define MULTIXACT_MEMBER_SAFE_THRESHOLD (MaxMultiXactOffset / 2)
216 #define MULTIXACT_MEMBER_DANGER_THRESHOLD \
217 (MaxMultiXactOffset - MaxMultiXactOffset / 4)
231 #define MultiXactOffsetCtl (&MultiXactOffsetCtlData)
232 #define MultiXactMemberCtl (&MultiXactMemberCtlData)
336 #define MaxOldestSlot (MaxBackends + max_prepared_xacts)
369 #define MAX_CACHE_ENTRIES 256
373 #ifdef MULTIXACT_DEBUG
374 #define debug_elog2(a,b) elog(a,b)
375 #define debug_elog3(a,b,c) elog(a,b,c)
376 #define debug_elog4(a,b,c,d) elog(a,b,c,d)
377 #define debug_elog5(a,b,c,d,e) elog(a,b,c,d,e)
378 #define debug_elog6(a,b,c,d,e,f) elog(a,b,c,d,e,f)
380 #define debug_elog2(a,b)
381 #define debug_elog3(a,b,c)
382 #define debug_elog4(a,b,c,d)
383 #define debug_elog5(a,b,c,d,e)
384 #define debug_elog6(a,b,c,d,e,f)
453 members[0].
xid = xid1;
454 members[0].
status = status1;
455 members[1].
xid = xid2;
456 members[1].
status = status2;
535 for (
i = 0;
i < nmembers;
i++)
538 (members[
i].status == status))
563 for (
i = 0,
j = 0;
i < nmembers;
i++)
574 newMembers[
j].
xid = xid;
575 newMembers[
j++].
status = status;
625 for (
i = 0;
i < nmembers;
i++)
640 for (
i = 0;
i < nmembers;
i++)
753 oldestMXact = thisoldest;
843 bool has_update =
false;
845 for (
i = 0;
i < nmembers;
i++)
850 elog(
ERROR,
"new multixact has more than one updating member: %s",
954 for (
i = 0;
i < nmembers;
i++, offset++)
970 if (pageno != prev_pageno)
978 if (lock != prevlock)
980 if (prevlock != NULL)
987 prev_pageno = pageno;
993 *memberptr = members[
i].
xid;
998 flagsval = *flagsptr;
1000 flagsval |= (members[
i].
status << bshift);
1001 *flagsptr = flagsval;
1006 if (prevlock != NULL)
1035 elog(
ERROR,
"cannot assign MultiXactIds during recovery");
1090 (
errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
1091 errmsg(
"database is not accepting commands that assign new MultiXactIds to avoid wraparound data loss in database \"%s\"",
1093 errhint(
"Execute a database-wide VACUUM in that database.\n"
1094 "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
1097 (
errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
1098 errmsg(
"database is not accepting commands that assign new MultiXactIds to avoid wraparound data loss in database with OID %u",
1100 errhint(
"Execute a database-wide VACUUM in that database.\n"
1101 "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
1119 (
errmsg_plural(
"database \"%s\" must be vacuumed before %u more MultiXactId is used",
1120 "database \"%s\" must be vacuumed before %u more MultiXactIds are used",
1121 multiWrapLimit - result,
1123 multiWrapLimit - result),
1124 errhint(
"Execute a database-wide VACUUM in that database.\n"
1125 "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
1128 (
errmsg_plural(
"database with OID %u must be vacuumed before %u more MultiXactId is used",
1129 "database with OID %u must be vacuumed before %u more MultiXactIds are used",
1130 multiWrapLimit - result,
1132 multiWrapLimit - result),
1133 errhint(
"Execute a database-wide VACUUM in that database.\n"
1134 "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
1153 if (nextOffset == 0)
1159 *offset = nextOffset;
1179 #define OFFSET_WARN_SEGMENTS 20
1188 (
errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
1189 errmsg(
"multixact \"members\" limit exceeded"),
1190 errdetail_plural(
"This command would create a multixact with %u members, but the remaining space is only enough for %u member.",
1191 "This command would create a multixact with %u members, but the remaining space is only enough for %u members.",
1195 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.",
1225 (
errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
1226 errmsg_plural(
"database with OID %u must be vacuumed before %d more multixact member is used",
1227 "database with OID %u must be vacuumed before %d more multixact members are used",
1231 errhint(
"Execute a database-wide VACUUM in that database with reduced \"vacuum_multixact_freeze_min_age\" and \"vacuum_multixact_freeze_table_age\" settings.")));
1294 bool from_pgupgrade,
bool isLockOnly)
1370 (
errcode(ERRCODE_INTERNAL_ERROR),
1371 errmsg(
"MultiXactId %u does no longer exist -- apparent wraparound",
1376 (
errcode(ERRCODE_INTERNAL_ERROR),
1377 errmsg(
"MultiXactId %u has not been created yet -- apparent wraparound",
1434 tmpMXact = multi + 1;
1436 if (nextMXact == tmpMXact)
1439 length = nextOffset - offset;
1449 prev_pageno = pageno;
1454 if (pageno != prev_pageno)
1464 if (newlock != lock)
1475 nextMXOffset = *offptr;
1477 if (nextMXOffset == 0)
1484 WAIT_EVENT_MULTIXACT_CREATION);
1489 length = nextMXOffset - offset;
1505 for (
int i = 0;
i < length;
i++, offset++)
1516 if (pageno != prev_pageno)
1526 if (newlock != lock)
1535 prev_pageno = pageno;
1552 ptr[truelength].
xid = *xactptr;
1586 if (member1.
xid > member2.
xid)
1588 if (member1.
xid < member2.
xid)
1637 return entry->
multi;
1665 if (entry->
multi == multi)
1713 "MultiXact cache context",
1722 entry->
multi = multi;
1755 return "fornokeyupd";
1763 elog(
ERROR,
"unrecognized multixact status %d", status);
1771 static char *
str = NULL;
1783 for (
i = 1;
i < nmembers;
i++)
1944 #define SHARED_MULTIXACT_STATE_SIZE \
1945 add_size(offsetof(MultiXactStateData, perBackendXactIds), \
1946 mul_size(sizeof(MultiXactId) * 2, MaxOldestSlot))
2249 MemSet(xidptr, 0, BLCKSZ - memberoff);
2288 "MultiXact: checkpoint is nextMulti %u, nextOffset %u, oldestMulti %u in DB %u",
2289 *nextMulti, *nextMultiOffset, *oldestMulti, *oldestMultiDB);
2298 TRACE_POSTGRESQL_MULTIXACT_CHECKPOINT_START(
true);
2308 TRACE_POSTGRESQL_MULTIXACT_CHECKPOINT_DONE(
true);
2324 nextMulti, nextMultiOffset);
2362 bool needs_offset_vacuum;
2381 multiStopLimit = multiWrapLimit - 3000000;
2395 multiWarnLimit = multiWrapLimit - 40000000;
2424 (
errmsg_internal(
"MultiXactId wrap limit is %u, limited by database with OID %u",
2425 multiWrapLimit, oldest_datoid)));
2456 char *oldest_datname;
2470 oldest_datname = NULL;
2474 (
errmsg_plural(
"database \"%s\" must be vacuumed before %u more MultiXactId is used",
2475 "database \"%s\" must be vacuumed before %u more MultiXactIds are used",
2476 multiWrapLimit - curMulti,
2478 multiWrapLimit - curMulti),
2479 errhint(
"To avoid MultiXactId assignment failures, execute a database-wide VACUUM in that database.\n"
2480 "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
2483 (
errmsg_plural(
"database with OID %u must be vacuumed before %u more MultiXactId is used",
2484 "database with OID %u must be vacuumed before %u more MultiXactIds are used",
2485 multiWrapLimit - curMulti,
2487 multiWrapLimit - curMulti),
2488 errhint(
"To avoid MultiXactId assignment failures, execute a database-wide VACUUM in that database.\n"
2489 "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
2585 while (nmembers > 0)
2596 if (flagsoff == 0 && flagsbit == 0)
2673 oldestMXact = nextMXact;
2681 oldestMXact = thisoldest;
2685 oldestMXact = thisoldest;
2712 bool oldestOffsetKnown =
false;
2713 bool prevOldestOffsetKnown;
2741 if (oldestMultiXactId == nextMXact)
2747 oldestOffset = nextOffset;
2748 oldestOffsetKnown =
true;
2761 if (oldestOffsetKnown)
2767 (
errmsg(
"MultiXact member wraparound protections are disabled because oldest checkpointed MultiXact %u does not exist on disk",
2768 oldestMultiXactId)));
2778 if (oldestOffsetKnown)
2781 offsetStopLimit = oldestOffset - (oldestOffset %
2787 if (!prevOldestOffsetKnown && !is_startup)
2789 (
errmsg(
"MultiXact member wraparound protections are now enabled")));
2792 (
errmsg_internal(
"MultiXact member stop limit is now %u based on MultiXact %u",
2793 offsetStopLimit, oldestMultiXactId)));
2795 else if (prevOldestOffsetKnown)
2803 oldestOffset = prevOldestOffset;
2804 oldestOffsetKnown =
true;
2805 offsetStopLimit = prevOffsetStopLimit;
2818 return !oldestOffsetKnown ||
2841 finish =
start + distance;
2864 if (
start < boundary)
2865 return finish >= boundary || finish <
start;
2867 return finish >= boundary && finish <
start;
2924 bool oldestOffsetKnown;
2934 if (!oldestOffsetKnown)
2937 *members = nextOffset - oldestOffset;
2938 *multixacts = nextMultiXactId - oldestMultiXactId;
2974 uint32 victim_multixacts;
2993 victim_multixacts = multixacts * fraction;
2996 if (victim_multixacts > multixacts)
2998 result = multixacts - victim_multixacts;
3045 int segment = startsegment;
3051 while (segment != endsegment)
3053 elog(
DEBUG2,
"truncating multixact members segment %llx",
3054 (
unsigned long long) segment);
3058 if (segment == maxsegment)
3172 if (oldestMulti == nextMulti)
3175 oldestOffset = nextOffset;
3180 (
errmsg(
"oldest MultiXact %u not found, earliest MultiXact %u, skipping truncation",
3181 oldestMulti, earliest)));
3190 if (newOldestMulti == nextMulti)
3193 newOldestOffset = nextOffset;
3198 (
errmsg(
"cannot truncate up to MultiXact %u because it does not exist on disk, skipping truncation",
3204 elog(
DEBUG1,
"performing multixact truncation: "
3205 "offsets [%u, %u), offsets segments [%llx, %llx), "
3206 "members [%u, %u), members segments [%llx, %llx)",
3207 oldestMulti, newOldestMulti,
3210 oldestOffset, newOldestOffset,
3233 oldestMulti, newOldestMulti,
3234 oldestOffset, newOldestOffset);
3464 elog(
DEBUG1,
"replaying multixact truncation: "
3465 "offsets [%u, %u), offsets segments [%llx, %llx), "
3466 "members [%u, %u), members segments [%llx, %llx)",
3498 elog(
PANIC,
"multixact_redo: unknown op code %u", info);
3516 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
3517 errmsg(
"invalid MultiXactId: %u", mxid)));
3527 multi =
palloc(
sizeof(mxact));
3534 elog(
ERROR,
"return type must be a row type");
3545 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]
#define Assert(condition)
TransactionId MultiXactId
#define FLEXIBLE_ARRAY_MEMBER
#define MemSet(start, val, len)
bool ConditionVariableCancelSleep(void)
void ConditionVariableBroadcast(ConditionVariable *cv)
void ConditionVariableInit(ConditionVariable *cv)
void ConditionVariableSleep(ConditionVariable *cv, uint32 wait_event_info)
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)
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()
static void WriteMTruncateXlogRec(Oid oldestMultiDB, MultiXactId startTruncOff, MultiXactId endTruncOff, MultiXactOffset startTruncMemb, MultiXactOffset endTruncMemb)
static MultiXactId PreviousMultiXactId(MultiXactId multi)
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)
static int64 MXOffsetToMemberPage(MultiXactOffset offset)
#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 MULTIXACT_FLAGBYTES_PER_GROUP
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)
void MultiXactAdvanceOldest(MultiXactId oldestMulti, Oid oldestMultiDB)
static int MultiXactIdToOffsetEntry(MultiXactId multi)
static void mXactCachePut(MultiXactId multi, int nmembers, MultiXactMember *members)
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 MULTIXACT_MEMBERGROUPS_PER_PAGE
#define MultiXactOffsetCtl
void multixact_twophase_postabort(TransactionId xid, uint16 info, void *recdata, uint32 len)
static int MXOffsetToMemberOffset(MultiXactOffset offset)
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
static int64 MultiXactIdToOffsetPage(MultiXactId multi)
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
static int MXOffsetToMemberSegment(MultiXactOffset offset)
char * mxid_to_string(MultiXactId multi, int nmembers, MultiXactMember *members)
#define debug_elog3(a, b, c)
#define MULTIXACT_MEMBERGROUP_SIZE
#define debug_elog4(a, b, c, d)
static bool MultiXactOffsetPagePrecedes(int64 page1, int64 page2)
static bool SetOffsetVacuumLimit(bool is_startup)
static int MXOffsetToFlagsOffset(MultiXactOffset offset)
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)
#define MULTIXACT_MEMBERS_PER_MEMBERGROUP
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)
static int MultiXactIdToOffsetSegment(MultiXactId multi)
#define MULTIXACT_MEMBER_DANGER_THRESHOLD
static int MXOffsetToFlagsBitShift(MultiXactOffset offset)
bool check_multixact_offset_buffers(int *newval, void **extra, GucSource source)
static bool MultiXactOffsetPrecedes(MultiXactOffset offset1, MultiXactOffset offset2)
bool check_multixact_member_buffers(int *newval, void **extra, GucSource source)
void AtEOXact_MultiXact(void)
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 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,...)
MemoryContextSwitchTo(old_ctx)
Size add_size(Size s1, Size s2)
void * ShmemInitStruct(const char *name, Size size, bool *foundPtr)
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
ConditionVariable nextoff_cv
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)