#include "access/rmgr.h"
#include "access/xlogdefs.h"
#include "access/xloginsert.h"
#include "access/xlogreader.h"
#include "datatype/timestamp.h"
#include "lib/stringinfo.h"
#include "nodes/pg_list.h"
#include "storage/fd.h"

Include dependency graph for xlog.h:

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

Go to the source code of this file.

Data Structures
struct	CheckpointStatsData

Macros
#define	SYNC_METHOD_FSYNC 0

#define	SYNC_METHOD_FDATASYNC 1

#define	SYNC_METHOD_OPEN 2 /* for O_SYNC */

#define	SYNC_METHOD_FSYNC_WRITETHROUGH 3

#define	SYNC_METHOD_OPEN_DSYNC 4 /* for O_DSYNC */

#define	InHotStandby (standbyState >= STANDBY_SNAPSHOT_PENDING)

#define	XLogArchivingActive() (AssertMacro(XLogArchiveMode == ARCHIVE_MODE_OFF \|\| wal_level >= WAL_LEVEL_REPLICA), XLogArchiveMode > ARCHIVE_MODE_OFF)

#define	XLogArchivingAlways() (AssertMacro(XLogArchiveMode == ARCHIVE_MODE_OFF \|\| wal_level >= WAL_LEVEL_REPLICA), XLogArchiveMode == ARCHIVE_MODE_ALWAYS)

#define	XLogArchiveCommandSet() (XLogArchiveCommand[0] != '\0')

#define	XLogIsNeeded() (wal_level >= WAL_LEVEL_REPLICA)

#define	XLogHintBitIsNeeded() (DataChecksumsEnabled() \|\| wal_log_hints)

#define	XLogStandbyInfoActive() (wal_level >= WAL_LEVEL_REPLICA)

#define	XLogLogicalInfoActive() (wal_level >= WAL_LEVEL_LOGICAL)

#define	CHECKPOINT_IS_SHUTDOWN 0x0001 /* Checkpoint is for shutdown */

#define	CHECKPOINT_END_OF_RECOVERY

#define	CHECKPOINT_IMMEDIATE 0x0004 /* Do it without delays */

#define	CHECKPOINT_FORCE 0x0008 /* Force even if no activity */

#define	CHECKPOINT_FLUSH_ALL

#define	CHECKPOINT_WAIT 0x0020 /* Wait for completion */

#define	CHECKPOINT_CAUSE_XLOG 0x0040 /* XLOG consumption */

#define	CHECKPOINT_CAUSE_TIME 0x0080 /* Elapsed time */

#define	XLOG_INCLUDE_ORIGIN 0x01 /* include the replication origin */

#define	XLOG_MARK_UNIMPORTANT 0x02 /* record not important for durability */

#define	BACKUP_LABEL_FILE "backup_label"

#define	BACKUP_LABEL_OLD "backup_label.old"

#define	TABLESPACE_MAP "tablespace_map"

#define	TABLESPACE_MAP_OLD "tablespace_map.old"

Typedefs
typedef enum ArchiveMode	ArchiveMode

typedef enum WalLevel	WalLevel

typedef struct CheckpointStatsData	CheckpointStatsData

typedef enum SessionBackupState	SessionBackupState

Functions
XLogRecPtr	XLogInsertRecord (struct XLogRecData *rdata, XLogRecPtr fpw_lsn, uint8 flags)

void	XLogFlush (XLogRecPtr RecPtr)

bool	XLogBackgroundFlush (void)

bool	XLogNeedsFlush (XLogRecPtr RecPtr)

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

int	XLogFileOpen (XLogSegNo segno)

void	CheckXLogRemoved (XLogSegNo segno, TimeLineID tli)

XLogSegNo	XLogGetLastRemovedSegno (void)

void	XLogSetAsyncXactLSN (XLogRecPtr record)

void	XLogSetReplicationSlotMinimumLSN (XLogRecPtr lsn)

void	xlog_redo (XLogReaderState *record)

void	xlog_desc (StringInfo buf, XLogReaderState *record)

const char *	xlog_identify (uint8 info)

void	issue_xlog_fsync (int fd, XLogSegNo segno)

bool	RecoveryInProgress (void)

bool	HotStandbyActive (void)

bool	HotStandbyActiveInReplay (void)

bool	XLogInsertAllowed (void)

void	GetXLogReceiptTime (TimestampTz rtime, bool fromStream)

XLogRecPtr	GetXLogReplayRecPtr (TimeLineID *replayTLI)

XLogRecPtr	GetXLogInsertRecPtr (void)

XLogRecPtr	GetXLogWriteRecPtr (void)

bool	RecoveryIsPaused (void)

void	SetRecoveryPause (bool recoveryPause)

TimestampTz	GetLatestXTime (void)

TimestampTz	GetCurrentChunkReplayStartTime (void)

char *	XLogFileNameP (TimeLineID tli, XLogSegNo segno)

void	UpdateControlFile (void)

uint64	GetSystemIdentifier (void)

char *	GetMockAuthenticationNonce (void)

bool	DataChecksumsEnabled (void)

XLogRecPtr	GetFakeLSNForUnloggedRel (void)

Size	XLOGShmemSize (void)

void	XLOGShmemInit (void)

void	BootStrapXLOG (void)

void	LocalProcessControlFile (bool reset)

void	StartupXLOG (void)

void	ShutdownXLOG (int code, Datum arg)

void	InitXLOGAccess (void)

void	CreateCheckPoint (int flags)

bool	CreateRestartPoint (int flags)

void	XLogPutNextOid (Oid nextOid)

XLogRecPtr	XLogRestorePoint (const char *rpName)

void	UpdateFullPageWrites (void)

void	GetFullPageWriteInfo (XLogRecPtr RedoRecPtr_p, bool doPageWrites_p)

XLogRecPtr	GetRedoRecPtr (void)

XLogRecPtr	GetInsertRecPtr (void)

XLogRecPtr	GetFlushRecPtr (void)

XLogRecPtr	GetLastImportantRecPtr (void)

void	GetNextXidAndEpoch (TransactionId xid, uint32 epoch)

void	RemovePromoteSignalFiles (void)

bool	CheckPromoteSignal (void)

void	WakeupRecovery (void)

void	SetWalWriterSleeping (bool sleeping)

void	XLogRequestWalReceiverReply (void)

void	assign_max_wal_size (int newval, void *extra)

void	assign_checkpoint_completion_target (double newval, void *extra)

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

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

void	do_pg_abort_backup (void)

SessionBackupState	get_backup_status (void)

Macro Definition Documentation

◆ BACKUP_LABEL_FILE

#define BACKUP_LABEL_FILE "backup_label"

Definition at line 322 of file xlog.h.

Referenced by BackupInProgress(), CancelBackup(), do_pg_start_backup(), do_pg_stop_backup(), perform_base_backup(), pg_backup_start_time(), read_backup_label(), and StartupXLOG().

◆ BACKUP_LABEL_OLD

#define BACKUP_LABEL_OLD "backup_label.old"

Definition at line 323 of file xlog.h.

Referenced by CancelBackup(), and StartupXLOG().

◆ CHECKPOINT_CAUSE_TIME

#define CHECKPOINT_CAUSE_TIME 0x0080 /* Elapsed time */

Definition at line 187 of file xlog.h.

Referenced by CheckpointerMain(), and LogCheckpointStart().

◆ CHECKPOINT_CAUSE_XLOG

#define CHECKPOINT_CAUSE_XLOG 0x0040 /* XLOG consumption */

Definition at line 186 of file xlog.h.

Referenced by CheckpointerMain(), LogCheckpointStart(), XLogPageRead(), and XLogWrite().

◆ CHECKPOINT_END_OF_RECOVERY

#define CHECKPOINT_END_OF_RECOVERY

Value:

0x0002 /* Like shutdown checkpoint, but

* issued at end of WAL recovery */

Definition at line 177 of file xlog.h.

Referenced by BufferSync(), CheckpointerMain(), CreateCheckPoint(), LogCheckpointStart(), and StartupXLOG().

◆ CHECKPOINT_FLUSH_ALL

#define CHECKPOINT_FLUSH_ALL

Value:

0x0010 /* Flush all pages, including those

* belonging to unlogged tables */

Definition at line 181 of file xlog.h.

Referenced by BufferSync(), createdb(), LogCheckpointStart(), and movedb().

◆ CHECKPOINT_FORCE

#define CHECKPOINT_FORCE 0x0008 /* Force even if no activity */

Definition at line 180 of file xlog.h.

Referenced by CreateCheckPoint(), createdb(), do_pg_start_backup(), dropdb(), DropTableSpace(), LogCheckpointStart(), movedb(), standard_ProcessUtility(), and StartupXLOG().

◆ CHECKPOINT_IMMEDIATE

#define CHECKPOINT_IMMEDIATE 0x0004 /* Do it without delays */

Definition at line 179 of file xlog.h.

Referenced by CheckpointWriteDelay(), createdb(), do_pg_start_backup(), dropdb(), DropTableSpace(), ImmediateCheckpointRequested(), LogCheckpointStart(), movedb(), RequestCheckpoint(), ShutdownXLOG(), standard_ProcessUtility(), and StartupXLOG().

◆ CHECKPOINT_IS_SHUTDOWN

#define CHECKPOINT_IS_SHUTDOWN 0x0001 /* Checkpoint is for shutdown */

Definition at line 176 of file xlog.h.

Referenced by BufferSync(), CreateCheckPoint(), CreateRestartPoint(), LogCheckpointStart(), and ShutdownXLOG().

◆ CHECKPOINT_WAIT

#define CHECKPOINT_WAIT 0x0020 /* Wait for completion */

Definition at line 184 of file xlog.h.

Referenced by createdb(), do_pg_start_backup(), dropdb(), DropTableSpace(), LogCheckpointStart(), movedb(), RequestCheckpoint(), standard_ProcessUtility(), and StartupXLOG().

◆ InHotStandby

#define InHotStandby (standbyState >= STANDBY_SNAPSHOT_PENDING)

Definition at line 74 of file xlog.h.

Referenced by btree_xlog_delete(), btree_xlog_reuse_page(), dbase_redo(), GetLockConflicts(), hash_xlog_vacuum_one_page(), heap_xlog_clean(), heap_xlog_cleanup_info(), heap_xlog_freeze_page(), heap_xlog_visible(), LockBufferForCleanup(), ProcSleep(), RecoverPreparedTransactions(), ResolveRecoveryConflictWithBufferPin(), ResolveRecoveryConflictWithLock(), and spgRedoVacuumRedirect().

◆ SYNC_METHOD_FDATASYNC

#define SYNC_METHOD_FDATASYNC 1

Definition at line 26 of file xlog.h.

Referenced by get_sync_bit(), and issue_xlog_fsync().

◆ SYNC_METHOD_FSYNC

#define SYNC_METHOD_FSYNC 0

