snapmgr.c File Reference

#include "postgres.h"
#include <sys/stat.h>
#include <unistd.h>
#include "access/subtrans.h"
#include "access/transam.h"
#include "access/xact.h"
#include "datatype/timestamp.h"
#include "lib/pairingheap.h"
#include "miscadmin.h"
#include "port/pg_lfind.h"
#include "storage/fd.h"
#include "storage/predicate.h"
#include "storage/proc.h"
#include "storage/procarray.h"
#include "utils/builtins.h"
#include "utils/memutils.h"
#include "utils/resowner.h"
#include "utils/snapmgr.h"
#include "utils/syscache.h"

Include dependency graph for snapmgr.c:

Go to the source code of this file.

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 Snapshot	CopySnapshot (Snapshot snapshot)
static void	UnregisterSnapshotNoOwner (Snapshot snapshot)
static void	FreeSnapshot (Snapshot snapshot)
static void	SnapshotResetXmin (void)
static void	ResOwnerReleaseSnapshot (Datum res)
static void	ResourceOwnerRememberSnapshot (ResourceOwner owner, Snapshot snap)
static void	ResourceOwnerForgetSnapshot (ResourceOwner owner, Snapshot snap)
Snapshot	GetTransactionSnapshot (void)
Snapshot	GetLatestSnapshot (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 snapshot)
void	PushActiveSnapshotWithLevel (Snapshot snapshot, 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)
void	SetupHistoricSnapshot (Snapshot historic_snapshot, HTAB *tuplecids)
void	TeardownHistoricSnapshot (bool is_error)
bool	HistoricSnapshotActive (void)
HTAB *	HistoricSnapshotGetTupleCids (void)
Size	EstimateSnapshotSpace (Snapshot snapshot)
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
static SnapshotData	CurrentSnapshotData = {SNAPSHOT_MVCC}
static SnapshotData	SecondarySnapshotData = {SNAPSHOT_MVCC}
static SnapshotData	CatalogSnapshotData = {SNAPSHOT_MVCC}
SnapshotData	SnapshotSelfData = {SNAPSHOT_SELF}
SnapshotData	SnapshotAnyData = {SNAPSHOT_ANY}
SnapshotData	SnapshotToastData = {SNAPSHOT_TOAST}
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 pairingheap	RegisteredSnapshots = {&xmin_cmp, NULL, NULL}
bool	FirstSnapshotSet = false
static Snapshot	FirstXactSnapshot = NULL
static List *	exportedSnapshots = NIL
static const ResourceOwnerDesc	snapshot_resowner_desc

Macro Definition Documentation

SNAPSHOT_EXPORT_DIR

#define SNAPSHOT_EXPORT_DIR   "pg_snapshots"

Definition at line 202 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 799 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(), ReindexMultipleInternal(), RelationBuildPartitionDesc(), RelationGetPartitionDesc(), RevalidateCachedQuery(), UpdateCachedPlan(), and vacuum().

AtEOXact_Snapshot()

void AtEOXact_Snapshot	(	bool	isCommit,
		bool	resetXmin
	)

Definition at line 1003 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;
    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, 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 969 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;
    }
 
    SnapshotResetXmin();
}

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

Referenced by AbortSubTransaction().

AtSubCommit_Snapshot()

void AtSubCommit_Snapshot

(

int

level

)

Definition at line 948 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 595 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 1574 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

snapshot

)

Definition at line 1699 of file snapmgr.c.

