slot.h File Reference

#include "access/xlog.h"
#include "access/xlogreader.h"
#include "storage/condition_variable.h"
#include "storage/lwlock.h"
#include "storage/shmem.h"
#include "storage/spin.h"
#include "replication/walreceiver.h"

Include dependency graph for slot.h:

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

Go to the source code of this file.

Data Structures
struct	ReplicationSlotPersistentData
struct	ReplicationSlot
struct	ReplicationSlotCtlData

Macros
#define	PG_REPLSLOT_DIR   "pg_replslot"
#define	CONFLICT_DETECTION_SLOT   "pg_conflict_detection"
#define	RS_INVAL_MAX_CAUSES   4
#define	SlotIsPhysical(slot)   ((slot)->data.database == InvalidOid)
#define	SlotIsLogical(slot)   ((slot)->data.database != InvalidOid)

Typedefs
typedef enum ReplicationSlotPersistency	ReplicationSlotPersistency
typedef enum ReplicationSlotInvalidationCause	ReplicationSlotInvalidationCause
typedef enum SlotSyncSkipReason	SlotSyncSkipReason
typedef struct ReplicationSlotPersistentData	ReplicationSlotPersistentData
typedef struct ReplicationSlot	ReplicationSlot
typedef struct ReplicationSlotCtlData	ReplicationSlotCtlData

Enumerations
enum	ReplicationSlotPersistency { RS_PERSISTENT , RS_EPHEMERAL , RS_TEMPORARY }
enum	ReplicationSlotInvalidationCause {   RS_INVAL_NONE = 0 , RS_INVAL_WAL_REMOVED = (1 << 0) , RS_INVAL_HORIZON = (1 << 1) , RS_INVAL_WAL_LEVEL = (1 << 2) ,   RS_INVAL_IDLE_TIMEOUT = (1 << 3) }
enum	SlotSyncSkipReason {   SS_SKIP_NONE , SS_SKIP_WAL_NOT_FLUSHED , SS_SKIP_WAL_OR_ROWS_REMOVED , SS_SKIP_NO_CONSISTENT_SNAPSHOT ,   SS_SKIP_INVALID }

Functions
static void	ReplicationSlotSetInactiveSince (ReplicationSlot *s, TimestampTz ts, bool acquire_lock)
Size	ReplicationSlotsShmemSize (void)
void	ReplicationSlotsShmemInit (void)
void	ReplicationSlotCreate (const char *name, bool db_specific, ReplicationSlotPersistency persistency, bool two_phase, bool failover, bool synced)
void	ReplicationSlotPersist (void)
void	ReplicationSlotDrop (const char *name, bool nowait)
void	ReplicationSlotDropAcquired (void)
void	ReplicationSlotAlter (const char *name, const bool *failover, const bool *two_phase)
void	ReplicationSlotAcquire (const char *name, bool nowait, bool error_if_invalid)
void	ReplicationSlotRelease (void)
void	ReplicationSlotCleanup (bool synced_only)
void	ReplicationSlotSave (void)
void	ReplicationSlotMarkDirty (void)
void	ReplicationSlotInitialize (void)
bool	ReplicationSlotValidateName (const char *name, bool allow_reserved_name, int elevel)
bool	ReplicationSlotValidateNameInternal (const char *name, bool allow_reserved_name, int *err_code, char **err_msg, char **err_hint)
void	ReplicationSlotReserveWal (void)
void	ReplicationSlotsComputeRequiredXmin (bool already_locked)
void	ReplicationSlotsComputeRequiredLSN (void)
XLogRecPtr	ReplicationSlotsComputeLogicalRestartLSN (void)
bool	ReplicationSlotsCountDBSlots (Oid dboid, int *nslots, int *nactive)
bool	CheckLogicalSlotExists (void)
void	ReplicationSlotsDropDBSlots (Oid dboid)
bool	InvalidateObsoleteReplicationSlots (uint32 possible_causes, XLogSegNo oldestSegno, Oid dboid, TransactionId snapshotConflictHorizon)
ReplicationSlot *	SearchNamedReplicationSlot (const char *name, bool need_lock)
int	ReplicationSlotIndex (ReplicationSlot *slot)
bool	ReplicationSlotName (int index, Name name)
void	ReplicationSlotNameForTablesync (Oid suboid, Oid relid, char *syncslotname, Size szslot)
void	ReplicationSlotDropAtPubNode (WalReceiverConn *wrconn, char *slotname, bool missing_ok)
void	StartupReplicationSlots (void)
void	CheckPointReplicationSlots (bool is_shutdown)
void	CheckSlotRequirements (void)
void	CheckSlotPermissions (void)
ReplicationSlotInvalidationCause	GetSlotInvalidationCause (const char *cause_name)
const char *	GetSlotInvalidationCauseName (ReplicationSlotInvalidationCause cause)
bool	SlotExistsInSyncStandbySlots (const char *slot_name)
bool	StandbySlotsHaveCaughtup (XLogRecPtr wait_for_lsn, int elevel)
void	WaitForStandbyConfirmation (XLogRecPtr wait_for_lsn)

Variables
PGDLLIMPORT ReplicationSlotCtlData *	ReplicationSlotCtl
PGDLLIMPORT ReplicationSlot *	MyReplicationSlot
PGDLLIMPORT int	max_replication_slots
PGDLLIMPORT char *	synchronized_standby_slots
PGDLLIMPORT int	idle_replication_slot_timeout_secs

Macro Definition Documentation

CONFLICT_DETECTION_SLOT

#define CONFLICT_DETECTION_SLOT   "pg_conflict_detection"

Definition at line 28 of file slot.h.

PG_REPLSLOT_DIR

#define PG_REPLSLOT_DIR   "pg_replslot"

Definition at line 21 of file slot.h.

RS_INVAL_MAX_CAUSES

#define RS_INVAL_MAX_CAUSES   4

Definition at line 72 of file slot.h.

SlotIsLogical

#define SlotIsLogical

(

slot

)

((slot)->data.database != InvalidOid)

Definition at line 288 of file slot.h.

SlotIsPhysical

#define SlotIsPhysical

(

slot

)

((slot)->data.database == InvalidOid)

Definition at line 287 of file slot.h.

Typedef Documentation

ReplicationSlot

typedef struct ReplicationSlot ReplicationSlot

ReplicationSlotCtlData

typedef struct ReplicationSlotCtlData ReplicationSlotCtlData

ReplicationSlotInvalidationCause

typedef enum ReplicationSlotInvalidationCause ReplicationSlotInvalidationCause

ReplicationSlotPersistency

typedef enum ReplicationSlotPersistency ReplicationSlotPersistency

ReplicationSlotPersistentData

typedef struct ReplicationSlotPersistentData ReplicationSlotPersistentData

SlotSyncSkipReason

typedef enum SlotSyncSkipReason SlotSyncSkipReason

Enumeration Type Documentation

ReplicationSlotInvalidationCause

enum ReplicationSlotInvalidationCause

Enumerator
RS_INVAL_NONE
RS_INVAL_WAL_REMOVED
RS_INVAL_HORIZON
RS_INVAL_WAL_LEVEL
RS_INVAL_IDLE_TIMEOUT

Definition at line 58 of file slot.h.

{
    RS_INVAL_NONE = 0,
    /* required WAL has been removed */
    RS_INVAL_WAL_REMOVED = (1 << 0),
    /* required rows have been removed */
    RS_INVAL_HORIZON = (1 << 1),
    /* wal_level insufficient for slot */
    RS_INVAL_WAL_LEVEL = (1 << 2),
    /* idle slot timeout has occurred */
    RS_INVAL_IDLE_TIMEOUT = (1 << 3),
} ReplicationSlotInvalidationCause;

ReplicationSlotPersistency

enum ReplicationSlotPersistency

Enumerator
RS_PERSISTENT
RS_EPHEMERAL
RS_TEMPORARY

Definition at line 43 of file slot.h.

{
    RS_PERSISTENT,
    RS_EPHEMERAL,
    RS_TEMPORARY,
} ReplicationSlotPersistency;

SlotSyncSkipReason

enum SlotSyncSkipReason

Enumerator
SS_SKIP_NONE
SS_SKIP_WAL_NOT_FLUSHED
SS_SKIP_WAL_OR_ROWS_REMOVED
SS_SKIP_NO_CONSISTENT_SNAPSHOT
SS_SKIP_INVALID

Definition at line 80 of file slot.h.

{
    SS_SKIP_NONE,               /* No skip */
    SS_SKIP_WAL_NOT_FLUSHED,    /* Standby did not flush the wal corresponding
                                 * to confirmed flush of remote slot */
    SS_SKIP_WAL_OR_ROWS_REMOVED,    /* Remote slot is behind; required WAL or
                                     * rows may be removed or at risk */
    SS_SKIP_NO_CONSISTENT_SNAPSHOT, /* Standby could not build a consistent
                                     * snapshot */
    SS_SKIP_INVALID             /* Local slot is invalid */
} SlotSyncSkipReason;

Function Documentation

CheckLogicalSlotExists()

bool CheckLogicalSlotExists ( void  )

extern

Definition at line 1616 of file slot.c.

{
    bool        found = false;
 
    if (max_replication_slots <= 0)
        return false;
 
    LWLockAcquire(ReplicationSlotControlLock, LW_SHARED);
    for (int i = 0; i < max_replication_slots; i++)
    {
        ReplicationSlot *s;
        bool        invalidated;
 
        s = &ReplicationSlotCtl->replication_slots[i];
 
        /* cannot change while ReplicationSlotCtlLock is held */
        if (!s->in_use)
            continue;
 
        if (SlotIsPhysical(s))
            continue;
 
        SpinLockAcquire(&s->mutex);
        invalidated = s->data.invalidated != RS_INVAL_NONE;
        SpinLockRelease(&s->mutex);
 
        if (invalidated)
            continue;
 
        found = true;
        break;
    }
    LWLockRelease(ReplicationSlotControlLock);
 
    return found;
}

References ReplicationSlot::data, fb(), i, ReplicationSlot::in_use, ReplicationSlotPersistentData::invalidated, LW_SHARED, LWLockAcquire(), LWLockRelease(), max_replication_slots, ReplicationSlot::mutex, ReplicationSlotCtlData::replication_slots, ReplicationSlotCtl, RS_INVAL_NONE, SlotIsPhysical, SpinLockAcquire(), and SpinLockRelease().

Referenced by DisableLogicalDecoding(), and UpdateLogicalDecodingStatusEndOfRecovery().

CheckPointReplicationSlots()

void CheckPointReplicationSlots ( bool  is_shutdown )

extern

Definition at line 2310 of file slot.c.

{
    int         i;
    bool        last_saved_restart_lsn_updated = false;
 
    elog(DEBUG1, "performing replication slot checkpoint");
 
    /*
     * Prevent any slot from being created/dropped while we're active. As we
     * explicitly do *not* want to block iterating over replication_slots or
     * acquiring a slot we cannot take the control lock - but that's OK,
     * because holding ReplicationSlotAllocationLock is strictly stronger, and
     * enough to guarantee that nobody can change the in_use bits on us.
     *
     * Additionally, acquiring the Allocation lock is necessary to serialize
     * the slot flush process with concurrent slot WAL reservation. This
     * ensures that the WAL position being reserved is either flushed to disk
     * or is beyond or equal to the redo pointer of the current checkpoint
     * (See ReplicationSlotReserveWal for details).
     */
    LWLockAcquire(ReplicationSlotAllocationLock, LW_SHARED);
 
    for (i = 0; i < max_replication_slots; i++)
    {
        ReplicationSlot *s = &ReplicationSlotCtl->replication_slots[i];
        char        path[MAXPGPATH];
 
        if (!s->in_use)
            continue;
 
        /* save the slot to disk, locking is handled in SaveSlotToPath() */
        sprintf(path, "%s/%s", PG_REPLSLOT_DIR, NameStr(s->data.name));
 
        /*
         * Slot's data is not flushed each time the confirmed_flush LSN is
         * updated as that could lead to frequent writes.  However, we decide
         * to force a flush of all logical slot's data at the time of shutdown
         * if the confirmed_flush LSN is changed since we last flushed it to
         * disk.  This helps in avoiding an unnecessary retreat of the
         * confirmed_flush LSN after restart.
         */
        if (is_shutdown && SlotIsLogical(s))
        {
            SpinLockAcquire(&s->mutex);
 
            if (s->data.invalidated == RS_INVAL_NONE &&
                s->data.confirmed_flush > s->last_saved_confirmed_flush)
            {
                s->just_dirtied = true;
                s->dirty = true;
            }
            SpinLockRelease(&s->mutex);
        }
 
        /*
         * Track if we're going to update slot's last_saved_restart_lsn. We
         * need this to know if we need to recompute the required LSN.
         */
        if (s->last_saved_restart_lsn != s->data.restart_lsn)
            last_saved_restart_lsn_updated = true;
 
        SaveSlotToPath(s, path, LOG);
    }
    LWLockRelease(ReplicationSlotAllocationLock);
 
    /*
     * Recompute the required LSN if SaveSlotToPath() updated
     * last_saved_restart_lsn for any slot.
     */
    if (last_saved_restart_lsn_updated)
        ReplicationSlotsComputeRequiredLSN();
}

