xlogrecovery.c File Reference

#include "postgres.h"
#include <ctype.h>
#include <math.h>
#include <time.h>
#include <sys/stat.h>
#include <unistd.h>
#include "access/timeline.h"
#include "access/transam.h"
#include "access/xact.h"
#include "access/xlog_internal.h"
#include "access/xlogarchive.h"
#include "access/xlogprefetcher.h"
#include "access/xlogreader.h"
#include "access/xlogrecovery.h"
#include "access/xlogutils.h"
#include "backup/basebackup.h"
#include "catalog/pg_control.h"
#include "commands/tablespace.h"
#include "common/file_utils.h"
#include "miscadmin.h"
#include "pgstat.h"
#include "postmaster/bgwriter.h"
#include "postmaster/startup.h"
#include "replication/slot.h"
#include "replication/slotsync.h"
#include "replication/walreceiver.h"
#include "storage/fd.h"
#include "storage/ipc.h"
#include "storage/latch.h"
#include "storage/pmsignal.h"
#include "storage/procarray.h"
#include "storage/spin.h"
#include "utils/datetime.h"
#include "utils/fmgrprotos.h"
#include "utils/guc_hooks.h"
#include "utils/pg_lsn.h"
#include "utils/ps_status.h"
#include "utils/pg_rusage.h"

Include dependency graph for xlogrecovery.c:

Go to the source code of this file.

Data Structures
struct	XLogPageReadPrivate
struct	XLogRecoveryCtlData

Macros
#define	RECOVERY_COMMAND_FILE   "recovery.conf"
#define	RECOVERY_COMMAND_DONE   "recovery.done"

Typedefs
typedef struct XLogPageReadPrivate	XLogPageReadPrivate
typedef struct XLogRecoveryCtlData	XLogRecoveryCtlData

Enumerations
enum	XLogSource { XLOG_FROM_ANY = 0 , XLOG_FROM_ARCHIVE , XLOG_FROM_PG_WAL , XLOG_FROM_STREAM }

Functions
static void	ApplyWalRecord (XLogReaderState *xlogreader, XLogRecord *record, TimeLineID *replayTLI)
static void	EnableStandbyMode (void)
static void	readRecoverySignalFile (void)
static void	validateRecoveryParameters (void)
static bool	read_backup_label (XLogRecPtr *checkPointLoc, TimeLineID *backupLabelTLI, bool *backupEndRequired, bool *backupFromStandby)
static bool	read_tablespace_map (List **tablespaces)
static void	xlogrecovery_redo (XLogReaderState *record, TimeLineID replayTLI)
static void	CheckRecoveryConsistency (void)
static void	rm_redo_error_callback (void *arg)
static void	xlog_block_info (StringInfo buf, XLogReaderState *record)
static void	checkTimeLineSwitch (XLogRecPtr lsn, TimeLineID newTLI, TimeLineID prevTLI, TimeLineID replayTLI)
static bool	getRecordTimestamp (XLogReaderState *record, TimestampTz *recordXtime)
static void	verifyBackupPageConsistency (XLogReaderState *record)
static bool	recoveryStopsBefore (XLogReaderState *record)
static bool	recoveryStopsAfter (XLogReaderState *record)
static char *	getRecoveryStopReason (void)
static void	recoveryPausesHere (bool endOfRecovery)
static bool	recoveryApplyDelay (XLogReaderState *record)
static void	ConfirmRecoveryPaused (void)
static XLogRecord *	ReadRecord (XLogPrefetcher *xlogprefetcher, int emode, bool fetching_ckpt, TimeLineID replayTLI)
static int	XLogPageRead (XLogReaderState *xlogreader, XLogRecPtr targetPagePtr, int reqLen, XLogRecPtr targetRecPtr, char *readBuf)
static XLogPageReadResult	WaitForWALToBecomeAvailable (XLogRecPtr RecPtr, bool randAccess, bool fetching_ckpt, XLogRecPtr tliRecPtr, TimeLineID replayTLI, XLogRecPtr replayLSN, bool nonblocking)
static int	emode_for_corrupt_record (int emode, XLogRecPtr RecPtr)
static XLogRecord *	ReadCheckpointRecord (XLogPrefetcher *xlogprefetcher, XLogRecPtr RecPtr, TimeLineID replayTLI)
static bool	rescanLatestTimeLine (TimeLineID replayTLI, XLogRecPtr replayLSN)
static int	XLogFileRead (XLogSegNo segno, int emode, TimeLineID tli, XLogSource source, bool notfoundOk)
static int	XLogFileReadAnyTLI (XLogSegNo segno, int emode, XLogSource source)
static bool	CheckForStandbyTrigger (void)
static void	SetPromoteIsTriggered (void)
static bool	HotStandbyActiveInReplay (void)
static void	SetCurrentChunkStartTime (TimestampTz xtime)
static void	SetLatestXTime (TimestampTz xtime)
Size	XLogRecoveryShmemSize (void)
void	XLogRecoveryShmemInit (void)
void	InitWalRecovery (ControlFileData *ControlFile, bool *wasShutdown_ptr, bool *haveBackupLabel_ptr, bool *haveTblspcMap_ptr)
EndOfWalRecoveryInfo *	FinishWalRecovery (void)
void	ShutdownWalRecovery (void)
void	PerformWalRecovery (void)
static void	CheckTablespaceDirectory (void)
void	xlog_outdesc (StringInfo buf, XLogReaderState *record)
RecoveryPauseState	GetRecoveryPauseState (void)
void	SetRecoveryPause (bool recoveryPause)
void	StartupRequestWalReceiverRestart (void)
bool	PromoteIsTriggered (void)
void	RemovePromoteSignalFiles (void)
bool	CheckPromoteSignal (void)
void	WakeupRecovery (void)
void	XLogRequestWalReceiverReply (void)
bool	HotStandbyActive (void)
XLogRecPtr	GetXLogReplayRecPtr (TimeLineID *replayTLI)
XLogRecPtr	GetCurrentReplayRecPtr (TimeLineID *replayEndTLI)
TimestampTz	GetLatestXTime (void)
TimestampTz	GetCurrentChunkReplayStartTime (void)
void	GetXLogReceiptTime (TimestampTz *rtime, bool *fromStream)
void	RecoveryRequiresIntParameter (const char *param_name, int currValue, int minValue)
bool	check_primary_slot_name (char **newval, void **extra, GucSource source)
static void	pg_attribute_noreturn () error_multiple_recovery_targets(void)
bool	check_recovery_target (char **newval, void **extra, GucSource source)
void	assign_recovery_target (const char *newval, void *extra)
bool	check_recovery_target_lsn (char **newval, void **extra, GucSource source)
void	assign_recovery_target_lsn (const char *newval, void *extra)
bool	check_recovery_target_name (char **newval, void **extra, GucSource source)
void	assign_recovery_target_name (const char *newval, void *extra)
bool	check_recovery_target_time (char **newval, void **extra, GucSource source)
void	assign_recovery_target_time (const char *newval, void *extra)
bool	check_recovery_target_timeline (char **newval, void **extra, GucSource source)
void	assign_recovery_target_timeline (const char *newval, void *extra)
bool	check_recovery_target_xid (char **newval, void **extra, GucSource source)
void	assign_recovery_target_xid (const char *newval, void *extra)

Variables
const struct config_enum_entry	recovery_target_action_options []
char *	recoveryRestoreCommand = NULL
char *	recoveryEndCommand = NULL
char *	archiveCleanupCommand = NULL
RecoveryTargetType	recoveryTarget = RECOVERY_TARGET_UNSET
bool	recoveryTargetInclusive = true
int	recoveryTargetAction = RECOVERY_TARGET_ACTION_PAUSE
TransactionId	recoveryTargetXid
char *	recovery_target_time_string
TimestampTz	recoveryTargetTime
const char *	recoveryTargetName
XLogRecPtr	recoveryTargetLSN
int	recovery_min_apply_delay = 0
char *	PrimaryConnInfo = NULL
char *	PrimarySlotName = NULL
bool	wal_receiver_create_temp_slot = false
RecoveryTargetTimeLineGoal	recoveryTargetTimeLineGoal = RECOVERY_TARGET_TIMELINE_LATEST
TimeLineID	recoveryTargetTLIRequested = 0
TimeLineID	recoveryTargetTLI = 0
static List *	expectedTLEs
static TimeLineID	curFileTLI
bool	ArchiveRecoveryRequested = false
bool	InArchiveRecovery = false
static bool	StandbyModeRequested = false
bool	StandbyMode = false
static bool	standby_signal_file_found = false
static bool	recovery_signal_file_found = false
static XLogRecPtr	CheckPointLoc = InvalidXLogRecPtr
static TimeLineID	CheckPointTLI = 0
static XLogRecPtr	RedoStartLSN = InvalidXLogRecPtr
static TimeLineID	RedoStartTLI = 0
static bool	LocalHotStandbyActive = false
static bool	LocalPromoteIsTriggered = false
static bool	doRequestWalReceiverReply
static XLogReaderState *	xlogreader = NULL
static XLogPrefetcher *	xlogprefetcher = NULL
static bool	InRedo = false
static const char *const	xlogSourceNames [] = {"any", "archive", "pg_wal", "stream"}
static int	readFile = -1
static XLogSegNo	readSegNo = 0
static uint32	readOff = 0
static uint32	readLen = 0
static XLogSource	readSource = XLOG_FROM_ANY
static XLogSource	currentSource = XLOG_FROM_ANY
static bool	lastSourceFailed = false
static bool	pendingWalRcvRestart = false
static TimestampTz	XLogReceiptTime = 0
static XLogSource	XLogReceiptSource = XLOG_FROM_ANY
static XLogRecPtr	flushedUpto = 0
static TimeLineID	receiveTLI = 0
static XLogRecPtr	minRecoveryPoint
static TimeLineID	minRecoveryPointTLI
static XLogRecPtr	backupStartPoint
static XLogRecPtr	backupEndPoint
static bool	backupEndRequired = false
bool	reachedConsistency = false
static char *	replay_image_masked = NULL
static char *	primary_image_masked = NULL
static XLogRecoveryCtlData *	XLogRecoveryCtl = NULL
static XLogRecPtr	abortedRecPtr
static XLogRecPtr	missingContrecPtr
static TransactionId	recoveryStopXid
static TimestampTz	recoveryStopTime
static XLogRecPtr	recoveryStopLSN
static char	recoveryStopName [MAXFNAMELEN]
static bool	recoveryStopAfter

Macro Definition Documentation

RECOVERY_COMMAND_DONE

#define RECOVERY_COMMAND_DONE   "recovery.done"

Definition at line 69 of file xlogrecovery.c.

RECOVERY_COMMAND_FILE

#define RECOVERY_COMMAND_FILE   "recovery.conf"

Definition at line 68 of file xlogrecovery.c.

Typedef Documentation

XLogPageReadPrivate

typedef struct XLogPageReadPrivate XLogPageReadPrivate

XLogRecoveryCtlData

typedef struct XLogRecoveryCtlData XLogRecoveryCtlData

Enumeration Type Documentation

XLogSource

enum XLogSource

Enumerator
XLOG_FROM_ANY
XLOG_FROM_ARCHIVE
XLOG_FROM_PG_WAL
XLOG_FROM_STREAM

Definition at line 209 of file xlogrecovery.c.

{
    XLOG_FROM_ANY = 0,          /* request to read WAL from any source */
    XLOG_FROM_ARCHIVE,          /* restored using restore_command */
    XLOG_FROM_PG_WAL,           /* existing file in pg_wal */
    XLOG_FROM_STREAM,           /* streamed from primary */
} XLogSource;

Function Documentation

ApplyWalRecord()

static void ApplyWalRecord ( XLogReaderState *  xlogreader, XLogRecord *  record, TimeLineID *  replayTLI  )

static

Definition at line 1908 of file xlogrecovery.c.

{
    ErrorContextCallback errcallback;
    bool        switchedTLI = false;
 
    /* Setup error traceback support for ereport() */
    errcallback.callback = rm_redo_error_callback;
    errcallback.arg = (void *) xlogreader;
    errcallback.previous = error_context_stack;
    error_context_stack = &errcallback;
 
    /*
     * TransamVariables->nextXid must be beyond record's xid.
     */
    AdvanceNextFullTransactionIdPastXid(record->xl_xid);
 
    /*
     * Before replaying this record, check if this record causes the current
     * timeline to change. The record is already considered to be part of the
     * new timeline, so we update replayTLI before replaying it. That's
     * important so that replayEndTLI, which is recorded as the minimum
     * recovery point's TLI if recovery stops after this record, is set
     * correctly.
     */
    if (record->xl_rmid == RM_XLOG_ID)
    {
        TimeLineID  newReplayTLI = *replayTLI;
        TimeLineID  prevReplayTLI = *replayTLI;
        uint8       info = record->xl_info & ~XLR_INFO_MASK;
 
        if (info == XLOG_CHECKPOINT_SHUTDOWN)
        {
            CheckPoint  checkPoint;
 
            memcpy(&checkPoint, XLogRecGetData(xlogreader), sizeof(CheckPoint));
            newReplayTLI = checkPoint.ThisTimeLineID;
            prevReplayTLI = checkPoint.PrevTimeLineID;
        }
        else if (info == XLOG_END_OF_RECOVERY)
        {
            xl_end_of_recovery xlrec;
 
            memcpy(&xlrec, XLogRecGetData(xlogreader), sizeof(xl_end_of_recovery));
            newReplayTLI = xlrec.ThisTimeLineID;
            prevReplayTLI = xlrec.PrevTimeLineID;
        }
 
        if (newReplayTLI != *replayTLI)
        {
            /* Check that it's OK to switch to this TLI */
            checkTimeLineSwitch(xlogreader->EndRecPtr,
                                newReplayTLI, prevReplayTLI, *replayTLI);
 
            /* Following WAL records should be run with new TLI */
            *replayTLI = newReplayTLI;
            switchedTLI = true;
        }
    }
 
    /*
     * Update shared replayEndRecPtr before replaying this record, so that
     * XLogFlush will update minRecoveryPoint correctly.
     */
    SpinLockAcquire(&XLogRecoveryCtl->info_lck);
    XLogRecoveryCtl->replayEndRecPtr = xlogreader->EndRecPtr;
    XLogRecoveryCtl->replayEndTLI = *replayTLI;
    SpinLockRelease(&XLogRecoveryCtl->info_lck);
 
    /*
     * If we are attempting to enter Hot Standby mode, process XIDs we see
     */
    if (standbyState >= STANDBY_INITIALIZED &&
        TransactionIdIsValid(record->xl_xid))
        RecordKnownAssignedTransactionIds(record->xl_xid);
 
    /*
     * Some XLOG record types that are related to recovery are processed
     * directly here, rather than in xlog_redo()
     */
    if (record->xl_rmid == RM_XLOG_ID)
        xlogrecovery_redo(xlogreader, *replayTLI);
 
    /* Now apply the WAL record itself */
    GetRmgr(record->xl_rmid).rm_redo(xlogreader);
 
    /*
     * After redo, check whether the backup pages associated with the WAL
     * record are consistent with the existing pages. This check is done only
     * if consistency check is enabled for this record.
     */
    if ((record->xl_info & XLR_CHECK_CONSISTENCY) != 0)
        verifyBackupPageConsistency(xlogreader);
 
    /* Pop the error context stack */
    error_context_stack = errcallback.previous;
 
    /*
     * Update lastReplayedEndRecPtr after this record has been successfully
     * replayed.
     */
    SpinLockAcquire(&XLogRecoveryCtl->info_lck);
    XLogRecoveryCtl->lastReplayedReadRecPtr = xlogreader->ReadRecPtr;
    XLogRecoveryCtl->lastReplayedEndRecPtr = xlogreader->EndRecPtr;
    XLogRecoveryCtl->lastReplayedTLI = *replayTLI;
    SpinLockRelease(&XLogRecoveryCtl->info_lck);
 
    /* ------
     * Wakeup walsenders:
     *
     * On the standby, the WAL is flushed first (which will only wake up
     * physical walsenders) and then applied, which will only wake up logical
     * walsenders.
     *
     * Indeed, logical walsenders on standby can't decode and send data until
     * it's been applied.
     *
     * Physical walsenders don't need to be woken up during replay unless
     * cascading replication is allowed and time line change occurred (so that
     * they can notice that they are on a new time line).
     *
     * That's why the wake up conditions are for:
     *
     *  - physical walsenders in case of new time line and cascade
     *    replication is allowed
     *  - logical walsenders in case cascade replication is allowed (could not
     *    be created otherwise)
     * ------
     */
    if (AllowCascadeReplication())
        WalSndWakeup(switchedTLI, true);
 
    /*
     * If rm_redo called XLogRequestWalReceiverReply, then we wake up the
     * receiver so that it notices the updated lastReplayedEndRecPtr and sends
     * a reply to the primary.
     */
    if (doRequestWalReceiverReply)
    {
        doRequestWalReceiverReply = false;
        WalRcvForceReply();
    }
 
    /* Allow read-only connections if we're consistent now */
    CheckRecoveryConsistency();
 
    /* Is this a timeline switch? */
    if (switchedTLI)
    {
        /*
         * Before we continue on the new timeline, clean up any (possibly
         * bogus) future WAL segments on the old timeline.
         */
        RemoveNonParentXlogFiles(xlogreader->EndRecPtr, *replayTLI);
 
        /* Reset the prefetcher. */
        XLogPrefetchReconfigure();
    }
}

References AdvanceNextFullTransactionIdPastXid(), AllowCascadeReplication, ErrorContextCallback::arg, ErrorContextCallback::callback, CheckRecoveryConsistency(), checkTimeLineSwitch(), doRequestWalReceiverReply, XLogReaderState::EndRecPtr, error_context_stack, GetRmgr(), XLogRecoveryCtlData::info_lck, XLogRecoveryCtlData::lastReplayedEndRecPtr, XLogRecoveryCtlData::lastReplayedReadRecPtr, XLogRecoveryCtlData::lastReplayedTLI, ErrorContextCallback::previous, xl_end_of_recovery::PrevTimeLineID, CheckPoint::PrevTimeLineID, XLogReaderState::ReadRecPtr, RecordKnownAssignedTransactionIds(), RemoveNonParentXlogFiles(), XLogRecoveryCtlData::replayEndRecPtr, XLogRecoveryCtlData::replayEndTLI, RmgrData::rm_redo, rm_redo_error_callback(), SpinLockAcquire, SpinLockRelease, STANDBY_INITIALIZED, standbyState, xl_end_of_recovery::ThisTimeLineID, CheckPoint::ThisTimeLineID, TransactionIdIsValid, verifyBackupPageConsistency(), WalRcvForceReply(), WalSndWakeup(), XLogRecord::xl_info, XLogRecord::xl_rmid, XLogRecord::xl_xid, XLOG_CHECKPOINT_SHUTDOWN, XLOG_END_OF_RECOVERY, XLogPrefetchReconfigure(), xlogreader, XLogRecGetData, xlogrecovery_redo(), XLogRecoveryCtl, XLR_CHECK_CONSISTENCY, and XLR_INFO_MASK.

Referenced by PerformWalRecovery().

assign_recovery_target()

void assign_recovery_target	(	const char *	newval,
		void *	extra
	)

Definition at line 4795 of file xlogrecovery.c.

{
    if (recoveryTarget != RECOVERY_TARGET_UNSET &&
        recoveryTarget != RECOVERY_TARGET_IMMEDIATE)
        error_multiple_recovery_targets();
 
    if (newval && strcmp(newval, "") != 0)
        recoveryTarget = RECOVERY_TARGET_IMMEDIATE;
    else
        recoveryTarget = RECOVERY_TARGET_UNSET;
}

References newval, RECOVERY_TARGET_IMMEDIATE, RECOVERY_TARGET_UNSET, and recoveryTarget.

assign_recovery_target_lsn()

void assign_recovery_target_lsn	(	const char *	newval,
		void *	extra
	)

Definition at line 4834 of file xlogrecovery.c.

{
    if (recoveryTarget != RECOVERY_TARGET_UNSET &&
        recoveryTarget != RECOVERY_TARGET_LSN)
        error_multiple_recovery_targets();
 
    if (newval && strcmp(newval, "") != 0)
    {
        recoveryTarget = RECOVERY_TARGET_LSN;
        recoveryTargetLSN = *((XLogRecPtr *) extra);
    }
    else
        recoveryTarget = RECOVERY_TARGET_UNSET;
}

References newval, RECOVERY_TARGET_LSN, RECOVERY_TARGET_UNSET, recoveryTarget, and recoveryTargetLSN.

assign_recovery_target_name()

void assign_recovery_target_name	(	const char *	newval,
		void *	extra
	)

Definition at line 4869 of file xlogrecovery.c.

{
    if (recoveryTarget != RECOVERY_TARGET_UNSET &&
        recoveryTarget != RECOVERY_TARGET_NAME)
        error_multiple_recovery_targets();
 
    if (newval && strcmp(newval, "") != 0)
    {
        recoveryTarget = RECOVERY_TARGET_NAME;
        recoveryTargetName = newval;
    }
    else
        recoveryTarget = RECOVERY_TARGET_UNSET;
}

References newval, RECOVERY_TARGET_NAME, RECOVERY_TARGET_UNSET, recoveryTarget, and recoveryTargetName.

assign_recovery_target_time()

void assign_recovery_target_time	(	const char *	newval,
		void *	extra
	)

Definition at line 4949 of file xlogrecovery.c.

{
    if (recoveryTarget != RECOVERY_TARGET_UNSET &&
        recoveryTarget != RECOVERY_TARGET_TIME)
        error_multiple_recovery_targets();
 
    if (newval && strcmp(newval, "") != 0)
        recoveryTarget = RECOVERY_TARGET_TIME;
    else
        recoveryTarget = RECOVERY_TARGET_UNSET;
}

References newval, RECOVERY_TARGET_TIME, RECOVERY_TARGET_UNSET, and recoveryTarget.

assign_recovery_target_timeline()

void assign_recovery_target_timeline	(	const char *	newval,
		void *	extra
	)

Definition at line 4998 of file xlogrecovery.c.

{
    recoveryTargetTimeLineGoal = *((RecoveryTargetTimeLineGoal *) extra);
    if (recoveryTargetTimeLineGoal == RECOVERY_TARGET_TIMELINE_NUMERIC)
        recoveryTargetTLIRequested = (TimeLineID) strtoul(newval, NULL, 0);
    else
        recoveryTargetTLIRequested = 0;
}

References newval, RECOVERY_TARGET_TIMELINE_NUMERIC, recoveryTargetTimeLineGoal, and recoveryTargetTLIRequested.

assign_recovery_target_xid()

void assign_recovery_target_xid	(	const char *	newval,
		void *	extra
	)

Definition at line 5034 of file xlogrecovery.c.

{
    if (recoveryTarget != RECOVERY_TARGET_UNSET &&
        recoveryTarget != RECOVERY_TARGET_XID)
        error_multiple_recovery_targets();
 
    if (newval && strcmp(newval, "") != 0)
    {
        recoveryTarget = RECOVERY_TARGET_XID;
        recoveryTargetXid = *((TransactionId *) extra);
    }
    else
        recoveryTarget = RECOVERY_TARGET_UNSET;
}

References newval, RECOVERY_TARGET_UNSET, RECOVERY_TARGET_XID, recoveryTarget, and recoveryTargetXid.

check_primary_slot_name()

bool check_primary_slot_name	(	char **	newval,
		void **	extra,
		GucSource	source
	)

Definition at line 4740 of file xlogrecovery.c.

{
    if (*newval && strcmp(*newval, "") != 0 &&
        !ReplicationSlotValidateName(*newval, WARNING))
        return false;
 
    return true;
}

References newval, ReplicationSlotValidateName(), and WARNING.

check_recovery_target()

bool check_recovery_target	(	char **	newval,
		void **	extra,
		GucSource	source
	)

Definition at line 4781 of file xlogrecovery.c.

{
    if (strcmp(*newval, "immediate") != 0 && strcmp(*newval, "") != 0)
    {
        GUC_check_errdetail("The only allowed value is \"immediate\".");
        return false;
    }
    return true;
}

References GUC_check_errdetail, and newval.

check_recovery_target_lsn()

bool check_recovery_target_lsn	(	char **	newval,
		void **	extra,
		GucSource	source
	)

Definition at line 4811 of file xlogrecovery.c.

{
    if (strcmp(*newval, "") != 0)
    {
        XLogRecPtr  lsn;
        XLogRecPtr *myextra;
        bool        have_error = false;
 
        lsn = pg_lsn_in_internal(*newval, &have_error);
        if (have_error)
            return false;
 
        myextra = (XLogRecPtr *) guc_malloc(ERROR, sizeof(XLogRecPtr));
        *myextra = lsn;
        *extra = (void *) myextra;
    }
    return true;
}

References ERROR, guc_malloc(), newval, and pg_lsn_in_internal().

check_recovery_target_name()

bool check_recovery_target_name	(	char **	newval,
		void **	extra,
		GucSource	source
	)

Definition at line 4853 of file xlogrecovery.c.

{
    /* Use the value of newval directly */
    if (strlen(*newval) >= MAXFNAMELEN)
    {
        GUC_check_errdetail("%s is too long (maximum %d characters).",
                            "recovery_target_name", MAXFNAMELEN - 1);
        return false;
    }
    return true;
}

References GUC_check_errdetail, MAXFNAMELEN, and newval.

check_recovery_target_time()

bool check_recovery_target_time	(	char **	newval,
		void **	extra,
		GucSource	source
	)

Definition at line 4894 of file xlogrecovery.c.

{
    if (strcmp(*newval, "") != 0)
    {
        /* reject some special values */
        if (strcmp(*newval, "now") == 0 ||
            strcmp(*newval, "today") == 0 ||
            strcmp(*newval, "tomorrow") == 0 ||
            strcmp(*newval, "yesterday") == 0)
        {
            return false;
        }
 
        /*
         * parse timestamp value (see also timestamptz_in())
         */
        {
            char       *str = *newval;
            fsec_t      fsec;
            struct pg_tm tt,
                       *tm = &tt;
            int         tz;
            int         dtype;
            int         nf;
            int         dterr;
            char       *field[MAXDATEFIELDS];
            int         ftype[MAXDATEFIELDS];
            char        workbuf[MAXDATELEN + MAXDATEFIELDS];
            DateTimeErrorExtra dtextra;
            TimestampTz timestamp;
 
            dterr = ParseDateTime(str, workbuf, sizeof(workbuf),
                                  field, ftype, MAXDATEFIELDS, &nf);
            if (dterr == 0)
                dterr = DecodeDateTime(field, ftype, nf,
                                       &dtype, tm, &fsec, &tz, &dtextra);
            if (dterr != 0)
                return false;
            if (dtype != DTK_DATE)
                return false;
 
            if (tm2timestamp(tm, fsec, &tz, &timestamp) != 0)
            {
                GUC_check_errdetail("timestamp out of range: \"%s\"", str);
                return false;
            }
        }
    }
    return true;
}