{
    Size        size;
 
    Assert(snapshot != InvalidSnapshot);
    Assert(snapshot->snapshot_type == SNAPSHOT_MVCC);
 
    /* We allocate any XID arrays needed in the same palloc block. */
    size = add_size(sizeof(SerializedSnapshotData),
                    mul_size(snapshot->xcnt, sizeof(TransactionId)));
    if (snapshot->subxcnt > 0 &&
        (!snapshot->suboverflowed || snapshot->takenDuringRecovery))
        size = add_size(size,
                        mul_size(snapshot->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 index_parallelscan_estimate(), index_parallelscan_initialize(), InitializeParallelDSM(), and table_parallelscan_estimate().

ExportSnapshot()

char * ExportSnapshot

(

Snapshot

snapshot

)

Definition at line 1102 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->vxid.procNumber, MyProc->vxid.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->vxid.procNumber, MyProc->vxid.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(), 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, PGPROC::procNumber, pstrdup(), SnapshotData::regd_count, RegisteredSnapshots, ExportedSnapshot::snapfile, ExportedSnapshot::snapshot, SNAPSHOT_EXPORT_DIR, snprintf, SnapshotData::suboverflowed, SnapshotData::subxcnt, SnapshotData::subxip, SnapshotData::takenDuringRecovery, TopTransactionContext, TransactionIdIsValid, TransactionIdPrecedes(), PGPROC::vxid, 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 651 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 UnregisterSnapshotNoOwner().

GetActiveSnapshot()

Snapshot GetActiveSnapshot

(

void

)

Definition at line 787 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(), ExecInitParallelPlan(), ExecParallelGetQueryDesc(), execute_sql_string(), ExecuteQuery(), ExplainOnePlan(), find_inheritance_children_extended(), FindConflictTuple(), has_lo_priv_byid(), InitializeParallelDSM(), inv_open(), PerformCursorOpen(), pg_current_snapshot(), pg_export_snapshot(), pgrowlocks(), PortalRunUtility(), PortalStart(), postquel_start(), ProcessQuery(), refresh_matview_datafill(), RelationFindReplTupleByIndex(), RelationFindReplTupleSeq(), RelationGetPartitionDesc(), spgvacuumscan(), SPI_cursor_open_internal(), standard_ExecutorRun(), and standard_ExecutorStart().

GetCatalogSnapshot()

Snapshot GetCatalogSnapshot

(

Oid

relid

)

Definition at line 373 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 342 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 asyncQueueReadAllNotifications(), ATRewriteTable(), check_default_partition_contents(), currtid_internal(), FindConflictTuple(), IndexCheckExclusion(), RelationFindReplTupleByIndex(), RelationFindReplTupleSeq(), RI_Initial_Check(), RI_PartitionRemove_Check(), ri_PerformCheck(), ScanSourceDatabasePgClass(), validateDomainCheckConstraint(), validateDomainNotNullConstraint(), and validateForeignKeyConstraint().

GetNonHistoricCatalogSnapshot()

Snapshot GetNonHistoricCatalogSnapshot

(

Oid

relid

)

Definition at line 395 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().

GetTransactionSnapshot()

Snapshot GetTransactionSnapshot

(

void

)

Definition at line 271 of file snapmgr.c.

{
    /*
     * This should not be called while doing logical decoding.  Historic
     * snapshots are only usable for catalog access, not for general-purpose
     * queries.
     */
    if (HistoricSnapshotActive())
        elog(ERROR, "cannot take query snapshot during logical decoding");
 
    /* 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(), HistoricSnapshotActive(), InvalidateCatalogSnapshot(), IsInParallelMode(), IsolationIsSerializable, IsolationUsesXactSnapshot, pairingheap_add(), pairingheap_is_empty, SnapshotData::ph_node, SnapshotData::regd_count, and RegisteredSnapshots.

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

HaveRegisteredOrActiveSnapshot()

bool HaveRegisteredOrActiveSnapshot

(

void

)

Definition at line 1631 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 get_toast_snapshot(), and SnapBuildInitialSnapshot().

HistoricSnapshotActive()

bool HistoricSnapshotActive

(

void

)

Definition at line 1679 of file snapmgr.c.

{
    return HistoricSnapshot != NULL;
}

References HistoricSnapshot.

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

HistoricSnapshotGetTupleCids()

HTAB * HistoricSnapshotGetTupleCids

(

void

)

Definition at line 1685 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 1374 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)
    {
        /*
         * If file is missing while identifier has a correct format, avoid
         * system errors.
         */
        if (errno == ENOENT)
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_OBJECT),
                     errmsg("snapshot \"%s\" does not exist", idstr)));
        else
            ereport(ERROR,
                    (errcode_for_file_access(),
                     errmsg("could not open file \"%s\" for reading: %m",
                            path)));
    }
 
    /* 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(), errcode_for_file_access(), 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 443 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(), heap_inplace_lock(), InitPostgres(), InvalidateCatalogSnapshotConditionally(), InvalidateSystemCachesExtended(), LocalExecuteInvalidationMessage(), SetTransactionSnapshot(), SnapBuildInitialSnapshot(), and wait_for_relation_state_change().

InvalidateCatalogSnapshotConditionally()

void InvalidateCatalogSnapshotConditionally

(

void

)

Definition at line 464 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().

parseIntFromText()

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

static

Definition at line 1294 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 1344 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->procNumber, &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 ereport, errcode(), errmsg(), ERROR, filename, VirtualTransactionId::localTransactionId, and VirtualTransactionId::procNumber.

Referenced by ImportSnapshot().

parseXidFromText()

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

static

Definition at line 1319 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 1279 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 762 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;
 
    SnapshotResetXmin();
}

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

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

PushActiveSnapshot()

void PushActiveSnapshot

(

Snapshot

snapshot

)

Definition at line 669 of file snapmgr.c.

{
    PushActiveSnapshotWithLevel(snapshot, GetCurrentTransactionNestLevel());
}

References GetCurrentTransactionNestLevel(), and PushActiveSnapshotWithLevel().

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

PushActiveSnapshotWithLevel()

void PushActiveSnapshotWithLevel	(	Snapshot	snapshot,
		int	snap_level
	)

Definition at line 683 of file snapmgr.c.

{
    ActiveSnapshotElt *newactive;
 
    Assert(snapshot != 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 (snapshot == CurrentSnapshot || snapshot == SecondarySnapshot ||
        !snapshot->copied)
        newactive->as_snap = CopySnapshot(snapshot);
    else
        newactive->as_snap = snapshot;
 
    newactive->as_next = ActiveSnapshot;
    newactive->as_level = snap_level;
 
    newactive->as_snap->active_count++;
 
    ActiveSnapshot = newactive;
}

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

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

PushCopiedSnapshot()

void PushCopiedSnapshot

(

Snapshot

snapshot

)

Definition at line 719 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 811 of file snapmgr.c.

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

References CurrentResourceOwner, InvalidSnapshot, and RegisterSnapshotOnOwner().

Referenced by _brin_begin_parallel(), _bt_begin_parallel(), _gin_begin_parallel(), asyncQueueReadAllNotifications(), ATRewriteTable(), bt_check_every_level(), check_default_partition_contents(), CreateQueryDesc(), currtid_internal(), DefineIndex(), heapam_index_build_range_scan(), index_beginscan_parallel(), IndexCheckExclusion(), pg_get_constraintdef_worker(), PortalRunMulti(), PortalRunUtility(), process_settings(), ReindexRelationConcurrently(), ScanPgRelation(), ScanSourceDatabasePgClass(), standard_ExecutorStart(), systable_beginscan(), systable_beginscan_ordered(), systable_recheck_tuple(), table_beginscan_catalog(), table_beginscan_parallel(), validateDomainCheckConstraint(), validateDomainNotNullConstraint(), and validateForeignKeyConstraint().

RegisterSnapshotOnOwner()

Snapshot RegisterSnapshotOnOwner	(	Snapshot	snapshot,
		ResourceOwner	owner
	)

Definition at line 824 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 */
    ResourceOwnerEnlarge(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, ResourceOwnerEnlarge(), and ResourceOwnerRememberSnapshot().

Referenced by be_lo_open(), and RegisterSnapshot().

ResourceOwnerForgetSnapshot()

static void ResourceOwnerForgetSnapshot ( ResourceOwner  owner, Snapshot  snap  )

inlinestatic

Definition at line 239 of file snapmgr.c.

{
    ResourceOwnerForget(owner, PointerGetDatum(snap), &snapshot_resowner_desc);
}

References PointerGetDatum(), ResourceOwnerForget(), and snapshot_resowner_desc.

Referenced by UnregisterSnapshotFromOwner().

ResourceOwnerRememberSnapshot()

static void ResourceOwnerRememberSnapshot ( ResourceOwner  owner, Snapshot  snap  )

inlinestatic

Definition at line 234 of file snapmgr.c.

{
    ResourceOwnerRemember(owner, PointerGetDatum(snap), &snapshot_resowner_desc);
}

References PointerGetDatum(), ResourceOwnerRemember(), and snapshot_resowner_desc.

Referenced by RegisterSnapshotOnOwner().

ResOwnerReleaseSnapshot()

static void ResOwnerReleaseSnapshot ( Datum  res )

static

Definition at line 1958 of file snapmgr.c.

{
    UnregisterSnapshotNoOwner((Snapshot) DatumGetPointer(res));
}

References DatumGetPointer(), and UnregisterSnapshotNoOwner().

RestoreSnapshot()

Snapshot RestoreSnapshot

(

char *

start_address

)

Definition at line 1780 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->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;
}