References ReplicationSlotPersistentData::confirmed_flush, ReplicationSlot::data, DEBUG1, ReplicationSlot::dirty, elog, fb(), i, ReplicationSlot::in_use, ReplicationSlotPersistentData::invalidated, ReplicationSlot::just_dirtied, ReplicationSlot::last_saved_confirmed_flush, ReplicationSlot::last_saved_restart_lsn, LOG, LW_SHARED, LWLockAcquire(), LWLockRelease(), max_replication_slots, MAXPGPATH, ReplicationSlot::mutex, ReplicationSlotPersistentData::name, NameStr, PG_REPLSLOT_DIR, ReplicationSlotCtlData::replication_slots, ReplicationSlotCtl, ReplicationSlotsComputeRequiredLSN(), ReplicationSlotPersistentData::restart_lsn, RS_INVAL_NONE, SaveSlotToPath(), SlotIsLogical, SpinLockAcquire(), SpinLockRelease(), and sprintf.

Referenced by CheckPointGuts().

CheckSlotPermissions()

void CheckSlotPermissions ( void  )

extern

Definition at line 1680 of file slot.c.

{
    if (!has_rolreplication(GetUserId()))
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("permission denied to use replication slots"),
                 errdetail("Only roles with the %s attribute may use replication slots.",
                           "REPLICATION")));
}

References ereport, errcode(), errdetail(), errmsg, ERROR, fb(), GetUserId(), and has_rolreplication().

Referenced by copy_replication_slot(), pg_create_logical_replication_slot(), pg_create_physical_replication_slot(), pg_drop_replication_slot(), pg_logical_slot_get_changes_guts(), pg_replication_slot_advance(), and pg_sync_replication_slots().

CheckSlotRequirements()

void CheckSlotRequirements ( void  )

extern

Definition at line 1658 of file slot.c.

{
    /*
     * NB: Adding a new requirement likely means that RestoreSlotFromDisk()
     * needs the same check.
     */
 
    if (max_replication_slots == 0)
        ereport(ERROR,
                (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                 errmsg("replication slots can only be used if \"max_replication_slots\" > 0")));
 
    if (wal_level < WAL_LEVEL_REPLICA)
        ereport(ERROR,
                (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                 errmsg("replication slots can only be used if \"wal_level\" >= \"replica\"")));
}

References ereport, errcode(), errmsg, ERROR, fb(), max_replication_slots, wal_level, and WAL_LEVEL_REPLICA.

Referenced by CheckLogicalDecodingRequirements(), copy_replication_slot(), pg_create_physical_replication_slot(), and pg_drop_replication_slot().

GetSlotInvalidationCause()

ReplicationSlotInvalidationCause GetSlotInvalidationCause ( const char *  cause_name )

extern

Definition at line 2916 of file slot.c.

{
    Assert(cause_name);
 
    /* Search lookup table for the cause having this name */
    for (int i = 0; i <= RS_INVAL_MAX_CAUSES; i++)
    {
        if (strcmp(SlotInvalidationCauses[i].cause_name, cause_name) == 0)
            return SlotInvalidationCauses[i].cause;
    }
 
    Assert(false);
    return RS_INVAL_NONE;       /* to keep compiler quiet */
}

References Assert, SlotInvalidationCauseMap::cause, fb(), i, RS_INVAL_MAX_CAUSES, RS_INVAL_NONE, and SlotInvalidationCauses.

Referenced by fetch_remote_slots().

GetSlotInvalidationCauseName()

const char * GetSlotInvalidationCauseName ( ReplicationSlotInvalidationCause  cause )

extern

Definition at line 2936 of file slot.c.

{
    /* Search lookup table for the name of this cause */
    for (int i = 0; i <= RS_INVAL_MAX_CAUSES; i++)
    {
        if (SlotInvalidationCauses[i].cause == cause)
            return SlotInvalidationCauses[i].cause_name;
    }
 
    Assert(false);
    return "none";              /* to keep compiler quiet */
}

References Assert, SlotInvalidationCauseMap::cause_name, i, RS_INVAL_MAX_CAUSES, and SlotInvalidationCauses.

Referenced by pg_get_replication_slots(), and ReplicationSlotAcquire().

InvalidateObsoleteReplicationSlots()

bool InvalidateObsoleteReplicationSlots ( uint32  possible_causes, XLogSegNo  oldestSegno, Oid  dboid, TransactionId  snapshotConflictHorizon  )

extern

Definition at line 2206 of file slot.c.

{
    XLogRecPtr  oldestLSN;
    bool        invalidated = false;
    bool        invalidated_logical = false;
    bool        found_valid_logicalslot;
 
    Assert(!(possible_causes & RS_INVAL_HORIZON) || TransactionIdIsValid(snapshotConflictHorizon));
    Assert(!(possible_causes & RS_INVAL_WAL_REMOVED) || oldestSegno > 0);
    Assert(possible_causes != RS_INVAL_NONE);
 
    if (max_replication_slots == 0)
        return invalidated;
 
    XLogSegNoOffsetToRecPtr(oldestSegno, 0, wal_segment_size, oldestLSN);
 
restart:
    found_valid_logicalslot = false;
    LWLockAcquire(ReplicationSlotControlLock, LW_SHARED);
    for (int i = 0; i < max_replication_slots; i++)
    {
        ReplicationSlot *s = &ReplicationSlotCtl->replication_slots[i];
        bool        released_lock = false;
 
        if (!s->in_use)
            continue;
 
        /* Prevent invalidation of logical slots during binary upgrade */
        if (SlotIsLogical(s) && IsBinaryUpgrade)
        {
            SpinLockAcquire(&s->mutex);
            found_valid_logicalslot |= (s->data.invalidated == RS_INVAL_NONE);
            SpinLockRelease(&s->mutex);
 
            continue;
        }
 
        if (InvalidatePossiblyObsoleteSlot(possible_causes, s, oldestLSN,
                                           dboid, snapshotConflictHorizon,
                                           &released_lock))
        {
            Assert(released_lock);
 
            /* Remember we have invalidated a physical or logical slot */
            invalidated = true;
 
            /*
             * Additionally, remember we have invalidated a logical slot as we
             * can request disabling logical decoding later.
             */
            if (SlotIsLogical(s))
                invalidated_logical = true;
        }
        else
        {
            /*
             * We need to check if the slot is invalidated here since
             * InvalidatePossiblyObsoleteSlot() returns false also if the slot
             * is already invalidated.
             */
            SpinLockAcquire(&s->mutex);
            found_valid_logicalslot |=
                (SlotIsLogical(s) && (s->data.invalidated == RS_INVAL_NONE));
            SpinLockRelease(&s->mutex);
        }
 
        /* if the lock was released, start from scratch */
        if (released_lock)
            goto restart;
    }
    LWLockRelease(ReplicationSlotControlLock);
 
    /*
     * If any slots have been invalidated, recalculate the resource limits.
     */
    if (invalidated)
    {
        ReplicationSlotsComputeRequiredXmin(false);
        ReplicationSlotsComputeRequiredLSN();
    }
 
    /*
     * Request the checkpointer to disable logical decoding if no valid
     * logical slots remain. If called by the checkpointer during a
     * checkpoint, only the request is initiated; actual deactivation is
     * deferred until after the checkpoint completes.
     */
    if (invalidated_logical && !found_valid_logicalslot)
        RequestDisableLogicalDecoding();
 
    return invalidated;
}

References Assert, ReplicationSlot::data, fb(), i, ReplicationSlot::in_use, ReplicationSlotPersistentData::invalidated, InvalidatePossiblyObsoleteSlot(), IsBinaryUpgrade, LW_SHARED, LWLockAcquire(), LWLockRelease(), max_replication_slots, ReplicationSlot::mutex, ReplicationSlotCtlData::replication_slots, ReplicationSlotCtl, ReplicationSlotsComputeRequiredLSN(), ReplicationSlotsComputeRequiredXmin(), RequestDisableLogicalDecoding(), RS_INVAL_HORIZON, RS_INVAL_NONE, RS_INVAL_WAL_REMOVED, SlotIsLogical, SpinLockAcquire(), SpinLockRelease(), TransactionIdIsValid, wal_segment_size, and XLogSegNoOffsetToRecPtr.

Referenced by CreateCheckPoint(), CreateRestartPoint(), ResolveRecoveryConflictWithSnapshot(), and xlog_redo().

ReplicationSlotAcquire()

void ReplicationSlotAcquire ( const char *  name, bool  nowait, bool  error_if_invalid  )

extern

Definition at line 622 of file slot.c.

{
    ReplicationSlot *s;
    ProcNumber  active_proc;
    int         active_pid;
 
    Assert(name != NULL);
 
retry:
    Assert(MyReplicationSlot == NULL);
 
    LWLockAcquire(ReplicationSlotControlLock, LW_SHARED);
 
    /* Check if the slot exists with the given name. */
    s = SearchNamedReplicationSlot(name, false);
    if (s == NULL || !s->in_use)
    {
        LWLockRelease(ReplicationSlotControlLock);
 
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("replication slot \"%s\" does not exist",
                        name)));
    }
 
    /*
     * Do not allow users to acquire the reserved slot. This scenario may
     * occur if the launcher that owns the slot has terminated unexpectedly
     * due to an error, and a backend process attempts to reuse the slot.
     */
    if (!IsLogicalLauncher() && IsSlotForConflictCheck(name))
        ereport(ERROR,
                errcode(ERRCODE_UNDEFINED_OBJECT),
                errmsg("cannot acquire replication slot \"%s\"", name),
                errdetail("The slot is reserved for conflict detection and can only be acquired by logical replication launcher."));
 
    /*
     * This is the slot we want; check if it's active under some other
     * process.  In single user mode, we don't need this check.
     */
    if (IsUnderPostmaster)
    {
        /*
         * Get ready to sleep on the slot in case it is active.  (We may end
         * up not sleeping, but we don't want to do this while holding the
         * spinlock.)
         */
        if (!nowait)
            ConditionVariablePrepareToSleep(&s->active_cv);
 
        /*
         * It is important to reset the inactive_since under spinlock here to
         * avoid race conditions with slot invalidation. See comments related
         * to inactive_since in InvalidatePossiblyObsoleteSlot.
         */
        SpinLockAcquire(&s->mutex);
        if (s->active_proc == INVALID_PROC_NUMBER)
            s->active_proc = MyProcNumber;
        active_proc = s->active_proc;
        ReplicationSlotSetInactiveSince(s, 0, false);
        SpinLockRelease(&s->mutex);
    }
    else
    {
        s->active_proc = active_proc = MyProcNumber;
        ReplicationSlotSetInactiveSince(s, 0, true);
    }
    active_pid = GetPGProcByNumber(active_proc)->pid;
    LWLockRelease(ReplicationSlotControlLock);
 
    /*
     * If we found the slot but it's already active in another process, we
     * wait until the owning process signals us that it's been released, or
     * error out.
     */
    if (active_proc != MyProcNumber)
    {
        if (!nowait)
        {
            /* Wait here until we get signaled, and then restart */
            ConditionVariableSleep(&s->active_cv,
                                   WAIT_EVENT_REPLICATION_SLOT_DROP);
            ConditionVariableCancelSleep();
            goto retry;
        }
 
        ereport(ERROR,
                (errcode(ERRCODE_OBJECT_IN_USE),
                 errmsg("replication slot \"%s\" is active for PID %d",
                        NameStr(s->data.name), active_pid)));
    }
    else if (!nowait)
        ConditionVariableCancelSleep(); /* no sleep needed after all */
 
    /* We made this slot active, so it's ours now. */
    MyReplicationSlot = s;
 
    /*
     * We need to check for invalidation after making the slot ours to avoid
     * the possible race condition with the checkpointer that can otherwise
     * invalidate the slot immediately after the check.
     */
    if (error_if_invalid && s->data.invalidated != RS_INVAL_NONE)
        ereport(ERROR,
                errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                errmsg("can no longer access replication slot \"%s\"",
                       NameStr(s->data.name)),
                errdetail("This replication slot has been invalidated due to \"%s\".",
                          GetSlotInvalidationCauseName(s->data.invalidated)));
 
    /* Let everybody know we've modified this slot */
    ConditionVariableBroadcast(&s->active_cv);
 
    /*
     * The call to pgstat_acquire_replslot() protects against stats for a
     * different slot, from before a restart or such, being present during
     * pgstat_report_replslot().
     */
    if (SlotIsLogical(s))
        pgstat_acquire_replslot(s);
 
 
    if (am_walsender)
    {
        ereport(log_replication_commands ? LOG : DEBUG1,
                SlotIsLogical(s)
                ? errmsg("acquired logical replication slot \"%s\"",
                         NameStr(s->data.name))
                : errmsg("acquired physical replication slot \"%s\"",
                         NameStr(s->data.name)));
    }
}

