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 ReorderBuffer	ReorderBuffer
typedef struct SnapBuild	SnapBuild
typedef struct xl_heap_new_cid	xl_heap_new_cid
typedef struct xl_running_xacts	xl_running_xacts

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

Functions
void	CheckPointSnapBuild (void)
SnapBuild *	AllocateSnapshotBuilder (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, xl_heap_new_cid *xlrec)
void	SnapBuildProcessRunningXacts (SnapBuild *builder, XLogRecPtr lsn, xl_running_xacts *running)
void	SnapBuildSerializationPoint (SnapBuild *builder, XLogRecPtr lsn)
bool	SnapBuildSnapshotExists (XLogRecPtr lsn)

Typedef Documentation

ReorderBuffer

typedef struct ReorderBuffer ReorderBuffer

Definition at line 21 of file snapbuild.h.

SnapBuild

typedef struct SnapBuild SnapBuild

Definition at line 22 of file snapbuild.h.

xl_heap_new_cid

typedef struct xl_heap_new_cid xl_heap_new_cid

Definition at line 23 of file snapbuild.h.

xl_running_xacts

typedef struct xl_running_xacts xl_running_xacts

Definition at line 24 of file snapbuild.h.

Enumeration Type Documentation

SnapBuildState

enum SnapBuildState

Enumerator
SNAPBUILD_START
SNAPBUILD_BUILDING_SNAPSHOT
SNAPBUILD_FULL_SNAPSHOT
SNAPBUILD_CONSISTENT

Definition at line 30 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 ( ReorderBuffer *  reorder, TransactionId  xmin_horizon, XLogRecPtr  start_lsn, bool  need_full_snapshot, bool  in_slot_creation, XLogRecPtr  two_phase_at  )

extern

Definition at line 189 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_array(TransactionId, builder->committed.xcnt_space);
    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_array, 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 1974 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 237 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 603 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 944 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 281 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 542 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 582 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 290 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 444 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(), RepackWorkerMain(), and SnapBuildExportSnapshot().

SnapBuildProcessChange()

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

extern

Definition at line 642 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, xl_heap_new_cid *  xlrec  )

extern

Definition at line 692 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, xl_running_xacts *  running  )

extern

Definition at line 1140 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 630 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 1488 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 299 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 332 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 2062 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 308 of file snapbuild.c.

{
    return ptr < builder->start_decoding_at;
}

References SnapBuild::start_decoding_at.

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