References DecodeDateTime(), DTK_DATE, GUC_check_errdetail, MAXDATEFIELDS, MAXDATELEN, newval, ParseDateTime(), str, tm, and tm2timestamp().

check_recovery_target_timeline()

bool check_recovery_target_timeline	(	char **	newval,
		void **	extra,
		GucSource	source
	)

Definition at line 4965 of file xlogrecovery.c.

{
    RecoveryTargetTimeLineGoal rttg;
    RecoveryTargetTimeLineGoal *myextra;
 
    if (strcmp(*newval, "current") == 0)
        rttg = RECOVERY_TARGET_TIMELINE_CONTROLFILE;
    else if (strcmp(*newval, "latest") == 0)
        rttg = RECOVERY_TARGET_TIMELINE_LATEST;
    else
    {
        rttg = RECOVERY_TARGET_TIMELINE_NUMERIC;
 
        errno = 0;
        strtoul(*newval, NULL, 0);
        if (errno == EINVAL || errno == ERANGE)
        {
            GUC_check_errdetail("recovery_target_timeline is not a valid number.");
            return false;
        }
    }
 
    myextra = (RecoveryTargetTimeLineGoal *) guc_malloc(ERROR, sizeof(RecoveryTargetTimeLineGoal));
    *myextra = rttg;
    *extra = (void *) myextra;
 
    return true;
}

References ERROR, GUC_check_errdetail, guc_malloc(), newval, RECOVERY_TARGET_TIMELINE_CONTROLFILE, RECOVERY_TARGET_TIMELINE_LATEST, and RECOVERY_TARGET_TIMELINE_NUMERIC.

check_recovery_target_xid()

bool check_recovery_target_xid	(	char **	newval,
		void **	extra,
		GucSource	source
	)

Definition at line 5011 of file xlogrecovery.c.

{
    if (strcmp(*newval, "") != 0)
    {
        TransactionId xid;
        TransactionId *myextra;
 
        errno = 0;
        xid = (TransactionId) strtou64(*newval, NULL, 0);
        if (errno == EINVAL || errno == ERANGE)
            return false;
 
        myextra = (TransactionId *) guc_malloc(ERROR, sizeof(TransactionId));
        *myextra = xid;
        *extra = (void *) myextra;
    }
    return true;
}

References ERROR, guc_malloc(), newval, and strtou64.

CheckForStandbyTrigger()

static bool CheckForStandbyTrigger ( void  )

static

Definition at line 4433 of file xlogrecovery.c.

{
    if (LocalPromoteIsTriggered)
        return true;
 
    if (IsPromoteSignaled() && CheckPromoteSignal())
    {
        ereport(LOG, (errmsg("received promote request")));
        RemovePromoteSignalFiles();
        ResetPromoteSignaled();
        SetPromoteIsTriggered();
        return true;
    }
 
    return false;
}

References CheckPromoteSignal(), ereport, errmsg(), IsPromoteSignaled(), LocalPromoteIsTriggered, LOG, RemovePromoteSignalFiles(), ResetPromoteSignaled(), and SetPromoteIsTriggered().

Referenced by ReadRecord(), recoveryApplyDelay(), recoveryPausesHere(), RecoveryRequiresIntParameter(), and WaitForWALToBecomeAvailable().

CheckPromoteSignal()

bool CheckPromoteSignal

(

void

)

Definition at line 4463 of file xlogrecovery.c.

{
    struct stat stat_buf;
 
    if (stat(PROMOTE_SIGNAL_FILE, &stat_buf) == 0)
        return true;
 
    return false;
}

References PROMOTE_SIGNAL_FILE, and stat.

Referenced by CheckForStandbyTrigger(), and process_pm_pmsignal().

CheckRecoveryConsistency()

static void CheckRecoveryConsistency ( void  )

static

Definition at line 2175 of file xlogrecovery.c.

{
    XLogRecPtr  lastReplayedEndRecPtr;
    TimeLineID  lastReplayedTLI;
 
    /*
     * During crash recovery, we don't reach a consistent state until we've
     * replayed all the WAL.
     */
    if (XLogRecPtrIsInvalid(minRecoveryPoint))
        return;
 
    Assert(InArchiveRecovery);
 
    /*
     * assume that we are called in the startup process, and hence don't need
     * a lock to read lastReplayedEndRecPtr
     */
    lastReplayedEndRecPtr = XLogRecoveryCtl->lastReplayedEndRecPtr;
    lastReplayedTLI = XLogRecoveryCtl->lastReplayedTLI;
 
    /*
     * Have we reached the point where our base backup was completed?
     */
    if (!XLogRecPtrIsInvalid(backupEndPoint) &&
        backupEndPoint <= lastReplayedEndRecPtr)
    {
        XLogRecPtr  saveBackupStartPoint = backupStartPoint;
        XLogRecPtr  saveBackupEndPoint = backupEndPoint;
 
        elog(DEBUG1, "end of backup reached");
 
        /*
         * We have reached the end of base backup, as indicated by pg_control.
         * Update the control file accordingly.
         */
        ReachedEndOfBackup(lastReplayedEndRecPtr, lastReplayedTLI);
        backupStartPoint = InvalidXLogRecPtr;
        backupEndPoint = InvalidXLogRecPtr;
        backupEndRequired = false;
 
        ereport(LOG,
                (errmsg("completed backup recovery with redo LSN %X/%X and end LSN %X/%X",
                        LSN_FORMAT_ARGS(saveBackupStartPoint),
                        LSN_FORMAT_ARGS(saveBackupEndPoint))));
    }
 
    /*
     * Have we passed our safe starting point? Note that minRecoveryPoint is
     * known to be incorrectly set if recovering from a backup, until the
     * XLOG_BACKUP_END arrives to advise us of the correct minRecoveryPoint.
     * All we know prior to that is that we're not consistent yet.
     */
    if (!reachedConsistency && !backupEndRequired &&
        minRecoveryPoint <= lastReplayedEndRecPtr)
    {
        /*
         * Check to see if the XLOG sequence contained any unresolved
         * references to uninitialized pages.
         */
        XLogCheckInvalidPages();
 
        /*
         * Check that pg_tblspc doesn't contain any real directories. Replay
         * of Database/CREATE_* records may have created fictitious tablespace
         * directories that should have been removed by the time consistency
         * was reached.
         */
        CheckTablespaceDirectory();
 
        reachedConsistency = true;
        ereport(LOG,
                (errmsg("consistent recovery state reached at %X/%X",
                        LSN_FORMAT_ARGS(lastReplayedEndRecPtr))));
    }
 
    /*
     * Have we got a valid starting snapshot that will allow queries to be
     * run? If so, we can tell postmaster that the database is consistent now,
     * enabling connections.
     */
    if (standbyState == STANDBY_SNAPSHOT_READY &&
        !LocalHotStandbyActive &&
        reachedConsistency &&
        IsUnderPostmaster)
    {
        SpinLockAcquire(&XLogRecoveryCtl->info_lck);
        XLogRecoveryCtl->SharedHotStandbyActive = true;
        SpinLockRelease(&XLogRecoveryCtl->info_lck);
 
        LocalHotStandbyActive = true;
 
        SendPostmasterSignal(PMSIGNAL_BEGIN_HOT_STANDBY);
    }
}

References Assert, backupEndPoint, backupEndRequired, backupStartPoint, CheckTablespaceDirectory(), DEBUG1, elog, ereport, errmsg(), InArchiveRecovery, XLogRecoveryCtlData::info_lck, InvalidXLogRecPtr, IsUnderPostmaster, XLogRecoveryCtlData::lastReplayedEndRecPtr, XLogRecoveryCtlData::lastReplayedTLI, LocalHotStandbyActive, LOG, LSN_FORMAT_ARGS, minRecoveryPoint, PMSIGNAL_BEGIN_HOT_STANDBY, reachedConsistency, ReachedEndOfBackup(), SendPostmasterSignal(), XLogRecoveryCtlData::SharedHotStandbyActive, SpinLockAcquire, SpinLockRelease, STANDBY_SNAPSHOT_READY, standbyState, XLogCheckInvalidPages(), XLogRecoveryCtl, and XLogRecPtrIsInvalid.

Referenced by ApplyWalRecord(), PerformWalRecovery(), and ReadRecord().

CheckTablespaceDirectory()

static void CheckTablespaceDirectory ( void  )

static

Definition at line 2143 of file xlogrecovery.c.

{
    DIR        *dir;
    struct dirent *de;
 
    dir = AllocateDir("pg_tblspc");
    while ((de = ReadDir(dir, "pg_tblspc")) != NULL)
    {
        char        path[MAXPGPATH + 10];
 
        /* Skip entries of non-oid names */
        if (strspn(de->d_name, "0123456789") != strlen(de->d_name))
            continue;
 
        snprintf(path, sizeof(path), "pg_tblspc/%s", de->d_name);
 
        if (get_dirent_type(path, de, false, ERROR) != PGFILETYPE_LNK)
            ereport(allow_in_place_tablespaces ? WARNING : PANIC,
                    (errcode(ERRCODE_DATA_CORRUPTED),
                     errmsg("unexpected directory entry \"%s\" found in %s",
                            de->d_name, "pg_tblspc/"),
                     errdetail("All directory entries in pg_tblspc/ should be symbolic links."),
                     errhint("Remove those directories, or set allow_in_place_tablespaces to ON transiently to let recovery complete.")));
    }
}

References AllocateDir(), allow_in_place_tablespaces, dirent::d_name, ereport, errcode(), ERRCODE_DATA_CORRUPTED, errdetail(), errhint(), errmsg(), ERROR, get_dirent_type(), MAXPGPATH, PANIC, PGFILETYPE_LNK, ReadDir(), snprintf, and WARNING.

Referenced by CheckRecoveryConsistency().

checkTimeLineSwitch()

static void checkTimeLineSwitch ( XLogRecPtr  lsn, TimeLineID  newTLI, TimeLineID  prevTLI, TimeLineID  replayTLI  )

static

Definition at line 2377 of file xlogrecovery.c.

{
    /* Check that the record agrees on what the current (old) timeline is */
    if (prevTLI != replayTLI)
        ereport(PANIC,
                (errmsg("unexpected previous timeline ID %u (current timeline ID %u) in checkpoint record",
                        prevTLI, replayTLI)));
 
    /*
     * The new timeline better be in the list of timelines we expect to see,
     * according to the timeline history. It should also not decrease.
     */
    if (newTLI < replayTLI || !tliInHistory(newTLI, expectedTLEs))
        ereport(PANIC,
                (errmsg("unexpected timeline ID %u (after %u) in checkpoint record",
                        newTLI, replayTLI)));
 
    /*
     * If we have not yet reached min recovery point, and we're about to
     * switch to a timeline greater than the timeline of the min recovery
     * point: trouble. After switching to the new timeline, we could not
     * possibly visit the min recovery point on the correct timeline anymore.
     * This can happen if there is a newer timeline in the archive that
     * branched before the timeline the min recovery point is on, and you
     * attempt to do PITR to the new timeline.
     */
    if (!XLogRecPtrIsInvalid(minRecoveryPoint) &&
        lsn < minRecoveryPoint &&
        newTLI > minRecoveryPointTLI)
        ereport(PANIC,
                (errmsg("unexpected timeline ID %u in checkpoint record, before reaching minimum recovery point %X/%X on timeline %u",
                        newTLI,
                        LSN_FORMAT_ARGS(minRecoveryPoint),
                        minRecoveryPointTLI)));
 
    /* Looks good */
}

References ereport, errmsg(), expectedTLEs, LSN_FORMAT_ARGS, minRecoveryPoint, minRecoveryPointTLI, PANIC, tliInHistory(), and XLogRecPtrIsInvalid.

Referenced by ApplyWalRecord().

ConfirmRecoveryPaused()

static void ConfirmRecoveryPaused ( void  )

static

Definition at line 3110 of file xlogrecovery.c.

{
    /* If recovery pause is requested then set it paused */
    SpinLockAcquire(&XLogRecoveryCtl->info_lck);
    if (XLogRecoveryCtl->recoveryPauseState == RECOVERY_PAUSE_REQUESTED)
        XLogRecoveryCtl->recoveryPauseState = RECOVERY_PAUSED;
    SpinLockRelease(&XLogRecoveryCtl->info_lck);
}

References XLogRecoveryCtlData::info_lck, RECOVERY_PAUSE_REQUESTED, RECOVERY_PAUSED, XLogRecoveryCtlData::recoveryPauseState, SpinLockAcquire, SpinLockRelease, and XLogRecoveryCtl.

Referenced by recoveryPausesHere(), and RecoveryRequiresIntParameter().

emode_for_corrupt_record()

static int emode_for_corrupt_record ( int  emode, XLogRecPtr  RecPtr  )

static

Definition at line 4030 of file xlogrecovery.c.

{
    static XLogRecPtr lastComplaint = 0;
 
    if (readSource == XLOG_FROM_PG_WAL && emode == LOG)
    {
        if (RecPtr == lastComplaint)
            emode = DEBUG1;
        else
            lastComplaint = RecPtr;
    }
    return emode;
}

References DEBUG1, LOG, readSource, and XLOG_FROM_PG_WAL.

Referenced by ReadRecord(), and XLogPageRead().

EnableStandbyMode()

static void EnableStandbyMode ( void  )

static

Definition at line 478 of file xlogrecovery.c.

{
    StandbyMode = true;
 
    /*
     * To avoid server log bloat, we don't report recovery progress in a
     * standby as it will always be in recovery unless promoted. We disable
     * startup progress timeout in standby mode to avoid calling
     * startup_progress_timeout_handler() unnecessarily.
     */
    disable_startup_progress_timeout();
}

References disable_startup_progress_timeout(), and StandbyMode.

Referenced by InitWalRecovery(), and ReadRecord().

FinishWalRecovery()

EndOfWalRecoveryInfo* FinishWalRecovery

(

void

)

Definition at line 1458 of file xlogrecovery.c.

{
    EndOfWalRecoveryInfo *result = palloc(sizeof(EndOfWalRecoveryInfo));
    XLogRecPtr  lastRec;
    TimeLineID  lastRecTLI;
    XLogRecPtr  endOfLog;
 
    /*
     * Kill WAL receiver, if it's still running, before we continue to write
     * the startup checkpoint and aborted-contrecord records. It will trump
     * over these records and subsequent ones if it's still alive when we
     * start writing WAL.
     */
    XLogShutdownWalRcv();
 
    /*
     * Shutdown the slot sync worker to drop any temporary slots acquired by
     * it and to prevent it from keep trying to fetch the failover slots.
     *
     * We do not update the 'synced' column in 'pg_replication_slots' system
     * view from true to false here, as any failed update could leave 'synced'
     * column false for some slots. This could cause issues during slot sync
     * after restarting the server as a standby. While updating the 'synced'
     * column after switching to the new timeline is an option, it does not
     * simplify the handling for the 'synced' column. Therefore, we retain the
     * 'synced' column as true after promotion as it may provide useful
     * information about the slot origin.
     */
    ShutDownSlotSync();
 
    /*
     * We are now done reading the xlog from stream. Turn off streaming
     * recovery to force fetching the files (which would be required at end of
     * recovery, e.g., timeline history file) from archive or pg_wal.
     *
     * Note that standby mode must be turned off after killing WAL receiver,
     * i.e., calling XLogShutdownWalRcv().
     */
    Assert(!WalRcvStreaming());
    StandbyMode = false;
 
    /*
     * Determine where to start writing WAL next.
     *
     * Re-fetch the last valid or last applied record, so we can identify the
     * exact endpoint of what we consider the valid portion of WAL.  There may
     * be an incomplete continuation record after that, in which case
     * 'abortedRecPtr' and 'missingContrecPtr' are set and the caller will
     * write a special OVERWRITE_CONTRECORD message to mark that the rest of
     * it is intentionally missing.  See CreateOverwriteContrecordRecord().
     *
     * An important side-effect of this is to load the last page into
     * xlogreader. The caller uses it to initialize the WAL for writing.
     */
    if (!InRecovery)
    {
        lastRec = CheckPointLoc;
        lastRecTLI = CheckPointTLI;
    }
    else
    {
        lastRec = XLogRecoveryCtl->lastReplayedReadRecPtr;
        lastRecTLI = XLogRecoveryCtl->lastReplayedTLI;
    }
    XLogPrefetcherBeginRead(xlogprefetcher, lastRec);
    (void) ReadRecord(xlogprefetcher, PANIC, false, lastRecTLI);
    endOfLog = xlogreader->EndRecPtr;
 
    /*
     * Remember the TLI in the filename of the XLOG segment containing the
     * end-of-log.  It could be different from the timeline that endOfLog
     * nominally belongs to, if there was a timeline switch in that segment,
     * and we were reading the old WAL from a segment belonging to a higher
     * timeline.
     */
    result->endOfLogTLI = xlogreader->seg.ws_tli;
 
    if (ArchiveRecoveryRequested)
    {
        /*
         * We are no longer in archive recovery state.
         *
         * We are now done reading the old WAL.  Turn off archive fetching if
         * it was active.
         */
        Assert(InArchiveRecovery);
        InArchiveRecovery = false;
 
        /*
         * If the ending log segment is still open, close it (to avoid
         * problems on Windows with trying to rename or delete an open file).
         */
        if (readFile >= 0)
        {
            close(readFile);
            readFile = -1;
        }
    }
 
    /*
     * Copy the last partial block to the caller, for initializing the WAL
     * buffer for appending new WAL.
     */
    if (endOfLog % XLOG_BLCKSZ != 0)
    {
        char       *page;
        int         len;
        XLogRecPtr  pageBeginPtr;
 
        pageBeginPtr = endOfLog - (endOfLog % XLOG_BLCKSZ);
        Assert(readOff == XLogSegmentOffset(pageBeginPtr, wal_segment_size));
 
        /* Copy the valid part of the last block */
        len = endOfLog % XLOG_BLCKSZ;
        page = palloc(len);
        memcpy(page, xlogreader->readBuf, len);
 
        result->lastPageBeginPtr = pageBeginPtr;
        result->lastPage = page;
    }
    else
    {
        /* There is no partial block to copy. */
        result->lastPageBeginPtr = endOfLog;
        result->lastPage = NULL;
    }
 
    /*
     * Create a comment for the history file to explain why and where timeline
     * changed.
     */
    result->recoveryStopReason = getRecoveryStopReason();
 
    result->lastRec = lastRec;
    result->lastRecTLI = lastRecTLI;
    result->endOfLog = endOfLog;
 
    result->abortedRecPtr = abortedRecPtr;
    result->missingContrecPtr = missingContrecPtr;
 
    result->standby_signal_file_found = standby_signal_file_found;
    result->recovery_signal_file_found = recovery_signal_file_found;
 
    return result;
}

References abortedRecPtr, EndOfWalRecoveryInfo::abortedRecPtr, ArchiveRecoveryRequested, Assert, CheckPointLoc, CheckPointTLI, close, EndOfWalRecoveryInfo::endOfLog, EndOfWalRecoveryInfo::endOfLogTLI, XLogReaderState::EndRecPtr, getRecoveryStopReason(), InArchiveRecovery, InRecovery, EndOfWalRecoveryInfo::lastPage, EndOfWalRecoveryInfo::lastPageBeginPtr, EndOfWalRecoveryInfo::lastRec, EndOfWalRecoveryInfo::lastRecTLI, XLogRecoveryCtlData::lastReplayedReadRecPtr, XLogRecoveryCtlData::lastReplayedTLI, len, missingContrecPtr, EndOfWalRecoveryInfo::missingContrecPtr, palloc(), PANIC, XLogReaderState::readBuf, readFile, readOff, ReadRecord(), recovery_signal_file_found, EndOfWalRecoveryInfo::recovery_signal_file_found, EndOfWalRecoveryInfo::recoveryStopReason, XLogReaderState::seg, ShutDownSlotSync(), standby_signal_file_found, EndOfWalRecoveryInfo::standby_signal_file_found, StandbyMode, wal_segment_size, WalRcvStreaming(), WALOpenSegment::ws_tli, xlogprefetcher, XLogPrefetcherBeginRead(), xlogreader, XLogRecoveryCtl, XLogSegmentOffset, and XLogShutdownWalRcv().

Referenced by StartupXLOG().

GetCurrentChunkReplayStartTime()

TimestampTz GetCurrentChunkReplayStartTime

(

void

)

Definition at line 4626 of file xlogrecovery.c.

{
    TimestampTz xtime;
 
    SpinLockAcquire(&XLogRecoveryCtl->info_lck);
    xtime = XLogRecoveryCtl->currentChunkStartTime;
    SpinLockRelease(&XLogRecoveryCtl->info_lck);
 
    return xtime;
}

References XLogRecoveryCtlData::currentChunkStartTime, XLogRecoveryCtlData::info_lck, SpinLockAcquire, SpinLockRelease, and XLogRecoveryCtl.

Referenced by GetReplicationApplyDelay().

GetCurrentReplayRecPtr()

XLogRecPtr GetCurrentReplayRecPtr

(

TimeLineID *

replayEndTLI

)

Definition at line 4562 of file xlogrecovery.c.

{
    XLogRecPtr  recptr;
    TimeLineID  tli;
 
    SpinLockAcquire(&XLogRecoveryCtl->info_lck);
    recptr = XLogRecoveryCtl->replayEndRecPtr;
    tli = XLogRecoveryCtl->replayEndTLI;
    SpinLockRelease(&XLogRecoveryCtl->info_lck);
 
    if (replayEndTLI)
        *replayEndTLI = tli;
    return recptr;
}

References XLogRecoveryCtlData::info_lck, XLogRecoveryCtlData::replayEndRecPtr, XLogRecoveryCtlData::replayEndTLI, SpinLockAcquire, SpinLockRelease, and XLogRecoveryCtl.

Referenced by UpdateMinRecoveryPoint(), and xlog_redo().

GetLatestXTime()

TimestampTz GetLatestXTime

(

void

)

Definition at line 4596 of file xlogrecovery.c.

{
    TimestampTz xtime;
 
    SpinLockAcquire(&XLogRecoveryCtl->info_lck);
    xtime = XLogRecoveryCtl->recoveryLastXTime;
    SpinLockRelease(&XLogRecoveryCtl->info_lck);
 
    return xtime;
}

References XLogRecoveryCtlData::info_lck, XLogRecoveryCtlData::recoveryLastXTime, SpinLockAcquire, SpinLockRelease, and XLogRecoveryCtl.

Referenced by CreateRestartPoint(), PerformWalRecovery(), and pg_last_xact_replay_timestamp().

getRecordTimestamp()

static bool getRecordTimestamp ( XLogReaderState *  record, TimestampTz *  recordXtime  )

static

Definition at line 2426 of file xlogrecovery.c.

{
    uint8       info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
    uint8       xact_info = info & XLOG_XACT_OPMASK;
    uint8       rmid = XLogRecGetRmid(record);
 
    if (rmid == RM_XLOG_ID && info == XLOG_RESTORE_POINT)
    {
        *recordXtime = ((xl_restore_point *) XLogRecGetData(record))->rp_time;
        return true;
    }
    if (rmid == RM_XACT_ID && (xact_info == XLOG_XACT_COMMIT ||
                               xact_info == XLOG_XACT_COMMIT_PREPARED))
    {
        *recordXtime = ((xl_xact_commit *) XLogRecGetData(record))->xact_time;
        return true;
    }
    if (rmid == RM_XACT_ID && (xact_info == XLOG_XACT_ABORT ||
                               xact_info == XLOG_XACT_ABORT_PREPARED))
    {
        *recordXtime = ((xl_xact_abort *) XLogRecGetData(record))->xact_time;
        return true;
    }
    return false;
}

References XLOG_RESTORE_POINT, XLOG_XACT_ABORT, XLOG_XACT_ABORT_PREPARED, XLOG_XACT_COMMIT, XLOG_XACT_COMMIT_PREPARED, XLOG_XACT_OPMASK, XLogRecGetData, XLogRecGetInfo, XLogRecGetRmid, and XLR_INFO_MASK.

Referenced by recoveryApplyDelay(), recoveryStopsAfter(), and recoveryStopsBefore().

GetRecoveryPauseState()

RecoveryPauseState GetRecoveryPauseState

(

void

)

Definition at line 3070 of file xlogrecovery.c.

{
    RecoveryPauseState state;
 
    SpinLockAcquire(&XLogRecoveryCtl->info_lck);
    state = XLogRecoveryCtl->recoveryPauseState;
    SpinLockRelease(&XLogRecoveryCtl->info_lck);
 
    return state;
}

References XLogRecoveryCtlData::info_lck, XLogRecoveryCtlData::recoveryPauseState, SpinLockAcquire, SpinLockRelease, and XLogRecoveryCtl.

Referenced by pg_get_wal_replay_pause_state(), pg_is_wal_replay_paused(), recoveryPausesHere(), and RecoveryRequiresIntParameter().

getRecoveryStopReason()

static char * getRecoveryStopReason ( void  )

static

Definition at line 2886 of file xlogrecovery.c.

{
    char        reason[200];
 
    if (recoveryTarget == RECOVERY_TARGET_XID)
        snprintf(reason, sizeof(reason),
                 "%s transaction %u",
                 recoveryStopAfter ? "after" : "before",
                 recoveryStopXid);
    else if (recoveryTarget == RECOVERY_TARGET_TIME)
        snprintf(reason, sizeof(reason),
                 "%s %s\n",
                 recoveryStopAfter ? "after" : "before",
                 timestamptz_to_str(recoveryStopTime));
    else if (recoveryTarget == RECOVERY_TARGET_LSN)
        snprintf(reason, sizeof(reason),
                 "%s LSN %X/%X\n",
                 recoveryStopAfter ? "after" : "before",
                 LSN_FORMAT_ARGS(recoveryStopLSN));
    else if (recoveryTarget == RECOVERY_TARGET_NAME)
        snprintf(reason, sizeof(reason),
                 "at restore point \"%s\"",
                 recoveryStopName);
    else if (recoveryTarget == RECOVERY_TARGET_IMMEDIATE)
        snprintf(reason, sizeof(reason), "reached consistency");
    else
        snprintf(reason, sizeof(reason), "no recovery target specified");
 
    return pstrdup(reason);
}

