#include "postgres.h"
#include <sys/stat.h>
#include <unistd.h>
#include "access/subtrans.h"
#include "access/transam.h"
#include "access/xact.h"
#include "access/xlog.h"
#include "catalog/catalog.h"
#include "datatype/timestamp.h"
#include "lib/pairingheap.h"
#include "miscadmin.h"
#include "storage/predicate.h"
#include "storage/proc.h"
#include "storage/procarray.h"
#include "storage/sinval.h"
#include "storage/sinvaladt.h"
#include "storage/spin.h"
#include "utils/builtins.h"
#include "utils/memutils.h"
#include "utils/old_snapshot.h"
#include "utils/rel.h"
#include "utils/resowner_private.h"
#include "utils/snapmgr.h"
#include "utils/syscache.h"
#include "utils/timestamp.h"

Include dependency graph for snapmgr.c:

Data Structures
struct	ActiveSnapshotElt

struct	ExportedSnapshot

struct	SerializedSnapshotData

Macros
#define	SNAPSHOT_EXPORT_DIR "pg_snapshots"

Typedefs
typedef struct ActiveSnapshotElt	ActiveSnapshotElt

typedef struct ExportedSnapshot	ExportedSnapshot

typedef struct SerializedSnapshotData	SerializedSnapshotData

Functions
static int	xmin_cmp (const pairingheap_node a, const pairingheap_node b, void *arg)

static TimestampTz	AlignTimestampToMinuteBoundary (TimestampTz ts)

static Snapshot	CopySnapshot (Snapshot snapshot)

static void	FreeSnapshot (Snapshot snapshot)

static void	SnapshotResetXmin (void)

Size	SnapMgrShmemSize (void)

void	SnapMgrInit (void)

Snapshot	GetTransactionSnapshot (void)

Snapshot	GetLatestSnapshot (void)

Snapshot	GetOldestSnapshot (void)

Snapshot	GetCatalogSnapshot (Oid relid)

Snapshot	GetNonHistoricCatalogSnapshot (Oid relid)

void	InvalidateCatalogSnapshot (void)

void	InvalidateCatalogSnapshotConditionally (void)

void	SnapshotSetCommandId (CommandId curcid)

static void	SetTransactionSnapshot (Snapshot sourcesnap, VirtualTransactionId sourcevxid, int sourcepid, PGPROC sourceproc)

void	PushActiveSnapshot (Snapshot snap)

void	PushCopiedSnapshot (Snapshot snapshot)

void	UpdateActiveSnapshotCommandId (void)

void	PopActiveSnapshot (void)

Snapshot	GetActiveSnapshot (void)

bool	ActiveSnapshotSet (void)

Snapshot	RegisterSnapshot (Snapshot snapshot)

Snapshot	RegisterSnapshotOnOwner (Snapshot snapshot, ResourceOwner owner)

void	UnregisterSnapshot (Snapshot snapshot)

void	UnregisterSnapshotFromOwner (Snapshot snapshot, ResourceOwner owner)

void	AtSubCommit_Snapshot (int level)

void	AtSubAbort_Snapshot (int level)

void	AtEOXact_Snapshot (bool isCommit, bool resetXmin)

char *	ExportSnapshot (Snapshot snapshot)

Datum	pg_export_snapshot (PG_FUNCTION_ARGS)

static int	parseIntFromText (const char prefix, char s, const char filename)

static TransactionId	parseXidFromText (const char prefix, char s, const char filename)

static void	parseVxidFromText (const char prefix, char s, const char filename, VirtualTransactionId *vxid)

void	ImportSnapshot (const char *idstr)

bool	XactHasExportedSnapshots (void)

void	DeleteAllExportedSnapshotFiles (void)

bool	ThereAreNoPriorRegisteredSnapshots (void)

TimestampTz	GetSnapshotCurrentTimestamp (void)

TimestampTz	GetOldSnapshotThresholdTimestamp (void)

void	SetOldSnapshotThresholdTimestamp (TimestampTz ts, TransactionId xlimit)

void	SnapshotTooOldMagicForTest (void)

static bool	GetOldSnapshotFromTimeMapping (TimestampTz ts, TransactionId *xlimitp)

bool	TransactionIdLimitedForOldSnapshots (TransactionId recentXmin, Relation relation, TransactionId limit_xid, TimestampTz limit_ts)

void	MaintainOldSnapshotTimeMapping (TimestampTz whenTaken, TransactionId xmin)

void	SetupHistoricSnapshot (Snapshot historic_snapshot, HTAB *tuplecids)

void	TeardownHistoricSnapshot (bool is_error)

bool	HistoricSnapshotActive (void)

HTAB *	HistoricSnapshotGetTupleCids (void)

Size	EstimateSnapshotSpace (Snapshot snap)

void	SerializeSnapshot (Snapshot snapshot, char *start_address)

Snapshot	RestoreSnapshot (char *start_address)

void	RestoreTransactionSnapshot (Snapshot snapshot, void *source_pgproc)

bool	XidInMVCCSnapshot (TransactionId xid, Snapshot snapshot)

Variables
int	old_snapshot_threshold

volatile OldSnapshotControlData *	oldSnapshotControl

static SnapshotData	CurrentSnapshotData = {SNAPSHOT_MVCC}

static SnapshotData	SecondarySnapshotData = {SNAPSHOT_MVCC}

SnapshotData	CatalogSnapshotData = {SNAPSHOT_MVCC}

SnapshotData	SnapshotSelfData = {SNAPSHOT_SELF}

SnapshotData	SnapshotAnyData = {SNAPSHOT_ANY}

static Snapshot	CurrentSnapshot = NULL

static Snapshot	SecondarySnapshot = NULL

static Snapshot	CatalogSnapshot = NULL

static Snapshot	HistoricSnapshot = NULL

TransactionId	TransactionXmin = FirstNormalTransactionId

TransactionId	RecentXmin = FirstNormalTransactionId

static HTAB *	tuplecid_data = NULL

static ActiveSnapshotElt *	ActiveSnapshot = NULL

static ActiveSnapshotElt *	OldestActiveSnapshot = NULL

static pairingheap	RegisteredSnapshots = {&xmin_cmp, NULL, NULL}

bool	FirstSnapshotSet = false

static Snapshot	FirstXactSnapshot = NULL

static List *	exportedSnapshots = NIL

Macro Definition Documentation

◆ SNAPSHOT_EXPORT_DIR

#define SNAPSHOT_EXPORT_DIR "pg_snapshots"

Definition at line 159 of file snapmgr.c.

Referenced by DeleteAllExportedSnapshotFiles(), ExportSnapshot(), and ImportSnapshot().

Typedef Documentation

◆ ActiveSnapshotElt

typedef struct ActiveSnapshotElt ActiveSnapshotElt

◆ ExportedSnapshot

typedef struct ExportedSnapshot ExportedSnapshot

◆ SerializedSnapshotData

typedef struct SerializedSnapshotData SerializedSnapshotData

Function Documentation

◆ ActiveSnapshotSet()

bool ActiveSnapshotSet ( void )

Definition at line 798 of file snapmgr.c.

Referenced by _SPI_commit(), _SPI_execute_plan(), BuildCachedPlan(), find_inheritance_children(), index_concurrently_build(), OldSnapshotThresholdActive(), pg_plan_query(), PortalRunUtility(), postquel_start(), RevalidateCachedQuery(), and vacuum().

 {
     return ActiveSnapshot != NULL;
 }

◆ AlignTimestampToMinuteBoundary()

static TimestampTz AlignTimestampToMinuteBoundary ( TimestampTz ts )

static

Definition at line 1621 of file snapmgr.c.

References USECS_PER_MINUTE.

Referenced by GetOldSnapshotFromTimeMapping(), MaintainOldSnapshotTimeMapping(), and TransactionIdLimitedForOldSnapshots().

 {
     TimestampTz retval = ts + (USECS_PER_MINUTE - 1);
 
     return retval - (retval % USECS_PER_MINUTE);
 }

◆ AtEOXact_Snapshot()

void AtEOXact_Snapshot	(	bool	isCommit,
		bool	resetXmin
	)

Definition at line 1006 of file snapmgr.c.

References ActiveSnapshotElt::as_next, Assert, elog, FirstSnapshotSet, InvalidateCatalogSnapshot(), lfirst, MyProc, NIL, pairingheap_is_empty, pairingheap_remove(), pairingheap_reset, SnapshotData::ph_node, SnapshotData::regd_count, ExportedSnapshot::snapfile, ExportedSnapshot::snapshot, SnapshotResetXmin(), WARNING, and PGPROC::xmin.

Referenced by CleanupTransaction(), CommitTransaction(), OldSnapshotThresholdActive(), and PrepareTransaction().

 {
     /*
      * In transaction-snapshot mode we must release our privately-managed
      * reference to the transaction snapshot.  We must remove it from
      * RegisteredSnapshots to keep the check below happy.  But we don't bother
      * to do FreeSnapshot, for two reasons: the memory will go away with
      * TopTransactionContext anyway, and if someone has left the snapshot
      * stacked as active, we don't want the code below to be chasing through a
      * dangling pointer.
      */
     if (FirstXactSnapshot != NULL)
     {
         Assert(FirstXactSnapshot->regd_count > 0);
         Assert(!pairingheap_is_empty(&RegisteredSnapshots));
         pairingheap_remove(&RegisteredSnapshots, &FirstXactSnapshot->ph_node);
     }
     FirstXactSnapshot = NULL;
 
     /*
      * If we exported any snapshots, clean them up.
      */
     if (exportedSnapshots != NIL)
     {
         ListCell   *lc;
 
         /*
          * Get rid of the files.  Unlink failure is only a WARNING because (1)
          * it's too late to abort the transaction, and (2) leaving a leaked
          * file around has little real consequence anyway.
          *
          * We also need to remove the snapshots from RegisteredSnapshots to
          * prevent a warning below.
          *
          * As with the FirstXactSnapshot, we don't need to free resources of
          * the snapshot itself as it will go away with the memory context.
          */
         foreach(lc, exportedSnapshots)
         {
             ExportedSnapshot *esnap = (ExportedSnapshot *) lfirst(lc);
 
             if (unlink(esnap->snapfile))
                 elog(WARNING, "could not unlink file \"%s\": %m",
                      esnap->snapfile);
 
             pairingheap_remove(&RegisteredSnapshots,
                                &esnap->snapshot->ph_node);
         }
 
         exportedSnapshots = NIL;
     }
 
     /* Drop catalog snapshot if any */
     InvalidateCatalogSnapshot();
 
     /* On commit, complain about leftover snapshots */
     if (isCommit)
     {
         ActiveSnapshotElt *active;
 
         if (!pairingheap_is_empty(&RegisteredSnapshots))
             elog(WARNING, "registered snapshots seem to remain after cleanup");
 
         /* complain about unpopped active snapshots */
         for (active = ActiveSnapshot; active != NULL; active = active->as_next)
             elog(WARNING, "snapshot %p still active", active);
     }
 
     /*
      * And reset our state.  We don't need to free the memory explicitly --
      * it'll go away with TopTransactionContext.
      */
     ActiveSnapshot = NULL;
     OldestActiveSnapshot = NULL;
     pairingheap_reset(&RegisteredSnapshots);
 
     CurrentSnapshot = NULL;
     SecondarySnapshot = NULL;
 
     FirstSnapshotSet = false;
 
     /*
      * During normal commit processing, we call ProcArrayEndTransaction() to
      * reset the MyProc->xmin. That call happens prior to the call to
      * AtEOXact_Snapshot(), so we need not touch xmin here at all.
      */
     if (resetXmin)
         SnapshotResetXmin();
 
     Assert(resetXmin || MyProc->xmin == 0);
 }

◆ AtSubAbort_Snapshot()

void AtSubAbort_Snapshot ( int level )

Definition at line 970 of file snapmgr.c.

References SnapshotData::active_count, ActiveSnapshotElt::as_level, ActiveSnapshotElt::as_next, ActiveSnapshotElt::as_snap, Assert, FreeSnapshot(), next, pfree(), SnapshotData::regd_count, and SnapshotResetXmin().

Referenced by AbortSubTransaction(), and OldSnapshotThresholdActive().

 {
     /* Forget the active snapshots set by this subtransaction */
     while (ActiveSnapshot && ActiveSnapshot->as_level >= level)
     {
         ActiveSnapshotElt *next;
 
         next = ActiveSnapshot->as_next;
 
         /*
          * Decrement the snapshot's active count.  If it's still registered or
          * marked as active by an outer subtransaction, we can't free it yet.
          */
         Assert(ActiveSnapshot->as_snap->active_count >= 1);
         ActiveSnapshot->as_snap->active_count -= 1;
 
         if (ActiveSnapshot->as_snap->active_count == 0 &&
             ActiveSnapshot->as_snap->regd_count == 0)
             FreeSnapshot(ActiveSnapshot->as_snap);
 
         /* and free the stack element */
         pfree(ActiveSnapshot);
 
         ActiveSnapshot = next;
         if (ActiveSnapshot == NULL)
             OldestActiveSnapshot = NULL;
     }
 
     SnapshotResetXmin();
 }

◆ AtSubCommit_Snapshot()

void AtSubCommit_Snapshot ( int level )

Definition at line 949 of file snapmgr.c.

References ActiveSnapshotElt::as_level, and ActiveSnapshotElt::as_next.