References ReplicationSlot::active_cv, ReplicationSlot::active_proc, am_walsender, Assert, ConditionVariableBroadcast(), ConditionVariableCancelSleep(), ConditionVariablePrepareToSleep(), ConditionVariableSleep(), ReplicationSlot::data, DEBUG1, ereport, errcode(), errdetail(), errmsg, ERROR, fb(), GetPGProcByNumber, GetSlotInvalidationCauseName(), ReplicationSlot::in_use, INVALID_PROC_NUMBER, ReplicationSlotPersistentData::invalidated, IsLogicalLauncher(), IsSlotForConflictCheck(), IsUnderPostmaster, LOG, log_replication_commands, LW_SHARED, LWLockAcquire(), LWLockRelease(), ReplicationSlot::mutex, MyProcNumber, MyReplicationSlot, name, ReplicationSlotPersistentData::name, NameStr, pgstat_acquire_replslot(), ReplicationSlotSetInactiveSince(), RS_INVAL_NONE, SearchNamedReplicationSlot(), SlotIsLogical, SpinLockAcquire(), and SpinLockRelease().

Referenced by acquire_conflict_slot_if_exists(), binary_upgrade_check_logical_slot_pending_wal(), drop_local_obsolete_slots(), pg_logical_slot_get_changes_guts(), pg_replication_slot_advance(), ReplicationSlotAlter(), ReplicationSlotDrop(), StartLogicalReplication(), StartReplication(), and synchronize_one_slot().

ReplicationSlotAlter()

void ReplicationSlotAlter ( const char *  name, const bool *  failover, const bool *  two_phase  )

extern

Definition at line 953 of file slot.c.

{
    bool        update_slot = false;
 
    Assert(MyReplicationSlot == NULL);
    Assert(failover || two_phase);
 
    ReplicationSlotAcquire(name, false, true);
 
    if (SlotIsPhysical(MyReplicationSlot))
        ereport(ERROR,
                errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                errmsg("cannot use %s with a physical replication slot",
                       "ALTER_REPLICATION_SLOT"));
 
    if (RecoveryInProgress())
    {
        /*
         * Do not allow users to alter the slots which are currently being
         * synced from the primary to the standby.
         */
        if (MyReplicationSlot->data.synced)
            ereport(ERROR,
                    errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                    errmsg("cannot alter replication slot \"%s\"", name),
                    errdetail("This replication slot is being synchronized from the primary server."));
 
        /*
         * Do not allow users to enable failover on the standby as we do not
         * support sync to the cascading standby.
         */
        if (failover && *failover)
            ereport(ERROR,
                    errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                    errmsg("cannot enable failover for a replication slot"
                           " on the standby"));
    }
 
    if (failover)
    {
        /*
         * Do not allow users to enable failover for temporary slots as we do
         * not support syncing temporary slots to the standby.
         */
        if (*failover && MyReplicationSlot->data.persistency == RS_TEMPORARY)
            ereport(ERROR,
                    errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                    errmsg("cannot enable failover for a temporary replication slot"));
 
        if (MyReplicationSlot->data.failover != *failover)
        {
            SpinLockAcquire(&MyReplicationSlot->mutex);
            MyReplicationSlot->data.failover = *failover;
            SpinLockRelease(&MyReplicationSlot->mutex);
 
            update_slot = true;
        }
    }
 
    if (two_phase && MyReplicationSlot->data.two_phase != *two_phase)
    {
        SpinLockAcquire(&MyReplicationSlot->mutex);
        MyReplicationSlot->data.two_phase = *two_phase;
        SpinLockRelease(&MyReplicationSlot->mutex);
 
        update_slot = true;
    }
 
    if (update_slot)
    {
        ReplicationSlotMarkDirty();
        ReplicationSlotSave();
    }
 
    ReplicationSlotRelease();
}

References Assert, ReplicationSlot::data, ereport, errcode(), errdetail(), errmsg, ERROR, failover, ReplicationSlotPersistentData::failover, fb(), ReplicationSlot::mutex, MyReplicationSlot, name, ReplicationSlotPersistentData::persistency, RecoveryInProgress(), ReplicationSlotAcquire(), ReplicationSlotMarkDirty(), ReplicationSlotRelease(), ReplicationSlotSave(), RS_TEMPORARY, SlotIsPhysical, SpinLockAcquire(), SpinLockRelease(), ReplicationSlotPersistentData::synced, two_phase, and ReplicationSlotPersistentData::two_phase.

Referenced by AlterReplicationSlot().

ReplicationSlotCleanup()

void ReplicationSlotCleanup ( bool  synced_only )

extern

Definition at line 861 of file slot.c.

{
    int         i;
    bool        found_valid_logicalslot;
    bool        dropped_logical = false;
 
    Assert(MyReplicationSlot == NULL);
 
restart:
    found_valid_logicalslot = false;
    LWLockAcquire(ReplicationSlotControlLock, LW_SHARED);
    for (i = 0; i < max_replication_slots; i++)
    {
        ReplicationSlot *s = &ReplicationSlotCtl->replication_slots[i];
 
        if (!s->in_use)
            continue;
 
        SpinLockAcquire(&s->mutex);
 
        found_valid_logicalslot |=
            (SlotIsLogical(s) && s->data.invalidated == RS_INVAL_NONE);
 
        if ((s->active_proc == MyProcNumber &&
             (!synced_only || s->data.synced)))
        {
            Assert(s->data.persistency == RS_TEMPORARY);
            SpinLockRelease(&s->mutex);
            LWLockRelease(ReplicationSlotControlLock);  /* avoid deadlock */
 
            if (SlotIsLogical(s))
                dropped_logical = true;
 
            ReplicationSlotDropPtr(s);
 
            ConditionVariableBroadcast(&s->active_cv);
            goto restart;
        }
        else
            SpinLockRelease(&s->mutex);
    }
 
    LWLockRelease(ReplicationSlotControlLock);
 
    if (dropped_logical && !found_valid_logicalslot)
        RequestDisableLogicalDecoding();
}

References ReplicationSlot::active_cv, ReplicationSlot::active_proc, Assert, ConditionVariableBroadcast(), ReplicationSlot::data, fb(), i, ReplicationSlot::in_use, ReplicationSlotPersistentData::invalidated, LW_SHARED, LWLockAcquire(), LWLockRelease(), max_replication_slots, ReplicationSlot::mutex, MyProcNumber, MyReplicationSlot, ReplicationSlotPersistentData::persistency, ReplicationSlotCtlData::replication_slots, ReplicationSlotCtl, ReplicationSlotDropPtr(), RequestDisableLogicalDecoding(), RS_INVAL_NONE, RS_TEMPORARY, SlotIsLogical, SpinLockAcquire(), SpinLockRelease(), and ReplicationSlotPersistentData::synced.

Referenced by PostgresMain(), ReplicationSlotShmemExit(), slotsync_failure_callback(), slotsync_worker_onexit(), SyncReplicationSlots(), and WalSndErrorCleanup().

ReplicationSlotCreate()

void ReplicationSlotCreate ( const char *  name, bool  db_specific, ReplicationSlotPersistency  persistency, bool  two_phase, bool  failover, bool  synced  )

extern

Definition at line 380 of file slot.c.

{
    ReplicationSlot *slot = NULL;
    int         i;
 
    Assert(MyReplicationSlot == NULL);
 
    /*
     * The logical launcher or pg_upgrade may create or migrate an internal
     * slot, so using a reserved name is allowed in these cases.
     */
    ReplicationSlotValidateName(name, IsBinaryUpgrade || IsLogicalLauncher(),
                                ERROR);
 
    if (failover)
    {
        /*
         * Do not allow users to create the failover enabled slots on the
         * standby as we do not support sync to the cascading standby.
         *
         * However, failover enabled slots can be created during slot
         * synchronization because we need to retain the same values as the
         * remote slot.
         */
        if (RecoveryInProgress() && !IsSyncingReplicationSlots())
            ereport(ERROR,
                    errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                    errmsg("cannot enable failover for a replication slot created on the standby"));
 
        /*
         * Do not allow users to create failover enabled temporary slots,
         * because temporary slots will not be synced to the standby.
         *
         * However, failover enabled temporary slots can be created during
         * slot synchronization. See the comments atop slotsync.c for details.
         */
        if (persistency == RS_TEMPORARY && !IsSyncingReplicationSlots())
            ereport(ERROR,
                    errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                    errmsg("cannot enable failover for a temporary replication slot"));
    }
 
    /*
     * If some other backend ran this code concurrently with us, we'd likely
     * both allocate the same slot, and that would be bad.  We'd also be at
     * risk of missing a name collision.  Also, we don't want to try to create
     * a new slot while somebody's busy cleaning up an old one, because we
     * might both be monkeying with the same directory.
     */
    LWLockAcquire(ReplicationSlotAllocationLock, LW_EXCLUSIVE);
 
    /*
     * Check for name collision, and identify an allocatable slot.  We need to
     * hold ReplicationSlotControlLock in shared mode for this, so that nobody
     * else can change the in_use flags while we're looking at them.
     */
    LWLockAcquire(ReplicationSlotControlLock, LW_SHARED);
    for (i = 0; i < max_replication_slots; i++)
    {
        ReplicationSlot *s = &ReplicationSlotCtl->replication_slots[i];
 
        if (s->in_use && strcmp(name, NameStr(s->data.name)) == 0)
            ereport(ERROR,
                    (errcode(ERRCODE_DUPLICATE_OBJECT),
                     errmsg("replication slot \"%s\" already exists", name)));
        if (!s->in_use && slot == NULL)
            slot = s;
    }
    LWLockRelease(ReplicationSlotControlLock);
 
    /* If all slots are in use, we're out of luck. */
    if (slot == NULL)
        ereport(ERROR,
                (errcode(ERRCODE_CONFIGURATION_LIMIT_EXCEEDED),
                 errmsg("all replication slots are in use"),
                 errhint("Free one or increase \"max_replication_slots\".")));
 
    /*
     * Since this slot is not in use, nobody should be looking at any part of
     * it other than the in_use field unless they're trying to allocate it.
     * And since we hold ReplicationSlotAllocationLock, nobody except us can
     * be doing that.  So it's safe to initialize the slot.
     */
    Assert(!slot->in_use);
    Assert(slot->active_proc == INVALID_PROC_NUMBER);
 
    /* first initialize persistent data */
    memset(&slot->data, 0, sizeof(ReplicationSlotPersistentData));
    namestrcpy(&slot->data.name, name);
    slot->data.database = db_specific ? MyDatabaseId : InvalidOid;
    slot->data.persistency = persistency;
    slot->data.two_phase = two_phase;
    slot->data.two_phase_at = InvalidXLogRecPtr;
    slot->data.failover = failover;
    slot->data.synced = synced;
 
    /* and then data only present in shared memory */
    slot->just_dirtied = false;
    slot->dirty = false;
    slot->effective_xmin = InvalidTransactionId;
    slot->effective_catalog_xmin = InvalidTransactionId;
    slot->candidate_catalog_xmin = InvalidTransactionId;
    slot->candidate_xmin_lsn = InvalidXLogRecPtr;
    slot->candidate_restart_valid = InvalidXLogRecPtr;
    slot->candidate_restart_lsn = InvalidXLogRecPtr;
    slot->last_saved_confirmed_flush = InvalidXLogRecPtr;
    slot->last_saved_restart_lsn = InvalidXLogRecPtr;
    slot->inactive_since = 0;
    slot->slotsync_skip_reason = SS_SKIP_NONE;
 
    /*
     * Create the slot on disk.  We haven't actually marked the slot allocated
     * yet, so no special cleanup is required if this errors out.
     */
    CreateSlotOnDisk(slot);
 
    /*
     * We need to briefly prevent any other backend from iterating over the
     * slots while we flip the in_use flag. We also need to set the active
     * flag while holding the ControlLock as otherwise a concurrent
     * ReplicationSlotAcquire() could acquire the slot as well.
     */
    LWLockAcquire(ReplicationSlotControlLock, LW_EXCLUSIVE);
 
    slot->in_use = true;
 
    /* We can now mark the slot active, and that makes it our slot. */
    SpinLockAcquire(&slot->mutex);
    Assert(slot->active_proc == INVALID_PROC_NUMBER);
    slot->active_proc = MyProcNumber;
    SpinLockRelease(&slot->mutex);
    MyReplicationSlot = slot;
 
    LWLockRelease(ReplicationSlotControlLock);
 
    /*
     * Create statistics entry for the new logical slot. We don't collect any
     * stats for physical slots, so no need to create an entry for the same.
     * See ReplicationSlotDropPtr for why we need to do this before releasing
     * ReplicationSlotAllocationLock.
     */
    if (SlotIsLogical(slot))
        pgstat_create_replslot(slot);
 
    /*
     * Now that the slot has been marked as in_use and active, it's safe to
     * let somebody else try to allocate a slot.
     */
    LWLockRelease(ReplicationSlotAllocationLock);
 
    /* Let everybody know we've modified this slot */
    ConditionVariableBroadcast(&slot->active_cv);
}