References LSN_FORMAT_ARGS, pstrdup(), RECOVERY_TARGET_IMMEDIATE, RECOVERY_TARGET_LSN, RECOVERY_TARGET_NAME, RECOVERY_TARGET_TIME, RECOVERY_TARGET_XID, recoveryStopAfter, recoveryStopLSN, recoveryStopName, recoveryStopTime, recoveryStopXid, recoveryTarget, snprintf, and timestamptz_to_str().

Referenced by FinishWalRecovery().

GetXLogReceiptTime()

void GetXLogReceiptTime	(	TimestampTz *	rtime,
		bool *	fromStream
	)

Definition at line 4642 of file xlogrecovery.c.

{
    /*
     * This must be executed in the startup process, since we don't export the
     * relevant state to shared memory.
     */
    Assert(InRecovery);
 
    *rtime = XLogReceiptTime;
    *fromStream = (XLogReceiptSource == XLOG_FROM_STREAM);
}

References Assert, InRecovery, XLOG_FROM_STREAM, XLogReceiptSource, and XLogReceiptTime.

Referenced by GetStandbyLimitTime().

GetXLogReplayRecPtr()

XLogRecPtr GetXLogReplayRecPtr

(

TimeLineID *

replayTLI

)

Definition at line 4539 of file xlogrecovery.c.

{
    XLogRecPtr  recptr;
    TimeLineID  tli;
 
    SpinLockAcquire(&XLogRecoveryCtl->info_lck);
    recptr = XLogRecoveryCtl->lastReplayedEndRecPtr;
    tli = XLogRecoveryCtl->lastReplayedTLI;
    SpinLockRelease(&XLogRecoveryCtl->info_lck);
 
    if (replayTLI)
        *replayTLI = tli;
    return recptr;
}

References XLogRecoveryCtlData::info_lck, XLogRecoveryCtlData::lastReplayedEndRecPtr, XLogRecoveryCtlData::lastReplayedTLI, SpinLockAcquire, SpinLockRelease, and XLogRecoveryCtl.

Referenced by CheckpointerMain(), CreateRestartPoint(), GetCurrentLSN(), GetLatestLSN(), GetReplicationApplyDelay(), GetStandbyFlushRecPtr(), IsCheckpointOnSchedule(), logical_read_xlog_page(), pg_last_wal_replay_lsn(), pg_logical_slot_get_changes_guts(), pg_replication_slot_advance(), read_local_xlog_page_guts(), ReadReplicationSlot(), ReplicationSlotReserveWal(), WalReceiverMain(), WalSndWaitForWal(), and XLogWalRcvSendReply().

HotStandbyActive()

bool HotStandbyActive

(

void

)

Definition at line 4502 of file xlogrecovery.c.

{
    /*
     * We check shared state each time only until Hot Standby is active. We
     * can't de-activate Hot Standby, so there's no need to keep checking
     * after the shared variable has once been seen true.
     */
    if (LocalHotStandbyActive)
        return true;
    else
    {
        /* spinlock is essential on machines with weak memory ordering! */
        SpinLockAcquire(&XLogRecoveryCtl->info_lck);
        LocalHotStandbyActive = XLogRecoveryCtl->SharedHotStandbyActive;
        SpinLockRelease(&XLogRecoveryCtl->info_lck);
 
        return LocalHotStandbyActive;
    }
}

References XLogRecoveryCtlData::info_lck, LocalHotStandbyActive, XLogRecoveryCtlData::SharedHotStandbyActive, SpinLockAcquire, SpinLockRelease, and XLogRecoveryCtl.

Referenced by XLogWalRcvSendHSFeedback().

HotStandbyActiveInReplay()

static bool HotStandbyActiveInReplay ( void  )

static

Definition at line 4527 of file xlogrecovery.c.

{
    Assert(AmStartupProcess() || !IsPostmasterEnvironment);
    return LocalHotStandbyActive;
}

References AmStartupProcess, Assert, IsPostmasterEnvironment, and LocalHotStandbyActive.

Referenced by RecoveryRequiresIntParameter().

InitWalRecovery()

void InitWalRecovery	(	ControlFileData *	ControlFile,
		bool *	wasShutdown_ptr,
		bool *	haveBackupLabel_ptr,
		bool *	haveTblspcMap_ptr
	)

Definition at line 512 of file xlogrecovery.c.

{
    XLogPageReadPrivate *private;
    struct stat st;
    bool        wasShutdown;
    XLogRecord *record;
    DBState     dbstate_at_startup;
    bool        haveTblspcMap = false;
    bool        haveBackupLabel = false;
    CheckPoint  checkPoint;
    bool        backupFromStandby = false;
 
    dbstate_at_startup = ControlFile->state;
 
    /*
     * Initialize on the assumption we want to recover to the latest timeline
     * that's active according to pg_control.
     */
    if (ControlFile->minRecoveryPointTLI >
        ControlFile->checkPointCopy.ThisTimeLineID)
        recoveryTargetTLI = ControlFile->minRecoveryPointTLI;
    else
        recoveryTargetTLI = ControlFile->checkPointCopy.ThisTimeLineID;
 
    /*
     * Check for signal files, and if so set up state for offline recovery
     */
    readRecoverySignalFile();
    validateRecoveryParameters();
 
    /*
     * Take ownership of the wakeup latch if we're going to sleep during
     * recovery, if required.
     */
    if (ArchiveRecoveryRequested)
        OwnLatch(&XLogRecoveryCtl->recoveryWakeupLatch);
 
    /*
     * Set the WAL reading processor now, as it will be needed when reading
     * the checkpoint record required (backup_label or not).
     */
    private = palloc0(sizeof(XLogPageReadPrivate));
    xlogreader =
        XLogReaderAllocate(wal_segment_size, NULL,
                           XL_ROUTINE(.page_read = &XLogPageRead,
                                      .segment_open = NULL,
                                      .segment_close = wal_segment_close),
                           private);
    if (!xlogreader)
        ereport(ERROR,
                (errcode(ERRCODE_OUT_OF_MEMORY),
                 errmsg("out of memory"),
                 errdetail("Failed while allocating a WAL reading processor.")));
    xlogreader->system_identifier = ControlFile->system_identifier;
 
    /*
     * Set the WAL decode buffer size.  This limits how far ahead we can read
     * in the WAL.
     */
    XLogReaderSetDecodeBuffer(xlogreader, NULL, wal_decode_buffer_size);
 
    /* Create a WAL prefetcher. */
    xlogprefetcher = XLogPrefetcherAllocate(xlogreader);
 
    /*
     * Allocate two page buffers dedicated to WAL consistency checks.  We do
     * it this way, rather than just making static arrays, for two reasons:
     * (1) no need to waste the storage in most instantiations of the backend;
     * (2) a static char array isn't guaranteed to have any particular
     * alignment, whereas palloc() will provide MAXALIGN'd storage.
     */
    replay_image_masked = (char *) palloc(BLCKSZ);
    primary_image_masked = (char *) palloc(BLCKSZ);
 
    /*
     * Read the backup_label file.  We want to run this part of the recovery
     * process after checking for signal files and after performing validation
     * of the recovery parameters.
     */
    if (read_backup_label(&CheckPointLoc, &CheckPointTLI, &backupEndRequired,
                          &backupFromStandby))
    {
        List       *tablespaces = NIL;
 
        /*
         * Archive recovery was requested, and thanks to the backup label
         * file, we know how far we need to replay to reach consistency. Enter
         * archive recovery directly.
         */
        InArchiveRecovery = true;
        if (StandbyModeRequested)
            EnableStandbyMode();
 
        /*
         * Omitting backup_label when creating a new replica, PITR node etc.
         * unfortunately is a common cause of corruption.  Logging that
         * backup_label was used makes it a bit easier to exclude that as the
         * cause of observed corruption.
         *
         * Do so before we try to read the checkpoint record (which can fail),
         * as otherwise it can be hard to understand why a checkpoint other
         * than ControlFile->checkPoint is used.
         */
        ereport(LOG,
                (errmsg("starting backup recovery with redo LSN %X/%X, checkpoint LSN %X/%X, on timeline ID %u",
                        LSN_FORMAT_ARGS(RedoStartLSN),
                        LSN_FORMAT_ARGS(CheckPointLoc),
                        CheckPointTLI)));
 
        /*
         * When a backup_label file is present, we want to roll forward from
         * the checkpoint it identifies, rather than using pg_control.
         */
        record = ReadCheckpointRecord(xlogprefetcher, CheckPointLoc,
                                      CheckPointTLI);
        if (record != NULL)
        {
            memcpy(&checkPoint, XLogRecGetData(xlogreader), sizeof(CheckPoint));
            wasShutdown = ((record->xl_info & ~XLR_INFO_MASK) == XLOG_CHECKPOINT_SHUTDOWN);
            ereport(DEBUG1,
                    (errmsg_internal("checkpoint record is at %X/%X",
                                     LSN_FORMAT_ARGS(CheckPointLoc))));
            InRecovery = true;  /* force recovery even if SHUTDOWNED */
 
            /*
             * Make sure that REDO location exists. This may not be the case
             * if there was a crash during an online backup, which left a
             * backup_label around that references a WAL segment that's
             * already been archived.
             */
            if (checkPoint.redo < CheckPointLoc)
            {
                XLogPrefetcherBeginRead(xlogprefetcher, checkPoint.redo);
                if (!ReadRecord(xlogprefetcher, LOG, false,
                                checkPoint.ThisTimeLineID))
                    ereport(FATAL,
                            (errmsg("could not find redo location %X/%X referenced by checkpoint record at %X/%X",
                                    LSN_FORMAT_ARGS(checkPoint.redo), LSN_FORMAT_ARGS(CheckPointLoc)),
                             errhint("If you are restoring from a backup, touch \"%s/recovery.signal\" or \"%s/standby.signal\" and add required recovery options.\n"
                                     "If you are not restoring from a backup, try removing the file \"%s/backup_label\".\n"
                                     "Be careful: removing \"%s/backup_label\" will result in a corrupt cluster if restoring from a backup.",
                                     DataDir, DataDir, DataDir, DataDir)));
            }
        }
        else
        {
            ereport(FATAL,
                    (errmsg("could not locate required checkpoint record at %X/%X",
                            LSN_FORMAT_ARGS(CheckPointLoc)),
                     errhint("If you are restoring from a backup, touch \"%s/recovery.signal\" or \"%s/standby.signal\" and add required recovery options.\n"
                             "If you are not restoring from a backup, try removing the file \"%s/backup_label\".\n"
                             "Be careful: removing \"%s/backup_label\" will result in a corrupt cluster if restoring from a backup.",
                             DataDir, DataDir, DataDir, DataDir)));
            wasShutdown = false;    /* keep compiler quiet */
        }
 
        /* Read the tablespace_map file if present and create symlinks. */
        if (read_tablespace_map(&tablespaces))
        {
            ListCell   *lc;
 
            foreach(lc, tablespaces)
            {
                tablespaceinfo *ti = lfirst(lc);
                char       *linkloc;
 
                linkloc = psprintf("pg_tblspc/%u", ti->oid);
 
                /*
                 * Remove the existing symlink if any and Create the symlink
                 * under PGDATA.
                 */
                remove_tablespace_symlink(linkloc);
 
                if (symlink(ti->path, linkloc) < 0)
                    ereport(ERROR,
                            (errcode_for_file_access(),
                             errmsg("could not create symbolic link \"%s\": %m",
                                    linkloc)));
 
                pfree(ti->path);
                pfree(ti);
            }
 
            /* tell the caller to delete it later */
            haveTblspcMap = true;
        }
 
        /* tell the caller to delete it later */
        haveBackupLabel = true;
    }
    else
    {
        /* No backup_label file has been found if we are here. */
 
        /*
         * If tablespace_map file is present without backup_label file, there
         * is no use of such file.  There is no harm in retaining it, but it
         * is better to get rid of the map file so that we don't have any
         * redundant file in data directory and it will avoid any sort of
         * confusion.  It seems prudent though to just rename the file out of
         * the way rather than delete it completely, also we ignore any error
         * that occurs in rename operation as even if map file is present
         * without backup_label file, it is harmless.
         */
        if (stat(TABLESPACE_MAP, &st) == 0)
        {
            unlink(TABLESPACE_MAP_OLD);
            if (durable_rename(TABLESPACE_MAP, TABLESPACE_MAP_OLD, DEBUG1) == 0)
                ereport(LOG,
                        (errmsg("ignoring file \"%s\" because no file \"%s\" exists",
                                TABLESPACE_MAP, BACKUP_LABEL_FILE),
                         errdetail("File \"%s\" was renamed to \"%s\".",
                                   TABLESPACE_MAP, TABLESPACE_MAP_OLD)));
            else
                ereport(LOG,
                        (errmsg("ignoring file \"%s\" because no file \"%s\" exists",
                                TABLESPACE_MAP, BACKUP_LABEL_FILE),
                         errdetail("Could not rename file \"%s\" to \"%s\": %m.",
                                   TABLESPACE_MAP, TABLESPACE_MAP_OLD)));
        }
 
        /*
         * It's possible that archive recovery was requested, but we don't
         * know how far we need to replay the WAL before we reach consistency.
         * This can happen for example if a base backup is taken from a
         * running server using an atomic filesystem snapshot, without calling
         * pg_backup_start/stop. Or if you just kill a running primary server
         * and put it into archive recovery by creating a recovery signal
         * file.
         *
         * Our strategy in that case is to perform crash recovery first,
         * replaying all the WAL present in pg_wal, and only enter archive
         * recovery after that.
         *
         * But usually we already know how far we need to replay the WAL (up
         * to minRecoveryPoint, up to backupEndPoint, or until we see an
         * end-of-backup record), and we can enter archive recovery directly.
         */
        if (ArchiveRecoveryRequested &&
            (ControlFile->minRecoveryPoint != InvalidXLogRecPtr ||
             ControlFile->backupEndRequired ||
             ControlFile->backupEndPoint != InvalidXLogRecPtr ||
             ControlFile->state == DB_SHUTDOWNED))
        {
            InArchiveRecovery = true;
            if (StandbyModeRequested)
                EnableStandbyMode();
        }
 
        /*
         * For the same reason as when starting up with backup_label present,
         * emit a log message when we continue initializing from a base
         * backup.
         */
        if (!XLogRecPtrIsInvalid(ControlFile->backupStartPoint))
            ereport(LOG,
                    (errmsg("restarting backup recovery with redo LSN %X/%X",
                            LSN_FORMAT_ARGS(ControlFile->backupStartPoint))));
 
        /* Get the last valid checkpoint record. */
        CheckPointLoc = ControlFile->checkPoint;
        CheckPointTLI = ControlFile->checkPointCopy.ThisTimeLineID;
        RedoStartLSN = ControlFile->checkPointCopy.redo;
        RedoStartTLI = ControlFile->checkPointCopy.ThisTimeLineID;
        record = ReadCheckpointRecord(xlogprefetcher, CheckPointLoc,
                                      CheckPointTLI);
        if (record != NULL)
        {
            ereport(DEBUG1,
                    (errmsg_internal("checkpoint record is at %X/%X",
                                     LSN_FORMAT_ARGS(CheckPointLoc))));
        }
        else
        {
            /*
             * We used to attempt to go back to a secondary checkpoint record
             * here, but only when not in standby mode. We now just fail if we
             * can't read the last checkpoint because this allows us to
             * simplify processing around checkpoints.
             */
            ereport(PANIC,
                    (errmsg("could not locate a valid checkpoint record at %X/%X",
                            LSN_FORMAT_ARGS(CheckPointLoc))));
        }
        memcpy(&checkPoint, XLogRecGetData(xlogreader), sizeof(CheckPoint));
        wasShutdown = ((record->xl_info & ~XLR_INFO_MASK) == XLOG_CHECKPOINT_SHUTDOWN);
    }
 
    if (ArchiveRecoveryRequested)
    {
        if (StandbyModeRequested)
            ereport(LOG,
                    (errmsg("entering standby mode")));
        else if (recoveryTarget == RECOVERY_TARGET_XID)
            ereport(LOG,
                    (errmsg("starting point-in-time recovery to XID %u",
                            recoveryTargetXid)));
        else if (recoveryTarget == RECOVERY_TARGET_TIME)
            ereport(LOG,
                    (errmsg("starting point-in-time recovery to %s",
                            timestamptz_to_str(recoveryTargetTime))));
        else if (recoveryTarget == RECOVERY_TARGET_NAME)
            ereport(LOG,
                    (errmsg("starting point-in-time recovery to \"%s\"",
                            recoveryTargetName)));
        else if (recoveryTarget == RECOVERY_TARGET_LSN)
            ereport(LOG,
                    (errmsg("starting point-in-time recovery to WAL location (LSN) \"%X/%X\"",
                            LSN_FORMAT_ARGS(recoveryTargetLSN))));
        else if (recoveryTarget == RECOVERY_TARGET_IMMEDIATE)
            ereport(LOG,
                    (errmsg("starting point-in-time recovery to earliest consistent point")));
        else
            ereport(LOG,
                    (errmsg("starting archive recovery")));
    }
 
    /*
     * If the location of the checkpoint record is not on the expected
     * timeline in the history of the requested timeline, we cannot proceed:
     * the backup is not part of the history of the requested timeline.
     */
    Assert(expectedTLEs);       /* was initialized by reading checkpoint
                                 * record */
    if (tliOfPointInHistory(CheckPointLoc, expectedTLEs) !=
        CheckPointTLI)
    {
        XLogRecPtr  switchpoint;
 
        /*
         * tliSwitchPoint will throw an error if the checkpoint's timeline is
         * not in expectedTLEs at all.
         */
        switchpoint = tliSwitchPoint(ControlFile->checkPointCopy.ThisTimeLineID, expectedTLEs, NULL);
        ereport(FATAL,
                (errmsg("requested timeline %u is not a child of this server's history",
                        recoveryTargetTLI),
                 errdetail("Latest checkpoint is at %X/%X on timeline %u, but in the history of the requested timeline, the server forked off from that timeline at %X/%X.",
                           LSN_FORMAT_ARGS(ControlFile->checkPoint),
                           ControlFile->checkPointCopy.ThisTimeLineID,
                           LSN_FORMAT_ARGS(switchpoint))));
    }
 
    /*
     * The min recovery point should be part of the requested timeline's
     * history, too.
     */
    if (!XLogRecPtrIsInvalid(ControlFile->minRecoveryPoint) &&
        tliOfPointInHistory(ControlFile->minRecoveryPoint - 1, expectedTLEs) !=
        ControlFile->minRecoveryPointTLI)
        ereport(FATAL,
                (errmsg("requested timeline %u does not contain minimum recovery point %X/%X on timeline %u",
                        recoveryTargetTLI,
                        LSN_FORMAT_ARGS(ControlFile->minRecoveryPoint),
                        ControlFile->minRecoveryPointTLI)));
 
    ereport(DEBUG1,
            (errmsg_internal("redo record is at %X/%X; shutdown %s",
                             LSN_FORMAT_ARGS(checkPoint.redo),
                             wasShutdown ? "true" : "false")));
    ereport(DEBUG1,
            (errmsg_internal("next transaction ID: " UINT64_FORMAT "; next OID: %u",
                             U64FromFullTransactionId(checkPoint.nextXid),
                             checkPoint.nextOid)));
    ereport(DEBUG1,
            (errmsg_internal("next MultiXactId: %u; next MultiXactOffset: %u",
                             checkPoint.nextMulti, checkPoint.nextMultiOffset)));
    ereport(DEBUG1,
            (errmsg_internal("oldest unfrozen transaction ID: %u, in database %u",
                             checkPoint.oldestXid, checkPoint.oldestXidDB)));
    ereport(DEBUG1,
            (errmsg_internal("oldest MultiXactId: %u, in database %u",
                             checkPoint.oldestMulti, checkPoint.oldestMultiDB)));
    ereport(DEBUG1,
            (errmsg_internal("commit timestamp Xid oldest/newest: %u/%u",
                             checkPoint.oldestCommitTsXid,
                             checkPoint.newestCommitTsXid)));
    if (!TransactionIdIsNormal(XidFromFullTransactionId(checkPoint.nextXid)))
        ereport(PANIC,
                (errmsg("invalid next transaction ID")));
 
    /* sanity check */
    if (checkPoint.redo > CheckPointLoc)
        ereport(PANIC,
                (errmsg("invalid redo in checkpoint record")));
 
    /*
     * Check whether we need to force recovery from WAL.  If it appears to
     * have been a clean shutdown and we did not have a recovery signal file,
     * then assume no recovery needed.
     */
    if (checkPoint.redo < CheckPointLoc)
    {
        if (wasShutdown)
            ereport(PANIC,
                    (errmsg("invalid redo record in shutdown checkpoint")));
        InRecovery = true;
    }
    else if (ControlFile->state != DB_SHUTDOWNED)
        InRecovery = true;
    else if (ArchiveRecoveryRequested)
    {
        /* force recovery due to presence of recovery signal file */
        InRecovery = true;
    }
 
    /*
     * If recovery is needed, update our in-memory copy of pg_control to show
     * that we are recovering and to show the selected checkpoint as the place
     * we are starting from. We also mark pg_control with any minimum recovery
     * stop point obtained from a backup history file.
     *
     * We don't write the changes to disk yet, though. Only do that after
     * initializing various subsystems.
     */
    if (InRecovery)
    {
        if (InArchiveRecovery)
        {
            ControlFile->state = DB_IN_ARCHIVE_RECOVERY;
        }
        else
        {
            ereport(LOG,
                    (errmsg("database system was not properly shut down; "
                            "automatic recovery in progress")));
            if (recoveryTargetTLI > ControlFile->checkPointCopy.ThisTimeLineID)
                ereport(LOG,
                        (errmsg("crash recovery starts in timeline %u "
                                "and has target timeline %u",
                                ControlFile->checkPointCopy.ThisTimeLineID,
                                recoveryTargetTLI)));
            ControlFile->state = DB_IN_CRASH_RECOVERY;
        }
        ControlFile->checkPoint = CheckPointLoc;
        ControlFile->checkPointCopy = checkPoint;
        if (InArchiveRecovery)
        {
            /* initialize minRecoveryPoint if not set yet */
            if (ControlFile->minRecoveryPoint < checkPoint.redo)
            {
                ControlFile->minRecoveryPoint = checkPoint.redo;
                ControlFile->minRecoveryPointTLI = checkPoint.ThisTimeLineID;
            }
        }
 
        /*
         * Set backupStartPoint if we're starting recovery from a base backup.
         *
         * Also set backupEndPoint and use minRecoveryPoint as the backup end
         * location if we're starting recovery from a base backup which was
         * taken from a standby. In this case, the database system status in
         * pg_control must indicate that the database was already in recovery.
         * Usually that will be DB_IN_ARCHIVE_RECOVERY but also can be
         * DB_SHUTDOWNED_IN_RECOVERY if recovery previously was interrupted
         * before reaching this point; e.g. because restore_command or
         * primary_conninfo were faulty.
         *
         * Any other state indicates that the backup somehow became corrupted
         * and we can't sensibly continue with recovery.
         */
        if (haveBackupLabel)
        {
            ControlFile->backupStartPoint = checkPoint.redo;
            ControlFile->backupEndRequired = backupEndRequired;
 
            if (backupFromStandby)
            {
                if (dbstate_at_startup != DB_IN_ARCHIVE_RECOVERY &&
                    dbstate_at_startup != DB_SHUTDOWNED_IN_RECOVERY)
                    ereport(FATAL,
                            (errmsg("backup_label contains data inconsistent with control file"),
                             errhint("This means that the backup is corrupted and you will "
                                     "have to use another backup for recovery.")));
                ControlFile->backupEndPoint = ControlFile->minRecoveryPoint;
            }
        }
    }
 
    /* remember these, so that we know when we have reached consistency */
    backupStartPoint = ControlFile->backupStartPoint;
    backupEndRequired = ControlFile->backupEndRequired;
    backupEndPoint = ControlFile->backupEndPoint;
    if (InArchiveRecovery)
    {
        minRecoveryPoint = ControlFile->minRecoveryPoint;
        minRecoveryPointTLI = ControlFile->minRecoveryPointTLI;
    }
    else
    {
        minRecoveryPoint = InvalidXLogRecPtr;
        minRecoveryPointTLI = 0;
    }
 
    /*
     * Start recovery assuming that the final record isn't lost.
     */
    abortedRecPtr = InvalidXLogRecPtr;
    missingContrecPtr = InvalidXLogRecPtr;
 
    *wasShutdown_ptr = wasShutdown;
    *haveBackupLabel_ptr = haveBackupLabel;
    *haveTblspcMap_ptr = haveTblspcMap;
}