Referenced by CommitSubTransaction(), and OldSnapshotThresholdActive().

 {
     ActiveSnapshotElt *active;
 
     /*
      * Relabel the active snapshots set in this subtransaction as though they
      * are owned by the parent subxact.
      */
     for (active = ActiveSnapshot; active != NULL; active = active->as_next)
     {
         if (active->as_level < level)
             break;
         active->as_level = level - 1;
     }
 }

◆ CopySnapshot()

static Snapshot CopySnapshot ( Snapshot snapshot )

static

Definition at line 606 of file snapmgr.c.

References SnapshotData::active_count, Assert, SnapshotData::copied, InvalidSnapshot, MemoryContextAlloc(), SnapshotData::regd_count, SnapshotData::snapXactCompletionCount, SnapshotData::suboverflowed, SnapshotData::subxcnt, SnapshotData::subxip, SnapshotData::takenDuringRecovery, TopTransactionContext, SnapshotData::xcnt, and SnapshotData::xip.

Referenced by ExportSnapshot(), GetTransactionSnapshot(), PushActiveSnapshot(), PushCopiedSnapshot(), RegisterSnapshotOnOwner(), and SetTransactionSnapshot().

 {
     Snapshot    newsnap;
     Size        subxipoff;
     Size        size;
 
     Assert(snapshot != InvalidSnapshot);
 
     /* We allocate any XID arrays needed in the same palloc block. */
     size = subxipoff = sizeof(SnapshotData) +
         snapshot->xcnt * sizeof(TransactionId);
     if (snapshot->subxcnt > 0)
         size += snapshot->subxcnt * sizeof(TransactionId);
 
     newsnap = (Snapshot) MemoryContextAlloc(TopTransactionContext, size);
     memcpy(newsnap, snapshot, sizeof(SnapshotData));
 
     newsnap->regd_count = 0;
     newsnap->active_count = 0;
     newsnap->copied = true;
     newsnap->snapXactCompletionCount = 0;
 
     /* setup XID array */
     if (snapshot->xcnt > 0)
     {
         newsnap->xip = (TransactionId *) (newsnap + 1);
         memcpy(newsnap->xip, snapshot->xip,
                snapshot->xcnt * sizeof(TransactionId));
     }
     else
         newsnap->xip = NULL;
 
     /*
      * Setup subXID array. Don't bother to copy it if it had overflowed,
      * though, because it's not used anywhere in that case. Except if it's a
      * snapshot taken during recovery; all the top-level XIDs are in subxip as
      * well in that case, so we mustn't lose them.
      */
     if (snapshot->subxcnt > 0 &&
         (!snapshot->suboverflowed || snapshot->takenDuringRecovery))
     {
         newsnap->subxip = (TransactionId *) ((char *) newsnap + subxipoff);
         memcpy(newsnap->subxip, snapshot->subxip,
                snapshot->subxcnt * sizeof(TransactionId));
     }
     else
         newsnap->subxip = NULL;
 
     return newsnap;
 }

◆ DeleteAllExportedSnapshotFiles()

void DeleteAllExportedSnapshotFiles ( void )

Definition at line 1565 of file snapmgr.c.

References AllocateDir(), buf, dirent::d_name, ereport, errcode_for_file_access(), errmsg(), FreeDir(), LOG, MAXPGPATH, ReadDirExtended(), SNAPSHOT_EXPORT_DIR, and snprintf.

Referenced by OldSnapshotThresholdActive(), and StartupXLOG().

 {
     char        buf[MAXPGPATH + sizeof(SNAPSHOT_EXPORT_DIR)];
     DIR        *s_dir;
     struct dirent *s_de;
 
     /*
      * Problems in reading the directory, or unlinking files, are reported at
      * LOG level.  Since we're running in the startup process, ERROR level
      * would prevent database start, and it's not important enough for that.
      */
     s_dir = AllocateDir(SNAPSHOT_EXPORT_DIR);
 
     while ((s_de = ReadDirExtended(s_dir, SNAPSHOT_EXPORT_DIR, LOG)) != NULL)
     {
         if (strcmp(s_de->d_name, ".") == 0 ||
             strcmp(s_de->d_name, "..") == 0)
             continue;
 
         snprintf(buf, sizeof(buf), SNAPSHOT_EXPORT_DIR "/%s", s_de->d_name);
 
         if (unlink(buf) != 0)
             ereport(LOG,
                     (errcode_for_file_access(),
                      errmsg("could not remove file \"%s\": %m", buf)));
     }
 
     FreeDir(s_dir);
 }

◆ EstimateSnapshotSpace()

Size EstimateSnapshotSpace ( Snapshot snap )

Definition at line 2078 of file snapmgr.c.

References add_size(), Assert, InvalidSnapshot, mul_size(), SNAPSHOT_MVCC, SnapshotData::snapshot_type, SnapshotData::suboverflowed, SnapshotData::subxcnt, SnapshotData::takenDuringRecovery, and SnapshotData::xcnt.

Referenced by ExecBitmapHeapEstimate(), index_parallelscan_estimate(), index_parallelscan_initialize(), InitializeParallelDSM(), and table_parallelscan_estimate().

 {
     Size        size;
 
     Assert(snap != InvalidSnapshot);
     Assert(snap->snapshot_type == SNAPSHOT_MVCC);
 
     /* We allocate any XID arrays needed in the same palloc block. */
     size = add_size(sizeof(SerializedSnapshotData),
                     mul_size(snap->xcnt, sizeof(TransactionId)));
     if (snap->subxcnt > 0 &&
         (!snap->suboverflowed || snap->takenDuringRecovery))
         size = add_size(size,
                         mul_size(snap->subxcnt, sizeof(TransactionId)));
 
     return size;
 }

◆ ExportSnapshot()

char* ExportSnapshot ( Snapshot snapshot )

Definition at line 1106 of file snapmgr.c.

References AllocateFile(), appendStringInfo(), appendStringInfoString(), PGPROC::backendId, buf, CopySnapshot(), StringInfoData::data, ereport, errcode(), errcode_for_file_access(), errmsg(), ERROR, FreeFile(), GetMaxSnapshotSubxidCount(), GetTopTransactionIdIfAny(), i, initStringInfo(), IsSubTransaction(), lappend(), StringInfoData::len, list_length(), PGPROC::lxid, MAXPGPATH, MemoryContextSwitchTo(), MyDatabaseId, MyProc, MyProcPid, pairingheap_add(), palloc(), PG_BINARY_W, SnapshotData::ph_node, pstrdup(), SnapshotData::regd_count, ExportedSnapshot::snapfile, ExportedSnapshot::snapshot, SNAPSHOT_EXPORT_DIR, snprintf, SnapshotData::suboverflowed, SnapshotData::subxcnt, SnapshotData::subxip, SnapshotData::takenDuringRecovery, TopTransactionContext, TransactionIdIsValid, TransactionIdPrecedes(), xactGetCommittedChildren(), XactIsoLevel, XactReadOnly, SnapshotData::xcnt, SnapshotData::xip, SnapshotData::xmax, and SnapshotData::xmin.

Referenced by OldSnapshotThresholdActive(), pg_export_snapshot(), and SnapBuildExportSnapshot().

 {
     TransactionId topXid;
     TransactionId *children;
     ExportedSnapshot *esnap;
     int         nchildren;
     int         addTopXid;
     StringInfoData buf;
     FILE       *f;
     int         i;
     MemoryContext oldcxt;
     char        path[MAXPGPATH];
     char        pathtmp[MAXPGPATH];
 
     /*
      * It's tempting to call RequireTransactionBlock here, since it's not very
      * useful to export a snapshot that will disappear immediately afterwards.
      * However, we haven't got enough information to do that, since we don't
      * know if we're at top level or not.  For example, we could be inside a
      * plpgsql function that is going to fire off other transactions via
      * dblink.  Rather than disallow perfectly legitimate usages, don't make a
      * check.
      *
      * Also note that we don't make any restriction on the transaction's
      * isolation level; however, importers must check the level if they are
      * serializable.
      */
 
     /*
      * Get our transaction ID if there is one, to include in the snapshot.
      */
     topXid = GetTopTransactionIdIfAny();
 
     /*
      * We cannot export a snapshot from a subtransaction because there's no
      * easy way for importers to verify that the same subtransaction is still
      * running.
      */
     if (IsSubTransaction())
         ereport(ERROR,
                 (errcode(ERRCODE_ACTIVE_SQL_TRANSACTION),
                  errmsg("cannot export a snapshot from a subtransaction")));
 
     /*
      * We do however allow previous committed subtransactions to exist.
      * Importers of the snapshot must see them as still running, so get their
      * XIDs to add them to the snapshot.
      */
     nchildren = xactGetCommittedChildren(&children);
 
     /*
      * Generate file path for the snapshot.  We start numbering of snapshots
      * inside the transaction from 1.
      */
     snprintf(path, sizeof(path), SNAPSHOT_EXPORT_DIR "/%08X-%08X-%d",
              MyProc->backendId, MyProc->lxid, list_length(exportedSnapshots) + 1);
 
     /*
      * Copy the snapshot into TopTransactionContext, add it to the
      * exportedSnapshots list, and mark it pseudo-registered.  We do this to
      * ensure that the snapshot's xmin is honored for the rest of the
      * transaction.
      */
     snapshot = CopySnapshot(snapshot);
 
     oldcxt = MemoryContextSwitchTo(TopTransactionContext);
     esnap = (ExportedSnapshot *) palloc(sizeof(ExportedSnapshot));
     esnap->snapfile = pstrdup(path);
     esnap->snapshot = snapshot;
     exportedSnapshots = lappend(exportedSnapshots, esnap);
     MemoryContextSwitchTo(oldcxt);
 
     snapshot->regd_count++;
     pairingheap_add(&RegisteredSnapshots, &snapshot->ph_node);
 
     /*
      * Fill buf with a text serialization of the snapshot, plus identification
      * data about this transaction.  The format expected by ImportSnapshot is
      * pretty rigid: each line must be fieldname:value.
      */
     initStringInfo(&buf);
 
     appendStringInfo(&buf, "vxid:%d/%u\n", MyProc->backendId, MyProc->lxid);
     appendStringInfo(&buf, "pid:%d\n", MyProcPid);
     appendStringInfo(&buf, "dbid:%u\n", MyDatabaseId);
     appendStringInfo(&buf, "iso:%d\n", XactIsoLevel);
     appendStringInfo(&buf, "ro:%d\n", XactReadOnly);
 
     appendStringInfo(&buf, "xmin:%u\n", snapshot->xmin);
     appendStringInfo(&buf, "xmax:%u\n", snapshot->xmax);
 
     /*
      * We must include our own top transaction ID in the top-xid data, since
      * by definition we will still be running when the importing transaction
      * adopts the snapshot, but GetSnapshotData never includes our own XID in
      * the snapshot.  (There must, therefore, be enough room to add it.)
      *
      * However, it could be that our topXid is after the xmax, in which case
      * we shouldn't include it because xip[] members are expected to be before
      * xmax.  (We need not make the same check for subxip[] members, see
      * snapshot.h.)
      */
     addTopXid = (TransactionIdIsValid(topXid) &&
                  TransactionIdPrecedes(topXid, snapshot->xmax)) ? 1 : 0;
     appendStringInfo(&buf, "xcnt:%d\n", snapshot->xcnt + addTopXid);
     for (i = 0; i < snapshot->xcnt; i++)
         appendStringInfo(&buf, "xip:%u\n", snapshot->xip[i]);
     if (addTopXid)
         appendStringInfo(&buf, "xip:%u\n", topXid);
 
     /*
      * Similarly, we add our subcommitted child XIDs to the subxid data. Here,
      * we have to cope with possible overflow.
      */
     if (snapshot->suboverflowed ||
         snapshot->subxcnt + nchildren > GetMaxSnapshotSubxidCount())
         appendStringInfoString(&buf, "sof:1\n");
     else
     {
         appendStringInfoString(&buf, "sof:0\n");
         appendStringInfo(&buf, "sxcnt:%d\n", snapshot->subxcnt + nchildren);
         for (i = 0; i < snapshot->subxcnt; i++)
             appendStringInfo(&buf, "sxp:%u\n", snapshot->subxip[i]);
         for (i = 0; i < nchildren; i++)
             appendStringInfo(&buf, "sxp:%u\n", children[i]);
     }
     appendStringInfo(&buf, "rec:%u\n", snapshot->takenDuringRecovery);
 
     /*
      * Now write the text representation into a file.  We first write to a
      * ".tmp" filename, and rename to final filename if no error.  This
      * ensures that no other backend can read an incomplete file
      * (ImportSnapshot won't allow it because of its valid-characters check).
      */
     snprintf(pathtmp, sizeof(pathtmp), "%s.tmp", path);
     if (!(f = AllocateFile(pathtmp, PG_BINARY_W)))
         ereport(ERROR,
                 (errcode_for_file_access(),
                  errmsg("could not create file \"%s\": %m", pathtmp)));
 
     if (fwrite(buf.data, buf.len, 1, f) != 1)
         ereport(ERROR,
                 (errcode_for_file_access(),
                  errmsg("could not write to file \"%s\": %m", pathtmp)));
 
     /* no fsync() since file need not survive a system crash */
 
     if (FreeFile(f))
         ereport(ERROR,
                 (errcode_for_file_access(),
                  errmsg("could not write to file \"%s\": %m", pathtmp)));
 
     /*
      * Now that we have written everything into a .tmp file, rename the file
      * to remove the .tmp suffix.
      */
     if (rename(pathtmp, path) < 0)
         ereport(ERROR,
                 (errcode_for_file_access(),
                  errmsg("could not rename file \"%s\" to \"%s\": %m",
                         pathtmp, path)));
 
     /*
      * The basename of the file is what we return from pg_export_snapshot().
      * It's already in path in a textual format and we know that the path
      * starts with SNAPSHOT_EXPORT_DIR.  Skip over the prefix and the slash
      * and pstrdup it so as not to return the address of a local variable.
      */
     return pstrdup(path + strlen(SNAPSHOT_EXPORT_DIR) + 1);
 }

