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",
1225 "recovery snapshot waiting for non-overflowed snapshot or " 1226 "until oldest active xid on standby is at least %u (now %u)",
1267 for (i = 0; i < nsubxids; i++)
1382 (
errcode(ERRCODE_OUT_OF_MEMORY),
1383 errmsg(
"out of memory")));
1395 latestCompletedXid =
1407 for (
size_t pgxactoff = 0; pgxactoff <
numProcs; pgxactoff++)
1415 if (pgxactoff == mypgxactoff)
1444 pxids = other_subxidstates[pgxactoff].
count;
1446 pgprocno = arrayP->
pgprocnos[pgxactoff];
1447 proc = &allProcs[pgprocno];
1448 for (j = pxids - 1; j >= 0; j--)
1468 if (other_subxidstates[pgxactoff].overflowed)
1469 xids[nxids++] = pxid;
1533 for (
int i = 0;
i < nxids;
i++)
1554 bool result =
false;
1568 for (i = 0; i < arrayP->
numProcs; i++)
1571 PGPROC *proc = &allProcs[pgprocno];
1716 PGPROC *proc = &allProcs[pgprocno];
1920 if (rel == NULL || rel->
rd_rel->relisshared)
2028 uint64 curXactCompletionCount;
2068 snapshot->
copied =
false;
2117 bool suboverflowed =
false;
2122 uint64 curXactCompletionCount;
2127 Assert(snapshot != NULL);
2140 if (snapshot->
xip == NULL)
2148 if (snapshot->
xip == NULL)
2150 (
errcode(ERRCODE_OUT_OF_MEMORY),
2151 errmsg(
"out of memory")));
2155 if (snapshot->
subxip == NULL)
2157 (
errcode(ERRCODE_OUT_OF_MEMORY),
2158 errmsg(
"out of memory")));
2175 myxid = other_xids[mypgxactoff];
2207 for (
size_t pgxactoff = 0; pgxactoff <
numProcs; pgxactoff++)
2227 if (pgxactoff == mypgxactoff)
2250 statusFlags = allStatusFlags[pgxactoff];
2278 if (subxidStates[pgxactoff].overflowed)
2279 suboverflowed =
true;
2282 int nsubxids = subxidStates[pgxactoff].
count;
2286 int pgprocno = pgprocnos[pgxactoff];
2287 PGPROC *proc = &allProcs[pgprocno];
2291 memcpy(snapshot->
subxip + subcount,
2294 subcount += nsubxids;
2335 suboverflowed =
true;
2379 def_vis_xid = def_vis_xid_data;
2439 snapshot->
xmin = xmin;
2440 snapshot->
xmax = xmax;
2441 snapshot->
xcnt = count;
2454 snapshot->
copied =
false;
2475 bool result =
false;
2486 for (index = 0; index < arrayP->
numProcs; index++)
2488 int pgprocno = arrayP->
pgprocnos[index];
2489 PGPROC *proc = &allProcs[pgprocno];
2549 bool result =
false;
2637 if (CurrentRunningXacts->
xids == NULL)
2644 if (CurrentRunningXacts->
xids == NULL)
2646 (
errcode(ERRCODE_OUT_OF_MEMORY),
2647 errmsg(
"out of memory")));
2650 xids = CurrentRunningXacts->
xids;
2652 count = subcount = 0;
2653 suboverflowed =
false;
2662 latestCompletedXid =
2670 for (index = 0; index < arrayP->
numProcs; index++)
2690 oldestRunningXid = xid;
2693 suboverflowed =
true;
2703 xids[count++] = xid;
2714 for (index = 0; index < arrayP->
numProcs; index++)
2716 int pgprocno = arrayP->
pgprocnos[index];
2717 PGPROC *proc = &allProcs[pgprocno];
2724 nsubxids = other_subxidstates[index].
count;
2733 subcount += nsubxids;
2753 CurrentRunningXacts->
xcnt = count - subcount;
2754 CurrentRunningXacts->
subxcnt = subcount;
2766 return CurrentRunningXacts;
2809 for (index = 0; index < arrayP->
numProcs; index++)
2820 oldestRunningXid = xid;
2830 return oldestRunningXid;
2900 if (!recovery_in_progress)
2907 for (index = 0; index < arrayP->
numProcs; index++)
2918 oldestSafeXid = xid;
2924 return oldestSafeXid;
2959 for (index = 0; index < arrayP->
numProcs; index++)
2961 int pgprocno = arrayP->
pgprocnos[index];
2962 PGPROC *proc = &allProcs[pgprocno];
2970 vxids[count++] = vxid;
2992 bool result =
false;
2998 for (index = 0; index < arrayP->
numProcs; index++)
3000 int pgprocno = arrayP->
pgprocnos[index];
3001 PGPROC *proc = &allProcs[pgprocno];
3010 for (i = 0; i < nvxids; i++)
3068 for (index = 0; index < arrayP->
numProcs; index++)
3072 if (proc->
pid == pid)
3108 for (index = 0; index < arrayP->
numProcs; index++)
3110 int pgprocno = arrayP->
pgprocnos[index];
3111 PGPROC *proc = &allProcs[pgprocno];
3113 if (other_xids[index] == xid)
3165 bool allDbs,
int excludeVacuum,
3179 for (index = 0; index < arrayP->
numProcs; index++)
3181 int pgprocno = arrayP->
pgprocnos[index];
3182 PGPROC *proc = &allProcs[pgprocno];
3188 if (excludeVacuum & statusFlags)
3210 vxids[count++] = vxid;
3270 (
errcode(ERRCODE_OUT_OF_MEMORY),
3271 errmsg(
"out of memory")));
3276 for (index = 0; index < arrayP->
numProcs; index++)
3278 int pgprocno = arrayP->
pgprocnos[index];
3279 PGPROC *proc = &allProcs[pgprocno];
3306 vxids[count++] = vxid;
3333 bool conflictPending)
3341 for (index = 0; index < arrayP->
numProcs; index++)
3343 int pgprocno = arrayP->
pgprocnos[index];
3344 PGPROC *proc = &allProcs[pgprocno];
3396 for (index = 0; index < arrayP->
numProcs; index++)
3398 int pgprocno = arrayP->
pgprocnos[index];
3399 PGPROC *proc = &allProcs[pgprocno];
3427 return count >= min;
3442 for (index = 0; index < arrayP->
numProcs; index++)
3444 int pgprocno = arrayP->
pgprocnos[index];
3445 PGPROC *proc = &allProcs[pgprocno];
3472 for (index = 0; index < arrayP->
numProcs; index++)
3474 int pgprocno = arrayP->
pgprocnos[index];
3475 PGPROC *proc = &allProcs[pgprocno];
3503 for (index = 0; index < arrayP->
numProcs; index++)
3505 int pgprocno = arrayP->
pgprocnos[index];
3506 PGPROC *proc = &allProcs[pgprocno];
3543 for (index = 0; index < arrayP->
numProcs; index++)
3545 int pgprocno = arrayP->
pgprocnos[index];
3546 PGPROC *proc = &allProcs[pgprocno];
3552 if (proc->
roleId == roleid)
3589 #define MAXAUTOVACPIDS 10 3594 for (tries = 0; tries < 50; tries++)
3602 *nbackends = *nprepared = 0;
3606 for (index = 0; index < arrayP->
numProcs; index++)
3608 int pgprocno = arrayP->
pgprocnos[index];
3609 PGPROC *proc = &allProcs[pgprocno];
3626 autovac_pids[nautovacs++] = proc->
pid;
3641 for (index = 0; index < nautovacs; index++)
3642 (
void)
kill(autovac_pids[index], SIGTERM);
3672 for (i = 0; i < procArray->
numProcs; i++)
3675 PGPROC *proc = &allProcs[pgprocno];
3692 (
errcode(ERRCODE_OBJECT_IN_USE),
3693 errmsg(
"database \"%s\" is being used by prepared transactions",
3696 "There are %d prepared transactions using the database.",
3724 (
errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
3725 errmsg(
"must be a superuser to terminate superuser process")));
3731 (
errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
3732 errmsg(
"must be a member of the role whose process is being terminated or member of pg_signal_backend")));
3754 (void)
kill(-pid, SIGTERM);
3756 (void)
kill(pid, SIGTERM);
3772 bool already_locked)
3776 if (!already_locked)
3782 if (!already_locked)
3801 if (catalog_xmin != NULL)
3847 for (i = nxids - 1; i >= 0; i--)
3857 mysubxidstat->
count--;
3870 if (j < 0 && !MyProc->subxidStatus.overflowed)
3871 elog(
WARNING,
"did not find subXID %u in MyProc", anxid);
3880 mysubxidstat->
count--;
3886 if (j < 0 && !MyProc->subxidStatus.overflowed)
3887 elog(
WARNING,
"did not find subXID %u in MyProc", xid);
3895 #ifdef XIDCACHE_DEBUG 3901 DisplayXidCache(
void)
3904 "XidCache: xmin: %ld, known: %ld, myxact: %ld, latest: %ld, mainxid: %ld, childxid: %ld, knownassigned: %ld, nooflo: %ld, slow: %ld\n",
3911 xc_by_known_assigned,
3939 need_shared = need_catalog =
true;
3947 rel->
rd_rel->relkind == RELKIND_MATVIEW ||
3948 rel->
rd_rel->relkind == RELKIND_TOASTVALUE);
3956 else if (need_catalog)
4195 + (
int32) (xid - rel_xid));
4299 Assert(next_expected_xid == xid);
4502 int nelements = head - tail;
4514 for (i = tail; i < head; i++)
4541 bool exclusive_lock)
4557 if (to_xid >= from_xid)
4558 nxids = to_xid - from_xid + 1;
4562 next_xid = from_xid;
4578 Assert(tail >= 0 && tail < pArray->maxKnownAssignedXids);
4589 elog(
ERROR,
"out-of-order XID insertion in KnownAssignedXids");
4598 if (!exclusive_lock)
4606 if (!exclusive_lock)
4613 elog(
ERROR,
"too many KnownAssignedXids");
4617 next_xid = from_xid;
4618 for (i = 0; i < nxids; i++)
4665 int result_index = -1;
4688 while (first <= last)
4693 mid_index = (first + last) / 2;
4698 result_index = mid_index;
4702 last = mid_index - 1;
4704 first = mid_index + 1;
4707 if (result_index < 0)
4724 if (result_index == tail)
4798 for (i = 0; i < nsubxids; i++)
4837 for (i = tail; i < head; i++)
4860 for (i = tail; i < head; i++)
4926 for (i = tail; i < head; i++)
4950 xarray[count++] = knownXid;
4976 for (i = tail; i < head; i++)
5011 for (i = tail; i < head; i++)
5020 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 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 pgstat_report_wait_end(void)
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)
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)
bool GlobalVisIsRemovableFullXid(Relation rel, FullTransactionId fxid)
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]
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)
static void pgstat_report_wait_start(uint32 wait_event_info)
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)