#include "postgres.h"
#include <ctype.h>
#include <math.h>
#include <time.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include "access/clog.h"
#include "access/commit_ts.h"
#include "access/heaptoast.h"
#include "access/multixact.h"
#include "access/rewriteheap.h"
#include "access/subtrans.h"
#include "access/timeline.h"
#include "access/transam.h"
#include "access/twophase.h"
#include "access/xact.h"
#include "access/xlog_internal.h"
#include "access/xlogarchive.h"
#include "access/xloginsert.h"
#include "access/xlogreader.h"
#include "access/xlogutils.h"
#include "catalog/catversion.h"
#include "catalog/pg_control.h"
#include "catalog/pg_database.h"
#include "commands/progress.h"
#include "commands/tablespace.h"
#include "common/controldata_utils.h"
#include "executor/instrument.h"
#include "miscadmin.h"
#include "pg_trace.h"
#include "pgstat.h"
#include "port/atomics.h"
#include "postmaster/bgwriter.h"
#include "postmaster/startup.h"
#include "postmaster/walwriter.h"
#include "replication/basebackup.h"
#include "replication/logical.h"
#include "replication/origin.h"
#include "replication/slot.h"
#include "replication/snapbuild.h"
#include "replication/walreceiver.h"
#include "replication/walsender.h"
#include "storage/bufmgr.h"
#include "storage/fd.h"
#include "storage/ipc.h"
#include "storage/large_object.h"
#include "storage/latch.h"
#include "storage/pmsignal.h"
#include "storage/predicate.h"
#include "storage/proc.h"
#include "storage/procarray.h"
#include "storage/reinit.h"
#include "storage/smgr.h"
#include "storage/spin.h"
#include "storage/sync.h"
#include "utils/builtins.h"
#include "utils/guc.h"
#include "utils/memutils.h"
#include "utils/ps_status.h"
#include "utils/relmapper.h"
#include "utils/snapmgr.h"
#include "utils/timestamp.h"

Include dependency graph for xlog.c:

Data Structures
struct	XLogwrtRqst

struct	XLogwrtResult

struct	WALInsertLock

union	WALInsertLockPadded

struct	XLogCtlInsert

struct	XLogCtlData

struct	XLogPageReadPrivate

Macros
#define	RECOVERY_COMMAND_FILE "recovery.conf"

#define	RECOVERY_COMMAND_DONE "recovery.done"

#define	NUM_XLOGINSERT_LOCKS 8

#define	INSERT_FREESPACE(endptr) (((endptr) % XLOG_BLCKSZ == 0) ? 0 : (XLOG_BLCKSZ - (endptr) % XLOG_BLCKSZ))

#define	NextBufIdx(idx) (((idx) == XLogCtl->XLogCacheBlck) ? 0 : ((idx) + 1))

#define	XLogRecPtrToBufIdx(recptr) (((recptr) / XLOG_BLCKSZ) % (XLogCtl->XLogCacheBlck + 1))

#define	UsableBytesInPage (XLOG_BLCKSZ - SizeOfXLogShortPHD)

#define	ConvertToXSegs(x, segsize) XLogMBVarToSegs((x), (segsize))

#define	RecoveryRequiresIntParameter(param_name, currValue, minValue)

Typedefs
typedef struct XLogwrtRqst	XLogwrtRqst

typedef struct XLogwrtResult	XLogwrtResult

typedef union WALInsertLockPadded	WALInsertLockPadded

typedef enum ExclusiveBackupState	ExclusiveBackupState

typedef struct XLogCtlInsert	XLogCtlInsert

typedef struct XLogCtlData	XLogCtlData

typedef struct XLogPageReadPrivate	XLogPageReadPrivate

Enumerations
enum	ExclusiveBackupState { EXCLUSIVE_BACKUP_NONE = 0, EXCLUSIVE_BACKUP_STARTING, EXCLUSIVE_BACKUP_IN_PROGRESS, EXCLUSIVE_BACKUP_STOPPING }

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

Functions
static void	readRecoverySignalFile (void)

static void	validateRecoveryParameters (void)

static void	exitArchiveRecovery (TimeLineID endTLI, XLogRecPtr endOfLog)

static bool	recoveryStopsBefore (XLogReaderState *record)

static bool	recoveryStopsAfter (XLogReaderState *record)

static void	recoveryPausesHere (bool endOfRecovery)

static bool	recoveryApplyDelay (XLogReaderState *record)

static void	SetLatestXTime (TimestampTz xtime)

static void	SetCurrentChunkStartTime (TimestampTz xtime)

static void	CheckRequiredParameterValues (void)

static void	XLogReportParameters (void)

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

static void	LocalSetXLogInsertAllowed (void)

static void	CreateEndOfRecoveryRecord (void)

static void	CheckPointGuts (XLogRecPtr checkPointRedo, int flags)

static void	KeepLogSeg (XLogRecPtr recptr, XLogSegNo *logSegNo)

static XLogRecPtr	XLogGetReplicationSlotMinimumLSN (void)

static void	AdvanceXLInsertBuffer (XLogRecPtr upto, bool opportunistic)

static bool	XLogCheckpointNeeded (XLogSegNo new_segno)

static void	XLogWrite (XLogwrtRqst WriteRqst, bool flexible)

static bool	InstallXLogFileSegment (XLogSegNo segno, char tmppath, bool find_free, XLogSegNo max_segno, bool use_lock)

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

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

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

static bool	WaitForWALToBecomeAvailable (XLogRecPtr RecPtr, bool randAccess, bool fetching_ckpt, XLogRecPtr tliRecPtr)

static int	emode_for_corrupt_record (int emode, XLogRecPtr RecPtr)

static void	XLogFileClose (void)

static void	PreallocXlogFiles (XLogRecPtr endptr)

static void	RemoveTempXlogFiles (void)

static void	RemoveOldXlogFiles (XLogSegNo segno, XLogRecPtr lastredoptr, XLogRecPtr endptr)

static void	RemoveXlogFile (const char *segname, XLogRecPtr lastredoptr, XLogRecPtr endptr)

static void	UpdateLastRemovedPtr (char *filename)

static void	ValidateXLOGDirectoryStructure (void)

static void	CleanupBackupHistory (void)

static void	UpdateMinRecoveryPoint (XLogRecPtr lsn, bool force)

static XLogRecord *	ReadRecord (XLogReaderState *xlogreader, int emode, bool fetching_ckpt)

static void	CheckRecoveryConsistency (void)

static XLogRecord *	ReadCheckpointRecord (XLogReaderState *xlogreader, XLogRecPtr RecPtr, int whichChkpt, bool report)

static bool	rescanLatestTimeLine (void)

static void	InitControlFile (uint64 sysidentifier)

static void	WriteControlFile (void)

static void	ReadControlFile (void)

static char *	str_time (pg_time_t tnow)

static void	SetPromoteIsTriggered (void)

static bool	CheckForStandbyTrigger (void)

static void	xlog_outdesc (StringInfo buf, XLogReaderState *record)

static void	pg_start_backup_callback (int code, Datum arg)

static void	pg_stop_backup_callback (int code, Datum arg)

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

static bool	read_tablespace_map (List **tablespaces)

static void	rm_redo_error_callback (void *arg)

static int	get_sync_bit (int method)

static void	CopyXLogRecordToWAL (int write_len, bool isLogSwitch, XLogRecData *rdata, XLogRecPtr StartPos, XLogRecPtr EndPos)

static void	ReserveXLogInsertLocation (int size, XLogRecPtr StartPos, XLogRecPtr EndPos, XLogRecPtr *PrevPtr)

static bool	ReserveXLogSwitch (XLogRecPtr StartPos, XLogRecPtr EndPos, XLogRecPtr *PrevPtr)

static XLogRecPtr	WaitXLogInsertionsToFinish (XLogRecPtr upto)

static char *	GetXLogBuffer (XLogRecPtr ptr)

static XLogRecPtr	XLogBytePosToRecPtr (uint64 bytepos)

static XLogRecPtr	XLogBytePosToEndRecPtr (uint64 bytepos)

static uint64	XLogRecPtrToBytePos (XLogRecPtr ptr)

static void	checkXLogConsistency (XLogReaderState *record)

static void	WALInsertLockAcquire (void)

static void	WALInsertLockAcquireExclusive (void)

static void	WALInsertLockRelease (void)

static void	WALInsertLockUpdateInsertingAt (XLogRecPtr insertingAt)

XLogRecPtr	XLogInsertRecord (XLogRecData *rdata, XLogRecPtr fpw_lsn, uint8 flags, int num_fpi)

static void	CalculateCheckpointSegments (void)

void	assign_max_wal_size (int newval, void *extra)

void	assign_checkpoint_completion_target (double newval, void *extra)

static XLogSegNo	XLOGfileslop (XLogRecPtr lastredoptr)

void	XLogSetAsyncXactLSN (XLogRecPtr asyncXactLSN)

void	XLogSetReplicationSlotMinimumLSN (XLogRecPtr lsn)

void	XLogFlush (XLogRecPtr record)

bool	XLogBackgroundFlush (void)

bool	XLogNeedsFlush (XLogRecPtr record)

int	XLogFileInit (XLogSegNo logsegno, bool *use_existent, bool use_lock)

static void	XLogFileCopy (XLogSegNo destsegno, TimeLineID srcTLI, XLogSegNo srcsegno, int upto)

int	XLogFileOpen (XLogSegNo segno)

void	CheckXLogRemoved (XLogSegNo segno, TimeLineID tli)

XLogSegNo	XLogGetLastRemovedSegno (void)

static void	RemoveNonParentXlogFiles (XLogRecPtr switchpoint, TimeLineID newTLI)

void	UpdateControlFile (void)

uint64	GetSystemIdentifier (void)

char *	GetMockAuthenticationNonce (void)

bool	DataChecksumsEnabled (void)

XLogRecPtr	GetFakeLSNForUnloggedRel (void)

static int	XLOGChooseNumBuffers (void)

bool	check_wal_buffers (int newval, void *extra, GucSource source)

void	LocalProcessControlFile (bool reset)

Size	XLOGShmemSize (void)

void	XLOGShmemInit (void)

void	BootStrapXLOG (void)

static bool	getRecordTimestamp (XLogReaderState record, TimestampTz recordXtime)

bool	RecoveryIsPaused (void)

void	SetRecoveryPause (bool recoveryPause)

TimestampTz	GetLatestXTime (void)

TimestampTz	GetCurrentChunkReplayStartTime (void)

void	GetXLogReceiptTime (TimestampTz rtime, bool fromStream)

void	StartupXLOG (void)

bool	RecoveryInProgress (void)

RecoveryState	GetRecoveryState (void)

bool	HotStandbyActive (void)

bool	HotStandbyActiveInReplay (void)

bool	XLogInsertAllowed (void)

void	InitXLOGAccess (void)

XLogRecPtr	GetRedoRecPtr (void)

void	GetFullPageWriteInfo (XLogRecPtr RedoRecPtr_p, bool doPageWrites_p)

XLogRecPtr	GetInsertRecPtr (void)

XLogRecPtr	GetFlushRecPtr (void)

XLogRecPtr	GetLastImportantRecPtr (void)

pg_time_t	GetLastSegSwitchData (XLogRecPtr *lastSwitchLSN)

void	ShutdownXLOG (int code, Datum arg)

static void	LogCheckpointStart (int flags, bool restartpoint)

static void	LogCheckpointEnd (bool restartpoint)

static void	UpdateCheckPointDistanceEstimate (uint64 nbytes)

void	CreateCheckPoint (int flags)

static void	RecoveryRestartPoint (const CheckPoint *checkPoint)

bool	CreateRestartPoint (int flags)

WALAvailability	GetWALAvailability (XLogRecPtr targetLSN)

void	XLogPutNextOid (Oid nextOid)

XLogRecPtr	RequestXLogSwitch (bool mark_unimportant)

XLogRecPtr	XLogRestorePoint (const char *rpName)

void	UpdateFullPageWrites (void)

void	xlog_redo (XLogReaderState *record)

void	assign_xlog_sync_method (int new_sync_method, void *extra)

void	issue_xlog_fsync (int fd, XLogSegNo segno)

XLogRecPtr	do_pg_start_backup (const char backupidstr, bool fast, TimeLineID starttli_p, StringInfo labelfile, List **tablespaces, StringInfo tblspcmapfile, bool needtblspcmapfile)

SessionBackupState	get_backup_status (void)

XLogRecPtr	do_pg_stop_backup (char labelfile, bool waitforarchive, TimeLineID stoptli_p)

void	do_pg_abort_backup (int code, Datum arg)

void	register_persistent_abort_backup_handler (void)

XLogRecPtr	GetXLogReplayRecPtr (TimeLineID *replayTLI)

XLogRecPtr	GetXLogInsertRecPtr (void)

XLogRecPtr	GetXLogWriteRecPtr (void)

void	GetOldestRestartPoint (XLogRecPtr oldrecptr, TimeLineID oldtli)

bool	BackupInProgress (void)

void	CancelBackup (void)

void	StartupRequestWalReceiverRestart (void)

bool	PromoteIsTriggered (void)

void	RemovePromoteSignalFiles (void)

bool	CheckPromoteSignal (void)

void	WakeupRecovery (void)

void	SetWalWriterSleeping (bool sleeping)

void	XLogRequestWalReceiverReply (void)

Variables
uint32	bootstrap_data_checksum_version

int	max_wal_size_mb = 1024

int	min_wal_size_mb = 80

int	wal_keep_size_mb = 0

int	XLOGbuffers = -1

int	XLogArchiveTimeout = 0

int	XLogArchiveMode = ARCHIVE_MODE_OFF

char *	XLogArchiveCommand = NULL

bool	EnableHotStandby = false

bool	fullPageWrites = true

bool	wal_log_hints = false

bool	wal_compression = false

char *	wal_consistency_checking_string = NULL

bool *	wal_consistency_checking = NULL

bool	wal_init_zero = true

bool	wal_recycle = true

bool	log_checkpoints = false

int	sync_method = DEFAULT_SYNC_METHOD

int	wal_level = WAL_LEVEL_MINIMAL

int	CommitDelay = 0

int	CommitSiblings = 5

int	wal_retrieve_retry_interval = 5000

int	max_slot_wal_keep_size_mb = -1

int	wal_segment_size = DEFAULT_XLOG_SEG_SIZE

int	CheckPointSegments

static double	CheckPointDistanceEstimate = 0

static double	PrevCheckPointDistance = 0

const struct config_enum_entry	sync_method_options []

const struct config_enum_entry	archive_mode_options []

const struct config_enum_entry	recovery_target_action_options []

CheckpointStatsData	CheckpointStats

TimeLineID	ThisTimeLineID = 0

bool	InRecovery = false

HotStandbyState	standbyState = STANDBY_DISABLED

static XLogRecPtr	LastRec

static XLogRecPtr	flushedUpto = 0

static TimeLineID	receiveTLI = 0

static bool	lastFullPageWrites

static bool	LocalRecoveryInProgress = true

static bool	LocalHotStandbyActive = false

static bool	LocalPromoteIsTriggered = false

static int	LocalXLogInsertAllowed = -1

bool	ArchiveRecoveryRequested = false

bool	InArchiveRecovery = false

static bool	standby_signal_file_found = false

static bool	recovery_signal_file_found = false

static bool	restoredFromArchive = false

static char *	replay_image_masked = NULL

static char *	primary_image_masked = NULL

char *	recoveryRestoreCommand = NULL

char *	recoveryEndCommand = NULL

char *	archiveCleanupCommand = NULL

RecoveryTargetType	recoveryTarget = RECOVERY_TARGET_UNSET

bool	recoveryTargetInclusive = true

int	recoveryTargetAction = RECOVERY_TARGET_ACTION_PAUSE

TransactionId	recoveryTargetXid

char *	recovery_target_time_string

static TimestampTz	recoveryTargetTime

const char *	recoveryTargetName

XLogRecPtr	recoveryTargetLSN

int	recovery_min_apply_delay = 0

bool	StandbyModeRequested = false

char *	PrimaryConnInfo = NULL

char *	PrimarySlotName = NULL

char *	PromoteTriggerFile = NULL

bool	wal_receiver_create_temp_slot = false

bool	StandbyMode = false

static TransactionId	recoveryStopXid

static TimestampTz	recoveryStopTime

static XLogRecPtr	recoveryStopLSN

static char	recoveryStopName [MAXFNAMELEN]

static bool	recoveryStopAfter

RecoveryTargetTimeLineGoal	recoveryTargetTimeLineGoal = RECOVERY_TARGET_TIMELINE_LATEST

TimeLineID	recoveryTargetTLIRequested = 0

TimeLineID	recoveryTargetTLI = 0

static List *	expectedTLEs

static TimeLineID	curFileTLI

XLogRecPtr	ProcLastRecPtr = InvalidXLogRecPtr

XLogRecPtr	XactLastRecEnd = InvalidXLogRecPtr

XLogRecPtr	XactLastCommitEnd = InvalidXLogRecPtr

static XLogRecPtr	RedoRecPtr

static bool	doPageWrites

static bool	doRequestWalReceiverReply

static XLogRecPtr	RedoStartLSN = InvalidXLogRecPtr

static SessionBackupState	sessionBackupState = SESSION_BACKUP_NONE

static XLogCtlData *	XLogCtl = NULL

static WALInsertLockPadded *	WALInsertLocks = NULL

static ControlFileData *	ControlFile = NULL

static int	UsableBytesInSegment

static XLogwrtResult	LogwrtResult = {0, 0}

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

static int	openLogFile = -1

static XLogSegNo	openLogSegNo = 0

static int	readFile = -1

static XLogSegNo	readSegNo = 0

static uint32	readOff = 0

static uint32	readLen = 0

static XLogSource	readSource = XLOG_FROM_ANY

static XLogSource	currentSource = XLOG_FROM_ANY

static bool	lastSourceFailed = false

static bool	pendingWalRcvRestart = false

static TimestampTz	XLogReceiptTime = 0

static XLogSource	XLogReceiptSource = XLOG_FROM_ANY

static XLogRecPtr	ReadRecPtr