◆ FreeSnapshot()

static void FreeSnapshot ( Snapshot snapshot )

static

Definition at line 662 of file snapmgr.c.

References SnapshotData::active_count, Assert, SnapshotData::copied, pfree(), and SnapshotData::regd_count.

Referenced by AtSubAbort_Snapshot(), PopActiveSnapshot(), and UnregisterSnapshotFromOwner().

 {
     Assert(snapshot->regd_count == 0);
     Assert(snapshot->active_count == 0);
     Assert(snapshot->copied);
 
     pfree(snapshot);
 }

◆ GetActiveSnapshot()

Snapshot GetActiveSnapshot ( void )

Definition at line 786 of file snapmgr.c.

References ActiveSnapshotElt::as_snap, and Assert.

Referenced by _SPI_execute_plan(), ATExecDetachPartitionFinalize(), BeginCopyTo(), DoCopyTo(), ExecCreateTableAs(), ExecParallelGetQueryDesc(), execute_sql_string(), ExecuteQuery(), ExplainOnePlan(), find_inheritance_children(), InitializeParallelDSM(), inv_open(), OldSnapshotThresholdActive(), PerformCursorOpen(), pg_current_snapshot(), pg_export_snapshot(), pg_xact_status(), pgrowlocks(), PortalRunUtility(), PortalStart(), postquel_start(), ProcessQuery(), refresh_matview_datafill(), spgvacuumscan(), and SPI_cursor_open_internal().

 {
     Assert(ActiveSnapshot != NULL);
 
     return ActiveSnapshot->as_snap;
 }

◆ GetCatalogSnapshot()

Snapshot GetCatalogSnapshot ( Oid relid )

Definition at line 386 of file snapmgr.c.

References GetNonHistoricCatalogSnapshot(), HistoricSnapshot, and HistoricSnapshotActive().

Referenced by OldSnapshotThresholdActive(), process_settings(), systable_beginscan(), systable_beginscan_ordered(), systable_recheck_tuple(), and table_beginscan_catalog().

 {
     /*
      * Return historic snapshot while we're doing logical decoding, so we can
      * see the appropriate state of the catalog.
      *
      * This is the primary reason for needing to reset the system caches after
      * finishing decoding.
      */
     if (HistoricSnapshotActive())
         return HistoricSnapshot;
 
     return GetNonHistoricCatalogSnapshot(relid);
 }

◆ GetLatestSnapshot()

Snapshot GetLatestSnapshot ( void )

Definition at line 325 of file snapmgr.c.

References Assert, elog, ERROR, FirstSnapshotSet, GetSnapshotData(), GetTransactionSnapshot(), HistoricSnapshotActive(), IsInParallelMode(), and SecondarySnapshot.

Referenced by AlterDomainNotNull(), asyncQueueReadAllNotifications(), ATRewriteTable(), check_default_partition_contents(), currtid_internal(), DefineQueryRewrite(), IndexCheckExclusion(), OldSnapshotThresholdActive(), pgstat_collect_oids(), RelationFindReplTupleByIndex(), RelationFindReplTupleSeq(), RI_Initial_Check(), RI_PartitionRemove_Check(), ri_PerformCheck(), validateDomainConstraint(), and validateForeignKeyConstraint().

 {
     /*
      * We might be able to relax this, but nothing that could otherwise work
      * needs it.
      */
     if (IsInParallelMode())
         elog(ERROR,
              "cannot update SecondarySnapshot during a parallel operation");
 
     /*
      * So far there are no cases requiring support for GetLatestSnapshot()
      * during logical decoding, but it wouldn't be hard to add if required.
      */
     Assert(!HistoricSnapshotActive());
 
     /* If first call in transaction, go ahead and set the xact snapshot */
     if (!FirstSnapshotSet)
         return GetTransactionSnapshot();
 
     SecondarySnapshot = GetSnapshotData(&SecondarySnapshotData);
 
     return SecondarySnapshot;
 }

◆ GetNonHistoricCatalogSnapshot()

Snapshot GetNonHistoricCatalogSnapshot ( Oid relid )

Definition at line 408 of file snapmgr.c.

References CatalogSnapshot, GetSnapshotData(), InvalidateCatalogSnapshot(), pairingheap_add(), SnapshotData::ph_node, RelationHasSysCache(), and RelationInvalidatesSnapshotsOnly().

Referenced by GetCatalogSnapshot(), OldSnapshotThresholdActive(), and ScanPgRelation().

 {
     /*
      * If the caller is trying to scan a relation that has no syscache, no
      * catcache invalidations will be sent when it is updated.  For a few key
      * relations, snapshot invalidations are sent instead.  If we're trying to
      * scan a relation for which neither catcache nor snapshot invalidations
      * are sent, we must refresh the snapshot every time.
      */
     if (CatalogSnapshot &&
         !RelationInvalidatesSnapshotsOnly(relid) &&
         !RelationHasSysCache(relid))
         InvalidateCatalogSnapshot();
 
     if (CatalogSnapshot == NULL)
     {
         /* Get new snapshot. */
         CatalogSnapshot = GetSnapshotData(&CatalogSnapshotData);
 
         /*
          * Make sure the catalog snapshot will be accounted for in decisions
          * about advancing PGPROC->xmin.  We could apply RegisterSnapshot, but
          * that would result in making a physical copy, which is overkill; and
          * it would also create a dependency on some resource owner, which we
          * do not want for reasons explained at the head of this file. Instead
          * just shove the CatalogSnapshot into the pairing heap manually. This
          * has to be reversed in InvalidateCatalogSnapshot, of course.
          *
          * NB: it had better be impossible for this to throw error, since the
          * CatalogSnapshot pointer is already valid.
          */
         pairingheap_add(&RegisteredSnapshots, &CatalogSnapshot->ph_node);
     }
 
     return CatalogSnapshot;
 }

◆ GetOldestSnapshot()

Snapshot GetOldestSnapshot ( void )

Definition at line 357 of file snapmgr.c.

References ActiveSnapshotElt::as_snap, InvalidXLogRecPtr, SnapshotData::lsn, pairingheap_container, pairingheap_first(), pairingheap_is_empty, and XLogRecPtrIsInvalid.

Referenced by init_toast_snapshot(), and OldSnapshotThresholdActive().

 {
     Snapshot    OldestRegisteredSnapshot = NULL;
     XLogRecPtr  RegisteredLSN = InvalidXLogRecPtr;
 
     if (!pairingheap_is_empty(&RegisteredSnapshots))
     {
         OldestRegisteredSnapshot = pairingheap_container(SnapshotData, ph_node,
                                                          pairingheap_first(&RegisteredSnapshots));
         RegisteredLSN = OldestRegisteredSnapshot->lsn;
     }
 
     if (OldestActiveSnapshot != NULL)
     {
         XLogRecPtr  ActiveLSN = OldestActiveSnapshot->as_snap->lsn;
 
         if (XLogRecPtrIsInvalid(RegisteredLSN) || RegisteredLSN > ActiveLSN)
             return OldestActiveSnapshot->as_snap;
     }
 
     return OldestRegisteredSnapshot;
 }

◆ GetOldSnapshotFromTimeMapping()

static bool GetOldSnapshotFromTimeMapping	(	TimestampTz	ts,
		TransactionId *	xlimitp
	)

static

Definition at line 1707 of file snapmgr.c.

References AlignTimestampToMinuteBoundary(), Assert, OldSnapshotControlData::count_used, OldSnapshotControlData::head_offset, OldSnapshotControlData::head_timestamp, LW_SHARED, LWLockAcquire(), LWLockRelease(), OLD_SNAPSHOT_TIME_MAP_ENTRIES, USECS_PER_MINUTE, and OldSnapshotControlData::xid_by_minute.

Referenced by TransactionIdLimitedForOldSnapshots().

 {
     bool        in_mapping = false;
 
     Assert(ts == AlignTimestampToMinuteBoundary(ts));
 
     LWLockAcquire(OldSnapshotTimeMapLock, LW_SHARED);
 
     if (oldSnapshotControl->count_used > 0
         && ts >= oldSnapshotControl->head_timestamp)
     {
         int         offset;
 
         offset = ((ts - oldSnapshotControl->head_timestamp)
                   / USECS_PER_MINUTE);
         if (offset > oldSnapshotControl->count_used - 1)
             offset = oldSnapshotControl->count_used - 1;
         offset = (oldSnapshotControl->head_offset + offset)
             % OLD_SNAPSHOT_TIME_MAP_ENTRIES;
 
         *xlimitp = oldSnapshotControl->xid_by_minute[offset];
 
         in_mapping = true;
     }
 
     LWLockRelease(OldSnapshotTimeMapLock);
 
     return in_mapping;
 }

◆ GetOldSnapshotThresholdTimestamp()

TimestampTz GetOldSnapshotThresholdTimestamp ( void )

Definition at line 1660 of file snapmgr.c.

References OldSnapshotControlData::mutex_threshold, SpinLockAcquire, SpinLockRelease, and OldSnapshotControlData::threshold_timestamp.

Referenced by TestForOldSnapshot_impl().

 {
     TimestampTz threshold_timestamp;
 
     SpinLockAcquire(&oldSnapshotControl->mutex_threshold);
     threshold_timestamp = oldSnapshotControl->threshold_timestamp;
     SpinLockRelease(&oldSnapshotControl->mutex_threshold);
 
     return threshold_timestamp;
 }

◆ GetSnapshotCurrentTimestamp()

TimestampTz GetSnapshotCurrentTimestamp ( void )

Definition at line 1635 of file snapmgr.c.

References OldSnapshotControlData::current_timestamp, GetCurrentTimestamp(), OldSnapshotControlData::mutex_current, now(), SpinLockAcquire, and SpinLockRelease.

Referenced by GetSnapshotDataInitOldSnapshot(), SnapshotTooOldMagicForTest(), and TransactionIdLimitedForOldSnapshots().

 {
     TimestampTz now = GetCurrentTimestamp();
 
     /*
      * Don't let time move backward; if it hasn't advanced, use the old value.
      */
     SpinLockAcquire(&oldSnapshotControl->mutex_current);
     if (now <= oldSnapshotControl->current_timestamp)
         now = oldSnapshotControl->current_timestamp;
     else
         oldSnapshotControl->current_timestamp = now;
     SpinLockRelease(&oldSnapshotControl->mutex_current);
 
     return now;
 }

◆ GetTransactionSnapshot()

Snapshot GetTransactionSnapshot ( void )

Definition at line 250 of file snapmgr.c.

References Assert, CopySnapshot(), CurrentSnapshot, elog, ERROR, FirstSnapshotSet, GetSerializableTransactionSnapshot(), GetSnapshotData(), HistoricSnapshot, HistoricSnapshotActive(), InvalidateCatalogSnapshot(), IsInParallelMode(), IsolationIsSerializable, IsolationUsesXactSnapshot, pairingheap_add(), pairingheap_is_empty, SnapshotData::ph_node, and SnapshotData::regd_count.

Referenced by _bt_begin_parallel(), _SPI_execute_plan(), AfterTriggerFireDeferred(), AfterTriggerSetState(), apply_handle_delete(), apply_handle_insert(), apply_handle_update(), bt_check_every_level(), BuildCachedPlan(), CheckTargetForConflictsIn(), cluster(), DefineIndex(), exec_bind_message(), exec_eval_simple_expr(), exec_parse_message(), exec_simple_query(), exec_stmt_call(), execute_sql_string(), fmgr_sql(), get_database_list(), get_subscription_list(), GetLatestSnapshot(), HandleFunctionRequest(), heapam_index_build_range_scan(), initialize_worker_spi(), InitializeParallelDSM(), InitPostgres(), LogicalRepSyncTableStart(), OldSnapshotThresholdActive(), pg_get_constraintdef_worker(), PortalRunMulti(), PortalRunUtility(), PortalStart(), ReindexMultipleInternal(), ReindexRelationConcurrently(), RememberToFreeTupleDescAtEOX(), RevalidateCachedQuery(), ri_PerformCheck(), SPI_cursor_open_internal(), vacuum(), vacuum_rel(), verify_heapam(), and XidIsConcurrent().

 {
     /*
      * Return historic snapshot if doing logical decoding. We'll never need a
      * non-historic transaction snapshot in this (sub-)transaction, so there's
      * no need to be careful to set one up for later calls to
      * GetTransactionSnapshot().
      */
     if (HistoricSnapshotActive())
     {
         Assert(!FirstSnapshotSet);
         return HistoricSnapshot;
     }
 
     /* First call in transaction? */
     if (!FirstSnapshotSet)
     {
         /*
          * Don't allow catalog snapshot to be older than xact snapshot.  Must
          * do this first to allow the empty-heap Assert to succeed.
          */
         InvalidateCatalogSnapshot();
 
         Assert(pairingheap_is_empty(&RegisteredSnapshots));
         Assert(FirstXactSnapshot == NULL);
 
         if (IsInParallelMode())
             elog(ERROR,
                  "cannot take query snapshot during a parallel operation");
 
         /*
          * In transaction-snapshot mode, the first snapshot must live until
          * end of xact regardless of what the caller does with it, so we must
          * make a copy of it rather than returning CurrentSnapshotData
          * directly.  Furthermore, if we're running in serializable mode,
          * predicate.c needs to wrap the snapshot fetch in its own processing.
          */
         if (IsolationUsesXactSnapshot())
         {
             /* First, create the snapshot in CurrentSnapshotData */
             if (IsolationIsSerializable())
                 CurrentSnapshot = GetSerializableTransactionSnapshot(&CurrentSnapshotData);
             else
                 CurrentSnapshot = GetSnapshotData(&CurrentSnapshotData);
             /* Make a saved copy */
             CurrentSnapshot = CopySnapshot(CurrentSnapshot);
             FirstXactSnapshot = CurrentSnapshot;
             /* Mark it as "registered" in FirstXactSnapshot */
             FirstXactSnapshot->regd_count++;
             pairingheap_add(&RegisteredSnapshots, &FirstXactSnapshot->ph_node);
         }
         else
             CurrentSnapshot = GetSnapshotData(&CurrentSnapshotData);
 
         FirstSnapshotSet = true;
         return CurrentSnapshot;
     }
 
     if (IsolationUsesXactSnapshot())
         return CurrentSnapshot;
 
     /* Don't allow catalog snapshot to be older than xact snapshot. */
     InvalidateCatalogSnapshot();
 
     CurrentSnapshot = GetSnapshotData(&CurrentSnapshotData);
 
     return CurrentSnapshot;
 }