References SnapshotData::active_count, SnapshotData::copied, SerializedSnapshotData::curcid, SnapshotData::curcid, MemoryContextAlloc(), SnapshotData::regd_count, SNAPSHOT_MVCC, SnapshotData::snapshot_type, SnapshotData::snapXactCompletionCount, SerializedSnapshotData::suboverflowed, SnapshotData::suboverflowed, SerializedSnapshotData::subxcnt, SnapshotData::subxcnt, SnapshotData::subxip, SerializedSnapshotData::takenDuringRecovery, SnapshotData::takenDuringRecovery, TopTransactionContext, SerializedSnapshotData::xcnt, SnapshotData::xcnt, SnapshotData::xip, SerializedSnapshotData::xmax, SnapshotData::xmax, SerializedSnapshotData::xmin, and SnapshotData::xmin.

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

RestoreTransactionSnapshot()

void RestoreTransactionSnapshot	(	Snapshot	snapshot,
		void *	source_pgproc
	)

Definition at line 1843 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 1723 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;
 
    /*
     * 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));
    }
}

References Assert(), SerializedSnapshotData::curcid, SnapshotData::curcid, SerializedSnapshotData::suboverflowed, SnapshotData::suboverflowed, SerializedSnapshotData::subxcnt, SnapshotData::subxcnt, SnapshotData::subxip, SerializedSnapshotData::takenDuringRecovery, SnapshotData::takenDuringRecovery, SerializedSnapshotData::xcnt, SnapshotData::xcnt, SnapshotData::xip, SerializedSnapshotData::xmax, SnapshotData::xmax, SerializedSnapshotData::xmin, and SnapshotData::xmin.

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

SetTransactionSnapshot()

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

static

Definition at line 498 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 1656 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().

SnapshotResetXmin()

static void SnapshotResetXmin ( void  )

static

Definition at line 924 of file snapmgr.c.

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

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

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

SnapshotSetCommandId()

void SnapshotSetCommandId

(

CommandId

curcid

)

Definition at line 477 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().

TeardownHistoricSnapshot()

void TeardownHistoricSnapshot

(

bool

is_error

)

Definition at line 1672 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 1613 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().

UnregisterSnapshot()

void UnregisterSnapshot

(

Snapshot

snapshot

)

Definition at line 853 of file snapmgr.c.

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

References CurrentResourceOwner, and UnregisterSnapshotFromOwner().

Referenced by _brin_begin_parallel(), _brin_end_parallel(), _bt_begin_parallel(), _bt_end_parallel(), _gin_begin_parallel(), _gin_end_parallel(), asyncQueueReadAllNotifications(), ATRewriteTable(), bt_check_every_level(), check_default_partition_contents(), currtid_internal(), DefineIndex(), FreeQueryDesc(), heap_endscan(), heapam_index_build_range_scan(), index_endscan(), IndexCheckExclusion(), pg_get_constraintdef_worker(), process_settings(), ReindexRelationConcurrently(), ScanPgRelation(), ScanSourceDatabasePgClass(), standard_ExecutorEnd(), systable_endscan(), systable_endscan_ordered(), systable_recheck_tuple(), validateDomainCheckConstraint(), validateDomainNotNullConstraint(), and validateForeignKeyConstraint().

UnregisterSnapshotFromOwner()

void UnregisterSnapshotFromOwner	(	Snapshot	snapshot,
		ResourceOwner	owner
	)

Definition at line 866 of file snapmgr.c.

{
    if (snapshot == NULL)
        return;
 
    ResourceOwnerForgetSnapshot(owner, snapshot);
    UnregisterSnapshotNoOwner(snapshot);
}

References ResourceOwnerForgetSnapshot(), and UnregisterSnapshotNoOwner().

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

UnregisterSnapshotNoOwner()

static void UnregisterSnapshotNoOwner ( Snapshot  snapshot )

static

Definition at line 876 of file snapmgr.c.

{
    Assert(snapshot->regd_count > 0);
    Assert(!pairingheap_is_empty(&RegisteredSnapshots));
 
    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, and SnapshotResetXmin().

Referenced by ResOwnerReleaseSnapshot(), and UnregisterSnapshotFromOwner().

UpdateActiveSnapshotCommandId()

void UpdateActiveSnapshotCommandId

(

void

)

Definition at line 731 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 1561 of file snapmgr.c.

{
    return (exportedSnapshots != NIL);
}

References exportedSnapshots, and NIL.

Referenced by PrepareTransaction().

XidInMVCCSnapshot()

bool XidInMVCCSnapshot	(	TransactionId	xid,
		Snapshot	snapshot
	)

Definition at line 1859 of file snapmgr.c.

{
    /*
     * 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 */
            if (pg_lfind32(xid, snapshot->subxip, snapshot->subxcnt))
                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;
        }
 
        if (pg_lfind32(xid, snapshot->xip, snapshot->xcnt))
            return true;
    }
    else
    {
        /*
         * In recovery we store all xids in the subxip 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.
         */
        if (pg_lfind32(xid, snapshot->subxip, snapshot->subxcnt))
            return true;
    }
 
    return false;
}