static XLogRecPtr	EndRecPtr

static XLogRecPtr	minRecoveryPoint

static TimeLineID	minRecoveryPointTLI

static bool	updateMinRecoveryPoint = true

bool	reachedConsistency = false

static bool	InRedo = false

static bool	bgwriterLaunched = false

static int	MyLockNo = 0

static bool	holdingAllLocks = false

Macro Definition Documentation

◆ ConvertToXSegs

#define ConvertToXSegs	(	x,
		segsize
	)	XLogMBVarToSegs((x), (segsize))

Definition at line 765 of file xlog.c.

Referenced by CalculateCheckpointSegments(), GetWALAvailability(), KeepLogSeg(), ReadControlFile(), and XLOGfileslop().

◆ INSERT_FREESPACE

#define INSERT_FREESPACE ( endptr ) (((endptr) % XLOG_BLCKSZ == 0) ? 0 : (XLOG_BLCKSZ - (endptr) % XLOG_BLCKSZ))

Definition at line 742 of file xlog.c.

Referenced by CopyXLogRecordToWAL(), and CreateCheckPoint().

◆ NextBufIdx

#define NextBufIdx ( idx ) (((idx) == XLogCtl->XLogCacheBlck) ? 0 : ((idx) + 1))

Definition at line 746 of file xlog.c.

Referenced by XLogWrite().

◆ NUM_XLOGINSERT_LOCKS

#define NUM_XLOGINSERT_LOCKS 8

Definition at line 123 of file xlog.c.

Referenced by GetLastImportantRecPtr(), WaitXLogInsertionsToFinish(), WALInsertLockAcquire(), WALInsertLockAcquireExclusive(), WALInsertLockRelease(), WALInsertLockUpdateInsertingAt(), XLOGShmemInit(), and XLOGShmemSize().

◆ RECOVERY_COMMAND_DONE

#define RECOVERY_COMMAND_DONE "recovery.done"

Definition at line 86 of file xlog.c.

Referenced by readRecoverySignalFile().

◆ RECOVERY_COMMAND_FILE

#define RECOVERY_COMMAND_FILE "recovery.conf"

Definition at line 85 of file xlog.c.

Referenced by readRecoverySignalFile().

◆ RecoveryRequiresIntParameter

#define RecoveryRequiresIntParameter	(	param_name,
		currValue,
		minValue
	)

Value:

do { \
    if ((currValue) < (minValue)) \
        ereport(ERROR, \
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE), \
                 errmsg("hot standby is not possible because %s = %d is a lower setting than on the primary server (its value was %d)", \
                        param_name, \
                        currValue, \
                        minValue))); \
} while(0)

Definition at line 6235 of file xlog.c.

Referenced by CheckRequiredParameterValues().

◆ UsableBytesInPage

#define UsableBytesInPage (XLOG_BLCKSZ - SizeOfXLogShortPHD)

Definition at line 759 of file xlog.c.

Referenced by ReadControlFile(), XLogBytePosToEndRecPtr(), XLogBytePosToRecPtr(), and XLogRecPtrToBytePos().

◆ XLogRecPtrToBufIdx

#define XLogRecPtrToBufIdx ( recptr ) (((recptr) / XLOG_BLCKSZ) % (XLogCtl->XLogCacheBlck + 1))

Definition at line 753 of file xlog.c.

Referenced by AdvanceXLInsertBuffer(), GetXLogBuffer(), StartupXLOG(), and XLogWrite().

Typedef Documentation

◆ ExclusiveBackupState

typedef enum ExclusiveBackupState ExclusiveBackupState

◆ WALInsertLockPadded

typedef union WALInsertLockPadded WALInsertLockPadded

◆ XLogCtlData

typedef struct XLogCtlData XLogCtlData

◆ XLogCtlInsert

typedef struct XLogCtlInsert XLogCtlInsert

◆ XLogPageReadPrivate

typedef struct XLogPageReadPrivate XLogPageReadPrivate

◆ XLogwrtResult

typedef struct XLogwrtResult XLogwrtResult

◆ XLogwrtRqst

typedef struct XLogwrtRqst XLogwrtRqst

Enumeration Type Documentation

◆ ExclusiveBackupState

enum ExclusiveBackupState

Enumerator
EXCLUSIVE_BACKUP_NONE
EXCLUSIVE_BACKUP_STARTING
EXCLUSIVE_BACKUP_IN_PROGRESS
EXCLUSIVE_BACKUP_STOPPING

Definition at line 521 of file xlog.c.

 {
     EXCLUSIVE_BACKUP_NONE = 0,
     EXCLUSIVE_BACKUP_STARTING,
     EXCLUSIVE_BACKUP_IN_PROGRESS,
     EXCLUSIVE_BACKUP_STOPPING
 } ExclusiveBackupState;

◆ XLogSource

enum XLogSource

Enumerator
XLOG_FROM_ANY
XLOG_FROM_ARCHIVE
XLOG_FROM_PG_WAL
XLOG_FROM_STREAM

Definition at line 780 of file xlog.c.

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

Function Documentation

◆ AdvanceXLInsertBuffer()

static void AdvanceXLInsertBuffer	(	XLogRecPtr	upto,
		bool	opportunistic
	)

static

Definition at line 2122 of file xlog.c.

References Assert, DEBUG1, elog, XLogwrtRqst::Flush, XLogCtlInsert::forcePageWrites, XLogCtlData::info_lck, XLogCtlData::InitializedUpTo, Insert(), XLogCtlData::Insert, InvalidXLogRecPtr, XLogCtlData::LogwrtResult, XLogCtlData::LogwrtRqst, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MemSet, XLogCtlData::pages, pg_write_barrier, SpinLockAcquire, SpinLockRelease, ControlFileData::system_identifier, ThisTimeLineID, WaitXLogInsertionsToFinish(), wal_segment_size, XLogwrtRqst::Write, XLogwrtResult::Write, XLogCtlData::xlblocks, XLOG_PAGE_MAGIC, XLogRecPtrToBufIdx, XLogSegmentOffset, XLogWrite(), XLP_BKP_REMOVABLE, XLP_LONG_HEADER, XLogLongPageHeaderData::xlp_seg_size, XLogLongPageHeaderData::xlp_sysid, and XLogLongPageHeaderData::xlp_xlog_blcksz.

Referenced by GetXLogBuffer(), and XLogBackgroundFlush().

 {
     XLogCtlInsert *Insert = &XLogCtl->Insert;
     int         nextidx;
     XLogRecPtr  OldPageRqstPtr;
     XLogwrtRqst WriteRqst;
     XLogRecPtr  NewPageEndPtr = InvalidXLogRecPtr;
     XLogRecPtr  NewPageBeginPtr;
     XLogPageHeader NewPage;
     int         npages = 0;
 
     LWLockAcquire(WALBufMappingLock, LW_EXCLUSIVE);
 
     /*
      * Now that we have the lock, check if someone initialized the page
      * already.
      */
     while (upto >= XLogCtl->InitializedUpTo || opportunistic)
     {
         nextidx = XLogRecPtrToBufIdx(XLogCtl->InitializedUpTo);
 
         /*
          * Get ending-offset of the buffer page we need to replace (this may
          * be zero if the buffer hasn't been used yet).  Fall through if it's
          * already written out.
          */
         OldPageRqstPtr = XLogCtl->xlblocks[nextidx];
         if (LogwrtResult.Write < OldPageRqstPtr)
         {
             /*
              * Nope, got work to do. If we just want to pre-initialize as much
              * as we can without flushing, give up now.
              */
             if (opportunistic)
                 break;
 
             /* Before waiting, get info_lck and update LogwrtResult */
             SpinLockAcquire(&XLogCtl->info_lck);
             if (XLogCtl->LogwrtRqst.Write < OldPageRqstPtr)
                 XLogCtl->LogwrtRqst.Write = OldPageRqstPtr;
             LogwrtResult = XLogCtl->LogwrtResult;
             SpinLockRelease(&XLogCtl->info_lck);
 
             /*
              * Now that we have an up-to-date LogwrtResult value, see if we
              * still need to write it or if someone else already did.
              */
             if (LogwrtResult.Write < OldPageRqstPtr)
             {
                 /*
                  * Must acquire write lock. Release WALBufMappingLock first,
                  * to make sure that all insertions that we need to wait for
                  * can finish (up to this same position). Otherwise we risk
                  * deadlock.
                  */
                 LWLockRelease(WALBufMappingLock);
 
                 WaitXLogInsertionsToFinish(OldPageRqstPtr);
 
                 LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
 
                 LogwrtResult = XLogCtl->LogwrtResult;
                 if (LogwrtResult.Write >= OldPageRqstPtr)
                 {
                     /* OK, someone wrote it already */
                     LWLockRelease(WALWriteLock);
                 }
                 else
                 {
                     /* Have to write it ourselves */
                     TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_START();
                     WriteRqst.Write = OldPageRqstPtr;
                     WriteRqst.Flush = 0;
                     XLogWrite(WriteRqst, false);
                     LWLockRelease(WALWriteLock);
                     TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_DONE();
                 }
                 /* Re-acquire WALBufMappingLock and retry */
                 LWLockAcquire(WALBufMappingLock, LW_EXCLUSIVE);
                 continue;
             }
         }
 
         /*
          * Now the next buffer slot is free and we can set it up to be the
          * next output page.
          */
         NewPageBeginPtr = XLogCtl->InitializedUpTo;
         NewPageEndPtr = NewPageBeginPtr + XLOG_BLCKSZ;
 
         Assert(XLogRecPtrToBufIdx(NewPageBeginPtr) == nextidx);
 
         NewPage = (XLogPageHeader) (XLogCtl->pages + nextidx * (Size) XLOG_BLCKSZ);
 
         /*
          * Be sure to re-zero the buffer so that bytes beyond what we've
          * written will look like zeroes and not valid XLOG records...
          */
         MemSet((char *) NewPage, 0, XLOG_BLCKSZ);
 
         /*
          * Fill the new page's header
          */
         NewPage->xlp_magic = XLOG_PAGE_MAGIC;
 
         /* NewPage->xlp_info = 0; */    /* done by memset */
         NewPage->xlp_tli = ThisTimeLineID;
         NewPage->xlp_pageaddr = NewPageBeginPtr;
 
         /* NewPage->xlp_rem_len = 0; */ /* done by memset */
 
         /*
          * If online backup is not in progress, mark the header to indicate
          * that WAL records beginning in this page have removable backup
          * blocks.  This allows the WAL archiver to know whether it is safe to
          * compress archived WAL data by transforming full-block records into
          * the non-full-block format.  It is sufficient to record this at the
          * page level because we force a page switch (in fact a segment
          * switch) when starting a backup, so the flag will be off before any
          * records can be written during the backup.  At the end of a backup,
          * the last page will be marked as all unsafe when perhaps only part
          * is unsafe, but at worst the archiver would miss the opportunity to
          * compress a few records.
          */
         if (!Insert->forcePageWrites)
             NewPage->xlp_info |= XLP_BKP_REMOVABLE;
 
         /*
          * If first page of an XLOG segment file, make it a long header.
          */
         if ((XLogSegmentOffset(NewPage->xlp_pageaddr, wal_segment_size)) == 0)
         {
             XLogLongPageHeader NewLongPage = (XLogLongPageHeader) NewPage;
 
             NewLongPage->xlp_sysid = ControlFile->system_identifier;
             NewLongPage->xlp_seg_size = wal_segment_size;
             NewLongPage->xlp_xlog_blcksz = XLOG_BLCKSZ;
             NewPage->xlp_info |= XLP_LONG_HEADER;
         }
 
         /*
          * Make sure the initialization of the page becomes visible to others
          * before the xlblocks update. GetXLogBuffer() reads xlblocks without
          * holding a lock.
          */
         pg_write_barrier();
 
         *((volatile XLogRecPtr *) &XLogCtl->xlblocks[nextidx]) = NewPageEndPtr;
 
         XLogCtl->InitializedUpTo = NewPageEndPtr;
 
         npages++;
     }
     LWLockRelease(WALBufMappingLock);
 
 #ifdef WAL_DEBUG
     if (XLOG_DEBUG && npages > 0)
     {
         elog(DEBUG1, "initialized %d pages, up to %X/%X",
              npages, (uint32) (NewPageEndPtr >> 32), (uint32) NewPageEndPtr);
     }
 #endif
 }

◆ assign_checkpoint_completion_target()

void assign_checkpoint_completion_target	(	double	newval,
		void *	extra
	)

Definition at line 2327 of file xlog.c.

References CalculateCheckpointSegments(), CheckPointCompletionTarget, and newval.

 {
     CheckPointCompletionTarget = newval;
     CalculateCheckpointSegments();
 }

◆ assign_max_wal_size()

void assign_max_wal_size	(	int	newval,
		void *	extra
	)

Definition at line 2320 of file xlog.c.

References CalculateCheckpointSegments(), max_wal_size_mb, and newval.

 {
     max_wal_size_mb = newval;
     CalculateCheckpointSegments();
 }

◆ assign_xlog_sync_method()

void assign_xlog_sync_method	(	int	new_sync_method,
		void *	extra
	)

Definition at line 10361 of file xlog.c.

References ereport, errcode_for_file_access(), errmsg(), get_sync_bit(), MAXFNAMELEN, openLogFile, openLogSegNo, PANIC, pg_fsync(), pgstat_report_wait_end(), pgstat_report_wait_start(), sync_method, ThisTimeLineID, WAIT_EVENT_WAL_SYNC_METHOD_ASSIGN, wal_segment_size, XLogFileClose(), and XLogFileName.

 {
     if (sync_method != new_sync_method)
     {
         /*
          * To ensure that no blocks escape unsynced, force an fsync on the
          * currently open log segment (if any).  Also, if the open flag is
          * changing, close the log file so it will be reopened (with new flag
          * bit) at next use.
          */
         if (openLogFile >= 0)
         {
             pgstat_report_wait_start(WAIT_EVENT_WAL_SYNC_METHOD_ASSIGN);
             if (pg_fsync(openLogFile) != 0)
             {
                 char        xlogfname[MAXFNAMELEN];
                 int         save_errno;
 
                 save_errno = errno;
                 XLogFileName(xlogfname, ThisTimeLineID, openLogSegNo,
                              wal_segment_size);
                 errno = save_errno;
                 ereport(PANIC,
                         (errcode_for_file_access(),
                          errmsg("could not fsync file \"%s\": %m", xlogfname)));
             }
 
             pgstat_report_wait_end();
             if (get_sync_bit(sync_method) != get_sync_bit(new_sync_method))
                 XLogFileClose();
         }
     }
 }

◆ BackupInProgress()

bool BackupInProgress ( void )

Definition at line 11771 of file xlog.c.

References BACKUP_LABEL_FILE, and stat.

Referenced by pg_is_in_backup(), and PostmasterStateMachine().

 {
     struct stat stat_buf;
 
     return (stat(BACKUP_LABEL_FILE, &stat_buf) == 0);
 }

◆ BootStrapXLOG()

void BootStrapXLOG ( void )

Definition at line 5193 of file xlog.c.

References AdvanceOldestClogXid(), Assert, BootStrapCLOG(), BootStrapCommitTs(), BootStrapMultiXact(), BootStrapSUBTRANS(), ControlFileData::checkPoint, ControlFileData::checkPointCopy, close, COMP_CRC32C, ereport, errcode_for_file_access(), errmsg(), FIN_CRC32C, FirstBootstrapObjectId, FirstMultiXactId, FirstNormalTransactionId, CheckPoint::fullPageWrites, fullPageWrites, FullTransactionIdFromEpochAndXid(), gettimeofday(), INIT_CRC32C, InitControlFile(), InvalidTransactionId, MultiXactSetNextMXact(), CheckPoint::newestCommitTsXid, CheckPoint::nextMulti, CheckPoint::nextMultiOffset, CheckPoint::nextOid, VariableCacheData::nextOid, CheckPoint::nextXid, VariableCacheData::nextXid, offsetof, VariableCacheData::oidCount, CheckPoint::oldestActiveXid, CheckPoint::oldestCommitTsXid, CheckPoint::oldestMulti, CheckPoint::oldestMultiDB, CheckPoint::oldestXid, CheckPoint::oldestXidDB, openLogFile, palloc(), PANIC, pfree(), pg_fsync(), pgstat_report_wait_end(), pgstat_report_wait_start(), CheckPoint::PrevTimeLineID, ReadControlFile(), CheckPoint::redo, SetCommitTsLimit(), SetMultiXactIdLimit(), SetTransactionIdLimit(), ShmemVariableCache, SizeOfXLogLongPHD, SizeOfXLogRecord, SizeOfXLogRecordDataHeaderShort, CheckPoint::ThisTimeLineID, ThisTimeLineID, CheckPoint::time, ControlFileData::time, TYPEALIGN, WAIT_EVENT_WAL_BOOTSTRAP_SYNC, WAIT_EVENT_WAL_BOOTSTRAP_WRITE, wal_segment_size, write, WriteControlFile(), XLogRecord::xl_info, XLogRecord::xl_prev, XLogRecord::xl_rmid, XLogRecord::xl_tot_len, XLogRecord::xl_xid, XLOG_CHECKPOINT_SHUTDOWN, XLOG_PAGE_MAGIC, XLogFileInit(), XLogPageHeaderData::xlp_info, XLP_LONG_HEADER, XLogPageHeaderData::xlp_magic, XLogPageHeaderData::xlp_pageaddr, XLogLongPageHeaderData::xlp_seg_size, XLogLongPageHeaderData::xlp_sysid, XLogPageHeaderData::xlp_tli, XLogLongPageHeaderData::xlp_xlog_blcksz, and XLR_BLOCK_ID_DATA_SHORT.