◆ HistoricSnapshotActive()

bool HistoricSnapshotActive ( void )

Definition at line 2058 of file snapmgr.c.

Referenced by GetCatalogSnapshot(), GetLatestSnapshot(), GetTransactionSnapshot(), HistoricSnapshotGetTupleCids(), RelationClearRelation(), RelationInitPhysicalAddr(), and SetTransactionSnapshot().

 {
     return HistoricSnapshot != NULL;
 }

◆ HistoricSnapshotGetTupleCids()

HTAB* HistoricSnapshotGetTupleCids ( void )

Definition at line 2064 of file snapmgr.c.

References Assert, HistoricSnapshotActive(), and tuplecid_data.

Referenced by HeapTupleSatisfiesHistoricMVCC().

 {
     Assert(HistoricSnapshotActive());
     return tuplecid_data;
 }

◆ ImportSnapshot()

void ImportSnapshot ( const char * idstr )

Definition at line 1377 of file snapmgr.c.

References AllocateFile(), elog, ereport, errcode(), errmsg(), ERROR, FirstSnapshotSet, FreeFile(), fstat, GetMaxSnapshotSubxidCount(), GetMaxSnapshotXidCount(), GetTopTransactionIdIfAny(), i, InvalidTransactionId, IsolationIsSerializable, IsolationUsesXactSnapshot, IsSubTransaction(), MAXPGPATH, MyDatabaseId, OidIsValid, palloc(), parseIntFromText(), parseVxidFromText(), parseXidFromText(), PG_BINARY_R, SetTransactionSnapshot(), SNAPSHOT_EXPORT_DIR, SNAPSHOT_MVCC, SnapshotData::snapshot_type, snprintf, stat::st_size, SnapshotData::suboverflowed, SnapshotData::subxcnt, SnapshotData::subxip, SnapshotData::takenDuringRecovery, TransactionIdIsNormal, VirtualTransactionIdIsValid, XACT_SERIALIZABLE, XactReadOnly, SnapshotData::xcnt, SnapshotData::xip, SnapshotData::xmax, and SnapshotData::xmin.

Referenced by ExecSetVariableStmt(), and OldSnapshotThresholdActive().

 {
     char        path[MAXPGPATH];
     FILE       *f;
     struct stat stat_buf;
     char       *filebuf;
     int         xcnt;
     int         i;
     VirtualTransactionId src_vxid;
     int         src_pid;
     Oid         src_dbid;
     int         src_isolevel;
     bool        src_readonly;
     SnapshotData snapshot;
 
     /*
      * Must be at top level of a fresh transaction.  Note in particular that
      * we check we haven't acquired an XID --- if we have, it's conceivable
      * that the snapshot would show it as not running, making for very screwy
      * behavior.
      */
     if (FirstSnapshotSet ||
         GetTopTransactionIdIfAny() != InvalidTransactionId ||
         IsSubTransaction())
         ereport(ERROR,
                 (errcode(ERRCODE_ACTIVE_SQL_TRANSACTION),
                  errmsg("SET TRANSACTION SNAPSHOT must be called before any query")));
 
     /*
      * If we are in read committed mode then the next query would execute with
      * a new snapshot thus making this function call quite useless.
      */
     if (!IsolationUsesXactSnapshot())
         ereport(ERROR,
                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                  errmsg("a snapshot-importing transaction must have isolation level SERIALIZABLE or REPEATABLE READ")));
 
     /*
      * Verify the identifier: only 0-9, A-F and hyphens are allowed.  We do
      * this mainly to prevent reading arbitrary files.
      */
     if (strspn(idstr, "0123456789ABCDEF-") != strlen(idstr))
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                  errmsg("invalid snapshot identifier: \"%s\"", idstr)));
 
     /* OK, read the file */
     snprintf(path, MAXPGPATH, SNAPSHOT_EXPORT_DIR "/%s", idstr);
 
     f = AllocateFile(path, PG_BINARY_R);
     if (!f)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                  errmsg("invalid snapshot identifier: \"%s\"", idstr)));
 
     /* get the size of the file so that we know how much memory we need */
     if (fstat(fileno(f), &stat_buf))
         elog(ERROR, "could not stat file \"%s\": %m", path);
 
     /* and read the file into a palloc'd string */
     filebuf = (char *) palloc(stat_buf.st_size + 1);
     if (fread(filebuf, stat_buf.st_size, 1, f) != 1)
         elog(ERROR, "could not read file \"%s\": %m", path);
 
     filebuf[stat_buf.st_size] = '\0';
 
     FreeFile(f);
 
     /*
      * Construct a snapshot struct by parsing the file content.
      */
     memset(&snapshot, 0, sizeof(snapshot));
 
     parseVxidFromText("vxid:", &filebuf, path, &src_vxid);
     src_pid = parseIntFromText("pid:", &filebuf, path);
     /* we abuse parseXidFromText a bit here ... */
     src_dbid = parseXidFromText("dbid:", &filebuf, path);
     src_isolevel = parseIntFromText("iso:", &filebuf, path);
     src_readonly = parseIntFromText("ro:", &filebuf, path);
 
     snapshot.snapshot_type = SNAPSHOT_MVCC;
 
     snapshot.xmin = parseXidFromText("xmin:", &filebuf, path);
     snapshot.xmax = parseXidFromText("xmax:", &filebuf, path);
 
     snapshot.xcnt = xcnt = parseIntFromText("xcnt:", &filebuf, path);
 
     /* sanity-check the xid count before palloc */
     if (xcnt < 0 || xcnt > GetMaxSnapshotXidCount())
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                  errmsg("invalid snapshot data in file \"%s\"", path)));
 
     snapshot.xip = (TransactionId *) palloc(xcnt * sizeof(TransactionId));
     for (i = 0; i < xcnt; i++)
         snapshot.xip[i] = parseXidFromText("xip:", &filebuf, path);
 
     snapshot.suboverflowed = parseIntFromText("sof:", &filebuf, path);
 
     if (!snapshot.suboverflowed)
     {
         snapshot.subxcnt = xcnt = parseIntFromText("sxcnt:", &filebuf, path);
 
         /* sanity-check the xid count before palloc */
         if (xcnt < 0 || xcnt > GetMaxSnapshotSubxidCount())
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                      errmsg("invalid snapshot data in file \"%s\"", path)));
 
         snapshot.subxip = (TransactionId *) palloc(xcnt * sizeof(TransactionId));
         for (i = 0; i < xcnt; i++)
             snapshot.subxip[i] = parseXidFromText("sxp:", &filebuf, path);
     }
     else
     {
         snapshot.subxcnt = 0;
         snapshot.subxip = NULL;
     }
 
     snapshot.takenDuringRecovery = parseIntFromText("rec:", &filebuf, path);
 
     /*
      * Do some additional sanity checking, just to protect ourselves.  We
      * don't trouble to check the array elements, just the most critical
      * fields.
      */
     if (!VirtualTransactionIdIsValid(src_vxid) ||
         !OidIsValid(src_dbid) ||
         !TransactionIdIsNormal(snapshot.xmin) ||
         !TransactionIdIsNormal(snapshot.xmax))
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                  errmsg("invalid snapshot data in file \"%s\"", path)));
 
     /*
      * If we're serializable, the source transaction must be too, otherwise
      * predicate.c has problems (SxactGlobalXmin could go backwards).  Also, a
      * non-read-only transaction can't adopt a snapshot from a read-only
      * transaction, as predicate.c handles the cases very differently.
      */
     if (IsolationIsSerializable())
     {
         if (src_isolevel != XACT_SERIALIZABLE)
             ereport(ERROR,
                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                      errmsg("a serializable transaction cannot import a snapshot from a non-serializable transaction")));
         if (src_readonly && !XactReadOnly)
             ereport(ERROR,
                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                      errmsg("a non-read-only serializable transaction cannot import a snapshot from a read-only transaction")));
     }
 
     /*
      * We cannot import a snapshot that was taken in a different database,
      * because vacuum calculates OldestXmin on a per-database basis; so the
      * source transaction's xmin doesn't protect us from data loss.  This
      * restriction could be removed if the source transaction were to mark its
      * xmin as being globally applicable.  But that would require some
      * additional syntax, since that has to be known when the snapshot is
      * initially taken.  (See pgsql-hackers discussion of 2011-10-21.)
      */
     if (src_dbid != MyDatabaseId)
         ereport(ERROR,
                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                  errmsg("cannot import a snapshot from a different database")));
 
     /* OK, install the snapshot */
     SetTransactionSnapshot(&snapshot, &src_vxid, src_pid, NULL);
 }

◆ InvalidateCatalogSnapshot()

void InvalidateCatalogSnapshot ( void )

Definition at line 456 of file snapmgr.c.

References pairingheap_remove(), SnapshotData::ph_node, and SnapshotResetXmin().

Referenced by AtEOXact_Snapshot(), CopyFrom(), GetNonHistoricCatalogSnapshot(), GetTransactionSnapshot(), InitPostgres(), InvalidateCatalogSnapshotConditionally(), InvalidateSystemCaches(), LocalExecuteInvalidationMessage(), OldSnapshotThresholdActive(), SetTransactionSnapshot(), and wait_for_relation_state_change().

 {
     if (CatalogSnapshot)
     {
         pairingheap_remove(&RegisteredSnapshots, &CatalogSnapshot->ph_node);
         CatalogSnapshot = NULL;
         SnapshotResetXmin();
     }
 }

◆ InvalidateCatalogSnapshotConditionally()

void InvalidateCatalogSnapshotConditionally ( void )

Definition at line 477 of file snapmgr.c.

References InvalidateCatalogSnapshot(), and pairingheap_is_singular.

Referenced by OldSnapshotThresholdActive(), and PostgresMain().

 {
     if (CatalogSnapshot &&
         ActiveSnapshot == NULL &&
         pairingheap_is_singular(&RegisteredSnapshots))
         InvalidateCatalogSnapshot();
 }

◆ MaintainOldSnapshotTimeMapping()

void MaintainOldSnapshotTimeMapping	(	TimestampTz	whenTaken,
		TransactionId	xmin
	)

Definition at line 1858 of file snapmgr.c.

References AlignTimestampToMinuteBoundary(), Assert, OldSnapshotControlData::count_used, DEBUG1, elog, OldSnapshotControlData::head_offset, OldSnapshotControlData::head_timestamp, i, OldSnapshotControlData::latest_xmin, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), OldSnapshotControlData::mutex_latest_xmin, OldSnapshotControlData::next_map_update, old_snapshot_threshold, OLD_SNAPSHOT_TIME_MAP_ENTRIES, SpinLockAcquire, SpinLockRelease, TransactionIdFollows(), TransactionIdIsNormal, TransactionIdPrecedes(), USECS_PER_MINUTE, and OldSnapshotControlData::xid_by_minute.

