#include "access/xlogreader.h"
#include "catalog/pg_control.h"
#include "lib/stringinfo.h"
#include "utils/timestamp.h"

Include dependency graph for xlogrecovery.h:

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

Go to the source code of this file.

Data Structures
struct	EndOfWalRecoveryInfo

Typedefs
typedef enum RecoveryPauseState	RecoveryPauseState

Functions
Size	XLogRecoveryShmemSize (void)

void	XLogRecoveryShmemInit (void)

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

void	PerformWalRecovery (void)

EndOfWalRecoveryInfo *	FinishWalRecovery (void)

void	ShutdownWalRecovery (void)

void	RemovePromoteSignalFiles (void)

bool	HotStandbyActive (void)

XLogRecPtr	GetXLogReplayRecPtr (TimeLineID *replayTLI)

RecoveryPauseState	GetRecoveryPauseState (void)

void	SetRecoveryPause (bool recoveryPause)

void	GetXLogReceiptTime (TimestampTz rtime, bool fromStream)

TimestampTz	GetLatestXTime (void)

TimestampTz	GetCurrentChunkReplayStartTime (void)

XLogRecPtr	GetCurrentReplayRecPtr (TimeLineID *replayEndTLI)

bool	PromoteIsTriggered (void)

bool	CheckPromoteSignal (void)

void	WakeupRecovery (void)

void	StartupRequestWalReceiverRestart (void)

void	XLogRequestWalReceiverReply (void)

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

void	xlog_outdesc (StringInfo buf, XLogReaderState *record)

Variables
PGDLLIMPORT bool	recoveryTargetInclusive

PGDLLIMPORT int	recoveryTargetAction

PGDLLIMPORT int	recovery_min_apply_delay

PGDLLIMPORT char *	PrimaryConnInfo

PGDLLIMPORT char *	PrimarySlotName

PGDLLIMPORT char *	recoveryRestoreCommand

PGDLLIMPORT char *	recoveryEndCommand

PGDLLIMPORT char *	archiveCleanupCommand

PGDLLIMPORT TransactionId	recoveryTargetXid

PGDLLIMPORT char *	recovery_target_time_string

PGDLLIMPORT TimestampTz	recoveryTargetTime

PGDLLIMPORT const char *	recoveryTargetName

PGDLLIMPORT XLogRecPtr	recoveryTargetLSN

PGDLLIMPORT RecoveryTargetType	recoveryTarget

PGDLLIMPORT bool	wal_receiver_create_temp_slot

PGDLLIMPORT RecoveryTargetTimeLineGoal	recoveryTargetTimeLineGoal

PGDLLIMPORT TimeLineID	recoveryTargetTLIRequested

PGDLLIMPORT TimeLineID	recoveryTargetTLI

PGDLLIMPORT bool	reachedConsistency

PGDLLIMPORT bool	StandbyMode

Typedef Documentation

◆ RecoveryPauseState

typedef enum RecoveryPauseState RecoveryPauseState

Enumeration Type Documentation

◆ RecoveryPauseState

enum RecoveryPauseState

Enumerator
RECOVERY_NOT_PAUSED
RECOVERY_PAUSE_REQUESTED
RECOVERY_PAUSED

Definition at line 54 of file xlogrecovery.h.

{
    RECOVERY_NOT_PAUSED,        /* pause not requested */
    RECOVERY_PAUSE_REQUESTED,   /* pause requested, but not yet paused */
    RECOVERY_PAUSED,            /* recovery is paused */
} RecoveryPauseState;

◆ RecoveryTargetAction

enum RecoveryTargetAction

Enumerator
RECOVERY_TARGET_ACTION_PAUSE
RECOVERY_TARGET_ACTION_PROMOTE
RECOVERY_TARGET_ACTION_SHUTDOWN

Definition at line 46 of file xlogrecovery.h.

{
    RECOVERY_TARGET_ACTION_PAUSE,
    RECOVERY_TARGET_ACTION_PROMOTE,
    RECOVERY_TARGET_ACTION_SHUTDOWN,
}           RecoveryTargetAction;

◆ RecoveryTargetTimeLineGoal

enum RecoveryTargetTimeLineGoal

Enumerator
RECOVERY_TARGET_TIMELINE_CONTROLFILE
RECOVERY_TARGET_TIMELINE_LATEST
RECOVERY_TARGET_TIMELINE_NUMERIC

Definition at line 36 of file xlogrecovery.h.

{
    RECOVERY_TARGET_TIMELINE_CONTROLFILE,
    RECOVERY_TARGET_TIMELINE_LATEST,
    RECOVERY_TARGET_TIMELINE_NUMERIC,
} RecoveryTargetTimeLineGoal;

◆ RecoveryTargetType

