#include "postgres.h"
#include <sys/stat.h>
#include <unistd.h>
#include "access/transam.h"
#include "access/xact.h"
#include "access/xlog.h"
#include "catalog/catalog.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/rel.h"
#include "utils/resowner_private.h"
#include "utils/snapmgr.h"
#include "utils/syscache.h"
#include "utils/tqual.h"

Include dependency graph for snapmgr.c:

Data Structures
struct	OldSnapshotControlData

struct	ActiveSnapshotElt

struct	ExportedSnapshot

struct	SerializedSnapshotData

Macros
#define	SNAPSHOT_EXPORT_DIR "pg_snapshots"

Typedefs
typedef struct OldSnapshotControlData	OldSnapshotControlData

typedef struct ActiveSnapshotElt	ActiveSnapshotElt

typedef struct ExportedSnapshot	ExportedSnapshot

typedef struct SerializedSnapshotData	SerializedSnapshotData

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

static TimestampTz	AlignTimestampToMinuteBoundary (TimestampTz ts)

static Snapshot	CopySnapshot (Snapshot snapshot)

static void	FreeSnapshot (Snapshot snapshot)

static void	SnapshotResetXmin (void)

Size	SnapMgrShmemSize (void)

void	SnapMgrInit (void)

Snapshot	GetTransactionSnapshot (void)

Snapshot	GetLatestSnapshot (void)

Snapshot	GetOldestSnapshot (void)

Snapshot	GetCatalogSnapshot (Oid relid)

Snapshot	GetNonHistoricCatalogSnapshot (Oid relid)

void	InvalidateCatalogSnapshot (void)

void	InvalidateCatalogSnapshotConditionally (void)

void	SnapshotSetCommandId (CommandId curcid)

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

void	PushActiveSnapshot (Snapshot snap)

void	PushCopiedSnapshot (Snapshot snapshot)

void	UpdateActiveSnapshotCommandId (void)

void	PopActiveSnapshot (void)

Snapshot	GetActiveSnapshot (void)

bool	ActiveSnapshotSet (void)

Snapshot	RegisterSnapshot (Snapshot snapshot)

Snapshot	RegisterSnapshotOnOwner (Snapshot snapshot, ResourceOwner owner)

void	UnregisterSnapshot (Snapshot snapshot)

void	UnregisterSnapshotFromOwner (Snapshot snapshot, ResourceOwner owner)

void	AtSubCommit_Snapshot (int level)

void	AtSubAbort_Snapshot (int level)

void	AtEOXact_Snapshot (bool isCommit, bool resetXmin)

char *	ExportSnapshot (Snapshot snapshot)

Datum	pg_export_snapshot (PG_FUNCTION_ARGS)

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

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

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

void	ImportSnapshot (const char *idstr)

bool	XactHasExportedSnapshots (void)

void	DeleteAllExportedSnapshotFiles (void)

bool	ThereAreNoPriorRegisteredSnapshots (void)

TimestampTz	GetSnapshotCurrentTimestamp (void)

TimestampTz	GetOldSnapshotThresholdTimestamp (void)

static void	SetOldSnapshotThresholdTimestamp (TimestampTz ts, TransactionId xlimit)

TransactionId	TransactionIdLimitedForOldSnapshots (TransactionId recentXmin, Relation relation)

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 *master_pgproc)

Variables
int	old_snapshot_threshold

static volatile OldSnapshotControlData *	oldSnapshotControl

static SnapshotData	CurrentSnapshotData = {HeapTupleSatisfiesMVCC}

static SnapshotData	SecondarySnapshotData = {HeapTupleSatisfiesMVCC}

SnapshotData	CatalogSnapshotData = {HeapTupleSatisfiesMVCC}

static Snapshot	CurrentSnapshot = NULL

static Snapshot	SecondarySnapshot = NULL

static Snapshot	CatalogSnapshot = NULL

static Snapshot	HistoricSnapshot = NULL

TransactionId	TransactionXmin = FirstNormalTransactionId

TransactionId	RecentXmin = FirstNormalTransactionId

TransactionId	RecentGlobalXmin = InvalidTransactionId

TransactionId	RecentGlobalDataXmin = InvalidTransactionId

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

#define SNAPSHOT_EXPORT_DIR "pg_snapshots"

Definition at line 213 of file snapmgr.c.

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

Typedef Documentation

typedef struct ActiveSnapshotElt ActiveSnapshotElt

typedef struct ExportedSnapshot ExportedSnapshot