Referenced by GetSnapshotDataInitOldSnapshot(), and OldSnapshotThresholdActive().

 {
     TimestampTz ts;
     TransactionId latest_xmin;
     TimestampTz update_ts;
     bool        map_update_required = false;
 
     /* Never call this function when old snapshot checking is disabled. */
     Assert(old_snapshot_threshold >= 0);
 
     ts = AlignTimestampToMinuteBoundary(whenTaken);
 
     /*
      * Keep track of the latest xmin seen by any process. Update mapping with
      * a new value when we have crossed a bucket boundary.
      */
     SpinLockAcquire(&oldSnapshotControl->mutex_latest_xmin);
     latest_xmin = oldSnapshotControl->latest_xmin;
     update_ts = oldSnapshotControl->next_map_update;
     if (ts > update_ts)
     {
         oldSnapshotControl->next_map_update = ts;
         map_update_required = true;
     }
     if (TransactionIdFollows(xmin, latest_xmin))
         oldSnapshotControl->latest_xmin = xmin;
     SpinLockRelease(&oldSnapshotControl->mutex_latest_xmin);
 
     /* We only needed to update the most recent xmin value. */
     if (!map_update_required)
         return;
 
     /* No further tracking needed for 0 (used for testing). */
     if (old_snapshot_threshold == 0)
         return;
 
     /*
      * We don't want to do something stupid with unusual values, but we don't
      * want to litter the log with warnings or break otherwise normal
      * processing for this feature; so if something seems unreasonable, just
      * log at DEBUG level and return without doing anything.
      */
     if (whenTaken < 0)
     {
         elog(DEBUG1,
              "MaintainOldSnapshotTimeMapping called with negative whenTaken = %ld",
              (long) whenTaken);
         return;
     }
     if (!TransactionIdIsNormal(xmin))
     {
         elog(DEBUG1,
              "MaintainOldSnapshotTimeMapping called with xmin = %lu",
              (unsigned long) xmin);
         return;
     }
 
     LWLockAcquire(OldSnapshotTimeMapLock, LW_EXCLUSIVE);
 
     Assert(oldSnapshotControl->head_offset >= 0);
     Assert(oldSnapshotControl->head_offset < OLD_SNAPSHOT_TIME_MAP_ENTRIES);
     Assert((oldSnapshotControl->head_timestamp % USECS_PER_MINUTE) == 0);
     Assert(oldSnapshotControl->count_used >= 0);
     Assert(oldSnapshotControl->count_used <= OLD_SNAPSHOT_TIME_MAP_ENTRIES);
 
     if (oldSnapshotControl->count_used == 0)
     {
         /* set up first entry for empty mapping */
         oldSnapshotControl->head_offset = 0;
         oldSnapshotControl->head_timestamp = ts;
         oldSnapshotControl->count_used = 1;
         oldSnapshotControl->xid_by_minute[0] = xmin;
     }
     else if (ts < oldSnapshotControl->head_timestamp)
     {
         /* old ts; log it at DEBUG */
         LWLockRelease(OldSnapshotTimeMapLock);
         elog(DEBUG1,
              "MaintainOldSnapshotTimeMapping called with old whenTaken = %ld",
              (long) whenTaken);
         return;
     }
     else if (ts <= (oldSnapshotControl->head_timestamp +
                     ((oldSnapshotControl->count_used - 1)
                      * USECS_PER_MINUTE)))
     {
         /* existing mapping; advance xid if possible */
         int         bucket = (oldSnapshotControl->head_offset
                               + ((ts - oldSnapshotControl->head_timestamp)
                                  / USECS_PER_MINUTE))
         % OLD_SNAPSHOT_TIME_MAP_ENTRIES;
 
         if (TransactionIdPrecedes(oldSnapshotControl->xid_by_minute[bucket], xmin))
             oldSnapshotControl->xid_by_minute[bucket] = xmin;
     }
     else
     {
         /* We need a new bucket, but it might not be the very next one. */
         int         distance_to_new_tail;
         int         distance_to_current_tail;
         int         advance;
 
         /*
          * Our goal is for the new "tail" of the mapping, that is, the entry
          * which is newest and thus furthest from the "head" entry, to
          * correspond to "ts". Since there's one entry per minute, the
          * distance between the current head and the new tail is just the
          * number of minutes of difference between ts and the current
          * head_timestamp.
          *
          * The distance from the current head to the current tail is one
          * less than the number of entries in the mapping, because the
          * entry at the head_offset is for 0 minutes after head_timestamp.
          *
          * The difference between these two values is the number of minutes
          * by which we need to advance the mapping, either adding new entries
          * or rotating old ones out.
          */
         distance_to_new_tail =
             (ts - oldSnapshotControl->head_timestamp) / USECS_PER_MINUTE;
         distance_to_current_tail =
             oldSnapshotControl->count_used - 1;
         advance = distance_to_new_tail - distance_to_current_tail;
         Assert(advance > 0);
 
         if (advance >= OLD_SNAPSHOT_TIME_MAP_ENTRIES)
         {
             /* Advance is so far that all old data is junk; start over. */
             oldSnapshotControl->head_offset = 0;
             oldSnapshotControl->count_used = 1;
             oldSnapshotControl->xid_by_minute[0] = xmin;
             oldSnapshotControl->head_timestamp = ts;
         }
         else
         {
             /* Store the new value in one or more buckets. */
             int         i;
 
             for (i = 0; i < advance; i++)
             {
                 if (oldSnapshotControl->count_used == OLD_SNAPSHOT_TIME_MAP_ENTRIES)
                 {
                     /* Map full and new value replaces old head. */
                     int         old_head = oldSnapshotControl->head_offset;
 
                     if (old_head == (OLD_SNAPSHOT_TIME_MAP_ENTRIES - 1))
                         oldSnapshotControl->head_offset = 0;
                     else
                         oldSnapshotControl->head_offset = old_head + 1;
                     oldSnapshotControl->xid_by_minute[old_head] = xmin;
                     oldSnapshotControl->head_timestamp += USECS_PER_MINUTE;
                 }
                 else
                 {
                     /* Extend map to unused entry. */
                     int         new_tail = (oldSnapshotControl->head_offset
                                             + oldSnapshotControl->count_used)
                     % OLD_SNAPSHOT_TIME_MAP_ENTRIES;
 
                     oldSnapshotControl->count_used++;
                     oldSnapshotControl->xid_by_minute[new_tail] = xmin;
                 }
             }
         }
     }
 
     LWLockRelease(OldSnapshotTimeMapLock);
 }

◆ parseIntFromText()

static int parseIntFromText	(	const char *	prefix,
		char **	s,
		const char *	filename
	)

static

Definition at line 1297 of file snapmgr.c.

References ereport, errcode(), errmsg(), ERROR, and val.

Referenced by ImportSnapshot().

 {
     char       *ptr = *s;
     int         prefixlen = strlen(prefix);
     int         val;
 
     if (strncmp(ptr, prefix, prefixlen) != 0)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                  errmsg("invalid snapshot data in file \"%s\"", filename)));
     ptr += prefixlen;
     if (sscanf(ptr, "%d", &val) != 1)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                  errmsg("invalid snapshot data in file \"%s\"", filename)));
     ptr = strchr(ptr, '\n');
     if (!ptr)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                  errmsg("invalid snapshot data in file \"%s\"", filename)));
     *s = ptr + 1;
     return val;
 }

◆ parseVxidFromText()

static void parseVxidFromText	(	const char *	prefix,
		char **	s,
		const char *	filename,
		VirtualTransactionId *	vxid
	)

static

Definition at line 1347 of file snapmgr.c.

References VirtualTransactionId::backendId, ereport, errcode(), errmsg(), ERROR, and VirtualTransactionId::localTransactionId.

Referenced by ImportSnapshot().

 {
     char       *ptr = *s;
     int         prefixlen = strlen(prefix);
 
     if (strncmp(ptr, prefix, prefixlen) != 0)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                  errmsg("invalid snapshot data in file \"%s\"", filename)));
     ptr += prefixlen;
     if (sscanf(ptr, "%d/%u", &vxid->backendId, &vxid->localTransactionId) != 2)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                  errmsg("invalid snapshot data in file \"%s\"", filename)));
     ptr = strchr(ptr, '\n');
     if (!ptr)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                  errmsg("invalid snapshot data in file \"%s\"", filename)));
     *s = ptr + 1;
 }

◆ parseXidFromText()

static TransactionId parseXidFromText	(	const char *	prefix,
		char **	s,
		const char *	filename
	)

static

Definition at line 1322 of file snapmgr.c.

References ereport, errcode(), errmsg(), ERROR, and val.

Referenced by ImportSnapshot().

 {
     char       *ptr = *s;
     int         prefixlen = strlen(prefix);
     TransactionId val;
 
     if (strncmp(ptr, prefix, prefixlen) != 0)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                  errmsg("invalid snapshot data in file \"%s\"", filename)));
     ptr += prefixlen;
     if (sscanf(ptr, "%u", &val) != 1)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                  errmsg("invalid snapshot data in file \"%s\"", filename)));
     ptr = strchr(ptr, '\n');
     if (!ptr)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                  errmsg("invalid snapshot data in file \"%s\"", filename)));
     *s = ptr + 1;
     return val;
 }

◆ pg_export_snapshot()

Datum pg_export_snapshot ( PG_FUNCTION_ARGS )

Definition at line 1282 of file snapmgr.c.

References cstring_to_text(), ExportSnapshot(), GetActiveSnapshot(), and PG_RETURN_TEXT_P.

 {
     char       *snapshotName;
 
     snapshotName = ExportSnapshot(GetActiveSnapshot());
     PG_RETURN_TEXT_P(cstring_to_text(snapshotName));
 }

◆ PopActiveSnapshot()

void PopActiveSnapshot ( void )

Definition at line 759 of file snapmgr.c.

References SnapshotData::active_count, ActiveSnapshotElt::as_next, ActiveSnapshotElt::as_snap, Assert, FreeSnapshot(), pfree(), SnapshotData::regd_count, and SnapshotResetXmin().

Referenced by _SPI_commit(), _SPI_execute_plan(), AfterTriggerFireDeferred(), AfterTriggerSetState(), apply_handle_delete(), apply_handle_insert(), apply_handle_update(), ATExecDetachPartition(), BuildCachedPlan(), cluster(), DefineIndex(), DoPortalRewind(), EndCopyTo(), exec_bind_message(), exec_eval_simple_expr(), exec_parse_message(), exec_simple_query(), exec_stmt_call(), ExecCreateTableAs(), execute_sql_string(), ExplainOnePlan(), fmgr_sql(), HandleFunctionRequest(), index_drop(), initialize_worker_spi(), LogicalRepSyncTableStart(), movedb(), OldSnapshotThresholdActive(), ParallelWorkerMain(), PersistHoldablePortal(), PortalRunMulti(), PortalRunSelect(), PortalRunUtility(), PortalStart(), refresh_matview_datafill(), ReindexMultipleInternal(), ReindexRelationConcurrently(), RelationFindReplTupleByIndex(), RelationFindReplTupleSeq(), RememberToFreeTupleDescAtEOX(), RevalidateCachedQuery(), ShutdownSQLFunction(), vacuum(), and vacuum_rel().

 {
     ActiveSnapshotElt *newstack;
 
     newstack = ActiveSnapshot->as_next;
 
     Assert(ActiveSnapshot->as_snap->active_count > 0);
 
     ActiveSnapshot->as_snap->active_count--;
 
     if (ActiveSnapshot->as_snap->active_count == 0 &&
         ActiveSnapshot->as_snap->regd_count == 0)
         FreeSnapshot(ActiveSnapshot->as_snap);
 
     pfree(ActiveSnapshot);
     ActiveSnapshot = newstack;
     if (ActiveSnapshot == NULL)
         OldestActiveSnapshot = NULL;
 
     SnapshotResetXmin();
 }

◆ PushActiveSnapshot()

void PushActiveSnapshot ( Snapshot snap )

Definition at line 680 of file snapmgr.c.

References SnapshotData::active_count, ActiveSnapshot, ActiveSnapshotElt::as_level, ActiveSnapshotElt::as_next, ActiveSnapshotElt::as_snap, Assert, SnapshotData::copied, CopySnapshot(), GetCurrentTransactionNestLevel(), InvalidSnapshot, MemoryContextAlloc(), and TopTransactionContext.

Referenced by _SPI_execute_plan(), AfterTriggerFireDeferred(), AfterTriggerSetState(), apply_handle_delete(), apply_handle_insert(), apply_handle_update(), BuildCachedPlan(), cluster(), DefineIndex(), DoPortalRewind(), exec_bind_message(), exec_eval_simple_expr(), exec_parse_message(), exec_simple_query(), exec_stmt_call(), execute_sql_string(), fmgr_sql(), HandleFunctionRequest(), initialize_worker_spi(), LogicalRepSyncTableStart(), OldSnapshotThresholdActive(), ParallelWorkerMain(), PersistHoldablePortal(), PortalRunSelect(), PortalRunUtility(), PortalStart(), PushCopiedSnapshot(), ReindexMultipleInternal(), ReindexRelationConcurrently(), RelationFindReplTupleByIndex(), RelationFindReplTupleSeq(), RememberToFreeTupleDescAtEOX(), RevalidateCachedQuery(), ShutdownSQLFunction(), vacuum(), and vacuum_rel().

 {
     ActiveSnapshotElt *newactive;
 
     Assert(snap != InvalidSnapshot);
 
     newactive = MemoryContextAlloc(TopTransactionContext, sizeof(ActiveSnapshotElt));
 
     /*
      * Checking SecondarySnapshot is probably useless here, but it seems
      * better to be sure.
      */
     if (snap == CurrentSnapshot || snap == SecondarySnapshot || !snap->copied)
         newactive->as_snap = CopySnapshot(snap);
     else
         newactive->as_snap = snap;
 
     newactive->as_next = ActiveSnapshot;
     newactive->as_level = GetCurrentTransactionNestLevel();
 
     newactive->as_snap->active_count++;
 
     ActiveSnapshot = newactive;
     if (OldestActiveSnapshot == NULL)
         OldestActiveSnapshot = ActiveSnapshot;
 }

◆ PushCopiedSnapshot()

void PushCopiedSnapshot ( Snapshot snapshot )

Definition at line 716 of file snapmgr.c.

References CopySnapshot(), and PushActiveSnapshot().

Referenced by _SPI_execute_plan(), BeginCopyTo(), ExecCreateTableAs(), ExplainOnePlan(), OldSnapshotThresholdActive(), PortalRunMulti(), and refresh_matview_datafill().

 {
     PushActiveSnapshot(CopySnapshot(snapshot));
 }

◆ RegisterSnapshot()

Snapshot RegisterSnapshot ( Snapshot snapshot )

Definition at line 810 of file snapmgr.c.

References CurrentResourceOwner, InvalidSnapshot, and RegisterSnapshotOnOwner().