References abortedRecPtr, ArchiveRecoveryRequested, Assert, BACKUP_LABEL_FILE, backupEndPoint, ControlFileData::backupEndPoint, backupEndRequired, ControlFileData::backupEndRequired, backupStartPoint, ControlFileData::backupStartPoint, ControlFileData::checkPoint, ControlFileData::checkPointCopy, CheckPointLoc, CheckPointTLI, ControlFile, DataDir, DB_IN_ARCHIVE_RECOVERY, DB_IN_CRASH_RECOVERY, DB_SHUTDOWNED, DB_SHUTDOWNED_IN_RECOVERY, DEBUG1, durable_rename(), EnableStandbyMode(), ereport, errcode(), errcode_for_file_access(), errdetail(), errhint(), errmsg(), errmsg_internal(), ERROR, expectedTLEs, FATAL, InArchiveRecovery, InRecovery, InvalidXLogRecPtr, lfirst, LOG, LSN_FORMAT_ARGS, minRecoveryPoint, ControlFileData::minRecoveryPoint, minRecoveryPointTLI, ControlFileData::minRecoveryPointTLI, missingContrecPtr, CheckPoint::newestCommitTsXid, CheckPoint::nextMulti, CheckPoint::nextMultiOffset, CheckPoint::nextOid, CheckPoint::nextXid, NIL, tablespaceinfo::oid, CheckPoint::oldestCommitTsXid, CheckPoint::oldestMulti, CheckPoint::oldestMultiDB, CheckPoint::oldestXid, CheckPoint::oldestXidDB, OwnLatch(), palloc(), palloc0(), PANIC, tablespaceinfo::path, pfree(), primary_image_masked, psprintf(), read_backup_label(), read_tablespace_map(), ReadCheckpointRecord(), ReadRecord(), readRecoverySignalFile(), RECOVERY_TARGET_IMMEDIATE, RECOVERY_TARGET_LSN, RECOVERY_TARGET_NAME, RECOVERY_TARGET_TIME, RECOVERY_TARGET_XID, recoveryTarget, recoveryTargetLSN, recoveryTargetName, recoveryTargetTime, recoveryTargetTLI, recoveryTargetXid, XLogRecoveryCtlData::recoveryWakeupLatch, CheckPoint::redo, RedoStartLSN, RedoStartTLI, remove_tablespace_symlink(), replay_image_masked, StandbyModeRequested, stat, ControlFileData::state, symlink, XLogReaderState::system_identifier, ControlFileData::system_identifier, TABLESPACE_MAP, TABLESPACE_MAP_OLD, CheckPoint::ThisTimeLineID, timestamptz_to_str(), tliOfPointInHistory(), tliSwitchPoint(), TransactionIdIsNormal, U64FromFullTransactionId, UINT64_FORMAT, validateRecoveryParameters(), wal_decode_buffer_size, wal_segment_close(), wal_segment_size, XidFromFullTransactionId, XLogRecord::xl_info, XL_ROUTINE, XLOG_CHECKPOINT_SHUTDOWN, XLogPageRead(), xlogprefetcher, XLogPrefetcherAllocate(), XLogPrefetcherBeginRead(), xlogreader, XLogReaderAllocate(), XLogReaderSetDecodeBuffer(), XLogRecGetData, XLogRecoveryCtl, XLogRecPtrIsInvalid, and XLR_INFO_MASK.

Referenced by StartupXLOG().

PerformWalRecovery()

void PerformWalRecovery

(

void

)

Definition at line 1652 of file xlogrecovery.c.

{
    XLogRecord *record;
    bool        reachedRecoveryTarget = false;
    TimeLineID  replayTLI;
 
    /*
     * Initialize shared variables for tracking progress of WAL replay, as if
     * we had just replayed the record before the REDO location (or the
     * checkpoint record itself, if it's a shutdown checkpoint).
     */
    SpinLockAcquire(&XLogRecoveryCtl->info_lck);
    if (RedoStartLSN < CheckPointLoc)
    {
        XLogRecoveryCtl->lastReplayedReadRecPtr = InvalidXLogRecPtr;
        XLogRecoveryCtl->lastReplayedEndRecPtr = RedoStartLSN;
        XLogRecoveryCtl->lastReplayedTLI = RedoStartTLI;
    }
    else
    {
        XLogRecoveryCtl->lastReplayedReadRecPtr = xlogreader->ReadRecPtr;
        XLogRecoveryCtl->lastReplayedEndRecPtr = xlogreader->EndRecPtr;
        XLogRecoveryCtl->lastReplayedTLI = CheckPointTLI;
    }
    XLogRecoveryCtl->replayEndRecPtr = XLogRecoveryCtl->lastReplayedEndRecPtr;
    XLogRecoveryCtl->replayEndTLI = XLogRecoveryCtl->lastReplayedTLI;
    XLogRecoveryCtl->recoveryLastXTime = 0;
    XLogRecoveryCtl->currentChunkStartTime = 0;
    XLogRecoveryCtl->recoveryPauseState = RECOVERY_NOT_PAUSED;
    SpinLockRelease(&XLogRecoveryCtl->info_lck);
 
    /* Also ensure XLogReceiptTime has a sane value */
    XLogReceiptTime = GetCurrentTimestamp();
 
    /*
     * Let postmaster know we've started redo now, so that it can launch the
     * archiver if necessary.
     */
    if (IsUnderPostmaster)
        SendPostmasterSignal(PMSIGNAL_RECOVERY_STARTED);
 
    /*
     * Allow read-only connections immediately if we're consistent already.
     */
    CheckRecoveryConsistency();
 
    /*
     * Find the first record that logically follows the checkpoint --- it
     * might physically precede it, though.
     */
    if (RedoStartLSN < CheckPointLoc)
    {
        /* back up to find the record */
        replayTLI = RedoStartTLI;
        XLogPrefetcherBeginRead(xlogprefetcher, RedoStartLSN);
        record = ReadRecord(xlogprefetcher, PANIC, false, replayTLI);
 
        /*
         * If a checkpoint record's redo pointer points back to an earlier
         * LSN, the record at that LSN should be an XLOG_CHECKPOINT_REDO
         * record.
         */
        if (record->xl_rmid != RM_XLOG_ID ||
            (record->xl_info & ~XLR_INFO_MASK) != XLOG_CHECKPOINT_REDO)
            ereport(FATAL,
                    (errmsg("unexpected record type found at redo point %X/%X",
                            LSN_FORMAT_ARGS(xlogreader->ReadRecPtr))));
    }
    else
    {
        /* just have to read next record after CheckPoint */
        Assert(xlogreader->ReadRecPtr == CheckPointLoc);
        replayTLI = CheckPointTLI;
        record = ReadRecord(xlogprefetcher, LOG, false, replayTLI);
    }
 
    if (record != NULL)
    {
        TimestampTz xtime;
        PGRUsage    ru0;
 
        pg_rusage_init(&ru0);
 
        InRedo = true;
 
        RmgrStartup();
 
        ereport(LOG,
                (errmsg("redo starts at %X/%X",
                        LSN_FORMAT_ARGS(xlogreader->ReadRecPtr))));
 
        /* Prepare to report progress of the redo phase. */
        if (!StandbyMode)
            begin_startup_progress_phase();
 
        /*
         * main redo apply loop
         */
        do
        {
            if (!StandbyMode)
                ereport_startup_progress("redo in progress, elapsed time: %ld.%02d s, current LSN: %X/%X",
                                         LSN_FORMAT_ARGS(xlogreader->ReadRecPtr));
 
#ifdef WAL_DEBUG
            if (XLOG_DEBUG)
            {
                StringInfoData buf;
 
                initStringInfo(&buf);
                appendStringInfo(&buf, "REDO @ %X/%X; LSN %X/%X: ",
                                 LSN_FORMAT_ARGS(xlogreader->ReadRecPtr),
                                 LSN_FORMAT_ARGS(xlogreader->EndRecPtr));
                xlog_outrec(&buf, xlogreader);
                appendStringInfoString(&buf, " - ");
                xlog_outdesc(&buf, xlogreader);
                elog(LOG, "%s", buf.data);
                pfree(buf.data);
            }
#endif
 
            /* Handle interrupt signals of startup process */
            HandleStartupProcInterrupts();
 
            /*
             * Pause WAL replay, if requested by a hot-standby session via
             * SetRecoveryPause().
             *
             * Note that we intentionally don't take the info_lck spinlock
             * here.  We might therefore read a slightly stale value of the
             * recoveryPause flag, but it can't be very stale (no worse than
             * the last spinlock we did acquire).  Since a pause request is a
             * pretty asynchronous thing anyway, possibly responding to it one
             * WAL record later than we otherwise would is a minor issue, so
             * it doesn't seem worth adding another spinlock cycle to prevent
             * that.
             */
            if (((volatile XLogRecoveryCtlData *) XLogRecoveryCtl)->recoveryPauseState !=
                RECOVERY_NOT_PAUSED)
                recoveryPausesHere(false);
 
            /*
             * Have we reached our recovery target?
             */
            if (recoveryStopsBefore(xlogreader))
            {
                reachedRecoveryTarget = true;
                break;
            }
 
            /*
             * If we've been asked to lag the primary, wait on latch until
             * enough time has passed.
             */
            if (recoveryApplyDelay(xlogreader))
            {
                /*
                 * We test for paused recovery again here. If user sets
                 * delayed apply, it may be because they expect to pause
                 * recovery in case of problems, so we must test again here
                 * otherwise pausing during the delay-wait wouldn't work.
                 */
                if (((volatile XLogRecoveryCtlData *) XLogRecoveryCtl)->recoveryPauseState !=
                    RECOVERY_NOT_PAUSED)
                    recoveryPausesHere(false);
            }
 
            /*
             * Apply the record
             */
            ApplyWalRecord(xlogreader, record, &replayTLI);
 
            /* Exit loop if we reached inclusive recovery target */
            if (recoveryStopsAfter(xlogreader))
            {
                reachedRecoveryTarget = true;
                break;
            }
 
            /* Else, try to fetch the next WAL record */
            record = ReadRecord(xlogprefetcher, LOG, false, replayTLI);
        } while (record != NULL);
 
        /*
         * end of main redo apply loop
         */
 
        if (reachedRecoveryTarget)
        {
            if (!reachedConsistency)
                ereport(FATAL,
                        (errmsg("requested recovery stop point is before consistent recovery point")));
 
            /*
             * This is the last point where we can restart recovery with a new
             * recovery target, if we shutdown and begin again. After this,
             * Resource Managers may choose to do permanent corrective actions
             * at end of recovery.
             */
            switch (recoveryTargetAction)
            {
                case RECOVERY_TARGET_ACTION_SHUTDOWN:
 
                    /*
                     * exit with special return code to request shutdown of
                     * postmaster.  Log messages issued from postmaster.
                     */
                    proc_exit(3);
 
                case RECOVERY_TARGET_ACTION_PAUSE:
                    SetRecoveryPause(true);
                    recoveryPausesHere(true);
 
                    /* drop into promote */
 
                case RECOVERY_TARGET_ACTION_PROMOTE:
                    break;
            }
        }
 
        RmgrCleanup();
 
        ereport(LOG,
                (errmsg("redo done at %X/%X system usage: %s",
                        LSN_FORMAT_ARGS(xlogreader->ReadRecPtr),
                        pg_rusage_show(&ru0))));
        xtime = GetLatestXTime();
        if (xtime)
            ereport(LOG,
                    (errmsg("last completed transaction was at log time %s",
                            timestamptz_to_str(xtime))));
 
        InRedo = false;
    }
    else
    {
        /* there are no WAL records following the checkpoint */
        ereport(LOG,
                (errmsg("redo is not required")));
    }
 
    /*
     * This check is intentionally after the above log messages that indicate
     * how far recovery went.
     */
    if (ArchiveRecoveryRequested &&
        recoveryTarget != RECOVERY_TARGET_UNSET &&
        !reachedRecoveryTarget)
        ereport(FATAL,
                (errmsg("recovery ended before configured recovery target was reached")));
}

References appendStringInfo(), appendStringInfoString(), ApplyWalRecord(), ArchiveRecoveryRequested, Assert, begin_startup_progress_phase(), buf, CheckPointLoc, CheckPointTLI, CheckRecoveryConsistency(), XLogRecoveryCtlData::currentChunkStartTime, elog, XLogReaderState::EndRecPtr, ereport, ereport_startup_progress, errmsg(), FATAL, GetCurrentTimestamp(), GetLatestXTime(), HandleStartupProcInterrupts(), XLogRecoveryCtlData::info_lck, initStringInfo(), InRedo, InvalidXLogRecPtr, IsUnderPostmaster, XLogRecoveryCtlData::lastReplayedEndRecPtr, XLogRecoveryCtlData::lastReplayedReadRecPtr, XLogRecoveryCtlData::lastReplayedTLI, LOG, LSN_FORMAT_ARGS, PANIC, pfree(), pg_rusage_init(), pg_rusage_show(), PMSIGNAL_RECOVERY_STARTED, proc_exit(), reachedConsistency, ReadRecord(), XLogReaderState::ReadRecPtr, RECOVERY_NOT_PAUSED, RECOVERY_TARGET_ACTION_PAUSE, RECOVERY_TARGET_ACTION_PROMOTE, RECOVERY_TARGET_ACTION_SHUTDOWN, RECOVERY_TARGET_UNSET, recoveryApplyDelay(), XLogRecoveryCtlData::recoveryLastXTime, recoveryPausesHere(), XLogRecoveryCtlData::recoveryPauseState, recoveryStopsAfter(), recoveryStopsBefore(), recoveryTarget, recoveryTargetAction, RedoStartLSN, RedoStartTLI, XLogRecoveryCtlData::replayEndRecPtr, XLogRecoveryCtlData::replayEndTLI, RmgrCleanup(), RmgrStartup(), SendPostmasterSignal(), SetRecoveryPause(), SpinLockAcquire, SpinLockRelease, StandbyMode, timestamptz_to_str(), XLogRecord::xl_info, XLogRecord::xl_rmid, XLOG_CHECKPOINT_REDO, xlog_outdesc(), xlogprefetcher, XLogPrefetcherBeginRead(), xlogreader, XLogReceiptTime, XLogRecoveryCtl, and XLR_INFO_MASK.

Referenced by StartupXLOG().

pg_attribute_noreturn()

static void pg_attribute_noreturn ( )

static

Definition at line 4768 of file xlogrecovery.c.

{
    ereport(ERROR,
            (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
             errmsg("multiple recovery targets specified"),
             errdetail("At most one of recovery_target, recovery_target_lsn, recovery_target_name, recovery_target_time, recovery_target_xid may be set.")));
}

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

PromoteIsTriggered()

bool PromoteIsTriggered

(

void

)

Definition at line 4394 of file xlogrecovery.c.

{
    /*
     * We check shared state each time only until a standby promotion is
     * triggered. We can't trigger a promotion again, so there's no need to
     * keep checking after the shared variable has once been seen true.
     */
    if (LocalPromoteIsTriggered)
        return true;
 
    SpinLockAcquire(&XLogRecoveryCtl->info_lck);
    LocalPromoteIsTriggered = XLogRecoveryCtl->SharedPromoteIsTriggered;
    SpinLockRelease(&XLogRecoveryCtl->info_lck);
 
    return LocalPromoteIsTriggered;
}

References XLogRecoveryCtlData::info_lck, LocalPromoteIsTriggered, XLogRecoveryCtlData::SharedPromoteIsTriggered, SpinLockAcquire, SpinLockRelease, and XLogRecoveryCtl.

Referenced by PerformRecoveryXLogAction(), pg_wal_replay_pause(), and pg_wal_replay_resume().

read_backup_label()

static bool read_backup_label ( XLogRecPtr *  checkPointLoc, TimeLineID *  backupLabelTLI, bool *  backupEndRequired, bool *  backupFromStandby  )

static

Definition at line 1208 of file xlogrecovery.c.

{
    char        startxlogfilename[MAXFNAMELEN];
    TimeLineID  tli_from_walseg,
                tli_from_file;
    FILE       *lfp;
    char        ch;
    char        backuptype[20];
    char        backupfrom[20];
    char        backuplabel[MAXPGPATH];
    char        backuptime[128];
    uint32      hi,
                lo;
 
    /* suppress possible uninitialized-variable warnings */
    *checkPointLoc = InvalidXLogRecPtr;
    *backupLabelTLI = 0;
    *backupEndRequired = false;
    *backupFromStandby = false;
 
    /*
     * See if label file is present
     */
    lfp = AllocateFile(BACKUP_LABEL_FILE, "r");
    if (!lfp)
    {
        if (errno != ENOENT)
            ereport(FATAL,
                    (errcode_for_file_access(),
                     errmsg("could not read file \"%s\": %m",
                            BACKUP_LABEL_FILE)));
        return false;           /* it's not there, all is fine */
    }
 
    /*
     * Read and parse the START WAL LOCATION and CHECKPOINT lines (this code
     * is pretty crude, but we are not expecting any variability in the file
     * format).
     */
    if (fscanf(lfp, "START WAL LOCATION: %X/%X (file %08X%16s)%c",
               &hi, &lo, &tli_from_walseg, startxlogfilename, &ch) != 5 || ch != '\n')
        ereport(FATAL,
                (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                 errmsg("invalid data in file \"%s\"", BACKUP_LABEL_FILE)));
    RedoStartLSN = ((uint64) hi) << 32 | lo;
    RedoStartTLI = tli_from_walseg;
    if (fscanf(lfp, "CHECKPOINT LOCATION: %X/%X%c",
               &hi, &lo, &ch) != 3 || ch != '\n')
        ereport(FATAL,
                (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                 errmsg("invalid data in file \"%s\"", BACKUP_LABEL_FILE)));
    *checkPointLoc = ((uint64) hi) << 32 | lo;
    *backupLabelTLI = tli_from_walseg;
 
    /*
     * BACKUP METHOD lets us know if this was a typical backup ("streamed",
     * which could mean either pg_basebackup or the pg_backup_start/stop
     * method was used) or if this label came from somewhere else (the only
     * other option today being from pg_rewind).  If this was a streamed
     * backup then we know that we need to play through until we get to the
     * end of the WAL which was generated during the backup (at which point we
     * will have reached consistency and backupEndRequired will be reset to be
     * false).
     */
    if (fscanf(lfp, "BACKUP METHOD: %19s\n", backuptype) == 1)
    {
        if (strcmp(backuptype, "streamed") == 0)
            *backupEndRequired = true;
    }
 
    /*
     * BACKUP FROM lets us know if this was from a primary or a standby.  If
     * it was from a standby, we'll double-check that the control file state
     * matches that of a standby.
     */
    if (fscanf(lfp, "BACKUP FROM: %19s\n", backupfrom) == 1)
    {
        if (strcmp(backupfrom, "standby") == 0)
            *backupFromStandby = true;
    }
 
    /*
     * Parse START TIME and LABEL. Those are not mandatory fields for recovery
     * but checking for their presence is useful for debugging and the next
     * sanity checks. Cope also with the fact that the result buffers have a
     * pre-allocated size, hence if the backup_label file has been generated
     * with strings longer than the maximum assumed here an incorrect parsing
     * happens. That's fine as only minor consistency checks are done
     * afterwards.
     */
    if (fscanf(lfp, "START TIME: %127[^\n]\n", backuptime) == 1)
        ereport(DEBUG1,
                (errmsg_internal("backup time %s in file \"%s\"",
                                 backuptime, BACKUP_LABEL_FILE)));
 
    if (fscanf(lfp, "LABEL: %1023[^\n]\n", backuplabel) == 1)
        ereport(DEBUG1,
                (errmsg_internal("backup label %s in file \"%s\"",
                                 backuplabel, BACKUP_LABEL_FILE)));
 
    /*
     * START TIMELINE is new as of 11. Its parsing is not mandatory, still use
     * it as a sanity check if present.
     */
    if (fscanf(lfp, "START TIMELINE: %u\n", &tli_from_file) == 1)
    {
        if (tli_from_walseg != tli_from_file)
            ereport(FATAL,
                    (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                     errmsg("invalid data in file \"%s\"", BACKUP_LABEL_FILE),
                     errdetail("Timeline ID parsed is %u, but expected %u.",
                               tli_from_file, tli_from_walseg)));
 
        ereport(DEBUG1,
                (errmsg_internal("backup timeline %u in file \"%s\"",
                                 tli_from_file, BACKUP_LABEL_FILE)));
    }
 
    if (fscanf(lfp, "INCREMENTAL FROM LSN: %X/%X\n", &hi, &lo) > 0)
        ereport(FATAL,
                (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                 errmsg("this is an incremental backup, not a data directory"),
                 errhint("Use pg_combinebackup to reconstruct a valid data directory.")));
 
    if (ferror(lfp) || FreeFile(lfp))
        ereport(FATAL,
                (errcode_for_file_access(),
                 errmsg("could not read file \"%s\": %m",
                        BACKUP_LABEL_FILE)));
 
    return true;
}

References AllocateFile(), BACKUP_LABEL_FILE, backupEndRequired, DEBUG1, ereport, errcode(), errcode_for_file_access(), errdetail(), errhint(), errmsg(), errmsg_internal(), FATAL, FreeFile(), InvalidXLogRecPtr, MAXFNAMELEN, MAXPGPATH, RedoStartLSN, and RedoStartTLI.

Referenced by InitWalRecovery().

read_tablespace_map()

static bool read_tablespace_map ( List **  tablespaces )

static

Definition at line 1354 of file xlogrecovery.c.

{
    tablespaceinfo *ti;
    FILE       *lfp;
    char        str[MAXPGPATH];
    int         ch,
                i,
                n;
    bool        was_backslash;
 
    /*
     * See if tablespace_map file is present
     */
    lfp = AllocateFile(TABLESPACE_MAP, "r");
    if (!lfp)
    {
        if (errno != ENOENT)
            ereport(FATAL,
                    (errcode_for_file_access(),
                     errmsg("could not read file \"%s\": %m",
                            TABLESPACE_MAP)));
        return false;           /* it's not there, all is fine */
    }
 
    /*
     * Read and parse the link name and path lines from tablespace_map file
     * (this code is pretty crude, but we are not expecting any variability in
     * the file format).  De-escape any backslashes that were inserted.
     */
    i = 0;
    was_backslash = false;
    while ((ch = fgetc(lfp)) != EOF)
    {
        if (!was_backslash && (ch == '\n' || ch == '\r'))
        {
            char       *endp;
 
            if (i == 0)
                continue;       /* \r immediately followed by \n */
 
            /*
             * The de-escaped line should contain an OID followed by exactly
             * one space followed by a path.  The path might start with
             * spaces, so don't be too liberal about parsing.
             */
            str[i] = '\0';
            n = 0;
            while (str[n] && str[n] != ' ')
                n++;
            if (n < 1 || n >= i - 1)
                ereport(FATAL,
                        (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                         errmsg("invalid data in file \"%s\"", TABLESPACE_MAP)));
            str[n++] = '\0';
 
            ti = palloc0(sizeof(tablespaceinfo));
            errno = 0;
            ti->oid = strtoul(str, &endp, 10);
            if (*endp != '\0' || errno == EINVAL || errno == ERANGE)
                ereport(FATAL,
                        (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                         errmsg("invalid data in file \"%s\"", TABLESPACE_MAP)));
            ti->path = pstrdup(str + n);
            *tablespaces = lappend(*tablespaces, ti);
 
            i = 0;
            continue;
        }
        else if (!was_backslash && ch == '\\')
            was_backslash = true;
        else
        {
            if (i < sizeof(str) - 1)
                str[i++] = ch;
            was_backslash = false;
        }
    }
 
    if (i != 0 || was_backslash)    /* last line not terminated? */
        ereport(FATAL,
                (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                 errmsg("invalid data in file \"%s\"", TABLESPACE_MAP)));
 
    if (ferror(lfp) || FreeFile(lfp))
        ereport(FATAL,
                (errcode_for_file_access(),
                 errmsg("could not read file \"%s\": %m",
                        TABLESPACE_MAP)));
 
    return true;
}

References AllocateFile(), ereport, errcode(), errcode_for_file_access(), errmsg(), FATAL, FreeFile(), i, lappend(), MAXPGPATH, tablespaceinfo::oid, palloc0(), tablespaceinfo::path, pstrdup(), str, and TABLESPACE_MAP.

Referenced by InitWalRecovery().

ReadCheckpointRecord()

static XLogRecord * ReadCheckpointRecord ( XLogPrefetcher *  xlogprefetcher, XLogRecPtr  RecPtr, TimeLineID  replayTLI  )

static

Definition at line 4049 of file xlogrecovery.c.

{
    XLogRecord *record;
    uint8       info;
 
    Assert(xlogreader != NULL);
 
    if (!XRecOffIsValid(RecPtr))
    {
        ereport(LOG,
                (errmsg("invalid checkpoint location")));
        return NULL;
    }
 
    XLogPrefetcherBeginRead(xlogprefetcher, RecPtr);
    record = ReadRecord(xlogprefetcher, LOG, true, replayTLI);
 
    if (record == NULL)
    {
        ereport(LOG,
                (errmsg("invalid checkpoint record")));
        return NULL;
    }
    if (record->xl_rmid != RM_XLOG_ID)
    {
        ereport(LOG,
                (errmsg("invalid resource manager ID in checkpoint record")));
        return NULL;
    }
    info = record->xl_info & ~XLR_INFO_MASK;
    if (info != XLOG_CHECKPOINT_SHUTDOWN &&
        info != XLOG_CHECKPOINT_ONLINE)
    {
        ereport(LOG,
                (errmsg("invalid xl_info in checkpoint record")));
        return NULL;
    }
    if (record->xl_tot_len != SizeOfXLogRecord + SizeOfXLogRecordDataHeaderShort + sizeof(CheckPoint))
    {
        ereport(LOG,
                (errmsg("invalid length of checkpoint record")));
        return NULL;
    }
    return record;
}

References Assert, ereport, errmsg(), LOG, ReadRecord(), SizeOfXLogRecord, SizeOfXLogRecordDataHeaderShort, XLogRecord::xl_info, XLogRecord::xl_rmid, XLogRecord::xl_tot_len, XLOG_CHECKPOINT_ONLINE, XLOG_CHECKPOINT_SHUTDOWN, xlogprefetcher, XLogPrefetcherBeginRead(), xlogreader, XLR_INFO_MASK, and XRecOffIsValid.

Referenced by InitWalRecovery().

ReadRecord()

static XLogRecord * ReadRecord ( XLogPrefetcher *  xlogprefetcher, int  emode, bool  fetching_ckpt, TimeLineID  replayTLI  )

static

Definition at line 3131 of file xlogrecovery.c.