References ReplicationSlot::active_cv, ReplicationSlot::active_proc, Assert, ReplicationSlot::candidate_catalog_xmin, ReplicationSlot::candidate_restart_lsn, ReplicationSlot::candidate_restart_valid, ReplicationSlot::candidate_xmin_lsn, ConditionVariableBroadcast(), CreateSlotOnDisk(), ReplicationSlot::data, ReplicationSlotPersistentData::database, ReplicationSlot::dirty, ReplicationSlot::effective_catalog_xmin, ReplicationSlot::effective_xmin, ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errhint(), errmsg, ERROR, failover, ReplicationSlotPersistentData::failover, fb(), i, ReplicationSlot::in_use, ReplicationSlot::inactive_since, INVALID_PROC_NUMBER, InvalidOid, InvalidTransactionId, InvalidXLogRecPtr, IsBinaryUpgrade, IsLogicalLauncher(), IsSyncingReplicationSlots(), ReplicationSlot::just_dirtied, ReplicationSlot::last_saved_confirmed_flush, ReplicationSlot::last_saved_restart_lsn, LW_EXCLUSIVE, LW_SHARED, LWLockAcquire(), LWLockRelease(), max_replication_slots, ReplicationSlot::mutex, MyDatabaseId, MyProcNumber, MyReplicationSlot, name, ReplicationSlotPersistentData::name, NameStr, namestrcpy(), ReplicationSlotPersistentData::persistency, pgstat_create_replslot(), RecoveryInProgress(), ReplicationSlotCtlData::replication_slots, ReplicationSlotCtl, ReplicationSlotValidateName(), RS_TEMPORARY, SlotIsLogical, ReplicationSlot::slotsync_skip_reason, SpinLockAcquire(), SpinLockRelease(), SS_SKIP_NONE, ReplicationSlotPersistentData::synced, two_phase, ReplicationSlotPersistentData::two_phase, and ReplicationSlotPersistentData::two_phase_at.

Referenced by create_logical_replication_slot(), create_physical_replication_slot(), CreateConflictDetectionSlot(), CreateReplicationSlot(), and synchronize_one_slot().

ReplicationSlotDrop()

void ReplicationSlotDrop ( const char *  name, bool  nowait  )

extern

Definition at line 913 of file slot.c.

{
    bool        is_logical;
 
    Assert(MyReplicationSlot == NULL);
 
    ReplicationSlotAcquire(name, nowait, false);
 
    /*
     * Do not allow users to drop the slots which are currently being synced
     * from the primary to the standby.
     */
    if (RecoveryInProgress() && MyReplicationSlot->data.synced)
        ereport(ERROR,
                errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                errmsg("cannot drop replication slot \"%s\"", name),
                errdetail("This replication slot is being synchronized from the primary server."));
 
    is_logical = SlotIsLogical(MyReplicationSlot);
 
    ReplicationSlotDropAcquired();
 
    if (is_logical)
        RequestDisableLogicalDecoding();
}

References Assert, ReplicationSlot::data, ereport, errcode(), errdetail(), errmsg, ERROR, fb(), MyReplicationSlot, name, RecoveryInProgress(), ReplicationSlotAcquire(), ReplicationSlotDropAcquired(), RequestDisableLogicalDecoding(), SlotIsLogical, and ReplicationSlotPersistentData::synced.

Referenced by DropReplicationSlot(), and pg_drop_replication_slot().

ReplicationSlotDropAcquired()

void ReplicationSlotDropAcquired ( void  )

extern

Definition at line 1035 of file slot.c.

{
    ReplicationSlot *slot = MyReplicationSlot;
 
    Assert(MyReplicationSlot != NULL);
 
    /* slot isn't acquired anymore */
    MyReplicationSlot = NULL;
 
    ReplicationSlotDropPtr(slot);
}

References Assert, fb(), MyReplicationSlot, and ReplicationSlotDropPtr().

Referenced by ApplyLauncherMain(), drop_local_obsolete_slots(), ReplicationSlotDrop(), ReplicationSlotRelease(), and ReplicationSlotsDropDBSlots().

ReplicationSlotDropAtPubNode()

void ReplicationSlotDropAtPubNode ( WalReceiverConn *  wrconn, char *  slotname, bool  missing_ok  )

extern

Definition at line 2494 of file subscriptioncmds.c.

{
    StringInfoData cmd;
 
    Assert(wrconn);
 
    load_file("libpqwalreceiver", false);
 
    initStringInfo(&cmd);
    appendStringInfo(&cmd, "DROP_REPLICATION_SLOT %s WAIT", quote_identifier(slotname));
 
    PG_TRY();
    {
        WalRcvExecResult *res;
 
        res = walrcv_exec(wrconn, cmd.data, 0, NULL);
 
        if (res->status == WALRCV_OK_COMMAND)
        {
            /* NOTICE. Success. */
            ereport(NOTICE,
                    (errmsg("dropped replication slot \"%s\" on publisher",
                            slotname)));
        }
        else if (res->status == WALRCV_ERROR &&
                 missing_ok &&
                 res->sqlstate == ERRCODE_UNDEFINED_OBJECT)
        {
            /* LOG. Error, but missing_ok = true. */
            ereport(LOG,
                    (errmsg("could not drop replication slot \"%s\" on publisher: %s",
                            slotname, res->err)));
        }
        else
        {
            /* ERROR. */
            ereport(ERROR,
                    (errcode(ERRCODE_CONNECTION_FAILURE),
                     errmsg("could not drop replication slot \"%s\" on publisher: %s",
                            slotname, res->err)));
        }
 
        walrcv_clear_result(res);
    }
    PG_FINALLY();
    {
        pfree(cmd.data);
    }
    PG_END_TRY();
}

References appendStringInfo(), Assert, StringInfoData::data, ereport, WalRcvExecResult::err, errcode(), errmsg, ERROR, fb(), initStringInfo(), load_file(), LOG, NOTICE, pfree(), PG_END_TRY, PG_FINALLY, PG_TRY, quote_identifier(), WalRcvExecResult::sqlstate, WalRcvExecResult::status, walrcv_clear_result(), WALRCV_ERROR, walrcv_exec, WALRCV_OK_COMMAND, and wrconn.

Referenced by AlterSubscription_refresh(), DropSubscription(), LogicalRepSyncTableStart(), and ProcessSyncingTablesForSync().

ReplicationSlotIndex()

int ReplicationSlotIndex ( ReplicationSlot *  slot )

extern

Definition at line 575 of file slot.c.

{
    Assert(slot >= ReplicationSlotCtl->replication_slots &&
           slot < ReplicationSlotCtl->replication_slots + max_replication_slots);
 
    return slot - ReplicationSlotCtl->replication_slots;
}

References Assert, fb(), max_replication_slots, ReplicationSlotCtlData::replication_slots, and ReplicationSlotCtl.

Referenced by get_replslot_index(), pgstat_acquire_replslot(), pgstat_create_replslot(), pgstat_drop_replslot(), pgstat_report_replslot(), pgstat_report_replslotsync(), and pgstat_reset_replslot().

ReplicationSlotInitialize()

void ReplicationSlotInitialize ( void  )

extern

Definition at line 243 of file slot.c.

{
    before_shmem_exit(ReplicationSlotShmemExit, 0);
}

References before_shmem_exit(), and ReplicationSlotShmemExit().

Referenced by BaseInit().

ReplicationSlotMarkDirty()

void ReplicationSlotMarkDirty ( void  )

extern

Definition at line 1177 of file slot.c.

{
    ReplicationSlot *slot = MyReplicationSlot;
 
    Assert(MyReplicationSlot != NULL);
 
    SpinLockAcquire(&slot->mutex);
    MyReplicationSlot->just_dirtied = true;
    MyReplicationSlot->dirty = true;
    SpinLockRelease(&slot->mutex);
}

References Assert, ReplicationSlot::dirty, fb(), ReplicationSlot::just_dirtied, ReplicationSlot::mutex, MyReplicationSlot, SpinLockAcquire(), and SpinLockRelease().

Referenced by copy_replication_slot(), create_physical_replication_slot(), CreateDecodingContext(), CreateInitDecodingContext(), CreateReplicationSlot(), init_conflict_slot_xmin(), InvalidatePossiblyObsoleteSlot(), LogicalConfirmReceivedLocation(), LogicalSlotAdvanceAndCheckSnapState(), pg_logical_slot_get_changes_guts(), pg_physical_replication_slot_advance(), PhysicalConfirmReceivedLocation(), PhysicalReplicationSlotNewXmin(), ReplicationSlotAlter(), ReplicationSlotPersist(), synchronize_one_slot(), update_conflict_slot_xmin(), and update_local_synced_slot().

ReplicationSlotName()

bool ReplicationSlotName ( int  index, Name  name  )

extern

Definition at line 591 of file slot.c.

{
    ReplicationSlot *slot;
    bool        found;
 
    slot = &ReplicationSlotCtl->replication_slots[index];
 
    /*
     * Ensure that the slot cannot be dropped while we copy the name. Don't
     * need the spinlock as the name of an existing slot cannot change.
     */
    LWLockAcquire(ReplicationSlotControlLock, LW_SHARED);
    found = slot->in_use;
    if (slot->in_use)
        namestrcpy(name, NameStr(slot->data.name));
    LWLockRelease(ReplicationSlotControlLock);
 
    return found;
}

References ReplicationSlot::data, fb(), ReplicationSlot::in_use, LW_SHARED, LWLockAcquire(), LWLockRelease(), name, ReplicationSlotPersistentData::name, NameStr, namestrcpy(), ReplicationSlotCtlData::replication_slots, and ReplicationSlotCtl.

Referenced by pgstat_replslot_to_serialized_name_cb().

ReplicationSlotNameForTablesync()

void ReplicationSlotNameForTablesync ( Oid  suboid, Oid  relid, char *  syncslotname, Size  szslot  )

extern

Definition at line 1203 of file tablesync.c.

{
    snprintf(syncslotname, szslot, "pg_%u_sync_%u_" UINT64_FORMAT, suboid,
             relid, GetSystemIdentifier());
}

References fb(), GetSystemIdentifier(), snprintf, and UINT64_FORMAT.

Referenced by AlterSubscription_refresh(), DropSubscription(), LogicalRepSyncTableStart(), ProcessSyncingTablesForSync(), and ReportSlotConnectionError().

ReplicationSlotPersist()

void ReplicationSlotPersist ( void  )

extern

Definition at line 1194 of file slot.c.

{
    ReplicationSlot *slot = MyReplicationSlot;
 
    Assert(slot != NULL);
    Assert(slot->data.persistency != RS_PERSISTENT);
 
    SpinLockAcquire(&slot->mutex);
    slot->data.persistency = RS_PERSISTENT;
    SpinLockRelease(&slot->mutex);
 
    ReplicationSlotMarkDirty();
    ReplicationSlotSave();
}

References Assert, ReplicationSlot::data, fb(), ReplicationSlot::mutex, MyReplicationSlot, ReplicationSlotPersistentData::persistency, ReplicationSlotMarkDirty(), ReplicationSlotSave(), RS_PERSISTENT, SpinLockAcquire(), and SpinLockRelease().