References pg_lfind32(), SnapshotData::suboverflowed, SubTransGetTopmostTransaction(), SnapshotData::subxcnt, SnapshotData::subxip, SnapshotData::takenDuringRecovery, 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 897 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 180 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 150 of file snapmgr.c.

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

CatalogSnapshotData

SnapshotData CatalogSnapshotData = {SNAPSHOT_MVCC}

static

Definition at line 142 of file snapmgr.c.

Referenced by GetNonHistoricCatalogSnapshot().

CurrentSnapshot

Snapshot CurrentSnapshot = NULL

static

Definition at line 148 of file snapmgr.c.

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

CurrentSnapshotData

SnapshotData CurrentSnapshotData = {SNAPSHOT_MVCC}

static

Definition at line 140 of file snapmgr.c.

Referenced by GetTransactionSnapshot(), and SetTransactionSnapshot().

exportedSnapshots

List* exportedSnapshots = NIL

static

Definition at line 212 of file snapmgr.c.

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

FirstSnapshotSet

bool FirstSnapshotSet = false

Definition at line 192 of file snapmgr.c.

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

FirstXactSnapshot

Snapshot FirstXactSnapshot = NULL

static

Definition at line 199 of file snapmgr.c.

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

HistoricSnapshot

Snapshot HistoricSnapshot = NULL