{
    XLogRecord *record;
    XLogReaderState *xlogreader = XLogPrefetcherGetReader(xlogprefetcher);
    XLogPageReadPrivate *private = (XLogPageReadPrivate *) xlogreader->private_data;
 
    /* Pass through parameters to XLogPageRead */
    private->fetching_ckpt = fetching_ckpt;
    private->emode = emode;
    private->randAccess = (xlogreader->ReadRecPtr == InvalidXLogRecPtr);
    private->replayTLI = replayTLI;
 
    /* This is the first attempt to read this page. */
    lastSourceFailed = false;
 
    for (;;)
    {
        char       *errormsg;
 
        record = XLogPrefetcherReadRecord(xlogprefetcher, &errormsg);
        if (record == NULL)
        {
            /*
             * When we find that WAL ends in an incomplete record, keep track
             * of that record.  After recovery is done, we'll write a record
             * to indicate to downstream WAL readers that that portion is to
             * be ignored.
             *
             * However, when ArchiveRecoveryRequested = true, we're going to
             * switch to a new timeline at the end of recovery. We will only
             * copy WAL over to the new timeline up to the end of the last
             * complete record, so if we did this, we would later create an
             * overwrite contrecord in the wrong place, breaking everything.
             */
            if (!ArchiveRecoveryRequested &&
                !XLogRecPtrIsInvalid(xlogreader->abortedRecPtr))
            {
                abortedRecPtr = xlogreader->abortedRecPtr;
                missingContrecPtr = xlogreader->missingContrecPtr;
            }
 
            if (readFile >= 0)
            {
                close(readFile);
                readFile = -1;
            }
 
            /*
             * We only end up here without a message when XLogPageRead()
             * failed - in that case we already logged something. In
             * StandbyMode that only happens if we have been triggered, so we
             * shouldn't loop anymore in that case.
             */
            if (errormsg)
                ereport(emode_for_corrupt_record(emode, xlogreader->EndRecPtr),
                        (errmsg_internal("%s", errormsg) /* already translated */ ));
        }
 
        /*
         * Check page TLI is one of the expected values.
         */
        else if (!tliInHistory(xlogreader->latestPageTLI, expectedTLEs))
        {
            char        fname[MAXFNAMELEN];
            XLogSegNo   segno;
            int32       offset;
 
            XLByteToSeg(xlogreader->latestPagePtr, segno, wal_segment_size);
            offset = XLogSegmentOffset(xlogreader->latestPagePtr,
                                       wal_segment_size);
            XLogFileName(fname, xlogreader->seg.ws_tli, segno,
                         wal_segment_size);
            ereport(emode_for_corrupt_record(emode, xlogreader->EndRecPtr),
                    (errmsg("unexpected timeline ID %u in WAL segment %s, LSN %X/%X, offset %u",
                            xlogreader->latestPageTLI,
                            fname,
                            LSN_FORMAT_ARGS(xlogreader->latestPagePtr),
                            offset)));
            record = NULL;
        }
 
        if (record)
        {
            /* Great, got a record */
            return record;
        }
        else
        {
            /* No valid record available from this source */
            lastSourceFailed = true;
 
            /*
             * If archive recovery was requested, but we were still doing
             * crash recovery, switch to archive recovery and retry using the
             * offline archive. We have now replayed all the valid WAL in
             * pg_wal, so we are presumably now consistent.
             *
             * We require that there's at least some valid WAL present in
             * pg_wal, however (!fetching_ckpt).  We could recover using the
             * WAL from the archive, even if pg_wal is completely empty, but
             * we'd have no idea how far we'd have to replay to reach
             * consistency.  So err on the safe side and give up.
             */
            if (!InArchiveRecovery && ArchiveRecoveryRequested &&
                !fetching_ckpt)
            {
                ereport(DEBUG1,
                        (errmsg_internal("reached end of WAL in pg_wal, entering archive recovery")));
                InArchiveRecovery = true;
                if (StandbyModeRequested)
                    EnableStandbyMode();
 
                SwitchIntoArchiveRecovery(xlogreader->EndRecPtr, replayTLI);
                minRecoveryPoint = xlogreader->EndRecPtr;
                minRecoveryPointTLI = replayTLI;
 
                CheckRecoveryConsistency();
 
                /*
                 * Before we retry, reset lastSourceFailed and currentSource
                 * so that we will check the archive next.
                 */
                lastSourceFailed = false;
                currentSource = XLOG_FROM_ANY;
 
                continue;
            }
 
            /* In standby mode, loop back to retry. Otherwise, give up. */
            if (StandbyMode && !CheckForStandbyTrigger())
                continue;
            else
                return NULL;
        }
    }
}

References abortedRecPtr, XLogReaderState::abortedRecPtr, ArchiveRecoveryRequested, CheckForStandbyTrigger(), CheckRecoveryConsistency(), close, currentSource, DEBUG1, emode_for_corrupt_record(), EnableStandbyMode(), XLogReaderState::EndRecPtr, ereport, errmsg(), errmsg_internal(), expectedTLEs, InArchiveRecovery, InvalidXLogRecPtr, lastSourceFailed, XLogReaderState::latestPagePtr, XLogReaderState::latestPageTLI, LSN_FORMAT_ARGS, MAXFNAMELEN, minRecoveryPoint, minRecoveryPointTLI, missingContrecPtr, XLogReaderState::missingContrecPtr, XLogReaderState::private_data, readFile, XLogReaderState::ReadRecPtr, XLogReaderState::seg, StandbyMode, StandbyModeRequested, SwitchIntoArchiveRecovery(), tliInHistory(), wal_segment_size, WALOpenSegment::ws_tli, XLByteToSeg, XLOG_FROM_ANY, XLogFileName(), xlogprefetcher, XLogPrefetcherGetReader(), XLogPrefetcherReadRecord(), xlogreader, XLogRecPtrIsInvalid, and XLogSegmentOffset.

Referenced by FinishWalRecovery(), InitWalRecovery(), PerformWalRecovery(), and ReadCheckpointRecord().

readRecoverySignalFile()

static void readRecoverySignalFile ( void  )

static

Definition at line 1027 of file xlogrecovery.c.

{
    struct stat stat_buf;
 
    if (IsBootstrapProcessingMode())
        return;
 
    /*
     * Check for old recovery API file: recovery.conf
     */
    if (stat(RECOVERY_COMMAND_FILE, &stat_buf) == 0)
        ereport(FATAL,
                (errcode_for_file_access(),
                 errmsg("using recovery command file \"%s\" is not supported",
                        RECOVERY_COMMAND_FILE)));
 
    /*
     * Remove unused .done file, if present. Ignore if absent.
     */
    unlink(RECOVERY_COMMAND_DONE);
 
    /*
     * Check for recovery signal files and if found, fsync them since they
     * represent server state information.  We don't sweat too much about the
     * possibility of fsync failure, however.
     *
     * If present, standby signal file takes precedence. If neither is present
     * then we won't enter archive recovery.
     */
    if (stat(STANDBY_SIGNAL_FILE, &stat_buf) == 0)
    {
        int         fd;
 
        fd = BasicOpenFilePerm(STANDBY_SIGNAL_FILE, O_RDWR | PG_BINARY,
                               S_IRUSR | S_IWUSR);
        if (fd >= 0)
        {
            (void) pg_fsync(fd);
            close(fd);
        }
        standby_signal_file_found = true;
    }
    else if (stat(RECOVERY_SIGNAL_FILE, &stat_buf) == 0)
    {
        int         fd;
 
        fd = BasicOpenFilePerm(RECOVERY_SIGNAL_FILE, O_RDWR | PG_BINARY,
                               S_IRUSR | S_IWUSR);
        if (fd >= 0)
        {
            (void) pg_fsync(fd);
            close(fd);
        }
        recovery_signal_file_found = true;
    }
 
    StandbyModeRequested = false;
    ArchiveRecoveryRequested = false;
    if (standby_signal_file_found)
    {
        StandbyModeRequested = true;
        ArchiveRecoveryRequested = true;
    }
    else if (recovery_signal_file_found)
    {
        StandbyModeRequested = false;
        ArchiveRecoveryRequested = true;
    }
    else
        return;
 
    /*
     * We don't support standby mode in standalone backends; that requires
     * other processes such as the WAL receiver to be alive.
     */
    if (StandbyModeRequested && !IsUnderPostmaster)
        ereport(FATAL,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("standby mode is not supported by single-user servers")));
}

References ArchiveRecoveryRequested, BasicOpenFilePerm(), close, ereport, errcode(), errcode_for_file_access(), errmsg(), FATAL, fd(), IsBootstrapProcessingMode, IsUnderPostmaster, PG_BINARY, pg_fsync(), RECOVERY_COMMAND_DONE, RECOVERY_COMMAND_FILE, RECOVERY_SIGNAL_FILE, recovery_signal_file_found, S_IRUSR, S_IWUSR, STANDBY_SIGNAL_FILE, standby_signal_file_found, StandbyModeRequested, and stat.

Referenced by InitWalRecovery().

recoveryApplyDelay()

static bool recoveryApplyDelay ( XLogReaderState *  record )

static

Definition at line 2982 of file xlogrecovery.c.

{
    uint8       xact_info;
    TimestampTz xtime;
    TimestampTz delayUntil;
    long        msecs;
 
    /* nothing to do if no delay configured */
    if (recovery_min_apply_delay <= 0)
        return false;
 
    /* no delay is applied on a database not yet consistent */
    if (!reachedConsistency)
        return false;
 
    /* nothing to do if crash recovery is requested */
    if (!ArchiveRecoveryRequested)
        return false;
 
    /*
     * Is it a COMMIT record?
     *
     * We deliberately choose not to delay aborts since they have no effect on
     * MVCC. We already allow replay of records that don't have a timestamp,
     * so there is already opportunity for issues caused by early conflicts on
     * standbys.
     */
    if (XLogRecGetRmid(record) != RM_XACT_ID)
        return false;
 
    xact_info = XLogRecGetInfo(record) & XLOG_XACT_OPMASK;
 
    if (xact_info != XLOG_XACT_COMMIT &&
        xact_info != XLOG_XACT_COMMIT_PREPARED)
        return false;
 
    if (!getRecordTimestamp(record, &xtime))
        return false;
 
    delayUntil = TimestampTzPlusMilliseconds(xtime, recovery_min_apply_delay);
 
    /*
     * Exit without arming the latch if it's already past time to apply this
     * record
     */
    msecs = TimestampDifferenceMilliseconds(GetCurrentTimestamp(), delayUntil);
    if (msecs <= 0)
        return false;
 
    while (true)
    {
        ResetLatch(&XLogRecoveryCtl->recoveryWakeupLatch);
 
        /* This might change recovery_min_apply_delay. */
        HandleStartupProcInterrupts();
 
        if (CheckForStandbyTrigger())
            break;
 
        /*
         * Recalculate delayUntil as recovery_min_apply_delay could have
         * changed while waiting in this loop.
         */
        delayUntil = TimestampTzPlusMilliseconds(xtime, recovery_min_apply_delay);
 
        /*
         * Wait for difference between GetCurrentTimestamp() and delayUntil.
         */
        msecs = TimestampDifferenceMilliseconds(GetCurrentTimestamp(),
                                                delayUntil);
 
        if (msecs <= 0)
            break;
 
        elog(DEBUG2, "recovery apply delay %ld milliseconds", msecs);
 
        (void) WaitLatch(&XLogRecoveryCtl->recoveryWakeupLatch,
                         WL_LATCH_SET | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH,
                         msecs,
                         WAIT_EVENT_RECOVERY_APPLY_DELAY);
    }
    return true;
}

References ArchiveRecoveryRequested, CheckForStandbyTrigger(), DEBUG2, elog, GetCurrentTimestamp(), getRecordTimestamp(), HandleStartupProcInterrupts(), reachedConsistency, recovery_min_apply_delay, XLogRecoveryCtlData::recoveryWakeupLatch, ResetLatch(), TimestampDifferenceMilliseconds(), TimestampTzPlusMilliseconds, WaitLatch(), WL_EXIT_ON_PM_DEATH, WL_LATCH_SET, WL_TIMEOUT, XLOG_XACT_COMMIT, XLOG_XACT_COMMIT_PREPARED, XLOG_XACT_OPMASK, XLogRecGetInfo, XLogRecGetRmid, and XLogRecoveryCtl.

Referenced by PerformWalRecovery().

recoveryPausesHere()

static void recoveryPausesHere ( bool  endOfRecovery )

static

Definition at line 2925 of file xlogrecovery.c.

{
    /* Don't pause unless users can connect! */
    if (!LocalHotStandbyActive)
        return;
 
    /* Don't pause after standby promotion has been triggered */
    if (LocalPromoteIsTriggered)
        return;
 
    if (endOfRecovery)
        ereport(LOG,
                (errmsg("pausing at the end of recovery"),
                 errhint("Execute pg_wal_replay_resume() to promote.")));
    else
        ereport(LOG,
                (errmsg("recovery has paused"),
                 errhint("Execute pg_wal_replay_resume() to continue.")));
 
    /* loop until recoveryPauseState is set to RECOVERY_NOT_PAUSED */
    while (GetRecoveryPauseState() != RECOVERY_NOT_PAUSED)
    {
        HandleStartupProcInterrupts();
        if (CheckForStandbyTrigger())
            return;
 
        /*
         * If recovery pause is requested then set it paused.  While we are in
         * the loop, user might resume and pause again so set this every time.
         */
        ConfirmRecoveryPaused();
 
        /*
         * We wait on a condition variable that will wake us as soon as the
         * pause ends, but we use a timeout so we can check the above exit
         * condition periodically too.
         */
        ConditionVariableTimedSleep(&XLogRecoveryCtl->recoveryNotPausedCV, 1000,
                                    WAIT_EVENT_RECOVERY_PAUSE);
    }
    ConditionVariableCancelSleep();
}

References CheckForStandbyTrigger(), ConditionVariableCancelSleep(), ConditionVariableTimedSleep(), ConfirmRecoveryPaused(), ereport, errhint(), errmsg(), GetRecoveryPauseState(), HandleStartupProcInterrupts(), LocalHotStandbyActive, LocalPromoteIsTriggered, LOG, RECOVERY_NOT_PAUSED, XLogRecoveryCtlData::recoveryNotPausedCV, and XLogRecoveryCtl.

Referenced by PerformWalRecovery(), and WaitForWALToBecomeAvailable().

RecoveryRequiresIntParameter()

void RecoveryRequiresIntParameter	(	const char *	param_name,
		int	currValue,
		int	minValue
	)

Definition at line 4659 of file xlogrecovery.c.

{
    if (currValue < minValue)
    {
        if (HotStandbyActiveInReplay())
        {
            bool        warned_for_promote = false;
 
            ereport(WARNING,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("hot standby is not possible because of insufficient parameter settings"),
                     errdetail("%s = %d is a lower setting than on the primary server, where its value was %d.",
                               param_name,
                               currValue,
                               minValue)));
 
            SetRecoveryPause(true);
 
            ereport(LOG,
                    (errmsg("recovery has paused"),
                     errdetail("If recovery is unpaused, the server will shut down."),
                     errhint("You can then restart the server after making the necessary configuration changes.")));
 
            while (GetRecoveryPauseState() != RECOVERY_NOT_PAUSED)
            {
                HandleStartupProcInterrupts();
 
                if (CheckForStandbyTrigger())
                {
                    if (!warned_for_promote)
                        ereport(WARNING,
                                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                                 errmsg("promotion is not possible because of insufficient parameter settings"),
 
                        /*
                         * Repeat the detail from above so it's easy to find
                         * in the log.
                         */
                                 errdetail("%s = %d is a lower setting than on the primary server, where its value was %d.",
                                           param_name,
                                           currValue,
                                           minValue),
                                 errhint("Restart the server after making the necessary configuration changes.")));
                    warned_for_promote = true;
                }
 
                /*
                 * If recovery pause is requested then set it paused.  While
                 * we are in the loop, user might resume and pause again so
                 * set this every time.
                 */
                ConfirmRecoveryPaused();
 
                /*
                 * We wait on a condition variable that will wake us as soon
                 * as the pause ends, but we use a timeout so we can check the
                 * above conditions periodically too.
                 */
                ConditionVariableTimedSleep(&XLogRecoveryCtl->recoveryNotPausedCV, 1000,
                                            WAIT_EVENT_RECOVERY_PAUSE);
            }
            ConditionVariableCancelSleep();
        }
 
        ereport(FATAL,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("recovery aborted because of insufficient parameter settings"),
        /* Repeat the detail from above so it's easy to find in the log. */
                 errdetail("%s = %d is a lower setting than on the primary server, where its value was %d.",
                           param_name,
                           currValue,
                           minValue),
                 errhint("You can restart the server after making the necessary configuration changes.")));
    }
}

References CheckForStandbyTrigger(), ConditionVariableCancelSleep(), ConditionVariableTimedSleep(), ConfirmRecoveryPaused(), ereport, errcode(), errdetail(), errhint(), errmsg(), FATAL, GetRecoveryPauseState(), HandleStartupProcInterrupts(), HotStandbyActiveInReplay(), LOG, RECOVERY_NOT_PAUSED, XLogRecoveryCtlData::recoveryNotPausedCV, SetRecoveryPause(), WARNING, and XLogRecoveryCtl.

Referenced by CheckRequiredParameterValues().

recoveryStopsAfter()

static bool recoveryStopsAfter ( XLogReaderState *  record )

static

Definition at line 2726 of file xlogrecovery.c.

{
    uint8       info;
    uint8       xact_info;
    uint8       rmid;
    TimestampTz recordXtime = 0;
 
    /*
     * Ignore recovery target settings when not in archive recovery (meaning
     * we are in crash recovery).
     */
    if (!ArchiveRecoveryRequested)
        return false;
 
    info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
    rmid = XLogRecGetRmid(record);
 
    /*
     * There can be many restore points that share the same name; we stop at
     * the first one.
     */
    if (recoveryTarget == RECOVERY_TARGET_NAME &&
        rmid == RM_XLOG_ID && info == XLOG_RESTORE_POINT)
    {
        xl_restore_point *recordRestorePointData;
 
        recordRestorePointData = (xl_restore_point *) XLogRecGetData(record);
 
        if (strcmp(recordRestorePointData->rp_name, recoveryTargetName) == 0)
        {
            recoveryStopAfter = true;
            recoveryStopXid = InvalidTransactionId;
            recoveryStopLSN = InvalidXLogRecPtr;
            (void) getRecordTimestamp(record, &recoveryStopTime);
            strlcpy(recoveryStopName, recordRestorePointData->rp_name, MAXFNAMELEN);
 
            ereport(LOG,
                    (errmsg("recovery stopping at restore point \"%s\", time %s",
                            recoveryStopName,
                            timestamptz_to_str(recoveryStopTime))));
            return true;
        }
    }
 
    /* Check if the target LSN has been reached */
    if (recoveryTarget == RECOVERY_TARGET_LSN &&
        recoveryTargetInclusive &&
        record->ReadRecPtr >= recoveryTargetLSN)
    {
        recoveryStopAfter = true;
        recoveryStopXid = InvalidTransactionId;
        recoveryStopLSN = record->ReadRecPtr;
        recoveryStopTime = 0;
        recoveryStopName[0] = '\0';
        ereport(LOG,
                (errmsg("recovery stopping after WAL location (LSN) \"%X/%X\"",
                        LSN_FORMAT_ARGS(recoveryStopLSN))));
        return true;
    }
 
    if (rmid != RM_XACT_ID)
        return false;
 
    xact_info = info & XLOG_XACT_OPMASK;
 
    if (xact_info == XLOG_XACT_COMMIT ||
        xact_info == XLOG_XACT_COMMIT_PREPARED ||
        xact_info == XLOG_XACT_ABORT ||
        xact_info == XLOG_XACT_ABORT_PREPARED)
    {
        TransactionId recordXid;
 
        /* Update the last applied transaction timestamp */
        if (getRecordTimestamp(record, &recordXtime))
            SetLatestXTime(recordXtime);
 
        /* Extract the XID of the committed/aborted transaction */
        if (xact_info == XLOG_XACT_COMMIT_PREPARED)
        {
            xl_xact_commit *xlrec = (xl_xact_commit *) XLogRecGetData(record);
            xl_xact_parsed_commit parsed;
 
            ParseCommitRecord(XLogRecGetInfo(record),
                              xlrec,
                              &parsed);
            recordXid = parsed.twophase_xid;
        }
        else if (xact_info == XLOG_XACT_ABORT_PREPARED)
        {
            xl_xact_abort *xlrec = (xl_xact_abort *) XLogRecGetData(record);
            xl_xact_parsed_abort parsed;
 
            ParseAbortRecord(XLogRecGetInfo(record),
                             xlrec,
                             &parsed);
            recordXid = parsed.twophase_xid;
        }
        else
            recordXid = XLogRecGetXid(record);
 
        /*
         * There can be only one transaction end record with this exact
         * transactionid
         *
         * when testing for an xid, we MUST test for equality only, since
         * transactions are numbered in the order they start, not the order
         * they complete. A higher numbered xid will complete before you about
         * 50% of the time...
         */
        if (recoveryTarget == RECOVERY_TARGET_XID && recoveryTargetInclusive &&
            recordXid == recoveryTargetXid)
        {
            recoveryStopAfter = true;
            recoveryStopXid = recordXid;
            recoveryStopTime = recordXtime;
            recoveryStopLSN = InvalidXLogRecPtr;
            recoveryStopName[0] = '\0';
 
            if (xact_info == XLOG_XACT_COMMIT ||
                xact_info == XLOG_XACT_COMMIT_PREPARED)
            {
                ereport(LOG,
                        (errmsg("recovery stopping after commit of transaction %u, time %s",
                                recoveryStopXid,
                                timestamptz_to_str(recoveryStopTime))));
            }
            else if (xact_info == XLOG_XACT_ABORT ||
                     xact_info == XLOG_XACT_ABORT_PREPARED)
            {
                ereport(LOG,
                        (errmsg("recovery stopping after abort of transaction %u, time %s",
                                recoveryStopXid,
                                timestamptz_to_str(recoveryStopTime))));
            }
            return true;
        }
    }
 
    /* Check if we should stop as soon as reaching consistency */
    if (recoveryTarget == RECOVERY_TARGET_IMMEDIATE && reachedConsistency)
    {
        ereport(LOG,
                (errmsg("recovery stopping after reaching consistency")));
 
        recoveryStopAfter = true;
        recoveryStopXid = InvalidTransactionId;
        recoveryStopTime = 0;
        recoveryStopLSN = InvalidXLogRecPtr;
        recoveryStopName[0] = '\0';
        return true;
    }
 
    return false;
}

References ArchiveRecoveryRequested, ereport, errmsg(), getRecordTimestamp(), InvalidTransactionId, InvalidXLogRecPtr, LOG, LSN_FORMAT_ARGS, MAXFNAMELEN, ParseAbortRecord(), ParseCommitRecord(), reachedConsistency, XLogReaderState::ReadRecPtr, RECOVERY_TARGET_IMMEDIATE, RECOVERY_TARGET_LSN, RECOVERY_TARGET_NAME, RECOVERY_TARGET_XID, recoveryStopAfter, recoveryStopLSN, recoveryStopName, recoveryStopTime, recoveryStopXid, recoveryTarget, recoveryTargetInclusive, recoveryTargetLSN, recoveryTargetName, recoveryTargetXid, xl_restore_point::rp_name, SetLatestXTime(), strlcpy(), timestamptz_to_str(), xl_xact_parsed_commit::twophase_xid, xl_xact_parsed_abort::twophase_xid, XLOG_RESTORE_POINT, XLOG_XACT_ABORT, XLOG_XACT_ABORT_PREPARED, XLOG_XACT_COMMIT, XLOG_XACT_COMMIT_PREPARED, XLOG_XACT_OPMASK, XLogRecGetData, XLogRecGetInfo, XLogRecGetRmid, XLogRecGetXid, and XLR_INFO_MASK.

Referenced by PerformWalRecovery().

recoveryStopsBefore()

static bool recoveryStopsBefore ( XLogReaderState *  record )

static

Definition at line 2573 of file xlogrecovery.c.

{
    bool        stopsHere = false;
    uint8       xact_info;
    bool        isCommit;
    TimestampTz recordXtime = 0;
    TransactionId recordXid;
 
    /*
     * Ignore recovery target settings when not in archive recovery (meaning
     * we are in crash recovery).
     */
    if (!ArchiveRecoveryRequested)
        return false;
 
    /* Check if we should stop as soon as reaching consistency */
    if (recoveryTarget == RECOVERY_TARGET_IMMEDIATE && reachedConsistency)
    {
        ereport(LOG,
                (errmsg("recovery stopping after reaching consistency")));
 
        recoveryStopAfter = false;
        recoveryStopXid = InvalidTransactionId;
        recoveryStopLSN = InvalidXLogRecPtr;
        recoveryStopTime = 0;
        recoveryStopName[0] = '\0';
        return true;
    }
 
    /* Check if target LSN has been reached */
    if (recoveryTarget == RECOVERY_TARGET_LSN &&
        !recoveryTargetInclusive &&
        record->ReadRecPtr >= recoveryTargetLSN)
    {
        recoveryStopAfter = false;
        recoveryStopXid = InvalidTransactionId;
        recoveryStopLSN = record->ReadRecPtr;
        recoveryStopTime = 0;
        recoveryStopName[0] = '\0';
        ereport(LOG,
                (errmsg("recovery stopping before WAL location (LSN) \"%X/%X\"",
                        LSN_FORMAT_ARGS(recoveryStopLSN))));
        return true;
    }
 
    /* Otherwise we only consider stopping before COMMIT or ABORT records. */
    if (XLogRecGetRmid(record) != RM_XACT_ID)
        return false;
 
    xact_info = XLogRecGetInfo(record) & XLOG_XACT_OPMASK;
 
    if (xact_info == XLOG_XACT_COMMIT)
    {
        isCommit = true;
        recordXid = XLogRecGetXid(record);
    }
    else if (xact_info == XLOG_XACT_COMMIT_PREPARED)
    {
        xl_xact_commit *xlrec = (xl_xact_commit *) XLogRecGetData(record);
        xl_xact_parsed_commit parsed;
 
        isCommit = true;
        ParseCommitRecord(XLogRecGetInfo(record),
                          xlrec,
                          &parsed);
        recordXid = parsed.twophase_xid;
    }
    else if (xact_info == XLOG_XACT_ABORT)
    {
        isCommit = false;
        recordXid = XLogRecGetXid(record);
    }
    else if (xact_info == XLOG_XACT_ABORT_PREPARED)
    {
        xl_xact_abort *xlrec = (xl_xact_abort *) XLogRecGetData(record);
        xl_xact_parsed_abort parsed;
 
        isCommit = false;
        ParseAbortRecord(XLogRecGetInfo(record),
                         xlrec,
                         &parsed);
        recordXid = parsed.twophase_xid;
    }
    else
        return false;
 
    if (recoveryTarget == RECOVERY_TARGET_XID && !recoveryTargetInclusive)
    {
        /*
         * There can be only one transaction end record with this exact
         * transactionid
         *
         * when testing for an xid, we MUST test for equality only, since
         * transactions are numbered in the order they start, not the order
         * they complete. A higher numbered xid will complete before you about
         * 50% of the time...
         */
        stopsHere = (recordXid == recoveryTargetXid);
    }
 
    /*
     * Note: we must fetch recordXtime regardless of recoveryTarget setting.
     * We don't expect getRecordTimestamp ever to fail, since we already know
     * this is a commit or abort record; but test its result anyway.
     */
    if (getRecordTimestamp(record, &recordXtime) &&
        recoveryTarget == RECOVERY_TARGET_TIME)
    {
        /*
         * There can be many transactions that share the same commit time, so
         * we stop after the last one, if we are inclusive, or stop at the
         * first one if we are exclusive
         */
        if (recoveryTargetInclusive)
            stopsHere = (recordXtime > recoveryTargetTime);
        else
            stopsHere = (recordXtime >= recoveryTargetTime);
    }
 
    if (stopsHere)
    {
        recoveryStopAfter = false;
        recoveryStopXid = recordXid;
        recoveryStopTime = recordXtime;
        recoveryStopLSN = InvalidXLogRecPtr;
        recoveryStopName[0] = '\0';
 
        if (isCommit)
        {
            ereport(LOG,
                    (errmsg("recovery stopping before commit of transaction %u, time %s",
                            recoveryStopXid,
                            timestamptz_to_str(recoveryStopTime))));
        }
        else
        {
            ereport(LOG,
                    (errmsg("recovery stopping before abort of transaction %u, time %s",
                            recoveryStopXid,
                            timestamptz_to_str(recoveryStopTime))));
        }
    }
 
    return stopsHere;
}