Referenced by copy_replication_slot(), CreateReplicationSlot(), pg_create_logical_replication_slot(), and update_and_persist_local_synced_slot().

ReplicationSlotRelease()

void ReplicationSlotRelease ( void  )

extern

Definition at line 762 of file slot.c.

{
    ReplicationSlot *slot = MyReplicationSlot;
    char       *slotname = NULL;    /* keep compiler quiet */
    bool        is_logical;
    TimestampTz now = 0;
 
    Assert(slot != NULL && slot->active_proc != INVALID_PROC_NUMBER);
 
    is_logical = SlotIsLogical(slot);
 
    if (am_walsender)
        slotname = pstrdup(NameStr(slot->data.name));
 
    if (slot->data.persistency == RS_EPHEMERAL)
    {
        /*
         * Delete the slot. There is no !PANIC case where this is allowed to
         * fail, all that may happen is an incomplete cleanup of the on-disk
         * data.
         */
        ReplicationSlotDropAcquired();
 
        /*
         * Request to disable logical decoding, even though this slot may not
         * have been the last logical slot. The checkpointer will verify if
         * logical decoding should actually be disabled.
         */
        if (is_logical)
            RequestDisableLogicalDecoding();
    }
 
    /*
     * If slot needed to temporarily restrain both data and catalog xmin to
     * create the catalog snapshot, remove that temporary constraint.
     * Snapshots can only be exported while the initial snapshot is still
     * acquired.
     */
    if (!TransactionIdIsValid(slot->data.xmin) &&
        TransactionIdIsValid(slot->effective_xmin))
    {
        SpinLockAcquire(&slot->mutex);
        slot->effective_xmin = InvalidTransactionId;
        SpinLockRelease(&slot->mutex);
        ReplicationSlotsComputeRequiredXmin(false);
    }
 
    /*
     * Set the time since the slot has become inactive. We get the current
     * time beforehand to avoid system call while holding the spinlock.
     */
    now = GetCurrentTimestamp();
 
    if (slot->data.persistency == RS_PERSISTENT)
    {
        /*
         * Mark persistent slot inactive.  We're not freeing it, just
         * disconnecting, but wake up others that may be waiting for it.
         */
        SpinLockAcquire(&slot->mutex);
        slot->active_proc = INVALID_PROC_NUMBER;
        ReplicationSlotSetInactiveSince(slot, now, false);
        SpinLockRelease(&slot->mutex);
        ConditionVariableBroadcast(&slot->active_cv);
    }
    else
        ReplicationSlotSetInactiveSince(slot, now, true);
 
    MyReplicationSlot = NULL;
 
    /* might not have been set when we've been a plain slot */
    LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
    MyProc->statusFlags &= ~PROC_IN_LOGICAL_DECODING;
    ProcGlobal->statusFlags[MyProc->pgxactoff] = MyProc->statusFlags;
    LWLockRelease(ProcArrayLock);
 
    if (am_walsender)
    {
        ereport(log_replication_commands ? LOG : DEBUG1,
                is_logical
                ? errmsg("released logical replication slot \"%s\"",
                         slotname)
                : errmsg("released physical replication slot \"%s\"",
                         slotname));
 
        pfree(slotname);
    }
}

References ReplicationSlot::active_cv, ReplicationSlot::active_proc, am_walsender, Assert, ConditionVariableBroadcast(), ReplicationSlot::data, DEBUG1, ReplicationSlot::effective_xmin, ereport, errmsg, fb(), GetCurrentTimestamp(), INVALID_PROC_NUMBER, InvalidTransactionId, LOG, log_replication_commands, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), ReplicationSlot::mutex, MyProc, MyReplicationSlot, ReplicationSlotPersistentData::name, NameStr, now(), ReplicationSlotPersistentData::persistency, pfree(), PGPROC::pgxactoff, ProcGlobal, pstrdup(), ReplicationSlotDropAcquired(), ReplicationSlotsComputeRequiredXmin(), ReplicationSlotSetInactiveSince(), RequestDisableLogicalDecoding(), RS_EPHEMERAL, RS_PERSISTENT, SlotIsLogical, SpinLockAcquire(), SpinLockRelease(), PGPROC::statusFlags, PROC_HDR::statusFlags, TransactionIdIsValid, and ReplicationSlotPersistentData::xmin.

Referenced by binary_upgrade_check_logical_slot_pending_wal(), binary_upgrade_create_conflict_detection_slot(), copy_replication_slot(), CreateReplicationSlot(), InvalidatePossiblyObsoleteSlot(), pg_create_logical_replication_slot(), pg_create_physical_replication_slot(), pg_logical_slot_get_changes_guts(), pg_replication_slot_advance(), PostgresMain(), ReplicationSlotAlter(), ReplicationSlotShmemExit(), slotsync_failure_callback(), slotsync_worker_onexit(), StartLogicalReplication(), StartReplication(), synchronize_one_slot(), and WalSndErrorCleanup().

ReplicationSlotReserveWal()

void ReplicationSlotReserveWal ( void  )

extern

Definition at line 1697 of file slot.c.

{
    ReplicationSlot *slot = MyReplicationSlot;
    XLogSegNo   segno;
    XLogRecPtr  restart_lsn;
 
    Assert(slot != NULL);
    Assert(!XLogRecPtrIsValid(slot->data.restart_lsn));
    Assert(!XLogRecPtrIsValid(slot->last_saved_restart_lsn));
 
    /*
     * The replication slot mechanism is used to prevent the removal of
     * required WAL.
     *
     * Acquire an exclusive lock to prevent the checkpoint process from
     * concurrently computing the minimum slot LSN (see
     * CheckPointReplicationSlots). This ensures that the WAL reserved for
     * replication cannot be removed during a checkpoint.
     *
     * The mechanism is reliable because if WAL reservation occurs first, the
     * checkpoint must wait for the restart_lsn update before determining the
     * minimum non-removable LSN. On the other hand, if the checkpoint happens
     * first, subsequent WAL reservations will select positions at or beyond
     * the redo pointer of that checkpoint.
     */
    LWLockAcquire(ReplicationSlotAllocationLock, LW_EXCLUSIVE);
 
    /*
     * For logical slots log a standby snapshot and start logical decoding at
     * exactly that position. That allows the slot to start up more quickly.
     * But on a standby we cannot do WAL writes, so just use the replay
     * pointer; effectively, an attempt to create a logical slot on standby
     * will cause it to wait for an xl_running_xact record to be logged
     * independently on the primary, so that a snapshot can be built using the
     * record.
     *
     * None of this is needed (or indeed helpful) for physical slots as
     * they'll start replay at the last logged checkpoint anyway. Instead,
     * return the location of the last redo LSN, where a base backup has to
     * start replay at.
     */
    if (SlotIsPhysical(slot))
        restart_lsn = GetRedoRecPtr();
    else if (RecoveryInProgress())
        restart_lsn = GetXLogReplayRecPtr(NULL);
    else
        restart_lsn = GetXLogInsertRecPtr();
 
    SpinLockAcquire(&slot->mutex);
    slot->data.restart_lsn = restart_lsn;
    SpinLockRelease(&slot->mutex);
 
    /* prevent WAL removal as fast as possible */
    ReplicationSlotsComputeRequiredLSN();
 
    /* Checkpoint shouldn't remove the required WAL. */
    XLByteToSeg(slot->data.restart_lsn, segno, wal_segment_size);
    if (XLogGetLastRemovedSegno() >= segno)
        elog(ERROR, "WAL required by replication slot %s has been removed concurrently",
             NameStr(slot->data.name));
 
    LWLockRelease(ReplicationSlotAllocationLock);
 
    if (!RecoveryInProgress() && SlotIsLogical(slot))
    {
        XLogRecPtr  flushptr;
 
        /* make sure we have enough information to start */
        flushptr = LogStandbySnapshot();
 
        /* and make sure it's fsynced to disk */
        XLogFlush(flushptr);
    }
}

References Assert, ReplicationSlot::data, elog, ERROR, fb(), GetRedoRecPtr(), GetXLogInsertRecPtr(), GetXLogReplayRecPtr(), ReplicationSlot::last_saved_restart_lsn, LogStandbySnapshot(), LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), ReplicationSlot::mutex, MyReplicationSlot, ReplicationSlotPersistentData::name, NameStr, RecoveryInProgress(), ReplicationSlotsComputeRequiredLSN(), ReplicationSlotPersistentData::restart_lsn, SlotIsLogical, SlotIsPhysical, SpinLockAcquire(), SpinLockRelease(), wal_segment_size, XLByteToSeg, XLogFlush(), XLogGetLastRemovedSegno(), and XLogRecPtrIsValid.

Referenced by create_physical_replication_slot(), CreateInitDecodingContext(), and CreateReplicationSlot().

ReplicationSlotSave()

void ReplicationSlotSave ( void  )

extern

Definition at line 1159 of file slot.c.

{
    char        path[MAXPGPATH];
 
    Assert(MyReplicationSlot != NULL);
 
    sprintf(path, "%s/%s", PG_REPLSLOT_DIR, NameStr(MyReplicationSlot->data.name));
    SaveSlotToPath(MyReplicationSlot, path, ERROR);
}

References Assert, ReplicationSlot::data, ERROR, fb(), MAXPGPATH, MyReplicationSlot, ReplicationSlotPersistentData::name, NameStr, PG_REPLSLOT_DIR, SaveSlotToPath(), and sprintf.

Referenced by copy_replication_slot(), create_physical_replication_slot(), CreateDecodingContext(), CreateInitDecodingContext(), CreateReplicationSlot(), init_conflict_slot_xmin(), InvalidatePossiblyObsoleteSlot(), LogicalConfirmReceivedLocation(), ReplicationSlotAlter(), ReplicationSlotPersist(), synchronize_one_slot(), and update_local_synced_slot().

ReplicationSlotsComputeLogicalRestartLSN()

XLogRecPtr ReplicationSlotsComputeLogicalRestartLSN ( void  )

extern

Definition at line 1371 of file slot.c.

{
    XLogRecPtr  result = InvalidXLogRecPtr;
    int         i;
 
    if (max_replication_slots <= 0)
        return InvalidXLogRecPtr;
 
    LWLockAcquire(ReplicationSlotControlLock, LW_SHARED);
 
    for (i = 0; i < max_replication_slots; i++)
    {
        ReplicationSlot *s;
        XLogRecPtr  restart_lsn;
        XLogRecPtr  last_saved_restart_lsn;
        bool        invalidated;
        ReplicationSlotPersistency persistency;
 
        s = &ReplicationSlotCtl->replication_slots[i];
 
        /* cannot change while ReplicationSlotCtlLock is held */
        if (!s->in_use)
            continue;
 
        /* we're only interested in logical slots */
        if (!SlotIsLogical(s))
            continue;
 
        /* read once, it's ok if it increases while we're checking */
        SpinLockAcquire(&s->mutex);
        persistency = s->data.persistency;
        restart_lsn = s->data.restart_lsn;
        invalidated = s->data.invalidated != RS_INVAL_NONE;
        last_saved_restart_lsn = s->last_saved_restart_lsn;
        SpinLockRelease(&s->mutex);
 
        /* invalidated slots need not apply */
        if (invalidated)
            continue;
 
        /*
         * For persistent slot use last_saved_restart_lsn to compute the
         * oldest LSN for removal of WAL segments.  The segments between
         * last_saved_restart_lsn and restart_lsn might be needed by a
         * persistent slot in the case of database crash.  Non-persistent
         * slots can't survive the database crash, so we don't care about
         * last_saved_restart_lsn for them.
         */
        if (persistency == RS_PERSISTENT)
        {
            if (XLogRecPtrIsValid(last_saved_restart_lsn) &&
                restart_lsn > last_saved_restart_lsn)
            {
                restart_lsn = last_saved_restart_lsn;
            }
        }
 
        if (!XLogRecPtrIsValid(restart_lsn))
            continue;
 
        if (!XLogRecPtrIsValid(result) ||
            restart_lsn < result)
            result = restart_lsn;
    }
 
    LWLockRelease(ReplicationSlotControlLock);
 
    return result;
}

References ReplicationSlot::data, fb(), i, ReplicationSlot::in_use, ReplicationSlotPersistentData::invalidated, InvalidXLogRecPtr, ReplicationSlot::last_saved_restart_lsn, LW_SHARED, LWLockAcquire(), LWLockRelease(), max_replication_slots, ReplicationSlot::mutex, ReplicationSlotPersistentData::persistency, ReplicationSlotCtlData::replication_slots, ReplicationSlotCtl, ReplicationSlotPersistentData::restart_lsn, RS_INVAL_NONE, RS_PERSISTENT, SlotIsLogical, SpinLockAcquire(), SpinLockRelease(), and XLogRecPtrIsValid.