Definition at line 25 of file xlog.h.

Referenced by get_sync_bit(), and issue_xlog_fsync().

◆ SYNC_METHOD_FSYNC_WRITETHROUGH

#define SYNC_METHOD_FSYNC_WRITETHROUGH 3

Definition at line 28 of file xlog.h.

Referenced by get_sync_bit(), issue_xlog_fsync(), and pg_fsync().

◆ SYNC_METHOD_OPEN

#define SYNC_METHOD_OPEN 2 /* for O_SYNC */

Definition at line 27 of file xlog.h.

Referenced by get_sync_bit(), issue_xlog_fsync(), and XLogWrite().

◆ SYNC_METHOD_OPEN_DSYNC

#define SYNC_METHOD_OPEN_DSYNC 4 /* for O_DSYNC */

Definition at line 29 of file xlog.h.

Referenced by get_sync_bit(), issue_xlog_fsync(), and XLogWrite().

◆ TABLESPACE_MAP

#define TABLESPACE_MAP "tablespace_map"

Definition at line 325 of file xlog.h.

Referenced by CancelBackup(), do_pg_start_backup(), do_pg_stop_backup(), perform_base_backup(), read_tablespace_map(), and StartupXLOG().

◆ TABLESPACE_MAP_OLD

#define TABLESPACE_MAP_OLD "tablespace_map.old"

Definition at line 326 of file xlog.h.

Referenced by CancelBackup(), and StartupXLOG().

◆ XLOG_INCLUDE_ORIGIN

#define XLOG_INCLUDE_ORIGIN 0x01 /* include the replication origin */

Definition at line 192 of file xlog.h.

Referenced by EndPrepare(), ExecuteTruncateGuts(), heap_delete(), heap_finish_speculative(), heap_insert(), heap_multi_insert(), log_heap_update(), LogLogicalMessage(), XactLogAbortRecord(), XactLogCommitRecord(), and XLogRecordAssemble().

◆ XLOG_MARK_UNIMPORTANT

#define XLOG_MARK_UNIMPORTANT 0x02 /* record not important for durability */

Definition at line 193 of file xlog.h.

Referenced by LogAccessExclusiveLocks(), LogCurrentRunningXacts(), RequestXLogSwitch(), and XLogInsertRecord().

◆ XLogArchiveCommandSet

#define XLogArchiveCommandSet ( ) (XLogArchiveCommand[0] != '\0')

Definition at line 140 of file xlog.h.

Referenced by pgarch_ArchiverCopyLoop(), and ShutdownXLOG().

◆ XLogArchivingActive

#define XLogArchivingActive ( ) (AssertMacro(XLogArchiveMode == ARCHIVE_MODE_OFF || wal_level >= WAL_LEVEL_REPLICA), XLogArchiveMode > ARCHIVE_MODE_OFF)

Definition at line 135 of file xlog.h.

Referenced by do_pg_stop_backup(), pgarch_start(), show_archive_command(), ShutdownXLOG(), StartupXLOG(), writeTimeLineHistory(), XLogArchiveCheckDone(), and XLogWrite().

◆ XLogArchivingAlways

#define XLogArchivingAlways ( ) (AssertMacro(XLogArchiveMode == ARCHIVE_MODE_OFF || wal_level >= WAL_LEVEL_REPLICA), XLogArchiveMode == ARCHIVE_MODE_ALWAYS)

Definition at line 138 of file xlog.h.

Referenced by do_pg_stop_backup(), and sigusr1_handler().

◆ XLogHintBitIsNeeded

#define XLogHintBitIsNeeded ( ) (DataChecksumsEnabled() || wal_log_hints)

Definition at line 157 of file xlog.h.

Referenced by BufferGetLSNAtomic(), FreeSpaceMapTruncateRel(), log_heap_visible(), MarkBufferDirtyHint(), visibilitymap_set(), and visibilitymap_truncate().

◆ XLogIsNeeded

#define XLogIsNeeded ( ) (wal_level >= WAL_LEVEL_REPLICA)

Definition at line 146 of file xlog.h.

Referenced by _bt_leafbuild(), ATRewriteTable(), copy_heap_data(), copy_relation_data(), CopyFrom(), do_pg_start_backup(), do_pg_stop_backup(), get_sync_bit(), intorel_startup(), pg_create_restore_point(), transientrel_startup(), vacuum_log_cleanup_info(), XLogFileClose(), and XLogReportParameters().

◆ XLogLogicalInfoActive

#define XLogLogicalInfoActive ( ) (wal_level >= WAL_LEVEL_LOGICAL)

Definition at line 163 of file xlog.h.

Referenced by AssignTransactionId(), ExecuteTruncateGuts(), XactLogAbortRecord(), and XactLogCommitRecord().

◆ XLogStandbyInfoActive

#define XLogStandbyInfoActive ( ) (wal_level >= WAL_LEVEL_REPLICA)

Definition at line 160 of file xlog.h.

Referenced by _bt_getbuf(), AssignTransactionId(), BackgroundWriterMain(), btvacuumscan(), CreateCheckPoint(), LockAcquireExtended(), LogStandbySnapshot(), RecordTransactionCommit(), and UpdateFullPageWrites().

Typedef Documentation

◆ ArchiveMode

typedef enum ArchiveMode ArchiveMode

◆ CheckpointStatsData

typedef struct CheckpointStatsData CheckpointStatsData

◆ SessionBackupState

typedef enum SessionBackupState SessionBackupState

◆ WalLevel

typedef enum WalLevel WalLevel

Enumeration Type Documentation

◆ ArchiveMode

enum ArchiveMode

Enumerator
ARCHIVE_MODE_OFF
ARCHIVE_MODE_ON
ARCHIVE_MODE_ALWAYS

Definition at line 116 of file xlog.h.

 {
     ARCHIVE_MODE_OFF = 0,       /* disabled */
     ARCHIVE_MODE_ON,            /* enabled while server is running normally */
     ARCHIVE_MODE_ALWAYS         /* enabled always (even during recovery) */
 } ArchiveMode;

◆ HotStandbyState

enum HotStandbyState

Enumerator
STANDBY_DISABLED
STANDBY_INITIALIZED
STANDBY_SNAPSHOT_PENDING
STANDBY_SNAPSHOT_READY

Definition at line 64 of file xlog.h.

 {
     STANDBY_DISABLED,
     STANDBY_INITIALIZED,
     STANDBY_SNAPSHOT_PENDING,
     STANDBY_SNAPSHOT_READY
 } HotStandbyState;

◆ RecoveryTargetType

enum RecoveryTargetType

Enumerator
RECOVERY_TARGET_UNSET
RECOVERY_TARGET_XID
RECOVERY_TARGET_TIME
RECOVERY_TARGET_NAME
RECOVERY_TARGET_LSN
RECOVERY_TARGET_IMMEDIATE

Definition at line 80 of file xlog.h.

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

◆ SessionBackupState

enum SessionBackupState

Enumerator
SESSION_BACKUP_NONE
SESSION_BACKUP_EXCLUSIVE
SESSION_BACKUP_NON_EXCLUSIVE

Definition at line 305 of file xlog.h.

 {
     SESSION_BACKUP_NONE,
     SESSION_BACKUP_EXCLUSIVE,
     SESSION_BACKUP_NON_EXCLUSIVE
 } SessionBackupState;

◆ WalLevel

enum WalLevel

Enumerator
WAL_LEVEL_MINIMAL
WAL_LEVEL_REPLICA
WAL_LEVEL_LOGICAL

Definition at line 125 of file xlog.h.

 {
     WAL_LEVEL_MINIMAL = 0,
     WAL_LEVEL_REPLICA,
     WAL_LEVEL_LOGICAL
 } WalLevel;

Function Documentation

◆ assign_checkpoint_completion_target()

void assign_checkpoint_completion_target	(	double	newval,
		void *	extra
	)

Definition at line 2272 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 2265 of file xlog.c.

References CalculateCheckpointSegments(), max_wal_size_mb, and newval.

 {
     max_wal_size_mb = newval;
     CalculateCheckpointSegments();
 }

◆ BootStrapXLOG()

void BootStrapXLOG ( void )

Definition at line 5026 of file xlog.c.