References ArchiveRecoveryRequested, ereport, errmsg(), getRecordTimestamp(), InvalidTransactionId, InvalidXLogRecPtr, LOG, LSN_FORMAT_ARGS, ParseAbortRecord(), ParseCommitRecord(), reachedConsistency, XLogReaderState::ReadRecPtr, RECOVERY_TARGET_IMMEDIATE, RECOVERY_TARGET_LSN, RECOVERY_TARGET_TIME, RECOVERY_TARGET_XID, recoveryStopAfter, recoveryStopLSN, recoveryStopName, recoveryStopTime, recoveryStopXid, recoveryTarget, recoveryTargetInclusive, recoveryTargetLSN, recoveryTargetTime, recoveryTargetXid, timestamptz_to_str(), xl_xact_parsed_commit::twophase_xid, xl_xact_parsed_abort::twophase_xid, XLOG_XACT_ABORT, XLOG_XACT_ABORT_PREPARED, XLOG_XACT_COMMIT, XLOG_XACT_COMMIT_PREPARED, XLOG_XACT_OPMASK, XLogRecGetData, XLogRecGetInfo, XLogRecGetRmid, and XLogRecGetXid.

Referenced by PerformWalRecovery().

RemovePromoteSignalFiles()

void RemovePromoteSignalFiles

(

void

)

Definition at line 4454 of file xlogrecovery.c.

{
    unlink(PROMOTE_SIGNAL_FILE);
}

References PROMOTE_SIGNAL_FILE.

Referenced by CheckForStandbyTrigger(), and PostmasterMain().

rescanLatestTimeLine()

static bool rescanLatestTimeLine ( TimeLineID  replayTLI, XLogRecPtr  replayLSN  )

static

Definition at line 4104 of file xlogrecovery.c.

{
    List       *newExpectedTLEs;
    bool        found;
    ListCell   *cell;
    TimeLineID  newtarget;
    TimeLineID  oldtarget = recoveryTargetTLI;
    TimeLineHistoryEntry *currentTle = NULL;
 
    newtarget = findNewestTimeLine(recoveryTargetTLI);
    if (newtarget == recoveryTargetTLI)
    {
        /* No new timelines found */
        return false;
    }
 
    /*
     * Determine the list of expected TLIs for the new TLI
     */
 
    newExpectedTLEs = readTimeLineHistory(newtarget);
 
    /*
     * If the current timeline is not part of the history of the new timeline,
     * we cannot proceed to it.
     */
    found = false;
    foreach(cell, newExpectedTLEs)
    {
        currentTle = (TimeLineHistoryEntry *) lfirst(cell);
 
        if (currentTle->tli == recoveryTargetTLI)
        {
            found = true;
            break;
        }
    }
    if (!found)
    {
        ereport(LOG,
                (errmsg("new timeline %u is not a child of database system timeline %u",
                        newtarget,
                        replayTLI)));
        return false;
    }
 
    /*
     * The current timeline was found in the history file, but check that the
     * next timeline was forked off from it *after* the current recovery
     * location.
     */
    if (currentTle->end < replayLSN)
    {
        ereport(LOG,
                (errmsg("new timeline %u forked off current database system timeline %u before current recovery point %X/%X",
                        newtarget,
                        replayTLI,
                        LSN_FORMAT_ARGS(replayLSN))));
        return false;
    }
 
    /* The new timeline history seems valid. Switch target */
    recoveryTargetTLI = newtarget;
    list_free_deep(expectedTLEs);
    expectedTLEs = newExpectedTLEs;
 
    /*
     * As in StartupXLOG(), try to ensure we have all the history files
     * between the old target and new target in pg_wal.
     */
    restoreTimeLineHistoryFiles(oldtarget + 1, newtarget);
 
    ereport(LOG,
            (errmsg("new target timeline is %u",
                    recoveryTargetTLI)));
 
    return true;
}

References TimeLineHistoryEntry::end, ereport, errmsg(), expectedTLEs, findNewestTimeLine(), lfirst, list_free_deep(), LOG, LSN_FORMAT_ARGS, readTimeLineHistory(), recoveryTargetTLI, restoreTimeLineHistoryFiles(), and TimeLineHistoryEntry::tli.

Referenced by WaitForWALToBecomeAvailable().

rm_redo_error_callback()

static void rm_redo_error_callback ( void *  arg )

static

Definition at line 2275 of file xlogrecovery.c.

{
    XLogReaderState *record = (XLogReaderState *) arg;
    StringInfoData buf;
 
    initStringInfo(&buf);
    xlog_outdesc(&buf, record);
    xlog_block_info(&buf, record);
 
    /* translator: %s is a WAL record description */
    errcontext("WAL redo at %X/%X for %s",
               LSN_FORMAT_ARGS(record->ReadRecPtr),
               buf.data);
 
    pfree(buf.data);
}

References arg, buf, errcontext, initStringInfo(), LSN_FORMAT_ARGS, pfree(), XLogReaderState::ReadRecPtr, xlog_block_info(), and xlog_outdesc().

Referenced by ApplyWalRecord().

SetCurrentChunkStartTime()

static void SetCurrentChunkStartTime ( TimestampTz  xtime )

static

Definition at line 4614 of file xlogrecovery.c.

{
    SpinLockAcquire(&XLogRecoveryCtl->info_lck);
    XLogRecoveryCtl->currentChunkStartTime = xtime;
    SpinLockRelease(&XLogRecoveryCtl->info_lck);
}

References XLogRecoveryCtlData::currentChunkStartTime, XLogRecoveryCtlData::info_lck, SpinLockAcquire, SpinLockRelease, and XLogRecoveryCtl.

Referenced by WaitForWALToBecomeAvailable().

SetLatestXTime()

static void SetLatestXTime ( TimestampTz  xtime )

static

Definition at line 4585 of file xlogrecovery.c.

{
    SpinLockAcquire(&XLogRecoveryCtl->info_lck);
    XLogRecoveryCtl->recoveryLastXTime = xtime;
    SpinLockRelease(&XLogRecoveryCtl->info_lck);
}

References XLogRecoveryCtlData::info_lck, XLogRecoveryCtlData::recoveryLastXTime, SpinLockAcquire, SpinLockRelease, and XLogRecoveryCtl.

Referenced by recoveryStopsAfter().

SetPromoteIsTriggered()

static void SetPromoteIsTriggered ( void  )

static

Definition at line 4412 of file xlogrecovery.c.

{
    SpinLockAcquire(&XLogRecoveryCtl->info_lck);
    XLogRecoveryCtl->SharedPromoteIsTriggered = true;
    SpinLockRelease(&XLogRecoveryCtl->info_lck);
 
    /*
     * Mark the recovery pause state as 'not paused' because the paused state
     * ends and promotion continues if a promotion is triggered while recovery
     * is paused. Otherwise pg_get_wal_replay_pause_state() can mistakenly
     * return 'paused' while a promotion is ongoing.
     */
    SetRecoveryPause(false);
 
    LocalPromoteIsTriggered = true;
}

References XLogRecoveryCtlData::info_lck, LocalPromoteIsTriggered, SetRecoveryPause(), XLogRecoveryCtlData::SharedPromoteIsTriggered, SpinLockAcquire, SpinLockRelease, and XLogRecoveryCtl.

Referenced by CheckForStandbyTrigger().

SetRecoveryPause()

void SetRecoveryPause

(

bool

recoveryPause

)

Definition at line 3090 of file xlogrecovery.c.

{
    SpinLockAcquire(&XLogRecoveryCtl->info_lck);
 
    if (!recoveryPause)
        XLogRecoveryCtl->recoveryPauseState = RECOVERY_NOT_PAUSED;
    else if (XLogRecoveryCtl->recoveryPauseState == RECOVERY_NOT_PAUSED)
        XLogRecoveryCtl->recoveryPauseState = RECOVERY_PAUSE_REQUESTED;
 
    SpinLockRelease(&XLogRecoveryCtl->info_lck);
 
    if (!recoveryPause)
        ConditionVariableBroadcast(&XLogRecoveryCtl->recoveryNotPausedCV);
}

References ConditionVariableBroadcast(), XLogRecoveryCtlData::info_lck, RECOVERY_NOT_PAUSED, RECOVERY_PAUSE_REQUESTED, XLogRecoveryCtlData::recoveryNotPausedCV, XLogRecoveryCtlData::recoveryPauseState, SpinLockAcquire, SpinLockRelease, and XLogRecoveryCtl.

Referenced by PerformWalRecovery(), pg_wal_replay_pause(), pg_wal_replay_resume(), RecoveryRequiresIntParameter(), and SetPromoteIsTriggered().

ShutdownWalRecovery()

void ShutdownWalRecovery

(

void

)

Definition at line 1608 of file xlogrecovery.c.

{
    char        recoveryPath[MAXPGPATH];
 
    /* Final update of pg_stat_recovery_prefetch. */
    XLogPrefetcherComputeStats(xlogprefetcher);
 
    /* Shut down xlogreader */
    if (readFile >= 0)
    {
        close(readFile);
        readFile = -1;
    }
    XLogReaderFree(xlogreader);
    XLogPrefetcherFree(xlogprefetcher);
 
    if (ArchiveRecoveryRequested)
    {
        /*
         * Since there might be a partial WAL segment named RECOVERYXLOG, get
         * rid of it.
         */
        snprintf(recoveryPath, MAXPGPATH, XLOGDIR "/RECOVERYXLOG");
        unlink(recoveryPath);   /* ignore any error */
 
        /* Get rid of any remaining recovered timeline-history file, too */
        snprintf(recoveryPath, MAXPGPATH, XLOGDIR "/RECOVERYHISTORY");
        unlink(recoveryPath);   /* ignore any error */
    }
 
    /*
     * We don't need the latch anymore. It's not strictly necessary to disown
     * it, but let's do it for the sake of tidiness.
     */
    if (ArchiveRecoveryRequested)
        DisownLatch(&XLogRecoveryCtl->recoveryWakeupLatch);
}

References ArchiveRecoveryRequested, close, DisownLatch(), MAXPGPATH, readFile, XLogRecoveryCtlData::recoveryWakeupLatch, snprintf, XLOGDIR, xlogprefetcher, XLogPrefetcherComputeStats(), XLogPrefetcherFree(), xlogreader, XLogReaderFree(), and XLogRecoveryCtl.

Referenced by StartupXLOG().

StartupRequestWalReceiverRestart()

void StartupRequestWalReceiverRestart

(

void

)

Definition at line 4375 of file xlogrecovery.c.

{
    if (currentSource == XLOG_FROM_STREAM && WalRcvRunning())
    {
        ereport(LOG,
                (errmsg("WAL receiver process shutdown requested")));
 
        pendingWalRcvRestart = true;
    }
}

References currentSource, ereport, errmsg(), LOG, pendingWalRcvRestart, WalRcvRunning(), and XLOG_FROM_STREAM.

Referenced by StartupRereadConfig().

validateRecoveryParameters()

static void validateRecoveryParameters ( void  )

static

Definition at line 1109 of file xlogrecovery.c.

{
    if (!ArchiveRecoveryRequested)
        return;
 
    /*
     * Check for compulsory parameters
     */
    if (StandbyModeRequested)
    {
        if ((PrimaryConnInfo == NULL || strcmp(PrimaryConnInfo, "") == 0) &&
            (recoveryRestoreCommand == NULL || strcmp(recoveryRestoreCommand, "") == 0))
            ereport(WARNING,
                    (errmsg("specified neither primary_conninfo nor restore_command"),
                     errhint("The database server will regularly poll the pg_wal subdirectory to check for files placed there.")));
    }
    else
    {
        if (recoveryRestoreCommand == NULL ||
            strcmp(recoveryRestoreCommand, "") == 0)
            ereport(FATAL,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("must specify restore_command when standby mode is not enabled")));
    }
 
    /*
     * Override any inconsistent requests. Note that this is a change of
     * behaviour in 9.5; prior to this we simply ignored a request to pause if
     * hot_standby = off, which was surprising behaviour.
     */
    if (recoveryTargetAction == RECOVERY_TARGET_ACTION_PAUSE &&
        !EnableHotStandby)
        recoveryTargetAction = RECOVERY_TARGET_ACTION_SHUTDOWN;
 
    /*
     * Final parsing of recovery_target_time string; see also
     * check_recovery_target_time().
     */
    if (recoveryTarget == RECOVERY_TARGET_TIME)
    {
        recoveryTargetTime = DatumGetTimestampTz(DirectFunctionCall3(timestamptz_in,
                                                                     CStringGetDatum(recovery_target_time_string),
                                                                     ObjectIdGetDatum(InvalidOid),
                                                                     Int32GetDatum(-1)));
    }
 
    /*
     * If user specified recovery_target_timeline, validate it or compute the
     * "latest" value.  We can't do this until after we've gotten the restore
     * command and set InArchiveRecovery, because we need to fetch timeline
     * history files from the archive.
     */
    if (recoveryTargetTimeLineGoal == RECOVERY_TARGET_TIMELINE_NUMERIC)
    {
        TimeLineID  rtli = recoveryTargetTLIRequested;
 
        /* Timeline 1 does not have a history file, all else should */
        if (rtli != 1 && !existsTimeLineHistory(rtli))
            ereport(FATAL,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("recovery target timeline %u does not exist",
                            rtli)));
        recoveryTargetTLI = rtli;
    }
    else if (recoveryTargetTimeLineGoal == RECOVERY_TARGET_TIMELINE_LATEST)
    {
        /* We start the "latest" search from pg_control's timeline */
        recoveryTargetTLI = findNewestTimeLine(recoveryTargetTLI);
    }
    else
    {
        /*
         * else we just use the recoveryTargetTLI as already read from
         * ControlFile
         */
        Assert(recoveryTargetTimeLineGoal == RECOVERY_TARGET_TIMELINE_CONTROLFILE);
    }
}

References ArchiveRecoveryRequested, Assert, CStringGetDatum(), DatumGetTimestampTz(), DirectFunctionCall3, EnableHotStandby, ereport, errcode(), errhint(), errmsg(), existsTimeLineHistory(), FATAL, findNewestTimeLine(), Int32GetDatum(), InvalidOid, ObjectIdGetDatum(), PrimaryConnInfo, RECOVERY_TARGET_ACTION_PAUSE, RECOVERY_TARGET_ACTION_SHUTDOWN, RECOVERY_TARGET_TIME, recovery_target_time_string, RECOVERY_TARGET_TIMELINE_CONTROLFILE, RECOVERY_TARGET_TIMELINE_LATEST, RECOVERY_TARGET_TIMELINE_NUMERIC, recoveryRestoreCommand, recoveryTarget, recoveryTargetAction, recoveryTargetTime, recoveryTargetTimeLineGoal, recoveryTargetTLI, recoveryTargetTLIRequested, StandbyModeRequested, timestamptz_in(), and WARNING.

Referenced by InitWalRecovery().

verifyBackupPageConsistency()

static void verifyBackupPageConsistency ( XLogReaderState *  record )

static

Definition at line 2461 of file xlogrecovery.c.

{
    RmgrData    rmgr = GetRmgr(XLogRecGetRmid(record));
    RelFileLocator rlocator;
    ForkNumber  forknum;
    BlockNumber blkno;
    int         block_id;
 
    /* Records with no backup blocks have no need for consistency checks. */
    if (!XLogRecHasAnyBlockRefs(record))
        return;
 
    Assert((XLogRecGetInfo(record) & XLR_CHECK_CONSISTENCY) != 0);
 
    for (block_id = 0; block_id <= XLogRecMaxBlockId(record); block_id++)
    {
        Buffer      buf;
        Page        page;
 
        if (!XLogRecGetBlockTagExtended(record, block_id,
                                        &rlocator, &forknum, &blkno, NULL))
        {
            /*
             * WAL record doesn't contain a block reference with the given id.
             * Do nothing.
             */
            continue;
        }
 
        Assert(XLogRecHasBlockImage(record, block_id));
 
        if (XLogRecBlockImageApply(record, block_id))
        {
            /*
             * WAL record has already applied the page, so bypass the
             * consistency check as that would result in comparing the full
             * page stored in the record with itself.
             */
            continue;
        }
 
        /*
         * Read the contents from the current buffer and store it in a
         * temporary page.
         */
        buf = XLogReadBufferExtended(rlocator, forknum, blkno,
                                     RBM_NORMAL_NO_LOG,
                                     InvalidBuffer);
        if (!BufferIsValid(buf))
            continue;
 
        LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
        page = BufferGetPage(buf);
 
        /*
         * Take a copy of the local page where WAL has been applied to have a
         * comparison base before masking it...
         */
        memcpy(replay_image_masked, page, BLCKSZ);
 
        /* No need for this page anymore now that a copy is in. */
        UnlockReleaseBuffer(buf);
 
        /*
         * If the block LSN is already ahead of this WAL record, we can't
         * expect contents to match.  This can happen if recovery is
         * restarted.
         */
        if (PageGetLSN(replay_image_masked) > record->EndRecPtr)
            continue;
 
        /*
         * Read the contents from the backup copy, stored in WAL record and
         * store it in a temporary page. There is no need to allocate a new
         * page here, a local buffer is fine to hold its contents and a mask
         * can be directly applied on it.
         */
        if (!RestoreBlockImage(record, block_id, primary_image_masked))
            ereport(ERROR,
                    (errcode(ERRCODE_INTERNAL_ERROR),
                     errmsg_internal("%s", record->errormsg_buf)));
 
        /*
         * If masking function is defined, mask both the primary and replay
         * images
         */
        if (rmgr.rm_mask != NULL)
        {
            rmgr.rm_mask(replay_image_masked, blkno);
            rmgr.rm_mask(primary_image_masked, blkno);
        }
 
        /* Time to compare the primary and replay images. */
        if (memcmp(replay_image_masked, primary_image_masked, BLCKSZ) != 0)
        {
            elog(FATAL,
                 "inconsistent page found, rel %u/%u/%u, forknum %u, blkno %u",
                 rlocator.spcOid, rlocator.dbOid, rlocator.relNumber,
                 forknum, blkno);
        }
    }
}

References Assert, buf, BUFFER_LOCK_EXCLUSIVE, BufferGetPage(), BufferIsValid(), RelFileLocator::dbOid, elog, XLogReaderState::EndRecPtr, ereport, errcode(), errmsg_internal(), ERROR, XLogReaderState::errormsg_buf, FATAL, GetRmgr(), InvalidBuffer, LockBuffer(), PageGetLSN(), primary_image_masked, RBM_NORMAL_NO_LOG, RelFileLocator::relNumber, replay_image_masked, RestoreBlockImage(), RmgrData::rm_mask, RelFileLocator::spcOid, UnlockReleaseBuffer(), XLogReadBufferExtended(), XLogRecBlockImageApply, XLogRecGetBlockTagExtended(), XLogRecGetInfo, XLogRecGetRmid, XLogRecHasAnyBlockRefs, XLogRecHasBlockImage, XLogRecMaxBlockId, and XLR_CHECK_CONSISTENCY.

Referenced by ApplyWalRecord().

WaitForWALToBecomeAvailable()

static XLogPageReadResult WaitForWALToBecomeAvailable ( XLogRecPtr  RecPtr, bool  randAccess, bool  fetching_ckpt, XLogRecPtr  tliRecPtr, TimeLineID  replayTLI, XLogRecPtr  replayLSN, bool  nonblocking  )

static

Definition at line 3541 of file xlogrecovery.c.