Referenced by CheckPointLogicalRewriteHeap(), and CheckPointSnapBuild().

ReplicationSlotsComputeRequiredLSN()

void ReplicationSlotsComputeRequiredLSN ( void  )

extern

Definition at line 1301 of file slot.c.

{
    int         i;
    XLogRecPtr  min_required = InvalidXLogRecPtr;
 
    Assert(ReplicationSlotCtl != NULL);
 
    LWLockAcquire(ReplicationSlotControlLock, LW_SHARED);
    for (i = 0; i < max_replication_slots; i++)
    {
        ReplicationSlot *s = &ReplicationSlotCtl->replication_slots[i];
        XLogRecPtr  restart_lsn;
        XLogRecPtr  last_saved_restart_lsn;
        bool        invalidated;
        ReplicationSlotPersistency persistency;
 
        if (!s->in_use)
            continue;
 
        SpinLockAcquire(&s->mutex);
        persistency = s->data.persistency;
        restart_lsn = s->data.restart_lsn;
        invalidated = s->data.invalidated != RS_INVAL_NONE;
        last_saved_restart_lsn = s->last_saved_restart_lsn;
        SpinLockRelease(&s->mutex);
 
        /* invalidated slots need not apply */
        if (invalidated)
            continue;
 
        /*
         * For persistent slot use last_saved_restart_lsn to compute the
         * oldest LSN for removal of WAL segments.  The segments between
         * last_saved_restart_lsn and restart_lsn might be needed by a
         * persistent slot in the case of database crash.  Non-persistent
         * slots can't survive the database crash, so we don't care about
         * last_saved_restart_lsn for them.
         */
        if (persistency == RS_PERSISTENT)
        {
            if (XLogRecPtrIsValid(last_saved_restart_lsn) &&
                restart_lsn > last_saved_restart_lsn)
            {
                restart_lsn = last_saved_restart_lsn;
            }
        }
 
        if (XLogRecPtrIsValid(restart_lsn) &&
            (!XLogRecPtrIsValid(min_required) ||
             restart_lsn < min_required))
            min_required = restart_lsn;
    }
    LWLockRelease(ReplicationSlotControlLock);
 
    XLogSetReplicationSlotMinimumLSN(min_required);
}

References Assert, ReplicationSlot::data, fb(), i, ReplicationSlot::in_use, ReplicationSlotPersistentData::invalidated, InvalidXLogRecPtr, ReplicationSlot::last_saved_restart_lsn, LW_SHARED, LWLockAcquire(), LWLockRelease(), max_replication_slots, ReplicationSlot::mutex, ReplicationSlotPersistentData::persistency, ReplicationSlotCtlData::replication_slots, ReplicationSlotCtl, ReplicationSlotPersistentData::restart_lsn, RS_INVAL_NONE, RS_PERSISTENT, SpinLockAcquire(), SpinLockRelease(), XLogRecPtrIsValid, and XLogSetReplicationSlotMinimumLSN().

Referenced by CheckPointReplicationSlots(), copy_replication_slot(), InvalidateObsoleteReplicationSlots(), LogicalConfirmReceivedLocation(), pg_replication_slot_advance(), PhysicalConfirmReceivedLocation(), ReplicationSlotDropPtr(), ReplicationSlotReserveWal(), reserve_wal_for_local_slot(), StartupReplicationSlots(), and update_local_synced_slot().

ReplicationSlotsComputeRequiredXmin()

void ReplicationSlotsComputeRequiredXmin ( bool  already_locked )

extern

Definition at line 1219 of file slot.c.

{
    int         i;
    TransactionId agg_xmin = InvalidTransactionId;
    TransactionId agg_catalog_xmin = InvalidTransactionId;
 
    Assert(ReplicationSlotCtl != NULL);
    Assert(!already_locked ||
           (LWLockHeldByMeInMode(ReplicationSlotControlLock, LW_EXCLUSIVE) &&
            LWLockHeldByMeInMode(ProcArrayLock, LW_EXCLUSIVE)));
 
    /*
     * Hold the ReplicationSlotControlLock until after updating the slot xmin
     * values, so no backend updates the initial xmin for newly created slot
     * concurrently. A shared lock is used here to minimize lock contention,
     * especially when many slots exist and advancements occur frequently.
     * This is safe since an exclusive lock is taken during initial slot xmin
     * update in slot creation.
     *
     * One might think that we can hold the ProcArrayLock exclusively and
     * update the slot xmin values, but it could increase lock contention on
     * the ProcArrayLock, which is not great since this function can be called
     * at non-negligible frequency.
     *
     * Concurrent invocation of this function may cause the computed slot xmin
     * to regress. However, this is harmless because tuples prior to the most
     * recent xmin are no longer useful once advancement occurs (see
     * LogicalConfirmReceivedLocation where the slot's xmin value is flushed
     * before updating the effective_xmin). Thus, such regression merely
     * prevents VACUUM from prematurely removing tuples without causing the
     * early deletion of required data.
     */
    if (!already_locked)
        LWLockAcquire(ReplicationSlotControlLock, LW_SHARED);
 
    for (i = 0; i < max_replication_slots; i++)
    {
        ReplicationSlot *s = &ReplicationSlotCtl->replication_slots[i];
        TransactionId effective_xmin;
        TransactionId effective_catalog_xmin;
        bool        invalidated;
 
        if (!s->in_use)
            continue;
 
        SpinLockAcquire(&s->mutex);
        effective_xmin = s->effective_xmin;
        effective_catalog_xmin = s->effective_catalog_xmin;
        invalidated = s->data.invalidated != RS_INVAL_NONE;
        SpinLockRelease(&s->mutex);
 
        /* invalidated slots need not apply */
        if (invalidated)
            continue;
 
        /* check the data xmin */
        if (TransactionIdIsValid(effective_xmin) &&
            (!TransactionIdIsValid(agg_xmin) ||
             TransactionIdPrecedes(effective_xmin, agg_xmin)))
            agg_xmin = effective_xmin;
 
        /* check the catalog xmin */
        if (TransactionIdIsValid(effective_catalog_xmin) &&
            (!TransactionIdIsValid(agg_catalog_xmin) ||
             TransactionIdPrecedes(effective_catalog_xmin, agg_catalog_xmin)))
            agg_catalog_xmin = effective_catalog_xmin;
    }
 
    ProcArraySetReplicationSlotXmin(agg_xmin, agg_catalog_xmin, already_locked);
 
    if (!already_locked)
        LWLockRelease(ReplicationSlotControlLock);
}

References Assert, ReplicationSlot::data, ReplicationSlot::effective_catalog_xmin, ReplicationSlot::effective_xmin, fb(), i, ReplicationSlot::in_use, ReplicationSlotPersistentData::invalidated, InvalidTransactionId, LW_EXCLUSIVE, LW_SHARED, LWLockAcquire(), LWLockHeldByMeInMode(), LWLockRelease(), max_replication_slots, ReplicationSlot::mutex, ProcArraySetReplicationSlotXmin(), ReplicationSlotCtlData::replication_slots, ReplicationSlotCtl, RS_INVAL_NONE, SpinLockAcquire(), SpinLockRelease(), TransactionIdIsValid, and TransactionIdPrecedes().

Referenced by copy_replication_slot(), CreateInitDecodingContext(), init_conflict_slot_xmin(), InvalidateObsoleteReplicationSlots(), LogicalConfirmReceivedLocation(), pg_replication_slot_advance(), PhysicalReplicationSlotNewXmin(), ReplicationSlotDropPtr(), ReplicationSlotRelease(), StartupReplicationSlots(), synchronize_one_slot(), update_conflict_slot_xmin(), and update_local_synced_slot().

ReplicationSlotsCountDBSlots()

bool ReplicationSlotsCountDBSlots ( Oid  dboid, int *  nslots, int *  nactive  )

extern

Definition at line 1450 of file slot.c.

{
    int         i;
 
    *nslots = *nactive = 0;
 
    if (max_replication_slots <= 0)
        return false;
 
    LWLockAcquire(ReplicationSlotControlLock, LW_SHARED);
    for (i = 0; i < max_replication_slots; i++)
    {
        ReplicationSlot *s;
 
        s = &ReplicationSlotCtl->replication_slots[i];
 
        /* cannot change while ReplicationSlotCtlLock is held */
        if (!s->in_use)
            continue;
 
        /* only logical slots are database specific, skip */
        if (!SlotIsLogical(s))
            continue;
 
        /* not our database, skip */
        if (s->data.database != dboid)
            continue;
 
        /* NB: intentionally counting invalidated slots */
 
        /* count slots with spinlock held */
        SpinLockAcquire(&s->mutex);
        (*nslots)++;
        if (s->active_proc != INVALID_PROC_NUMBER)
            (*nactive)++;
        SpinLockRelease(&s->mutex);
    }
    LWLockRelease(ReplicationSlotControlLock);
 
    if (*nslots > 0)
        return true;
    return false;
}

References ReplicationSlot::active_proc, ReplicationSlot::data, ReplicationSlotPersistentData::database, fb(), i, ReplicationSlot::in_use, INVALID_PROC_NUMBER, LW_SHARED, LWLockAcquire(), LWLockRelease(), max_replication_slots, ReplicationSlot::mutex, ReplicationSlotCtlData::replication_slots, ReplicationSlotCtl, SlotIsLogical, SpinLockAcquire(), and SpinLockRelease().

Referenced by dropdb().

ReplicationSlotsDropDBSlots()

void ReplicationSlotsDropDBSlots ( Oid  dboid )

extern

Definition at line 1511 of file slot.c.

{
    int         i;
    bool        found_valid_logicalslot;
    bool        dropped = false;
 
    if (max_replication_slots <= 0)
        return;
 
restart:
    found_valid_logicalslot = false;
    LWLockAcquire(ReplicationSlotControlLock, LW_SHARED);
    for (i = 0; i < max_replication_slots; i++)
    {
        ReplicationSlot *s;
        char       *slotname;
        ProcNumber  active_proc;
 
        s = &ReplicationSlotCtl->replication_slots[i];
 
        /* cannot change while ReplicationSlotCtlLock is held */
        if (!s->in_use)
            continue;
 
        /* only logical slots are database specific, skip */
        if (!SlotIsLogical(s))
            continue;
 
        /*
         * Check logical slots on other databases too so we can disable
         * logical decoding only if no slots in the cluster.
         */
        SpinLockAcquire(&s->mutex);
        found_valid_logicalslot |= (s->data.invalidated == RS_INVAL_NONE);
        SpinLockRelease(&s->mutex);
 
        /* not our database, skip */
        if (s->data.database != dboid)
            continue;
 
        /* NB: intentionally including invalidated slots to drop */
 
        /* acquire slot, so ReplicationSlotDropAcquired can be reused  */
        SpinLockAcquire(&s->mutex);
        /* can't change while ReplicationSlotControlLock is held */
        slotname = NameStr(s->data.name);
        active_proc = s->active_proc;
        if (active_proc == INVALID_PROC_NUMBER)
        {
            MyReplicationSlot = s;
            s->active_proc = MyProcNumber;
        }
        SpinLockRelease(&s->mutex);
 
        /*
         * Even though we hold an exclusive lock on the database object a
         * logical slot for that DB can still be active, e.g. if it's
         * concurrently being dropped by a backend connected to another DB.
         *
         * That's fairly unlikely in practice, so we'll just bail out.
         *
         * The slot sync worker holds a shared lock on the database before
         * operating on synced logical slots to avoid conflict with the drop
         * happening here. The persistent synced slots are thus safe but there
         * is a possibility that the slot sync worker has created a temporary
         * slot (which stays active even on release) and we are trying to drop
         * that here. In practice, the chances of hitting this scenario are
         * less as during slot synchronization, the temporary slot is
         * immediately converted to persistent and thus is safe due to the
         * shared lock taken on the database. So, we'll just bail out in such
         * a case.
         *
         * XXX: We can consider shutting down the slot sync worker before
         * trying to drop synced temporary slots here.
         */
        if (active_proc != INVALID_PROC_NUMBER)
            ereport(ERROR,
                    (errcode(ERRCODE_OBJECT_IN_USE),
                     errmsg("replication slot \"%s\" is active for PID %d",
                            slotname, GetPGProcByNumber(active_proc)->pid)));
 
        /*
         * To avoid duplicating ReplicationSlotDropAcquired() and to avoid
         * holding ReplicationSlotControlLock over filesystem operations,
         * release ReplicationSlotControlLock and use
         * ReplicationSlotDropAcquired.
         *
         * As that means the set of slots could change, restart scan from the
         * beginning each time we release the lock.
         */
        LWLockRelease(ReplicationSlotControlLock);
        ReplicationSlotDropAcquired();
        dropped = true;
        goto restart;
    }
    LWLockRelease(ReplicationSlotControlLock);
 
    if (dropped && !found_valid_logicalslot)
        RequestDisableLogicalDecoding();
}