References AdvanceOldestClogXid(), Assert, bootstrap_data_checksum_version, BootStrapCLOG(), BootStrapCommitTs(), BootStrapMultiXact(), BootStrapSUBTRANS(), buffer, ControlFileData::checkPoint, ControlFileData::checkPointCopy, close, COMP_CRC32C, ControlFileData::data_checksum_version, DB_SHUTDOWNED, ereport, errcode(), errcode_for_file_access(), errmsg(), FIN_CRC32C, FirstBootstrapObjectId, FirstMultiXactId, FirstNormalTransactionId, CheckPoint::fullPageWrites, fullPageWrites, gettimeofday(), INIT_CRC32C, InvalidTransactionId, max_locks_per_xact, ControlFileData::max_locks_per_xact, max_prepared_xacts, ControlFileData::max_prepared_xacts, max_worker_processes, ControlFileData::max_worker_processes, MaxConnections, ControlFileData::MaxConnections, MOCK_AUTH_NONCE_LEN, ControlFileData::mock_authentication_nonce, MultiXactSetNextMXact(), CheckPoint::newestCommitTsXid, CheckPoint::nextMulti, CheckPoint::nextMultiOffset, CheckPoint::nextOid, VariableCacheData::nextOid, CheckPoint::nextXid, VariableCacheData::nextXid, CheckPoint::nextXidEpoch, offsetof, VariableCacheData::oidCount, CheckPoint::oldestActiveXid, CheckPoint::oldestCommitTsXid, CheckPoint::oldestMulti, CheckPoint::oldestMultiDB, CheckPoint::oldestXid, CheckPoint::oldestXidDB, openLogFile, palloc(), PANIC, pfree(), pg_backend_random(), pg_fsync(), pgstat_report_wait_end(), pgstat_report_wait_start(), CheckPoint::PrevTimeLineID, ReadControlFile(), CheckPoint::redo, SetCommitTsLimit(), SetMultiXactIdLimit(), SetTransactionIdLimit(), ShmemVariableCache, SizeOfXLogLongPHD, SizeOfXLogRecord, SizeOfXLogRecordDataHeaderShort, ControlFileData::state, ControlFileData::system_identifier, CheckPoint::ThisTimeLineID, ThisTimeLineID, CheckPoint::time, ControlFileData::time, track_commit_timestamp, ControlFileData::track_commit_timestamp, TYPEALIGN, ControlFileData::unloggedLSN, WAIT_EVENT_WAL_BOOTSTRAP_SYNC, WAIT_EVENT_WAL_BOOTSTRAP_WRITE, wal_level, ControlFileData::wal_level, wal_log_hints, ControlFileData::wal_log_hints, 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;
     char        mock_auth_nonce[MOCK_AUTH_NONCE_LEN];
     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;
 
     /*
      * Generate a random nonce. This is used for authentication requests that
      * will fail because the user does not exist. The nonce is used to create
      * a genuine-looking password challenge for the non-existent user, in lieu
      * of an actual stored password.
      */
     if (!pg_backend_random(mock_auth_nonce, MOCK_AUTH_NONCE_LEN))
         ereport(PANIC,
                 (errcode(ERRCODE_INTERNAL_ERROR),
                  errmsg("could not generate secret authorization token")));
 
     /* 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.nextXidEpoch = 0;
     checkPoint.nextXid = 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);
 
     /* 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))
         ereport(PANIC,
                 (errcode_for_file_access(),
                  errmsg("could not close bootstrap write-ahead log file: %m")));
 
     openLogFile = -1;
 
     /* Now create pg_control */
 
     memset(ControlFile, 0, sizeof(ControlFileData));
     /* Initialize pg_control status fields */
     ControlFile->system_identifier = sysidentifier;
     memcpy(ControlFile->mock_authentication_nonce, mock_auth_nonce, MOCK_AUTH_NONCE_LEN);
     ControlFile->state = DB_SHUTDOWNED;
     ControlFile->time = checkPoint.time;
     ControlFile->checkPoint = checkPoint.redo;
     ControlFile->checkPointCopy = checkPoint;
     ControlFile->unloggedLSN = 1;
 
     /* Set important parameter values for use when replaying WAL */
     ControlFile->MaxConnections = MaxConnections;
     ControlFile->max_worker_processes = max_worker_processes;
     ControlFile->max_prepared_xacts = max_prepared_xacts;
     ControlFile->max_locks_per_xact = max_locks_per_xact;
     ControlFile->wal_level = wal_level;
     ControlFile->wal_log_hints = wal_log_hints;
     ControlFile->track_commit_timestamp = track_commit_timestamp;
     ControlFile->data_checksum_version = bootstrap_data_checksum_version;
 
     /* 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();
 }

◆ CheckPromoteSignal()

bool CheckPromoteSignal ( void )

Definition at line 12268 of file xlog.c.

References FALLBACK_PROMOTE_SIGNAL_FILE, PROMOTE_SIGNAL_FILE, and stat.

Referenced by sigusr1_handler().

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

◆ CheckXLogRemoved()

void CheckXLogRemoved	(	XLogSegNo	segno,
		TimeLineID	tli
	)

Definition at line 3794 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 perform_base_backup(), and XLogRead().

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

◆ CreateCheckPoint()

void CreateCheckPoint ( int flags )

Definition at line 8587 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::ckptXid, XLogCtlData::ckptXidEpoch, 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, 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, CheckPoint::nextXidEpoch, 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, smgrpostckpt(), smgrpreckpt(), SpinLockAcquire, SpinLockRelease, START_CRIT_SECTION, ControlFileData::state, 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;
     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.
      */
     smgrpreckpt();
 
     /* 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);
 
     /* Increase XID epoch if we've wrapped around since last checkpoint */
     checkPoint.nextXidEpoch = ControlFile->checkPointCopy.nextXidEpoch;
     if (checkPoint.nextXid < ControlFile->checkPointCopy.nextXid)
         checkPoint.nextXidEpoch++;
 
     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->ckptXidEpoch = checkPoint.nextXidEpoch;
     XLogCtl->ckptXid = 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).
      */
     smgrpostckpt();
 
     /*
      * Delete old log files and recycle them
      */
     if (PriorRedoPtr != InvalidXLogRecPtr)
     {
         XLogSegNo   _logSegNo;
 
         /* Update the average distance between checkpoints. */
         UpdateCheckPointDistanceEstimate(RedoRecPtr - PriorRedoPtr);
 
         /* Trim from the last checkpoint, not the last - 1 */
         XLByteToSeg(RedoRecPtr, _logSegNo, wal_segment_size);
         KeepLogSeg(recptr, &_logSegNo);
         _logSegNo--;
         RemoveOldXlogFiles(_logSegNo, PriorRedoPtr, 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);
 }

◆ CreateRestartPoint()

bool CreateRestartPoint ( int flags )

Definition at line 9133 of file xlog.c.