typedef struct OldSnapshotControlData OldSnapshotControlData

typedef struct SerializedSnapshotData SerializedSnapshotData

Function Documentation

bool ActiveSnapshotSet ( void )

Definition at line 851 of file snapmgr.c.

References NULL.

Referenced by _SPI_execute_plan(), BuildCachedPlan(), pg_plan_query(), PortalRunUtility(), postquel_start(), RevalidateCachedQuery(), and vacuum().

 {
     return ActiveSnapshot != NULL;
 }

static TimestampTz AlignTimestampToMinuteBoundary ( TimestampTz ts )

static

Definition at line 1666 of file snapmgr.c.

References USECS_PER_MINUTE.

Referenced by MaintainOldSnapshotTimeMapping(), and TransactionIdLimitedForOldSnapshots().

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

void AtEOXact_Snapshot	(	bool	isCommit,
		bool	resetXmin
	)

Definition at line 1059 of file snapmgr.c.

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

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

 {
     /*
      * In transaction-snapshot mode we must release our privately-managed
      * reference to the transaction snapshot.  We must remove it from
      * RegisteredSnapshots to keep the check below happy.  But we don't bother
      * to do FreeSnapshot, for two reasons: the memory will go away with
      * TopTransactionContext anyway, and if someone has left the snapshot
      * stacked as active, we don't want the code below to be chasing through a
      * dangling pointer.
      */
     if (FirstXactSnapshot != NULL)
     {
         Assert(FirstXactSnapshot->regd_count > 0);
         Assert(!pairingheap_is_empty(&RegisteredSnapshots));
         pairingheap_remove(&RegisteredSnapshots, &FirstXactSnapshot->ph_node);
     }
     FirstXactSnapshot = NULL;
 
     /*
      * If we exported any snapshots, clean them up.
      */
     if (exportedSnapshots != NIL)
     {
         ListCell   *lc;
 
         /*
          * Get rid of the files.  Unlink failure is only a WARNING because (1)
          * it's too late to abort the transaction, and (2) leaving a leaked
          * file around has little real consequence anyway.
          *
          * We also 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 iself 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 PgXact->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 || MyPgXact->xmin == 0);
 }

void AtSubAbort_Snapshot ( int level )

Definition at line 1023 of file snapmgr.c.

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

Referenced by AbortSubTransaction().

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

void AtSubCommit_Snapshot ( int level )

Definition at line 1002 of file snapmgr.c.

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

Referenced by CommitSubTransaction().

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

static Snapshot CopySnapshot ( Snapshot snapshot )

static

Definition at line 660 of file snapmgr.c.

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

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

 {
     Snapshot    newsnap;
     Size        subxipoff;
     Size        size;
 
     Assert(snapshot != InvalidSnapshot);
 
     /* We allocate any XID arrays needed in the same palloc block. */
     size = subxipoff = sizeof(SnapshotData) +
         snapshot->xcnt * sizeof(TransactionId);
     if (snapshot->subxcnt > 0)
         size += snapshot->subxcnt * sizeof(TransactionId);
 
     newsnap = (Snapshot) MemoryContextAlloc(TopTransactionContext, size);
     memcpy(newsnap, snapshot, sizeof(SnapshotData));
 
     newsnap->regd_count = 0;
     newsnap->active_count = 0;
     newsnap->copied = true;
 
     /* 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;
 }

void DeleteAllExportedSnapshotFiles ( void )

Definition at line 1616 of file snapmgr.c.

References AllocateDir(), buf, dirent::d_name, elog, FreeDir(), LOG, MAXPGPATH, NULL, ReadDir(), SNAPSHOT_EXPORT_DIR, snprintf(), and unlink().

Referenced by StartupXLOG().

 {
     char        buf[MAXPGPATH + sizeof(SNAPSHOT_EXPORT_DIR)];
     DIR        *s_dir;
     struct dirent *s_de;
 
     if (!(s_dir = AllocateDir(SNAPSHOT_EXPORT_DIR)))
     {
         /*
          * We really should have that directory in a sane cluster setup. But
          * then again if we don't, it's not fatal enough to make it FATAL.
          * Since we're running in the postmaster, LOG is our best bet.
          */
         elog(LOG, "could not open directory \"%s\": %m", SNAPSHOT_EXPORT_DIR);
         return;
     }
 
     while ((s_de = ReadDir(s_dir, SNAPSHOT_EXPORT_DIR)) != 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);
         /* Again, unlink failure is not worthy of FATAL */
         if (unlink(buf))
             elog(LOG, "could not unlink file \"%s\": %m", buf);
     }
 
     FreeDir(s_dir);
 }

