#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

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	RecoveryPauseState { RECOVERY_NOT_PAUSED , RECOVERY_PAUSE_REQUESTED , RECOVERY_PAUSED }

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 44 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;

◆ 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 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().

◆ 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;
 }

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().

◆ 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().

◆ 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().

◆ 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")));
 }

Referenced by StartupXLOG().

◆ 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().

◆ 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().

◆ 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().

◆ 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().

◆ 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_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().

◆ 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

◆ archiveCleanupCommand

PGDLLIMPORT char* archiveCleanupCommand

extern

Definition at line 84 of file xlogrecovery.c.

Referenced by CreateRestartPoint().

◆ PrimaryConnInfo

PGDLLIMPORT char* PrimaryConnInfo

extern

Definition at line 96 of file xlogrecovery.c.

◆ PrimarySlotName

PGDLLIMPORT char* PrimarySlotName

extern

Definition at line 97 of file xlogrecovery.c.

◆ reachedConsistency

PGDLLIMPORT bool reachedConsistency

extern

Definition at line 294 of file xlogrecovery.c.

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

◆ recovery_min_apply_delay

PGDLLIMPORT int recovery_min_apply_delay

extern

Definition at line 93 of file xlogrecovery.c.

Referenced by recoveryApplyDelay().

◆ recovery_target_time_string

PGDLLIMPORT char* recovery_target_time_string

extern

Definition at line 89 of file xlogrecovery.c.

Referenced by validateRecoveryParameters().

◆ recoveryEndCommand

PGDLLIMPORT char* recoveryEndCommand

extern

Definition at line 83 of file xlogrecovery.c.

Referenced by CleanupAfterArchiveRecovery().

◆ recoveryRestoreCommand

PGDLLIMPORT char* recoveryRestoreCommand

extern

Definition at line 82 of file xlogrecovery.c.

Referenced by RestoreArchivedFile(), and validateRecoveryParameters().

◆ recoveryTarget

PGDLLIMPORT RecoveryTargetType recoveryTarget

extern

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

PGDLLIMPORT int recoveryTargetAction

extern

Definition at line 87 of file xlogrecovery.c.

Referenced by PerformWalRecovery(), and validateRecoveryParameters().

◆ recoveryTargetInclusive

PGDLLIMPORT bool recoveryTargetInclusive

extern

Definition at line 86 of file xlogrecovery.c.

Referenced by recoveryStopsAfter(), and recoveryStopsBefore().

◆ recoveryTargetLSN

PGDLLIMPORT XLogRecPtr recoveryTargetLSN

extern

Definition at line 92 of file xlogrecovery.c.

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

◆ recoveryTargetName

PGDLLIMPORT const char* recoveryTargetName

extern

Definition at line 91 of file xlogrecovery.c.

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

◆ recoveryTargetTime

PGDLLIMPORT TimestampTz recoveryTargetTime

extern

Definition at line 90 of file xlogrecovery.c.

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

◆ recoveryTargetTimeLineGoal

PGDLLIMPORT RecoveryTargetTimeLineGoal recoveryTargetTimeLineGoal

extern

Definition at line 120 of file xlogrecovery.c.

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

◆ recoveryTargetTLI

PGDLLIMPORT TimeLineID recoveryTargetTLI

extern

Definition at line 122 of file xlogrecovery.c.

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

◆ recoveryTargetTLIRequested

PGDLLIMPORT TimeLineID recoveryTargetTLIRequested

extern

Definition at line 121 of file xlogrecovery.c.

Referenced by assign_recovery_target_timeline(), and validateRecoveryParameters().

◆ recoveryTargetXid

PGDLLIMPORT TransactionId recoveryTargetXid

extern

Definition at line 88 of file xlogrecovery.c.

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

◆ StandbyMode

PGDLLIMPORT bool StandbyMode

extern

Definition at line 147 of file xlogrecovery.c.

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

◆ wal_receiver_create_temp_slot

PGDLLIMPORT bool wal_receiver_create_temp_slot

extern

Definition at line 98 of file xlogrecovery.c.

Referenced by StartupRereadConfig(), and WaitForWALToBecomeAvailable().

Data Structures

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ RecoveryPauseState

Enumeration Type Documentation

◆ RecoveryPauseState

◆ 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