#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	PushActiveSnapshotWithLevel (Snapshot snap, int snap_level)

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)

bool	HaveRegisteredOrActiveSnapshot (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.

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 815 of file snapmgr.c.

 {
     return ActiveSnapshot != NULL;
 }

References ActiveSnapshot.

Referenced by _SPI_execute_plan(), BuildCachedPlan(), EnsurePortalSnapshotExists(), find_inheritance_children_extended(), ForgetPortalSnapshots(), index_concurrently_build(), pg_plan_query(), PortalRunUtility(), postquel_start(), RelationBuildPartitionDesc(), RelationGetPartitionDesc(), RevalidateCachedQuery(), and vacuum().

◆ AlignTimestampToMinuteBoundary()

static TimestampTz AlignTimestampToMinuteBoundary ( TimestampTz ts )

static

Definition at line 1664 of file snapmgr.c.

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

References USECS_PER_MINUTE.

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

◆ AtEOXact_Snapshot()

void AtEOXact_Snapshot	(	bool	isCommit,
		bool	resetXmin
	)

Definition at line 1023 of file snapmgr.c.

 {
     /*
      * 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);
 }

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

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

◆ AtSubAbort_Snapshot()

void AtSubAbort_Snapshot ( int level )

Definition at line 987 of file snapmgr.c.

 {
     /* 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();
 }

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

Referenced by AbortSubTransaction().

◆ AtSubCommit_Snapshot()

void AtSubCommit_Snapshot ( int level )

Definition at line 966 of file snapmgr.c.

 {
     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;
     }
 }

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

Referenced by CommitSubTransaction().

◆ CopySnapshot()

static Snapshot CopySnapshot ( Snapshot snapshot )

static

Definition at line 608 of file snapmgr.c.

 {
     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;
 }

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(), PushActiveSnapshotWithLevel(), PushCopiedSnapshot(), RegisterSnapshotOnOwner(), and SetTransactionSnapshot().

◆ DeleteAllExportedSnapshotFiles()

void DeleteAllExportedSnapshotFiles ( void )

Definition at line 1582 of file snapmgr.c.

 {
     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);
 }

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

Referenced by StartupXLOG().

◆ EstimateSnapshotSpace()

Size EstimateSnapshotSpace ( Snapshot snap )

Definition at line 2121 of file snapmgr.c.

 {
     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;
 }

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().

◆ ExportSnapshot()

char* ExportSnapshot ( Snapshot snapshot )

Definition at line 1123 of file snapmgr.c.

 {
     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);
 }

References AllocateFile(), appendStringInfo(), appendStringInfoString(), PGPROC::backendId, buf, CopySnapshot(), ereport, errcode(), errcode_for_file_access(), errmsg(), ERROR, exportedSnapshots, FreeFile(), GetMaxSnapshotSubxidCount(), GetTopTransactionIdIfAny(), i, initStringInfo(), IsSubTransaction(), lappend(), list_length(), PGPROC::lxid, MAXPGPATH, MemoryContextSwitchTo(), MyDatabaseId, MyProc, MyProcPid, pairingheap_add(), palloc(), PG_BINARY_W, SnapshotData::ph_node, pstrdup(), SnapshotData::regd_count, RegisteredSnapshots, 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 pg_export_snapshot(), and SnapBuildExportSnapshot().

◆ FreeSnapshot()

static void FreeSnapshot ( Snapshot snapshot )

static

Definition at line 664 of file snapmgr.c.

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

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

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

◆ GetActiveSnapshot()

Snapshot GetActiveSnapshot ( void )

Definition at line 803 of file snapmgr.c.

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

References ActiveSnapshot, ActiveSnapshotElt::as_snap, and Assert().

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

◆ GetCatalogSnapshot()

Snapshot GetCatalogSnapshot ( Oid relid )

Definition at line 386 of file snapmgr.c.

 {
     /*
      * 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);
 }

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

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

◆ GetLatestSnapshot()

Snapshot GetLatestSnapshot ( void )

Definition at line 325 of file snapmgr.c.

 {
     /*
      * 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;
 }

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

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

◆ GetNonHistoricCatalogSnapshot()

Snapshot GetNonHistoricCatalogSnapshot ( Oid relid )

Definition at line 408 of file snapmgr.c.

 {
     /*
      * 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;
 }

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

Referenced by GetCatalogSnapshot(), and ScanPgRelation().

◆ GetOldestSnapshot()

Snapshot GetOldestSnapshot ( void )

Definition at line 357 of file snapmgr.c.

 {
     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;
 }

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

Referenced by init_toast_snapshot().

◆ GetOldSnapshotFromTimeMapping()

static bool GetOldSnapshotFromTimeMapping	(	TimestampTz	ts,
		TransactionId *	xlimitp
	)

static

Definition at line 1750 of file snapmgr.c.

 {
     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;
 }

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

Referenced by TransactionIdLimitedForOldSnapshots().

◆ GetOldSnapshotThresholdTimestamp()

TimestampTz GetOldSnapshotThresholdTimestamp ( void )

Definition at line 1703 of file snapmgr.c.

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

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

Referenced by TestForOldSnapshot_impl().

◆ GetSnapshotCurrentTimestamp()

TimestampTz GetSnapshotCurrentTimestamp ( void )

Definition at line 1678 of file snapmgr.c.

 {
     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;
 }

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

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

◆ GetTransactionSnapshot()

Snapshot GetTransactionSnapshot ( void )

Definition at line 250 of file snapmgr.c.

 {
     /*
      * 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;
 }

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

Referenced by _bt_begin_parallel(), _SPI_execute_plan(), AfterTriggerFireDeferred(), AfterTriggerSetState(), begin_replication_step(), bt_check_every_level(), BuildCachedPlan(), CheckTargetForConflictsIn(), cluster_multiple_rels(), DefineIndex(), EnsurePortalSnapshotExists(), exec_bind_message(), exec_eval_simple_expr(), exec_parse_message(), exec_simple_query(), execute_sql_string(), ExecuteCallStmt(), fmgr_sql(), get_database_list(), get_subscription_list(), GetLatestSnapshot(), HandleFunctionRequest(), heapam_index_build_range_scan(), initialize_worker_spi(), InitializeParallelDSM(), InitPostgres(), LogicalRepSyncTableStart(), pg_get_constraintdef_worker(), PortalRunMulti(), PortalRunUtility(), PortalStart(), ReindexMultipleInternal(), ReindexRelationConcurrently(), RemoveTempRelationsCallback(), RevalidateCachedQuery(), ri_PerformCheck(), SPI_cursor_open_internal(), vacuum(), vacuum_rel(), verify_heapam(), and XidIsConcurrent().

◆ HaveRegisteredOrActiveSnapshot()

bool HaveRegisteredOrActiveSnapshot ( void )

Definition at line 1639 of file snapmgr.c.

 {
     if (ActiveSnapshot != NULL)
         return true;
  
     /*
      * The catalog snapshot is in RegisteredSnapshots when valid, but can be
      * removed at any time due to invalidation processing. If explicitly
      * registered more than one snapshot has to be in RegisteredSnapshots.
      */
     if (CatalogSnapshot != NULL &&
         pairingheap_is_singular(&RegisteredSnapshots))
         return false;
  
     return !pairingheap_is_empty(&RegisteredSnapshots);
 }

References ActiveSnapshot, CatalogSnapshot, pairingheap_is_empty, pairingheap_is_singular, and RegisteredSnapshots.

Referenced by init_toast_snapshot().

◆ HistoricSnapshotActive()

bool HistoricSnapshotActive ( void )

Definition at line 2101 of file snapmgr.c.

 {
     return HistoricSnapshot != NULL;
 }

References HistoricSnapshot.

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

◆ HistoricSnapshotGetTupleCids()

HTAB* HistoricSnapshotGetTupleCids ( void )

Definition at line 2107 of file snapmgr.c.

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

References Assert(), HistoricSnapshotActive(), and tuplecid_data.

Referenced by HeapTupleSatisfiesHistoricMVCC().

◆ ImportSnapshot()

void ImportSnapshot ( const char * idstr )

Definition at line 1394 of file snapmgr.c.

 {
     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);
 }

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().