{
    static TimestampTz last_fail_time = 0;
    TimestampTz now;
    bool        streaming_reply_sent = false;
 
    /*-------
     * Standby mode is implemented by a state machine:
     *
     * 1. Read from either archive or pg_wal (XLOG_FROM_ARCHIVE), or just
     *    pg_wal (XLOG_FROM_PG_WAL)
     * 2. Check for promotion trigger request
     * 3. Read from primary server via walreceiver (XLOG_FROM_STREAM)
     * 4. Rescan timelines
     * 5. Sleep wal_retrieve_retry_interval milliseconds, and loop back to 1.
     *
     * Failure to read from the current source advances the state machine to
     * the next state.
     *
     * 'currentSource' indicates the current state. There are no currentSource
     * values for "check trigger", "rescan timelines", and "sleep" states,
     * those actions are taken when reading from the previous source fails, as
     * part of advancing to the next state.
     *
     * If standby mode is turned off while reading WAL from stream, we move
     * to XLOG_FROM_ARCHIVE and reset lastSourceFailed, to force fetching
     * the files (which would be required at end of recovery, e.g., timeline
     * history file) from archive or pg_wal. We don't need to kill WAL receiver
     * here because it's already stopped when standby mode is turned off at
     * the end of recovery.
     *-------
     */
    if (!InArchiveRecovery)
        currentSource = XLOG_FROM_PG_WAL;
    else if (currentSource == XLOG_FROM_ANY ||
             (!StandbyMode && currentSource == XLOG_FROM_STREAM))
    {
        lastSourceFailed = false;
        currentSource = XLOG_FROM_ARCHIVE;
    }
 
    for (;;)
    {
        XLogSource  oldSource = currentSource;
        bool        startWalReceiver = false;
 
        /*
         * First check if we failed to read from the current source, and
         * advance the state machine if so. The failure to read might've
         * happened outside this function, e.g when a CRC check fails on a
         * record, or within this loop.
         */
        if (lastSourceFailed)
        {
            /*
             * Don't allow any retry loops to occur during nonblocking
             * readahead.  Let the caller process everything that has been
             * decoded already first.
             */
            if (nonblocking)
                return XLREAD_WOULDBLOCK;
 
            switch (currentSource)
            {
                case XLOG_FROM_ARCHIVE:
                case XLOG_FROM_PG_WAL:
 
                    /*
                     * Check to see if promotion is requested. Note that we do
                     * this only after failure, so when you promote, we still
                     * finish replaying as much as we can from archive and
                     * pg_wal before failover.
                     */
                    if (StandbyMode && CheckForStandbyTrigger())
                    {
                        XLogShutdownWalRcv();
                        return XLREAD_FAIL;
                    }
 
                    /*
                     * Not in standby mode, and we've now tried the archive
                     * and pg_wal.
                     */
                    if (!StandbyMode)
                        return XLREAD_FAIL;
 
                    /*
                     * Move to XLOG_FROM_STREAM state, and set to start a
                     * walreceiver if necessary.
                     */
                    currentSource = XLOG_FROM_STREAM;
                    startWalReceiver = true;
                    break;
 
                case XLOG_FROM_STREAM:
 
                    /*
                     * Failure while streaming. Most likely, we got here
                     * because streaming replication was terminated, or
                     * promotion was triggered. But we also get here if we
                     * find an invalid record in the WAL streamed from the
                     * primary, in which case something is seriously wrong.
                     * There's little chance that the problem will just go
                     * away, but PANIC is not good for availability either,
                     * especially in hot standby mode. So, we treat that the
                     * same as disconnection, and retry from archive/pg_wal
                     * again. The WAL in the archive should be identical to
                     * what was streamed, so it's unlikely that it helps, but
                     * one can hope...
                     */
 
                    /*
                     * We should be able to move to XLOG_FROM_STREAM only in
                     * standby mode.
                     */
                    Assert(StandbyMode);
 
                    /*
                     * Before we leave XLOG_FROM_STREAM state, make sure that
                     * walreceiver is not active, so that it won't overwrite
                     * WAL that we restore from archive.
                     */
                    XLogShutdownWalRcv();
 
                    /*
                     * Before we sleep, re-scan for possible new timelines if
                     * we were requested to recover to the latest timeline.
                     */
                    if (recoveryTargetTimeLineGoal == RECOVERY_TARGET_TIMELINE_LATEST)
                    {
                        if (rescanLatestTimeLine(replayTLI, replayLSN))
                        {
                            currentSource = XLOG_FROM_ARCHIVE;
                            break;
                        }
                    }
 
                    /*
                     * XLOG_FROM_STREAM is the last state in our state
                     * machine, so we've exhausted all the options for
                     * obtaining the requested WAL. We're going to loop back
                     * and retry from the archive, but if it hasn't been long
                     * since last attempt, sleep wal_retrieve_retry_interval
                     * milliseconds to avoid busy-waiting.
                     */
                    now = GetCurrentTimestamp();
                    if (!TimestampDifferenceExceeds(last_fail_time, now,
                                                    wal_retrieve_retry_interval))
                    {
                        long        wait_time;
 
                        wait_time = wal_retrieve_retry_interval -
                            TimestampDifferenceMilliseconds(last_fail_time, now);
 
                        elog(LOG, "waiting for WAL to become available at %X/%X",
                             LSN_FORMAT_ARGS(RecPtr));
 
                        /* Do background tasks that might benefit us later. */
                        KnownAssignedTransactionIdsIdleMaintenance();
 
                        (void) WaitLatch(&XLogRecoveryCtl->recoveryWakeupLatch,
                                         WL_LATCH_SET | WL_TIMEOUT |
                                         WL_EXIT_ON_PM_DEATH,
                                         wait_time,
                                         WAIT_EVENT_RECOVERY_RETRIEVE_RETRY_INTERVAL);
                        ResetLatch(&XLogRecoveryCtl->recoveryWakeupLatch);
                        now = GetCurrentTimestamp();
 
                        /* Handle interrupt signals of startup process */
                        HandleStartupProcInterrupts();
                    }
                    last_fail_time = now;
                    currentSource = XLOG_FROM_ARCHIVE;
                    break;
 
                default:
                    elog(ERROR, "unexpected WAL source %d", currentSource);
            }
        }
        else if (currentSource == XLOG_FROM_PG_WAL)
        {
            /*
             * We just successfully read a file in pg_wal. We prefer files in
             * the archive over ones in pg_wal, so try the next file again
             * from the archive first.
             */
            if (InArchiveRecovery)
                currentSource = XLOG_FROM_ARCHIVE;
        }
 
        if (currentSource != oldSource)
            elog(DEBUG2, "switched WAL source from %s to %s after %s",
                 xlogSourceNames[oldSource], xlogSourceNames[currentSource],
                 lastSourceFailed ? "failure" : "success");
 
        /*
         * We've now handled possible failure. Try to read from the chosen
         * source.
         */
        lastSourceFailed = false;
 
        switch (currentSource)
        {
            case XLOG_FROM_ARCHIVE:
            case XLOG_FROM_PG_WAL:
 
                /*
                 * WAL receiver must not be running when reading WAL from
                 * archive or pg_wal.
                 */
                Assert(!WalRcvStreaming());
 
                /* Close any old file we might have open. */
                if (readFile >= 0)
                {
                    close(readFile);
                    readFile = -1;
                }
                /* Reset curFileTLI if random fetch. */
                if (randAccess)
                    curFileTLI = 0;
 
                /*
                 * Try to restore the file from archive, or read an existing
                 * file from pg_wal.
                 */
                readFile = XLogFileReadAnyTLI(readSegNo, DEBUG2,
                                              currentSource == XLOG_FROM_ARCHIVE ? XLOG_FROM_ANY :
                                              currentSource);
                if (readFile >= 0)
                    return XLREAD_SUCCESS;  /* success! */
 
                /*
                 * Nope, not found in archive or pg_wal.
                 */
                lastSourceFailed = true;
                break;
 
            case XLOG_FROM_STREAM:
                {
                    bool        havedata;
 
                    /*
                     * We should be able to move to XLOG_FROM_STREAM only in
                     * standby mode.
                     */
                    Assert(StandbyMode);
 
                    /*
                     * First, shutdown walreceiver if its restart has been
                     * requested -- but no point if we're already slated for
                     * starting it.
                     */
                    if (pendingWalRcvRestart && !startWalReceiver)
                    {
                        XLogShutdownWalRcv();
 
                        /*
                         * Re-scan for possible new timelines if we were
                         * requested to recover to the latest timeline.
                         */
                        if (recoveryTargetTimeLineGoal ==
                            RECOVERY_TARGET_TIMELINE_LATEST)
                            rescanLatestTimeLine(replayTLI, replayLSN);
 
                        startWalReceiver = true;
                    }
                    pendingWalRcvRestart = false;
 
                    /*
                     * Launch walreceiver if needed.
                     *
                     * If fetching_ckpt is true, RecPtr points to the initial
                     * checkpoint location. In that case, we use RedoStartLSN
                     * as the streaming start position instead of RecPtr, so
                     * that when we later jump backwards to start redo at
                     * RedoStartLSN, we will have the logs streamed already.
                     */
                    if (startWalReceiver &&
                        PrimaryConnInfo && strcmp(PrimaryConnInfo, "") != 0)
                    {
                        XLogRecPtr  ptr;
                        TimeLineID  tli;
 
                        if (fetching_ckpt)
                        {
                            ptr = RedoStartLSN;
                            tli = RedoStartTLI;
                        }
                        else
                        {
                            ptr = RecPtr;
 
                            /*
                             * Use the record begin position to determine the
                             * TLI, rather than the position we're reading.
                             */
                            tli = tliOfPointInHistory(tliRecPtr, expectedTLEs);
 
                            if (curFileTLI > 0 && tli < curFileTLI)
                                elog(ERROR, "according to history file, WAL location %X/%X belongs to timeline %u, but previous recovered WAL file came from timeline %u",
                                     LSN_FORMAT_ARGS(tliRecPtr),
                                     tli, curFileTLI);
                        }
                        curFileTLI = tli;
                        SetInstallXLogFileSegmentActive();
                        RequestXLogStreaming(tli, ptr, PrimaryConnInfo,
                                             PrimarySlotName,
                                             wal_receiver_create_temp_slot);
                        flushedUpto = 0;
                    }
 
                    /*
                     * Check if WAL receiver is active or wait to start up.
                     */
                    if (!WalRcvStreaming())
                    {
                        lastSourceFailed = true;
                        break;
                    }
 
                    /*
                     * Walreceiver is active, so see if new data has arrived.
                     *
                     * We only advance XLogReceiptTime when we obtain fresh
                     * WAL from walreceiver and observe that we had already
                     * processed everything before the most recent "chunk"
                     * that it flushed to disk.  In steady state where we are
                     * keeping up with the incoming data, XLogReceiptTime will
                     * be updated on each cycle. When we are behind,
                     * XLogReceiptTime will not advance, so the grace time
                     * allotted to conflicting queries will decrease.
                     */
                    if (RecPtr < flushedUpto)
                        havedata = true;
                    else
                    {
                        XLogRecPtr  latestChunkStart;
 
                        flushedUpto = GetWalRcvFlushRecPtr(&latestChunkStart, &receiveTLI);
                        if (RecPtr < flushedUpto && receiveTLI == curFileTLI)
                        {
                            havedata = true;
                            if (latestChunkStart <= RecPtr)
                            {
                                XLogReceiptTime = GetCurrentTimestamp();
                                SetCurrentChunkStartTime(XLogReceiptTime);
                            }
                        }
                        else
                            havedata = false;
                    }
                    if (havedata)
                    {
                        /*
                         * Great, streamed far enough.  Open the file if it's
                         * not open already.  Also read the timeline history
                         * file if we haven't initialized timeline history
                         * yet; it should be streamed over and present in
                         * pg_wal by now.  Use XLOG_FROM_STREAM so that source
                         * info is set correctly and XLogReceiptTime isn't
                         * changed.
                         *
                         * NB: We must set readTimeLineHistory based on
                         * recoveryTargetTLI, not receiveTLI. Normally they'll
                         * be the same, but if recovery_target_timeline is
                         * 'latest' and archiving is configured, then it's
                         * possible that we managed to retrieve one or more
                         * new timeline history files from the archive,
                         * updating recoveryTargetTLI.
                         */
                        if (readFile < 0)
                        {
                            if (!expectedTLEs)
                                expectedTLEs = readTimeLineHistory(recoveryTargetTLI);
                            readFile = XLogFileRead(readSegNo, PANIC,
                                                    receiveTLI,
                                                    XLOG_FROM_STREAM, false);
                            Assert(readFile >= 0);
                        }
                        else
                        {
                            /* just make sure source info is correct... */
                            readSource = XLOG_FROM_STREAM;
                            XLogReceiptSource = XLOG_FROM_STREAM;
                            return XLREAD_SUCCESS;
                        }
                        break;
                    }
 
                    /* In nonblocking mode, return rather than sleeping. */
                    if (nonblocking)
                        return XLREAD_WOULDBLOCK;
 
                    /*
                     * Data not here yet. Check for trigger, then wait for
                     * walreceiver to wake us up when new WAL arrives.
                     */
                    if (CheckForStandbyTrigger())
                    {
                        /*
                         * Note that we don't return XLREAD_FAIL immediately
                         * here. After being triggered, we still want to
                         * replay all the WAL that was already streamed. It's
                         * in pg_wal now, so we just treat this as a failure,
                         * and the state machine will move on to replay the
                         * streamed WAL from pg_wal, and then recheck the
                         * trigger and exit replay.
                         */
                        lastSourceFailed = true;
                        break;
                    }
 
                    /*
                     * Since we have replayed everything we have received so
                     * far and are about to start waiting for more WAL, let's
                     * tell the upstream server our replay location now so
                     * that pg_stat_replication doesn't show stale
                     * information.
                     */
                    if (!streaming_reply_sent)
                    {
                        WalRcvForceReply();
                        streaming_reply_sent = true;
                    }
 
                    /* Do any background tasks that might benefit us later. */
                    KnownAssignedTransactionIdsIdleMaintenance();
 
                    /* Update pg_stat_recovery_prefetch before sleeping. */
                    XLogPrefetcherComputeStats(xlogprefetcher);
 
                    /*
                     * Wait for more WAL to arrive, when we will be woken
                     * immediately by the WAL receiver.
                     */
                    (void) WaitLatch(&XLogRecoveryCtl->recoveryWakeupLatch,
                                     WL_LATCH_SET | WL_EXIT_ON_PM_DEATH,
                                     -1L,
                                     WAIT_EVENT_RECOVERY_WAL_STREAM);
                    ResetLatch(&XLogRecoveryCtl->recoveryWakeupLatch);
                    break;
                }
 
            default:
                elog(ERROR, "unexpected WAL source %d", currentSource);
        }
 
        /*
         * Check for recovery pause here so that we can confirm more quickly
         * that a requested pause has actually taken effect.
         */
        if (((volatile XLogRecoveryCtlData *) XLogRecoveryCtl)->recoveryPauseState !=
            RECOVERY_NOT_PAUSED)
            recoveryPausesHere(false);
 
        /*
         * This possibly-long loop needs to handle interrupts of startup
         * process.
         */
        HandleStartupProcInterrupts();
    }
 
    return XLREAD_FAIL;         /* not reached */
}

References Assert, CheckForStandbyTrigger(), close, curFileTLI, currentSource, DEBUG2, elog, ERROR, expectedTLEs, flushedUpto, GetCurrentTimestamp(), GetWalRcvFlushRecPtr(), HandleStartupProcInterrupts(), InArchiveRecovery, KnownAssignedTransactionIdsIdleMaintenance(), lastSourceFailed, LOG, LSN_FORMAT_ARGS, now(), PANIC, pendingWalRcvRestart, PrimaryConnInfo, PrimarySlotName, readFile, readSegNo, readSource, readTimeLineHistory(), receiveTLI, RECOVERY_NOT_PAUSED, RECOVERY_TARGET_TIMELINE_LATEST, recoveryPausesHere(), recoveryTargetTimeLineGoal, recoveryTargetTLI, XLogRecoveryCtlData::recoveryWakeupLatch, RedoStartLSN, RedoStartTLI, RequestXLogStreaming(), rescanLatestTimeLine(), ResetLatch(), SetCurrentChunkStartTime(), SetInstallXLogFileSegmentActive(), StandbyMode, TimestampDifferenceExceeds(), TimestampDifferenceMilliseconds(), tliOfPointInHistory(), WaitLatch(), wal_receiver_create_temp_slot, wal_retrieve_retry_interval, WalRcvForceReply(), WalRcvStreaming(), WL_EXIT_ON_PM_DEATH, WL_LATCH_SET, WL_TIMEOUT, XLOG_FROM_ANY, XLOG_FROM_ARCHIVE, XLOG_FROM_PG_WAL, XLOG_FROM_STREAM, XLogFileRead(), XLogFileReadAnyTLI(), xlogprefetcher, XLogPrefetcherComputeStats(), XLogReceiptSource, XLogReceiptTime, XLogRecoveryCtl, XLogShutdownWalRcv(), xlogSourceNames, XLREAD_FAIL, XLREAD_SUCCESS, and XLREAD_WOULDBLOCK.

Referenced by XLogPageRead().

WakeupRecovery()

void WakeupRecovery

(

void

)

Definition at line 4478 of file xlogrecovery.c.

{
    SetLatch(&XLogRecoveryCtl->recoveryWakeupLatch);
}

References XLogRecoveryCtlData::recoveryWakeupLatch, SetLatch(), and XLogRecoveryCtl.

Referenced by pg_wal_replay_pause(), StartupProcShutdownHandler(), StartupProcSigHupHandler(), StartupProcTriggerHandler(), WalRcvDie(), WalRcvWaitForStartPosition(), and XLogWalRcvFlush().

xlog_block_info()

static void xlog_block_info ( StringInfo  buf, XLogReaderState *  record  )

static

Definition at line 2336 of file xlogrecovery.c.

{
    int         block_id;
 
    /* decode block references */
    for (block_id = 0; block_id <= XLogRecMaxBlockId(record); block_id++)
    {
        RelFileLocator rlocator;
        ForkNumber  forknum;
        BlockNumber blk;
 
        if (!XLogRecGetBlockTagExtended(record, block_id,
                                        &rlocator, &forknum, &blk, NULL))
            continue;
 
        if (forknum != MAIN_FORKNUM)
            appendStringInfo(buf, "; blkref #%d: rel %u/%u/%u, fork %u, blk %u",
                             block_id,
                             rlocator.spcOid, rlocator.dbOid,
                             rlocator.relNumber,
                             forknum,
                             blk);
        else
            appendStringInfo(buf, "; blkref #%d: rel %u/%u/%u, blk %u",
                             block_id,
                             rlocator.spcOid, rlocator.dbOid,
                             rlocator.relNumber,
                             blk);
        if (XLogRecHasBlockImage(record, block_id))
            appendStringInfoString(buf, " FPW");
    }
}

References appendStringInfo(), appendStringInfoString(), buf, RelFileLocator::dbOid, MAIN_FORKNUM, RelFileLocator::relNumber, RelFileLocator::spcOid, XLogRecGetBlockTagExtended(), XLogRecHasBlockImage, and XLogRecMaxBlockId.

Referenced by rm_redo_error_callback().

xlog_outdesc()

void xlog_outdesc	(	StringInfo	buf,
		XLogReaderState *	record
	)

Definition at line 2297 of file xlogrecovery.c.

{
    RmgrData    rmgr = GetRmgr(XLogRecGetRmid(record));
    uint8       info = XLogRecGetInfo(record);
    const char *id;
 
    appendStringInfoString(buf, rmgr.rm_name);
    appendStringInfoChar(buf, '/');
 
    id = rmgr.rm_identify(info);
    if (id == NULL)
        appendStringInfo(buf, "UNKNOWN (%X): ", info & ~XLR_INFO_MASK);
    else
        appendStringInfo(buf, "%s: ", id);
 
    rmgr.rm_desc(buf, record);
}

References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), buf, GetRmgr(), RmgrData::rm_desc, RmgrData::rm_identify, RmgrData::rm_name, XLogRecGetInfo, XLogRecGetRmid, and XLR_INFO_MASK.

Referenced by PerformWalRecovery(), rm_redo_error_callback(), and XLogInsertRecord().

XLogFileRead()

static int XLogFileRead ( XLogSegNo  segno, int  emode, TimeLineID  tli, XLogSource  source, bool  notfoundOk  )

static

Definition at line 4191 of file xlogrecovery.c.

{
    char        xlogfname[MAXFNAMELEN];
    char        activitymsg[MAXFNAMELEN + 16];
    char        path[MAXPGPATH];
    int         fd;
 
    XLogFileName(xlogfname, tli, segno, wal_segment_size);
 
    switch (source)
    {
        case XLOG_FROM_ARCHIVE:
            /* Report recovery progress in PS display */
            snprintf(activitymsg, sizeof(activitymsg), "waiting for %s",
                     xlogfname);
            set_ps_display(activitymsg);
 
            if (!RestoreArchivedFile(path, xlogfname,
                                     "RECOVERYXLOG",
                                     wal_segment_size,
                                     InRedo))
                return -1;
            break;
 
        case XLOG_FROM_PG_WAL:
        case XLOG_FROM_STREAM:
            XLogFilePath(path, tli, segno, wal_segment_size);
            break;
 
        default:
            elog(ERROR, "invalid XLogFileRead source %d", source);
    }
 
    /*
     * If the segment was fetched from archival storage, replace the existing
     * xlog segment (if any) with the archival version.
     */
    if (source == XLOG_FROM_ARCHIVE)
    {
        Assert(!IsInstallXLogFileSegmentActive());
        KeepFileRestoredFromArchive(path, xlogfname);
 
        /*
         * Set path to point at the new file in pg_wal.
         */
        snprintf(path, MAXPGPATH, XLOGDIR "/%s", xlogfname);
    }
 
    fd = BasicOpenFile(path, O_RDONLY | PG_BINARY);
    if (fd >= 0)
    {
        /* Success! */
        curFileTLI = tli;
 
        /* Report recovery progress in PS display */
        snprintf(activitymsg, sizeof(activitymsg), "recovering %s",
                 xlogfname);
        set_ps_display(activitymsg);
 
        /* Track source of data in assorted state variables */
        readSource = source;
        XLogReceiptSource = source;
        /* In FROM_STREAM case, caller tracks receipt time, not me */
        if (source != XLOG_FROM_STREAM)
            XLogReceiptTime = GetCurrentTimestamp();
 
        return fd;
    }
    if (errno != ENOENT || !notfoundOk) /* unexpected failure? */
        ereport(PANIC,
                (errcode_for_file_access(),
                 errmsg("could not open file \"%s\": %m", path)));
    return -1;
}

References Assert, BasicOpenFile(), curFileTLI, elog, ereport, errcode_for_file_access(), errmsg(), ERROR, fd(), GetCurrentTimestamp(), InRedo, IsInstallXLogFileSegmentActive(), KeepFileRestoredFromArchive(), MAXFNAMELEN, MAXPGPATH, PANIC, PG_BINARY, readSource, RestoreArchivedFile(), set_ps_display(), snprintf, source, wal_segment_size, XLOG_FROM_ARCHIVE, XLOG_FROM_PG_WAL, XLOG_FROM_STREAM, XLOGDIR, XLogFileName(), XLogFilePath(), XLogReceiptSource, and XLogReceiptTime.

Referenced by WaitForWALToBecomeAvailable(), and XLogFileReadAnyTLI().

XLogFileReadAnyTLI()

static int XLogFileReadAnyTLI ( XLogSegNo  segno, int  emode, XLogSource  source  )

static

Definition at line 4273 of file xlogrecovery.c.

{
    char        path[MAXPGPATH];
    ListCell   *cell;
    int         fd;
    List       *tles;
 
    /*
     * Loop looking for a suitable timeline ID: we might need to read any of
     * the timelines listed in expectedTLEs.
     *
     * We expect curFileTLI on entry to be the TLI of the preceding file in
     * sequence, or 0 if there was no predecessor.  We do not allow curFileTLI
     * to go backwards; this prevents us from picking up the wrong file when a
     * parent timeline extends to higher segment numbers than the child we
     * want to read.
     *
     * If we haven't read the timeline history file yet, read it now, so that
     * we know which TLIs to scan.  We don't save the list in expectedTLEs,
     * however, unless we actually find a valid segment.  That way if there is
     * neither a timeline history file nor a WAL segment in the archive, and
     * streaming replication is set up, we'll read the timeline history file
     * streamed from the primary when we start streaming, instead of
     * recovering with a dummy history generated here.
     */
    if (expectedTLEs)
        tles = expectedTLEs;
    else
        tles = readTimeLineHistory(recoveryTargetTLI);
 
    foreach(cell, tles)
    {
        TimeLineHistoryEntry *hent = (TimeLineHistoryEntry *) lfirst(cell);
        TimeLineID  tli = hent->tli;
 
        if (tli < curFileTLI)
            break;              /* don't bother looking at too-old TLIs */
 
        /*
         * Skip scanning the timeline ID that the logfile segment to read
         * doesn't belong to
         */
        if (hent->begin != InvalidXLogRecPtr)
        {
            XLogSegNo   beginseg = 0;
 
            XLByteToSeg(hent->begin, beginseg, wal_segment_size);
 
            /*
             * The logfile segment that doesn't belong to the timeline is
             * older or newer than the segment that the timeline started or
             * ended at, respectively. It's sufficient to check only the
             * starting segment of the timeline here. Since the timelines are
             * scanned in descending order in this loop, any segments newer
             * than the ending segment should belong to newer timeline and
             * have already been read before. So it's not necessary to check
             * the ending segment of the timeline here.
             */
            if (segno < beginseg)
                continue;
        }
 
        if (source == XLOG_FROM_ANY || source == XLOG_FROM_ARCHIVE)
        {
            fd = XLogFileRead(segno, emode, tli,
                              XLOG_FROM_ARCHIVE, true);
            if (fd != -1)
            {
                elog(DEBUG1, "got WAL segment from archive");
                if (!expectedTLEs)
                    expectedTLEs = tles;
                return fd;
            }
        }
 
        if (source == XLOG_FROM_ANY || source == XLOG_FROM_PG_WAL)
        {
            fd = XLogFileRead(segno, emode, tli,
                              XLOG_FROM_PG_WAL, true);
            if (fd != -1)
            {
                if (!expectedTLEs)
                    expectedTLEs = tles;
                return fd;
            }
        }
    }
 
    /* Couldn't find it.  For simplicity, complain about front timeline */
    XLogFilePath(path, recoveryTargetTLI, segno, wal_segment_size);
    errno = ENOENT;
    ereport(emode,
            (errcode_for_file_access(),
             errmsg("could not open file \"%s\": %m", path)));
    return -1;
}

References TimeLineHistoryEntry::begin, curFileTLI, DEBUG1, elog, ereport, errcode_for_file_access(), errmsg(), expectedTLEs, fd(), InvalidXLogRecPtr, lfirst, MAXPGPATH, readTimeLineHistory(), recoveryTargetTLI, source, TimeLineHistoryEntry::tli, wal_segment_size, XLByteToSeg, XLOG_FROM_ANY, XLOG_FROM_ARCHIVE, XLOG_FROM_PG_WAL, XLogFilePath(), and XLogFileRead().

Referenced by WaitForWALToBecomeAvailable().

XLogPageRead()

static int XLogPageRead ( XLogReaderState *  xlogreader, XLogRecPtr  targetPagePtr, int  reqLen, XLogRecPtr  targetRecPtr, char *  readBuf  )

static

Definition at line 3298 of file xlogrecovery.c.

{
    XLogPageReadPrivate *private =
        (XLogPageReadPrivate *) xlogreader->private_data;
    int         emode = private->emode;
    uint32      targetPageOff;
    XLogSegNo   targetSegNo PG_USED_FOR_ASSERTS_ONLY;
    int         r;
 
    XLByteToSeg(targetPagePtr, targetSegNo, wal_segment_size);
    targetPageOff = XLogSegmentOffset(targetPagePtr, wal_segment_size);
 
    /*
     * See if we need to switch to a new segment because the requested record
     * is not in the currently open one.
     */
    if (readFile >= 0 &&
        !XLByteInSeg(targetPagePtr, readSegNo, wal_segment_size))
    {
        /*
         * Request a restartpoint if we've replayed too much xlog since the
         * last one.
         */
        if (ArchiveRecoveryRequested && IsUnderPostmaster)
        {
            if (XLogCheckpointNeeded(readSegNo))
            {
                (void) GetRedoRecPtr();
                if (XLogCheckpointNeeded(readSegNo))
                    RequestCheckpoint(CHECKPOINT_CAUSE_XLOG);
            }
        }
 
        close(readFile);
        readFile = -1;
        readSource = XLOG_FROM_ANY;
    }
 
    XLByteToSeg(targetPagePtr, readSegNo, wal_segment_size);
 
retry:
    /* See if we need to retrieve more data */
    if (readFile < 0 ||
        (readSource == XLOG_FROM_STREAM &&
         flushedUpto < targetPagePtr + reqLen))
    {
        if (readFile >= 0 &&
            xlogreader->nonblocking &&
            readSource == XLOG_FROM_STREAM &&
            flushedUpto < targetPagePtr + reqLen)
            return XLREAD_WOULDBLOCK;
 
        switch (WaitForWALToBecomeAvailable(targetPagePtr + reqLen,
                                            private->randAccess,
                                            private->fetching_ckpt,
                                            targetRecPtr,
                                            private->replayTLI,
                                            xlogreader->EndRecPtr,
                                            xlogreader->nonblocking))
        {
            case XLREAD_WOULDBLOCK:
                return XLREAD_WOULDBLOCK;
            case XLREAD_FAIL:
                if (readFile >= 0)
                    close(readFile);
                readFile = -1;
                readLen = 0;
                readSource = XLOG_FROM_ANY;
                return XLREAD_FAIL;
            case XLREAD_SUCCESS:
                break;
        }
    }
 
    /*
     * At this point, we have the right segment open and if we're streaming we
     * know the requested record is in it.
     */
    Assert(readFile != -1);
 
    /*
     * If the current segment is being streamed from the primary, calculate
     * how much of the current page we have received already. We know the
     * requested record has been received, but this is for the benefit of
     * future calls, to allow quick exit at the top of this function.
     */
    if (readSource == XLOG_FROM_STREAM)
    {
        if (((targetPagePtr) / XLOG_BLCKSZ) != (flushedUpto / XLOG_BLCKSZ))
            readLen = XLOG_BLCKSZ;
        else
            readLen = XLogSegmentOffset(flushedUpto, wal_segment_size) -
                targetPageOff;
    }
    else
        readLen = XLOG_BLCKSZ;
 
    /* Read the requested page */
    readOff = targetPageOff;
 
    pgstat_report_wait_start(WAIT_EVENT_WAL_READ);
    r = pg_pread(readFile, readBuf, XLOG_BLCKSZ, (off_t) readOff);
    if (r != XLOG_BLCKSZ)
    {
        char        fname[MAXFNAMELEN];
        int         save_errno = errno;
 
        pgstat_report_wait_end();
        XLogFileName(fname, curFileTLI, readSegNo, wal_segment_size);
        if (r < 0)
        {
            errno = save_errno;
            ereport(emode_for_corrupt_record(emode, targetPagePtr + reqLen),
                    (errcode_for_file_access(),
                     errmsg("could not read from WAL segment %s, LSN %X/%X, offset %u: %m",
                            fname, LSN_FORMAT_ARGS(targetPagePtr),
                            readOff)));
        }
        else
            ereport(emode_for_corrupt_record(emode, targetPagePtr + reqLen),
                    (errcode(ERRCODE_DATA_CORRUPTED),
                     errmsg("could not read from WAL segment %s, LSN %X/%X, offset %u: read %d of %zu",
                            fname, LSN_FORMAT_ARGS(targetPagePtr),
                            readOff, r, (Size) XLOG_BLCKSZ)));
        goto next_record_is_invalid;
    }
    pgstat_report_wait_end();
 
    Assert(targetSegNo == readSegNo);
    Assert(targetPageOff == readOff);
    Assert(reqLen <= readLen);
 
    xlogreader->seg.ws_tli = curFileTLI;
 
    /*
     * Check the page header immediately, so that we can retry immediately if
     * it's not valid. This may seem unnecessary, because ReadPageInternal()
     * validates the page header anyway, and would propagate the failure up to
     * ReadRecord(), which would retry. However, there's a corner case with
     * continuation records, if a record is split across two pages such that
     * we would need to read the two pages from different sources. For
     * example, imagine a scenario where a streaming replica is started up,
     * and replay reaches a record that's split across two WAL segments. The
     * first page is only available locally, in pg_wal, because it's already
     * been recycled on the primary. The second page, however, is not present
     * in pg_wal, and we should stream it from the primary. There is a
     * recycled WAL segment present in pg_wal, with garbage contents, however.
     * We would read the first page from the local WAL segment, but when
     * reading the second page, we would read the bogus, recycled, WAL
     * segment. If we didn't catch that case here, we would never recover,
     * because ReadRecord() would retry reading the whole record from the
     * beginning.
     *
     * Of course, this only catches errors in the page header, which is what
     * happens in the case of a recycled WAL segment. Other kinds of errors or
     * corruption still has the same problem. But this at least fixes the
     * common case, which can happen as part of normal operation.
     *
     * Validating the page header is cheap enough that doing it twice
     * shouldn't be a big deal from a performance point of view.
     *
     * When not in standby mode, an invalid page header should cause recovery
     * to end, not retry reading the page, so we don't need to validate the
     * page header here for the retry. Instead, ReadPageInternal() is
     * responsible for the validation.
     */
    if (StandbyMode &&
        !XLogReaderValidatePageHeader(xlogreader, targetPagePtr, readBuf))
    {
        /*
         * Emit this error right now then retry this page immediately. Use
         * errmsg_internal() because the message was already translated.
         */
        if (xlogreader->errormsg_buf[0])
            ereport(emode_for_corrupt_record(emode, xlogreader->EndRecPtr),
                    (errmsg_internal("%s", xlogreader->errormsg_buf)));
 
        /* reset any error XLogReaderValidatePageHeader() might have set */
        XLogReaderResetError(xlogreader);
        goto next_record_is_invalid;
    }
 
    return readLen;
 
next_record_is_invalid:
 
    /*
     * If we're reading ahead, give up fast.  Retries and error reporting will
     * be handled by a later read when recovery catches up to this point.
     */
    if (xlogreader->nonblocking)
        return XLREAD_WOULDBLOCK;
 
    lastSourceFailed = true;
 
    if (readFile >= 0)
        close(readFile);
    readFile = -1;
    readLen = 0;
    readSource = XLOG_FROM_ANY;
 
    /* In standby-mode, keep trying */
    if (StandbyMode)
        goto retry;
    else
        return XLREAD_FAIL;
}