Referenced by AuxiliaryProcessMain().

 {
     CheckPoint  checkPoint;
     char       *buffer;
     XLogPageHeader page;
     XLogLongPageHeader longpage;
     XLogRecord *record;
     char       *recptr;
     bool        use_existent;
     uint64      sysidentifier;
     struct timeval tv;
     pg_crc32c   crc;
 
     /*
      * Select a hopefully-unique system identifier code for this installation.
      * We use the result of gettimeofday(), including the fractional seconds
      * field, as being about as unique as we can easily get.  (Think not to
      * use random(), since it hasn't been seeded and there's no portable way
      * to seed it other than the system clock value...)  The upper half of the
      * uint64 value is just the tv_sec part, while the lower half contains the
      * tv_usec part (which must fit in 20 bits), plus 12 bits from our current
      * PID for a little extra uniqueness.  A person knowing this encoding can
      * determine the initialization time of the installation, which could
      * perhaps be useful sometimes.
      */
     gettimeofday(&tv, NULL);
     sysidentifier = ((uint64) tv.tv_sec) << 32;
     sysidentifier |= ((uint64) tv.tv_usec) << 12;
     sysidentifier |= getpid() & 0xFFF;
 
     /* First timeline ID is always 1 */
     ThisTimeLineID = 1;
 
     /* page buffer must be aligned suitably for O_DIRECT */
     buffer = (char *) palloc(XLOG_BLCKSZ + XLOG_BLCKSZ);
     page = (XLogPageHeader) TYPEALIGN(XLOG_BLCKSZ, buffer);
     memset(page, 0, XLOG_BLCKSZ);
 
     /*
      * Set up information for the initial checkpoint record
      *
      * The initial checkpoint record is written to the beginning of the WAL
      * segment with logid=0 logseg=1. The very first WAL segment, 0/0, is not
      * used, so that we can use 0/0 to mean "before any valid WAL segment".
      */
     checkPoint.redo = wal_segment_size + SizeOfXLogLongPHD;
     checkPoint.ThisTimeLineID = ThisTimeLineID;
     checkPoint.PrevTimeLineID = ThisTimeLineID;
     checkPoint.fullPageWrites = fullPageWrites;
     checkPoint.nextXid =
         FullTransactionIdFromEpochAndXid(0, FirstNormalTransactionId);
     checkPoint.nextOid = FirstBootstrapObjectId;
     checkPoint.nextMulti = FirstMultiXactId;
     checkPoint.nextMultiOffset = 0;
     checkPoint.oldestXid = FirstNormalTransactionId;
     checkPoint.oldestXidDB = TemplateDbOid;
     checkPoint.oldestMulti = FirstMultiXactId;
     checkPoint.oldestMultiDB = TemplateDbOid;
     checkPoint.oldestCommitTsXid = InvalidTransactionId;
     checkPoint.newestCommitTsXid = InvalidTransactionId;
     checkPoint.time = (pg_time_t) time(NULL);
     checkPoint.oldestActiveXid = InvalidTransactionId;
 
     ShmemVariableCache->nextXid = checkPoint.nextXid;
     ShmemVariableCache->nextOid = checkPoint.nextOid;
     ShmemVariableCache->oidCount = 0;
     MultiXactSetNextMXact(checkPoint.nextMulti, checkPoint.nextMultiOffset);
     AdvanceOldestClogXid(checkPoint.oldestXid);
     SetTransactionIdLimit(checkPoint.oldestXid, checkPoint.oldestXidDB);
     SetMultiXactIdLimit(checkPoint.oldestMulti, checkPoint.oldestMultiDB, true);
     SetCommitTsLimit(InvalidTransactionId, InvalidTransactionId);
 
     /* Set up the XLOG page header */
     page->xlp_magic = XLOG_PAGE_MAGIC;
     page->xlp_info = XLP_LONG_HEADER;
     page->xlp_tli = ThisTimeLineID;
     page->xlp_pageaddr = wal_segment_size;
     longpage = (XLogLongPageHeader) page;
     longpage->xlp_sysid = sysidentifier;
     longpage->xlp_seg_size = wal_segment_size;
     longpage->xlp_xlog_blcksz = XLOG_BLCKSZ;
 
     /* Insert the initial checkpoint record */
     recptr = ((char *) page + SizeOfXLogLongPHD);
     record = (XLogRecord *) recptr;
     record->xl_prev = 0;
     record->xl_xid = InvalidTransactionId;
     record->xl_tot_len = SizeOfXLogRecord + SizeOfXLogRecordDataHeaderShort + sizeof(checkPoint);
     record->xl_info = XLOG_CHECKPOINT_SHUTDOWN;
     record->xl_rmid = RM_XLOG_ID;
     recptr += SizeOfXLogRecord;
     /* fill the XLogRecordDataHeaderShort struct */
     *(recptr++) = (char) XLR_BLOCK_ID_DATA_SHORT;
     *(recptr++) = sizeof(checkPoint);
     memcpy(recptr, &checkPoint, sizeof(checkPoint));
     recptr += sizeof(checkPoint);
     Assert(recptr - (char *) record == record->xl_tot_len);
 
     INIT_CRC32C(crc);
     COMP_CRC32C(crc, ((char *) record) + SizeOfXLogRecord, record->xl_tot_len - SizeOfXLogRecord);
     COMP_CRC32C(crc, (char *) record, offsetof(XLogRecord, xl_crc));
     FIN_CRC32C(crc);
     record->xl_crc = crc;
 
     /* Create first XLOG segment file */
     use_existent = false;
     openLogFile = XLogFileInit(1, &use_existent, false);
 
     /*
      * We needn't bother with Reserve/ReleaseExternalFD here, since we'll
      * close the file again in a moment.
      */
 
     /* Write the first page with the initial record */
     errno = 0;
     pgstat_report_wait_start(WAIT_EVENT_WAL_BOOTSTRAP_WRITE);
     if (write(openLogFile, page, XLOG_BLCKSZ) != XLOG_BLCKSZ)
     {
         /* if write didn't set errno, assume problem is no disk space */
         if (errno == 0)
             errno = ENOSPC;
         ereport(PANIC,
                 (errcode_for_file_access(),
                  errmsg("could not write bootstrap write-ahead log file: %m")));
     }
     pgstat_report_wait_end();
 
     pgstat_report_wait_start(WAIT_EVENT_WAL_BOOTSTRAP_SYNC);
     if (pg_fsync(openLogFile) != 0)
         ereport(PANIC,
                 (errcode_for_file_access(),
                  errmsg("could not fsync bootstrap write-ahead log file: %m")));
     pgstat_report_wait_end();
 
     if (close(openLogFile) != 0)
         ereport(PANIC,
                 (errcode_for_file_access(),
                  errmsg("could not close bootstrap write-ahead log file: %m")));
 
     openLogFile = -1;
 
     /* Now create pg_control */
     InitControlFile(sysidentifier);
     ControlFile->time = checkPoint.time;
     ControlFile->checkPoint = checkPoint.redo;
     ControlFile->checkPointCopy = checkPoint;
 
     /* some additional ControlFile fields are set in WriteControlFile() */
     WriteControlFile();
 
     /* Bootstrap the commit log, too */
     BootStrapCLOG();
     BootStrapCommitTs();
     BootStrapSUBTRANS();
     BootStrapMultiXact();
 
     pfree(buffer);
 
     /*
      * Force control file to be read - in contrast to normal processing we'd
      * otherwise never run the checks and GUC related initializations therein.
      */
     ReadControlFile();
 }

◆ CalculateCheckpointSegments()

static void CalculateCheckpointSegments ( void )

static

Definition at line 2291 of file xlog.c.

References CheckPointCompletionTarget, CheckPointSegments, ConvertToXSegs, max_wal_size_mb, and wal_segment_size.

Referenced by assign_checkpoint_completion_target(), assign_max_wal_size(), and ReadControlFile().

 {
     double      target;
 
     /*-------
      * Calculate the distance at which to trigger a checkpoint, to avoid
      * exceeding max_wal_size_mb. This is based on two assumptions:
      *
      * a) we keep WAL for only one checkpoint cycle (prior to PG11 we kept
      *    WAL for two checkpoint cycles to allow us to recover from the
      *    secondary checkpoint if the first checkpoint failed, though we
      *    only did this on the primary anyway, not on standby. Keeping just
      *    one checkpoint simplifies processing and reduces disk space in
      *    many smaller databases.)
      * b) during checkpoint, we consume checkpoint_completion_target *
      *    number of segments consumed between checkpoints.
      *-------
      */
     target = (double) ConvertToXSegs(max_wal_size_mb, wal_segment_size) /
         (1.0 + CheckPointCompletionTarget);
 
     /* round down */
     CheckPointSegments = (int) target;
 
     if (CheckPointSegments < 1)
         CheckPointSegments = 1;
 }

◆ CancelBackup()

void CancelBackup ( void )

Definition at line 11791 of file xlog.c.

References BACKUP_LABEL_FILE, BACKUP_LABEL_OLD, DEBUG1, durable_rename(), ereport, errcode_for_file_access(), errdetail(), errmsg(), LOG, stat, TABLESPACE_MAP, TABLESPACE_MAP_OLD, and WARNING.

Referenced by PostmasterStateMachine().

 {
     struct stat stat_buf;
 
     /* if the backup_label file is not there, return */
     if (stat(BACKUP_LABEL_FILE, &stat_buf) < 0)
         return;
 
     /* remove leftover file from previously canceled backup if it exists */
     unlink(BACKUP_LABEL_OLD);
 
     if (durable_rename(BACKUP_LABEL_FILE, BACKUP_LABEL_OLD, DEBUG1) != 0)
     {
         ereport(WARNING,
                 (errcode_for_file_access(),
                  errmsg("online backup mode was not canceled"),
                  errdetail("File \"%s\" could not be renamed to \"%s\": %m.",
                            BACKUP_LABEL_FILE, BACKUP_LABEL_OLD)));
         return;
     }
 
     /* if the tablespace_map file is not there, return */
     if (stat(TABLESPACE_MAP, &stat_buf) < 0)
     {
         ereport(LOG,
                 (errmsg("online backup mode canceled"),
                  errdetail("File \"%s\" was renamed to \"%s\".",
                            BACKUP_LABEL_FILE, BACKUP_LABEL_OLD)));
         return;
     }
 
     /* remove leftover file from previously canceled backup if it exists */
     unlink(TABLESPACE_MAP_OLD);
 
     if (durable_rename(TABLESPACE_MAP, TABLESPACE_MAP_OLD, DEBUG1) == 0)
     {
         ereport(LOG,
                 (errmsg("online backup mode canceled"),
                  errdetail("Files \"%s\" and \"%s\" were renamed to "
                            "\"%s\" and \"%s\", respectively.",
                            BACKUP_LABEL_FILE, TABLESPACE_MAP,
                            BACKUP_LABEL_OLD, TABLESPACE_MAP_OLD)));
     }
     else
     {
         ereport(WARNING,
                 (errcode_for_file_access(),
                  errmsg("online backup mode canceled"),
                  errdetail("File \"%s\" was renamed to \"%s\", but "
                            "file \"%s\" could not be renamed to \"%s\": %m.",
                            BACKUP_LABEL_FILE, BACKUP_LABEL_OLD,
                            TABLESPACE_MAP, TABLESPACE_MAP_OLD)));
     }
 }

◆ check_wal_buffers()

bool check_wal_buffers	(	int *	newval,
		void **	extra,
		GucSource	source
	)

Definition at line 4986 of file xlog.c.

References XLOGbuffers, and XLOGChooseNumBuffers().

 {
     /*
      * -1 indicates a request for auto-tune.
      */
     if (*newval == -1)
     {
         /*
          * If we haven't yet changed the boot_val default of -1, just let it
          * be.  We'll fix it when XLOGShmemSize is called.
          */
         if (XLOGbuffers == -1)
             return true;
 
         /* Otherwise, substitute the auto-tune value */
         *newval = XLOGChooseNumBuffers();
     }
 
     /*
      * We clamp manually-set values to at least 4 blocks.  Prior to PostgreSQL
      * 9.1, a minimum of 4 was enforced by guc.c, but since that is no longer
      * the case, we just silently treat such values as a request for the
      * minimum.  (We could throw an error instead, but that doesn't seem very
      * helpful.)
      */
     if (*newval < 4)
         *newval = 4;
 
     return true;
 }

◆ CheckForStandbyTrigger()

static bool CheckForStandbyTrigger ( void )

static

Definition at line 12585 of file xlog.c.

References CheckPromoteSignal(), ereport, errcode_for_file_access(), errmsg(), ERROR, IsPromoteSignaled(), LocalPromoteIsTriggered, LOG, PromoteTriggerFile, RemovePromoteSignalFiles(), ResetPromoteSignaled(), SetPromoteIsTriggered(), and stat.

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

 {
     struct stat stat_buf;
 
     if (LocalPromoteIsTriggered)
         return true;
 
     if (IsPromoteSignaled() && CheckPromoteSignal())
     {
         ereport(LOG, (errmsg("received promote request")));
         RemovePromoteSignalFiles();
         ResetPromoteSignaled();
         SetPromoteIsTriggered();
         return true;
     }
 
     if (PromoteTriggerFile == NULL || strcmp(PromoteTriggerFile, "") == 0)
         return false;
 
     if (stat(PromoteTriggerFile, &stat_buf) == 0)
     {
         ereport(LOG,
                 (errmsg("promote trigger file found: %s", PromoteTriggerFile)));
         unlink(PromoteTriggerFile);
         SetPromoteIsTriggered();
         return true;
     }
     else if (errno != ENOENT)
         ereport(ERROR,
                 (errcode_for_file_access(),
                  errmsg("could not stat promote trigger file \"%s\": %m",
                         PromoteTriggerFile)));
 
     return false;
 }

◆ CheckPointGuts()

static void CheckPointGuts	(	XLogRecPtr	checkPointRedo,
		int	flags
	)

static

Definition at line 9172 of file xlog.c.

References CheckPointBuffers(), CheckPointCLOG(), CheckPointCommitTs(), CheckPointLogicalRewriteHeap(), CheckPointMultiXact(), CheckPointPredicate(), CheckPointRelationMap(), CheckPointReplicationOrigin(), CheckPointReplicationSlots(), CheckPointSnapBuild(), CheckPointSUBTRANS(), and CheckPointTwoPhase().

Referenced by CreateCheckPoint(), and CreateRestartPoint().

 {
     CheckPointCLOG();
     CheckPointCommitTs();
     CheckPointSUBTRANS();
     CheckPointMultiXact();
     CheckPointPredicate();
     CheckPointRelationMap();
     CheckPointReplicationSlots();
     CheckPointSnapBuild();
     CheckPointLogicalRewriteHeap();
     CheckPointBuffers(flags);   /* performs all required fsyncs */
     CheckPointReplicationOrigin();
     /* We deliberately delay 2PC checkpointing as long as possible */
     CheckPointTwoPhase(checkPointRedo);
 }

◆ CheckPromoteSignal()

bool CheckPromoteSignal ( void )

Definition at line 12634 of file xlog.c.

References PROMOTE_SIGNAL_FILE, and stat.

Referenced by CheckForStandbyTrigger(), and sigusr1_handler().

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

◆ CheckRecoveryConsistency()

static void CheckRecoveryConsistency ( void )

static

Definition at line 7968 of file xlog.c.

References Assert, ControlFileData::backupEndPoint, ControlFileData::backupEndRequired, ControlFileData::backupStartPoint, DEBUG1, elog, ereport, errmsg(), InArchiveRecovery, XLogCtlData::info_lck, InvalidXLogRecPtr, IsUnderPostmaster, XLogCtlData::lastReplayedEndRecPtr, LocalHotStandbyActive, LOG, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), ControlFileData::minRecoveryPoint, minRecoveryPoint, PMSIGNAL_BEGIN_HOT_STANDBY, reachedConsistency, SendPostmasterSignal(), XLogCtlData::SharedHotStandbyActive, SpinLockAcquire, SpinLockRelease, STANDBY_SNAPSHOT_READY, standbyState, UpdateControlFile(), XLogCheckInvalidPages(), and XLogRecPtrIsInvalid.

Referenced by ReadRecord(), and StartupXLOG().

 {
     XLogRecPtr  lastReplayedEndRecPtr;
 
     /*
      * During crash recovery, we don't reach a consistent state until we've
      * replayed all the WAL.
      */
     if (XLogRecPtrIsInvalid(minRecoveryPoint))
         return;
 
     Assert(InArchiveRecovery);
 
     /*
      * assume that we are called in the startup process, and hence don't need
      * a lock to read lastReplayedEndRecPtr
      */
     lastReplayedEndRecPtr = XLogCtl->lastReplayedEndRecPtr;
 
     /*
      * Have we reached the point where our base backup was completed?
      */
     if (!XLogRecPtrIsInvalid(ControlFile->backupEndPoint) &&
         ControlFile->backupEndPoint <= lastReplayedEndRecPtr)
     {
         /*
          * We have reached the end of base backup, as indicated by pg_control.
          * The data on disk is now consistent. Reset backupStartPoint and
          * backupEndPoint, and update minRecoveryPoint to make sure we don't
          * allow starting up at an earlier point even if recovery is stopped
          * and restarted soon after this.
          */
         elog(DEBUG1, "end of backup reached");
 
         LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
 
         if (ControlFile->minRecoveryPoint < lastReplayedEndRecPtr)
             ControlFile->minRecoveryPoint = lastReplayedEndRecPtr;
 
         ControlFile->backupStartPoint = InvalidXLogRecPtr;
         ControlFile->backupEndPoint = InvalidXLogRecPtr;
         ControlFile->backupEndRequired = false;
         UpdateControlFile();
 
         LWLockRelease(ControlFileLock);
     }
 
     /*
      * Have we passed our safe starting point? Note that minRecoveryPoint is
      * known to be incorrectly set if ControlFile->backupEndRequired, until
      * the XLOG_BACKUP_END arrives to advise us of the correct
      * minRecoveryPoint. All we know prior to that is that we're not
      * consistent yet.
      */
     if (!reachedConsistency && !ControlFile->backupEndRequired &&
         minRecoveryPoint <= lastReplayedEndRecPtr &&
         XLogRecPtrIsInvalid(ControlFile->backupStartPoint))
     {
         /*
          * Check to see if the XLOG sequence contained any unresolved
          * references to uninitialized pages.
          */
         XLogCheckInvalidPages();
 
         reachedConsistency = true;
         ereport(LOG,
                 (errmsg("consistent recovery state reached at %X/%X",
                         (uint32) (lastReplayedEndRecPtr >> 32),
                         (uint32) lastReplayedEndRecPtr)));
     }
 
     /*
      * Have we got a valid starting snapshot that will allow queries to be
      * run? If so, we can tell postmaster that the database is consistent now,
      * enabling connections.
      */
     if (standbyState == STANDBY_SNAPSHOT_READY &&
         !LocalHotStandbyActive &&
         reachedConsistency &&
         IsUnderPostmaster)
     {
         SpinLockAcquire(&XLogCtl->info_lck);
         XLogCtl->SharedHotStandbyActive = true;
         SpinLockRelease(&XLogCtl->info_lck);
 
         LocalHotStandbyActive = true;
 
         SendPostmasterSignal(PMSIGNAL_BEGIN_HOT_STANDBY);
     }
 }