◆ InvalidateCatalogSnapshot()

void InvalidateCatalogSnapshot ( void )

Definition at line 456 of file snapmgr.c.

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

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

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

◆ InvalidateCatalogSnapshotConditionally()

void InvalidateCatalogSnapshotConditionally ( void )

Definition at line 477 of file snapmgr.c.

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

References ActiveSnapshot, CatalogSnapshot, InvalidateCatalogSnapshot(), pairingheap_is_singular, and RegisteredSnapshots.

Referenced by PostgresMain().

◆ MaintainOldSnapshotTimeMapping()

void MaintainOldSnapshotTimeMapping	(	TimestampTz	whenTaken,
		TransactionId	xmin
	)

Definition at line 1901 of file snapmgr.c.

 {
     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);
 }

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, oldSnapshotControl, SpinLockAcquire, SpinLockRelease, TransactionIdFollows(), TransactionIdIsNormal, TransactionIdPrecedes(), USECS_PER_MINUTE, and OldSnapshotControlData::xid_by_minute.

Referenced by GetSnapshotDataInitOldSnapshot().

◆ parseIntFromText()

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

static

Definition at line 1314 of file snapmgr.c.

 {
     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;
 }

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

Referenced by ImportSnapshot().

◆ parseVxidFromText()

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

static