enum RecoveryTargetType

Enumerator
RECOVERY_TARGET_UNSET
RECOVERY_TARGET_XID
RECOVERY_TARGET_TIME
RECOVERY_TARGET_NAME
RECOVERY_TARGET_LSN
RECOVERY_TARGET_IMMEDIATE

Definition at line 23 of file xlogrecovery.h.

{
    RECOVERY_TARGET_UNSET,
    RECOVERY_TARGET_XID,
    RECOVERY_TARGET_TIME,
    RECOVERY_TARGET_NAME,
    RECOVERY_TARGET_LSN,
    RECOVERY_TARGET_IMMEDIATE,
} RecoveryTargetType;

Function Documentation

◆ CheckPromoteSignal()

bool CheckPromoteSignal ( void )

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

◆ FinishWalRecovery()

EndOfWalRecoveryInfo * FinishWalRecovery ( void )

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

Referenced by StartupXLOG().

◆ GetCurrentChunkReplayStartTime()

TimestampTz GetCurrentChunkReplayStartTime ( void )

Definition at line 4682 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 4618 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 4652 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().

◆ GetRecoveryPauseState()

RecoveryPauseState GetRecoveryPauseState ( void )

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

◆ GetXLogReceiptTime()

void GetXLogReceiptTime	(	TimestampTz *	rtime,
		bool *	fromStream
	)

Definition at line 4698 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 4595 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(), ExecWaitStmt(), 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(), WaitForLSN(), WalReceiverMain(), WalSndWaitForWal(), XLogSendLogical(), and XLogWalRcvSendReply().

◆ HotStandbyActive()

bool HotStandbyActive ( void )

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

◆ InitWalRecovery()

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