◆ CheckRequiredParameterValues()

static void CheckRequiredParameterValues ( void )

static

Definition at line 6255 of file xlog.c.

References ArchiveRecoveryRequested, EnableHotStandby, ereport, errhint(), errmsg(), ERROR, max_locks_per_xact, ControlFileData::max_locks_per_xact, max_prepared_xacts, ControlFileData::max_prepared_xacts, max_wal_senders, ControlFileData::max_wal_senders, max_worker_processes, ControlFileData::max_worker_processes, MaxConnections, ControlFileData::MaxConnections, RecoveryRequiresIntParameter, ControlFileData::wal_level, WAL_LEVEL_MINIMAL, WAL_LEVEL_REPLICA, and WARNING.

Referenced by StartupXLOG(), and xlog_redo().

 {
     /*
      * For archive recovery, the WAL must be generated with at least 'replica'
      * wal_level.
      */
     if (ArchiveRecoveryRequested && ControlFile->wal_level == WAL_LEVEL_MINIMAL)
     {
         ereport(WARNING,
                 (errmsg("WAL was generated with wal_level=minimal, data may be missing"),
                  errhint("This happens if you temporarily set wal_level=minimal without taking a new base backup.")));
     }
 
     /*
      * For Hot Standby, the WAL must be generated with 'replica' mode, and we
      * must have at least as many backend slots as the primary.
      */
     if (ArchiveRecoveryRequested && EnableHotStandby)
     {
         if (ControlFile->wal_level < WAL_LEVEL_REPLICA)
             ereport(ERROR,
                     (errmsg("hot standby is not possible because wal_level was not set to \"replica\" or higher on the primary server"),
                      errhint("Either set wal_level to \"replica\" on the primary, or turn off hot_standby here.")));
 
         /* We ignore autovacuum_max_workers when we make this test. */
         RecoveryRequiresIntParameter("max_connections",
                                      MaxConnections,
                                      ControlFile->MaxConnections);
         RecoveryRequiresIntParameter("max_worker_processes",
                                      max_worker_processes,
                                      ControlFile->max_worker_processes);
         RecoveryRequiresIntParameter("max_wal_senders",
                                      max_wal_senders,
                                      ControlFile->max_wal_senders);
         RecoveryRequiresIntParameter("max_prepared_transactions",
                                      max_prepared_xacts,
                                      ControlFile->max_prepared_xacts);
         RecoveryRequiresIntParameter("max_locks_per_transaction",
                                      max_locks_per_xact,
                                      ControlFile->max_locks_per_xact);
     }
 }

◆ checkTimeLineSwitch()

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

static

Definition at line 9850 of file xlog.c.

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

Referenced by StartupXLOG().

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

◆ checkXLogConsistency()

static void checkXLogConsistency ( XLogReaderState * record )

static

Definition at line 1404 of file xlog.c.

References Assert, buf, BUFFER_LOCK_EXCLUSIVE, BufferGetPage, BufferIsValid, RelFileNode::dbNode, elog, XLogReaderState::EndRecPtr, ERROR, FATAL, LockBuffer(), XLogReaderState::max_block_id, PageGetLSN, primary_image_masked, RBM_NORMAL_NO_LOG, RelFileNode::relNode, replay_image_masked, RestoreBlockImage(), RmgrData::rm_mask, RmgrTable, RelFileNode::spcNode, UnlockReleaseBuffer(), XLogReadBufferExtended(), XLogRecBlockImageApply, XLogRecGetBlockTag(), XLogRecGetInfo, XLogRecGetRmid, XLogRecHasAnyBlockRefs, XLogRecHasBlockImage, and XLR_CHECK_CONSISTENCY.

Referenced by StartupXLOG().

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

◆ CheckXLogRemoved()

void CheckXLogRemoved	(	XLogSegNo	segno,
		TimeLineID	tli
	)

Definition at line 3925 of file xlog.c.

References ereport, errcode_for_file_access(), errmsg(), ERROR, filename, XLogCtlData::info_lck, XLogCtlData::lastRemovedSegNo, MAXFNAMELEN, SpinLockAcquire, SpinLockRelease, wal_segment_size, and XLogFileName.

Referenced by logical_read_xlog_page(), perform_base_backup(), and XLogSendPhysical().

 {
     int         save_errno = errno;
     XLogSegNo   lastRemovedSegNo;
 
     SpinLockAcquire(&XLogCtl->info_lck);
     lastRemovedSegNo = XLogCtl->lastRemovedSegNo;
     SpinLockRelease(&XLogCtl->info_lck);
 
     if (segno <= lastRemovedSegNo)
     {
         char        filename[MAXFNAMELEN];
 
         XLogFileName(filename, tli, segno, wal_segment_size);
         errno = save_errno;
         ereport(ERROR,
                 (errcode_for_file_access(),
                  errmsg("requested WAL segment %s has already been removed",
                         filename)));
     }
     errno = save_errno;
 }

◆ CleanupBackupHistory()

static void CleanupBackupHistory ( void )

static

Definition at line 4289 of file xlog.c.

References AllocateDir(), dirent::d_name, DEBUG2, elog, FreeDir(), IsBackupHistoryFileName, MAXPGPATH, ReadDir(), snprintf, XLogArchiveCheckDone(), XLogArchiveCleanup(), and XLOGDIR.

Referenced by do_pg_stop_backup().

 {
     DIR        *xldir;
     struct dirent *xlde;
     char        path[MAXPGPATH + sizeof(XLOGDIR)];
 
     xldir = AllocateDir(XLOGDIR);
 
     while ((xlde = ReadDir(xldir, XLOGDIR)) != NULL)
     {
         if (IsBackupHistoryFileName(xlde->d_name))
         {
             if (XLogArchiveCheckDone(xlde->d_name))
             {
                 elog(DEBUG2, "removing WAL backup history file \"%s\"",
                      xlde->d_name);
                 snprintf(path, sizeof(path), XLOGDIR "/%s", xlde->d_name);
                 unlink(path);
                 XLogArchiveCleanup(xlde->d_name);
             }
         }
     }
 
     FreeDir(xldir);
 }

◆ CopyXLogRecordToWAL()

static void CopyXLogRecordToWAL	(	int	write_len,
		bool	isLogSwitch,
		XLogRecData *	rdata,
		XLogRecPtr	StartPos,
		XLogRecPtr	EndPos
	)

static

Definition at line 1508 of file xlog.c.

References Assert, XLogRecData::data, elog, GetXLogBuffer(), INSERT_FREESPACE, XLogRecData::len, MAXALIGN64, MemSet, XLogRecData::next, PANIC, SizeOfXLogLongPHD, SizeOfXLogRecord, SizeOfXLogShortPHD, wal_segment_size, XLogSegmentOffset, XLP_FIRST_IS_CONTRECORD, XLogPageHeaderData::xlp_info, and XLogPageHeaderData::xlp_rem_len.

Referenced by XLogInsertRecord().

 {
     char       *currpos;
     int         freespace;
     int         written;
     XLogRecPtr  CurrPos;
     XLogPageHeader pagehdr;
 
     /*
      * Get a pointer to the right place in the right WAL buffer to start
      * inserting to.
      */
     CurrPos = StartPos;
     currpos = GetXLogBuffer(CurrPos);
     freespace = INSERT_FREESPACE(CurrPos);
 
     /*
      * there should be enough space for at least the first field (xl_tot_len)
      * on this page.
      */
     Assert(freespace >= sizeof(uint32));
 
     /* Copy record data */
     written = 0;
     while (rdata != NULL)
     {
         char       *rdata_data = rdata->data;
         int         rdata_len = rdata->len;
 
         while (rdata_len > freespace)
         {
             /*
              * Write what fits on this page, and continue on the next page.
              */
             Assert(CurrPos % XLOG_BLCKSZ >= SizeOfXLogShortPHD || freespace == 0);
             memcpy(currpos, rdata_data, freespace);
             rdata_data += freespace;
             rdata_len -= freespace;
             written += freespace;
             CurrPos += freespace;
 
             /*
              * Get pointer to beginning of next page, and set the xlp_rem_len
              * in the page header. Set XLP_FIRST_IS_CONTRECORD.
              *
              * It's safe to set the contrecord flag and xlp_rem_len without a
              * lock on the page. All the other flags were already set when the
              * page was initialized, in AdvanceXLInsertBuffer, and we're the
              * only backend that needs to set the contrecord flag.
              */
             currpos = GetXLogBuffer(CurrPos);
             pagehdr = (XLogPageHeader) currpos;
             pagehdr->xlp_rem_len = write_len - written;
             pagehdr->xlp_info |= XLP_FIRST_IS_CONTRECORD;
 
             /* skip over the page header */
             if (XLogSegmentOffset(CurrPos, wal_segment_size) == 0)
             {
                 CurrPos += SizeOfXLogLongPHD;
                 currpos += SizeOfXLogLongPHD;
             }
             else
             {
                 CurrPos += SizeOfXLogShortPHD;
                 currpos += SizeOfXLogShortPHD;
             }
             freespace = INSERT_FREESPACE(CurrPos);
         }
 
         Assert(CurrPos % XLOG_BLCKSZ >= SizeOfXLogShortPHD || rdata_len == 0);
         memcpy(currpos, rdata_data, rdata_len);
         currpos += rdata_len;
         CurrPos += rdata_len;
         freespace -= rdata_len;
         written += rdata_len;
 
         rdata = rdata->next;
     }
     Assert(written == write_len);
 
     /*
      * If this was an xlog-switch, it's not enough to write the switch record,
      * we also have to consume all the remaining space in the WAL segment.  We
      * have already reserved that space, but we need to actually fill it.
      */
     if (isLogSwitch && XLogSegmentOffset(CurrPos, wal_segment_size) != 0)
     {
         /* An xlog-switch record doesn't contain any data besides the header */
         Assert(write_len == SizeOfXLogRecord);
 
         /* Assert that we did reserve the right amount of space */
         Assert(XLogSegmentOffset(EndPos, wal_segment_size) == 0);
 
         /* Use up all the remaining space on the current page */
         CurrPos += freespace;
 
         /*
          * Cause all remaining pages in the segment to be flushed, leaving the
          * XLog position where it should be, at the start of the next segment.
          * We do this one page at a time, to make sure we don't deadlock
          * against ourselves if wal_buffers < wal_segment_size.
          */
         while (CurrPos < EndPos)
         {
             /*
              * The minimal action to flush the page would be to call
              * WALInsertLockUpdateInsertingAt(CurrPos) followed by
              * AdvanceXLInsertBuffer(...).  The page would be left initialized
              * mostly to zeros, except for the page header (always the short
              * variant, as this is never a segment's first page).
              *
              * The large vistas of zeros are good for compressibility, but the
              * headers interrupting them every XLOG_BLCKSZ (with values that
              * differ from page to page) are not.  The effect varies with
              * compression tool, but bzip2 for instance compresses about an
              * order of magnitude worse if those headers are left in place.
              *
              * Rather than complicating AdvanceXLInsertBuffer itself (which is
              * called in heavily-loaded circumstances as well as this lightly-
              * loaded one) with variant behavior, we just use GetXLogBuffer
              * (which itself calls the two methods we need) to get the pointer
              * and zero most of the page.  Then we just zero the page header.
              */
             currpos = GetXLogBuffer(CurrPos);
             MemSet(currpos, 0, SizeOfXLogShortPHD);
 
             CurrPos += XLOG_BLCKSZ;
         }
     }
     else
     {
         /* Align the end position, so that the next record starts aligned */
         CurrPos = MAXALIGN64(CurrPos);
     }
 
     if (CurrPos != EndPos)
         elog(PANIC, "space reserved for WAL record does not match what was written");
 }

◆ CreateCheckPoint()

void CreateCheckPoint ( int flags )

Definition at line 8701 of file xlog.c.

References ControlFileData::checkPoint, CHECKPOINT_END_OF_RECOVERY, CHECKPOINT_FORCE, CHECKPOINT_IS_SHUTDOWN, ControlFileData::checkPointCopy, CheckPointGuts(), CheckpointStatsData::ckpt_bufs_written, CheckpointStatsData::ckpt_segs_added, CheckpointStatsData::ckpt_segs_recycled, CheckpointStatsData::ckpt_segs_removed, CheckpointStatsData::ckpt_start_t, XLogCtlData::ckptFullXid, XLogCtlInsert::CurrBytePos, DB_SHUTDOWNED, DB_SHUTDOWNING, DEBUG1, elog, END_CRIT_SECTION, ereport, errmsg(), ERROR, CheckPoint::fullPageWrites, XLogCtlInsert::fullPageWrites, GetCurrentTimestamp(), GetLastImportantRecPtr(), GetOldestActiveTransactionId(), GetOldestXmin(), GetVirtualXIDsDelayingChkpt(), HaveVirtualXIDsDelayingChkpt(), XLogCtlData::info_lck, InitXLogInsert(), Insert(), XLogCtlData::Insert, INSERT_FREESPACE, InvalidateObsoleteReplicationSlots(), InvalidTransactionId, InvalidXLogRecPtr, KeepLogSeg(), LocalSetXLogInsertAllowed(), LocalXLogInsertAllowed, log_checkpoints, LogCheckpointEnd(), LogCheckpointStart(), LogStandbySnapshot(), LW_EXCLUSIVE, LW_SHARED, LWLockAcquire(), LWLockRelease(), MemSet, ControlFileData::minRecoveryPoint, ControlFileData::minRecoveryPointTLI, MultiXactGetCheckptMulti(), NBuffers, CheckPoint::newestCommitTsXid, VariableCacheData::newestCommitTsXid, CheckPoint::nextMulti, CheckPoint::nextMultiOffset, CheckPoint::nextOid, VariableCacheData::nextOid, CheckPoint::nextXid, VariableCacheData::nextXid, VariableCacheData::oidCount, CheckPoint::oldestActiveXid, CheckPoint::oldestCommitTsXid, VariableCacheData::oldestCommitTsXid, CheckPoint::oldestMulti, CheckPoint::oldestMultiDB, CheckPoint::oldestXid, VariableCacheData::oldestXid, CheckPoint::oldestXidDB, VariableCacheData::oldestXidDB, PANIC, pfree(), pg_usleep(), PreallocXlogFiles(), CheckPoint::PrevTimeLineID, XLogCtlData::PrevTimeLineID, PROCARRAY_FLAGS_DEFAULT, ProcLastRecPtr, RecoveryInProgress(), CheckPoint::redo, RedoRecPtr, XLogCtlInsert::RedoRecPtr, XLogCtlData::RedoRecPtr, RemoveOldXlogFiles(), ShmemVariableCache, SizeOfXLogLongPHD, SizeOfXLogShortPHD, SpinLockAcquire, SpinLockRelease, START_CRIT_SECTION, ControlFileData::state, SyncPostCheckpoint(), SyncPreCheckpoint(), CheckPoint::ThisTimeLineID, ThisTimeLineID, CheckPoint::time, ControlFileData::time, TruncateSUBTRANS(), XLogCtlData::ulsn_lck, ControlFileData::unloggedLSN, XLogCtlData::unloggedLSN, UpdateCheckPointDistanceEstimate(), UpdateControlFile(), wal_segment_size, WALInsertLockAcquireExclusive(), WALInsertLockRelease(), XLByteToSeg, XLOG_CHECKPOINT_ONLINE, XLOG_CHECKPOINT_SHUTDOWN, XLogBeginInsert(), XLogBytePosToRecPtr(), XLogFlush(), XLogInsert(), XLogRegisterData(), XLogSegmentOffset, and XLogStandbyInfoActive.