References ArchiveRecoveryRequested, Assert, CHECKPOINT_CAUSE_XLOG, close, curFileTLI, emode_for_corrupt_record(), XLogReaderState::EndRecPtr, ereport, errcode(), ERRCODE_DATA_CORRUPTED, errcode_for_file_access(), errmsg(), errmsg_internal(), XLogReaderState::errormsg_buf, flushedUpto, GetRedoRecPtr(), IsUnderPostmaster, lastSourceFailed, LSN_FORMAT_ARGS, MAXFNAMELEN, XLogReaderState::nonblocking, pg_pread, PG_USED_FOR_ASSERTS_ONLY, pgstat_report_wait_end(), pgstat_report_wait_start(), XLogReaderState::private_data, readFile, readLen, readOff, readSegNo, readSource, RequestCheckpoint(), XLogReaderState::seg, StandbyMode, WaitForWALToBecomeAvailable(), wal_segment_size, WALOpenSegment::ws_tli, XLByteInSeg, XLByteToSeg, XLOG_FROM_ANY, XLOG_FROM_STREAM, XLogCheckpointNeeded(), XLogFileName(), xlogreader, XLogReaderResetError(), XLogReaderValidatePageHeader(), XLogSegmentOffset, XLREAD_FAIL, XLREAD_SUCCESS, and XLREAD_WOULDBLOCK.

Referenced by InitWalRecovery().

xlogrecovery_redo()

static void xlogrecovery_redo ( XLogReaderState *  record, TimeLineID  replayTLI  )

static

Definition at line 2072 of file xlogrecovery.c.

{
    uint8       info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
    XLogRecPtr  lsn = record->EndRecPtr;
 
    Assert(XLogRecGetRmid(record) == RM_XLOG_ID);
 
    if (info == XLOG_OVERWRITE_CONTRECORD)
    {
        /* Verify the payload of a XLOG_OVERWRITE_CONTRECORD record. */
        xl_overwrite_contrecord xlrec;
 
        memcpy(&xlrec, XLogRecGetData(record), sizeof(xl_overwrite_contrecord));
        if (xlrec.overwritten_lsn != record->overwrittenRecPtr)
            elog(FATAL, "mismatching overwritten LSN %X/%X -> %X/%X",
                 LSN_FORMAT_ARGS(xlrec.overwritten_lsn),
                 LSN_FORMAT_ARGS(record->overwrittenRecPtr));
 
        /* We have safely skipped the aborted record */
        abortedRecPtr = InvalidXLogRecPtr;
        missingContrecPtr = InvalidXLogRecPtr;
 
        ereport(LOG,
                (errmsg("successfully skipped missing contrecord at %X/%X, overwritten at %s",
                        LSN_FORMAT_ARGS(xlrec.overwritten_lsn),
                        timestamptz_to_str(xlrec.overwrite_time))));
 
        /* Verifying the record should only happen once */
        record->overwrittenRecPtr = InvalidXLogRecPtr;
    }
    else if (info == XLOG_BACKUP_END)
    {
        XLogRecPtr  startpoint;
 
        memcpy(&startpoint, XLogRecGetData(record), sizeof(startpoint));
 
        if (backupStartPoint == startpoint)
        {
            /*
             * We have reached the end of base backup, the point where
             * pg_backup_stop() was done.  The data on disk is now consistent
             * (assuming we have also reached minRecoveryPoint).  Set
             * backupEndPoint to the current LSN, so that the next call to
             * CheckRecoveryConsistency() will notice it and do the
             * end-of-backup processing.
             */
            elog(DEBUG1, "end of backup record reached");
 
            backupEndPoint = lsn;
        }
        else
            elog(DEBUG1, "saw end-of-backup record for backup starting at %X/%X, waiting for %X/%X",
                 LSN_FORMAT_ARGS(startpoint), LSN_FORMAT_ARGS(backupStartPoint));
    }
}

References abortedRecPtr, Assert, backupEndPoint, backupStartPoint, DEBUG1, elog, XLogReaderState::EndRecPtr, ereport, errmsg(), FATAL, InvalidXLogRecPtr, LOG, LSN_FORMAT_ARGS, missingContrecPtr, xl_overwrite_contrecord::overwrite_time, xl_overwrite_contrecord::overwritten_lsn, XLogReaderState::overwrittenRecPtr, timestamptz_to_str(), XLOG_BACKUP_END, XLOG_OVERWRITE_CONTRECORD, XLogRecGetData, XLogRecGetInfo, XLogRecGetRmid, and XLR_INFO_MASK.

Referenced by ApplyWalRecord().

XLogRecoveryShmemInit()

void XLogRecoveryShmemInit

(

void

)

Definition at line 458 of file xlogrecovery.c.

{
    bool        found;
 
    XLogRecoveryCtl = (XLogRecoveryCtlData *)
        ShmemInitStruct("XLOG Recovery Ctl", XLogRecoveryShmemSize(), &found);
    if (found)
        return;
    memset(XLogRecoveryCtl, 0, sizeof(XLogRecoveryCtlData));
 
    SpinLockInit(&XLogRecoveryCtl->info_lck);
    InitSharedLatch(&XLogRecoveryCtl->recoveryWakeupLatch);
    ConditionVariableInit(&XLogRecoveryCtl->recoveryNotPausedCV);
}

References ConditionVariableInit(), XLogRecoveryCtlData::info_lck, InitSharedLatch(), XLogRecoveryCtlData::recoveryNotPausedCV, XLogRecoveryCtlData::recoveryWakeupLatch, ShmemInitStruct(), SpinLockInit, XLogRecoveryCtl, and XLogRecoveryShmemSize().

Referenced by CreateOrAttachShmemStructs().

XLogRecoveryShmemSize()

Size XLogRecoveryShmemSize

(

void

)

Definition at line 447 of file xlogrecovery.c.

{
    Size        size;
 
    /* XLogRecoveryCtl */
    size = sizeof(XLogRecoveryCtlData);
 
    return size;
}

References size.

Referenced by CalculateShmemSize(), and XLogRecoveryShmemInit().

XLogRequestWalReceiverReply()

void XLogRequestWalReceiverReply

(

void

)

Definition at line 4487 of file xlogrecovery.c.

{
    doRequestWalReceiverReply = true;
}

References doRequestWalReceiverReply.

Referenced by xact_redo_commit().

Variable Documentation

abortedRecPtr

XLogRecPtr abortedRecPtr

static

Definition at line 372 of file xlogrecovery.c.

Referenced by FinishWalRecovery(), InitWalRecovery(), ReadRecord(), StartupXLOG(), and xlogrecovery_redo().

archiveCleanupCommand

char* archiveCleanupCommand = NULL

Definition at line 84 of file xlogrecovery.c.

Referenced by CreateRestartPoint().

ArchiveRecoveryRequested

bool ArchiveRecoveryRequested = false

Definition at line 137 of file xlogrecovery.c.

Referenced by CheckRequiredParameterValues(), existsTimeLineHistory(), FinishWalRecovery(), InitWalRecovery(), PerformRecoveryXLogAction(), PerformWalRecovery(), ReadRecord(), readRecoverySignalFile(), readTimeLineHistory(), recoveryApplyDelay(), recoveryStopsAfter(), recoveryStopsBefore(), RestoreArchivedFile(), ShutdownWalRecovery(), StartupXLOG(), validateRecoveryParameters(), writeTimeLineHistory(), xlog_redo(), and XLogPageRead().

backupEndPoint

XLogRecPtr backupEndPoint

static

Definition at line 282 of file xlogrecovery.c.

Referenced by CheckRecoveryConsistency(), InitWalRecovery(), and xlogrecovery_redo().

backupEndRequired

bool backupEndRequired = false

static

Definition at line 283 of file xlogrecovery.c.

Referenced by CheckRecoveryConsistency(), InitWalRecovery(), and read_backup_label().

backupStartPoint

XLogRecPtr backupStartPoint

static

Definition at line 281 of file xlogrecovery.c.

Referenced by CheckRecoveryConsistency(), InitWalRecovery(), and xlogrecovery_redo().

CheckPointLoc

XLogRecPtr CheckPointLoc = InvalidXLogRecPtr

static

Definition at line 167 of file xlogrecovery.c.

Referenced by FinishWalRecovery(), InitWalRecovery(), and PerformWalRecovery().

CheckPointTLI

TimeLineID CheckPointTLI = 0

static

Definition at line 168 of file xlogrecovery.c.

Referenced by FinishWalRecovery(), InitWalRecovery(), and PerformWalRecovery().

curFileTLI

TimeLineID curFileTLI

static

Definition at line 124 of file xlogrecovery.c.

Referenced by WaitForWALToBecomeAvailable(), XLogFileRead(), XLogFileReadAnyTLI(), and XLogPageRead().

currentSource

XLogSource currentSource = XLOG_FROM_ANY

static

Definition at line 246 of file xlogrecovery.c.

Referenced by ReadRecord(), StartupRequestWalReceiverRestart(), and WaitForWALToBecomeAvailable().

doRequestWalReceiverReply

bool doRequestWalReceiverReply

static

Definition at line 185 of file xlogrecovery.c.

Referenced by ApplyWalRecord(), and XLogRequestWalReceiverReply().

expectedTLEs

List* expectedTLEs

static

Definition at line 123 of file xlogrecovery.c.

Referenced by checkTimeLineSwitch(), InitWalRecovery(), PrepareForIncrementalBackup(), ReadRecord(), rescanLatestTimeLine(), tliInHistory(), WaitForWALToBecomeAvailable(), and XLogFileReadAnyTLI().

flushedUpto

XLogRecPtr flushedUpto = 0

static

Definition at line 262 of file xlogrecovery.c.

Referenced by WaitForWALToBecomeAvailable(), and XLogPageRead().

InArchiveRecovery

bool InArchiveRecovery = false

Definition at line 138 of file xlogrecovery.c.

Referenced by CheckRecoveryConsistency(), FinishWalRecovery(), InitWalRecovery(), ReadRecord(), StartupXLOG(), WaitForWALToBecomeAvailable(), and xlog_redo().

InRedo

bool InRedo = false

static

Definition at line 203 of file xlogrecovery.c.

Referenced by PerformWalRecovery(), and XLogFileRead().

lastSourceFailed

bool lastSourceFailed = false

static

Definition at line 247 of file xlogrecovery.c.

Referenced by ReadRecord(), WaitForWALToBecomeAvailable(), and XLogPageRead().

LocalHotStandbyActive

bool LocalHotStandbyActive = false

static

Definition at line 176 of file xlogrecovery.c.

Referenced by CheckRecoveryConsistency(), HotStandbyActive(), HotStandbyActiveInReplay(), and recoveryPausesHere().

LocalPromoteIsTriggered

bool LocalPromoteIsTriggered = false

static

Definition at line 182 of file xlogrecovery.c.

Referenced by CheckForStandbyTrigger(), PromoteIsTriggered(), recoveryPausesHere(), and SetPromoteIsTriggered().

minRecoveryPoint

XLogRecPtr minRecoveryPoint

static

Definition at line 278 of file xlogrecovery.c.

Referenced by CheckRecoveryConsistency(), checkTimeLineSwitch(), InitWalRecovery(), and ReadRecord().

minRecoveryPointTLI

TimeLineID minRecoveryPointTLI

static

Definition at line 279 of file xlogrecovery.c.

Referenced by checkTimeLineSwitch(), InitWalRecovery(), and ReadRecord().

missingContrecPtr

XLogRecPtr missingContrecPtr

static

Definition at line 373 of file xlogrecovery.c.

Referenced by FinishWalRecovery(), InitWalRecovery(), ReadRecord(), StartupXLOG(), and xlogrecovery_redo().

pendingWalRcvRestart

bool pendingWalRcvRestart = false

static

Definition at line 248 of file xlogrecovery.c.

Referenced by StartupRequestWalReceiverRestart(), and WaitForWALToBecomeAvailable().

primary_image_masked

char* primary_image_masked = NULL

static

Definition at line 298 of file xlogrecovery.c.

Referenced by InitWalRecovery(), and verifyBackupPageConsistency().

PrimaryConnInfo

char* PrimaryConnInfo = NULL

Definition at line 96 of file xlogrecovery.c.

Referenced by CheckAndGetDbnameFromConninfo(), pg_sync_replication_slots(), ReplSlotSyncWorkerMain(), slotsync_reread_config(), StartupRereadConfig(), validateRecoveryParameters(), ValidateSlotSyncParams(), and WaitForWALToBecomeAvailable().

PrimarySlotName

char* PrimarySlotName = NULL

Definition at line 97 of file xlogrecovery.c.

Referenced by slotsync_reread_config(), StartupRereadConfig(), validate_remote_info(), ValidateSlotSyncParams(), and WaitForWALToBecomeAvailable().

reachedConsistency

bool reachedConsistency = false

Definition at line 294 of file xlogrecovery.c.

Referenced by CheckRecoveryConsistency(), log_invalid_page(), PerformWalRecovery(), PrepareRedoAdd(), recovery_create_dbdir(), recoveryApplyDelay(), recoveryStopsAfter(), and recoveryStopsBefore().

readFile

int readFile = -1

static

Definition at line 230 of file xlogrecovery.c.

Referenced by FinishWalRecovery(), ReadRecord(), ShutdownWalRecovery(), WaitForWALToBecomeAvailable(), and XLogPageRead().

readLen

uint32 readLen = 0

static

Definition at line 233 of file xlogrecovery.c.

Referenced by ReadPageInternal(), XLogFindNextRecord(), and XLogPageRead().

readOff

uint32 readOff = 0

static

Definition at line 232 of file xlogrecovery.c.

Referenced by FinishWalRecovery(), XLogDecodeNextRecord(), and XLogPageRead().

readSegNo

XLogSegNo readSegNo = 0

static

Definition at line 231 of file xlogrecovery.c.

Referenced by WaitForWALToBecomeAvailable(), and XLogPageRead().

readSource

XLogSource readSource = XLOG_FROM_ANY

static

Definition at line 234 of file xlogrecovery.c.

Referenced by emode_for_corrupt_record(), WaitForWALToBecomeAvailable(), XLogFileRead(), and XLogPageRead().

receiveTLI

TimeLineID receiveTLI = 0

static

Definition at line 263 of file xlogrecovery.c.

Referenced by GetStandbyFlushRecPtr(), GetWalRcvFlushRecPtr(), and WaitForWALToBecomeAvailable().

recovery_min_apply_delay

int recovery_min_apply_delay = 0

Definition at line 93 of file xlogrecovery.c.

Referenced by recoveryApplyDelay().

recovery_signal_file_found

bool recovery_signal_file_found = false

static

Definition at line 151 of file xlogrecovery.c.

Referenced by FinishWalRecovery(), and readRecoverySignalFile().

recovery_target_action_options

const struct config_enum_entry recovery_target_action_options[]

Initial value:

= {
    {"pause", RECOVERY_TARGET_ACTION_PAUSE, false},
    {"promote", RECOVERY_TARGET_ACTION_PROMOTE, false},
    {"shutdown", RECOVERY_TARGET_ACTION_SHUTDOWN, false},
    {NULL, 0, false}
}

Definition at line 1 of file xlogrecovery.c.

recovery_target_time_string

char* recovery_target_time_string

Definition at line 89 of file xlogrecovery.c.

Referenced by validateRecoveryParameters().

recoveryEndCommand

char* recoveryEndCommand = NULL

Definition at line 83 of file xlogrecovery.c.

Referenced by CleanupAfterArchiveRecovery().

recoveryRestoreCommand

char* recoveryRestoreCommand = NULL

Definition at line 82 of file xlogrecovery.c.

Referenced by RestoreArchivedFile(), and validateRecoveryParameters().

recoveryStopAfter

bool recoveryStopAfter

static

Definition at line 383 of file xlogrecovery.c.

Referenced by getRecoveryStopReason(), recoveryStopsAfter(), and recoveryStopsBefore().

recoveryStopLSN

XLogRecPtr recoveryStopLSN

static

Definition at line 381 of file xlogrecovery.c.

Referenced by getRecoveryStopReason(), recoveryStopsAfter(), and recoveryStopsBefore().

recoveryStopName

char recoveryStopName[MAXFNAMELEN]

static

Definition at line 382 of file xlogrecovery.c.

Referenced by getRecoveryStopReason(), recoveryStopsAfter(), and recoveryStopsBefore().

recoveryStopTime

TimestampTz recoveryStopTime

static

Definition at line 380 of file xlogrecovery.c.

Referenced by getRecoveryStopReason(), recoveryStopsAfter(), and recoveryStopsBefore().

recoveryStopXid

TransactionId recoveryStopXid

static

Definition at line 379 of file xlogrecovery.c.

Referenced by getRecoveryStopReason(), recoveryStopsAfter(), and recoveryStopsBefore().

recoveryTarget

RecoveryTargetType recoveryTarget = RECOVERY_TARGET_UNSET

Definition at line 85 of file xlogrecovery.c.

Referenced by assign_recovery_target(), assign_recovery_target_lsn(), assign_recovery_target_name(), assign_recovery_target_time(), assign_recovery_target_xid(), getRecoveryStopReason(), InitWalRecovery(), PerformWalRecovery(), recoveryStopsAfter(), recoveryStopsBefore(), and validateRecoveryParameters().

recoveryTargetAction

int recoveryTargetAction = RECOVERY_TARGET_ACTION_PAUSE

Definition at line 87 of file xlogrecovery.c.

Referenced by PerformWalRecovery(), and validateRecoveryParameters().

recoveryTargetInclusive

bool recoveryTargetInclusive = true

Definition at line 86 of file xlogrecovery.c.

Referenced by recoveryStopsAfter(), and recoveryStopsBefore().

recoveryTargetLSN

XLogRecPtr recoveryTargetLSN

Definition at line 92 of file xlogrecovery.c.

Referenced by assign_recovery_target_lsn(), InitWalRecovery(), recoveryStopsAfter(), and recoveryStopsBefore().

recoveryTargetName

const char* recoveryTargetName

Definition at line 91 of file xlogrecovery.c.

Referenced by assign_recovery_target_name(), InitWalRecovery(), and recoveryStopsAfter().

recoveryTargetTime

TimestampTz recoveryTargetTime

Definition at line 90 of file xlogrecovery.c.

Referenced by InitWalRecovery(), recoveryStopsBefore(), and validateRecoveryParameters().

recoveryTargetTimeLineGoal

RecoveryTargetTimeLineGoal recoveryTargetTimeLineGoal = RECOVERY_TARGET_TIMELINE_LATEST

Definition at line 120 of file xlogrecovery.c.

Referenced by assign_recovery_target_timeline(), validateRecoveryParameters(), and WaitForWALToBecomeAvailable().

recoveryTargetTLI

TimeLineID recoveryTargetTLI = 0

Definition at line 122 of file xlogrecovery.c.

Referenced by InitWalRecovery(), rescanLatestTimeLine(), StartupXLOG(), validateRecoveryParameters(), WaitForWALToBecomeAvailable(), and XLogFileReadAnyTLI().

recoveryTargetTLIRequested

TimeLineID recoveryTargetTLIRequested = 0

Definition at line 121 of file xlogrecovery.c.

Referenced by assign_recovery_target_timeline(), and validateRecoveryParameters().

recoveryTargetXid

TransactionId recoveryTargetXid

Definition at line 88 of file xlogrecovery.c.

Referenced by assign_recovery_target_xid(), InitWalRecovery(), recoveryStopsAfter(), and recoveryStopsBefore().

RedoStartLSN

XLogRecPtr RedoStartLSN = InvalidXLogRecPtr

static

Definition at line 169 of file xlogrecovery.c.

Referenced by InitWalRecovery(), PerformWalRecovery(), read_backup_label(), and WaitForWALToBecomeAvailable().

RedoStartTLI

TimeLineID RedoStartTLI = 0

static

Definition at line 170 of file xlogrecovery.c.

Referenced by InitWalRecovery(), PerformWalRecovery(), read_backup_label(), and WaitForWALToBecomeAvailable().

replay_image_masked

char* replay_image_masked = NULL

static

Definition at line 297 of file xlogrecovery.c.

Referenced by InitWalRecovery(), and verifyBackupPageConsistency().

standby_signal_file_found

bool standby_signal_file_found = false

static

Definition at line 150 of file xlogrecovery.c.

Referenced by FinishWalRecovery(), and readRecoverySignalFile().

StandbyMode

bool StandbyMode = false

Definition at line 147 of file xlogrecovery.c.

Referenced by EnableStandbyMode(), FinishWalRecovery(), PerformWalRecovery(), ReadRecord(), RestoreArchivedFile(), update_synced_slots_inactive_since(), WaitForWALToBecomeAvailable(), and XLogPageRead().

StandbyModeRequested

bool StandbyModeRequested = false

static

Definition at line 146 of file xlogrecovery.c.

Referenced by InitWalRecovery(), ReadRecord(), readRecoverySignalFile(), and validateRecoveryParameters().

wal_receiver_create_temp_slot

bool wal_receiver_create_temp_slot = false

Definition at line 98 of file xlogrecovery.c.

Referenced by StartupRereadConfig(), and WaitForWALToBecomeAvailable().

xlogprefetcher

XLogPrefetcher* xlogprefetcher = NULL

static

Definition at line 191 of file xlogrecovery.c.

Referenced by FinishWalRecovery(), InitWalRecovery(), PerformWalRecovery(), ReadCheckpointRecord(), ReadRecord(), ShutdownWalRecovery(), and WaitForWALToBecomeAvailable().

xlogreader

XLogReaderState* xlogreader = NULL

static

Definition at line 188 of file xlogrecovery.c.

Referenced by ApplyWalRecord(), extractPageMap(), findLastCheckpoint(), FinishWalRecovery(), GetWALRecordsInfo(), GetWalStats(), InitWalRecovery(), InitXLogReaderState(), PerformWalRecovery(), pg_get_wal_block_info(), pg_get_wal_record_info(), ReadCheckpointRecord(), ReadNextXLogRecord(), readOneRecord(), ReadRecord(), ShutdownWalRecovery(), SimpleXLogPageRead(), SummarizeDbaseRecord(), SummarizeSmgrRecord(), SummarizeWAL(), SummarizeXactRecord(), SummarizeXlogRecord(), XLogPageRead(), and XlogReadTwoPhaseData().

XLogReceiptSource

XLogSource XLogReceiptSource = XLOG_FROM_ANY

static

Definition at line 259 of file xlogrecovery.c.

Referenced by GetXLogReceiptTime(), WaitForWALToBecomeAvailable(), and XLogFileRead().

XLogReceiptTime

TimestampTz XLogReceiptTime = 0

static

Definition at line 258 of file xlogrecovery.c.

Referenced by GetXLogReceiptTime(), PerformWalRecovery(), WaitForWALToBecomeAvailable(), and XLogFileRead().

XLogRecoveryCtl

XLogRecoveryCtlData* XLogRecoveryCtl = NULL

static

Definition at line 364 of file xlogrecovery.c.

Referenced by ApplyWalRecord(), CheckRecoveryConsistency(), ConfirmRecoveryPaused(), FinishWalRecovery(), GetCurrentChunkReplayStartTime(), GetCurrentReplayRecPtr(), GetLatestXTime(), GetRecoveryPauseState(), GetXLogReplayRecPtr(), HotStandbyActive(), InitWalRecovery(), PerformWalRecovery(), PromoteIsTriggered(), recoveryApplyDelay(), recoveryPausesHere(), RecoveryRequiresIntParameter(), SetCurrentChunkStartTime(), SetLatestXTime(), SetPromoteIsTriggered(), SetRecoveryPause(), ShutdownWalRecovery(), WaitForWALToBecomeAvailable(), WakeupRecovery(), and XLogRecoveryShmemInit().

xlogSourceNames

const char* const xlogSourceNames[] = {"any", "archive", "pg_wal", "stream"}

static

Definition at line 218 of file xlogrecovery.c.

Referenced by WaitForWALToBecomeAvailable().