Referenced by _bt_begin_parallel(), AlterDomainNotNull(), asyncQueueReadAllNotifications(), ATRewriteTable(), bt_check_every_level(), check_default_partition_contents(), CreateQueryDesc(), currtid_internal(), DefineIndex(), DefineQueryRewrite(), heapam_index_build_range_scan(), index_beginscan_parallel(), IndexCheckExclusion(), OldSnapshotThresholdActive(), pg_get_constraintdef_worker(), pgstat_collect_oids(), PortalRunMulti(), PortalRunUtility(), process_settings(), ReindexRelationConcurrently(), standard_ExecutorStart(), systable_beginscan(), systable_beginscan_ordered(), table_beginscan_catalog(), table_beginscan_parallel(), table_scan_update_snapshot(), validateDomainConstraint(), and validateForeignKeyConstraint().

 {
     if (snapshot == InvalidSnapshot)
         return InvalidSnapshot;
 
     return RegisterSnapshotOnOwner(snapshot, CurrentResourceOwner);
 }

◆ RegisterSnapshotOnOwner()

Snapshot RegisterSnapshotOnOwner	(	Snapshot	snapshot,
		ResourceOwner	owner
	)

Definition at line 823 of file snapmgr.c.

References SnapshotData::copied, CopySnapshot(), InvalidSnapshot, pairingheap_add(), SnapshotData::ph_node, SnapshotData::regd_count, ResourceOwnerEnlargeSnapshots(), and ResourceOwnerRememberSnapshot().

Referenced by inv_open(), OldSnapshotThresholdActive(), and RegisterSnapshot().

 {
     Snapshot    snap;
 
     if (snapshot == InvalidSnapshot)
         return InvalidSnapshot;
 
     /* Static snapshot?  Create a persistent copy */
     snap = snapshot->copied ? snapshot : CopySnapshot(snapshot);
 
     /* and tell resowner.c about it */
     ResourceOwnerEnlargeSnapshots(owner);
     snap->regd_count++;
     ResourceOwnerRememberSnapshot(owner, snap);
 
     if (snap->regd_count == 1)
         pairingheap_add(&RegisteredSnapshots, &snap->ph_node);
 
     return snap;
 }

◆ RestoreSnapshot()

Snapshot RestoreSnapshot ( char * start_address )

Definition at line 2161 of file snapmgr.c.

Referenced by ExecBitmapHeapInitializeWorker(), index_beginscan_parallel(), ParallelWorkerMain(), and table_beginscan_parallel().

 {
     SerializedSnapshotData serialized_snapshot;
     Size        size;
     Snapshot    snapshot;
     TransactionId *serialized_xids;
 
     memcpy(&serialized_snapshot, start_address,
            sizeof(SerializedSnapshotData));
     serialized_xids = (TransactionId *)
         (start_address + sizeof(SerializedSnapshotData));
 
     /* We allocate any XID arrays needed in the same palloc block. */
     size = sizeof(SnapshotData)
         + serialized_snapshot.xcnt * sizeof(TransactionId)
         + serialized_snapshot.subxcnt * sizeof(TransactionId);
 
     /* Copy all required fields */
     snapshot = (Snapshot) MemoryContextAlloc(TopTransactionContext, size);
     snapshot->snapshot_type = SNAPSHOT_MVCC;
     snapshot->xmin = serialized_snapshot.xmin;
     snapshot->xmax = serialized_snapshot.xmax;
     snapshot->xip = NULL;
     snapshot->xcnt = serialized_snapshot.xcnt;
     snapshot->subxip = NULL;
     snapshot->subxcnt = serialized_snapshot.subxcnt;
     snapshot->suboverflowed = serialized_snapshot.suboverflowed;
     snapshot->takenDuringRecovery = serialized_snapshot.takenDuringRecovery;
     snapshot->curcid = serialized_snapshot.curcid;
     snapshot->whenTaken = serialized_snapshot.whenTaken;
     snapshot->lsn = serialized_snapshot.lsn;
     snapshot->snapXactCompletionCount = 0;
 
     /* Copy XIDs, if present. */
     if (serialized_snapshot.xcnt > 0)
     {
         snapshot->xip = (TransactionId *) (snapshot + 1);
         memcpy(snapshot->xip, serialized_xids,
                serialized_snapshot.xcnt * sizeof(TransactionId));
     }
 
     /* Copy SubXIDs, if present. */
     if (serialized_snapshot.subxcnt > 0)
     {
         snapshot->subxip = ((TransactionId *) (snapshot + 1)) +
             serialized_snapshot.xcnt;
         memcpy(snapshot->subxip, serialized_xids + serialized_snapshot.xcnt,
                serialized_snapshot.subxcnt * sizeof(TransactionId));
     }
 
     /* Set the copied flag so that the caller will set refcounts correctly. */
     snapshot->regd_count = 0;
     snapshot->active_count = 0;
     snapshot->copied = true;
 
     return snapshot;
 }

◆ RestoreTransactionSnapshot()

void RestoreTransactionSnapshot	(	Snapshot	snapshot,
		void *	source_pgproc
	)

Definition at line 2226 of file snapmgr.c.

References InvalidPid, and SetTransactionSnapshot().

Referenced by CreateReplicationSlot(), and ParallelWorkerMain().

 {
     SetTransactionSnapshot(snapshot, NULL, InvalidPid, source_pgproc);
 }

◆ SerializeSnapshot()

void SerializeSnapshot	(	Snapshot	snapshot,
		char *	start_address
	)

Definition at line 2102 of file snapmgr.c.

Referenced by ExecBitmapHeapInitializeDSM(), index_parallelscan_initialize(), InitializeParallelDSM(), and table_parallelscan_initialize().

 {
     SerializedSnapshotData serialized_snapshot;
 
     Assert(snapshot->subxcnt >= 0);
 
     /* Copy all required fields */
     serialized_snapshot.xmin = snapshot->xmin;
     serialized_snapshot.xmax = snapshot->xmax;
     serialized_snapshot.xcnt = snapshot->xcnt;
     serialized_snapshot.subxcnt = snapshot->subxcnt;
     serialized_snapshot.suboverflowed = snapshot->suboverflowed;
     serialized_snapshot.takenDuringRecovery = snapshot->takenDuringRecovery;
     serialized_snapshot.curcid = snapshot->curcid;
     serialized_snapshot.whenTaken = snapshot->whenTaken;
     serialized_snapshot.lsn = snapshot->lsn;
 
     /*
      * Ignore the SubXID array if it has overflowed, unless the snapshot was
      * taken during recovery - in that case, top-level XIDs are in subxip as
      * well, and we mustn't lose them.
      */
     if (serialized_snapshot.suboverflowed && !snapshot->takenDuringRecovery)
         serialized_snapshot.subxcnt = 0;
 
     /* Copy struct to possibly-unaligned buffer */
     memcpy(start_address,
            &serialized_snapshot, sizeof(SerializedSnapshotData));
 
     /* Copy XID array */
     if (snapshot->xcnt > 0)
         memcpy((TransactionId *) (start_address +
                                   sizeof(SerializedSnapshotData)),
                snapshot->xip, snapshot->xcnt * sizeof(TransactionId));
 
     /*
      * Copy SubXID array. Don't bother to copy it if it had overflowed,
      * though, because it's not used anywhere in that case. Except if it's a
      * snapshot taken during recovery; all the top-level XIDs are in subxip as
      * well in that case, so we mustn't lose them.
      */
     if (serialized_snapshot.subxcnt > 0)
     {
         Size        subxipoff = sizeof(SerializedSnapshotData) +
         snapshot->xcnt * sizeof(TransactionId);
 
         memcpy((TransactionId *) (start_address + subxipoff),
                snapshot->subxip, snapshot->subxcnt * sizeof(TransactionId));
     }
 }

◆ SetOldSnapshotThresholdTimestamp()

void SetOldSnapshotThresholdTimestamp	(	TimestampTz	ts,
		TransactionId	xlimit
	)

Definition at line 1672 of file snapmgr.c.

References Assert, OldSnapshotControlData::mutex_threshold, SpinLockAcquire, SpinLockRelease, OldSnapshotControlData::threshold_timestamp, OldSnapshotControlData::threshold_xid, and TransactionIdPrecedesOrEquals().

Referenced by heap_prune_satisfies_vacuum(), OldSnapshotThresholdActive(), and vacuum_set_xid_limits().

 {
     SpinLockAcquire(&oldSnapshotControl->mutex_threshold);
     Assert(oldSnapshotControl->threshold_timestamp <= ts);
     Assert(TransactionIdPrecedesOrEquals(oldSnapshotControl->threshold_xid, xlimit));
     oldSnapshotControl->threshold_timestamp = ts;
     oldSnapshotControl->threshold_xid = xlimit;
     SpinLockRelease(&oldSnapshotControl->mutex_threshold);
 }

◆ SetTransactionSnapshot()

static void SetTransactionSnapshot	(	Snapshot	sourcesnap,
		VirtualTransactionId *	sourcevxid,
		int	sourcepid,
		PGPROC *	sourceproc
	)

static

Definition at line 511 of file snapmgr.c.

References Assert, CopySnapshot(), CurrentSnapshot, ereport, errcode(), errdetail(), errmsg(), ERROR, FirstSnapshotSet, GetMaxSnapshotSubxidCount(), GetMaxSnapshotXidCount(), GetSnapshotData(), HistoricSnapshotActive(), InvalidateCatalogSnapshot(), IsolationIsSerializable, IsolationUsesXactSnapshot, pairingheap_add(), pairingheap_is_empty, SnapshotData::ph_node, ProcArrayInstallImportedXmin(), ProcArrayInstallRestoredXmin(), SnapshotData::regd_count, SetSerializableTransactionSnapshot(), SnapshotData::snapXactCompletionCount, SnapshotData::suboverflowed, SnapshotData::subxcnt, SnapshotData::subxip, SnapshotData::takenDuringRecovery, SnapshotData::xcnt, SnapshotData::xip, SnapshotData::xmax, and SnapshotData::xmin.

Referenced by ImportSnapshot(), and RestoreTransactionSnapshot().

 {
     /* Caller should have checked this already */
     Assert(!FirstSnapshotSet);
 
     /* Better do this to ensure following Assert succeeds. */
     InvalidateCatalogSnapshot();
 
     Assert(pairingheap_is_empty(&RegisteredSnapshots));
     Assert(FirstXactSnapshot == NULL);
     Assert(!HistoricSnapshotActive());
 
     /*
      * Even though we are not going to use the snapshot it computes, we must
      * call GetSnapshotData, for two reasons: (1) to be sure that
      * CurrentSnapshotData's XID arrays have been allocated, and (2) to update
      * the state for GlobalVis*.
      */
     CurrentSnapshot = GetSnapshotData(&CurrentSnapshotData);
 
     /*
      * Now copy appropriate fields from the source snapshot.
      */
     CurrentSnapshot->xmin = sourcesnap->xmin;
     CurrentSnapshot->xmax = sourcesnap->xmax;
     CurrentSnapshot->xcnt = sourcesnap->xcnt;
     Assert(sourcesnap->xcnt <= GetMaxSnapshotXidCount());
     memcpy(CurrentSnapshot->xip, sourcesnap->xip,
            sourcesnap->xcnt * sizeof(TransactionId));
     CurrentSnapshot->subxcnt = sourcesnap->subxcnt;
     Assert(sourcesnap->subxcnt <= GetMaxSnapshotSubxidCount());
     memcpy(CurrentSnapshot->subxip, sourcesnap->subxip,
            sourcesnap->subxcnt * sizeof(TransactionId));
     CurrentSnapshot->suboverflowed = sourcesnap->suboverflowed;
     CurrentSnapshot->takenDuringRecovery = sourcesnap->takenDuringRecovery;
     /* NB: curcid should NOT be copied, it's a local matter */
 
     CurrentSnapshot->snapXactCompletionCount = 0;
 
     /*
      * Now we have to fix what GetSnapshotData did with MyProc->xmin and
      * TransactionXmin.  There is a race condition: to make sure we are not
      * causing the global xmin to go backwards, we have to test that the
      * source transaction is still running, and that has to be done
      * atomically. So let procarray.c do it.
      *
      * Note: in serializable mode, predicate.c will do this a second time. It
      * doesn't seem worth contorting the logic here to avoid two calls,
      * especially since it's not clear that predicate.c *must* do this.
      */
     if (sourceproc != NULL)
     {
         if (!ProcArrayInstallRestoredXmin(CurrentSnapshot->xmin, sourceproc))
             ereport(ERROR,
                     (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                      errmsg("could not import the requested snapshot"),
                      errdetail("The source transaction is not running anymore.")));
     }
     else if (!ProcArrayInstallImportedXmin(CurrentSnapshot->xmin, sourcevxid))
         ereport(ERROR,
                 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                  errmsg("could not import the requested snapshot"),
                  errdetail("The source process with PID %d is not running anymore.",
                            sourcepid)));
 
     /*
      * In transaction-snapshot mode, the first snapshot must live until end of
      * xact, so we must make a copy of it.  Furthermore, if we're running in
      * serializable mode, predicate.c needs to do its own processing.
      */
     if (IsolationUsesXactSnapshot())
     {
         if (IsolationIsSerializable())
             SetSerializableTransactionSnapshot(CurrentSnapshot, sourcevxid,
                                                sourcepid);
         /* Make a saved copy */
         CurrentSnapshot = CopySnapshot(CurrentSnapshot);
         FirstXactSnapshot = CurrentSnapshot;
         /* Mark it as "registered" in FirstXactSnapshot */
         FirstXactSnapshot->regd_count++;
         pairingheap_add(&RegisteredSnapshots, &FirstXactSnapshot->ph_node);
     }
 
     FirstSnapshotSet = true;
 }