References XLogCtlData::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(), GetWalRcvWriteRecPtr(), GetXLogReplayRecPtr(), XLogCtlData::info_lck, XLogCtlData::Insert, 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;
     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
      * 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);
 
     /*
      * Delete old log files (those no longer needed even for previous
      * checkpoint/restartpoint) to prevent the disk holding the xlog from
      * growing full.
      */
     if (PriorRedoPtr != InvalidXLogRecPtr)
     {
         XLogRecPtr  receivePtr;
         XLogRecPtr  replayPtr;
         TimeLineID  replayTLI;
         XLogRecPtr  endptr;
         XLogSegNo   _logSegNo;
 
         /* Update the average distance between checkpoints/restartpoints. */
         UpdateCheckPointDistanceEstimate(RedoRecPtr - PriorRedoPtr);
 
         XLByteToSeg(PriorRedoPtr, _logSegNo, wal_segment_size);
 
         /*
          * Get the current end of xlog replayed or received, whichever is
          * later.
          */
         receivePtr = GetWalRcvWriteRecPtr(NULL, NULL);
         replayPtr = GetXLogReplayRecPtr(&replayTLI);
         endptr = (receivePtr < replayPtr) ? replayPtr : receivePtr;
 
         KeepLogSeg(endptr, &_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, PriorRedoPtr, 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 (XLogCtl->archiveCleanupCommand[0])
         ExecuteRecoveryCommand(XLogCtl->archiveCleanupCommand,
                                "archive_cleanup_command",
                                false);
 
     return true;
 }

◆ DataChecksumsEnabled()

bool DataChecksumsEnabled ( void )

Definition at line 4761 of file xlog.c.

References Assert, and ControlFileData::data_checksum_version.

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

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

◆ do_pg_abort_backup()

void do_pg_abort_backup ( void )

Definition at line 11166 of file xlog.c.

References Assert, EXCLUSIVE_BACKUP_NONE, XLogCtlInsert::exclusiveBackupState, XLogCtlInsert::forcePageWrites, XLogCtlData::Insert, XLogCtlInsert::nonExclusiveBackups, SESSION_BACKUP_NON_EXCLUSIVE, SESSION_BACKUP_NONE, sessionBackupState, WALInsertLockAcquireExclusive(), and WALInsertLockRelease().

Referenced by base_backup_cleanup(), and nonexclusive_base_backup_cleanup().

 {
     /*
      * Quick exit if session is not keeping around a non-exclusive backup
      * already started.
      */
     if (sessionBackupState == SESSION_BACKUP_NONE)
         return;
 
     WALInsertLockAcquireExclusive();
     Assert(XLogCtl->Insert.nonExclusiveBackups > 0);
     Assert(sessionBackupState == SESSION_BACKUP_NON_EXCLUSIVE);
     XLogCtl->Insert.nonExclusiveBackups--;
 
     if (XLogCtl->Insert.exclusiveBackupState == EXCLUSIVE_BACKUP_NONE &&
         XLogCtl->Insert.nonExclusiveBackups == 0)
     {
         XLogCtl->Insert.forcePageWrites = false;
     }
     WALInsertLockRelease();
 }

◆ do_pg_start_backup()

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

Definition at line 10244 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, sendTablespace(), 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 master, "
                                      "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 = infotbssize ? sendTablespace(fullpath, true) : -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" : "master");
         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 10761 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, 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(), RecoveryInProgress(), remaining, RequestXLogSwitch(), SESSION_BACKUP_NONE, sessionBackupState, SpinLockAcquire, SpinLockRelease, stat, TABLESPACE_MAP, ThisTimeLineID, 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 master, "
                              "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_segments 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("pg_stop_backup cleanup done, waiting for required WAL segments to be archived")));
                 reported_waiting = true;
             }
 
             pg_usleep(1000000L);
 
             if (++waits >= seconds_before_warning)
             {
                 seconds_before_warning *= 2;    /* This wraps in >10 years... */
                 ereport(WARNING,
                         (errmsg("pg_stop_backup still waiting for all required WAL segments to be archived (%d seconds elapsed)",
                                 waits),
                          errhint("Check that your archive_command is executing properly.  "
                                  "pg_stop_backup can be canceled safely, "
                                  "but the database backup will not be usable without all the WAL segments.")));
             }
         }
 
         ereport(NOTICE,
                 (errmsg("pg_stop_backup complete, 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;
 }

◆ get_backup_status()

SessionBackupState get_backup_status ( void )

Definition at line 10742 of file xlog.c.

References sessionBackupState.

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

 {
     return sessionBackupState;
 }

◆ GetCurrentChunkReplayStartTime()

TimestampTz GetCurrentChunkReplayStartTime ( void )

Definition at line 6189 of file xlog.c.

References XLogCtlData::currentChunkStartTime, XLogCtlData::info_lck, SpinLockAcquire, and SpinLockRelease.

Referenced by GetReplicationApplyDelay().

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

◆ GetFakeLSNForUnloggedRel()

XLogRecPtr GetFakeLSNForUnloggedRel ( void )

Definition at line 4777 of file xlog.c.

References SpinLockAcquire, SpinLockRelease, XLogCtlData::ulsn_lck, and XLogCtlData::unloggedLSN.

Referenced by gistGetFakeLSN().

 {
     XLogRecPtr  nextUnloggedLSN;
 
     /* increment the unloggedLSN counter, need SpinLock */
     SpinLockAcquire(&XLogCtl->ulsn_lck);
     nextUnloggedLSN = XLogCtl->unloggedLSN++;
     SpinLockRelease(&XLogCtl->ulsn_lck);
 
     return nextUnloggedLSN;
 }

◆ GetFlushRecPtr()

XLogRecPtr GetFlushRecPtr ( void )

Definition at line 8281 of file xlog.c.

References XLogwrtResult::Flush, XLogCtlData::info_lck, XLogCtlData::LogwrtResult, SpinLockAcquire, and SpinLockRelease.

Referenced by get_flush_position(), IdentifySystem(), pg_current_wal_flush_lsn(), pg_logical_slot_get_changes_guts(), pg_replication_slot_advance(), read_local_xlog_page(), StartReplication(), WalSndWaitForWal(), XLogSendLogical(), and XLogSendPhysical().

 {
     SpinLockAcquire(&XLogCtl->info_lck);
     LogwrtResult = XLogCtl->LogwrtResult;
     SpinLockRelease(&XLogCtl->info_lck);
 
     return LogwrtResult.Flush;
 }

◆ GetFullPageWriteInfo()

void GetFullPageWriteInfo	(	XLogRecPtr *	RedoRecPtr_p,
		bool *	doPageWrites_p
	)

Definition at line 8250 of file xlog.c.

References doPageWrites, and RedoRecPtr.

Referenced by XLogCheckBufferNeedsBackup(), and XLogInsert().

 {
     *RedoRecPtr_p = RedoRecPtr;
     *doPageWrites_p = doPageWrites;
 }

◆ GetInsertRecPtr()

XLogRecPtr GetInsertRecPtr ( void )

Definition at line 8265 of file xlog.c.

References XLogCtlData::info_lck, XLogCtlData::LogwrtRqst, SpinLockAcquire, SpinLockRelease, and XLogwrtRqst::Write.

Referenced by CheckpointerMain(), and IsCheckpointOnSchedule().

 {
     XLogRecPtr  recptr;
 
     SpinLockAcquire(&XLogCtl->info_lck);
     recptr = XLogCtl->LogwrtRqst.Write;
     SpinLockRelease(&XLogCtl->info_lck);
 
     return recptr;
 }

◆ GetLastImportantRecPtr()

XLogRecPtr GetLastImportantRecPtr ( void )

Definition at line 8299 of file xlog.c.

References i, InvalidXLogRecPtr, WALInsertLockPadded::l, WALInsertLock::lastImportantAt, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), and NUM_XLOGINSERT_LOCKS.

Referenced by BackgroundWriterMain(), CheckArchiveTimeout(), and CreateCheckPoint().

 {
     XLogRecPtr  res = InvalidXLogRecPtr;
     int         i;
 
     for (i = 0; i < NUM_XLOGINSERT_LOCKS; i++)
     {
         XLogRecPtr  last_important;
 
         /*
          * Need to take a lock to prevent torn reads of the LSN, which are
          * possible on some of the supported platforms. WAL insert locks only
          * support exclusive mode, so we have to use that.
          */
         LWLockAcquire(&WALInsertLocks[i].l.lock, LW_EXCLUSIVE);
         last_important = WALInsertLocks[i].l.lastImportantAt;
         LWLockRelease(&WALInsertLocks[i].l.lock);
 
         if (res < last_important)
             res = last_important;
     }
 
     return res;
 }

◆ GetLatestXTime()

TimestampTz GetLatestXTime ( void )

Definition at line 6159 of file xlog.c.

References XLogCtlData::info_lck, XLogCtlData::recoveryLastXTime, SpinLockAcquire, and SpinLockRelease.

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

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

◆ GetMockAuthenticationNonce()

char* GetMockAuthenticationNonce ( void )

Definition at line 4751 of file xlog.c.

References Assert, and ControlFileData::mock_authentication_nonce.

Referenced by scram_mock_salt().

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

◆ GetNextXidAndEpoch()

void GetNextXidAndEpoch	(	TransactionId *	xid,
		uint32 *	epoch
	)

Definition at line 8350 of file xlog.c.

References XLogCtlData::ckptXid, XLogCtlData::ckptXidEpoch, XLogCtlData::info_lck, ReadNewTransactionId(), SpinLockAcquire, and SpinLockRelease.

Referenced by load_xid_epoch(), TransactionIdInRecentPast(), and XLogWalRcvSendHSFeedback().

 {
     uint32      ckptXidEpoch;
     TransactionId ckptXid;
     TransactionId nextXid;
 
     /* Must read checkpoint info first, else have race condition */
     SpinLockAcquire(&XLogCtl->info_lck);
     ckptXidEpoch = XLogCtl->ckptXidEpoch;
     ckptXid = XLogCtl->ckptXid;
     SpinLockRelease(&XLogCtl->info_lck);
 
     /* Now fetch current nextXid */
     nextXid = ReadNewTransactionId();
 
     /*
      * nextXid is certainly logically later than ckptXid.  So if it's
      * numerically less, it must have wrapped into the next epoch.
      */
     if (nextXid < ckptXid)
         ckptXidEpoch++;
 
     *xid = nextXid;
     *epoch = ckptXidEpoch;
 }

◆ GetRedoRecPtr()

XLogRecPtr GetRedoRecPtr ( void )

Definition at line 8222 of file xlog.c.

References XLogCtlData::info_lck, RedoRecPtr, XLogCtlData::RedoRecPtr, SpinLockAcquire, and SpinLockRelease.

Referenced by CheckPointLogicalRewriteHeap(), CheckPointSnapBuild(), InitXLOGAccess(), nextval_internal(), ReplicationSlotReserveWal(), XLogPageRead(), XLogSaveBufferForHint(), and XLogWrite().

 {
     XLogRecPtr  ptr;
 
     /*
      * The possibly not up-to-date copy in XlogCtl is enough. Even if we
      * grabbed a WAL insertion lock to read the master copy, someone might
      * update it just after we've released the lock.
      */
     SpinLockAcquire(&XLogCtl->info_lck);
     ptr = XLogCtl->RedoRecPtr;
     SpinLockRelease(&XLogCtl->info_lck);
 
     if (RedoRecPtr < ptr)
         RedoRecPtr = ptr;
 
     return RedoRecPtr;
 }

◆ GetSystemIdentifier()

uint64 GetSystemIdentifier ( void )

Definition at line 4741 of file xlog.c.

References Assert, and ControlFileData::system_identifier.

Referenced by IdentifySystem(), and WalReceiverMain().

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

◆ GetXLogInsertRecPtr()

XLogRecPtr GetXLogInsertRecPtr ( void )

Definition at line 11213 of file xlog.c.

References XLogCtlInsert::CurrBytePos, Insert(), XLogCtlData::Insert, XLogCtlInsert::insertpos_lck, SpinLockAcquire, SpinLockRelease, and XLogBytePosToRecPtr().

Referenced by GetSnapshotData(), logical_begin_heap_rewrite(), pg_current_wal_insert_lsn(), and ReplicationSlotReserveWal().

 {
     XLogCtlInsert *Insert = &XLogCtl->Insert;
     uint64      current_bytepos;
 
     SpinLockAcquire(&Insert->insertpos_lck);
     current_bytepos = Insert->CurrBytePos;
     SpinLockRelease(&Insert->insertpos_lck);
 
     return XLogBytePosToRecPtr(current_bytepos);
 }

◆ GetXLogReceiptTime()

void GetXLogReceiptTime	(	TimestampTz *	rtime,
		bool *	fromStream
	)

Definition at line 6205 of file xlog.c.

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

Referenced by GetStandbyLimitTime().

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

◆ GetXLogReplayRecPtr()

XLogRecPtr GetXLogReplayRecPtr ( TimeLineID * replayTLI )

Definition at line 11194 of file xlog.c.

References XLogCtlData::info_lck, XLogCtlData::lastReplayedEndRecPtr, XLogCtlData::lastReplayedTLI, SpinLockAcquire, and SpinLockRelease.

Referenced by CheckpointerMain(), CreateRestartPoint(), GetReplicationApplyDelay(), GetStandbyFlushRecPtr(), IsCheckpointOnSchedule(), pg_last_wal_replay_lsn(), pg_logical_slot_get_changes_guts(), pg_replication_slot_advance(), read_local_xlog_page(), WalReceiverMain(), WalSndWaitForWal(), and XLogWalRcvSendReply().

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

◆ GetXLogWriteRecPtr()

XLogRecPtr GetXLogWriteRecPtr ( void )

Definition at line 11229 of file xlog.c.

References XLogCtlData::info_lck, XLogCtlData::LogwrtResult, SpinLockAcquire, SpinLockRelease, and XLogwrtResult::Write.

Referenced by pg_attribute_noreturn(), and pg_current_wal_lsn().

 {
     SpinLockAcquire(&XLogCtl->info_lck);
     LogwrtResult = XLogCtl->LogwrtResult;
     SpinLockRelease(&XLogCtl->info_lck);
 
     return LogwrtResult.Write;
 }

◆ HotStandbyActive()

bool HotStandbyActive ( void )

Definition at line 8005 of file xlog.c.

References XLogCtlData::info_lck, LocalHotStandbyActive, XLogCtlData::SharedHotStandbyActive, SpinLockAcquire, and SpinLockRelease.

Referenced by XLogWalRcvSendHSFeedback().

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

◆ HotStandbyActiveInReplay()

bool HotStandbyActiveInReplay ( void )

Definition at line 8030 of file xlog.c.

References AmStartupProcess, Assert, IsPostmasterEnvironment, and LocalHotStandbyActive.

Referenced by btree_xlog_vacuum().

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

◆ InitXLOGAccess()

void InitXLOGAccess ( void )

Definition at line 8196 of file xlog.c.

References Assert, doPageWrites, XLogCtlInsert::forcePageWrites, XLogCtlInsert::fullPageWrites, GetRedoRecPtr(), InitXLogInsert(), Insert(), XLogCtlData::Insert, IsBootstrapProcessingMode, ThisTimeLineID, XLogCtlData::ThisTimeLineID, wal_segment_size, and ControlFileData::xlog_seg_size.

Referenced by AuxiliaryProcessMain(), LocalSetXLogInsertAllowed(), and RecoveryInProgress().

 {
     XLogCtlInsert *Insert = &XLogCtl->Insert;
 
     /* ThisTimeLineID doesn't change so we need no lock to copy it */
     ThisTimeLineID = XLogCtl->ThisTimeLineID;
     Assert(ThisTimeLineID != 0 || IsBootstrapProcessingMode());
 
     /* set wal_segment_size */
     wal_segment_size = ControlFile->xlog_seg_size;
 
     /* Use GetRedoRecPtr to copy the RedoRecPtr safely */
     (void) GetRedoRecPtr();
     /* Also update our copy of doPageWrites. */
     doPageWrites = (Insert->fullPageWrites || Insert->forcePageWrites);
 
     /* Also initialize the working areas for constructing WAL records */
     InitXLogInsert();
 }

◆ issue_xlog_fsync()

void issue_xlog_fsync	(	int	fd,
		XLogSegNo	segno
	)

Definition at line 10154 of file xlog.c.

References elog, ereport, errcode_for_file_access(), errmsg(), PANIC, pg_fdatasync(), pg_fsync_no_writethrough(), pg_fsync_writethrough(), sync_method, SYNC_METHOD_FDATASYNC, SYNC_METHOD_FSYNC, SYNC_METHOD_FSYNC_WRITETHROUGH, SYNC_METHOD_OPEN, SYNC_METHOD_OPEN_DSYNC, ThisTimeLineID, and XLogFileNameP().

Referenced by XLogWalRcvFlush(), and XLogWrite().

 {
     switch (sync_method)
     {
         case SYNC_METHOD_FSYNC:
             if (pg_fsync_no_writethrough(fd) != 0)
                 ereport(PANIC,
                         (errcode_for_file_access(),
                          errmsg("could not fsync log file %s: %m",
                                 XLogFileNameP(ThisTimeLineID, segno))));
             break;
 #ifdef HAVE_FSYNC_WRITETHROUGH
         case SYNC_METHOD_FSYNC_WRITETHROUGH:
             if (pg_fsync_writethrough(fd) != 0)
                 ereport(PANIC,
                         (errcode_for_file_access(),
                          errmsg("could not fsync write-through log file %s: %m",
                                 XLogFileNameP(ThisTimeLineID, segno))));
             break;
 #endif
 #ifdef HAVE_FDATASYNC
         case SYNC_METHOD_FDATASYNC:
             if (pg_fdatasync(fd) != 0)
                 ereport(PANIC,
                         (errcode_for_file_access(),
                          errmsg("could not fdatasync log file %s: %m",
                                 XLogFileNameP(ThisTimeLineID, segno))));
             break;
 #endif
         case SYNC_METHOD_OPEN:
         case SYNC_METHOD_OPEN_DSYNC:
             /* write synced it already */
             break;
         default:
             elog(PANIC, "unrecognized wal_sync_method: %d", sync_method);
             break;
     }
 }

◆ LocalProcessControlFile()

void LocalProcessControlFile ( bool reset )

Definition at line 4861 of file xlog.c.

References Assert, palloc(), and ReadControlFile().

Referenced by BackendRun(), PostgresMain(), PostmasterMain(), and PostmasterStateMachine().

 {
     Assert(reset || ControlFile == NULL);
     ControlFile = palloc(sizeof(ControlFileData));
     ReadControlFile();
 }

◆ RecoveryInProgress()

bool RecoveryInProgress ( void )

Definition at line 7949 of file xlog.c.

References InitXLOGAccess(), LocalRecoveryInProgress, pg_memory_barrier, XLogCtlData::SharedRecoveryInProgress, and XLogCtl.

Referenced by BackgroundWriterMain(), brin_desummarize_range(), brin_summarize_range(), check_transaction_read_only(), check_XactIsoLevel(), CheckArchiveTimeout(), CheckLogicalDecodingRequirements(), CheckpointerMain(), CreateCheckPoint(), CreateEndOfRecoveryRecord(), CreateRestartPoint(), do_pg_start_backup(), do_pg_stop_backup(), error_commit_ts_disabled(), get_relation_info(), GetNewMultiXactId(), GetNewObjectId(), GetNewTransactionId(), GetOldestActiveTransactionId(), GetOldestSafeDecodingTransactionId(), GetOldestXmin(), GetRunningTransactionData(), GetSerializableTransactionSnapshot(), GetSerializableTransactionSnapshotInt(), GetSnapshotData(), gin_clean_pending_list(), heap_page_prune_opt(), IdentifySystem(), InitPostgres(), InitTempTableNamespace(), IsCheckpointOnSchedule(), LockAcquireExtended(), MarkBufferDirtyHint(), OldSerXidSetActiveSerXmin(), perform_base_backup(), pg_create_restore_point(), pg_current_wal_flush_lsn(), pg_current_wal_insert_lsn(), pg_current_wal_lsn(), pg_is_in_recovery(), pg_is_wal_replay_paused(), pg_logical_slot_get_changes_guts(), pg_replication_slot_advance(), pg_switch_wal(), pg_wal_replay_pause(), pg_wal_replay_resume(), pg_walfile_name(), pg_walfile_name_offset(), PrepareRedoAdd(), PrepareRedoRemove(), PreventCommandDuringRecovery(), ProcSendSignal(), ProcSleep(), read_local_xlog_page(), ReplicationSlotReserveWal(), replorigin_check_prerequisites(), sendDir(), ShutdownXLOG(), SnapBuildWaitSnapshot(), standard_ProcessUtility(), StartLogicalReplication(), StartTransaction(), TransactionIdIsInProgress(), TruncateMultiXact(), UpdateFullPageWrites(), WalReceiverMain(), WalSndWaitForWal(), XLogBackgroundFlush(), XLogInsertAllowed(), XLogNeedsFlush(), and XLogSendPhysical().

 {
     /*
      * We check shared state each time only until we leave recovery mode. We
      * can't re-enter recovery, so there's no need to keep checking after the
      * shared variable has once been seen false.
      */
     if (!LocalRecoveryInProgress)
         return false;
     else
     {
         /*
          * use volatile pointer to make sure we make a fresh read of the
          * shared variable.
          */
         volatile XLogCtlData *xlogctl = XLogCtl;
 
         LocalRecoveryInProgress = xlogctl->SharedRecoveryInProgress;
 
         /*
          * Initialize TimeLineID and RedoRecPtr when we discover that recovery
          * is finished. InitPostgres() relies upon this behaviour to ensure
          * that InitXLOGAccess() is called at backend startup.  (If you change
          * this, see also LocalSetXLogInsertAllowed.)
          */
         if (!LocalRecoveryInProgress)
         {
             /*
              * If we just exited recovery, make sure we read TimeLineID and
              * RedoRecPtr after SharedRecoveryInProgress (for machines with
              * weak memory ordering).
              */
             pg_memory_barrier();
             InitXLOGAccess();
         }
 
         /*
          * Note: We don't need a memory barrier when we're still in recovery.
          * We might exit recovery immediately after return, so the caller
          * can't rely on 'true' meaning that we're still in recovery anyway.
          */
 
         return LocalRecoveryInProgress;
     }
 }

◆ RecoveryIsPaused()

bool RecoveryIsPaused ( void )

Definition at line 6028 of file xlog.c.

References XLogCtlData::info_lck, XLogCtlData::recoveryPause, SpinLockAcquire, and SpinLockRelease.

Referenced by pg_is_wal_replay_paused(), and recoveryPausesHere().

 {
     bool        recoveryPause;
 
     SpinLockAcquire(&XLogCtl->info_lck);
     recoveryPause = XLogCtl->recoveryPause;
     SpinLockRelease(&XLogCtl->info_lck);
 
     return recoveryPause;
 }

◆ RemovePromoteSignalFiles()

void RemovePromoteSignalFiles ( void )

Definition at line 12257 of file xlog.c.

References FALLBACK_PROMOTE_SIGNAL_FILE, and PROMOTE_SIGNAL_FILE.

Referenced by PostmasterMain().

 {
     unlink(PROMOTE_SIGNAL_FILE);
     unlink(FALLBACK_PROMOTE_SIGNAL_FILE);
 }

◆ SetRecoveryPause()

void SetRecoveryPause ( bool recoveryPause )

Definition at line 6040 of file xlog.c.

References XLogCtlData::info_lck, XLogCtlData::recoveryPause, SpinLockAcquire, and SpinLockRelease.

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

 {
     SpinLockAcquire(&XLogCtl->info_lck);
     XLogCtl->recoveryPause = recoveryPause;
     SpinLockRelease(&XLogCtl->info_lck);
 }

◆ SetWalWriterSleeping()

void SetWalWriterSleeping ( bool sleeping )

Definition at line 12293 of file xlog.c.

References XLogCtlData::info_lck, SpinLockAcquire, SpinLockRelease, and XLogCtlData::WalWriterSleeping.

Referenced by WalWriterMain().

 {
     SpinLockAcquire(&XLogCtl->info_lck);
     XLogCtl->WalWriterSleeping = sleeping;
     SpinLockRelease(&XLogCtl->info_lck);
 }

◆ ShutdownXLOG()

void ShutdownXLOG	(	int	code,
		Datum	arg
	)

Definition at line 8380 of file xlog.c.

References CHECKPOINT_IMMEDIATE, CHECKPOINT_IS_SHUTDOWN, CreateCheckPoint(), CreateRestartPoint(), ereport, errmsg(), IsPostmasterEnvironment, LOG, NOTICE, RecoveryInProgress(), RequestXLogSwitch(), ShutdownCLOG(), ShutdownCommitTs(), ShutdownMultiXact(), ShutdownSUBTRANS(), WalSndInitStopping(), WalSndWaitStopping(), XLogArchiveCommandSet, and XLogArchivingActive.

Referenced by CheckpointerMain(), and InitPostgres().

 {
     /* Don't be chatty in standalone mode */
     ereport(IsPostmasterEnvironment ? LOG : NOTICE,
             (errmsg("shutting down")));
 
     /*
      * Signal walsenders to move to stopping state.
      */
     WalSndInitStopping();
 
     /*
      * Wait for WAL senders to be in stopping state.  This prevents commands
      * from writing new WAL.
      */
     WalSndWaitStopping();
 
     if (RecoveryInProgress())
         CreateRestartPoint(CHECKPOINT_IS_SHUTDOWN | CHECKPOINT_IMMEDIATE);
     else
     {
         /*
          * If archiving is enabled, rotate the last XLOG file so that all the
          * remaining records are archived (postmaster wakes up the archiver
          * process one more time at the end of shutdown). The checkpoint
          * record will go to the next XLOG file and won't be archived (yet).
          */
         if (XLogArchivingActive() && XLogArchiveCommandSet())
             RequestXLogSwitch(false);
 
         CreateCheckPoint(CHECKPOINT_IS_SHUTDOWN | CHECKPOINT_IMMEDIATE);
     }
     ShutdownCLOG();
     ShutdownCommitTs();
     ShutdownSUBTRANS();
     ShutdownMultiXact();
 }

◆ StartupXLOG()

void StartupXLOG ( void )

Definition at line 6287 of file xlog.c.

References AdvanceOldestClogXid(), AllowCascadeReplication, appendStringInfo(), appendStringInfoString(), archiveCleanupCommand, XLogCtlData::archiveCleanupCommand, ArchiveRecoveryRequested, ErrorContextCallback::arg, Assert, BACKUP_LABEL_FILE, BACKUP_LABEL_OLD, ControlFileData::backupEndPoint, ControlFileData::backupEndRequired, ControlFileData::backupStartPoint, bgwriterLaunched, buf, ErrorContextCallback::callback, ControlFileData::checkPoint, CHECKPOINT_END_OF_RECOVERY, CHECKPOINT_FORCE, CHECKPOINT_IMMEDIATE, CHECKPOINT_WAIT, ControlFileData::checkPointCopy, CheckRecoveryConsistency(), CheckRequiredParameterValues(), checkTimeLineSwitch(), checkXLogConsistency(), XLogCtlData::ckptXid, XLogCtlData::ckptXidEpoch, close, CompleteCommitTsInitialization(), CreateCheckPoint(), CreateEndOfRecoveryRecord(), XLogCtlInsert::CurrBytePos, XLogCtlData::currentChunkStartTime, StringInfoData::data, DataDir, DB_IN_ARCHIVE_RECOVERY, DB_IN_CRASH_RECOVERY, DB_IN_PRODUCTION, DB_SHUTDOWNED, DB_SHUTDOWNED_IN_RECOVERY, DB_SHUTDOWNING, DEBUG1, DEBUG2, DEBUG3, DeleteAllExportedSnapshotFiles(), DisownLatch(), doPageWrites, doRequestWalReceiverReply, durable_rename(), elog, EnableHotStandby, EndRecPtr, ereport, errcode(), errcode_for_file_access(), errdetail(), errhint(), errmsg(), errmsg_internal(), ERROR, error_context_stack, ExecuteRecoveryCommand(), exitArchiveRecovery(), fast_promote, FATAL, findNewestTimeLine(), XLogwrtRqst::Flush, XLogwrtResult::Flush, CheckPoint::fullPageWrites, XLogCtlInsert::fullPageWrites, GetCurrentTimestamp(), GetLatestXTime(), HandleStartupProcInterrupts(), InArchiveRecovery, XLogCtlData::info_lck, XLogCtlData::InitializedUpTo, InitRecoveryTransactionEnvironment(), initStringInfo(), InRecovery, InRedo, Insert(), XLogCtlData::Insert, InvalidXLogRecPtr, IsPostmasterEnvironment, IsUnderPostmaster, lastFullPageWrites, LastRec, XLogCtlData::lastReplayedEndRecPtr, XLogCtlData::lastReplayedTLI, XLogCtlData::lastSegSwitchLSN, XLogCtlData::lastSegSwitchTime, RunningTransactionsData::latestCompletedXid, VariableCacheData::latestCompletedXid, lfirst, LocalSetXLogInsertAllowed(), LocalXLogInsertAllowed, LOG, XLogCtlData::LogwrtResult, LogwrtResult, XLogCtlData::LogwrtRqst, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), master_image_masked, MAXFNAMELEN, MAXPGPATH, MemSet, ControlFileData::minRecoveryPoint, minRecoveryPoint, ControlFileData::minRecoveryPointTLI, minRecoveryPointTLI, MultiXactSetNextMXact(), CheckPoint::newestCommitTsXid, CheckPoint::nextMulti, CheckPoint::nextMultiOffset, CheckPoint::nextOid, VariableCacheData::nextOid, CheckPoint::nextXid, RunningTransactionsData::nextXid, VariableCacheData::nextXid, CheckPoint::nextXidEpoch, NIL, NOTICE, tablespaceinfo::oid, VariableCacheData::oidCount, CheckPoint::oldestActiveXid, CheckPoint::oldestCommitTsXid, CheckPoint::oldestMulti, CheckPoint::oldestMultiDB, RunningTransactionsData::oldestRunningXid, CheckPoint::oldestXid, CheckPoint::oldestXidDB, OwnLatch(), XLogCtlData::pages, palloc(), PANIC, tablespaceinfo::path, pfree(), pg_usleep(), pgstat_reset_all(), PMSIGNAL_RECOVERY_STARTED, PreallocXlogFiles(), PrescanPreparedTransactions(), XLogCtlInsert::PrevBytePos, ErrorContextCallback::previous, CheckPoint::PrevTimeLineID, xl_end_of_recovery::PrevTimeLineID, XLogCtlData::PrevTimeLineID, proc_exit(), ProcArrayApplyRecoveryInfo(), ProcArrayInitRecovery(), psprintf(), PublishStartupProcessInformation(), reachedConsistency, read_backup_label(), read_tablespace_map(), XLogReaderState::readBuf, ReadCheckpointRecord(), readFile, readOff, XLogReaderState::readPageTLI, ReadRecord(), readRecoveryCommandFile(), ReadRecPtr, RecordKnownAssignedTransactionIds(), RecoverPreparedTransactions(), RECOVERY_TARGET_ACTION_PAUSE, RECOVERY_TARGET_ACTION_PROMOTE, RECOVERY_TARGET_ACTION_SHUTDOWN, RECOVERY_TARGET_IMMEDIATE, RECOVERY_TARGET_LSN, RECOVERY_TARGET_NAME, RECOVERY_TARGET_TIME, RECOVERY_TARGET_XID, recoveryApplyDelay(), recoveryEndCommand, XLogCtlData::recoveryLastXTime, XLogCtlData::recoveryPause, recoveryPausesHere(), recoveryStopAfter, recoveryStopLSN, recoveryStopName, recoveryStopsAfter(), recoveryStopsBefore(), recoveryStopTime, recoveryStopXid, recoveryTarget, recoveryTargetAction, recoveryTargetLSN, recoveryTargetName, recoveryTargetTime, recoveryTargetTLI, recoveryTargetXid, XLogCtlData::recoveryWakeupLatch, CheckPoint::redo, RedoRecPtr, XLogCtlInsert::RedoRecPtr, XLogCtlData::RedoRecPtr, RedoStartLSN, RelationCacheInitFileRemove(), remove_tablespace_symlink(), RemoveNonParentXlogFiles(), replay_image_masked, XLogCtlData::replayEndRecPtr, XLogCtlData::replayEndTLI, RequestCheckpoint(), ResetUnloggedRelations(), restoreTimeLineHistoryFiles(), restoreTwoPhaseData(), RmgrData::rm_cleanup, RM_MAX_ID, RmgrData::rm_redo, rm_redo_error_callback(), RmgrData::rm_startup, RmgrTable, SendPostmasterSignal(), SetCommitTsLimit(), SetForwardFsyncRequests(), SetMultiXactIdLimit(), SetRecoveryPause(), SetTransactionIdLimit(), XLogCtlData::SharedRecoveryInProgress, ShmemVariableCache, ShutdownRecoveryTransactionEnvironment(), ShutdownWalRcv(), snprintf(), SpinLockAcquire, SpinLockRelease, STANDBY_DISABLED, STANDBY_INITIALIZED, StandbyMode, StandbyModeRequested, StandbyRecoverPreparedTransactions(), standbyState, StartupCLOG(), StartupCommitTs(), StartupMultiXact(), StartupReorderBuffer(), StartupReplicationOrigin(), StartupReplicationSlots(), StartupSUBTRANS(), stat, ControlFileData::state, str_time(), strlcpy(), RunningTransactionsData::subxcnt, RunningTransactionsData::subxid_overflow, symlink, SyncDataDirectory(), ControlFileData::system_identifier, XLogReaderState::system_identifier, TABLESPACE_MAP, TABLESPACE_MAP_OLD, CheckPoint::ThisTimeLineID, ThisTimeLineID, xl_end_of_recovery::ThisTimeLineID, XLogCtlData::ThisTimeLineID, CheckPoint::time, ControlFileData::time, timestamptz_to_str(), tliOfPointInHistory(), tliSwitchPoint(), trace_recovery_messages, track_commit_timestamp, ControlFileData::track_commit_timestamp, TransactionIdAdvance, TransactionIdFollowsOrEquals(), TransactionIdIsNormal, TransactionIdIsValid, TransactionIdRetreat, TrimCLOG(), TrimMultiXact(), UNLOGGED_RELATION_CLEANUP, UNLOGGED_RELATION_INIT, ControlFileData::unloggedLSN, XLogCtlData::unloggedLSN, UpdateControlFile(), UpdateFullPageWrites(), ValidateXLOGDirectoryStructure(), wal_segment_size, WalRcvForceReply(), WalSndWakeup(), XLogwrtRqst::Write, XLogwrtResult::Write, writeTimeLineHistory(), RunningTransactionsData::xcnt, RunningTransactionsData::xids, XLogRecord::xl_info, XLogRecord::xl_rmid, XLogRecord::xl_xid, XLogCtlData::xlblocks, XLByteToPrevSeg, XLOG_CHECKPOINT_SHUTDOWN, XLOG_END_OF_RECOVERY, xlog_outdesc(), XLogArchiveCleanup(), XLogArchiveIsReadyOrDone(), XLogArchiveNotify(), XLogArchivingActive, XLogFileName, XLogFilePath, XLogPageRead(), XLogReaderAllocate(), XLogReaderFree(), XLogReceiptTime, XLogRecGetData, XLogRecPtrIsInvalid, XLogRecPtrToBufIdx, XLogRecPtrToBytePos(), XLogReportParameters(), XLogSegmentOffset, XLR_CHECK_CONSISTENCY, XLR_INFO_MASK, and XRecOffIsValid.