References ReplicationSlot::active_proc, ReplicationSlot::data, ReplicationSlotPersistentData::database, ereport, errcode(), errmsg, ERROR, fb(), GetPGProcByNumber, i, ReplicationSlot::in_use, INVALID_PROC_NUMBER, ReplicationSlotPersistentData::invalidated, LW_SHARED, LWLockAcquire(), LWLockRelease(), max_replication_slots, ReplicationSlot::mutex, MyProcNumber, MyReplicationSlot, ReplicationSlotPersistentData::name, NameStr, ReplicationSlotCtlData::replication_slots, ReplicationSlotCtl, ReplicationSlotDropAcquired(), RequestDisableLogicalDecoding(), RS_INVAL_NONE, SlotIsLogical, SpinLockAcquire(), and SpinLockRelease().

Referenced by dbase_redo(), and dropdb().

ReplicationSlotSetInactiveSince()

static void ReplicationSlotSetInactiveSince ( ReplicationSlot *  s, TimestampTz  ts, bool  acquire_lock  )

inlinestatic

Definition at line 306 of file slot.h.

{
    if (acquire_lock)
        SpinLockAcquire(&s->mutex);
 
    if (s->data.invalidated == RS_INVAL_NONE)
        s->inactive_since = ts;
 
    if (acquire_lock)
        SpinLockRelease(&s->mutex);
}

References ReplicationSlot::data, fb(), ReplicationSlot::inactive_since, ReplicationSlotPersistentData::invalidated, ReplicationSlot::mutex, RS_INVAL_NONE, SpinLockAcquire(), and SpinLockRelease().

Referenced by ReplicationSlotAcquire(), ReplicationSlotRelease(), RestoreSlotFromDisk(), and update_synced_slots_inactive_since().

ReplicationSlotsShmemInit()

void ReplicationSlotsShmemInit ( void  )

extern

Definition at line 207 of file slot.c.

{
    bool        found;
 
    if (max_replication_slots == 0)
        return;
 
    ReplicationSlotCtl = (ReplicationSlotCtlData *)
        ShmemInitStruct("ReplicationSlot Ctl", ReplicationSlotsShmemSize(),
                        &found);
 
    if (!found)
    {
        int         i;
 
        /* First time through, so initialize */
        MemSet(ReplicationSlotCtl, 0, ReplicationSlotsShmemSize());
 
        for (i = 0; i < max_replication_slots; i++)
        {
            ReplicationSlot *slot = &ReplicationSlotCtl->replication_slots[i];
 
            /* everything else is zeroed by the memset above */
            slot->active_proc = INVALID_PROC_NUMBER;
            SpinLockInit(&slot->mutex);
            LWLockInitialize(&slot->io_in_progress_lock,
                             LWTRANCHE_REPLICATION_SLOT_IO);
            ConditionVariableInit(&slot->active_cv);
        }
    }
}

References ReplicationSlot::active_cv, ReplicationSlot::active_proc, ConditionVariableInit(), fb(), i, INVALID_PROC_NUMBER, ReplicationSlot::io_in_progress_lock, LWLockInitialize(), max_replication_slots, MemSet, ReplicationSlot::mutex, ReplicationSlotCtlData::replication_slots, ReplicationSlotCtl, ReplicationSlotsShmemSize(), ShmemInitStruct(), and SpinLockInit().

Referenced by CreateOrAttachShmemStructs().

ReplicationSlotsShmemSize()

Size ReplicationSlotsShmemSize ( void  )

extern

Definition at line 189 of file slot.c.

{
    Size        size = 0;
 
    if (max_replication_slots == 0)
        return size;
 
    size = offsetof(ReplicationSlotCtlData, replication_slots);
    size = add_size(size,
                    mul_size(max_replication_slots, sizeof(ReplicationSlot)));
 
    return size;
}

References add_size(), fb(), max_replication_slots, and mul_size().

Referenced by CalculateShmemSize(), and ReplicationSlotsShmemInit().

ReplicationSlotValidateName()

bool ReplicationSlotValidateName ( const char *  name, bool  allow_reserved_name, int  elevel  )

extern

Definition at line 268 of file slot.c.

{
    int         err_code;
    char       *err_msg = NULL;
    char       *err_hint = NULL;
 
    if (!ReplicationSlotValidateNameInternal(name, allow_reserved_name,
                                             &err_code, &err_msg, &err_hint))
    {
        /*
         * Use errmsg_internal() and errhint_internal() instead of errmsg()
         * and errhint(), since the messages from
         * ReplicationSlotValidateNameInternal() are already translated. This
         * avoids double translation.
         */
        ereport(elevel,
                errcode(err_code),
                errmsg_internal("%s", err_msg),
                (err_hint != NULL) ? errhint_internal("%s", err_hint) : 0);
 
        pfree(err_msg);
        if (err_hint != NULL)
            pfree(err_hint);
        return false;
    }
 
    return true;
}

References ereport, errcode(), errhint_internal(), errmsg_internal(), fb(), name, pfree(), and ReplicationSlotValidateNameInternal().

Referenced by parse_subscription_options(), ReplicationSlotCreate(), and StartupReorderBuffer().

ReplicationSlotValidateNameInternal()

bool ReplicationSlotValidateNameInternal ( const char *  name, bool  allow_reserved_name, int *  err_code, char **  err_msg, char **  err_hint  )

extern

Definition at line 313 of file slot.c.

{
    const char *cp;
 
    if (strlen(name) == 0)
    {
        *err_code = ERRCODE_INVALID_NAME;
        *err_msg = psprintf(_("replication slot name \"%s\" is too short"), name);
        *err_hint = NULL;
        return false;
    }
 
    if (strlen(name) >= NAMEDATALEN)
    {
        *err_code = ERRCODE_NAME_TOO_LONG;
        *err_msg = psprintf(_("replication slot name \"%s\" is too long"), name);
        *err_hint = NULL;
        return false;
    }
 
    for (cp = name; *cp; cp++)
    {
        if (!((*cp >= 'a' && *cp <= 'z')
              || (*cp >= '0' && *cp <= '9')
              || (*cp == '_')))
        {
            *err_code = ERRCODE_INVALID_NAME;
            *err_msg = psprintf(_("replication slot name \"%s\" contains invalid character"), name);
            *err_hint = psprintf(_("Replication slot names may only contain lower case letters, numbers, and the underscore character."));
            return false;
        }
    }
 
    if (!allow_reserved_name && IsSlotForConflictCheck(name))
    {
        *err_code = ERRCODE_RESERVED_NAME;
        *err_msg = psprintf(_("replication slot name \"%s\" is reserved"), name);
        *err_hint = psprintf(_("The name \"%s\" is reserved for the conflict detection slot."),
                             CONFLICT_DETECTION_SLOT);
        return false;
    }
 
    return true;
}

References _, CONFLICT_DETECTION_SLOT, fb(), IsSlotForConflictCheck(), name, NAMEDATALEN, and psprintf().

Referenced by check_primary_slot_name(), ReplicationSlotValidateName(), and validate_sync_standby_slots().

SearchNamedReplicationSlot()

ReplicationSlot * SearchNamedReplicationSlot ( const char *  name, bool  need_lock  )

extern

Definition at line 542 of file slot.c.

{
    int         i;
    ReplicationSlot *slot = NULL;
 
    if (need_lock)
        LWLockAcquire(ReplicationSlotControlLock, LW_SHARED);
 
    for (i = 0; i < max_replication_slots; i++)
    {
        ReplicationSlot *s = &ReplicationSlotCtl->replication_slots[i];
 
        if (s->in_use && strcmp(name, NameStr(s->data.name)) == 0)
        {
            slot = s;
            break;
        }
    }
 
    if (need_lock)
        LWLockRelease(ReplicationSlotControlLock);
 
    return slot;
}

References ReplicationSlot::data, fb(), i, ReplicationSlot::in_use, LW_SHARED, LWLockAcquire(), LWLockRelease(), max_replication_slots, name, ReplicationSlotPersistentData::name, NameStr, ReplicationSlotCtlData::replication_slots, and ReplicationSlotCtl.

Referenced by acquire_conflict_slot_if_exists(), get_replslot_index(), pg_ls_replslotdir(), pgstat_reset_replslot(), ReadReplicationSlot(), ReplicationSlotAcquire(), StandbySlotsHaveCaughtup(), and synchronize_one_slot().

SlotExistsInSyncStandbySlots()

bool SlotExistsInSyncStandbySlots ( const char *  slot_name )

extern

Definition at line 3060 of file slot.c.

{
    const char *standby_slot_name;
 
    /* Return false if there is no value in synchronized_standby_slots */
    if (synchronized_standby_slots_config == NULL)
        return false;
 
    /*
     * XXX: We are not expecting this list to be long so a linear search
     * shouldn't hurt but if that turns out not to be true then we can cache
     * this information for each WalSender as well.
     */
    standby_slot_name = synchronized_standby_slots_config->slot_names;
    for (int i = 0; i < synchronized_standby_slots_config->nslotnames; i++)
    {
        if (strcmp(standby_slot_name, slot_name) == 0)
            return true;
 
        standby_slot_name += strlen(standby_slot_name) + 1;
    }
 
    return false;
}

References fb(), i, SyncStandbySlotsConfigData::nslotnames, SyncStandbySlotsConfigData::slot_names, and synchronized_standby_slots_config.

Referenced by PhysicalWakeupLogicalWalSnd().

StandbySlotsHaveCaughtup()

bool StandbySlotsHaveCaughtup ( XLogRecPtr  wait_for_lsn, int  elevel  )

extern

Definition at line 3093 of file slot.c.