Size EstimateSnapshotSpace ( Snapshot snap )

Definition at line 2038 of file snapmgr.c.

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

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

 {
     Size        size;
 
     Assert(snap != InvalidSnapshot);
     Assert(snap->satisfies == HeapTupleSatisfiesMVCC);
 
     /* 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;
 }

char* ExportSnapshot ( Snapshot snapshot )

Definition at line 1159 of file snapmgr.c.

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

Referenced by pg_export_snapshot(), and SnapBuildExportSnapshot().

 {
     TransactionId topXid;
     TransactionId *children;
     ExportedSnapshot *esnap;
     int         nchildren;
     int         addTopXid;
     StringInfoData buf;
     FILE       *f;
     int         i;
     MemoryContext oldcxt;
     char        path[MAXPGPATH];
     char        pathtmp[MAXPGPATH];
 
     /*
      * It's tempting to call RequireTransactionChain 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);
 }

static void FreeSnapshot ( Snapshot snapshot )

static

Definition at line 715 of file snapmgr.c.

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

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

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

Snapshot GetActiveSnapshot ( void )

Definition at line 839 of file snapmgr.c.

References ActiveSnapshotElt::as_snap, Assert, and NULL.

Referenced by _SPI_execute_plan(), BeginCopy(), CopyTo(), ExecCreateTableAs(), ExecParallelGetQueryDesc(), execute_sql_string(), ExecuteQuery(), ExplainOnePlan(), InitializeParallelDSM(), inv_open(), PerformCursorOpen(), pg_export_snapshot(), pgrowlocks(), PortalRunUtility(), PortalStart(), postquel_start(), ProcessQuery(), refresh_matview_datafill(), spgvacuumscan(), SPI_cursor_open_internal(), txid_current_snapshot(), and txid_status().

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

Snapshot GetCatalogSnapshot ( Oid relid )

Definition at line 440 of file snapmgr.c.

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

Referenced by heap_beginscan_catalog(), process_settings(), ScanPgRelation(), systable_beginscan(), systable_beginscan_ordered(), and systable_recheck_tuple().

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

Snapshot GetLatestSnapshot ( void )

Definition at line 379 of file snapmgr.c.

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

Referenced by AlterDomainNotNull(), ATRewriteTable(), currtid_byrelname(), currtid_byreloid(), DefineQueryRewrite(), IndexCheckExclusion(), pgstat_collect_oids(), RelationFindReplTupleByIndex(), RelationFindReplTupleSeq(), RI_Initial_Check(), ri_PerformCheck(), validateCheckConstraint(), validateDomainConstraint(), validateForeignKeyConstraint(), and wait_for_relation_state_change().

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

Snapshot GetNonHistoricCatalogSnapshot ( Oid relid )

Definition at line 462 of file snapmgr.c.

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

Referenced by GetCatalogSnapshot(), and ScanPgRelation().

 {
     /*
      * If the caller is trying to scan a relation that has no syscache, no
      * catcache invalidations will be sent when it is updated.  For a few key
      * relations, snapshot invalidations are sent instead.  If we're trying to
      * scan a relation for which neither catcache nor snapshot invalidations
      * are sent, we must refresh the snapshot every time.
      */
     if (CatalogSnapshot &&
         !RelationInvalidatesSnapshotsOnly(relid) &&
         !RelationHasSysCache(relid))
         InvalidateCatalogSnapshot();
 
     if (CatalogSnapshot == NULL)
     {
         /* Get new snapshot. */
         CatalogSnapshot = GetSnapshotData(&CatalogSnapshotData);
 
         /*
          * Make sure the catalog snapshot will be accounted for in decisions
          * about advancing PGXACT->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;
 }

Snapshot GetOldestSnapshot ( void )

Definition at line 411 of file snapmgr.c.

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

Referenced by init_toast_snapshot().

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

TimestampTz GetOldSnapshotThresholdTimestamp ( void )

Definition at line 1705 of file snapmgr.c.

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

Referenced by TestForOldSnapshot_impl().

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

TimestampTz GetSnapshotCurrentTimestamp ( void )

Definition at line 1680 of file snapmgr.c.

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

Referenced by GetSnapshotData(), and TransactionIdLimitedForOldSnapshots().

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

Snapshot GetTransactionSnapshot ( void )

Definition at line 304 of file snapmgr.c.

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

Referenced by _SPI_execute_plan(), AfterTriggerFireDeferred(), AfterTriggerSetState(), apply_handle_delete(), apply_handle_insert(), apply_handle_update(), BuildCachedPlan(), CheckTargetForConflictsIn(), cluster(), DefineIndex(), exec_bind_message(), exec_eval_simple_expr(), exec_parse_message(), exec_simple_query(), execute_sql_string(), fmgr_sql(), get_database_list(), get_subscription_list(), GetLatestSnapshot(), HandleFunctionRequest(), IndexBuildHeapRangeScan(), initialize_worker_spi(), InitializeParallelDSM(), InitPostgres(), LogicalRepSyncTableStart(), pg_get_constraintdef_worker(), PortalRunMulti(), PortalRunUtility(), PortalStart(), ReindexMultipleTables(), RevalidateCachedQuery(), ri_PerformCheck(), SPI_cursor_open_internal(), vacuum(), vacuum_rel(), and XidIsConcurrent().

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

bool HistoricSnapshotActive ( void )

Definition at line 2018 of file snapmgr.c.

References NULL.

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

 {
     return HistoricSnapshot != NULL;
 }

HTAB* HistoricSnapshotGetTupleCids ( void )

Definition at line 2024 of file snapmgr.c.

References Assert, HistoricSnapshotActive(), and tuplecid_data.

Referenced by HeapTupleSatisfiesHistoricMVCC().

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

void ImportSnapshot ( const char * idstr )

Definition at line 1430 of file snapmgr.c.

References AllocateFile(), elog, ereport, errcode(), errmsg(), ERROR, FirstSnapshotSet, FreeFile(), GetMaxSnapshotSubxidCount(), GetMaxSnapshotXidCount(), GetTopTransactionIdIfAny(), i, InvalidTransactionId, IsolationIsSerializable, IsolationUsesXactSnapshot, IsSubTransaction(), MAXPGPATH, MyDatabaseId, NULL, OidIsValid, palloc(), parseIntFromText(), parseVxidFromText(), parseXidFromText(), PG_BINARY_R, SetTransactionSnapshot(), SNAPSHOT_EXPORT_DIR, snprintf(), 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().

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

void InvalidateCatalogSnapshot ( void )

Definition at line 510 of file snapmgr.c.

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

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

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

void InvalidateCatalogSnapshotConditionally ( void )

Definition at line 531 of file snapmgr.c.

References InvalidateCatalogSnapshot(), NULL, and pairingheap_is_singular.

Referenced by PostgresMain().

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

void MaintainOldSnapshotTimeMapping	(	TimestampTz	whenTaken,
		TransactionId	xmin
	)

Definition at line 1842 of file snapmgr.c.

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

Referenced by GetSnapshotData().

 {
     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         advance = ((ts - oldSnapshotControl->head_timestamp)
                                / USECS_PER_MINUTE);
 
         oldSnapshotControl->head_timestamp = ts;
 
         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;
         }
         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;
                 }
                 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);
 }

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

static

Definition at line 1350 of file snapmgr.c.

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

Referenced by ImportSnapshot().

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

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

static

Definition at line 1400 of file snapmgr.c.

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

Referenced by ImportSnapshot().

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

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

static

Definition at line 1375 of file snapmgr.c.

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

Referenced by ImportSnapshot().

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

Datum pg_export_snapshot ( PG_FUNCTION_ARGS )

Definition at line 1335 of file snapmgr.c.

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

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

void PopActiveSnapshot ( void )

Definition at line 812 of file snapmgr.c.

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

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

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

void PushActiveSnapshot ( Snapshot snap )

Definition at line 733 of file snapmgr.c.

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

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

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

void PushCopiedSnapshot ( Snapshot snapshot )

Definition at line 769 of file snapmgr.c.

References CopySnapshot(), and PushActiveSnapshot().

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

 {
     PushActiveSnapshot(CopySnapshot(snapshot));
 }

Snapshot RegisterSnapshot ( Snapshot snapshot )

Definition at line 863 of file snapmgr.c.

References CurrentResourceOwner, InvalidSnapshot, and RegisterSnapshotOnOwner().

Referenced by AlterDomainNotNull(), ATRewriteTable(), CreateQueryDesc(), currtid_byrelname(), currtid_byreloid(), DefineIndex(), DefineQueryRewrite(), heap_beginscan_catalog(), heap_beginscan_parallel(), heap_update_snapshot(), index_beginscan_parallel(), IndexBuildHeapRangeScan(), IndexCheckExclusion(), pg_get_constraintdef_worker(), pgstat_collect_oids(), PortalRunMulti(), PortalRunUtility(), process_settings(), standard_ExecutorStart(), systable_beginscan(), systable_beginscan_ordered(), validateCheckConstraint(), validateDomainConstraint(), and validateForeignKeyConstraint().

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

Snapshot RegisterSnapshotOnOwner	(	Snapshot	snapshot,
		ResourceOwner	owner
	)

Definition at line 876 of file snapmgr.c.

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

Referenced by inv_open(), and RegisterSnapshot().

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

Snapshot RestoreSnapshot ( char * start_address )

Definition at line 2121 of file snapmgr.c.

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

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

void RestoreTransactionSnapshot	(	Snapshot	snapshot,
		void *	master_pgproc
	)

Definition at line 2185 of file snapmgr.c.

References InvalidPid, NULL, and SetTransactionSnapshot().

Referenced by CreateReplicationSlot(), and ParallelWorkerMain().

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

void SerializeSnapshot	(	Snapshot	snapshot,
		char *	start_address
	)

Definition at line 2062 of file snapmgr.c.

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

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

static void SetOldSnapshotThresholdTimestamp	(	TimestampTz	ts,
		TransactionId	xlimit
	)

static

Definition at line 1717 of file snapmgr.c.

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

Referenced by TransactionIdLimitedForOldSnapshots().

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

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

static

Definition at line 565 of file snapmgr.c.

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

Referenced by ImportSnapshot(), and RestoreTransactionSnapshot().

 {
     /* Caller should have checked this already */
     Assert(!FirstSnapshotSet);
 
     /* Better do this to ensure following Assert succeeds. */
     InvalidateCatalogSnapshot();
 
     Assert(pairingheap_is_empty(&RegisteredSnapshots));
     Assert(FirstXactSnapshot == NULL);
     Assert(!HistoricSnapshotActive());
 
     /*
      * Even though we are not going to use the snapshot it computes, we must
      * call GetSnapshotData, for two reasons: (1) to be sure that
      * CurrentSnapshotData's XID arrays have been allocated, and (2) to update
      * RecentXmin and RecentGlobalXmin.  (We could alternatively include those
      * two variables in exported snapshot files, but it seems better to have
      * snapshot importers compute reasonably up-to-date values for them.)
      */
     CurrentSnapshot = GetSnapshotData(&CurrentSnapshotData);
 
     /*
      * Now copy appropriate fields from the source snapshot.
      */
     CurrentSnapshot->xmin = sourcesnap->xmin;
     CurrentSnapshot->xmax = sourcesnap->xmax;
     CurrentSnapshot->xcnt = sourcesnap->xcnt;
     Assert(sourcesnap->xcnt <= GetMaxSnapshotXidCount());
     memcpy(CurrentSnapshot->xip, sourcesnap->xip,
            sourcesnap->xcnt * sizeof(TransactionId));
     CurrentSnapshot->subxcnt = sourcesnap->subxcnt;
     Assert(sourcesnap->subxcnt <= GetMaxSnapshotSubxidCount());
     memcpy(CurrentSnapshot->subxip, sourcesnap->subxip,
            sourcesnap->subxcnt * sizeof(TransactionId));
     CurrentSnapshot->suboverflowed = sourcesnap->suboverflowed;
     CurrentSnapshot->takenDuringRecovery = sourcesnap->takenDuringRecovery;
     /* NB: curcid should NOT be copied, it's a local matter */
 
     /*
      * Now we have to fix what GetSnapshotData did with MyPgXact->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;
 }

void SetupHistoricSnapshot	(	Snapshot	historic_snapshot,
		HTAB *	tuplecids
	)

Definition at line 1995 of file snapmgr.c.

References Assert, and NULL.

Referenced by ReorderBufferCommit(), and ReorderBufferQueueMessage().

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

void SnapMgrInit ( void )

Definition at line 267 of file snapmgr.c.

Referenced by CreateSharedMemoryAndSemaphores().

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

Size SnapMgrShmemSize ( void )

Definition at line 251 of file snapmgr.c.

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

Referenced by CreateSharedMemoryAndSemaphores(), and SnapMgrInit().

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

static void SnapshotResetXmin ( void )

static

Definition at line 978 of file snapmgr.c.

References InvalidTransactionId, MyPgXact, NULL, pairingheap_container, pairingheap_first(), pairingheap_is_empty, TransactionIdPrecedes(), SnapshotData::xmin, and PGXACT::xmin.

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

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

void SnapshotSetCommandId ( CommandId curcid )

Definition at line 544 of file snapmgr.c.

References SnapshotData::curcid, and FirstSnapshotSet.

Referenced by CommandCounterIncrement().

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

void TeardownHistoricSnapshot ( bool is_error )

Definition at line 2011 of file snapmgr.c.

References NULL.

Referenced by ReorderBufferCommit(), and ReorderBufferQueueMessage().

 {
     HistoricSnapshot = NULL;
     tuplecid_data = NULL;
 }

bool ThereAreNoPriorRegisteredSnapshots ( void )

Definition at line 1649 of file snapmgr.c.

References pairingheap_is_empty, and pairingheap_is_singular.

Referenced by CopyFrom().

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

TransactionId TransactionIdLimitedForOldSnapshots	(	TransactionId	recentXmin,
		Relation	relation
	)

Definition at line 1735 of file snapmgr.c.

Referenced by heap_page_prune_opt(), and vacuum_set_xid_limits().

 {
     if (TransactionIdIsNormal(recentXmin)
         && old_snapshot_threshold >= 0
         && RelationAllowsEarlyPruning(relation))
     {
         TimestampTz ts = GetSnapshotCurrentTimestamp();
         TransactionId xlimit = recentXmin;
         TransactionId latest_xmin;
         TimestampTz update_ts;
         bool        same_ts_as_threshold = false;
 
         SpinLockAcquire(&oldSnapshotControl->mutex_latest_xmin);
         latest_xmin = oldSnapshotControl->latest_xmin;
         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, MyPgXact->xmin)
                 && TransactionIdFollows(latest_xmin, xlimit))
                 xlimit = latest_xmin;
 
             ts -= 5 * USECS_PER_SEC;
             SetOldSnapshotThresholdTimestamp(ts, xlimit);
 
             return xlimit;
         }
 
         ts = AlignTimestampToMinuteBoundary(ts)
             - (old_snapshot_threshold * USECS_PER_MINUTE);
 
         /* Check for fast exit without LW locking. */
         SpinLockAcquire(&oldSnapshotControl->mutex_threshold);
         if (ts == oldSnapshotControl->threshold_timestamp)
         {
             xlimit = oldSnapshotControl->threshold_xid;
             same_ts_as_threshold = true;
         }
         SpinLockRelease(&oldSnapshotControl->mutex_threshold);
 
         if (!same_ts_as_threshold)
         {
             if (ts == update_ts)
             {
                 xlimit = latest_xmin;
                 if (NormalTransactionIdFollows(xlimit, recentXmin))
                     SetOldSnapshotThresholdTimestamp(ts, xlimit);
             }
             else
             {
                 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;
                     xlimit = oldSnapshotControl->xid_by_minute[offset];
 
                     if (NormalTransactionIdFollows(xlimit, recentXmin))
                         SetOldSnapshotThresholdTimestamp(ts, xlimit);
                 }
 
                 LWLockRelease(OldSnapshotTimeMapLock);
             }
         }
 
         /*
          * 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 (NormalTransactionIdFollows(xlimit, recentXmin))
             return xlimit;
     }
 
     return recentXmin;
 }

void UnregisterSnapshot ( Snapshot snapshot )

Definition at line 905 of file snapmgr.c.

References CurrentResourceOwner, NULL, and UnregisterSnapshotFromOwner().

Referenced by AlterDomainNotNull(), ATRewriteTable(), currtid_byrelname(), currtid_byreloid(), DefineIndex(), DefineQueryRewrite(), FreeQueryDesc(), heap_endscan(), index_endscan(), IndexBuildHeapRangeScan(), IndexCheckExclusion(), pg_get_constraintdef_worker(), pgstat_collect_oids(), process_settings(), ResourceOwnerReleaseInternal(), standard_ExecutorEnd(), systable_endscan(), systable_endscan_ordered(), validateCheckConstraint(), validateDomainConstraint(), and validateForeignKeyConstraint().

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

void UnregisterSnapshotFromOwner	(	Snapshot	snapshot,
		ResourceOwner	owner
	)

Definition at line 918 of file snapmgr.c.

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

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

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

void UpdateActiveSnapshotCommandId ( void )

Definition at line 781 of file snapmgr.c.

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

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

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

bool XactHasExportedSnapshots ( void )

Definition at line 1603 of file snapmgr.c.

References NIL.

Referenced by PrepareTransaction().

 {
     return (exportedSnapshots != NIL);
 }

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

static

Definition at line 944 of file snapmgr.c.

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

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