Referenced by CheckpointerMain(), RequestCheckpoint(), ShutdownXLOG(), and StartupXLOG().

 {
     bool        shutdown;
     CheckPoint  checkPoint;
     XLogRecPtr  recptr;
     XLogSegNo   _logSegNo;
     XLogCtlInsert *Insert = &XLogCtl->Insert;
     uint32      freespace;
     XLogRecPtr  PriorRedoPtr;
     XLogRecPtr  curInsert;
     XLogRecPtr  last_important_lsn;
     VirtualTransactionId *vxids;
     int         nvxids;
 
     /*
      * An end-of-recovery checkpoint is really a shutdown checkpoint, just
      * issued at a different time.
      */
     if (flags & (CHECKPOINT_IS_SHUTDOWN | CHECKPOINT_END_OF_RECOVERY))
         shutdown = true;
     else
         shutdown = false;
 
     /* sanity check */
     if (RecoveryInProgress() && (flags & CHECKPOINT_END_OF_RECOVERY) == 0)
         elog(ERROR, "can't create a checkpoint during recovery");
 
     /*
      * Initialize InitXLogInsert working areas before entering the critical
      * section.  Normally, this is done by the first call to
      * RecoveryInProgress() or LocalSetXLogInsertAllowed(), but when creating
      * an end-of-recovery checkpoint, the LocalSetXLogInsertAllowed call is
      * done below in a critical section, and InitXLogInsert cannot be called
      * in a critical section.
      */
     InitXLogInsert();
 
     /*
      * Acquire CheckpointLock to ensure only one checkpoint happens at a time.
      * (This is just pro forma, since in the present system structure there is
      * only one process that is allowed to issue checkpoints at any given
      * time.)
      */
     LWLockAcquire(CheckpointLock, LW_EXCLUSIVE);
 
     /*
      * Prepare to accumulate statistics.
      *
      * Note: because it is possible for log_checkpoints to change while a
      * checkpoint proceeds, we always accumulate stats, even if
      * log_checkpoints is currently off.
      */
     MemSet(&CheckpointStats, 0, sizeof(CheckpointStats));
     CheckpointStats.ckpt_start_t = GetCurrentTimestamp();
 
     /*
      * Use a critical section to force system panic if we have trouble.
      */
     START_CRIT_SECTION();
 
     if (shutdown)
     {
         LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
         ControlFile->state = DB_SHUTDOWNING;
         ControlFile->time = (pg_time_t) time(NULL);
         UpdateControlFile();
         LWLockRelease(ControlFileLock);
     }
 
     /*
      * Let smgr prepare for checkpoint; this has to happen before we determine
      * the REDO pointer.  Note that smgr must not do anything that'd have to
      * be undone if we decide no checkpoint is needed.
      */
     SyncPreCheckpoint();
 
     /* Begin filling in the checkpoint WAL record */
     MemSet(&checkPoint, 0, sizeof(checkPoint));
     checkPoint.time = (pg_time_t) time(NULL);
 
     /*
      * For Hot Standby, derive the oldestActiveXid before we fix the redo
      * pointer. This allows us to begin accumulating changes to assemble our
      * starting snapshot of locks and transactions.
      */
     if (!shutdown && XLogStandbyInfoActive())
         checkPoint.oldestActiveXid = GetOldestActiveTransactionId();
     else
         checkPoint.oldestActiveXid = InvalidTransactionId;
 
     /*
      * Get location of last important record before acquiring insert locks (as
      * GetLastImportantRecPtr() also locks WAL locks).
      */
     last_important_lsn = GetLastImportantRecPtr();
 
     /*
      * We must block concurrent insertions while examining insert state to
      * determine the checkpoint REDO pointer.
      */
     WALInsertLockAcquireExclusive();
     curInsert = XLogBytePosToRecPtr(Insert->CurrBytePos);
 
     /*
      * If this isn't a shutdown or forced checkpoint, and if there has been no
      * WAL activity requiring a checkpoint, skip it.  The idea here is to
      * avoid inserting duplicate checkpoints when the system is idle.
      */
     if ((flags & (CHECKPOINT_IS_SHUTDOWN | CHECKPOINT_END_OF_RECOVERY |
                   CHECKPOINT_FORCE)) == 0)
     {
         if (last_important_lsn == ControlFile->checkPoint)
         {
             WALInsertLockRelease();
             LWLockRelease(CheckpointLock);
             END_CRIT_SECTION();
             ereport(DEBUG1,
                     (errmsg("checkpoint skipped because system is idle")));
             return;
         }
     }
 
     /*
      * An end-of-recovery checkpoint is created before anyone is allowed to
      * write WAL. To allow us to write the checkpoint record, temporarily
      * enable XLogInsertAllowed.  (This also ensures ThisTimeLineID is
      * initialized, which we need here and in AdvanceXLInsertBuffer.)
      */
     if (flags & CHECKPOINT_END_OF_RECOVERY)
         LocalSetXLogInsertAllowed();
 
     checkPoint.ThisTimeLineID = ThisTimeLineID;
     if (flags & CHECKPOINT_END_OF_RECOVERY)
         checkPoint.PrevTimeLineID = XLogCtl->PrevTimeLineID;
     else
         checkPoint.PrevTimeLineID = ThisTimeLineID;
 
     checkPoint.fullPageWrites = Insert->fullPageWrites;
 
     /*
      * Compute new REDO record ptr = location of next XLOG record.
      *
      * NB: this is NOT necessarily where the checkpoint record itself will be,
      * since other backends may insert more XLOG records while we're off doing
      * the buffer flush work.  Those XLOG records are logically after the
      * checkpoint, even though physically before it.  Got that?
      */
     freespace = INSERT_FREESPACE(curInsert);
     if (freespace == 0)
     {
         if (XLogSegmentOffset(curInsert, wal_segment_size) == 0)
             curInsert += SizeOfXLogLongPHD;
         else
             curInsert += SizeOfXLogShortPHD;
     }
     checkPoint.redo = curInsert;
 
     /*
      * Here we update the shared RedoRecPtr for future XLogInsert calls; this
      * must be done while holding all the insertion locks.
      *
      * Note: if we fail to complete the checkpoint, RedoRecPtr will be left
      * pointing past where it really needs to point.  This is okay; the only
      * consequence is that XLogInsert might back up whole buffers that it
      * didn't really need to.  We can't postpone advancing RedoRecPtr because
      * XLogInserts that happen while we are dumping buffers must assume that
      * their buffer changes are not included in the checkpoint.
      */
     RedoRecPtr = XLogCtl->Insert.RedoRecPtr = checkPoint.redo;
 
     /*
      * Now we can release the WAL insertion locks, allowing other xacts to
      * proceed while we are flushing disk buffers.
      */
     WALInsertLockRelease();
 
     /* Update the info_lck-protected copy of RedoRecPtr as well */
     SpinLockAcquire(&XLogCtl->info_lck);
     XLogCtl->RedoRecPtr = checkPoint.redo;
     SpinLockRelease(&XLogCtl->info_lck);
 
     /*
      * If enabled, log checkpoint start.  We postpone this until now so as not
      * to log anything if we decided to skip the checkpoint.
      */
     if (log_checkpoints)
         LogCheckpointStart(flags, false);
 
     TRACE_POSTGRESQL_CHECKPOINT_START(flags);
 
     /*
      * Get the other info we need for the checkpoint record.
      *
      * We don't need to save oldestClogXid in the checkpoint, it only matters
      * for the short period in which clog is being truncated, and if we crash
      * during that we'll redo the clog truncation and fix up oldestClogXid
      * there.
      */
     LWLockAcquire(XidGenLock, LW_SHARED);
     checkPoint.nextXid = ShmemVariableCache->nextXid;
     checkPoint.oldestXid = ShmemVariableCache->oldestXid;
     checkPoint.oldestXidDB = ShmemVariableCache->oldestXidDB;
     LWLockRelease(XidGenLock);
 
     LWLockAcquire(CommitTsLock, LW_SHARED);
     checkPoint.oldestCommitTsXid = ShmemVariableCache->oldestCommitTsXid;
     checkPoint.newestCommitTsXid = ShmemVariableCache->newestCommitTsXid;
     LWLockRelease(CommitTsLock);
 
     LWLockAcquire(OidGenLock, LW_SHARED);
     checkPoint.nextOid = ShmemVariableCache->nextOid;
     if (!shutdown)
         checkPoint.nextOid += ShmemVariableCache->oidCount;
     LWLockRelease(OidGenLock);
 
     MultiXactGetCheckptMulti(shutdown,
                              &checkPoint.nextMulti,
                              &checkPoint.nextMultiOffset,
                              &checkPoint.oldestMulti,
                              &checkPoint.oldestMultiDB);
 
     /*
      * Having constructed the checkpoint record, ensure all shmem disk buffers
      * and commit-log buffers are flushed to disk.
      *
      * This I/O could fail for various reasons.  If so, we will fail to
      * complete the checkpoint, but there is no reason to force a system
      * panic. Accordingly, exit critical section while doing it.
      */
     END_CRIT_SECTION();
 
     /*
      * In some cases there are groups of actions that must all occur on one
      * side or the other of a checkpoint record. Before flushing the
      * checkpoint record we must explicitly wait for any backend currently
      * performing those groups of actions.
      *
      * One example is end of transaction, so we must wait for any transactions
      * that are currently in commit critical sections.  If an xact inserted
      * its commit record into XLOG just before the REDO point, then a crash
      * restart from the REDO point would not replay that record, which means
      * that our flushing had better include the xact's update of pg_xact.  So
      * we wait till he's out of his commit critical section before proceeding.
      * See notes in RecordTransactionCommit().
      *
      * Because we've already released the insertion locks, this test is a bit
      * fuzzy: it is possible that we will wait for xacts we didn't really need
      * to wait for.  But the delay should be short and it seems better to make
      * checkpoint take a bit longer than to hold off insertions longer than
      * necessary. (In fact, the whole reason we have this issue is that xact.c
      * does commit record XLOG insertion and clog update as two separate steps
      * protected by different locks, but again that seems best on grounds of
      * minimizing lock contention.)
      *
      * A transaction that has not yet set delayChkpt when we look cannot be at
      * risk, since he's not inserted his commit record yet; and one that's
      * already cleared it is not at risk either, since he's done fixing clog
      * and we will correctly flush the update below.  So we cannot miss any
      * xacts we need to wait for.
      */
     vxids = GetVirtualXIDsDelayingChkpt(&nvxids);
     if (nvxids > 0)
     {
         do
         {
             pg_usleep(10000L);  /* wait for 10 msec */
         } while (HaveVirtualXIDsDelayingChkpt(vxids, nvxids));
     }
     pfree(vxids);
 
     CheckPointGuts(checkPoint.redo, flags);
 
     /*
      * Take a snapshot of running transactions and write this to WAL. This
      * allows us to reconstruct the state of running transactions during
      * archive recovery, if required. Skip, if this info disabled.
      *
      * If we are shutting down, or Startup process is completing crash
      * recovery we don't need to write running xact data.
      */
     if (!shutdown && XLogStandbyInfoActive())
         LogStandbySnapshot();
 
     START_CRIT_SECTION();
 
     /*
      * Now insert the checkpoint record into XLOG.
      */
     XLogBeginInsert();
     XLogRegisterData((char *) (&checkPoint), sizeof(checkPoint));
     recptr = XLogInsert(RM_XLOG_ID,
                         shutdown ? XLOG_CHECKPOINT_SHUTDOWN :
                         XLOG_CHECKPOINT_ONLINE);
 
     XLogFlush(recptr);
 
     /*
      * We mustn't write any new WAL after a shutdown checkpoint, or it will be
      * overwritten at next startup.  No-one should even try, this just allows
      * sanity-checking.  In the case of an end-of-recovery checkpoint, we want
      * to just temporarily disable writing until the system has exited
      * recovery.
      */
     if (shutdown)
     {
         if (flags & CHECKPOINT_END_OF_RECOVERY)
             LocalXLogInsertAllowed = -1;    /* return to "check" state */
         else
             LocalXLogInsertAllowed = 0; /* never again write WAL */
     }
 
     /*
      * We now have ProcLastRecPtr = start of actual checkpoint record, recptr
      * = end of actual checkpoint record.
      */
     if (shutdown && checkPoint.redo != ProcLastRecPtr)
         ereport(PANIC,
                 (errmsg("concurrent write-ahead log activity while database system is shutting down")));
 
     /*
      * Remember the prior checkpoint's redo ptr for
      * UpdateCheckPointDistanceEstimate()
      */
     PriorRedoPtr = ControlFile->checkPointCopy.redo;
 
     /*
      * Update the control file.
      */
     LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
     if (shutdown)
         ControlFile->state = DB_SHUTDOWNED;
     ControlFile->checkPoint = ProcLastRecPtr;
     ControlFile->checkPointCopy = checkPoint;
     ControlFile->time = (pg_time_t) time(NULL);
     /* crash recovery should always recover to the end of WAL */
     ControlFile->minRecoveryPoint = InvalidXLogRecPtr;
     ControlFile->minRecoveryPointTLI = 0;
 
     /*
      * Persist unloggedLSN value. It's reset on crash recovery, so this goes
      * unused on non-shutdown checkpoints, but seems useful to store it always
      * for debugging purposes.
      */
     SpinLockAcquire(&XLogCtl->ulsn_lck);
     ControlFile->unloggedLSN = XLogCtl->unloggedLSN;
     SpinLockRelease(&XLogCtl->ulsn_lck);
 
     UpdateControlFile();
     LWLockRelease(ControlFileLock);
 
     /* Update shared-memory copy of checkpoint XID/epoch */
     SpinLockAcquire(&XLogCtl->info_lck);
     XLogCtl->ckptFullXid = checkPoint.nextXid;
     SpinLockRelease(&XLogCtl->info_lck);
 
     /*
      * We are now done with critical updates; no need for system panic if we
      * have trouble while fooling with old log segments.
      */
     END_CRIT_SECTION();
 
     /*
      * Let smgr do post-checkpoint cleanup (eg, deleting old files).
      */
     SyncPostCheckpoint();
 
     /*
      * Update the average distance between checkpoints if the prior checkpoint
      * exists.
      */
     if (PriorRedoPtr != InvalidXLogRecPtr)
         UpdateCheckPointDistanceEstimate(RedoRecPtr - PriorRedoPtr);
 
     /*
      * Delete old log files, those no longer needed for last checkpoint to
      * prevent the disk holding the xlog from growing full.
      */
     XLByteToSeg(RedoRecPtr, _logSegNo, wal_segment_size);
     KeepLogSeg(recptr, &_logSegNo);
     InvalidateObsoleteReplicationSlots(_logSegNo);
     _logSegNo--;
     RemoveOldXlogFiles(_logSegNo, RedoRecPtr, recptr);
 
     /*
      * Make more log segments if needed.  (Do this after recycling old log
      * segments, since that may supply some of the needed files.)
      */
     if (!shutdown)
         PreallocXlogFiles(recptr);
 
     /*
      * Truncate pg_subtrans if possible.  We can throw away all data before
      * the oldest XMIN of any running transaction.  No future transaction will
      * attempt to reference any pg_subtrans entry older than that (see Asserts
      * in subtrans.c).  During recovery, though, we mustn't do this because
      * StartupSUBTRANS hasn't been called yet.
      */
     if (!RecoveryInProgress())
         TruncateSUBTRANS(GetOldestXmin(NULL, PROCARRAY_FLAGS_DEFAULT));
 
     /* Real work is done, but log and update stats before releasing lock. */
     LogCheckpointEnd(false);
 
     TRACE_POSTGRESQL_CHECKPOINT_DONE(CheckpointStats.ckpt_bufs_written,
                                      NBuffers,
                                      CheckpointStats.ckpt_segs_added,
                                      CheckpointStats.ckpt_segs_removed,
                                      CheckpointStats.ckpt_segs_recycled);
 
     LWLockRelease(CheckpointLock);
 }

◆ CreateEndOfRecoveryRecord()

static void CreateEndOfRecoveryRecord ( void )

static

Definition at line 9123 of file xlog.c.

References elog, END_CRIT_SECTION, xl_end_of_recovery::end_time, ERROR, GetCurrentTimestamp(), LocalSetXLogInsertAllowed(), LocalXLogInsertAllowed, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), ControlFileData::minRecoveryPoint, ControlFileData::minRecoveryPointTLI, xl_end_of_recovery::PrevTimeLineID, XLogCtlData::PrevTimeLineID, RecoveryInProgress(), START_CRIT_SECTION, ThisTimeLineID, xl_end_of_recovery::ThisTimeLineID, ControlFileData::time, UpdateControlFile(), WALInsertLockAcquireExclusive(), WALInsertLockRelease(), XLOG_END_OF_RECOVERY, XLogBeginInsert(), XLogFlush(), XLogInsert(), and XLogRegisterData().

Referenced by StartupXLOG().

 {
     xl_end_of_recovery xlrec;
     XLogRecPtr  recptr;
 
     /* sanity check */
     if (!RecoveryInProgress())
         elog(ERROR, "can only be used to end recovery");
 
     xlrec.end_time = GetCurrentTimestamp();
 
     WALInsertLockAcquireExclusive();
     xlrec.ThisTimeLineID = ThisTimeLineID;
     xlrec.PrevTimeLineID = XLogCtl->PrevTimeLineID;
     WALInsertLockRelease();
 
     LocalSetXLogInsertAllowed();
 
     START_CRIT_SECTION();
 
     XLogBeginInsert();
     XLogRegisterData((char *) &xlrec, sizeof(xl_end_of_recovery));
     recptr = XLogInsert(RM_XLOG_ID, XLOG_END_OF_RECOVERY);
 
     XLogFlush(recptr);
 
     /*
      * Update the control file so that crash recovery can follow the timeline
      * changes to this point.
      */
     LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
     ControlFile->time = (pg_time_t) time(NULL);
     ControlFile->minRecoveryPoint = recptr;
     ControlFile->minRecoveryPointTLI = ThisTimeLineID;
     UpdateControlFile();
     LWLockRelease(ControlFileLock);
 
     END_CRIT_SECTION();
 
     LocalXLogInsertAllowed = -1;    /* return to "check" state */
 }

◆ CreateRestartPoint()

bool CreateRestartPoint ( int flags )

Definition at line 9242 of file xlog.c.

References archiveCleanupCommand, ControlFileData::checkPoint, CHECKPOINT_IS_SHUTDOWN, ControlFileData::checkPointCopy, CheckPointGuts(), CheckpointStatsData::ckpt_start_t, DB_IN_ARCHIVE_RECOVERY, DB_SHUTDOWNED_IN_RECOVERY, DEBUG2, EnableHotStandby, ereport, errdetail(), errmsg(), ExecuteRecoveryCommand(), GetCurrentTimestamp(), GetLatestXTime(), GetOldestXmin(), GetWalRcvFlushRecPtr(), GetXLogReplayRecPtr(), XLogCtlData::info_lck, XLogCtlData::Insert, InvalidateObsoleteReplicationSlots(), InvalidXLogRecPtr, KeepLogSeg(), XLogCtlData::lastCheckPoint, XLogCtlData::lastCheckPointEndPtr, XLogCtlData::lastCheckPointRecPtr, LOG, log_checkpoints, LogCheckpointEnd(), LogCheckpointStart(), LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MemSet, ControlFileData::minRecoveryPoint, minRecoveryPoint, ControlFileData::minRecoveryPointTLI, minRecoveryPointTLI, PreallocXlogFiles(), PROCARRAY_FLAGS_DEFAULT, RecoveryInProgress(), CheckPoint::redo, RedoRecPtr, XLogCtlInsert::RedoRecPtr, XLogCtlData::RedoRecPtr, RemoveOldXlogFiles(), SpinLockAcquire, SpinLockRelease, ControlFileData::state, CheckPoint::ThisTimeLineID, ThisTimeLineID, ControlFileData::time, timestamptz_to_str(), TruncateSUBTRANS(), UpdateCheckPointDistanceEstimate(), UpdateControlFile(), UpdateMinRecoveryPoint(), wal_segment_size, WALInsertLockAcquireExclusive(), WALInsertLockRelease(), XLByteToSeg, and XLogRecPtrIsInvalid.