{
    const char *name;
    int         caught_up_slot_num = 0;
    XLogRecPtr  min_restart_lsn = InvalidXLogRecPtr;
 
    /*
     * Don't need to wait for the standbys to catch up if there is no value in
     * synchronized_standby_slots.
     */
    if (synchronized_standby_slots_config == NULL)
        return true;
 
    /*
     * Don't need to wait for the standbys to catch up if we are on a standby
     * server, since we do not support syncing slots to cascading standbys.
     */
    if (RecoveryInProgress())
        return true;
 
    /*
     * Don't need to wait for the standbys to catch up if they are already
     * beyond the specified WAL location.
     */
    if (XLogRecPtrIsValid(ss_oldest_flush_lsn) &&
        ss_oldest_flush_lsn >= wait_for_lsn)
        return true;
 
    /*
     * To prevent concurrent slot dropping and creation while filtering the
     * slots, take the ReplicationSlotControlLock outside of the loop.
     */
    LWLockAcquire(ReplicationSlotControlLock, LW_SHARED);
 
    name = synchronized_standby_slots_config->slot_names;
    for (int i = 0; i < synchronized_standby_slots_config->nslotnames; i++)
    {
        XLogRecPtr  restart_lsn;
        bool        invalidated;
        bool        inactive;
        ReplicationSlot *slot;
 
        slot = SearchNamedReplicationSlot(name, false);
 
        /*
         * If a slot name provided in synchronized_standby_slots does not
         * exist, report a message and exit the loop.
         */
        if (!slot)
        {
            ereport(elevel,
                    errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                    errmsg("replication slot \"%s\" specified in parameter \"%s\" does not exist",
                           name, "synchronized_standby_slots"),
                    errdetail("Logical replication is waiting on the standby associated with replication slot \"%s\".",
                              name),
                    errhint("Create the replication slot \"%s\" or amend parameter \"%s\".",
                            name, "synchronized_standby_slots"));
            break;
        }
 
        /* Same as above: if a slot is not physical, exit the loop. */
        if (SlotIsLogical(slot))
        {
            ereport(elevel,
                    errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                    errmsg("cannot specify logical replication slot \"%s\" in parameter \"%s\"",
                           name, "synchronized_standby_slots"),
                    errdetail("Logical replication is waiting for correction on replication slot \"%s\".",
                              name),
                    errhint("Remove the logical replication slot \"%s\" from parameter \"%s\".",
                            name, "synchronized_standby_slots"));
            break;
        }
 
        SpinLockAcquire(&slot->mutex);
        restart_lsn = slot->data.restart_lsn;
        invalidated = slot->data.invalidated != RS_INVAL_NONE;
        inactive = slot->active_proc == INVALID_PROC_NUMBER;
        SpinLockRelease(&slot->mutex);
 
        if (invalidated)
        {
            /* Specified physical slot has been invalidated */
            ereport(elevel,
                    errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                    errmsg("physical replication slot \"%s\" specified in parameter \"%s\" has been invalidated",
                           name, "synchronized_standby_slots"),
                    errdetail("Logical replication is waiting on the standby associated with replication slot \"%s\".",
                              name),
                    errhint("Drop and recreate the replication slot \"%s\", or amend parameter \"%s\".",
                            name, "synchronized_standby_slots"));
            break;
        }
 
        if (!XLogRecPtrIsValid(restart_lsn) || restart_lsn < wait_for_lsn)
        {
            /* Log a message if no active_pid for this physical slot */
            if (inactive)
                ereport(elevel,
                        errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                        errmsg("replication slot \"%s\" specified in parameter \"%s\" does not have active_pid",
                               name, "synchronized_standby_slots"),
                        errdetail("Logical replication is waiting on the standby associated with replication slot \"%s\".",
                                  name),
                        errhint("Start the standby associated with the replication slot \"%s\", or amend parameter \"%s\".",
                                name, "synchronized_standby_slots"));
 
            /* Continue if the current slot hasn't caught up. */
            break;
        }
 
        Assert(restart_lsn >= wait_for_lsn);
 
        if (!XLogRecPtrIsValid(min_restart_lsn) ||
            min_restart_lsn > restart_lsn)
            min_restart_lsn = restart_lsn;
 
        caught_up_slot_num++;
 
        name += strlen(name) + 1;
    }
 
    LWLockRelease(ReplicationSlotControlLock);
 
    /*
     * Return false if not all the standbys have caught up to the specified
     * WAL location.
     */
    if (caught_up_slot_num != synchronized_standby_slots_config->nslotnames)
        return false;
 
    /* The ss_oldest_flush_lsn must not retreat. */
    Assert(!XLogRecPtrIsValid(ss_oldest_flush_lsn) ||
           min_restart_lsn >= ss_oldest_flush_lsn);
 
    ss_oldest_flush_lsn = min_restart_lsn;
 
    return true;
}

References ReplicationSlot::active_proc, Assert, ReplicationSlot::data, ereport, errcode(), errdetail(), errhint(), errmsg, fb(), i, INVALID_PROC_NUMBER, ReplicationSlotPersistentData::invalidated, InvalidXLogRecPtr, LW_SHARED, LWLockAcquire(), LWLockRelease(), ReplicationSlot::mutex, name, SyncStandbySlotsConfigData::nslotnames, RecoveryInProgress(), ReplicationSlotPersistentData::restart_lsn, RS_INVAL_NONE, SearchNamedReplicationSlot(), SyncStandbySlotsConfigData::slot_names, SlotIsLogical, SpinLockAcquire(), SpinLockRelease(), ss_oldest_flush_lsn, synchronized_standby_slots_config, and XLogRecPtrIsValid.

Referenced by NeedToWaitForStandbys(), and WaitForStandbyConfirmation().

StartupReplicationSlots()

void StartupReplicationSlots ( void  )

extern

Definition at line 2388 of file slot.c.

{
    DIR        *replication_dir;
    struct dirent *replication_de;
 
    elog(DEBUG1, "starting up replication slots");
 
    /* restore all slots by iterating over all on-disk entries */
    replication_dir = AllocateDir(PG_REPLSLOT_DIR);
    while ((replication_de = ReadDir(replication_dir, PG_REPLSLOT_DIR)) != NULL)
    {
        char        path[MAXPGPATH + sizeof(PG_REPLSLOT_DIR)];
        PGFileType  de_type;
 
        if (strcmp(replication_de->d_name, ".") == 0 ||
            strcmp(replication_de->d_name, "..") == 0)
            continue;
 
        snprintf(path, sizeof(path), "%s/%s", PG_REPLSLOT_DIR, replication_de->d_name);
        de_type = get_dirent_type(path, replication_de, false, DEBUG1);
 
        /* we're only creating directories here, skip if it's not our's */
        if (de_type != PGFILETYPE_ERROR && de_type != PGFILETYPE_DIR)
            continue;
 
        /* we crashed while a slot was being setup or deleted, clean up */
        if (pg_str_endswith(replication_de->d_name, ".tmp"))
        {
            if (!rmtree(path, true))
            {
                ereport(WARNING,
                        (errmsg("could not remove directory \"%s\"",
                                path)));
                continue;
            }
            fsync_fname(PG_REPLSLOT_DIR, true);
            continue;
        }
 
        /* looks like a slot in a normal state, restore */
        RestoreSlotFromDisk(replication_de->d_name);
    }
    FreeDir(replication_dir);
 
    /* currently no slots exist, we're done. */
    if (max_replication_slots <= 0)
        return;
 
    /* Now that we have recovered all the data, compute replication xmin */
    ReplicationSlotsComputeRequiredXmin(false);
    ReplicationSlotsComputeRequiredLSN();
}

References AllocateDir(), DEBUG1, elog, ereport, errmsg, fb(), FreeDir(), fsync_fname(), get_dirent_type(), max_replication_slots, MAXPGPATH, PG_REPLSLOT_DIR, pg_str_endswith(), PGFILETYPE_DIR, PGFILETYPE_ERROR, ReadDir(), ReplicationSlotsComputeRequiredLSN(), ReplicationSlotsComputeRequiredXmin(), RestoreSlotFromDisk(), rmtree(), snprintf, and WARNING.

Referenced by StartupXLOG().

WaitForStandbyConfirmation()

void WaitForStandbyConfirmation ( XLogRecPtr  wait_for_lsn )

extern

Definition at line 3241 of file slot.c.

{
    /*
     * Don't need to wait for the standby to catch up if the current acquired
     * slot is not a logical failover slot, or there is no value in
     * synchronized_standby_slots.
     */
    if (!MyReplicationSlot->data.failover || !synchronized_standby_slots_config)
        return;
 
    ConditionVariablePrepareToSleep(&WalSndCtl->wal_confirm_rcv_cv);
 
    for (;;)
    {
        CHECK_FOR_INTERRUPTS();
 
        if (ConfigReloadPending)
        {
            ConfigReloadPending = false;
            ProcessConfigFile(PGC_SIGHUP);
        }
 
        /* Exit if done waiting for every slot. */
        if (StandbySlotsHaveCaughtup(wait_for_lsn, WARNING))
            break;
 
        /*
         * Wait for the slots in the synchronized_standby_slots to catch up,
         * but use a timeout (1s) so we can also check if the
         * synchronized_standby_slots has been changed.
         */
        ConditionVariableTimedSleep(&WalSndCtl->wal_confirm_rcv_cv, 1000,
                                    WAIT_EVENT_WAIT_FOR_STANDBY_CONFIRMATION);
    }
 
    ConditionVariableCancelSleep();
}

References CHECK_FOR_INTERRUPTS, ConditionVariableCancelSleep(), ConditionVariablePrepareToSleep(), ConditionVariableTimedSleep(), ConfigReloadPending, ReplicationSlot::data, ReplicationSlotPersistentData::failover, fb(), MyReplicationSlot, PGC_SIGHUP, ProcessConfigFile(), StandbySlotsHaveCaughtup(), synchronized_standby_slots_config, WalSndCtlData::wal_confirm_rcv_cv, WalSndCtl, and WARNING.

Referenced by LogicalSlotAdvanceAndCheckSnapState(), and pg_logical_slot_get_changes_guts().

Variable Documentation

idle_replication_slot_timeout_secs

PGDLLIMPORT int idle_replication_slot_timeout_secs

extern

Definition at line 159 of file slot.c.

Referenced by CanInvalidateIdleSlot(), DetermineSlotInvalidationCause(), and ReportSlotInvalidation().

max_replication_slots

PGDLLIMPORT int max_replication_slots

extern

Definition at line 152 of file slot.c.

Referenced by check_new_cluster_replication_slots(), CheckLogicalSlotExists(), CheckPointReplicationSlots(), CheckSlotRequirements(), copy_replication_slot(), get_local_synced_slots(), InvalidateObsoleteReplicationSlots(), pg_get_replication_slots(), ReplicationSlotCleanup(), ReplicationSlotCreate(), ReplicationSlotIndex(), ReplicationSlotsComputeLogicalRestartLSN(), ReplicationSlotsComputeRequiredLSN(), ReplicationSlotsComputeRequiredXmin(), ReplicationSlotsCountDBSlots(), ReplicationSlotsDropDBSlots(), ReplicationSlotsShmemInit(), ReplicationSlotsShmemSize(), RestoreSlotFromDisk(), SearchNamedReplicationSlot(), StartupReplicationSlots(), and update_synced_slots_inactive_since().

MyReplicationSlot

PGDLLIMPORT ReplicationSlot* MyReplicationSlot

extern

Definition at line 149 of file slot.c.

Referenced by abort_logical_decoding_activation(), ApplyLauncherMain(), binary_upgrade_check_logical_slot_pending_wal(), compute_min_nonremovable_xid(), copy_replication_slot(), create_logical_replication_slot(), create_physical_replication_slot(), CreateConflictDetectionSlot(), CreateDecodingContext(), CreateInitDecodingContext(), CreateReplicationSlot(), DisableLogicalDecodingIfNecessary(), EnsureLogicalDecodingEnabled(), init_conflict_slot_xmin(), InvalidatePossiblyObsoleteSlot(), LogicalConfirmReceivedLocation(), LogicalIncreaseRestartDecodingForSlot(), LogicalIncreaseXminForSlot(), logicalrep_worker_launch(), LogicalReplicationSlotCheckPendingWal(), LogicalSlotAdvanceAndCheckSnapState(), NeedToWaitForStandbys(), pg_create_logical_replication_slot(), pg_create_physical_replication_slot(), pg_logical_slot_get_changes_guts(), pg_physical_replication_slot_advance(), pg_replication_slot_advance(), PhysicalConfirmReceivedLocation(), PhysicalReplicationSlotNewXmin(), PhysicalWakeupLogicalWalSnd(), PostgresMain(), ProcessStandbyHSFeedbackMessage(), ProcessStandbyReplyMessage(), ReorderBufferAllocate(), ReorderBufferFree(), ReorderBufferRestoreChanges(), ReorderBufferRestoreCleanup(), ReorderBufferSerializedPath(), ReorderBufferSerializeTXN(), ReplicationSlotAcquire(), ReplicationSlotAlter(), ReplicationSlotCleanup(), ReplicationSlotCreate(), ReplicationSlotDrop(), ReplicationSlotDropAcquired(), ReplicationSlotMarkDirty(), ReplicationSlotPersist(), ReplicationSlotRelease(), ReplicationSlotReserveWal(), ReplicationSlotSave(), ReplicationSlotsDropDBSlots(), ReplicationSlotShmemExit(), reserve_wal_for_local_slot(), slotsync_failure_callback(), slotsync_worker_onexit(), StartLogicalReplication(), StartReplication(), StartupDecodingContext(), synchronize_one_slot(), update_and_persist_local_synced_slot(), update_conflict_slot_xmin(), update_local_synced_slot(), update_slotsync_skip_stats(), WaitForStandbyConfirmation(), and WalSndErrorCleanup().

ReplicationSlotCtl

PGDLLIMPORT ReplicationSlotCtlData* ReplicationSlotCtl

extern

Definition at line 146 of file slot.c.

Referenced by CheckLogicalSlotExists(), CheckPointReplicationSlots(), copy_replication_slot(), get_local_synced_slots(), InvalidateObsoleteReplicationSlots(), pg_get_replication_slots(), ReplicationSlotCleanup(), ReplicationSlotCreate(), ReplicationSlotIndex(), ReplicationSlotName(), ReplicationSlotsComputeLogicalRestartLSN(), ReplicationSlotsComputeRequiredLSN(), ReplicationSlotsComputeRequiredXmin(), ReplicationSlotsCountDBSlots(), ReplicationSlotsDropDBSlots(), ReplicationSlotsShmemInit(), RestoreSlotFromDisk(), SearchNamedReplicationSlot(), and update_synced_slots_inactive_since().

synchronized_standby_slots

PGDLLIMPORT char* synchronized_standby_slots

extern

Definition at line 165 of file slot.c.