◆ SetupHistoricSnapshot()

void SetupHistoricSnapshot	(	Snapshot	historic_snapshot,
		HTAB *	tuplecids
	)

Definition at line 2035 of file snapmgr.c.

References Assert.

Referenced by ReorderBufferProcessTXN(), and ReorderBufferQueueMessage().

 {
     Assert(historic_snapshot != NULL);
 
     /* setup the timetravel snapshot */
     HistoricSnapshot = historic_snapshot;
 
     /* setup (cmin, cmax) lookup hash */
     tuplecid_data = tuplecids;
 }

◆ SnapMgrInit()

void SnapMgrInit ( void )

Definition at line 213 of file snapmgr.c.

Referenced by CreateSharedMemoryAndSemaphores().

 {
     bool        found;
 
     /*
      * Create or attach to the OldSnapshotControlData structure.
      */
     oldSnapshotControl = (volatile OldSnapshotControlData *)
         ShmemInitStruct("OldSnapshotControlData",
                         SnapMgrShmemSize(), &found);
 
     if (!found)
     {
         SpinLockInit(&oldSnapshotControl->mutex_current);
         oldSnapshotControl->current_timestamp = 0;
         SpinLockInit(&oldSnapshotControl->mutex_latest_xmin);
         oldSnapshotControl->latest_xmin = InvalidTransactionId;
         oldSnapshotControl->next_map_update = 0;
         SpinLockInit(&oldSnapshotControl->mutex_threshold);
         oldSnapshotControl->threshold_timestamp = 0;
         oldSnapshotControl->threshold_xid = InvalidTransactionId;
         oldSnapshotControl->head_offset = 0;
         oldSnapshotControl->head_timestamp = 0;
         oldSnapshotControl->count_used = 0;
     }
 }

◆ SnapMgrShmemSize()

Size SnapMgrShmemSize ( void )

Definition at line 197 of file snapmgr.c.

References add_size(), mul_size(), offsetof, old_snapshot_threshold, and OLD_SNAPSHOT_TIME_MAP_ENTRIES.

Referenced by CreateSharedMemoryAndSemaphores(), and SnapMgrInit().

 {
     Size        size;
 
     size = offsetof(OldSnapshotControlData, xid_by_minute);
     if (old_snapshot_threshold > 0)
         size = add_size(size, mul_size(sizeof(TransactionId),
                                        OLD_SNAPSHOT_TIME_MAP_ENTRIES));
 
     return size;
 }

◆ SnapshotResetXmin()

static void SnapshotResetXmin ( void )

static

Definition at line 925 of file snapmgr.c.

References InvalidTransactionId, MyProc, pairingheap_container, pairingheap_first(), pairingheap_is_empty, TransactionIdPrecedes(), PGPROC::xmin, and SnapshotData::xmin.

Referenced by AtEOXact_Snapshot(), AtSubAbort_Snapshot(), InvalidateCatalogSnapshot(), PopActiveSnapshot(), and UnregisterSnapshotFromOwner().

 {
     Snapshot    minSnapshot;
 
     if (ActiveSnapshot != NULL)
         return;
 
     if (pairingheap_is_empty(&RegisteredSnapshots))
     {
         MyProc->xmin = InvalidTransactionId;
         return;
     }
 
     minSnapshot = pairingheap_container(SnapshotData, ph_node,
                                         pairingheap_first(&RegisteredSnapshots));
 
     if (TransactionIdPrecedes(MyProc->xmin, minSnapshot->xmin))
         MyProc->xmin = minSnapshot->xmin;
 }

◆ SnapshotSetCommandId()

void SnapshotSetCommandId ( CommandId curcid )

Definition at line 490 of file snapmgr.c.

References SnapshotData::curcid, and FirstSnapshotSet.

Referenced by CommandCounterIncrement(), and OldSnapshotThresholdActive().

 {
     if (!FirstSnapshotSet)
         return;
 
     if (CurrentSnapshot)
         CurrentSnapshot->curcid = curcid;
     if (SecondarySnapshot)
         SecondarySnapshot->curcid = curcid;
     /* Should we do the same with CatalogSnapshot? */
 }

◆ SnapshotTooOldMagicForTest()

void SnapshotTooOldMagicForTest ( void )

Definition at line 1689 of file snapmgr.c.

References Assert, GetSnapshotCurrentTimestamp(), OldSnapshotControlData::mutex_threshold, old_snapshot_threshold, SpinLockAcquire, SpinLockRelease, OldSnapshotControlData::threshold_timestamp, and USECS_PER_SEC.

Referenced by heap_page_prune_opt().

 {
     TimestampTz ts = GetSnapshotCurrentTimestamp();
 
     Assert(old_snapshot_threshold == 0);
 
     ts -= 5 * USECS_PER_SEC;
 
     SpinLockAcquire(&oldSnapshotControl->mutex_threshold);
     oldSnapshotControl->threshold_timestamp = ts;
     SpinLockRelease(&oldSnapshotControl->mutex_threshold);
 }

◆ TeardownHistoricSnapshot()

void TeardownHistoricSnapshot ( bool is_error )

Definition at line 2051 of file snapmgr.c.

Referenced by ReorderBufferProcessTXN(), and ReorderBufferQueueMessage().

 {
     HistoricSnapshot = NULL;
     tuplecid_data = NULL;
 }

◆ ThereAreNoPriorRegisteredSnapshots()

bool ThereAreNoPriorRegisteredSnapshots ( void )

Definition at line 1604 of file snapmgr.c.

References pairingheap_is_empty, and pairingheap_is_singular.

Referenced by CopyFrom(), and OldSnapshotThresholdActive().

 {
     if (pairingheap_is_empty(&RegisteredSnapshots) ||
         pairingheap_is_singular(&RegisteredSnapshots))
         return true;
 
     return false;
 }

◆ TransactionIdLimitedForOldSnapshots()

bool TransactionIdLimitedForOldSnapshots	(	TransactionId	recentXmin,
		Relation	relation,
		TransactionId *	limit_xid,
		TimestampTz *	limit_ts
	)

Definition at line 1751 of file snapmgr.c.

References AlignTimestampToMinuteBoundary(), Assert, GetOldSnapshotFromTimeMapping(), GetSnapshotCurrentTimestamp(), OldSnapshotControlData::latest_xmin, OldSnapshotControlData::mutex_latest_xmin, OldSnapshotControlData::mutex_threshold, MyProc, OldSnapshotControlData::next_map_update, old_snapshot_threshold, OldSnapshotThresholdActive(), RelationAllowsEarlyPruning, RelationNeedsWAL, SpinLockAcquire, SpinLockRelease, OldSnapshotControlData::threshold_timestamp, OldSnapshotControlData::threshold_xid, TransactionIdFollows(), TransactionIdFollowsOrEquals(), TransactionIdIsNormal, TransactionIdIsValid, TransactionIdPrecedes(), USECS_PER_MINUTE, USECS_PER_SEC, and PGPROC::xmin.

Referenced by heap_page_prune_opt(), heap_prune_satisfies_vacuum(), OldSnapshotThresholdActive(), and vacuum_set_xid_limits().

 {
     TimestampTz ts;
     TransactionId xlimit = recentXmin;
     TransactionId latest_xmin;
     TimestampTz next_map_update_ts;
     TransactionId threshold_timestamp;
     TransactionId threshold_xid;
 
     Assert(TransactionIdIsNormal(recentXmin));
     Assert(OldSnapshotThresholdActive());
     Assert(limit_ts != NULL && limit_xid != NULL);
 
     /*
      * TestForOldSnapshot() assumes early pruning advances the page LSN, so we
      * can't prune early when skipping WAL.
      */
     if (!RelationAllowsEarlyPruning(relation) || !RelationNeedsWAL(relation))
         return false;
 
     ts = GetSnapshotCurrentTimestamp();
 
     SpinLockAcquire(&oldSnapshotControl->mutex_latest_xmin);
     latest_xmin = oldSnapshotControl->latest_xmin;
     next_map_update_ts = oldSnapshotControl->next_map_update;
     SpinLockRelease(&oldSnapshotControl->mutex_latest_xmin);
 
     /*
      * Zero threshold always overrides to latest xmin, if valid.  Without some
      * heuristic it will find its own snapshot too old on, for example, a
      * simple UPDATE -- which would make it useless for most testing, but
      * there is no principled way to ensure that it doesn't fail in this way.
      * Use a five-second delay to try to get useful testing behavior, but this
      * may need adjustment.
      */
     if (old_snapshot_threshold == 0)
     {
         if (TransactionIdPrecedes(latest_xmin, MyProc->xmin)
             && TransactionIdFollows(latest_xmin, xlimit))
             xlimit = latest_xmin;
 
         ts -= 5 * USECS_PER_SEC;
     }
     else
     {
         ts = AlignTimestampToMinuteBoundary(ts)
             - (old_snapshot_threshold * USECS_PER_MINUTE);
 
         /* Check for fast exit without LW locking. */
         SpinLockAcquire(&oldSnapshotControl->mutex_threshold);
         threshold_timestamp = oldSnapshotControl->threshold_timestamp;
         threshold_xid = oldSnapshotControl->threshold_xid;
         SpinLockRelease(&oldSnapshotControl->mutex_threshold);
 
         if (ts == threshold_timestamp)
         {
             /*
              * Current timestamp is in same bucket as the last limit that
              * was applied. Reuse.
              */
             xlimit = threshold_xid;
         }
         else if (ts == next_map_update_ts)
         {
             /*
              * FIXME: This branch is super iffy - but that should probably
              * fixed separately.
              */
             xlimit = latest_xmin;
         }
         else if (GetOldSnapshotFromTimeMapping(ts, &xlimit))
         {
         }
 
         /*
          * Failsafe protection against vacuuming work of active transaction.
          *
          * This is not an assertion because we avoid the spinlock for
          * performance, leaving open the possibility that xlimit could advance
          * and be more current; but it seems prudent to apply this limit.  It
          * might make pruning a tiny bit less aggressive than it could be, but
          * protects against data loss bugs.
          */
         if (TransactionIdIsNormal(latest_xmin)
             && TransactionIdPrecedes(latest_xmin, xlimit))
             xlimit = latest_xmin;
     }
 
     if (TransactionIdIsValid(xlimit) &&
         TransactionIdFollowsOrEquals(xlimit, recentXmin))
     {
         *limit_ts = ts;
         *limit_xid = xlimit;
 
         return true;
     }
 
     return false;
 }

◆ UnregisterSnapshot()

void UnregisterSnapshot ( Snapshot snapshot )

Definition at line 852 of file snapmgr.c.

References CurrentResourceOwner, and UnregisterSnapshotFromOwner().

Referenced by _bt_begin_parallel(), _bt_end_parallel(), AlterDomainNotNull(), asyncQueueReadAllNotifications(), ATRewriteTable(), bt_check_every_level(), check_default_partition_contents(), currtid_internal(), DefineIndex(), DefineQueryRewrite(), FreeQueryDesc(), heap_endscan(), heapam_index_build_range_scan(), index_endscan(), IndexCheckExclusion(), OldSnapshotThresholdActive(), pg_get_constraintdef_worker(), pgstat_collect_oids(), process_settings(), ReindexRelationConcurrently(), ResourceOwnerReleaseInternal(), standard_ExecutorEnd(), systable_endscan(), systable_endscan_ordered(), validateDomainConstraint(), and validateForeignKeyConstraint().

 {
     if (snapshot == NULL)
         return;
 
     UnregisterSnapshotFromOwner(snapshot, CurrentResourceOwner);
 }

◆ UnregisterSnapshotFromOwner()

void UnregisterSnapshotFromOwner	(	Snapshot	snapshot,
		ResourceOwner	owner
	)

Definition at line 865 of file snapmgr.c.

References SnapshotData::active_count, Assert, FreeSnapshot(), pairingheap_is_empty, pairingheap_remove(), SnapshotData::ph_node, SnapshotData::regd_count, ResourceOwnerForgetSnapshot(), and SnapshotResetXmin().

Referenced by inv_close(), OldSnapshotThresholdActive(), PortalDrop(), PreCommit_Portals(), and UnregisterSnapshot().

 {
     if (snapshot == NULL)
         return;
 
     Assert(snapshot->regd_count > 0);
     Assert(!pairingheap_is_empty(&RegisteredSnapshots));
 
     ResourceOwnerForgetSnapshot(owner, snapshot);
 
     snapshot->regd_count--;
     if (snapshot->regd_count == 0)
         pairingheap_remove(&RegisteredSnapshots, &snapshot->ph_node);
 
     if (snapshot->regd_count == 0 && snapshot->active_count == 0)
     {
         FreeSnapshot(snapshot);
         SnapshotResetXmin();
     }
 }

◆ UpdateActiveSnapshotCommandId()

void UpdateActiveSnapshotCommandId ( void )

Definition at line 728 of file snapmgr.c.

References SnapshotData::active_count, ActiveSnapshotElt::as_snap, Assert, SnapshotData::curcid, elog, ERROR, GetCurrentCommandId(), IsInParallelMode(), and SnapshotData::regd_count.