Definition at line 1364 of file snapmgr.c.

 {
     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;
 }

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

Referenced by ImportSnapshot().

◆ parseXidFromText()

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

static

Definition at line 1339 of file snapmgr.c.

 {
     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;
 }

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

Referenced by ImportSnapshot().

◆ pg_export_snapshot()

Datum pg_export_snapshot ( PG_FUNCTION_ARGS )

Definition at line 1299 of file snapmgr.c.

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

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

◆ PopActiveSnapshot()

void PopActiveSnapshot ( void )

Definition at line 776 of file snapmgr.c.

 {
     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();
 }

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

Referenced by _SPI_execute_plan(), AfterTriggerFireDeferred(), AfterTriggerSetState(), ATExecDetachPartition(), BuildCachedPlan(), cluster_multiple_rels(), DefineIndex(), DoPortalRewind(), end_replication_step(), EndCopyTo(), exec_bind_message(), exec_eval_simple_expr(), exec_parse_message(), exec_simple_query(), ExecCreateTableAs(), execute_sql_string(), ExecuteCallStmt(), ExplainOnePlan(), fmgr_sql(), ForgetPortalSnapshots(), HandleFunctionRequest(), index_drop(), initialize_worker_spi(), LogicalRepSyncTableStart(), movedb(), ParallelWorkerMain(), PersistHoldablePortal(), PortalRunMulti(), PortalRunSelect(), PortalRunUtility(), PortalStart(), refresh_matview_datafill(), ReindexMultipleInternal(), ReindexRelationConcurrently(), RelationFindReplTupleByIndex(), RelationFindReplTupleSeq(), RemoveTempRelationsCallback(), RevalidateCachedQuery(), ShutdownSQLFunction(), vacuum(), and vacuum_rel().

◆ PushActiveSnapshot()

void PushActiveSnapshot ( Snapshot snap )

Definition at line 682 of file snapmgr.c.

 {
     PushActiveSnapshotWithLevel(snap, GetCurrentTransactionNestLevel());
 }

References GetCurrentTransactionNestLevel(), and PushActiveSnapshotWithLevel().

Referenced by _SPI_execute_plan(), AfterTriggerFireDeferred(), AfterTriggerSetState(), begin_replication_step(), BuildCachedPlan(), cluster_multiple_rels(), DefineIndex(), DoPortalRewind(), exec_bind_message(), exec_eval_simple_expr(), exec_parse_message(), exec_simple_query(), execute_sql_string(), ExecuteCallStmt(), fmgr_sql(), HandleFunctionRequest(), initialize_worker_spi(), LogicalRepSyncTableStart(), ParallelWorkerMain(), PersistHoldablePortal(), PortalRunSelect(), PortalStart(), PushCopiedSnapshot(), ReindexMultipleInternal(), ReindexRelationConcurrently(), RelationFindReplTupleByIndex(), RelationFindReplTupleSeq(), RemoveTempRelationsCallback(), RevalidateCachedQuery(), ShutdownSQLFunction(), vacuum(), and vacuum_rel().

◆ PushActiveSnapshotWithLevel()

void PushActiveSnapshotWithLevel	(	Snapshot	snap,
		int	snap_level
	)

Definition at line 696 of file snapmgr.c.

 {
     ActiveSnapshotElt *newactive;
  
     Assert(snap != InvalidSnapshot);
     Assert(ActiveSnapshot == NULL || snap_level >= ActiveSnapshot->as_level);
  
     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 = snap_level;
  
     newactive->as_snap->active_count++;
  
     ActiveSnapshot = newactive;
     if (OldestActiveSnapshot == NULL)
         OldestActiveSnapshot = ActiveSnapshot;
 }

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