Referenced by CheckpointerMain(), and ShutdownXLOG().

 {
     XLogRecPtr  lastCheckPointRecPtr;
     XLogRecPtr  lastCheckPointEndPtr;
     CheckPoint  lastCheckPoint;
     XLogRecPtr  PriorRedoPtr;
     XLogRecPtr  receivePtr;
     XLogRecPtr  replayPtr;
     TimeLineID  replayTLI;
     XLogRecPtr  endptr;
     XLogSegNo   _logSegNo;
     TimestampTz xtime;
 
     /*
      * Acquire CheckpointLock to ensure only one restartpoint or checkpoint
      * happens at a time.
      */
     LWLockAcquire(CheckpointLock, LW_EXCLUSIVE);
 
     /* Get a local copy of the last safe checkpoint record. */
     SpinLockAcquire(&XLogCtl->info_lck);
     lastCheckPointRecPtr = XLogCtl->lastCheckPointRecPtr;
     lastCheckPointEndPtr = XLogCtl->lastCheckPointEndPtr;
     lastCheckPoint = XLogCtl->lastCheckPoint;
     SpinLockRelease(&XLogCtl->info_lck);
 
     /*
      * Check that we're still in recovery mode. It's ok if we exit recovery
      * mode after this check, the restart point is valid anyway.
      */
     if (!RecoveryInProgress())
     {
         ereport(DEBUG2,
                 (errmsg("skipping restartpoint, recovery has already ended")));
         LWLockRelease(CheckpointLock);
         return false;
     }
 
     /*
      * If the last checkpoint record we've replayed is already our last
      * restartpoint, we can't perform a new restart point. We still update
      * minRecoveryPoint in that case, so that if this is a shutdown restart
      * point, we won't start up earlier than before. That's not strictly
      * necessary, but when hot standby is enabled, it would be rather weird if
      * the database opened up for read-only connections at a point-in-time
      * before the last shutdown. Such time travel is still possible in case of
      * immediate shutdown, though.
      *
      * We don't explicitly advance minRecoveryPoint when we do create a
      * restartpoint. It's assumed that flushing the buffers will do that as a
      * side-effect.
      */
     if (XLogRecPtrIsInvalid(lastCheckPointRecPtr) ||
         lastCheckPoint.redo <= ControlFile->checkPointCopy.redo)
     {
         ereport(DEBUG2,
                 (errmsg("skipping restartpoint, already performed at %X/%X",
                         (uint32) (lastCheckPoint.redo >> 32),
                         (uint32) lastCheckPoint.redo)));
 
         UpdateMinRecoveryPoint(InvalidXLogRecPtr, true);
         if (flags & CHECKPOINT_IS_SHUTDOWN)
         {
             LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
             ControlFile->state = DB_SHUTDOWNED_IN_RECOVERY;
             ControlFile->time = (pg_time_t) time(NULL);
             UpdateControlFile();
             LWLockRelease(ControlFileLock);
         }
         LWLockRelease(CheckpointLock);
         return false;
     }
 
     /*
      * Update the shared RedoRecPtr so that the startup process can calculate
      * the number of segments replayed since last restartpoint, and request a
      * restartpoint if it exceeds CheckPointSegments.
      *
      * Like in CreateCheckPoint(), hold off insertions to update it, although
      * during recovery this is just pro forma, because no WAL insertions are
      * happening.
      */
     WALInsertLockAcquireExclusive();
     RedoRecPtr = XLogCtl->Insert.RedoRecPtr = lastCheckPoint.redo;
     WALInsertLockRelease();
 
     /* Also update the info_lck-protected copy */
     SpinLockAcquire(&XLogCtl->info_lck);
     XLogCtl->RedoRecPtr = lastCheckPoint.redo;
     SpinLockRelease(&XLogCtl->info_lck);
 
     /*
      * Prepare to accumulate statistics.
      *
      * Note: because it is possible for log_checkpoints to change while a
      * checkpoint proceeds, we always accumulate stats, even if
      * log_checkpoints is currently off.
      */
     MemSet(&CheckpointStats, 0, sizeof(CheckpointStats));
     CheckpointStats.ckpt_start_t = GetCurrentTimestamp();
 
     if (log_checkpoints)
         LogCheckpointStart(flags, true);
 
     CheckPointGuts(lastCheckPoint.redo, flags);
 
     /*
      * Remember the prior checkpoint's redo ptr for
      * UpdateCheckPointDistanceEstimate()
      */
     PriorRedoPtr = ControlFile->checkPointCopy.redo;
 
     /*
      * Update pg_control, using current time.  Check that it still shows
      * DB_IN_ARCHIVE_RECOVERY state and an older checkpoint, else do nothing;
      * this is a quick hack to make sure nothing really bad happens if somehow
      * we get here after the end-of-recovery checkpoint.
      */
     LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
     if (ControlFile->state == DB_IN_ARCHIVE_RECOVERY &&
         ControlFile->checkPointCopy.redo < lastCheckPoint.redo)
     {
         ControlFile->checkPoint = lastCheckPointRecPtr;
         ControlFile->checkPointCopy = lastCheckPoint;
         ControlFile->time = (pg_time_t) time(NULL);
 
         /*
          * Ensure minRecoveryPoint is past the checkpoint record.  Normally,
          * this will have happened already while writing out dirty buffers,
          * but not necessarily - e.g. because no buffers were dirtied.  We do
          * this because a non-exclusive base backup uses minRecoveryPoint to
          * determine which WAL files must be included in the backup, and the
          * file (or files) containing the checkpoint record must be included,
          * at a minimum. Note that for an ordinary restart of recovery there's
          * no value in having the minimum recovery point any earlier than this
          * anyway, because redo will begin just after the checkpoint record.
          */
         if (ControlFile->minRecoveryPoint < lastCheckPointEndPtr)
         {
             ControlFile->minRecoveryPoint = lastCheckPointEndPtr;
             ControlFile->minRecoveryPointTLI = lastCheckPoint.ThisTimeLineID;
 
             /* update local copy */
             minRecoveryPoint = ControlFile->minRecoveryPoint;
             minRecoveryPointTLI = ControlFile->minRecoveryPointTLI;
         }
         if (flags & CHECKPOINT_IS_SHUTDOWN)
             ControlFile->state = DB_SHUTDOWNED_IN_RECOVERY;
         UpdateControlFile();
     }
     LWLockRelease(ControlFileLock);
 
     /*
      * Update the average distance between checkpoints/restartpoints if the
      * prior checkpoint exists.
      */
     if (PriorRedoPtr != InvalidXLogRecPtr)
         UpdateCheckPointDistanceEstimate(RedoRecPtr - PriorRedoPtr);
 
     /*
      * Delete old log files, those no longer needed for last restartpoint to
      * prevent the disk holding the xlog from growing full.
      */
     XLByteToSeg(RedoRecPtr, _logSegNo, wal_segment_size);
 
     /*
      * Retreat _logSegNo using the current end of xlog replayed or received,
      * whichever is later.
      */
     receivePtr = GetWalRcvFlushRecPtr(NULL, NULL);
     replayPtr = GetXLogReplayRecPtr(&replayTLI);
     endptr = (receivePtr < replayPtr) ? replayPtr : receivePtr;
     KeepLogSeg(endptr, &_logSegNo);
     InvalidateObsoleteReplicationSlots(_logSegNo);
     _logSegNo--;
 
     /*
      * Try to recycle segments on a useful timeline. If we've been promoted
      * since the beginning of this restartpoint, use the new timeline chosen
      * at end of recovery (RecoveryInProgress() sets ThisTimeLineID in that
      * case). If we're still in recovery, use the timeline we're currently
      * replaying.
      *
      * There is no guarantee that the WAL segments will be useful on the
      * current timeline; if recovery proceeds to a new timeline right after
      * this, the pre-allocated WAL segments on this timeline will not be used,
      * and will go wasted until recycled on the next restartpoint. We'll live
      * with that.
      */
     if (RecoveryInProgress())
         ThisTimeLineID = replayTLI;
 
     RemoveOldXlogFiles(_logSegNo, RedoRecPtr, endptr);
 
     /*
      * Make more log segments if needed.  (Do this after recycling old log
      * segments, since that may supply some of the needed files.)
      */
     PreallocXlogFiles(endptr);
 
     /*
      * ThisTimeLineID is normally not set when we're still in recovery.
      * However, recycling/preallocating segments above needed ThisTimeLineID
      * to determine which timeline to install the segments on. Reset it now,
      * to restore the normal state of affairs for debugging purposes.
      */
     if (RecoveryInProgress())
         ThisTimeLineID = 0;
 
     /*
      * Truncate pg_subtrans if possible.  We can throw away all data before
      * the oldest XMIN of any running transaction.  No future transaction will
      * attempt to reference any pg_subtrans entry older than that (see Asserts
      * in subtrans.c).  When hot standby is disabled, though, we mustn't do
      * this because StartupSUBTRANS hasn't been called yet.
      */
     if (EnableHotStandby)
         TruncateSUBTRANS(GetOldestXmin(NULL, PROCARRAY_FLAGS_DEFAULT));
 
     /* Real work is done, but log and update before releasing lock. */
     LogCheckpointEnd(true);
 
     xtime = GetLatestXTime();
     ereport((log_checkpoints ? LOG : DEBUG2),
             (errmsg("recovery restart point at %X/%X",
                     (uint32) (lastCheckPoint.redo >> 32), (uint32) lastCheckPoint.redo),
              xtime ? errdetail("Last completed transaction was at log time %s.",
                                timestamptz_to_str(xtime)) : 0));
 
     LWLockRelease(CheckpointLock);
 
     /*
      * Finally, execute archive_cleanup_command, if any.
      */
     if (archiveCleanupCommand && strcmp(archiveCleanupCommand, "") != 0)
         ExecuteRecoveryCommand(archiveCleanupCommand,
                                "archive_cleanup_command",
                                false);
 
     return true;
 }

◆ DataChecksumsEnabled()

bool DataChecksumsEnabled ( void )

Definition at line 4930 of file xlog.c.

References Assert, and ControlFileData::data_checksum_version.

Referenced by PageIsVerified(), PageSetChecksumCopy(), PageSetChecksumInplace(), pg_stat_get_db_checksum_failures(), pg_stat_get_db_checksum_last_failure(), ReadControlFile(), and sendFile().

 {
     Assert(ControlFile != NULL);
     return (ControlFile->data_checksum_version > 0);
 }

◆ do_pg_abort_backup()

void do_pg_abort_backup	(	int	code,
		Datum	arg
	)

Definition at line 11427 of file xlog.c.

References Assert, DatumGetBool, ereport, errmsg(), EXCLUSIVE_BACKUP_NONE, XLogCtlInsert::exclusiveBackupState, XLogCtlInsert::forcePageWrites, XLogCtlData::Insert, XLogCtlInsert::nonExclusiveBackups, SESSION_BACKUP_NON_EXCLUSIVE, sessionBackupState, WALInsertLockAcquireExclusive(), WALInsertLockRelease(), and WARNING.

Referenced by perform_base_backup(), and register_persistent_abort_backup_handler().

 {
     bool        emit_warning = DatumGetBool(arg);
 
     /*
      * Quick exit if session is not keeping around a non-exclusive backup
      * already started.
      */
     if (sessionBackupState != SESSION_BACKUP_NON_EXCLUSIVE)
         return;
 
     WALInsertLockAcquireExclusive();
     Assert(XLogCtl->Insert.nonExclusiveBackups > 0);
     XLogCtl->Insert.nonExclusiveBackups--;
 
     if (XLogCtl->Insert.exclusiveBackupState == EXCLUSIVE_BACKUP_NONE &&
         XLogCtl->Insert.nonExclusiveBackups == 0)
     {
         XLogCtl->Insert.forcePageWrites = false;
     }
     WALInsertLockRelease();
 
     if (emit_warning)
         ereport(WARNING,
                 (errmsg("aborting backup due to backend exiting before pg_stop_backup was called")));
 }

◆ do_pg_start_backup()

XLogRecPtr do_pg_start_backup	(	const char *	backupidstr,
		bool	fast,
		TimeLineID *	starttli_p,
		StringInfo	labelfile,
		List **	tablespaces,
		StringInfo	tblspcmapfile,
		bool	needtblspcmapfile
	)

Definition at line 10496 of file xlog.c.

References AllocateDir(), AllocateFile(), appendStringInfo(), appendStringInfoChar(), BACKUP_LABEL_FILE, backup_started_in_recovery, BoolGetDatum, ControlFileData::checkPoint, CHECKPOINT_FORCE, CHECKPOINT_IMMEDIATE, CHECKPOINT_WAIT, ControlFileData::checkPointCopy, dirent::d_name, StringInfoData::data, DataDir, ereport, errcode(), errcode_for_file_access(), errhint(), errmsg(), ERROR, EXCLUSIVE_BACKUP_IN_PROGRESS, EXCLUSIVE_BACKUP_NONE, EXCLUSIVE_BACKUP_STARTING, XLogCtlInsert::exclusiveBackupState, XLogCtlInsert::forcePageWrites, FreeDir(), FreeFile(), CheckPoint::fullPageWrites, XLogCtlData::info_lck, initStringInfo(), XLogCtlData::Insert, IS_DIR_SEP, lappend(), XLogCtlInsert::lastBackupStart, XLogCtlData::lastFpwDisableRecPtr, StringInfoData::len, log_timezone, LW_SHARED, LWLockAcquire(), LWLockRelease(), makeStringInfo(), MAXFNAMELEN, MAXPGPATH, XLogCtlInsert::nonExclusiveBackups, tablespaceinfo::oid, palloc(), tablespaceinfo::path, pfree(), PG_END_ENSURE_ERROR_CLEANUP, PG_ENSURE_ERROR_CLEANUP, pg_fsync(), pg_localtime(), pg_start_backup_callback(), pg_strftime(), pstrdup(), ReadDir(), readlink, RecoveryInProgress(), CheckPoint::redo, relpath, RequestCheckpoint(), RequestXLogSwitch(), tablespaceinfo::rpath, SESSION_BACKUP_EXCLUSIVE, SESSION_BACKUP_NON_EXCLUSIVE, sessionBackupState, tablespaceinfo::size, snprintf, SpinLockAcquire, SpinLockRelease, stat, TABLESPACE_MAP, CheckPoint::ThisTimeLineID, wal_segment_size, WALInsertLockAcquireExclusive(), WALInsertLockRelease(), WARNING, XLByteToSeg, XLogFileName, and XLogIsNeeded.