static

Definition at line 151 of file snapmgr.c.

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

RecentXmin

TransactionId RecentXmin = FirstNormalTransactionId

Definition at line 159 of file snapmgr.c.

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

RegisteredSnapshots

pairingheap RegisteredSnapshots = {&xmin_cmp, NULL, NULL}

static

Definition at line 189 of file snapmgr.c.

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

SecondarySnapshot

Snapshot SecondarySnapshot = NULL

static

Definition at line 149 of file snapmgr.c.

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

SecondarySnapshotData

SnapshotData SecondarySnapshotData = {SNAPSHOT_MVCC}

static

Definition at line 141 of file snapmgr.c.

Referenced by GetLatestSnapshot().

snapshot_resowner_desc

const ResourceOwnerDesc snapshot_resowner_desc

static

Initial value:

=
{
    .name = "snapshot reference",
    .release_phase = RESOURCE_RELEASE_AFTER_LOCKS,
    .release_priority = RELEASE_PRIO_SNAPSHOT_REFS,
    .ReleaseResource = ResOwnerReleaseSnapshot,
    .DebugPrint = NULL          
}

Definition at line 223 of file snapmgr.c.

Referenced by ResourceOwnerForgetSnapshot(), and ResourceOwnerRememberSnapshot().

SnapshotAnyData

SnapshotData SnapshotAnyData = {SNAPSHOT_ANY}

Definition at line 144 of file snapmgr.c.

SnapshotSelfData

SnapshotData SnapshotSelfData = {SNAPSHOT_SELF}

Definition at line 143 of file snapmgr.c.

SnapshotToastData

SnapshotData SnapshotToastData = {SNAPSHOT_TOAST}

Definition at line 145 of file snapmgr.c.

Referenced by get_toast_snapshot().

TransactionXmin

TransactionId TransactionXmin = FirstNormalTransactionId

Definition at line 158 of file snapmgr.c.

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

tuplecid_data

HTAB* tuplecid_data = NULL

static

Definition at line 162 of file snapmgr.c.

Referenced by ApplyLogicalMappingFile(), HistoricSnapshotGetTupleCids(), ResolveCminCmaxDuringDecoding(), SetupHistoricSnapshot(), TeardownHistoricSnapshot(), and UpdateLogicalMappings().