Referenced by _SPI_execute_plan(), BeginCopyTo(), ExecCreateTableAs(), ExplainOnePlan(), fmgr_sql(), OldSnapshotThresholdActive(), PortalRunMulti(), and refresh_matview_datafill().

 {
     CommandId   save_curcid,
                 curcid;
 
     Assert(ActiveSnapshot != NULL);
     Assert(ActiveSnapshot->as_snap->active_count == 1);
     Assert(ActiveSnapshot->as_snap->regd_count == 0);
 
     /*
      * Don't allow modification of the active snapshot during parallel
      * operation.  We share the snapshot to worker backends at the beginning
      * of parallel operation, so any change to the snapshot can lead to
      * inconsistencies.  We have other defenses against
      * CommandCounterIncrement, but there are a few places that call this
      * directly, so we put an additional guard here.
      */
     save_curcid = ActiveSnapshot->as_snap->curcid;
     curcid = GetCurrentCommandId(false);
     if (IsInParallelMode() && save_curcid != curcid)
         elog(ERROR, "cannot modify commandid in active snapshot during a parallel operation");
     ActiveSnapshot->as_snap->curcid = curcid;
 }

◆ XactHasExportedSnapshots()

bool XactHasExportedSnapshots ( void )

Definition at line 1552 of file snapmgr.c.

References NIL.

Referenced by OldSnapshotThresholdActive(), and PrepareTransaction().

 {
     return (exportedSnapshots != NIL);
 }

◆ XidInMVCCSnapshot()

bool XidInMVCCSnapshot	(	TransactionId	xid,
		Snapshot	snapshot
	)

Definition at line 2242 of file snapmgr.c.

References i, SnapshotData::suboverflowed, SubTransGetTopmostTransaction(), SnapshotData::subxcnt, SnapshotData::subxip, SnapshotData::takenDuringRecovery, TransactionIdEquals, TransactionIdFollowsOrEquals(), TransactionIdPrecedes(), SnapshotData::xcnt, SnapshotData::xip, SnapshotData::xmax, and SnapshotData::xmin.

Referenced by asyncQueueProcessPageEntries(), find_inheritance_children(), and HeapTupleSatisfiesMVCC().

 {
     uint32      i;
 
     /*
      * Make a quick range check to eliminate most XIDs without looking at the
      * xip arrays.  Note that this is OK even if we convert a subxact XID to
      * its parent below, because a subxact with XID < xmin has surely also got
      * a parent with XID < xmin, while one with XID >= xmax must belong to a
      * parent that was not yet committed at the time of this snapshot.
      */
 
     /* Any xid < xmin is not in-progress */
     if (TransactionIdPrecedes(xid, snapshot->xmin))
         return false;
     /* Any xid >= xmax is in-progress */
     if (TransactionIdFollowsOrEquals(xid, snapshot->xmax))
         return true;
 
     /*
      * Snapshot information is stored slightly differently in snapshots taken
      * during recovery.
      */
     if (!snapshot->takenDuringRecovery)
     {
         /*
          * If the snapshot contains full subxact data, the fastest way to
          * check things is just to compare the given XID against both subxact
          * XIDs and top-level XIDs.  If the snapshot overflowed, we have to
          * use pg_subtrans to convert a subxact XID to its parent XID, but
          * then we need only look at top-level XIDs not subxacts.
          */
         if (!snapshot->suboverflowed)
         {
             /* we have full data, so search subxip */
             int32       j;
 
             for (j = 0; j < snapshot->subxcnt; j++)
             {
                 if (TransactionIdEquals(xid, snapshot->subxip[j]))
                     return true;
             }
 
             /* not there, fall through to search xip[] */
         }
         else
         {
             /*
              * Snapshot overflowed, so convert xid to top-level.  This is safe
              * because we eliminated too-old XIDs above.
              */
             xid = SubTransGetTopmostTransaction(xid);
 
             /*
              * If xid was indeed a subxact, we might now have an xid < xmin,
              * so recheck to avoid an array scan.  No point in rechecking
              * xmax.
              */
             if (TransactionIdPrecedes(xid, snapshot->xmin))
                 return false;
         }
 
         for (i = 0; i < snapshot->xcnt; i++)
         {
             if (TransactionIdEquals(xid, snapshot->xip[i]))
                 return true;
         }
     }
     else
     {
         int32       j;
 
         /*
          * In recovery we store all xids in the subxact array because it is by
          * far the bigger array, and we mostly don't know which xids are
          * top-level and which are subxacts. The xip array is empty.
          *
          * We start by searching subtrans, if we overflowed.
          */
         if (snapshot->suboverflowed)
         {
             /*
              * Snapshot overflowed, so convert xid to top-level.  This is safe
              * because we eliminated too-old XIDs above.
              */
             xid = SubTransGetTopmostTransaction(xid);
 
             /*
              * If xid was indeed a subxact, we might now have an xid < xmin,
              * so recheck to avoid an array scan.  No point in rechecking
              * xmax.
              */
             if (TransactionIdPrecedes(xid, snapshot->xmin))
                 return false;
         }
 
         /*
          * We now have either a top-level xid higher than xmin or an
          * indeterminate xid. We don't know whether it's top level or subxact
          * but it doesn't matter. If it's present, the xid is visible.
          */
         for (j = 0; j < snapshot->subxcnt; j++)
         {
             if (TransactionIdEquals(xid, snapshot->subxip[j]))
                 return true;
         }
     }
 
     return false;
 }

◆ xmin_cmp()

static int xmin_cmp	(	const pairingheap_node *	a,
		const pairingheap_node *	b,
		void *	arg
	)

static

Definition at line 891 of file snapmgr.c.

References pairingheap_const_container, TransactionIdFollows(), TransactionIdPrecedes(), and SnapshotData::xmin.

 {
     const SnapshotData *asnap = pairingheap_const_container(SnapshotData, ph_node, a);
     const SnapshotData *bsnap = pairingheap_const_container(SnapshotData, ph_node, b);
 
     if (TransactionIdPrecedes(asnap->xmin, bsnap->xmin))
         return 1;
     else if (TransactionIdFollows(asnap->xmin, bsnap->xmin))
         return -1;
     else
         return 0;
 }

Variable Documentation

◆ ActiveSnapshot

ActiveSnapshotElt* ActiveSnapshot = NULL

static

Definition at line 134 of file snapmgr.c.

Referenced by PushActiveSnapshot().

◆ CatalogSnapshot

Snapshot CatalogSnapshot = NULL

static

Definition at line 104 of file snapmgr.c.

Referenced by GetNonHistoricCatalogSnapshot().

◆ CatalogSnapshotData

SnapshotData CatalogSnapshotData = {SNAPSHOT_MVCC}

Definition at line 97 of file snapmgr.c.

◆ CurrentSnapshot

Snapshot CurrentSnapshot = NULL

static

Definition at line 102 of file snapmgr.c.

Referenced by GetTransactionSnapshot(), and SetTransactionSnapshot().

◆ CurrentSnapshotData

SnapshotData CurrentSnapshotData = {SNAPSHOT_MVCC}

static

Definition at line 95 of file snapmgr.c.

◆ exportedSnapshots

List* exportedSnapshots = NIL

static

Definition at line 169 of file snapmgr.c.

◆ FirstSnapshotSet

bool FirstSnapshotSet = false

Definition at line 149 of file snapmgr.c.

Referenced by AtEOXact_Snapshot(), check_transaction_deferrable(), check_transaction_read_only(), check_XactIsoLevel(), CreateReplicationSlot(), GetLatestSnapshot(), GetTransactionSnapshot(), ImportSnapshot(), SetTransactionSnapshot(), SnapBuildInitialSnapshot(), and SnapshotSetCommandId().

◆ FirstXactSnapshot

Snapshot FirstXactSnapshot = NULL

static

Definition at line 156 of file snapmgr.c.

◆ HistoricSnapshot

Snapshot HistoricSnapshot = NULL

static

Definition at line 105 of file snapmgr.c.

Referenced by GetCatalogSnapshot(), and GetTransactionSnapshot().

◆ old_snapshot_threshold

int old_snapshot_threshold

Definition at line 78 of file snapmgr.c.

Referenced by heap_page_prune_opt(), MaintainOldSnapshotTimeMapping(), OldSnapshotThresholdActive(), should_attempt_truncation(), SnapMgrShmemSize(), SnapshotTooOldMagicForTest(), TestForOldSnapshot(), and TransactionIdLimitedForOldSnapshots().

◆ OldestActiveSnapshot

ActiveSnapshotElt* OldestActiveSnapshot = NULL

static

Definition at line 137 of file snapmgr.c.

◆ oldSnapshotControl

volatile OldSnapshotControlData* oldSnapshotControl

Definition at line 80 of file snapmgr.c.

Referenced by GetOldSnapshotTimeMapping().

◆ RecentXmin

TransactionId RecentXmin = FirstNormalTransactionId

Definition at line 113 of file snapmgr.c.

Referenced by ATRewriteTables(), bt_check_every_level(), GetSnapshotData(), GetSnapshotDataReuse(), GlobalVisTestFor(), GlobalVisTestShouldUpdate(), GlobalVisUpdateApply(), heap_hot_search_buffer(), heapam_relation_set_new_filenode(), index_getnext_tid(), refresh_by_heap_swap(), TransactionIdIsActive(), and TransactionIdIsInProgress().

◆ RegisteredSnapshots

pairingheap RegisteredSnapshots = {&xmin_cmp, NULL, NULL}

static

Definition at line 146 of file snapmgr.c.

◆ SecondarySnapshot

Snapshot SecondarySnapshot = NULL

static

Definition at line 103 of file snapmgr.c.

Referenced by GetLatestSnapshot().

◆ SecondarySnapshotData

SnapshotData SecondarySnapshotData = {SNAPSHOT_MVCC}

static

Definition at line 96 of file snapmgr.c.

◆ SnapshotAnyData

SnapshotData SnapshotAnyData = {SNAPSHOT_ANY}

Definition at line 99 of file snapmgr.c.

◆ SnapshotSelfData

SnapshotData SnapshotSelfData = {SNAPSHOT_SELF}

Definition at line 98 of file snapmgr.c.

◆ TransactionXmin

TransactionId TransactionXmin = FirstNormalTransactionId

Definition at line 112 of file snapmgr.c.

Referenced by BuildCachedPlan(), CheckCachedPlan(), get_relation_info(), GetSnapshotData(), GetSnapshotDataReuse(), heap_abort_speculative(), HeapCheckForSerializableConflictOut(), ProcArrayInstallImportedXmin(), ProcArrayInstallRestoredXmin(), SubTransGetParent(), SubTransGetTopmostTransaction(), TransactionIdDidAbort(), and TransactionIdDidCommit().

◆ tuplecid_data

HTAB* tuplecid_data = NULL

static

Definition at line 116 of file snapmgr.c.

Referenced by HistoricSnapshotGetTupleCids().

Data Structures

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ SNAPSHOT_EXPORT_DIR

Typedef Documentation

◆ ActiveSnapshotElt

◆ ExportedSnapshot

◆ SerializedSnapshotData

Function Documentation

◆ ActiveSnapshotSet()

◆ AlignTimestampToMinuteBoundary()

◆ AtEOXact_Snapshot()

◆ AtSubAbort_Snapshot()

◆ AtSubCommit_Snapshot()

◆ CopySnapshot()

◆ DeleteAllExportedSnapshotFiles()

◆ EstimateSnapshotSpace()

◆ ExportSnapshot()

◆ FreeSnapshot()

◆ GetActiveSnapshot()

◆ GetCatalogSnapshot()

◆ GetLatestSnapshot()

◆ GetNonHistoricCatalogSnapshot()

◆ GetOldestSnapshot()

◆ GetOldSnapshotFromTimeMapping()

◆ GetOldSnapshotThresholdTimestamp()

◆ GetSnapshotCurrentTimestamp()

◆ GetTransactionSnapshot()

◆ HistoricSnapshotActive()

◆ HistoricSnapshotGetTupleCids()

◆ ImportSnapshot()

◆ InvalidateCatalogSnapshot()

◆ InvalidateCatalogSnapshotConditionally()

◆ MaintainOldSnapshotTimeMapping()

◆ parseIntFromText()

◆ parseVxidFromText()

◆ parseXidFromText()

◆ pg_export_snapshot()

◆ PopActiveSnapshot()

◆ PushActiveSnapshot()

◆ PushCopiedSnapshot()

◆ RegisterSnapshot()

◆ RegisterSnapshotOnOwner()

◆ RestoreSnapshot()

◆ RestoreTransactionSnapshot()

◆ SerializeSnapshot()

◆ SetOldSnapshotThresholdTimestamp()

◆ SetTransactionSnapshot()

◆ SetupHistoricSnapshot()

◆ SnapMgrInit()

◆ SnapMgrShmemSize()

◆ SnapshotResetXmin()

◆ SnapshotSetCommandId()

◆ SnapshotTooOldMagicForTest()

◆ TeardownHistoricSnapshot()

◆ ThereAreNoPriorRegisteredSnapshots()

◆ TransactionIdLimitedForOldSnapshots()

◆ UnregisterSnapshot()

◆ UnregisterSnapshotFromOwner()

◆ UpdateActiveSnapshotCommandId()

◆ XactHasExportedSnapshots()

◆ XidInMVCCSnapshot()

◆ xmin_cmp()

Variable Documentation

◆ ActiveSnapshot

◆ CatalogSnapshot

◆ CatalogSnapshotData

◆ CurrentSnapshot

◆ CurrentSnapshotData

◆ exportedSnapshots

◆ FirstSnapshotSet

◆ FirstXactSnapshot

◆ HistoricSnapshot

◆ old_snapshot_threshold

◆ OldestActiveSnapshot

◆ oldSnapshotControl

◆ RecentXmin