Referenced by EnsurePortalSnapshotExists(), PortalRunUtility(), and PushActiveSnapshot().

◆ PushCopiedSnapshot()

void PushCopiedSnapshot ( Snapshot snapshot )

Definition at line 733 of file snapmgr.c.

 {
     PushActiveSnapshot(CopySnapshot(snapshot));
 }

References CopySnapshot(), and PushActiveSnapshot().

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

◆ RegisterSnapshot()

Snapshot RegisterSnapshot ( Snapshot snapshot )

Definition at line 827 of file snapmgr.c.

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

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(), pg_get_constraintdef_worker(), 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().

◆ RegisterSnapshotOnOwner()

Snapshot RegisterSnapshotOnOwner	(	Snapshot	snapshot,
		ResourceOwner	owner
	)

Definition at line 840 of file snapmgr.c.

 {
     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;
 }

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

Referenced by be_lo_open(), and RegisterSnapshot().

◆ RestoreSnapshot()

Snapshot RestoreSnapshot ( char * start_address )

Definition at line 2204 of file snapmgr.c.

 {
     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;
 }

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

◆ RestoreTransactionSnapshot()

void RestoreTransactionSnapshot	(	Snapshot	snapshot,
		void *	source_pgproc
	)

Definition at line 2269 of file snapmgr.c.

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

References InvalidPid, and SetTransactionSnapshot().

Referenced by CreateReplicationSlot(), and ParallelWorkerMain().

◆ SerializeSnapshot()

void SerializeSnapshot	(	Snapshot	snapshot,
		char *	start_address
	)

Definition at line 2145 of file snapmgr.c.

 {
     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));
     }
 }

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

◆ SetOldSnapshotThresholdTimestamp()

void SetOldSnapshotThresholdTimestamp	(	TimestampTz	ts,
		TransactionId	xlimit
	)

Definition at line 1715 of file snapmgr.c.

 {
     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);
 }

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

Referenced by heap_prune_satisfies_vacuum(), and vacuum_set_xid_limits().

◆ SetTransactionSnapshot()

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

static