Definition at line 520 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/%08X, checkpoint LSN %X/%08X, 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/%08X",
                                    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/%08X referenced by checkpoint record at %X/%08X",
                                   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/%08X",
                           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("%s/%u", PG_TBLSPC_DIR, 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 &&
            (XLogRecPtrIsValid(ControlFile->minRecoveryPoint) ||
             ControlFile->backupEndRequired ||
             XLogRecPtrIsValid(ControlFile->backupEndPoint) ||
             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 (XLogRecPtrIsValid(ControlFile->backupStartPoint))
            ereport(LOG,
                    errmsg("restarting backup recovery with redo LSN %X/%08X",
                           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/%08X",
                                    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/%08X",
                           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/%08X\"",
                           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(CheckPointTLI, expectedTLEs, NULL);
        ereport(FATAL,
                (errmsg("requested timeline %u is not a child of this server's history",
                        recoveryTargetTLI),
        /* translator: %s is a backup_label file or a pg_control file */
                 errdetail("Latest checkpoint in file \"%s\" is at %X/%08X on timeline %u, but in the history of the requested timeline, the server forked off from that timeline at %X/%08X.",
                           haveBackupLabel ? "backup_label" : "pg_control",
                           LSN_FORMAT_ARGS(CheckPointLoc),
                           CheckPointTLI,
                           LSN_FORMAT_ARGS(switchpoint))));
    }
 
    /*
     * The min recovery point should be part of the requested timeline's
     * history, too.
     */
    if (XLogRecPtrIsValid(ControlFile->minRecoveryPoint) &&
        tliOfPointInHistory(ControlFile->minRecoveryPoint - 1, expectedTLEs) !=
        ControlFile->minRecoveryPointTLI)
        ereport(FATAL,
                errmsg("requested timeline %u does not contain minimum recovery point %X/%08X on timeline %u",
                       recoveryTargetTLI,
                       LSN_FORMAT_ARGS(ControlFile->minRecoveryPoint),
                       ControlFile->minRecoveryPointTLI));
 
    ereport(DEBUG1,
            errmsg_internal("redo record is at %X/%08X; 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(), PG_TBLSPC_DIR, 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, and XLogRecPtrIsValid.

Referenced by StartupXLOG().

◆ PerformWalRecovery()

void PerformWalRecovery ( void )

Definition at line 1663 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/%08X",
                           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/%08X",
                       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/%08X",
                                         LSN_FORMAT_ARGS(xlogreader->ReadRecPtr));
 
#ifdef WAL_DEBUG
            if (XLOG_DEBUG)
            {
                StringInfoData buf;
 
                initStringInfo(&buf);
                appendStringInfo(&buf, "REDO @ %X/%08X; LSN %X/%08X: ",
                                 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 */
            ProcessStartupProcInterrupts();
 
            /*
             * 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;
            }
 
            /*
             * If we replayed an LSN that someone was waiting for then walk
             * over the shared memory array and set latches to notify the
             * waiters.
             */
            if (waitLSNState &&
                (XLogRecoveryCtl->lastReplayedEndRecPtr >=
                 pg_atomic_read_u64(&waitLSNState->minWaitedLSN[WAIT_LSN_TYPE_REPLAY])))
                WaitLSNWakeup(WAIT_LSN_TYPE_REPLAY, XLogRecoveryCtl->lastReplayedEndRecPtr);
 
            /* 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/%08X 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,
                (errcode(ERRCODE_CONFIG_FILE_ERROR),
                 errmsg("recovery ended before configured recovery target was reached")));
}

Referenced by StartupXLOG().

◆ PromoteIsTriggered()

bool PromoteIsTriggered ( void )

Definition at line 4450 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 ExecWaitStmt(), PerformRecoveryXLogAction(), pg_wal_replay_pause(), pg_wal_replay_resume(), and WaitForLSN().

◆ RecoveryRequiresIntParameter()

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

Definition at line 4715 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)
            {
                ProcessStartupProcInterrupts();
 
                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(), HotStandbyActiveInReplay(), LOG, ProcessStartupProcInterrupts(), RECOVERY_NOT_PAUSED, XLogRecoveryCtlData::recoveryNotPausedCV, SetRecoveryPause(), WARNING, and XLogRecoveryCtl.

Referenced by CheckRequiredParameterValues().

◆ RemovePromoteSignalFiles()

void RemovePromoteSignalFiles ( void )

Definition at line 4510 of file xlogrecovery.c.

{
    unlink(PROMOTE_SIGNAL_FILE);
}

References PROMOTE_SIGNAL_FILE.

Referenced by CheckForStandbyTrigger(), and PostmasterMain().

◆ SetRecoveryPause()

void SetRecoveryPause ( bool recoveryPause )

Definition at line 3114 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 1618 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;
    }
    pfree(xlogreader->private_data);
    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, pfree(), XLogReaderState::private_data, readFile, XLogRecoveryCtlData::recoveryWakeupLatch, snprintf, XLOGDIR, xlogprefetcher, XLogPrefetcherComputeStats(), XLogPrefetcherFree(), xlogreader, XLogReaderFree(), and XLogRecoveryCtl.

Referenced by StartupXLOG().

◆ StartupRequestWalReceiverRestart()

void StartupRequestWalReceiverRestart ( void )

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

◆ WakeupRecovery()

void WakeupRecovery ( void )

Definition at line 4534 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_outdesc()

void xlog_outdesc	(	StringInfo	buf,
		XLogReaderState *	record
	)

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

◆ XLogRecoveryShmemInit()

void XLogRecoveryShmemInit ( void )

Definition at line 466 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 455 of file xlogrecovery.c.

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

Referenced by CalculateShmemSize(), and XLogRecoveryShmemInit().

◆ XLogRequestWalReceiverReply()

void XLogRequestWalReceiverReply ( void )

Definition at line 4543 of file xlogrecovery.c.

{
    doRequestWalReceiverReply = true;
}

References doRequestWalReceiverReply.

Referenced by xact_redo_commit().

Variable Documentation

◆ archiveCleanupCommand

PGDLLIMPORT char* archiveCleanupCommand

extern

Definition at line 87 of file xlogrecovery.c.

Referenced by CreateRestartPoint().

◆ PrimaryConnInfo

PGDLLIMPORT char* PrimaryConnInfo

extern

Definition at line 99 of file xlogrecovery.c.

◆ PrimarySlotName

PGDLLIMPORT char* PrimarySlotName

extern

Definition at line 100 of file xlogrecovery.c.

◆ reachedConsistency

PGDLLIMPORT bool reachedConsistency

extern

Definition at line 302 of file xlogrecovery.c.

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

◆ recovery_min_apply_delay

PGDLLIMPORT int recovery_min_apply_delay

extern

Definition at line 96 of file xlogrecovery.c.

Referenced by recoveryApplyDelay().

◆ recovery_target_time_string

PGDLLIMPORT char* recovery_target_time_string

extern

Definition at line 92 of file xlogrecovery.c.

Referenced by validateRecoveryParameters().

◆ recoveryEndCommand

PGDLLIMPORT char* recoveryEndCommand

extern

Definition at line 86 of file xlogrecovery.c.

Referenced by CleanupAfterArchiveRecovery().

◆ recoveryRestoreCommand

PGDLLIMPORT char* recoveryRestoreCommand

extern

Definition at line 85 of file xlogrecovery.c.

Referenced by RestoreArchivedFile(), and validateRecoveryParameters().

◆ recoveryTarget

PGDLLIMPORT RecoveryTargetType recoveryTarget

extern

Definition at line 88 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

PGDLLIMPORT int recoveryTargetAction

extern

Definition at line 90 of file xlogrecovery.c.

Referenced by PerformWalRecovery(), and validateRecoveryParameters().

◆ recoveryTargetInclusive

PGDLLIMPORT bool recoveryTargetInclusive

extern

Definition at line 89 of file xlogrecovery.c.

Referenced by recoveryStopsAfter(), and recoveryStopsBefore().

◆ recoveryTargetLSN

PGDLLIMPORT XLogRecPtr recoveryTargetLSN

extern

Definition at line 95 of file xlogrecovery.c.

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

◆ recoveryTargetName

PGDLLIMPORT const char* recoveryTargetName

extern

Definition at line 94 of file xlogrecovery.c.

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

◆ recoveryTargetTime

PGDLLIMPORT TimestampTz recoveryTargetTime

extern

Definition at line 93 of file xlogrecovery.c.

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

◆ recoveryTargetTimeLineGoal

PGDLLIMPORT RecoveryTargetTimeLineGoal recoveryTargetTimeLineGoal

extern

Definition at line 123 of file xlogrecovery.c.

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

◆ recoveryTargetTLI

PGDLLIMPORT TimeLineID recoveryTargetTLI

extern

Definition at line 125 of file xlogrecovery.c.

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

◆ recoveryTargetTLIRequested

PGDLLIMPORT TimeLineID recoveryTargetTLIRequested

extern

Definition at line 124 of file xlogrecovery.c.

Referenced by assign_recovery_target_timeline(), and validateRecoveryParameters().

◆ recoveryTargetXid

PGDLLIMPORT TransactionId recoveryTargetXid

extern

Definition at line 91 of file xlogrecovery.c.

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

◆ StandbyMode

PGDLLIMPORT bool StandbyMode

extern

Definition at line 150 of file xlogrecovery.c.

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

◆ wal_receiver_create_temp_slot

PGDLLIMPORT bool wal_receiver_create_temp_slot

extern

Definition at line 101 of file xlogrecovery.c.

Referenced by StartupRereadConfig(), and WaitForWALToBecomeAvailable().

Enumerations
enum	RecoveryTargetType { RECOVERY_TARGET_UNSET , RECOVERY_TARGET_XID , RECOVERY_TARGET_TIME , RECOVERY_TARGET_NAME , RECOVERY_TARGET_LSN , RECOVERY_TARGET_IMMEDIATE }

enum	RecoveryTargetTimeLineGoal { RECOVERY_TARGET_TIMELINE_CONTROLFILE , RECOVERY_TARGET_TIMELINE_LATEST , RECOVERY_TARGET_TIMELINE_NUMERIC }

enum	RecoveryTargetAction { RECOVERY_TARGET_ACTION_PAUSE , RECOVERY_TARGET_ACTION_PROMOTE , RECOVERY_TARGET_ACTION_SHUTDOWN }

enum	RecoveryPauseState { RECOVERY_NOT_PAUSED , RECOVERY_PAUSE_REQUESTED , RECOVERY_PAUSED }

Data Structures

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ RecoveryPauseState

Enumeration Type Documentation

◆ RecoveryPauseState

◆ RecoveryTargetAction

◆ RecoveryTargetTimeLineGoal

◆ RecoveryTargetType

Function Documentation

◆ CheckPromoteSignal()

◆ FinishWalRecovery()

◆ GetCurrentChunkReplayStartTime()

◆ GetCurrentReplayRecPtr()

◆ GetLatestXTime()

◆ GetRecoveryPauseState()

◆ GetXLogReceiptTime()

◆ GetXLogReplayRecPtr()

◆ HotStandbyActive()

◆ InitWalRecovery()

◆ PerformWalRecovery()

◆ PromoteIsTriggered()

◆ RecoveryRequiresIntParameter()

◆ RemovePromoteSignalFiles()

◆ SetRecoveryPause()

◆ ShutdownWalRecovery()

◆ StartupRequestWalReceiverRestart()

◆ WakeupRecovery()

◆ xlog_outdesc()

◆ XLogRecoveryShmemInit()

◆ XLogRecoveryShmemSize()

◆ XLogRequestWalReceiverReply()

Variable Documentation

◆ archiveCleanupCommand

◆ PrimaryConnInfo

◆ PrimarySlotName

◆ reachedConsistency

◆ recovery_min_apply_delay

◆ recovery_target_time_string

◆ recoveryEndCommand

◆ recoveryRestoreCommand

◆ recoveryTarget

◆ recoveryTargetAction

◆ recoveryTargetInclusive

◆ recoveryTargetLSN

◆ recoveryTargetName

◆ recoveryTargetTime

◆ recoveryTargetTimeLineGoal

◆ recoveryTargetTLI

◆ recoveryTargetTLIRequested

◆ recoveryTargetXid

◆ StandbyMode

◆ wal_receiver_create_temp_slot