snapbuild.h File Reference

#include "access/xlogdefs.h"
#include "utils/snapmgr.h"

Include dependency graph for snapbuild.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Typedefs
typedef struct SnapBuild	SnapBuild

Enumerations
enum	SnapBuildState { SNAPBUILD_START = -1 , SNAPBUILD_BUILDING_SNAPSHOT = 0 , SNAPBUILD_FULL_SNAPSHOT = 1 , SNAPBUILD_CONSISTENT = 2 }

Functions
void	CheckPointSnapBuild (void)
SnapBuild *	AllocateSnapshotBuilder (struct ReorderBuffer *reorder, TransactionId xmin_horizon, XLogRecPtr start_lsn, bool need_full_snapshot, bool in_slot_creation, XLogRecPtr two_phase_at)
void	FreeSnapshotBuilder (SnapBuild *builder)
void	SnapBuildSnapDecRefcount (Snapshot snap)
Snapshot	SnapBuildInitialSnapshot (SnapBuild *builder)
const char *	SnapBuildExportSnapshot (SnapBuild *builder)
void	SnapBuildClearExportedSnapshot (void)
void	SnapBuildResetExportedSnapshotState (void)
SnapBuildState	SnapBuildCurrentState (SnapBuild *builder)
Snapshot	SnapBuildGetOrBuildSnapshot (SnapBuild *builder)
bool	SnapBuildXactNeedsSkip (SnapBuild *builder, XLogRecPtr ptr)
XLogRecPtr	SnapBuildGetTwoPhaseAt (SnapBuild *builder)
void	SnapBuildSetTwoPhaseAt (SnapBuild *builder, XLogRecPtr ptr)
void	SnapBuildCommitTxn (SnapBuild *builder, XLogRecPtr lsn, TransactionId xid, int nsubxacts, TransactionId *subxacts, uint32 xinfo)
bool	SnapBuildProcessChange (SnapBuild *builder, TransactionId xid, XLogRecPtr lsn)
void	SnapBuildProcessNewCid (SnapBuild *builder, TransactionId xid, XLogRecPtr lsn, struct xl_heap_new_cid *xlrec)
void	SnapBuildProcessRunningXacts (SnapBuild *builder, XLogRecPtr lsn, struct xl_running_xacts *running)
void	SnapBuildSerializationPoint (SnapBuild *builder, XLogRecPtr lsn)
bool	SnapBuildSnapshotExists (XLogRecPtr lsn)

Typedef Documentation

SnapBuild

typedef struct SnapBuild SnapBuild

Definition at line 55 of file snapbuild.h.

Enumeration Type Documentation

SnapBuildState

enum SnapBuildState

Enumerator
SNAPBUILD_START
SNAPBUILD_BUILDING_SNAPSHOT
SNAPBUILD_FULL_SNAPSHOT
SNAPBUILD_CONSISTENT

Definition at line 22 of file snapbuild.h.

{
    /*
     * Initial state, we can't do much yet.
     */
    SNAPBUILD_START = -1,
 
    /*
     * Collecting committed transactions, to build the initial catalog
     * snapshot.
     */
    SNAPBUILD_BUILDING_SNAPSHOT = 0,
 
    /*
     * We have collected enough information to decode tuples in transactions
     * that started after this.
     *
     * Once we reached this we start to collect changes. We cannot apply them
     * yet, because they might be based on transactions that were still
     * running when FULL_SNAPSHOT was reached.
     */
    SNAPBUILD_FULL_SNAPSHOT = 1,
 
    /*
     * Found a point after SNAPBUILD_FULL_SNAPSHOT where all transactions that
     * were running at that point finished. Till we reach that we hold off
     * calling any commit callbacks.
     */
    SNAPBUILD_CONSISTENT = 2,
} SnapBuildState;

Function Documentation

AllocateSnapshotBuilder()

SnapBuild * AllocateSnapshotBuilder ( struct ReorderBuffer *  reorder, TransactionId  xmin_horizon, XLogRecPtr  start_lsn, bool  need_full_snapshot, bool  in_slot_creation, XLogRecPtr  two_phase_at  )

extern

Definition at line 185 of file snapbuild.c.