Definition at line 511 of file snapmgr.c.

 {
     /* 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());
     if (sourcesnap->xcnt > 0)
         memcpy(CurrentSnapshot->xip, sourcesnap->xip,
                sourcesnap->xcnt * sizeof(TransactionId));
     CurrentSnapshot->subxcnt = sourcesnap->subxcnt;
     Assert(sourcesnap->subxcnt <= GetMaxSnapshotSubxidCount());
     if (sourcesnap->subxcnt > 0)
         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;
 }

References Assert(), CopySnapshot(), CurrentSnapshot, CurrentSnapshotData, ereport, errcode(), errdetail(), errmsg(), ERROR, FirstSnapshotSet, FirstXactSnapshot, GetMaxSnapshotSubxidCount(), GetMaxSnapshotXidCount(), GetSnapshotData(), HistoricSnapshotActive(), InvalidateCatalogSnapshot(), IsolationIsSerializable, IsolationUsesXactSnapshot, pairingheap_add(), pairingheap_is_empty, SnapshotData::ph_node, ProcArrayInstallImportedXmin(), ProcArrayInstallRestoredXmin(), SnapshotData::regd_count, RegisteredSnapshots, 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().

◆ SetupHistoricSnapshot()

void SetupHistoricSnapshot	(	Snapshot	historic_snapshot,
		HTAB *	tuplecids
	)

Definition at line 2078 of file snapmgr.c.

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

References Assert(), HistoricSnapshot, and tuplecid_data.

Referenced by ReorderBufferProcessTXN(), and ReorderBufferQueueMessage().

◆ SnapMgrInit()

void SnapMgrInit ( void )

Definition at line 213 of file snapmgr.c.

 {
     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;
     }
 }

Referenced by CreateSharedMemoryAndSemaphores().

◆ SnapMgrShmemSize()

Size SnapMgrShmemSize ( void )

Definition at line 197 of file snapmgr.c.

 {
     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;
 }

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

Referenced by CalculateShmemSize(), and SnapMgrInit().

◆ SnapshotResetXmin()

static void SnapshotResetXmin ( void )

static

Definition at line 942 of file snapmgr.c.

 {
     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;
 }

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

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

◆ SnapshotSetCommandId()

void SnapshotSetCommandId ( CommandId curcid )

Definition at line 490 of file snapmgr.c.

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

References SnapshotData::curcid, CurrentSnapshot, FirstSnapshotSet, and SecondarySnapshot.

Referenced by CommandCounterIncrement().

◆ SnapshotTooOldMagicForTest()

void SnapshotTooOldMagicForTest ( void )

Definition at line 1732 of file snapmgr.c.

 {
     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);
 }

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

Referenced by heap_page_prune_opt().

◆ TeardownHistoricSnapshot()

void TeardownHistoricSnapshot ( bool is_error )

Definition at line 2094 of file snapmgr.c.

 {
     HistoricSnapshot = NULL;
     tuplecid_data = NULL;
 }

References HistoricSnapshot, and tuplecid_data.

Referenced by ReorderBufferProcessTXN(), and ReorderBufferQueueMessage().

◆ ThereAreNoPriorRegisteredSnapshots()

bool ThereAreNoPriorRegisteredSnapshots ( void )

Definition at line 1621 of file snapmgr.c.

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

References pairingheap_is_empty, pairingheap_is_singular, and RegisteredSnapshots.

Referenced by CopyFrom().

◆ TransactionIdLimitedForOldSnapshots()

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

Definition at line 1794 of file snapmgr.c.

 {
     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;
 }

References AlignTimestampToMinuteBoundary(), Assert(), GetOldSnapshotFromTimeMapping(), GetSnapshotCurrentTimestamp(), OldSnapshotControlData::latest_xmin, OldSnapshotControlData::mutex_latest_xmin, OldSnapshotControlData::mutex_threshold, MyProc, OldSnapshotControlData::next_map_update, old_snapshot_threshold, oldSnapshotControl, 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(), and vacuum_set_xid_limits().

◆ UnregisterSnapshot()

void UnregisterSnapshot ( Snapshot snapshot )

Definition at line 869 of file snapmgr.c.

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

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(), pg_get_constraintdef_worker(), process_settings(), ReindexRelationConcurrently(), ResourceOwnerReleaseInternal(), standard_ExecutorEnd(), systable_endscan(), systable_endscan_ordered(), validateDomainConstraint(), and validateForeignKeyConstraint().

◆ UnregisterSnapshotFromOwner()

void UnregisterSnapshotFromOwner	(	Snapshot	snapshot,
		ResourceOwner	owner
	)

Definition at line 882 of file snapmgr.c.

 {
     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();
     }
 }

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

Referenced by closeLOfd(), PortalDrop(), PreCommit_Portals(), and UnregisterSnapshot().

◆ UpdateActiveSnapshotCommandId()

void UpdateActiveSnapshotCommandId ( void )

Definition at line 745 of file snapmgr.c.

 {
     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;
 }

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

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

◆ XactHasExportedSnapshots()

bool XactHasExportedSnapshots ( void )

Definition at line 1569 of file snapmgr.c.

 {
     return (exportedSnapshots != NIL);
 }

References exportedSnapshots, and NIL.

Referenced by PrepareTransaction().

◆ XidInMVCCSnapshot()

bool XidInMVCCSnapshot	(	TransactionId	xid,
		Snapshot	snapshot
	)

Definition at line 2285 of file snapmgr.c.

 {
     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;
 }

References i, j, 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_extended(), HeapTupleSatisfiesMVCC(), and RelationGetPartitionDesc().

◆ xmin_cmp()

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

static

Definition at line 908 of file snapmgr.c.

 {
     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;
 }

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

Variable Documentation

◆ ActiveSnapshot

ActiveSnapshotElt* ActiveSnapshot = NULL

static

Definition at line 134 of file snapmgr.c.

Referenced by ActiveSnapshotSet(), AtEOXact_Snapshot(), AtSubAbort_Snapshot(), AtSubCommit_Snapshot(), GetActiveSnapshot(), HaveRegisteredOrActiveSnapshot(), InvalidateCatalogSnapshotConditionally(), PopActiveSnapshot(), PushActiveSnapshotWithLevel(), SnapshotResetXmin(), and UpdateActiveSnapshotCommandId().

◆ CatalogSnapshot

Snapshot CatalogSnapshot = NULL

static

Definition at line 104 of file snapmgr.c.

Referenced by GetNonHistoricCatalogSnapshot(), HaveRegisteredOrActiveSnapshot(), InvalidateCatalogSnapshot(), and InvalidateCatalogSnapshotConditionally().

◆ CatalogSnapshotData

SnapshotData CatalogSnapshotData = {SNAPSHOT_MVCC}

Definition at line 97 of file snapmgr.c.

Referenced by GetNonHistoricCatalogSnapshot().

◆ CurrentSnapshot

Snapshot CurrentSnapshot = NULL

static

Definition at line 102 of file snapmgr.c.

Referenced by AtEOXact_Snapshot(), GetTransactionSnapshot(), PushActiveSnapshotWithLevel(), SetTransactionSnapshot(), and SnapshotSetCommandId().

◆ CurrentSnapshotData

SnapshotData CurrentSnapshotData = {SNAPSHOT_MVCC}

static

Definition at line 95 of file snapmgr.c.

Referenced by GetTransactionSnapshot(), and SetTransactionSnapshot().

◆ exportedSnapshots

List* exportedSnapshots = NIL

static

Definition at line 169 of file snapmgr.c.

Referenced by AtEOXact_Snapshot(), ExportSnapshot(), and XactHasExportedSnapshots().

◆ 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.

Referenced by AtEOXact_Snapshot(), GetTransactionSnapshot(), and SetTransactionSnapshot().

◆ HistoricSnapshot

Snapshot HistoricSnapshot = NULL

static

Definition at line 105 of file snapmgr.c.

Referenced by GetCatalogSnapshot(), GetTransactionSnapshot(), HistoricSnapshotActive(), SetupHistoricSnapshot(), and TeardownHistoricSnapshot().

◆ 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.

Referenced by AtEOXact_Snapshot(), AtSubAbort_Snapshot(), GetOldestSnapshot(), PopActiveSnapshot(), and PushActiveSnapshotWithLevel().

◆ oldSnapshotControl

volatile OldSnapshotControlData* oldSnapshotControl

Definition at line 80 of file snapmgr.c.

Referenced by GetOldSnapshotFromTimeMapping(), GetOldSnapshotThresholdTimestamp(), GetOldSnapshotTimeMapping(), GetSnapshotCurrentTimestamp(), MaintainOldSnapshotTimeMapping(), SetOldSnapshotThresholdTimestamp(), SnapMgrInit(), SnapshotTooOldMagicForTest(), and TransactionIdLimitedForOldSnapshots().

◆ 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.

Referenced by AtEOXact_Snapshot(), ExportSnapshot(), GetNonHistoricCatalogSnapshot(), GetOldestSnapshot(), GetTransactionSnapshot(), HaveRegisteredOrActiveSnapshot(), InvalidateCatalogSnapshot(), InvalidateCatalogSnapshotConditionally(), RegisterSnapshotOnOwner(), SetTransactionSnapshot(), SnapshotResetXmin(), ThereAreNoPriorRegisteredSnapshots(), and UnregisterSnapshotFromOwner().

◆ SecondarySnapshot

Snapshot SecondarySnapshot = NULL

static

Definition at line 103 of file snapmgr.c.

Referenced by AtEOXact_Snapshot(), GetLatestSnapshot(), PushActiveSnapshotWithLevel(), and SnapshotSetCommandId().

◆ SecondarySnapshotData

SnapshotData SecondarySnapshotData = {SNAPSHOT_MVCC}

static

Definition at line 96 of file snapmgr.c.

Referenced by GetLatestSnapshot().

◆ 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 ApplyLogicalMappingFile(), HistoricSnapshotGetTupleCids(), ResolveCminCmaxDuringDecoding(), SetupHistoricSnapshot(), TeardownHistoricSnapshot(), and UpdateLogicalMappings().

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()

◆ HaveRegisteredOrActiveSnapshot()

◆ HistoricSnapshotActive()

◆ HistoricSnapshotGetTupleCids()

◆ ImportSnapshot()

◆ InvalidateCatalogSnapshot()

◆ InvalidateCatalogSnapshotConditionally()

◆ MaintainOldSnapshotTimeMapping()

◆ parseIntFromText()

◆ parseVxidFromText()

◆ parseXidFromText()

◆ pg_export_snapshot()

◆ PopActiveSnapshot()

◆ PushActiveSnapshot()

◆ PushActiveSnapshotWithLevel()

◆ 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