Referenced by InitPostgres(), and StartupProcessMain().

 {
     XLogCtlInsert *Insert;
     CheckPoint  checkPoint;
     bool        wasShutdown;
     bool        reachedStopPoint = false;
     bool        haveBackupLabel = false;
     bool        haveTblspcMap = false;
     XLogRecPtr  RecPtr,
                 checkPointLoc,
                 EndOfLog;
     TimeLineID  EndOfLogTLI;
     TimeLineID  PrevTimeLineID;
     XLogRecord *record;
     TransactionId oldestActiveXID;
     bool        backupEndRequired = false;
     bool        backupFromStandby = false;
     DBState     dbstate_at_startup;
     XLogReaderState *xlogreader;
     XLogPageReadPrivate private;
     bool        fast_promoted = false;
     struct stat st;
 
     /*
      * Verify XLOG status looks valid.
      */
     if (ControlFile->state < DB_SHUTDOWNED ||
         ControlFile->state > DB_IN_PRODUCTION ||
         !XRecOffIsValid(ControlFile->checkPoint))
         ereport(FATAL,
                 (errmsg("control file contains invalid data")));
 
     if (ControlFile->state == DB_SHUTDOWNED)
     {
         /* This is the expected case, so don't be chatty in standalone mode */
         ereport(IsPostmasterEnvironment ? LOG : NOTICE,
                 (errmsg("database system was shut down at %s",
                         str_time(ControlFile->time))));
     }
     else if (ControlFile->state == DB_SHUTDOWNED_IN_RECOVERY)
         ereport(LOG,
                 (errmsg("database system was shut down in recovery at %s",
                         str_time(ControlFile->time))));
     else if (ControlFile->state == DB_SHUTDOWNING)
         ereport(LOG,
                 (errmsg("database system shutdown was interrupted; last known up at %s",
                         str_time(ControlFile->time))));
     else if (ControlFile->state == DB_IN_CRASH_RECOVERY)
         ereport(LOG,
                 (errmsg("database system was interrupted while in recovery at %s",
                         str_time(ControlFile->time)),
                  errhint("This probably means that some data is corrupted and"
                          " you will have to use the last backup for recovery.")));
     else if (ControlFile->state == DB_IN_ARCHIVE_RECOVERY)
         ereport(LOG,
                 (errmsg("database system was interrupted while in recovery at log time %s",
                         str_time(ControlFile->checkPointCopy.time)),
                  errhint("If this has occurred more than once some data might be corrupted"
                          " and you might need to choose an earlier recovery target.")));
     else if (ControlFile->state == DB_IN_PRODUCTION)
         ereport(LOG,
                 (errmsg("database system was interrupted; last known up at %s",
                         str_time(ControlFile->time))));
 
     /* This is just to allow attaching to startup process with a debugger */
 #ifdef XLOG_REPLAY_DELAY
     if (ControlFile->state != DB_SHUTDOWNED)
         pg_usleep(60000000L);
 #endif
 
     /*
      * Verify that pg_wal and pg_wal/archive_status exist.  In cases where
      * someone has performed a copy for PITR, these directories may have been
      * excluded and need to be re-created.
      */
     ValidateXLOGDirectoryStructure();
 
     /*
      * If we previously crashed, there might be data which we had written,
      * intending to fsync it, but which we had not actually fsync'd yet.
      * Therefore, a power failure in the near future might cause earlier
      * unflushed writes to be lost, even though more recent data written to
      * disk from here on would be persisted.  To avoid that, fsync the entire
      * data directory.
      */
     if (ControlFile->state != DB_SHUTDOWNED &&
         ControlFile->state != DB_SHUTDOWNED_IN_RECOVERY)
         SyncDataDirectory();
 
     /*
      * Initialize on the assumption we want to recover to the latest timeline
      * that's active according to pg_control.
      */
     if (ControlFile->minRecoveryPointTLI >
         ControlFile->checkPointCopy.ThisTimeLineID)
         recoveryTargetTLI = ControlFile->minRecoveryPointTLI;
     else
         recoveryTargetTLI = ControlFile->checkPointCopy.ThisTimeLineID;
 
     /*
      * Check for recovery control file, and if so set up state for offline
      * recovery
      */
     readRecoveryCommandFile();
 
     /*
      * Save archive_cleanup_command in shared memory so that other processes
      * can see it.
      */
     strlcpy(XLogCtl->archiveCleanupCommand,
             archiveCleanupCommand ? archiveCleanupCommand : "",
             sizeof(XLogCtl->archiveCleanupCommand));
 
     if (ArchiveRecoveryRequested)
     {
         if (StandbyModeRequested)
             ereport(LOG,
                     (errmsg("entering standby mode")));
         else if (recoveryTarget == RECOVERY_TARGET_XID)
             ereport(LOG,
                     (errmsg("starting point-in-time recovery to XID %u",
                             recoveryTargetXid)));
         else if (recoveryTarget == RECOVERY_TARGET_TIME)
             ereport(LOG,
                     (errmsg("starting point-in-time recovery to %s",
                             timestamptz_to_str(recoveryTargetTime))));
         else if (recoveryTarget == RECOVERY_TARGET_NAME)
             ereport(LOG,
                     (errmsg("starting point-in-time recovery to \"%s\"",
                             recoveryTargetName)));
         else if (recoveryTarget == RECOVERY_TARGET_LSN)
             ereport(LOG,
                     (errmsg("starting point-in-time recovery to WAL location (LSN) \"%X/%X\"",
                             (uint32) (recoveryTargetLSN >> 32),
                             (uint32) recoveryTargetLSN)));
         else if (recoveryTarget == RECOVERY_TARGET_IMMEDIATE)
             ereport(LOG,
                     (errmsg("starting point-in-time recovery to earliest consistent point")));
         else
             ereport(LOG,
                     (errmsg("starting archive recovery")));
     }
 
     /*
      * Take ownership of the wakeup latch if we're going to sleep during
      * recovery.
      */
     if (StandbyModeRequested)
         OwnLatch(&XLogCtl->recoveryWakeupLatch);
 
     /* Set up XLOG reader facility */
     MemSet(&private, 0, sizeof(XLogPageReadPrivate));
     xlogreader = XLogReaderAllocate(wal_segment_size, &XLogPageRead, &private);
     if (!xlogreader)
         ereport(ERROR,
                 (errcode(ERRCODE_OUT_OF_MEMORY),
                  errmsg("out of memory"),
                  errdetail("Failed while allocating a WAL reading processor.")));
     xlogreader->system_identifier = ControlFile->system_identifier;
 
     /*
      * Allocate pages dedicated to WAL consistency checks, those had better be
      * aligned.
      */
     replay_image_masked = (char *) palloc(BLCKSZ);
     master_image_masked = (char *) palloc(BLCKSZ);
 
     if (read_backup_label(&checkPointLoc, &backupEndRequired,
                           &backupFromStandby))
     {
         List       *tablespaces = NIL;
 
         /*
          * Archive recovery was requested, and thanks to the backup label
          * file, we know how far we need to replay to reach consistency. Enter
          * archive recovery directly.
          */
         InArchiveRecovery = true;
         if (StandbyModeRequested)
             StandbyMode = true;
 
         /*
          * When a backup_label file is present, we want to roll forward from
          * the checkpoint it identifies, rather than using pg_control.
          */
         record = ReadCheckpointRecord(xlogreader, checkPointLoc, 0, true);
         if (record != NULL)
         {
             memcpy(&checkPoint, XLogRecGetData(xlogreader), sizeof(CheckPoint));
             wasShutdown = ((record->xl_info & ~XLR_INFO_MASK) == XLOG_CHECKPOINT_SHUTDOWN);
             ereport(DEBUG1,
                     (errmsg("checkpoint record is at %X/%X",
                             (uint32) (checkPointLoc >> 32), (uint32) checkPointLoc)));
             InRecovery = true;  /* force recovery even if SHUTDOWNED */
 
             /*
              * Make sure that REDO location exists. This may not be the case
              * if there was a crash during an online backup, which left a
              * backup_label around that references a WAL segment that's
              * already been archived.
              */
             if (checkPoint.redo < checkPointLoc)
             {
                 if (!ReadRecord(xlogreader, checkPoint.redo, LOG, false))
                     ereport(FATAL,
                             (errmsg("could not find redo location referenced by checkpoint record"),
                              errhint("If you are not restoring from a backup, try removing the file \"%s/backup_label\".", DataDir)));
             }
         }
         else
         {
             ereport(FATAL,
                     (errmsg("could not locate required checkpoint record"),
                      errhint("If you are not restoring from a backup, try removing the file \"%s/backup_label\".", DataDir)));
             wasShutdown = false;    /* keep compiler quiet */
         }
 
         /* read the tablespace_map file if present and create symlinks. */
         if (read_tablespace_map(&tablespaces))
         {
             ListCell   *lc;
 
             foreach(lc, tablespaces)
             {
                 tablespaceinfo *ti = lfirst(lc);
                 char       *linkloc;
 
                 linkloc = psprintf("pg_tblspc/%s", ti->oid);
 
                 /*
                  * Remove the existing symlink if any and Create the symlink
                  * under PGDATA.
                  */
                 remove_tablespace_symlink(linkloc);
 
                 if (symlink(ti->path, linkloc) < 0)
                     ereport(ERROR,
                             (errcode_for_file_access(),
                              errmsg("could not create symbolic link \"%s\": %m",
                                     linkloc)));
 
                 pfree(ti->oid);
                 pfree(ti->path);
                 pfree(ti);
             }
 
             /* set flag to delete it later */
             haveTblspcMap = true;
         }
 
         /* set flag to delete it later */
         haveBackupLabel = true;
     }
     else
     {
         /*
          * If tablespace_map file is present without backup_label file, there
          * is no use of such file.  There is no harm in retaining it, but it
          * is better to get rid of the map file so that we don't have any
          * redundant file in data directory and it will avoid any sort of
          * confusion.  It seems prudent though to just rename the file out of
          * the way rather than delete it completely, also we ignore any error
          * that occurs in rename operation as even if map file is present
          * without backup_label file, it is harmless.
          */
         if (stat(TABLESPACE_MAP, &st) == 0)
         {
             unlink(TABLESPACE_MAP_OLD);
             if (durable_rename(TABLESPACE_MAP, TABLESPACE_MAP_OLD, DEBUG1) == 0)
                 ereport(LOG,
                         (errmsg("ignoring file \"%s\" because no file \"%s\" exists",
                                 TABLESPACE_MAP, BACKUP_LABEL_FILE),
                          errdetail("File \"%s\" was renamed to \"%s\".",
                                    TABLESPACE_MAP, TABLESPACE_MAP_OLD)));
             else
                 ereport(LOG,
                         (errmsg("ignoring file \"%s\" because no file \"%s\" exists",
                                 TABLESPACE_MAP, BACKUP_LABEL_FILE),
                          errdetail("Could not rename file \"%s\" to \"%s\": %m.",
                                    TABLESPACE_MAP, TABLESPACE_MAP_OLD)));
         }
 
         /*
          * It's possible that archive recovery was requested, but we don't
          * know how far we need to replay the WAL before we reach consistency.
          * This can happen for example if a base backup is taken from a
          * running server using an atomic filesystem snapshot, without calling
          * pg_start/stop_backup. Or if you just kill a running master server
          * and put it into archive recovery by creating a recovery.conf file.
          *
          * Our strategy in that case is to perform crash recovery first,
          * replaying all the WAL present in pg_wal, and only enter archive
          * recovery after that.
          *
          * But usually we already know how far we need to replay the WAL (up
          * to minRecoveryPoint, up to backupEndPoint, or until we see an
          * end-of-backup record), and we can enter archive recovery directly.
          */
         if (ArchiveRecoveryRequested &&
             (ControlFile->minRecoveryPoint != InvalidXLogRecPtr ||
              ControlFile->backupEndRequired ||
              ControlFile->backupEndPoint != InvalidXLogRecPtr ||
              ControlFile->state == DB_SHUTDOWNED))
         {
             InArchiveRecovery = true;
             if (StandbyModeRequested)
                 StandbyMode = true;
         }
 
         /* Get the last valid checkpoint record. */
         checkPointLoc = ControlFile->checkPoint;
         RedoStartLSN = ControlFile->checkPointCopy.redo;
         record = ReadCheckpointRecord(xlogreader, checkPointLoc, 1, true);
         if (record != NULL)
         {
             ereport(DEBUG1,
                     (errmsg("checkpoint record is at %X/%X",
                             (uint32) (checkPointLoc >> 32), (uint32) checkPointLoc)));
         }
         else
         {
             /*
              * We used to attempt to go back to a secondary checkpoint record
              * here, but only when not in standby_mode. We now just fail if we
              * can't read the last checkpoint because this allows us to
              * simplify processing around checkpoints.
              */
             ereport(PANIC,
                     (errmsg("could not locate a valid checkpoint record")));
         }
         memcpy(&checkPoint, XLogRecGetData(xlogreader), sizeof(CheckPoint));
         wasShutdown = ((record->xl_info & ~XLR_INFO_MASK) == XLOG_CHECKPOINT_SHUTDOWN);
     }
 
     /*
      * Clear out any old relcache cache files.  This is *necessary* if we do
      * any WAL replay, since that would probably result in the cache files
      * being out of sync with database reality.  In theory we could leave them
      * in place if the database had been cleanly shut down, but it seems
      * safest to just remove them always and let them be rebuilt during the
      * first backend startup.  These files needs to be removed from all
      * directories including pg_tblspc, however the symlinks are created only
      * after reading tablespace_map file in case of archive recovery from
      * backup, so needs to clear old relcache files here after creating
      * symlinks.
      */
     RelationCacheInitFileRemove();
 
     /*
      * If the location of the checkpoint record is not on the expected
      * timeline in the history of the requested timeline, we cannot proceed:
      * the backup is not part of the history of the requested timeline.
      */
     Assert(expectedTLEs);       /* was initialized by reading checkpoint
                                  * record */
     if (tliOfPointInHistory(checkPointLoc, expectedTLEs) !=
         checkPoint.ThisTimeLineID)
     {
         XLogRecPtr  switchpoint;
 
         /*
          * tliSwitchPoint will throw an error if the checkpoint's timeline is
          * not in expectedTLEs at all.
          */
         switchpoint = tliSwitchPoint(ControlFile->checkPointCopy.ThisTimeLineID, expectedTLEs, NULL);
         ereport(FATAL,
                 (errmsg("requested timeline %u is not a child of this server's history",
                         recoveryTargetTLI),
                  errdetail("Latest checkpoint is at %X/%X on timeline %u, but in the history of the requested timeline, the server forked off from that timeline at %X/%X.",
                            (uint32) (ControlFile->checkPoint >> 32),
                            (uint32) ControlFile->checkPoint,
                            ControlFile->checkPointCopy.ThisTimeLineID,
                            (uint32) (switchpoint >> 32),
                            (uint32) switchpoint)));
     }
 
     /*
      * The min recovery point should be part of the requested timeline's
      * history, too.
      */
     if (!XLogRecPtrIsInvalid(ControlFile->minRecoveryPoint) &&
         tliOfPointInHistory(ControlFile->minRecoveryPoint - 1, expectedTLEs) !=
         ControlFile->minRecoveryPointTLI)
         ereport(FATAL,
                 (errmsg("requested timeline %u does not contain minimum recovery point %X/%X on timeline %u",
                         recoveryTargetTLI,
                         (uint32) (ControlFile->minRecoveryPoint >> 32),
                         (uint32) ControlFile->minRecoveryPoint,
                         ControlFile->minRecoveryPointTLI)));
 
     LastRec = RecPtr = checkPointLoc;
 
     ereport(DEBUG1,
             (errmsg_internal("redo record is at %X/%X; shutdown %s",
                              (uint32) (checkPoint.redo >> 32), (uint32) checkPoint.redo,
                              wasShutdown ? "true" : "false")));
     ereport(DEBUG1,
             (errmsg_internal("next transaction ID: %u:%u; next OID: %u",
                              checkPoint.nextXidEpoch, checkPoint.nextXid,
                              checkPoint.nextOid)));
     ereport(DEBUG1,
             (errmsg_internal("next MultiXactId: %u; next MultiXactOffset: %u",
                              checkPoint.nextMulti, checkPoint.nextMultiOffset)));
     ereport(DEBUG1,
             (errmsg_internal("oldest unfrozen transaction ID: %u, in database %u",
                              checkPoint.oldestXid, checkPoint.oldestXidDB)));
     ereport(DEBUG1,
             (errmsg_internal("oldest MultiXactId: %u, in database %u",
                              checkPoint.oldestMulti, checkPoint.oldestMultiDB)));
     ereport(DEBUG1,
             (errmsg_internal("commit timestamp Xid oldest/newest: %u/%u",
                              checkPoint.oldestCommitTsXid,
                              checkPoint.newestCommitTsXid)));
     if (!TransactionIdIsNormal(checkPoint.nextXid))
         ereport(PANIC,
                 (errmsg("invalid next transaction ID")));
 
     /* initialize shared memory variables from the checkpoint record */
     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(checkPoint.oldestCommitTsXid,
                      checkPoint.newestCommitTsXid);
     XLogCtl->ckptXidEpoch = checkPoint.nextXidEpoch;
     XLogCtl->ckptXid = checkPoint.nextXid;
 
     /*
      * Initialize replication slots, before there's a chance to remove
      * required resources.
      */
     StartupReplicationSlots();
 
     /*
      * Startup logical state, needs to be setup now so we have proper data
      * during crash recovery.
      */
     StartupReorderBuffer();
 
     /*
      * Startup MultiXact. We need to do this early to be able to replay
      * truncations.
      */
     StartupMultiXact();
 
     /*
      * Ditto commit timestamps.  In a standby, we do it if setting is enabled
      * in ControlFile; in a master we base the decision on the GUC itself.
      */
     if (ArchiveRecoveryRequested ?
         ControlFile->track_commit_timestamp : track_commit_timestamp)
         StartupCommitTs();
 
     /*
      * Recover knowledge about replay progress of known replication partners.
      */
     StartupReplicationOrigin();
 
     /*
      * Initialize unlogged LSN. On a clean shutdown, it's restored from the
      * control file. On recovery, all unlogged relations are blown away, so
      * the unlogged LSN counter can be reset too.
      */
     if (ControlFile->state == DB_SHUTDOWNED)
         XLogCtl->unloggedLSN = ControlFile->unloggedLSN;
     else
         XLogCtl->unloggedLSN = 1;
 
     /*
      * We must replay WAL entries using the same TimeLineID they were created
      * under, so temporarily adopt the TLI indicated by the checkpoint (see
      * also xlog_redo()).
      */
     ThisTimeLineID = checkPoint.ThisTimeLineID;
 
     /*
      * Copy any missing timeline history files between 'now' and the recovery
      * target timeline from archive to pg_wal. While we don't need those files
      * ourselves - the history file of the recovery target timeline covers all
      * the previous timelines in the history too - a cascading standby server
      * might be interested in them. Or, if you archive the WAL from this
      * server to a different archive than the master, it'd be good for all the
      * history files to get archived there after failover, so that you can use
      * one of the old timelines as a PITR target. Timeline history files are
      * small, so it's better to copy them unnecessarily than not copy them and
      * regret later.
      */
     restoreTimeLineHistoryFiles(ThisTimeLineID, recoveryTargetTLI);
 
     /*
      * Before running in recovery, scan pg_twophase and fill in its status to
      * be able to work on entries generated by redo.  Doing a scan before
      * taking any recovery action has the merit to discard any 2PC files that
      * are newer than the first record to replay, saving from any conflicts at
      * replay.  This avoids as well any subsequent scans when doing recovery
      * of the on-disk two-phase data.
      */
     restoreTwoPhaseData();
 
     lastFullPageWrites = checkPoint.fullPageWrites;
 
     RedoRecPtr = XLogCtl->RedoRecPtr = XLogCtl->Insert.RedoRecPtr = checkPoint.redo;
     doPageWrites = lastFullPageWrites;
 
     if (RecPtr < checkPoint.

Enumerations
enum	HotStandbyState { STANDBY_DISABLED, STANDBY_INITIALIZED, STANDBY_SNAPSHOT_PENDING, STANDBY_SNAPSHOT_READY }

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

enum	ArchiveMode { ARCHIVE_MODE_OFF = 0, ARCHIVE_MODE_ON, ARCHIVE_MODE_ALWAYS }

enum	WalLevel { WAL_LEVEL_MINIMAL = 0, WAL_LEVEL_REPLICA, WAL_LEVEL_LOGICAL }

enum	SessionBackupState { SESSION_BACKUP_NONE, SESSION_BACKUP_EXCLUSIVE, SESSION_BACKUP_NON_EXCLUSIVE }

Variables
int	sync_method

PGDLLIMPORT TimeLineID	ThisTimeLineID

bool	InRecovery

HotStandbyState	standbyState

XLogRecPtr	ProcLastRecPtr

XLogRecPtr	XactLastRecEnd

PGDLLIMPORT XLogRecPtr	XactLastCommitEnd

bool	reachedConsistency

int	wal_segment_size

int	min_wal_size_mb

int	max_wal_size_mb

int	wal_keep_segments

int	XLOGbuffers

int	XLogArchiveTimeout

int	wal_retrieve_retry_interval

char *	XLogArchiveCommand

bool	EnableHotStandby

bool	fullPageWrites

bool	wal_log_hints

bool	wal_compression

bool *	wal_consistency_checking

char *	wal_consistency_checking_string

bool	log_checkpoints

int	CheckPointSegments

int	XLogArchiveMode

PGDLLIMPORT int	wal_level

CheckpointStatsData	CheckpointStats

Data Structures

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ BACKUP_LABEL_FILE

◆ BACKUP_LABEL_OLD

◆ CHECKPOINT_CAUSE_TIME

◆ CHECKPOINT_CAUSE_XLOG

◆ CHECKPOINT_END_OF_RECOVERY

◆ CHECKPOINT_FLUSH_ALL

◆ CHECKPOINT_FORCE

◆ CHECKPOINT_IMMEDIATE

◆ CHECKPOINT_IS_SHUTDOWN

◆ CHECKPOINT_WAIT

◆ InHotStandby

◆ SYNC_METHOD_FDATASYNC

◆ SYNC_METHOD_FSYNC

◆ SYNC_METHOD_FSYNC_WRITETHROUGH

◆ SYNC_METHOD_OPEN

◆ SYNC_METHOD_OPEN_DSYNC

◆ TABLESPACE_MAP

◆ TABLESPACE_MAP_OLD

◆ XLOG_INCLUDE_ORIGIN

◆ XLOG_MARK_UNIMPORTANT

◆ XLogArchiveCommandSet

◆ XLogArchivingActive

◆ XLogArchivingAlways

◆ XLogHintBitIsNeeded

◆ XLogIsNeeded

◆ XLogLogicalInfoActive

◆ XLogStandbyInfoActive

Typedef Documentation

◆ ArchiveMode

◆ CheckpointStatsData

◆ SessionBackupState

◆ WalLevel

Enumeration Type Documentation

◆ ArchiveMode

◆ HotStandbyState

◆ RecoveryTargetType

◆ SessionBackupState

◆ WalLevel

Function Documentation

◆ assign_checkpoint_completion_target()

◆ assign_max_wal_size()

◆ BootStrapXLOG()

◆ CheckPromoteSignal()

◆ CheckXLogRemoved()

◆ CreateCheckPoint()

◆ CreateRestartPoint()

◆ DataChecksumsEnabled()

◆ do_pg_abort_backup()

◆ do_pg_start_backup()

◆ do_pg_stop_backup()

◆ get_backup_status()

◆ GetCurrentChunkReplayStartTime()

◆ GetFakeLSNForUnloggedRel()

◆ GetFlushRecPtr()

◆ GetFullPageWriteInfo()

◆ GetInsertRecPtr()

◆ GetLastImportantRecPtr()

◆ GetLatestXTime()

◆ GetMockAuthenticationNonce()

◆ GetNextXidAndEpoch()

◆ GetRedoRecPtr()

◆ GetSystemIdentifier()

◆ GetXLogInsertRecPtr()

◆ GetXLogReceiptTime()

◆ GetXLogReplayRecPtr()

◆ GetXLogWriteRecPtr()

◆ HotStandbyActive()

◆ HotStandbyActiveInReplay()

◆ InitXLOGAccess()

◆ issue_xlog_fsync()

◆ LocalProcessControlFile()

◆ RecoveryInProgress()

◆ RecoveryIsPaused()