{
    MemoryContext context;
    MemoryContext oldcontext;
    SnapBuild  *builder;
 
    /* allocate memory in own context, to have better accountability */
    context = AllocSetContextCreate(CurrentMemoryContext,
                                    "snapshot builder context",
                                    ALLOCSET_DEFAULT_SIZES);
    oldcontext = MemoryContextSwitchTo(context);
 
    builder = palloc0_object(SnapBuild);
 
    builder->state = SNAPBUILD_START;
    builder->context = context;
    builder->reorder = reorder;
    /* Other struct members initialized by zeroing via palloc0 above */
 
    builder->committed.xcnt = 0;
    builder->committed.xcnt_space = 128;    /* arbitrary number */
    builder->committed.xip =
        palloc0(builder->committed.xcnt_space * sizeof(TransactionId));
    builder->committed.includes_all_transactions = true;
 
    builder->catchange.xcnt = 0;
    builder->catchange.xip = NULL;
 
    builder->initial_xmin_horizon = xmin_horizon;
    builder->start_decoding_at = start_lsn;
    builder->in_slot_creation = in_slot_creation;
    builder->building_full_snapshot = need_full_snapshot;
    builder->two_phase_at = two_phase_at;
 
    MemoryContextSwitchTo(oldcontext);
 
    return builder;
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, SnapBuild::building_full_snapshot, SnapBuild::catchange, SnapBuild::committed, SnapBuild::context, CurrentMemoryContext, fb(), SnapBuild::in_slot_creation, SnapBuild::includes_all_transactions, SnapBuild::initial_xmin_horizon, MemoryContextSwitchTo(), palloc0(), palloc0_object, SnapBuild::reorder, SNAPBUILD_START, SnapBuild::start_decoding_at, SnapBuild::state, SnapBuild::two_phase_at, SnapBuild::xcnt, SnapBuild::xcnt_space, and SnapBuild::xip.

Referenced by StartupDecodingContext().

CheckPointSnapBuild()

void CheckPointSnapBuild ( void  )

extern

Definition at line 1969 of file snapbuild.c.

{
    XLogRecPtr  cutoff;
    XLogRecPtr  redo;
    DIR        *snap_dir;
    struct dirent *snap_de;
    char        path[MAXPGPATH + sizeof(PG_LOGICAL_SNAPSHOTS_DIR)];
 
    /*
     * We start off with a minimum of the last redo pointer. No new
     * replication slot will start before that, so that's a safe upper bound
     * for removal.
     */
    redo = GetRedoRecPtr();
 
    /* now check for the restart ptrs from existing slots */
    cutoff = ReplicationSlotsComputeLogicalRestartLSN();
 
    /* don't start earlier than the restart lsn */
    if (redo < cutoff)
        cutoff = redo;
 
    snap_dir = AllocateDir(PG_LOGICAL_SNAPSHOTS_DIR);
    while ((snap_de = ReadDir(snap_dir, PG_LOGICAL_SNAPSHOTS_DIR)) != NULL)
    {
        uint32      hi;
        uint32      lo;
        XLogRecPtr  lsn;
        PGFileType  de_type;
 
        if (strcmp(snap_de->d_name, ".") == 0 ||
            strcmp(snap_de->d_name, "..") == 0)
            continue;
 
        snprintf(path, sizeof(path), "%s/%s", PG_LOGICAL_SNAPSHOTS_DIR, snap_de->d_name);
        de_type = get_dirent_type(path, snap_de, false, DEBUG1);
 
        if (de_type != PGFILETYPE_ERROR && de_type != PGFILETYPE_REG)
        {
            elog(DEBUG1, "only regular files expected: %s", path);
            continue;
        }
 
        /*
         * temporary filenames from SnapBuildSerialize() include the LSN and
         * everything but are postfixed by .$pid.tmp. We can just remove them
         * the same as other files because there can be none that are
         * currently being written that are older than cutoff.
         *
         * We just log a message if a file doesn't fit the pattern, it's
         * probably some editors lock/state file or similar...
         */
        if (sscanf(snap_de->d_name, "%X-%X.snap", &hi, &lo) != 2)
        {
            ereport(LOG,
                    (errmsg("could not parse file name \"%s\"", path)));
            continue;
        }
 
        lsn = ((uint64) hi) << 32 | lo;
 
        /* check whether we still need it */
        if (lsn < cutoff || !XLogRecPtrIsValid(cutoff))
        {
            elog(DEBUG1, "removing snapbuild snapshot %s", path);
 
            /*
             * It's not particularly harmful, though strange, if we can't
             * remove the file here. Don't prevent the checkpoint from
             * completing, that'd be a cure worse than the disease.
             */
            if (unlink(path) < 0)
            {
                ereport(LOG,
                        (errcode_for_file_access(),
                         errmsg("could not remove file \"%s\": %m",
                                path)));
                continue;
            }
        }
    }
    FreeDir(snap_dir);
}

References AllocateDir(), DEBUG1, elog, ereport, errcode_for_file_access(), errmsg(), fb(), FreeDir(), get_dirent_type(), GetRedoRecPtr(), LOG, MAXPGPATH, PG_LOGICAL_SNAPSHOTS_DIR, PGFILETYPE_ERROR, PGFILETYPE_REG, ReadDir(), ReplicationSlotsComputeLogicalRestartLSN(), snprintf, and XLogRecPtrIsValid.

Referenced by CheckPointGuts().

FreeSnapshotBuilder()

void FreeSnapshotBuilder ( SnapBuild *  builder )

extern

Definition at line 233 of file snapbuild.c.

{
    MemoryContext context = builder->context;
 
    /* free snapshot explicitly, that contains some error checking */
    if (builder->snapshot != NULL)
    {
        SnapBuildSnapDecRefcount(builder->snapshot);
        builder->snapshot = NULL;
    }
 
    /* other resources are deallocated via memory context reset */
    MemoryContextDelete(context);
}

References SnapBuild::context, fb(), MemoryContextDelete(), SnapBuildSnapDecRefcount(), and SnapBuild::snapshot.

Referenced by FreeDecodingContext().

SnapBuildClearExportedSnapshot()

void SnapBuildClearExportedSnapshot ( void  )

extern

Definition at line 599 of file snapbuild.c.

{
    ResourceOwner tmpResOwner;
 
    /* nothing exported, that is the usual case */
    if (!ExportInProgress)
        return;
 
    if (!IsTransactionState())
        elog(ERROR, "clearing exported snapshot in wrong transaction state");
 
    /*
     * AbortCurrentTransaction() takes care of resetting the snapshot state,
     * so remember SavedResourceOwnerDuringExport.
     */
    tmpResOwner = SavedResourceOwnerDuringExport;
 
    /* make sure nothing could have ever happened */
    AbortCurrentTransaction();
 
    CurrentResourceOwner = tmpResOwner;
}

References AbortCurrentTransaction(), CurrentResourceOwner, elog, ERROR, ExportInProgress, fb(), IsTransactionState(), and SavedResourceOwnerDuringExport.

Referenced by exec_replication_command().

SnapBuildCommitTxn()

void SnapBuildCommitTxn ( SnapBuild *  builder, XLogRecPtr  lsn, TransactionId  xid, int  nsubxacts, TransactionId *  subxacts, uint32  xinfo  )

extern

Definition at line 939 of file snapbuild.c.

{
    int         nxact;
 
    bool        needs_snapshot = false;
    bool        needs_timetravel = false;
    bool        sub_needs_timetravel = false;
 
    TransactionId xmax = xid;
 
    /*
     * Transactions preceding BUILDING_SNAPSHOT will neither be decoded, nor
     * will they be part of a snapshot.  So we don't need to record anything.
     */
    if (builder->state == SNAPBUILD_START ||
        (builder->state == SNAPBUILD_BUILDING_SNAPSHOT &&
         TransactionIdPrecedes(xid, builder->next_phase_at)))
    {
        /* ensure that only commits after this are getting replayed */
        if (builder->start_decoding_at <= lsn)
            builder->start_decoding_at = lsn + 1;
        return;
    }
 
    if (builder->state < SNAPBUILD_CONSISTENT)
    {
        /* ensure that only commits after this are getting replayed */
        if (builder->start_decoding_at <= lsn)
            builder->start_decoding_at = lsn + 1;
 
        /*
         * If building an exportable snapshot, force xid to be tracked, even
         * if the transaction didn't modify the catalog.
         */
        if (builder->building_full_snapshot)
        {
            needs_timetravel = true;
        }
    }
 
    for (nxact = 0; nxact < nsubxacts; nxact++)
    {
        TransactionId subxid = subxacts[nxact];
 
        /*
         * Add subtransaction to base snapshot if catalog modifying, we don't
         * distinguish to toplevel transactions there.
         */
        if (SnapBuildXidHasCatalogChanges(builder, subxid, xinfo))
        {
            sub_needs_timetravel = true;
            needs_snapshot = true;
 
            elog(DEBUG1, "found subtransaction %u:%u with catalog changes",
                 xid, subxid);
 
            SnapBuildAddCommittedTxn(builder, subxid);
 
            if (NormalTransactionIdFollows(subxid, xmax))
                xmax = subxid;
        }
 
        /*
         * If we're forcing timetravel we also need visibility information
         * about subtransaction, so keep track of subtransaction's state, even
         * if not catalog modifying.  Don't need to distribute a snapshot in
         * that case.
         */
        else if (needs_timetravel)
        {
            SnapBuildAddCommittedTxn(builder, subxid);
            if (NormalTransactionIdFollows(subxid, xmax))
                xmax = subxid;
        }
    }
 
    /* if top-level modified catalog, it'll need a snapshot */
    if (SnapBuildXidHasCatalogChanges(builder, xid, xinfo))
    {
        elog(DEBUG2, "found top level transaction %u, with catalog changes",
             xid);
        needs_snapshot = true;
        needs_timetravel = true;
        SnapBuildAddCommittedTxn(builder, xid);
    }
    else if (sub_needs_timetravel)
    {
        /* track toplevel txn as well, subxact alone isn't meaningful */
        elog(DEBUG2, "forced transaction %u to do timetravel due to one of its subtransactions",
             xid);
        needs_timetravel = true;
        SnapBuildAddCommittedTxn(builder, xid);
    }
    else if (needs_timetravel)
    {
        elog(DEBUG2, "forced transaction %u to do timetravel", xid);
 
        SnapBuildAddCommittedTxn(builder, xid);
    }
 
    if (!needs_timetravel)
    {
        /* record that we cannot export a general snapshot anymore */
        builder->committed.includes_all_transactions = false;
    }
 
    Assert(!needs_snapshot || needs_timetravel);
 
    /*
     * Adjust xmax of the snapshot builder, we only do that for committed,
     * catalog modifying, transactions, everything else isn't interesting for
     * us since we'll never look at the respective rows.
     */
    if (needs_timetravel &&
        (!TransactionIdIsValid(builder->xmax) ||
         TransactionIdFollowsOrEquals(xmax, builder->xmax)))
    {
        builder->xmax = xmax;
        TransactionIdAdvance(builder->xmax);
    }
 
    /* if there's any reason to build a historic snapshot, do so now */
    if (needs_snapshot)
    {
        /*
         * If we haven't built a complete snapshot yet there's no need to hand
         * it out, it wouldn't (and couldn't) be used anyway.
         */
        if (builder->state < SNAPBUILD_FULL_SNAPSHOT)
            return;
 
        /*
         * Decrease the snapshot builder's refcount of the old snapshot, note
         * that it still will be used if it has been handed out to the
         * reorderbuffer earlier.
         */
        if (builder->snapshot)
            SnapBuildSnapDecRefcount(builder->snapshot);
 
        builder->snapshot = SnapBuildBuildSnapshot(builder);
 
        /* we might need to execute invalidations, add snapshot */
        if (!ReorderBufferXidHasBaseSnapshot(builder->reorder, xid))
        {
            SnapBuildSnapIncRefcount(builder->snapshot);
            ReorderBufferSetBaseSnapshot(builder->reorder, xid, lsn,
                                         builder->snapshot);
        }
 
        /* refcount of the snapshot builder for the new snapshot */
        SnapBuildSnapIncRefcount(builder->snapshot);
 
        /*
         * Add a new catalog snapshot and invalidations messages to all
         * currently running transactions.
         */
        SnapBuildDistributeSnapshotAndInval(builder, lsn, xid);
    }
}

References Assert, SnapBuild::building_full_snapshot, SnapBuild::committed, DEBUG1, DEBUG2, elog, fb(), SnapBuild::includes_all_transactions, SnapBuild::next_phase_at, NormalTransactionIdFollows, SnapBuild::reorder, ReorderBufferSetBaseSnapshot(), ReorderBufferXidHasBaseSnapshot(), SNAPBUILD_BUILDING_SNAPSHOT, SNAPBUILD_CONSISTENT, SNAPBUILD_FULL_SNAPSHOT, SNAPBUILD_START, SnapBuildAddCommittedTxn(), SnapBuildBuildSnapshot(), SnapBuildDistributeSnapshotAndInval(), SnapBuildSnapDecRefcount(), SnapBuildSnapIncRefcount(), SnapBuildXidHasCatalogChanges(), SnapBuild::snapshot, SnapBuild::start_decoding_at, SnapBuild::state, TransactionIdAdvance, TransactionIdFollowsOrEquals(), TransactionIdIsValid, TransactionIdPrecedes(), and SnapBuild::xmax.

Referenced by DecodeCommit().

SnapBuildCurrentState()

SnapBuildState SnapBuildCurrentState ( SnapBuild *  builder )

extern

Definition at line 277 of file snapbuild.c.

{
    return builder->state;
}

References SnapBuild::state.

Referenced by DecodePrepare(), DecodingContextReady(), heap2_decode(), heap_decode(), logicalmsg_decode(), ReorderBufferCanStartStreaming(), and xact_decode().

SnapBuildExportSnapshot()

const char * SnapBuildExportSnapshot ( SnapBuild *  builder )

extern

Definition at line 538 of file snapbuild.c.

{
    Snapshot    snap;
    char       *snapname;
 
    if (IsTransactionOrTransactionBlock())
        elog(ERROR, "cannot export a snapshot from within a transaction");
 
    if (SavedResourceOwnerDuringExport)
        elog(ERROR, "can only export one snapshot at a time");
 
    SavedResourceOwnerDuringExport = CurrentResourceOwner;
    ExportInProgress = true;
 
    StartTransactionCommand();
 
    /* There doesn't seem to a nice API to set these */
    XactIsoLevel = XACT_REPEATABLE_READ;
    XactReadOnly = true;
 
    snap = SnapBuildInitialSnapshot(builder);
 
    /*
     * now that we've built a plain snapshot, make it active and use the
     * normal mechanisms for exporting it
     */
    snapname = ExportSnapshot(snap);
 
    ereport(LOG,
            (errmsg_plural("exported logical decoding snapshot: \"%s\" with %u transaction ID",
                           "exported logical decoding snapshot: \"%s\" with %u transaction IDs",
                           snap->xcnt,
                           snapname, snap->xcnt)));
    return snapname;
}

References CurrentResourceOwner, elog, ereport, errmsg_plural(), ERROR, ExportInProgress, ExportSnapshot(), fb(), IsTransactionOrTransactionBlock(), LOG, SavedResourceOwnerDuringExport, SnapBuildInitialSnapshot(), StartTransactionCommand(), XACT_REPEATABLE_READ, XactIsoLevel, and XactReadOnly.

Referenced by CreateReplicationSlot().

SnapBuildGetOrBuildSnapshot()

Snapshot SnapBuildGetOrBuildSnapshot ( SnapBuild *  builder )

extern

Definition at line 578 of file snapbuild.c.

{
    Assert(builder->state == SNAPBUILD_CONSISTENT);
 
    /* only build a new snapshot if we don't have a prebuilt one */
    if (builder->snapshot == NULL)
    {
        builder->snapshot = SnapBuildBuildSnapshot(builder);
        /* increase refcount for the snapshot builder */
        SnapBuildSnapIncRefcount(builder->snapshot);
    }
 
    return builder->snapshot;
}

References Assert, fb(), SNAPBUILD_CONSISTENT, SnapBuildBuildSnapshot(), SnapBuildSnapIncRefcount(), SnapBuild::snapshot, and SnapBuild::state.

Referenced by logicalmsg_decode().

SnapBuildGetTwoPhaseAt()

XLogRecPtr SnapBuildGetTwoPhaseAt ( SnapBuild *  builder )

extern

Definition at line 286 of file snapbuild.c.

{
    return builder->two_phase_at;
}

References SnapBuild::two_phase_at.

Referenced by DecodeCommit().

SnapBuildInitialSnapshot()

Snapshot SnapBuildInitialSnapshot ( SnapBuild *  builder )

extern

Definition at line 440 of file snapbuild.c.

{
    Snapshot    snap;
    TransactionId xid;
    TransactionId safeXid;
    TransactionId *newxip;
    int         newxcnt = 0;
 
    Assert(XactIsoLevel == XACT_REPEATABLE_READ);
    Assert(builder->building_full_snapshot);
 
    /* don't allow older snapshots */
    InvalidateCatalogSnapshot();    /* about to overwrite MyProc->xmin */
    if (HaveRegisteredOrActiveSnapshot())
        elog(ERROR, "cannot build an initial slot snapshot when snapshots exist");
    Assert(!HistoricSnapshotActive());
 
    if (builder->state != SNAPBUILD_CONSISTENT)
        elog(ERROR, "cannot build an initial slot snapshot before reaching a consistent state");
 
    if (!builder->committed.includes_all_transactions)
        elog(ERROR, "cannot build an initial slot snapshot, not all transactions are monitored anymore");
 
    /* so we don't overwrite the existing value */
    if (TransactionIdIsValid(MyProc->xmin))
        elog(ERROR, "cannot build an initial slot snapshot when MyProc->xmin already is valid");
 
    snap = SnapBuildBuildSnapshot(builder);
 
    /*
     * We know that snap->xmin is alive, enforced by the logical xmin
     * mechanism. Due to that we can do this without locks, we're only
     * changing our own value.
     *
     * Building an initial snapshot is expensive and an unenforced xmin
     * horizon would have bad consequences, therefore always double-check that
     * the horizon is enforced.
     */
    LWLockAcquire(ProcArrayLock, LW_SHARED);
    safeXid = GetOldestSafeDecodingTransactionId(false);
    LWLockRelease(ProcArrayLock);
 
    if (TransactionIdFollows(safeXid, snap->xmin))
        elog(ERROR, "cannot build an initial slot snapshot as oldest safe xid %u follows snapshot's xmin %u",
             safeXid, snap->xmin);
 
    MyProc->xmin = snap->xmin;
 
    /* allocate in transaction context */
    newxip = palloc_array(TransactionId, GetMaxSnapshotXidCount());
 
    /*
     * snapbuild.c builds transactions in an "inverted" manner, which means it
     * stores committed transactions in ->xip, not ones in progress. Build a
     * classical snapshot by marking all non-committed transactions as
     * in-progress. This can be expensive.
     */
    for (xid = snap->xmin; NormalTransactionIdPrecedes(xid, snap->xmax);)
    {
        void       *test;
 
        /*
         * Check whether transaction committed using the decoding snapshot
         * meaning of ->xip.
         */
        test = bsearch(&xid, snap->xip, snap->xcnt,
                       sizeof(TransactionId), xidComparator);
 
        if (test == NULL)
        {
            if (newxcnt >= GetMaxSnapshotXidCount())
                ereport(ERROR,
                        (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
                         errmsg("initial slot snapshot too large")));
 
            newxip[newxcnt++] = xid;
        }
 
        TransactionIdAdvance(xid);
    }
 
    /* adjust remaining snapshot fields as needed */
    snap->snapshot_type = SNAPSHOT_MVCC;
    snap->xcnt = newxcnt;
    snap->xip = newxip;
 
    return snap;
}

References Assert, SnapBuild::building_full_snapshot, SnapBuild::committed, elog, ereport, errcode(), ERRCODE_T_R_SERIALIZATION_FAILURE, errmsg(), ERROR, fb(), GetMaxSnapshotXidCount(), GetOldestSafeDecodingTransactionId(), HaveRegisteredOrActiveSnapshot(), HistoricSnapshotActive(), SnapBuild::includes_all_transactions, InvalidateCatalogSnapshot(), LW_SHARED, LWLockAcquire(), LWLockRelease(), MyProc, NormalTransactionIdPrecedes, palloc_array, SNAPBUILD_CONSISTENT, SnapBuildBuildSnapshot(), SNAPSHOT_MVCC, SnapBuild::state, test(), TransactionIdAdvance, TransactionIdFollows(), TransactionIdIsValid, XACT_REPEATABLE_READ, XactIsoLevel, xidComparator(), and PGPROC::xmin.

Referenced by CreateReplicationSlot(), and SnapBuildExportSnapshot().

SnapBuildProcessChange()

bool SnapBuildProcessChange ( SnapBuild *  builder, TransactionId  xid, XLogRecPtr  lsn  )

extern

Definition at line 638 of file snapbuild.c.

{
    /*
     * We can't handle data in transactions if we haven't built a snapshot
     * yet, so don't store them.
     */
    if (builder->state < SNAPBUILD_FULL_SNAPSHOT)
        return false;
 
    /*
     * No point in keeping track of changes in transactions that we don't have
     * enough information about to decode. This means that they started before
     * we got into the SNAPBUILD_FULL_SNAPSHOT state.
     */
    if (builder->state < SNAPBUILD_CONSISTENT &&
        TransactionIdPrecedes(xid, builder->next_phase_at))
        return false;
 
    /*
     * If the reorderbuffer doesn't yet have a snapshot, add one now, it will
     * be needed to decode the change we're currently processing.
     */
    if (!ReorderBufferXidHasBaseSnapshot(builder->reorder, xid))
    {
        /* only build a new snapshot if we don't have a prebuilt one */
        if (builder->snapshot == NULL)
        {
            builder->snapshot = SnapBuildBuildSnapshot(builder);
            /* increase refcount for the snapshot builder */
            SnapBuildSnapIncRefcount(builder->snapshot);
        }
 
        /*
         * Increase refcount for the transaction we're handing the snapshot
         * out to.
         */
        SnapBuildSnapIncRefcount(builder->snapshot);
        ReorderBufferSetBaseSnapshot(builder->reorder, xid, lsn,
                                     builder->snapshot);
    }
 
    return true;
}

References fb(), SnapBuild::next_phase_at, SnapBuild::reorder, ReorderBufferSetBaseSnapshot(), ReorderBufferXidHasBaseSnapshot(), SNAPBUILD_CONSISTENT, SNAPBUILD_FULL_SNAPSHOT, SnapBuildBuildSnapshot(), SnapBuildSnapIncRefcount(), SnapBuild::snapshot, SnapBuild::state, and TransactionIdPrecedes().

Referenced by heap2_decode(), heap_decode(), and logicalmsg_decode().

SnapBuildProcessNewCid()

void SnapBuildProcessNewCid ( SnapBuild *  builder, TransactionId  xid, XLogRecPtr  lsn, struct xl_heap_new_cid *  xlrec  )

extern

Definition at line 688 of file snapbuild.c.

{
    CommandId   cid;
 
    /*
     * we only log new_cid's if a catalog tuple was modified, so mark the
     * transaction as containing catalog modifications
     */
    ReorderBufferXidSetCatalogChanges(builder->reorder, xid, lsn);
 
    ReorderBufferAddNewTupleCids(builder->reorder, xlrec->top_xid, lsn,
                                 xlrec->target_locator, xlrec->target_tid,
                                 xlrec->cmin, xlrec->cmax,
                                 xlrec->combocid);
 
    /* figure out new command id */
    if (xlrec->cmin != InvalidCommandId &&
        xlrec->cmax != InvalidCommandId)
        cid = Max(xlrec->cmin, xlrec->cmax);
    else if (xlrec->cmax != InvalidCommandId)
        cid = xlrec->cmax;
    else if (xlrec->cmin != InvalidCommandId)
        cid = xlrec->cmin;
    else
    {
        cid = InvalidCommandId; /* silence compiler */
        elog(ERROR, "xl_heap_new_cid record without a valid CommandId");
    }
 
    ReorderBufferAddNewCommandId(builder->reorder, xid, lsn, cid + 1);
}

References elog, ERROR, fb(), InvalidCommandId, Max, SnapBuild::reorder, ReorderBufferAddNewCommandId(), ReorderBufferAddNewTupleCids(), and ReorderBufferXidSetCatalogChanges().

Referenced by heap2_decode().

SnapBuildProcessRunningXacts()

void SnapBuildProcessRunningXacts ( SnapBuild *  builder, XLogRecPtr  lsn, struct xl_running_xacts *  running  )

extern

Definition at line 1135 of file snapbuild.c.

{
    ReorderBufferTXN *txn;
    TransactionId xmin;
 
    /*
     * If we're not consistent yet, inspect the record to see whether it
     * allows to get closer to being consistent. If we are consistent, dump
     * our snapshot so others or we, after a restart, can use it.
     */
    if (builder->state < SNAPBUILD_CONSISTENT)
    {
        /* returns false if there's no point in performing cleanup just yet */
        if (!SnapBuildFindSnapshot(builder, lsn, running))
            return;
    }
    else
        SnapBuildSerialize(builder, lsn);
 
    /*
     * Update range of interesting xids based on the running xacts
     * information. We don't increase ->xmax using it, because once we are in
     * a consistent state we can do that ourselves and much more efficiently
     * so, because we only need to do it for catalog transactions since we
     * only ever look at those.
     *
     * NB: We only increase xmax when a catalog modifying transaction commits
     * (see SnapBuildCommitTxn).  Because of this, xmax can be lower than
     * xmin, which looks odd but is correct and actually more efficient, since
     * we hit fast paths in heapam_visibility.c.
     */
    builder->xmin = running->oldestRunningXid;
 
    /* Remove transactions we don't need to keep track off anymore */
    SnapBuildPurgeOlderTxn(builder);
 
    /*
     * Advance the xmin limit for the current replication slot, to allow
     * vacuum to clean up the tuples this slot has been protecting.
     *
     * The reorderbuffer might have an xmin among the currently running
     * snapshots; use it if so.  If not, we need only consider the snapshots
     * we'll produce later, which can't be less than the oldest running xid in
     * the record we're reading now.
     */
    xmin = ReorderBufferGetOldestXmin(builder->reorder);
    if (xmin == InvalidTransactionId)
        xmin = running->oldestRunningXid;
    elog(DEBUG3, "xmin: %u, xmax: %u, oldest running: %u, oldest xmin: %u",
         builder->xmin, builder->xmax, running->oldestRunningXid, xmin);
    LogicalIncreaseXminForSlot(lsn, xmin);
 
    /*
     * Also tell the slot where we can restart decoding from. We don't want to
     * do that after every commit because changing that implies an fsync of
     * the logical slot's state file, so we only do it every time we see a
     * running xacts record.
     *
     * Do so by looking for the oldest in progress transaction (determined by
     * the first LSN of any of its relevant records). Every transaction
     * remembers the last location we stored the snapshot to disk before its
     * beginning. That point is where we can restart from.
     */
 
    /*
     * Can't know about a serialized snapshot's location if we're not
     * consistent.
     */
    if (builder->state < SNAPBUILD_CONSISTENT)
        return;
 
    txn = ReorderBufferGetOldestTXN(builder->reorder);
 
    /*
     * oldest ongoing txn might have started when we didn't yet serialize
     * anything because we hadn't reached a consistent state yet.
     */
    if (txn != NULL && XLogRecPtrIsValid(txn->restart_decoding_lsn))
        LogicalIncreaseRestartDecodingForSlot(lsn, txn->restart_decoding_lsn);
 
    /*
     * No in-progress transaction, can reuse the last serialized snapshot if
     * we have one.
     */
    else if (txn == NULL &&
             XLogRecPtrIsValid(builder->reorder->current_restart_decoding_lsn) &&
             XLogRecPtrIsValid(builder->last_serialized_snapshot))
        LogicalIncreaseRestartDecodingForSlot(lsn,
                                              builder->last_serialized_snapshot);
}

References ReorderBuffer::current_restart_decoding_lsn, DEBUG3, elog, fb(), InvalidTransactionId, SnapBuild::last_serialized_snapshot, LogicalIncreaseRestartDecodingForSlot(), LogicalIncreaseXminForSlot(), xl_running_xacts::oldestRunningXid, SnapBuild::reorder, ReorderBufferGetOldestTXN(), ReorderBufferGetOldestXmin(), ReorderBufferTXN::restart_decoding_lsn, SNAPBUILD_CONSISTENT, SnapBuildFindSnapshot(), SnapBuildPurgeOlderTxn(), SnapBuildSerialize(), SnapBuild::state, XLogRecPtrIsValid, SnapBuild::xmax, and SnapBuild::xmin.

Referenced by standby_decode().

SnapBuildResetExportedSnapshotState()

void SnapBuildResetExportedSnapshotState ( void  )

extern

Definition at line 626 of file snapbuild.c.

{
    SavedResourceOwnerDuringExport = NULL;
    ExportInProgress = false;
}

References ExportInProgress, fb(), and SavedResourceOwnerDuringExport.

Referenced by AbortTransaction().

SnapBuildSerializationPoint()

void SnapBuildSerializationPoint ( SnapBuild *  builder, XLogRecPtr  lsn  )

extern

Definition at line 1483 of file snapbuild.c.

{
    if (builder->state < SNAPBUILD_CONSISTENT)
        SnapBuildRestore(builder, lsn);
    else
        SnapBuildSerialize(builder, lsn);
}

References SNAPBUILD_CONSISTENT, SnapBuildRestore(), SnapBuildSerialize(), and SnapBuild::state.

Referenced by xlog_decode().

SnapBuildSetTwoPhaseAt()

void SnapBuildSetTwoPhaseAt ( SnapBuild *  builder, XLogRecPtr  ptr  )

extern

Definition at line 295 of file snapbuild.c.

{
    builder->two_phase_at = ptr;
}

References SnapBuild::two_phase_at.

Referenced by CreateDecodingContext().

SnapBuildSnapDecRefcount()

void SnapBuildSnapDecRefcount ( Snapshot  snap )

extern

Definition at line 328 of file snapbuild.c.

{
    /* make sure we don't get passed an external snapshot */
    Assert(snap->snapshot_type == SNAPSHOT_HISTORIC_MVCC);
 
    /* make sure nobody modified our snapshot */
    Assert(snap->curcid == FirstCommandId);
    Assert(!snap->suboverflowed);
    Assert(!snap->takenDuringRecovery);
 
    Assert(snap->regd_count == 0);
 
    Assert(snap->active_count > 0);
 
    /* slightly more likely, so it's checked even without casserts */
    if (snap->copied)
        elog(ERROR, "cannot free a copied snapshot");
 
    snap->active_count--;
    if (snap->active_count == 0)
        SnapBuildFreeSnapshot(snap);
}

References Assert, elog, ERROR, fb(), FirstCommandId, SnapBuildFreeSnapshot(), and SNAPSHOT_HISTORIC_MVCC.

Referenced by FreeSnapshotBuilder(), ReorderBufferCleanupTXN(), ReorderBufferFreeSnap(), ReorderBufferTransferSnapToParent(), SnapBuildCommitTxn(), and SnapBuildRestore().

SnapBuildSnapshotExists()

bool SnapBuildSnapshotExists ( XLogRecPtr  lsn )

extern

Definition at line 2057 of file snapbuild.c.

{
    char        path[MAXPGPATH];
    int         ret;
    struct stat stat_buf;
 
    sprintf(path, "%s/%X-%X.snap",
            PG_LOGICAL_SNAPSHOTS_DIR,
            LSN_FORMAT_ARGS(lsn));
 
    ret = stat(path, &stat_buf);
 
    if (ret != 0 && errno != ENOENT)
        ereport(ERROR,
                (errcode_for_file_access(),
                 errmsg("could not stat file \"%s\": %m", path)));
 
    return ret == 0;
}

References ereport, errcode_for_file_access(), errmsg(), ERROR, fb(), LSN_FORMAT_ARGS, MAXPGPATH, PG_LOGICAL_SNAPSHOTS_DIR, sprintf, and stat.

Referenced by update_local_synced_slot().

SnapBuildXactNeedsSkip()

bool SnapBuildXactNeedsSkip ( SnapBuild *  builder, XLogRecPtr  ptr  )

extern

Definition at line 304 of file snapbuild.c.

{
    return ptr < builder->start_decoding_at;
}

References SnapBuild::start_decoding_at.

Referenced by AssertTXNLsnOrder(), DecodeTXNNeedSkip(), logicalmsg_decode(), and ReorderBufferCanStartStreaming().