Referenced by perform_base_backup(), and pg_start_backup().

 {
     bool        exclusive = (labelfile == NULL);
     bool        backup_started_in_recovery = false;
     XLogRecPtr  checkpointloc;
     XLogRecPtr  startpoint;
     TimeLineID  starttli;
     pg_time_t   stamp_time;
     char        strfbuf[128];
     char        xlogfilename[MAXFNAMELEN];
     XLogSegNo   _logSegNo;
     struct stat stat_buf;
     FILE       *fp;
 
     backup_started_in_recovery = RecoveryInProgress();
 
     /*
      * Currently only non-exclusive backup can be taken during recovery.
      */
     if (backup_started_in_recovery && exclusive)
         ereport(ERROR,
                 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                  errmsg("recovery is in progress"),
                  errhint("WAL control functions cannot be executed during recovery.")));
 
     /*
      * During recovery, we don't need to check WAL level. Because, if WAL
      * level is not sufficient, it's impossible to get here during recovery.
      */
     if (!backup_started_in_recovery && !XLogIsNeeded())
         ereport(ERROR,
                 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                  errmsg("WAL level not sufficient for making an online backup"),
                  errhint("wal_level must be set to \"replica\" or \"logical\" at server start.")));
 
     if (strlen(backupidstr) > MAXPGPATH)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                  errmsg("backup label too long (max %d bytes)",
                         MAXPGPATH)));
 
     /*
      * Mark backup active in shared memory.  We must do full-page WAL writes
      * during an on-line backup even if not doing so at other times, because
      * it's quite possible for the backup dump to obtain a "torn" (partially
      * written) copy of a database page if it reads the page concurrently with
      * our write to the same page.  This can be fixed as long as the first
      * write to the page in the WAL sequence is a full-page write. Hence, we
      * turn on forcePageWrites and then force a CHECKPOINT, to ensure there
      * are no dirty pages in shared memory that might get dumped while the
      * backup is in progress without having a corresponding WAL record.  (Once
      * the backup is complete, we need not force full-page writes anymore,
      * since we expect that any pages not modified during the backup interval
      * must have been correctly captured by the backup.)
      *
      * Note that forcePageWrites has no effect during an online backup from
      * the standby.
      *
      * We must hold all the insertion locks to change the value of
      * forcePageWrites, to ensure adequate interlocking against
      * XLogInsertRecord().
      */
     WALInsertLockAcquireExclusive();
     if (exclusive)
     {
         /*
          * At first, mark that we're now starting an exclusive backup, to
          * ensure that there are no other sessions currently running
          * pg_start_backup() or pg_stop_backup().
          */
         if (XLogCtl->Insert.exclusiveBackupState != EXCLUSIVE_BACKUP_NONE)
         {
             WALInsertLockRelease();
             ereport(ERROR,
                     (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                      errmsg("a backup is already in progress"),
                      errhint("Run pg_stop_backup() and try again.")));
         }
         XLogCtl->Insert.exclusiveBackupState = EXCLUSIVE_BACKUP_STARTING;
     }
     else
         XLogCtl->Insert.nonExclusiveBackups++;
     XLogCtl->Insert.forcePageWrites = true;
     WALInsertLockRelease();
 
     /* Ensure we release forcePageWrites if fail below */
     PG_ENSURE_ERROR_CLEANUP(pg_start_backup_callback, (Datum) BoolGetDatum(exclusive));
     {
         bool        gotUniqueStartpoint = false;
         DIR        *tblspcdir;
         struct dirent *de;
         tablespaceinfo *ti;
         int         datadirpathlen;
 
         /*
          * Force an XLOG file switch before the checkpoint, to ensure that the
          * WAL segment the checkpoint is written to doesn't contain pages with
          * old timeline IDs.  That would otherwise happen if you called
          * pg_start_backup() right after restoring from a PITR archive: the
          * first WAL segment containing the startup checkpoint has pages in
          * the beginning with the old timeline ID.  That can cause trouble at
          * recovery: we won't have a history file covering the old timeline if
          * pg_wal directory was not included in the base backup and the WAL
          * archive was cleared too before starting the backup.
          *
          * This also ensures that we have emitted a WAL page header that has
          * XLP_BKP_REMOVABLE off before we emit the checkpoint record.
          * Therefore, if a WAL archiver (such as pglesslog) is trying to
          * compress out removable backup blocks, it won't remove any that
          * occur after this point.
          *
          * During recovery, we skip forcing XLOG file switch, which means that
          * the backup taken during recovery is not available for the special
          * recovery case described above.
          */
         if (!backup_started_in_recovery)
             RequestXLogSwitch(false);
 
         do
         {
             bool        checkpointfpw;
 
             /*
              * Force a CHECKPOINT.  Aside from being necessary to prevent torn
              * page problems, this guarantees that two successive backup runs
              * will have different checkpoint positions and hence different
              * history file names, even if nothing happened in between.
              *
              * During recovery, establish a restartpoint if possible. We use
              * the last restartpoint as the backup starting checkpoint. This
              * means that two successive backup runs can have same checkpoint
              * positions.
              *
              * Since the fact that we are executing do_pg_start_backup()
              * during recovery means that checkpointer is running, we can use
              * RequestCheckpoint() to establish a restartpoint.
              *
              * We use CHECKPOINT_IMMEDIATE only if requested by user (via
              * passing fast = true).  Otherwise this can take awhile.
              */
             RequestCheckpoint(CHECKPOINT_FORCE | CHECKPOINT_WAIT |
                               (fast ? CHECKPOINT_IMMEDIATE : 0));
 
             /*
              * Now we need to fetch the checkpoint record location, and also
              * its REDO pointer.  The oldest point in WAL that would be needed
              * to restore starting from the checkpoint is precisely the REDO
              * pointer.
              */
             LWLockAcquire(ControlFileLock, LW_SHARED);
             checkpointloc = ControlFile->checkPoint;
             startpoint = ControlFile->checkPointCopy.redo;
             starttli = ControlFile->checkPointCopy.ThisTimeLineID;
             checkpointfpw = ControlFile->checkPointCopy.fullPageWrites;
             LWLockRelease(ControlFileLock);
 
             if (backup_started_in_recovery)
             {
                 XLogRecPtr  recptr;
 
                 /*
                  * Check to see if all WAL replayed during online backup
                  * (i.e., since last restartpoint used as backup starting
                  * checkpoint) contain full-page writes.
                  */
                 SpinLockAcquire(&XLogCtl->info_lck);
                 recptr = XLogCtl->lastFpwDisableRecPtr;
                 SpinLockRelease(&XLogCtl->info_lck);
 
                 if (!checkpointfpw || startpoint <= recptr)
                     ereport(ERROR,
                             (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                              errmsg("WAL generated with full_page_writes=off was replayed "
                                     "since last restartpoint"),
                              errhint("This means that the backup being taken on the standby "
                                      "is corrupt and should not be used. "
                                      "Enable full_page_writes and run CHECKPOINT on the primary, "
                                      "and then try an online backup again.")));
 
                 /*
                  * During recovery, since we don't use the end-of-backup WAL
                  * record and don't write the backup history file, the
                  * starting WAL location doesn't need to be unique. This means
                  * that two base backups started at the same time might use
                  * the same checkpoint as starting locations.
                  */
                 gotUniqueStartpoint = true;
             }
 
             /*
              * If two base backups are started at the same time (in WAL sender
              * processes), we need to make sure that they use different
              * checkpoints as starting locations, because we use the starting
              * WAL location as a unique identifier for the base backup in the
              * end-of-backup WAL record and when we write the backup history
              * file. Perhaps it would be better generate a separate unique ID
              * for each backup instead of forcing another checkpoint, but
              * taking a checkpoint right after another is not that expensive
              * either because only few buffers have been dirtied yet.
              */
             WALInsertLockAcquireExclusive();
             if (XLogCtl->Insert.lastBackupStart < startpoint)
             {
                 XLogCtl->Insert.lastBackupStart = startpoint;
                 gotUniqueStartpoint = true;
             }
             WALInsertLockRelease();
         } while (!gotUniqueStartpoint);
 
         XLByteToSeg(startpoint, _logSegNo, wal_segment_size);
         XLogFileName(xlogfilename, starttli, _logSegNo, wal_segment_size);
 
         /*
          * Construct tablespace_map file
          */
         if (exclusive)
             tblspcmapfile = makeStringInfo();
 
         datadirpathlen = strlen(DataDir);
 
         /* Collect information about all tablespaces */
         tblspcdir = AllocateDir("pg_tblspc");
         while ((de = ReadDir(tblspcdir, "pg_tblspc")) != NULL)
         {
             char        fullpath[MAXPGPATH + 10];
             char        linkpath[MAXPGPATH];
             char       *relpath = NULL;
             int         rllen;
             StringInfoData buflinkpath;
             char       *s = linkpath;
 
             /* Skip special stuff */
             if (strcmp(de->d_name, ".") == 0 || strcmp(de->d_name, "..") == 0)
                 continue;
 
             snprintf(fullpath, sizeof(fullpath), "pg_tblspc/%s", de->d_name);
 
 #if defined(HAVE_READLINK) || defined(WIN32)
             rllen = readlink(fullpath, linkpath, sizeof(linkpath));
             if (rllen < 0)
             {
                 ereport(WARNING,
                         (errmsg("could not read symbolic link \"%s\": %m",
                                 fullpath)));
                 continue;
             }
             else if (rllen >= sizeof(linkpath))
             {
                 ereport(WARNING,
                         (errmsg("symbolic link \"%s\" target is too long",
                                 fullpath)));
                 continue;
             }
             linkpath[rllen] = '\0';
 
             /*
              * Add the escape character '\\' before newline in a string to
              * ensure that we can distinguish between the newline in the
              * tablespace path and end of line while reading tablespace_map
              * file during archive recovery.
              */
             initStringInfo(&buflinkpath);
 
             while (*s)
             {
                 if ((*s == '\n' || *s == '\r') && needtblspcmapfile)
                     appendStringInfoChar(&buflinkpath, '\\');
                 appendStringInfoChar(&buflinkpath, *s++);
             }
 
             /*
              * Relpath holds the relative path of the tablespace directory
              * when it's located within PGDATA, or NULL if it's located
              * elsewhere.
              */
             if (rllen > datadirpathlen &&
                 strncmp(linkpath, DataDir, datadirpathlen) == 0 &&
                 IS_DIR_SEP(linkpath[datadirpathlen]))
                 relpath = linkpath + datadirpathlen + 1;
 
             ti = palloc(sizeof(tablespaceinfo));
             ti->oid = pstrdup(de->d_name);
             ti->path = pstrdup(buflinkpath.data);
             ti->rpath = relpath ? pstrdup(relpath) : NULL;
             ti->size = -1;
 
             if (tablespaces)
                 *tablespaces = lappend(*tablespaces, ti);
 
             appendStringInfo(tblspcmapfile, "%s %s\n", ti->oid, ti->path);
 
             pfree(buflinkpath.data);
 #else
 
             /*
              * If the platform does not have symbolic links, it should not be
              * possible to have tablespaces - clearly somebody else created
              * them. Warn about it and ignore.
              */
             ereport(WARNING,
                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                      errmsg("tablespaces are not supported on this platform")));
 #endif
         }
         FreeDir(tblspcdir);
 
         /*
          * Construct backup label file
          */
         if (exclusive)
             labelfile = makeStringInfo();
 
         /* Use the log timezone here, not the session timezone */
         stamp_time = (pg_time_t) time(NULL);
         pg_strftime(strfbuf, sizeof(strfbuf),
                     "%Y-%m-%d %H:%M:%S %Z",
                     pg_localtime(&stamp_time, log_timezone));
         appendStringInfo(labelfile, "START WAL LOCATION: %X/%X (file %s)\n",
                          (uint32) (startpoint >> 32), (uint32) startpoint, xlogfilename);
         appendStringInfo(labelfile, "CHECKPOINT LOCATION: %X/%X\n",
                          (uint32) (checkpointloc >> 32), (uint32) checkpointloc);
         appendStringInfo(labelfile, "BACKUP METHOD: %s\n",
                          exclusive ? "pg_start_backup" : "streamed");
         appendStringInfo(labelfile, "BACKUP FROM: %s\n",
                          backup_started_in_recovery ? "standby" : "primary");
         appendStringInfo(labelfile, "START TIME: %s\n", strfbuf);
         appendStringInfo(labelfile, "LABEL: %s\n", backupidstr);
         appendStringInfo(labelfile, "START TIMELINE: %u\n", starttli);
 
         /*
          * Okay, write the file, or return its contents to caller.
          */
         if (exclusive)
         {
             /*
              * Check for existing backup label --- implies a backup is already
              * running.  (XXX given that we checked exclusiveBackupState
              * above, maybe it would be OK to just unlink any such label
              * file?)
              */
             if (stat(BACKUP_LABEL_FILE, &stat_buf) != 0)
             {
                 if (errno != ENOENT)
                     ereport(ERROR,
                             (errcode_for_file_access(),
                              errmsg("could not stat file \"%s\": %m",
                                     BACKUP_LABEL_FILE)));
             }
             else
                 ereport(ERROR,
                         (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                          errmsg("a backup is already in progress"),
                          errhint("If you're sure there is no backup in progress, remove file \"%s\" and try again.",
                                  BACKUP_LABEL_FILE)));
 
             fp = AllocateFile(BACKUP_LABEL_FILE, "w");
 
             if (!fp)
                 ereport(ERROR,
                         (errcode_for_file_access(),
                          errmsg("could not create file \"%s\": %m",
                                 BACKUP_LABEL_FILE)));
             if (fwrite(labelfile->data, labelfile->len, 1, fp) != 1 ||
                 fflush(fp) != 0 ||
                 pg_fsync(fileno(fp)) != 0 ||
                 ferror(fp) ||
                 FreeFile(fp))
                 ereport(ERROR,
                         (errcode_for_file_access(),
                          errmsg("could not write file \"%s\": %m",
                                 BACKUP_LABEL_FILE)));
             /* Allocated locally for exclusive backups, so free separately */
             pfree(labelfile->data);
             pfree(labelfile);
 
             /* Write backup tablespace_map file. */
             if (tblspcmapfile->len > 0)
             {
                 if (stat(TABLESPACE_MAP, &stat_buf) != 0)
                 {
                     if (errno != ENOENT)
                         ereport(ERROR,
                                 (errcode_for_file_access(),
                                  errmsg("could not stat file \"%s\": %m",
                                         TABLESPACE_MAP)));
                 }
                 else
                     ereport(ERROR,
                             (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                              errmsg("a backup is already in progress"),
                              errhint("If you're sure there is no backup in progress, remove file \"%s\" and try again.",
                                      TABLESPACE_MAP)));
 
                 fp = AllocateFile(TABLESPACE_MAP, "w");
 
                 if (!fp)
                     ereport(ERROR,
                             (errcode_for_file_access(),
                              errmsg("could not create file \"%s\": %m",
                                     TABLESPACE_MAP)));
                 if (fwrite(tblspcmapfile->data, tblspcmapfile->len, 1, fp) != 1 ||
                     fflush(fp) != 0 ||
                     pg_fsync(fileno(fp)) != 0 ||
                     ferror(fp) ||
                     FreeFile(fp))
                     ereport(ERROR,
                             (errcode_for_file_access(),
                              errmsg("could not write file \"%s\": %m",
                                     TABLESPACE_MAP)));
             }
 
             /* Allocated locally for exclusive backups, so free separately */
             pfree(tblspcmapfile->data);
             pfree(tblspcmapfile);
         }
     }
     PG_END_ENSURE_ERROR_CLEANUP(pg_start_backup_callback, (Datum) BoolGetDatum(exclusive));
 
     /*
      * Mark that start phase has correctly finished for an exclusive backup.
      * Session-level locks are updated as well to reflect that state.
      *
      * Note that CHECK_FOR_INTERRUPTS() must not occur while updating backup
      * counters and session-level lock. Otherwise they can be updated
      * inconsistently, and which might cause do_pg_abort_backup() to fail.
      */
     if (exclusive)
     {
         WALInsertLockAcquireExclusive();
         XLogCtl->Insert.exclusiveBackupState = EXCLUSIVE_BACKUP_IN_PROGRESS;
 
         /* Set session-level lock */
         sessionBackupState = SESSION_BACKUP_EXCLUSIVE;
         WALInsertLockRelease();
     }
     else
         sessionBackupState = SESSION_BACKUP_NON_EXCLUSIVE;
 
     /*
      * We're done.  As a convenience, return the starting WAL location.
      */
     if (starttli_p)
         *starttli_p = starttli;
     return startpoint;
 }

◆ do_pg_stop_backup()

XLogRecPtr do_pg_stop_backup	(	char *	labelfile,
		bool	waitforarchive,
		TimeLineID *	stoptli_p
	)

Definition at line 11014 of file xlog.c.

References AllocateFile(), Assert, BACKUP_LABEL_FILE, backup_started_in_recovery, BackupHistoryFileName, BackupHistoryFilePath, BoolGetDatum, CHECK_FOR_INTERRUPTS, CleanupBackupHistory(), DEBUG1, durable_unlink(), ereport, errcode(), errcode_for_file_access(), errhint(), errmsg(), ERROR, EXCLUSIVE_BACKUP_IN_PROGRESS, EXCLUSIVE_BACKUP_NONE, EXCLUSIVE_BACKUP_STOPPING, XLogCtlInsert::exclusiveBackupState, XLogCtlInsert::forcePageWrites, fprintf, FreeFile(), XLogCtlData::info_lck, XLogCtlData::Insert, XLogCtlData::lastFpwDisableRecPtr, log_timezone, LW_SHARED, LWLockAcquire(), LWLockRelease(), MAXFNAMELEN, MAXPGPATH, ControlFileData::minRecoveryPoint, ControlFileData::minRecoveryPointTLI, XLogCtlInsert::nonExclusiveBackups, NOTICE, palloc(), PG_END_ENSURE_ERROR_CLEANUP, PG_ENSURE_ERROR_CLEANUP, pg_localtime(), pg_stop_backup_callback(), pg_strftime(), pg_usleep(), pgstat_report_wait_end(), pgstat_report_wait_start(), RecoveryInProgress(), remaining, RequestXLogSwitch(), SESSION_BACKUP_NONE, sessionBackupState, SpinLockAcquire, SpinLockRelease, stat, TABLESPACE_MAP, ThisTimeLineID, WAIT_EVENT_BACKUP_WAIT_WAL_ARCHIVE, wal_segment_size, WALInsertLockAcquireExclusive(), WALInsertLockRelease(), WARNING, XLByteToPrevSeg, XLByteToSeg, XLOG_BACKUP_END, XLogArchiveIsBusy(), XLogArchivingActive, XLogArchivingAlways, XLogBeginInsert(), XLogFileName, XLogInsert(), XLogIsNeeded, and XLogRegisterData().

