69 #define UINT32_ACCESS_ONCE(var) ((uint32)(*((volatile uint32 *)&(var)))) 285 #ifdef XIDCACHE_DEBUG 288 static long xc_by_recent_xmin = 0;
289 static long xc_by_known_xact = 0;
290 static long xc_by_my_xact = 0;
291 static long xc_by_latest_xid = 0;
292 static long xc_by_main_xid = 0;
293 static long xc_by_child_xid = 0;
294 static long xc_by_known_assigned = 0;
295 static long xc_no_overflow = 0;
296 static long xc_slow_answer = 0;
298 #define xc_by_recent_xmin_inc() (xc_by_recent_xmin++) 299 #define xc_by_known_xact_inc() (xc_by_known_xact++) 300 #define xc_by_my_xact_inc() (xc_by_my_xact++) 301 #define xc_by_latest_xid_inc() (xc_by_latest_xid++) 302 #define xc_by_main_xid_inc() (xc_by_main_xid++) 303 #define xc_by_child_xid_inc() (xc_by_child_xid++) 304 #define xc_by_known_assigned_inc() (xc_by_known_assigned++) 305 #define xc_no_overflow_inc() (xc_no_overflow++) 306 #define xc_slow_answer_inc() (xc_slow_answer++) 308 static void DisplayXidCache(
void);
311 #define xc_by_recent_xmin_inc() ((void) 0) 312 #define xc_by_known_xact_inc() ((void) 0) 313 #define xc_by_my_xact_inc() ((void) 0) 314 #define xc_by_latest_xid_inc() ((void) 0) 315 #define xc_by_main_xid_inc() ((void) 0) 316 #define xc_by_child_xid_inc() ((void) 0) 317 #define xc_by_known_assigned_inc() ((void) 0) 318 #define xc_no_overflow_inc() ((void) 0) 319 #define xc_slow_answer_inc() ((void) 0) 325 bool exclusive_lock);
357 #define PROCARRAY_MAXPROCS (MaxBackends + max_prepared_xacts) 375 #define TOTAL_MAX_CACHED_SUBXIDS \ 376 ((PGPROC_MAX_CACHED_SUBXIDS + 1) * PROCARRAY_MAXPROCS) 462 (
errcode(ERRCODE_TOO_MANY_CONNECTIONS),
463 errmsg(
"sorry, too many clients already")));
475 for (index = 0; index < arrayP->
numProcs; index++)
501 for (; index < arrayP->
numProcs; index++)
530 #ifdef XIDCACHE_DEBUG 567 for (index = 0; index < arrayP->
numProcs; index++)
585 for (; index < arrayP->
numProcs; index++)
602 elog(
LOG,
"failed to find proc %p in ProcArray", proc);
787 while (extraWaits-- > 0)
809 PGPROC *proc = &allProcs[nextidx];
829 PGPROC *proc = &allProcs[wakeidx];
1060 "recovery snapshots are now enabled");
1064 "recovery snapshot waiting for non-overflowed snapshot or " 1065 "until oldest active xid on standby is at least %u (now %u)",
1106 for (i = 0; i < running->
xcnt + running->
subxcnt; i++)
1119 xids[nxids++] = xid;
1127 elog(
ERROR,
"KnownAssignedXids is not empty");
1141 for (i = 0; i < nxids; i++)
1146 "found duplicated transaction %u for KnownAssignedXids insertion",
1230 "recovery snapshot waiting for non-overflowed snapshot or " 1231 "until oldest active xid on standby is at least %u (now %u)",
1272 for (i = 0; i < nsubxids; i++)
1387 (
errcode(ERRCODE_OUT_OF_MEMORY),
1388 errmsg(
"out of memory")));
1400 latestCompletedXid =
1412 for (
size_t pgxactoff = 0; pgxactoff <
numProcs; pgxactoff++)
1420 if (pgxactoff == mypgxactoff)
1449 pxids = other_subxidstates[pgxactoff].
count;
1451 pgprocno = arrayP->
pgprocnos[pgxactoff];
1452 proc = &allProcs[pgprocno];
1453 for (j = pxids - 1; j >= 0; j--)
1473 if (other_subxidstates[pgxactoff].overflowed)
1474 xids[nxids++] = pxid;
1538 for (
int i = 0;
i < nxids;
i++)
1559 bool result =
false;
1573 for (i = 0; i < arrayP->
numProcs; i++)
1576 PGPROC *proc = &allProcs[pgprocno];
1725 PGPROC *proc = &allProcs[pgprocno];
1951 if (rel == NULL || rel->
rd_rel->relisshared)
2059 uint64 curXactCompletionCount;
2099 snapshot->
copied =
false;
2148 bool suboverflowed =
false;
2153 uint64 curXactCompletionCount;
2158 Assert(snapshot != NULL);
2171 if (snapshot->
xip == NULL)
2179 if (snapshot->
xip == NULL)
2181 (
errcode(ERRCODE_OUT_OF_MEMORY),
2182 errmsg(
"out of memory")));
2186 if (snapshot->
subxip == NULL)
2188 (
errcode(ERRCODE_OUT_OF_MEMORY),
2189 errmsg(
"out of memory")));
2206 myxid = other_xids[mypgxactoff];
2238 for (
size_t pgxactoff = 0; pgxactoff <
numProcs; pgxactoff++)
2258 if (pgxactoff == mypgxactoff)
2281 statusFlags = allStatusFlags[pgxactoff];
2309 if (subxidStates[pgxactoff].overflowed)
2310 suboverflowed =
true;
2313 int nsubxids = subxidStates[pgxactoff].
count;
2317 int pgprocno = pgprocnos[pgxactoff];
2318 PGPROC *proc = &allProcs[pgprocno];
2322 memcpy(snapshot->
subxip + subcount,
2325 subcount += nsubxids;
2366 suboverflowed =
true;
2410 def_vis_xid = def_vis_xid_data;
2470 snapshot->
xmin = xmin;
2471 snapshot->
xmax = xmax;
2472 snapshot->
xcnt = count;
2485 snapshot->
copied =
false;
2506 bool result =
false;
2517 for (index = 0; index < arrayP->
numProcs; index++)
2519 int pgprocno = arrayP->
pgprocnos[index];
2520 PGPROC *proc = &allProcs[pgprocno];
2580 bool result =
false;
2668 if (CurrentRunningXacts->
xids == NULL)
2675 if (CurrentRunningXacts->
xids == NULL)
2677 (
errcode(ERRCODE_OUT_OF_MEMORY),
2678 errmsg(
"out of memory")));
2681 xids = CurrentRunningXacts->
xids;
2683 count = subcount = 0;
2684 suboverflowed =
false;
2693 latestCompletedXid =
2701 for (index = 0; index < arrayP->
numProcs; index++)
2721 oldestRunningXid = xid;
2724 suboverflowed =
true;
2734 xids[count++] = xid;
2745 for (index = 0; index < arrayP->
numProcs; index++)
2747 int pgprocno = arrayP->
pgprocnos[index];
2748 PGPROC *proc = &allProcs[pgprocno];
2755 nsubxids = other_subxidstates[index].
count;
2764 subcount += nsubxids;
2784 CurrentRunningXacts->
xcnt = count - subcount;
2785 CurrentRunningXacts->
subxcnt = subcount;
2797 return CurrentRunningXacts;
2840 for (index = 0; index < arrayP->
numProcs; index++)
2851 oldestRunningXid = xid;
2861 return oldestRunningXid;
2931 if (!recovery_in_progress)
2938 for (index = 0; index < arrayP->
numProcs; index++)
2949 oldestSafeXid = xid;
2955 return oldestSafeXid;
2990 for (index = 0; index < arrayP->
numProcs; index++)
2992 int pgprocno = arrayP->
pgprocnos[index];
2993 PGPROC *proc = &allProcs[pgprocno];
3001 vxids[count++] = vxid;
3023 bool result =
false;
3029 for (index = 0; index < arrayP->
numProcs; index++)
3031 int pgprocno = arrayP->
pgprocnos[index];
3032 PGPROC *proc = &allProcs[pgprocno];
3041 for (i = 0; i < nvxids; i++)
3099 for (index = 0; index < arrayP->
numProcs; index++)
3103 if (proc->
pid == pid)
3139 for (index = 0; index < arrayP->
numProcs; index++)
3141 int pgprocno = arrayP->
pgprocnos[index];
3142 PGPROC *proc = &allProcs[pgprocno];
3144 if (other_xids[index] == xid)
3196 bool allDbs,
int excludeVacuum,
3210 for (index = 0; index < arrayP->
numProcs; index++)
3212 int pgprocno = arrayP->
pgprocnos[index];
3213 PGPROC *proc = &allProcs[pgprocno];
3219 if (excludeVacuum & statusFlags)
3241 vxids[count++] = vxid;
3301 (
errcode(ERRCODE_OUT_OF_MEMORY),
3302 errmsg(
"out of memory")));
3307 for (index = 0; index < arrayP->
numProcs; index++)
3309 int pgprocno = arrayP->
pgprocnos[index];
3310 PGPROC *proc = &allProcs[pgprocno];
3337 vxids[count++] = vxid;
3364 bool conflictPending)
3372 for (index = 0; index < arrayP->
numProcs; index++)
3374 int pgprocno = arrayP->
pgprocnos[index];
3375 PGPROC *proc = &allProcs[pgprocno];
3427 for (index = 0; index < arrayP->
numProcs; index++)
3429 int pgprocno = arrayP->
pgprocnos[index];
3430 PGPROC *proc = &allProcs[pgprocno];
3458 return count >= min;
3473 for (index = 0; index < arrayP->
numProcs; index++)
3475 int pgprocno = arrayP->
pgprocnos[index];
3476 PGPROC *proc = &allProcs[pgprocno];
3503 for (index = 0; index < arrayP->
numProcs; index++)
3505 int pgprocno = arrayP->
pgprocnos[index];
3506 PGPROC *proc = &allProcs[pgprocno];
3534 for (index = 0; index < arrayP->
numProcs; index++)
3536 int pgprocno = arrayP->
pgprocnos[index];
3537 PGPROC *proc = &allProcs[pgprocno];
3574 for (index = 0; index < arrayP->
numProcs; index++)
3576 int pgprocno = arrayP->
pgprocnos[index];
3577 PGPROC *proc = &allProcs[pgprocno];
3583 if (proc->
roleId == roleid)
3620 #define MAXAUTOVACPIDS 10 3625 for (tries = 0; tries < 50; tries++)
3633 *nbackends = *nprepared = 0;
3637 for (index = 0; index < arrayP->
numProcs; index++)
3639 int pgprocno = arrayP->
pgprocnos[index];
3640 PGPROC *proc = &allProcs[pgprocno];
3657 autovac_pids[nautovacs++] = proc->
pid;
3672 for (index = 0; index < nautovacs; index++)
3673 (
void)
kill(autovac_pids[index], SIGTERM);
3703 for (i = 0; i < procArray->
numProcs; i++)
3706 PGPROC *proc = &allProcs[pgprocno];
3723 (
errcode(ERRCODE_OBJECT_IN_USE),
3724 errmsg(
"database \"%s\" is being used by prepared transactions",
3727 "There are %d prepared transactions using the database.",
3755 (
errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
3756 errmsg(
"must be a superuser to terminate superuser process")));
3762 (
errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
3763 errmsg(
"must be a member of the role whose process is being terminated or member of pg_signal_backend")));
3785 (void)
kill(-pid, SIGTERM);
3787 (void)
kill(pid, SIGTERM);
3803 bool already_locked)
3807 if (!already_locked)
3813 if (!already_locked)
3832 if (catalog_xmin != NULL)
3878 for (i = nxids - 1; i >= 0; i--)
3888 mysubxidstat->
count--;
3901 if (j < 0 && !MyProc->subxidStatus.overflowed)
3902 elog(
WARNING,
"did not find subXID %u in MyProc", anxid);
3911 mysubxidstat->
count--;
3917 if (j < 0 && !MyProc->subxidStatus.overflowed)
3918 elog(
WARNING,
"did not find subXID %u in MyProc", xid);
3929 #ifdef XIDCACHE_DEBUG 3935 DisplayXidCache(
void)
3938 "XidCache: xmin: %ld, known: %ld, myxact: %ld, latest: %ld, mainxid: %ld, childxid: %ld, knownassigned: %ld, nooflo: %ld, slow: %ld\n",
3945 xc_by_known_assigned,
3973 need_shared = need_catalog =
true;
3981 rel->
rd_rel->relkind == RELKIND_MATVIEW ||
3982 rel->
rd_rel->relkind == RELKIND_TOASTVALUE);
3990 else if (need_catalog)
4229 + (
int32) (xid - rel_xid));
4333 Assert(next_expected_xid == xid);
4536 int nelements = head - tail;
4548 for (i = tail; i < head; i++)
4575 bool exclusive_lock)
4591 if (to_xid >= from_xid)
4592 nxids = to_xid - from_xid + 1;
4596 next_xid = from_xid;
4612 Assert(tail >= 0 && tail < pArray->maxKnownAssignedXids);
4623 elog(
ERROR,
"out-of-order XID insertion in KnownAssignedXids");
4632 if (!exclusive_lock)
4640 if (!exclusive_lock)
4647 elog(
ERROR,
"too many KnownAssignedXids");
4651 next_xid = from_xid;
4652 for (i = 0; i < nxids; i++)
4699 int result_index = -1;
4722 while (first <= last)
4727 mid_index = (first + last) / 2;
4732 result_index = mid_index;
4736 last = mid_index - 1;
4738 first = mid_index + 1;
4741 if (result_index < 0)
4758 if (result_index == tail)
4832 for (i = 0; i < nsubxids; i++)
4871 for (i = tail; i < head; i++)
4894 for (i = tail; i < head; i++)
4960 for (i = tail; i < head; i++)
4984 xarray[count++] = knownXid;
5010 for (i = tail; i < head; i++)
5045 for (i = tail; i < head; i++)
5054 elog(trace_level,
"%d KnownAssignedXids (num=%d tail=%d head=%d) %s",
#define TransactionIdAdvance(dest)
void ProcArrayApplyRecoveryInfo(RunningTransactions running)
#define AmStartupProcess()
static TransactionId latestObservedXid
TransactionId oldest_considered_running
VirtualTransactionId * GetCurrentVirtualXIDs(TransactionId limitXmin, bool excludeXmin0, bool allDbs, int excludeVacuum, int *nvxids)
TransactionId oldestRunningXid
bool procArrayGroupMember
uint64 snapXactCompletionCount
pid_t CancelVirtualTransaction(VirtualTransactionId vxid, ProcSignalReason sigmode)
bool IsCatalogRelation(Relation relation)
#define PROCARRAY_MAXPROCS
#define InvalidXLogRecPtr
TransactionId GetOldestSafeDecodingTransactionId(bool catalogOnly)
static void ComputeXidHorizons(ComputeXidHorizonsResult *h)
bool LWLockHeldByMeInMode(LWLock *l, LWLockMode mode)
FullTransactionId latest_completed
int CountDBBackends(Oid databaseid)
TransactionId shared_oldest_nonremovable_raw
static void pgstat_report_wait_end(void)
static void KnownAssignedXidsDisplay(int trace_level)
#define GET_VXID_FROM_PGPROC(vxid, proc)
#define TransactionIdEquals(id1, id2)
bool TransactionIdFollows(TransactionId id1, TransactionId id2)
#define PROC_IN_LOGICAL_DECODING
void AdvanceNextFullTransactionIdPastXid(TransactionId xid)
void PGSemaphoreUnlock(PGSemaphore sema)
bool TransactionIdIsCurrentTransactionId(TransactionId xid)
TransactionId SubTransGetTopmostTransaction(TransactionId xid)
XidCacheStatus * subxidStates
bool LWLockHeldByMe(LWLock *l)
static bool pg_atomic_compare_exchange_u32(volatile pg_atomic_uint32 *ptr, uint32 *expected, uint32 newval)
static void ProcArrayEndTransactionInternal(PGPROC *proc, TransactionId latestXid)
PGPROC * BackendPidGetProc(int pid)
#define FullTransactionIdIsValid(x)
bool TransactionIdIsInProgress(TransactionId xid)
static bool OldSnapshotThresholdActive(void)
TransactionId TransactionIdLatest(TransactionId mainxid, int nxids, const TransactionId *xids)
int vacuum_defer_cleanup_age
#define UINT32_ACCESS_ONCE(var)
#define SpinLockInit(lock)
#define RELATION_IS_LOCAL(relation)
bool has_privs_of_role(Oid member, Oid role)
VirtualTransactionId * GetConflictingVirtualXIDs(TransactionId limitXmin, Oid dbOid)
TransactionId replication_slot_catalog_xmin
bool TransactionIdFollowsOrEquals(TransactionId id1, TransactionId id2)
VirtualTransactionId * GetVirtualXIDsDelayingChkpt(int *nvxids)
static void ProcArrayGroupClearXid(PGPROC *proc, TransactionId latestXid)
static FullTransactionId FullXidRelativeTo(FullTransactionId rel, TransactionId xid)
#define FLEXIBLE_ARRAY_MEMBER
#define xc_by_my_xact_inc()
static void MaintainLatestCompletedXidRecovery(TransactionId latestXid)
int errcode(int sqlerrcode)
uint64 xactCompletionCount
slock_t known_assigned_xids_lck
bool GlobalVisTestIsRemovableFullXid(GlobalVisState *state, FullTransactionId fxid)
bool TransactionIdDidCommit(TransactionId transactionId)
FullTransactionId latestCompletedXid
bool RecoveryInProgress(void)
static FullTransactionId FullTransactionIdFromU64(uint64 value)
#define TransactionIdRetreat(dest)
LocalTransactionId localTransactionId
void ProcArrayEndTransaction(PGPROC *proc, TransactionId latestXid)
#define xc_by_child_xid_inc()
bool TransactionIdIsKnownCompleted(TransactionId transactionId)
void ExpireTreeKnownAssignedTransactionIds(TransactionId xid, int nsubxids, TransactionId *subxids, TransactionId max_xid)
FullTransactionId nextXid
#define OidIsValid(objectId)
void ProcArrayGetReplicationSlotXmin(TransactionId *xmin, TransactionId *catalog_xmin)
TransactionId catalog_oldest_nonremovable
XidCacheStatus subxidStatus
void ExpireAllKnownAssignedTransactionIds(void)
bool GlobalVisTestIsRemovableXid(GlobalVisState *state, TransactionId xid)
int trace_recovery(int trace_level)
#define PROC_VACUUM_STATE_MASK
#define XidFromFullTransactionId(x)
TransactionId TransactionXmin
TransactionId latestCompletedXid
FullTransactionId definitely_needed
void LWLockRelease(LWLock *lock)
static uint32 pg_atomic_exchange_u32(volatile pg_atomic_uint32 *ptr, uint32 newval)
#define VirtualTransactionIdEquals(vxid1, vxid2)
#define xc_by_recent_xmin_inc()
#define xc_by_known_xact_inc()
static void GetSnapshotDataInitOldSnapshot(Snapshot snapshot)
bool MinimumActiveBackends(int min)
static void KnownAssignedXidsRemovePreceding(TransactionId xid)
PGPROC * BackendPidGetProcWithLock(int pid)
#define SpinLockAcquire(lock)
void pg_usleep(long microsec)
GlobalVisState * GlobalVisTestFor(Relation rel)
int SendProcSignal(pid_t pid, ProcSignalReason reason, BackendId backendId)
pid_t SignalVirtualTransaction(VirtualTransactionId vxid, ProcSignalReason sigmode, bool conflictPending)
#define AssertTransactionIdInAllowableRange(xid)
void pfree(void *pointer)
void appendStringInfo(StringInfo str, const char *fmt,...)
bool TransactionIdPrecedesOrEquals(TransactionId id1, TransactionId id2)
int CountDBConnections(Oid databaseid)
TransactionId GetOldestNonRemovableTransactionId(Relation rel)
void XidCacheRemoveRunningXids(TransactionId xid, int nxids, const TransactionId *xids, TransactionId latestXid)
#define FullTransactionIdIsNormal(x)
TimestampTz GetSnapshotCurrentTimestamp(void)
void ProcArrayClearTransaction(PGPROC *proc)
void * ShmemInitStruct(const char *name, Size size, bool *foundPtr)
void ExtendSUBTRANS(TransactionId newestXact)
void ProcArrayRemove(PGPROC *proc, TransactionId latestXid)
XLogRecPtr GetXLogInsertRecPtr(void)
TransactionId slot_catalog_xmin
void CancelDBBackends(Oid databaseid, ProcSignalReason sigmode, bool conflictPending)
char * get_database_name(Oid dbid)
#define xc_by_main_xid_inc()
static bool GlobalVisTestShouldUpdate(GlobalVisState *state)
static GlobalVisState GlobalVisSharedRels
bool LWLockConditionalAcquire(LWLock *lock, LWLockMode mode)
bool recoveryConflictPending
#define xc_by_known_assigned_inc()
VariableCache ShmemVariableCache
#define InvalidTransactionId
bool StandbyTransactionIdIsPrepared(TransactionId xid)
TransactionId shared_oldest_nonremovable
static void KnownAssignedXidsReset(void)
static bool * KnownAssignedXidsValid
TransactionId lastOverflowedXid
bool TransactionIdDidAbort(TransactionId transactionId)
#define xc_by_latest_xid_inc()
bool superuser_arg(Oid roleid)
bool TransactionIdPrecedes(TransactionId id1, TransactionId id2)
static void KnownAssignedXidsRemoveTree(TransactionId xid, int nsubxids, TransactionId *subxids)
pg_atomic_uint32 procArrayGroupNext
List * lappend_int(List *list, int datum)
static void pgstat_report_wait_start(uint32 wait_event_info)
void initStringInfo(StringInfo str)
static ProcArrayStruct * procArray
#define VirtualTransactionIdIsValid(vxid)
static TransactionId ComputeXidHorizonsResultLastXmin
#define SpinLockRelease(lock)
TransactionId replication_slot_xmin
Size mul_size(Size s1, Size s2)
int BackendXidGetPid(TransactionId xid)
static void MaintainLatestCompletedXid(TransactionId latestXid)
#define RelationIsAccessibleInLogicalDecoding(relation)
void GetReplicationHorizons(TransactionId *xmin, TransactionId *catalog_xmin)
static int KnownAssignedXidsGet(TransactionId *xarray, TransactionId xmax)
Size add_size(Size s1, Size s2)
static TransactionId KnownAssignedXidsGetOldestXmin(void)
#define ereport(elevel,...)
bool GlobalVisCheckRemovableXid(Relation rel, TransactionId xid)
int GetMaxSnapshotXidCount(void)
int pgprocnos[FLEXIBLE_ARRAY_MEMBER]
TransactionId xids[PGPROC_MAX_CACHED_SUBXIDS]
bool GlobalVisCheckRemovableFullXid(Relation rel, FullTransactionId fxid)
TransactionId temp_oldest_nonremovable
#define TOTAL_MAX_CACHED_SUBXIDS
static TransactionId TransactionIdOlder(TransactionId a, TransactionId b)
#define Assert(condition)
static TransactionId * KnownAssignedXids
#define pg_read_barrier()
#define U64FromFullTransactionId(x)
void CreateSharedProcArray(void)
#define FullTransactionIdFollowsOrEquals(a, b)
struct ComputeXidHorizonsResult ComputeXidHorizonsResult
Snapshot GetSnapshotData(Snapshot snapshot)
int errdetail_plural(const char *fmt_singular, const char *fmt_plural, unsigned long n,...)
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
static void GlobalVisUpdateApply(ComputeXidHorizonsResult *horizons)
static TransactionId TransactionIdRetreatedBy(TransactionId xid, uint32 amount)
static int KnownAssignedXidsGetAndSetXmin(TransactionId *xarray, TransactionId *xmin, TransactionId xmax)
static void KnownAssignedXidsAdd(TransactionId from_xid, TransactionId to_xid, bool exclusive_lock)
TransactionId GetOldestTransactionIdConsideredRunning(void)
bool ProcArrayInstallRestoredXmin(TransactionId xmin, PGPROC *proc)
#define NormalTransactionIdPrecedes(id1, id2)
#define xc_no_overflow_inc()
FullTransactionId maybe_needed
void PGSemaphoreLock(PGSemaphore sema)
static void KnownAssignedXidsCompress(bool force)
int CountUserBackends(Oid roleid)
static FullTransactionId FullTransactionIdNewer(FullTransactionId a, FullTransactionId b)
#define IsBootstrapProcessingMode()
static bool KnownAssignedXidExists(TransactionId xid)
static GlobalVisState GlobalVisTempRels
bool TransactionIdIsActive(TransactionId xid)
#define xc_slow_answer_inc()
pg_atomic_uint32 procArrayGroupFirst
void ProcArrayInitRecovery(TransactionId initializedUptoXID)
int errmsg(const char *fmt,...)
struct ProcArrayStruct ProcArrayStruct
static bool KnownAssignedXidsSearch(TransactionId xid, bool remove)
FullTransactionId GlobalVisTestNonRemovableFullHorizon(GlobalVisState *state)
static void KnownAssignedXidsRemove(TransactionId xid)
#define InvalidLocalTransactionId
TransactionId data_oldest_nonremovable
void ExpireOldKnownAssignedTransactionIds(TransactionId xid)
TransactionId GetOldestActiveTransactionId(void)
bool IsBackendPid(int pid)
#define pg_write_barrier()
static bool GetSnapshotDataReuse(Snapshot snapshot)
void ProcArraySetReplicationSlotXmin(TransactionId xmin, TransactionId catalog_xmin, bool already_locked)
int GetMaxSnapshotSubxidCount(void)
RunningTransactions GetRunningTransactionData(void)
void ProcArrayApplyXidAssignment(TransactionId topxid, int nsubxids, TransactionId *subxids)
void TerminateOtherDBBackends(Oid databaseId)
#define CHECK_FOR_INTERRUPTS()
#define FullTransactionIdPrecedes(a, b)
bool CountOtherDBBackends(Oid databaseId, int *nbackends, int *nprepared)
CommandId GetCurrentCommandId(bool used)
#define qsort(a, b, c, d)
#define TransactionIdIsValid(xid)
static void GlobalVisUpdate(void)
static void pg_atomic_write_u32(volatile pg_atomic_uint32 *ptr, uint32 val)
void MaintainOldSnapshotTimeMapping(TimestampTz whenTaken, TransactionId xmin)
bool HaveVirtualXIDsDelayingChkpt(VirtualTransactionId *vxids, int nvxids)
static GlobalVisState GlobalVisCatalogRels
TransactionId GlobalVisTestNonRemovableHorizon(GlobalVisState *state)
void RecordKnownAssignedTransactionIds(TransactionId xid)
#define TransactionIdIsNormal(xid)
void SubTransSetParent(TransactionId xid, TransactionId parent)
static GlobalVisState GlobalVisDataRels
bool ProcArrayInstallImportedXmin(TransactionId xmin, VirtualTransactionId *sourcevxid)
int tailKnownAssignedXids
static TransactionId standbySnapshotPendingXmin
static void FullTransactionIdAdvance(FullTransactionId *dest)
HotStandbyState standbyState
void ProcArrayAdd(PGPROC *proc)
#define PROC_IS_AUTOVACUUM
#define offsetof(type, field)
TransactionId procArrayGroupMemberXid
Size ProcArrayShmemSize(void)
void StandbyReleaseOldLocks(TransactionId oldxid)
int headKnownAssignedXids
int xidComparator(const void *arg1, const void *arg2)
static uint32 pg_atomic_read_u32(volatile pg_atomic_uint32 *ptr)