Referenced by perform_base_backup(), pg_stop_backup(), and pg_stop_backup_v2().

 {
     bool        exclusive = (labelfile == NULL);
     bool        backup_started_in_recovery = false;
     XLogRecPtr  startpoint;
     XLogRecPtr  stoppoint;
     TimeLineID  stoptli;
     pg_time_t   stamp_time;
     char        strfbuf[128];
     char        histfilepath[MAXPGPATH];
     char        startxlogfilename[MAXFNAMELEN];
     char        stopxlogfilename[MAXFNAMELEN];
     char        lastxlogfilename[MAXFNAMELEN];
     char        histfilename[MAXFNAMELEN];
     char        backupfrom[20];
     XLogSegNo   _logSegNo;
     FILE       *lfp;
     FILE       *fp;
     char        ch;
     int         seconds_before_warning;
     int         waits = 0;
     bool        reported_waiting = false;
     char       *remaining;
     char       *ptr;
     uint32      hi,
                 lo;
 
     backup_started_in_recovery = RecoveryInProgress();
 
     /*
      * Currently only non-exclusive backup can be taken during recovery.
      */
     if (backup_started_in_recovery && exclusive)
         ereport(ERROR,
                 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                  errmsg("recovery is in progress"),
                  errhint("WAL control functions cannot be executed during recovery.")));
 
     /*
      * During recovery, we don't need to check WAL level. Because, if WAL
      * level is not sufficient, it's impossible to get here during recovery.
      */
     if (!backup_started_in_recovery && !XLogIsNeeded())
         ereport(ERROR,
                 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                  errmsg("WAL level not sufficient for making an online backup"),
                  errhint("wal_level must be set to \"replica\" or \"logical\" at server start.")));
 
     if (exclusive)
     {
         /*
          * At first, mark that we're now stopping an exclusive backup, to
          * ensure that there are no other sessions currently running
          * pg_start_backup() or pg_stop_backup().
          */
         WALInsertLockAcquireExclusive();
         if (XLogCtl->Insert.exclusiveBackupState != EXCLUSIVE_BACKUP_IN_PROGRESS)
         {
             WALInsertLockRelease();
             ereport(ERROR,
                     (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                      errmsg("exclusive backup not in progress")));
         }
         XLogCtl->Insert.exclusiveBackupState = EXCLUSIVE_BACKUP_STOPPING;
         WALInsertLockRelease();
 
         /*
          * Remove backup_label. In case of failure, the state for an exclusive
          * backup is switched back to in-progress.
          */
         PG_ENSURE_ERROR_CLEANUP(pg_stop_backup_callback, (Datum) BoolGetDatum(exclusive));
         {
             /*
              * Read the existing label file into memory.
              */
             struct stat statbuf;
             int         r;
 
             if (stat(BACKUP_LABEL_FILE, &statbuf))
             {
                 /* should not happen per the upper checks */
                 if (errno != ENOENT)
                     ereport(ERROR,
                             (errcode_for_file_access(),
                              errmsg("could not stat file \"%s\": %m",
                                     BACKUP_LABEL_FILE)));
                 ereport(ERROR,
                         (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                          errmsg("a backup is not in progress")));
             }
 
             lfp = AllocateFile(BACKUP_LABEL_FILE, "r");
             if (!lfp)
             {
                 ereport(ERROR,
                         (errcode_for_file_access(),
                          errmsg("could not read file \"%s\": %m",
                                 BACKUP_LABEL_FILE)));
             }
             labelfile = palloc(statbuf.st_size + 1);
             r = fread(labelfile, statbuf.st_size, 1, lfp);
             labelfile[statbuf.st_size] = '\0';
 
             /*
              * Close and remove the backup label file
              */
             if (r != 1 || ferror(lfp) || FreeFile(lfp))
                 ereport(ERROR,
                         (errcode_for_file_access(),
                          errmsg("could not read file \"%s\": %m",
                                 BACKUP_LABEL_FILE)));
             durable_unlink(BACKUP_LABEL_FILE, ERROR);
 
             /*
              * Remove tablespace_map file if present, it is created only if
              * there are tablespaces.
              */
             durable_unlink(TABLESPACE_MAP, DEBUG1);
         }
         PG_END_ENSURE_ERROR_CLEANUP(pg_stop_backup_callback, (Datum) BoolGetDatum(exclusive));
     }
 
     /*
      * OK to update backup counters, forcePageWrites and session-level lock.
      *
      * Note that CHECK_FOR_INTERRUPTS() must not occur while updating them.
      * Otherwise they can be updated inconsistently, and which might cause
      * do_pg_abort_backup() to fail.
      */
     WALInsertLockAcquireExclusive();
     if (exclusive)
     {
         XLogCtl->Insert.exclusiveBackupState = EXCLUSIVE_BACKUP_NONE;
     }
     else
     {
         /*
          * The user-visible pg_start/stop_backup() functions that operate on
          * exclusive backups can be called at any time, but for non-exclusive
          * backups, it is expected that each do_pg_start_backup() call is
          * matched by exactly one do_pg_stop_backup() call.
          */
         Assert(XLogCtl->Insert.nonExclusiveBackups > 0);
         XLogCtl->Insert.nonExclusiveBackups--;
     }
 
     if (XLogCtl->Insert.exclusiveBackupState == EXCLUSIVE_BACKUP_NONE &&
         XLogCtl->Insert.nonExclusiveBackups == 0)
     {
         XLogCtl->Insert.forcePageWrites = false;
     }
 
     /*
      * Clean up session-level lock.
      *
      * You might think that WALInsertLockRelease() can be called before
      * cleaning up session-level lock because session-level lock doesn't need
      * to be protected with WAL insertion lock. But since
      * CHECK_FOR_INTERRUPTS() can occur in it, session-level lock must be
      * cleaned up before it.
      */
     sessionBackupState = SESSION_BACKUP_NONE;
 
     WALInsertLockRelease();
 
     /*
      * Read and parse the START WAL LOCATION line (this code is pretty crude,
      * but we are not expecting any variability in the file format).
      */
     if (sscanf(labelfile, "START WAL LOCATION: %X/%X (file %24s)%c",
                &hi, &lo, startxlogfilename,
                &ch) != 4 || ch != '\n')
         ereport(ERROR,
                 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                  errmsg("invalid data in file \"%s\"", BACKUP_LABEL_FILE)));
     startpoint = ((uint64) hi) << 32 | lo;
     remaining = strchr(labelfile, '\n') + 1;    /* %n is not portable enough */
 
     /*
      * Parse the BACKUP FROM line. If we are taking an online backup from the
      * standby, we confirm that the standby has not been promoted during the
      * backup.
      */
     ptr = strstr(remaining, "BACKUP FROM:");
     if (!ptr || sscanf(ptr, "BACKUP FROM: %19s\n", backupfrom) != 1)
         ereport(ERROR,
                 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                  errmsg("invalid data in file \"%s\"", BACKUP_LABEL_FILE)));
     if (strcmp(backupfrom, "standby") == 0 && !backup_started_in_recovery)
         ereport(ERROR,
                 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                  errmsg("the standby was promoted during online backup"),
                  errhint("This means that the backup being taken is corrupt "
                          "and should not be used. "
                          "Try taking another online backup.")));
 
     /*
      * During recovery, we don't write an end-of-backup record. We assume that
      * pg_control was backed up last and its minimum recovery point can be
      * available as the backup end location. Since we don't have an
      * end-of-backup record, we use the pg_control value to check whether
      * we've reached the end of backup when starting recovery from this
      * backup. We have no way of checking if pg_control wasn't backed up last
      * however.
      *
      * We don't force a switch to new WAL file but it is still possible to
      * wait for all the required files to be archived if waitforarchive is
      * true. This is okay if we use the backup to start a standby and fetch
      * the missing WAL using streaming replication. But in the case of an
      * archive recovery, a user should set waitforarchive to true and wait for
      * them to be archived to ensure that all the required files are
      * available.
      *
      * We return the current minimum recovery point as the backup end
      * location. Note that it can be greater than the exact backup end
      * location if the minimum recovery point is updated after the backup of
      * pg_control. This is harmless for current uses.
      *
      * XXX currently a backup history file is for informational and debug
      * purposes only. It's not essential for an online backup. Furthermore,
      * even if it's created, it will not be archived during recovery because
      * an archiver is not invoked. So it doesn't seem worthwhile to write a
      * backup history file during recovery.
      */
     if (backup_started_in_recovery)
     {
         XLogRecPtr  recptr;
 
         /*
          * Check to see if all WAL replayed during online backup contain
          * full-page writes.
          */
         SpinLockAcquire(&XLogCtl->info_lck);
         recptr = XLogCtl->lastFpwDisableRecPtr;
         SpinLockRelease(&XLogCtl->info_lck);
 
         if (startpoint <= recptr)
             ereport(ERROR,
                     (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                      errmsg("WAL generated with full_page_writes=off was replayed "
                             "during online backup"),
                      errhint("This means that the backup being taken on the standby "
                              "is corrupt and should not be used. "
                              "Enable full_page_writes and run CHECKPOINT on the primary, "
                              "and then try an online backup again.")));
 
 
         LWLockAcquire(ControlFileLock, LW_SHARED);
         stoppoint = ControlFile->minRecoveryPoint;
         stoptli = ControlFile->minRecoveryPointTLI;
         LWLockRelease(ControlFileLock);
     }
     else
     {
         /*
          * Write the backup-end xlog record
          */
         XLogBeginInsert();
         XLogRegisterData((char *) (&startpoint), sizeof(startpoint));
         stoppoint = XLogInsert(RM_XLOG_ID, XLOG_BACKUP_END);
         stoptli = ThisTimeLineID;
 
         /*
          * Force a switch to a new xlog segment file, so that the backup is
          * valid as soon as archiver moves out the current segment file.
          */
         RequestXLogSwitch(false);
 
         XLByteToPrevSeg(stoppoint, _logSegNo, wal_segment_size);
         XLogFileName(stopxlogfilename, stoptli, _logSegNo, wal_segment_size);
 
         /* Use the log timezone here, not the session timezone */
         stamp_time = (pg_time_t) time(NULL);
         pg_strftime(strfbuf, sizeof(strfbuf),
                     "%Y-%m-%d %H:%M:%S %Z",
                     pg_localtime(&stamp_time, log_timezone));
 
         /*
          * Write the backup history file
          */
         XLByteToSeg(startpoint, _logSegNo, wal_segment_size);
         BackupHistoryFilePath(histfilepath, stoptli, _logSegNo,
                               startpoint, wal_segment_size);
         fp = AllocateFile(histfilepath, "w");
         if (!fp)
             ereport(ERROR,
                     (errcode_for_file_access(),
                      errmsg("could not create file \"%s\": %m",
                             histfilepath)));
         fprintf(fp, "START WAL LOCATION: %X/%X (file %s)\n",
                 (uint32) (startpoint >> 32), (uint32) startpoint, startxlogfilename);
         fprintf(fp, "STOP WAL LOCATION: %X/%X (file %s)\n",
                 (uint32) (stoppoint >> 32), (uint32) stoppoint, stopxlogfilename);
 
         /*
          * Transfer remaining lines including label and start timeline to
          * history file.
          */
         fprintf(fp, "%s", remaining);
         fprintf(fp, "STOP TIME: %s\n", strfbuf);
         fprintf(fp, "STOP TIMELINE: %u\n", stoptli);
         if (fflush(fp) || ferror(fp) || FreeFile(fp))
             ereport(ERROR,
                     (errcode_for_file_access(),
                      errmsg("could not write file \"%s\": %m",
                             histfilepath)));
 
         /*
          * Clean out any no-longer-needed history files.  As a side effect,
          * this will post a .ready file for the newly created history file,
          * notifying the archiver that history file may be archived
          * immediately.
          */
         CleanupBackupHistory();
     }
 
     /*
      * If archiving is enabled, wait for all the required WAL files to be
      * archived before returning. If archiving isn't enabled, the required WAL
      * needs to be transported via streaming replication (hopefully with
      * wal_keep_size set high enough), or some more exotic mechanism like
      * polling and copying files from pg_wal with script. We have no knowledge
      * of those mechanisms, so it's up to the user to ensure that he gets all
      * the required WAL.
      *
      * We wait until both the last WAL file filled during backup and the
      * history file have been archived, and assume that the alphabetic sorting
      * property of the WAL files ensures any earlier WAL files are safely
      * archived as well.
      *
      * We wait forever, since archive_command is supposed to work and we
      * assume the admin wanted his backup to work completely. If you don't
      * wish to wait, then either waitforarchive should be passed in as false,
      * or you can set statement_timeout.  Also, some notices are issued to
      * clue in anyone who might be doing this interactively.
      */
 
     if (waitforarchive &&
         ((!backup_started_in_recovery && XLogArchivingActive()) ||
          (backup_started_in_recovery && XLogArchivingAlways())))
     {
         XLByteToPrevSeg(stoppoint, _logSegNo, wal_segment_size);
         XLogFileName(lastxlogfilename, stoptli, _logSegNo, wal_segment_size);
 
         XLByteToSeg(startpoint, _logSegNo, wal_segment_size);
         BackupHistoryFileName(histfilename, stoptli, _logSegNo,
                               startpoint, wal_segment_size);
 
         seconds_before_warning = 60;
         waits = 0;
 
         while (XLogArchiveIsBusy(lastxlogfilename) ||
                XLogArchiveIsBusy(histfilename))
         {
             CHECK_FOR_INTERRUPTS();
 
             if (!reported_waiting && waits > 5)
             {
                 ereport(NOTICE,
                         (errmsg("base backup done, waiting for required WAL segments to be archived")));
                 reported_waiting = true;
             }
 
             pgstat_report_wait_start(WAIT_EVENT_BACKUP_WAIT_WAL_ARCHIVE);
             pg_usleep(1000000L);
             pgstat_report_wait_end();
 
             if (++waits >= seconds_before_warning)
             {
                 seconds_before_warning *= 2;    /* This wraps in >10 years... */
                 ereport(WARNING,
                         (errmsg("still waiting for all required WAL segments to be archived (%d seconds elapsed)",
                                 waits),
                          errhint("Check that your archive_command is executing properly.  "
                                  "You can safely cancel this backup, "
                                  "but the database backup will not be usable without all the WAL segments.")));
             }
         }
 
         ereport(NOTICE,
                 (errmsg("all required WAL segments have been archived")));
     }
     else if (waitforarchive)
         ereport(NOTICE,
                 (errmsg("WAL archiving is not enabled; you must ensure that all required WAL segments are copied through other means to complete the backup")));
 
     /*
      * We're done.  As a convenience, return the ending WAL location.
      */
     if (stoptli_p)
         *stoptli_p = stoptli;
     return stoppoint;
 }

◆ emode_for_corrupt_record()

static int emode_for_corrupt_record	(	int	emode,
		XLogRecPtr	RecPtr
	)

static

Definition at line 12532 of file xlog.c.

References DEBUG1, LOG, readSource, and XLOG_FROM_PG_WAL.

Referenced by ReadRecord(), and XLogPageRead().

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

◆ exitArchiveRecovery()

static void exitArchiveRecovery	(	TimeLineID	endTLI,
		XLogRecPtr	endOfLog
	)

static

Definition at line 5543 of file xlog.c.

References Assert, close, durable_unlink(), ereport, errcode_for_file_access(), errmsg(), ERROR, FATAL, fd(), InArchiveRecovery, InvalidXLogRecPtr, LOG, MAXFNAMELEN, readFile, RECOVERY_SIGNAL_FILE, recovery_signal_file_found, STANDBY_SIGNAL_FILE, standby_signal_file_found, ThisTimeLineID, UpdateMinRecoveryPoint(), wal_segment_size, XLByteToPrevSeg, XLByteToSeg, XLogArchiveCleanup(), XLogFileCopy(), XLogFileInit(), XLogFileName, and XLogSegmentOffset.

Referenced by StartupXLOG().

 {
     char        xlogfname[MAXFNAMELEN];
     XLogSegNo   endLogSegNo;
     XLogSegNo   startLogSegNo;
 
     /* we always switch to a new timeline after archive recovery */
     Assert(endTLI != ThisTimeLineID);
 
     /*
      * We are no longer in archive recovery state.
      */
     InArchiveRecovery = false;
 
     /*
      * Update min recovery point one last time.
      */
     UpdateMinRecoveryPoint(InvalidXLogRecPtr, true);
 
     /*
      * 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;
     }
 
     /*
      * Calculate the last segment on the old timeline, and the first segment
      * on the new timeline. If the switch happens in the middle of a segment,
      * they are the same, but if the switch happens exactly at a segment
      * boundary, startLogSegNo will be endLogSegNo + 1.
      */
     XLByteToPrevSeg(endOfLog, endLogSegNo, wal_segment_size);
     XLByteToSeg(endOfLog, startLogSegNo, wal_segment_size);
 
     /*
      * Initialize the starting WAL segment for the new timeline. If the switch
      * happens in the middle of a segment, copy data from the last WAL segment
      * of the old timeline up to the switch point, to the starting WAL segment
      * on the new timeline.
      */
     if (endLogSegNo == startLogSegNo)
     {
         /*
          * Make a copy of the file on the new timeline.
          *
          * Writing WAL isn't allowed yet, so there are no locking
          * considerations. But we should be just as tense as XLogFileInit to
          * avoid emplacing a bogus file.
          */
         XLogFileCopy(endLogSegNo, endTLI, endLogSegNo,
                      XLogSegmentOffset(endOfLog, wal_segment_size));
     }
     else
     {
         /*
          * The switch happened at a segment boundary, so just create the next
          * segment on the new timeline.
          */
         bool        use_existent = true;
         int         fd;
 
         fd = XLogFileInit(startLogSegNo, &use_existent, true);
 
         if (close(fd) != 0)
         {
             char        xlogfname[MAXFNAMELEN];
             int         save_errno = errno;
 
             XLogFileName(xlogfname, ThisTimeLineID, startLogSegNo,
                          wal_segment_size);
             errno = save_errno;
             ereport(ERROR,
                     (errcode_for_file_access(),
                      errmsg("could not close file \"%s\": %m", xlogfname)));
         }
     }
 
     /*
      * Let's just make real sure there are not .ready or .done flags posted
      * for the new segment.
      */
     XLogFileName(xlogfname, ThisTimeLineID, startLogSegNo, wal_segment_size);
     XLogArchiveCleanup(xlogfname);
 
     /*
      * Remove the signal files out of the way, so that we don't accidentally
      * re-enter archive recovery mode in a subsequent crash.
      */
     if (standby_signal_file_found)
         durable_unlink(STANDBY_SIGNAL_FILE, FATAL);
 
     if (recovery_signal_file_found)
         durable_unlink(RECOVERY_SIGNAL_FILE, FATAL);
 
     ereport(LOG,
             (errmsg("archive recovery complete")));
 }

Data Structures

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ ConvertToXSegs

◆ INSERT_FREESPACE

◆ NextBufIdx

◆ NUM_XLOGINSERT_LOCKS

◆ RECOVERY_COMMAND_DONE

◆ RECOVERY_COMMAND_FILE

◆ RecoveryRequiresIntParameter

◆ UsableBytesInPage

◆ XLogRecPtrToBufIdx

Typedef Documentation

◆ ExclusiveBackupState

◆ WALInsertLockPadded

◆ XLogCtlData

◆ XLogCtlInsert

◆ XLogPageReadPrivate

◆ XLogwrtResult

◆ XLogwrtRqst

Enumeration Type Documentation

◆ ExclusiveBackupState

◆ XLogSource

Function Documentation

◆ AdvanceXLInsertBuffer()

◆ assign_checkpoint_completion_target()

◆ assign_max_wal_size()

◆ assign_xlog_sync_method()

◆ BackupInProgress()

◆ BootStrapXLOG()

◆ CalculateCheckpointSegments()

◆ CancelBackup()

◆ check_wal_buffers()

◆ CheckForStandbyTrigger()

◆ CheckPointGuts()

◆ CheckPromoteSignal()

◆ CheckRecoveryConsistency()

◆ CheckRequiredParameterValues()

◆ checkTimeLineSwitch()

◆ checkXLogConsistency()

◆ CheckXLogRemoved()

◆ CleanupBackupHistory()

◆ CopyXLogRecordToWAL()

◆ CreateCheckPoint()

◆ CreateEndOfRecoveryRecord()

◆ CreateRestartPoint()

◆ DataChecksumsEnabled()

◆ do_pg_abort_backup()

◆ do_pg_start_backup()

◆ do_pg_stop_backup()

◆ emode_for_corrupt_record()

◆ exitArchiveRecovery()