xlog.h File Reference

#include "access/xlogbackup.h"
#include "access/xlogdefs.h"
#include "datatype/timestamp.h"
#include "lib/stringinfo.h"
#include "nodes/pg_list.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	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	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_REQUESTED   0x0040 /* Checkpoint request has been made */
#define	CHECKPOINT_CAUSE_XLOG   0x0080 /* XLOG consumption */
#define	CHECKPOINT_CAUSE_TIME   0x0100 /* Elapsed time */
#define	XLOG_INCLUDE_ORIGIN   0x01 /* include the replication origin */
#define	XLOG_MARK_UNIMPORTANT   0x02 /* record not important for durability */
#define	RECOVERY_SIGNAL_FILE   "recovery.signal"
#define	STANDBY_SIGNAL_FILE   "standby.signal"
#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"
#define	PROMOTE_SIGNAL_FILE   "promote"

Typedefs
typedef enum ArchiveMode	ArchiveMode
typedef enum WalLevel	WalLevel
typedef enum WalCompression	WalCompression
typedef enum RecoveryState	RecoveryState
typedef struct CheckpointStatsData	CheckpointStatsData
typedef enum WALAvailability	WALAvailability
typedef enum SessionBackupState	SessionBackupState

Enumerations
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	WalCompression { WAL_COMPRESSION_NONE = 0 , WAL_COMPRESSION_PGLZ , WAL_COMPRESSION_LZ4 , WAL_COMPRESSION_ZSTD }
enum	RecoveryState { RECOVERY_STATE_CRASH = 0 , RECOVERY_STATE_ARCHIVE , RECOVERY_STATE_DONE }
enum	WALAvailability {   WALAVAIL_INVALID_LSN , WALAVAIL_RESERVED , WALAVAIL_EXTENDED , WALAVAIL_UNRESERVED ,   WALAVAIL_REMOVED }
enum	SessionBackupState { SESSION_BACKUP_NONE , SESSION_BACKUP_RUNNING }

Functions
XLogRecPtr	XLogInsertRecord (struct XLogRecData *rdata, XLogRecPtr fpw_lsn, uint8 flags, int num_fpi, bool topxid_included)
void	XLogFlush (XLogRecPtr record)
bool	XLogBackgroundFlush (void)
bool	XLogNeedsFlush (XLogRecPtr record)
int	XLogFileInit (XLogSegNo logsegno, TimeLineID logtli)
int	XLogFileOpen (XLogSegNo segno, TimeLineID tli)
void	CheckXLogRemoved (XLogSegNo segno, TimeLineID tli)
XLogSegNo	XLogGetLastRemovedSegno (void)
void	XLogSetAsyncXactLSN (XLogRecPtr asyncXactLSN)
void	XLogSetReplicationSlotMinimumLSN (XLogRecPtr lsn)
void	xlog_redo (struct XLogReaderState *record)
void	xlog_desc (StringInfo buf, struct XLogReaderState *record)
const char *	xlog_identify (uint8 info)
void	issue_xlog_fsync (int fd, XLogSegNo segno, TimeLineID tli)
bool	RecoveryInProgress (void)
RecoveryState	GetRecoveryState (void)
bool	XLogInsertAllowed (void)
XLogRecPtr	GetXLogInsertRecPtr (void)
XLogRecPtr	GetXLogWriteRecPtr (void)
uint64	GetSystemIdentifier (void)
char *	GetMockAuthenticationNonce (void)
bool	DataChecksumsEnabled (void)
XLogRecPtr	GetFakeLSNForUnloggedRel (void)
Size	XLOGShmemSize (void)
void	XLOGShmemInit (void)
void	BootStrapXLOG (void)
void	InitializeWalConsistencyChecking (void)
void	LocalProcessControlFile (bool reset)
void	StartupXLOG (void)
void	ShutdownXLOG (int code, Datum arg)
void	CreateCheckPoint (int flags)
bool	CreateRestartPoint (int flags)
WALAvailability	GetWALAvailability (XLogRecPtr targetLSN)
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 (TimeLineID *insertTLI)
TimeLineID	GetWALInsertionTimeLine (void)
XLogRecPtr	GetLastImportantRecPtr (void)
void	SetWalWriterSleeping (bool sleeping)
void	RemoveNonParentXlogFiles (XLogRecPtr switchpoint, TimeLineID newTLI)
bool	XLogCheckpointNeeded (XLogSegNo new_segno)
void	SwitchIntoArchiveRecovery (XLogRecPtr EndRecPtr, TimeLineID replayTLI)
void	ReachedEndOfBackup (XLogRecPtr EndRecPtr, TimeLineID tli)
void	SetInstallXLogFileSegmentActive (void)
bool	IsInstallXLogFileSegmentActive (void)
void	XLogShutdownWalRcv (void)
void	do_pg_backup_start (const char *backupidstr, bool fast, List **tablespaces, BackupState *state, StringInfo tblspcmapfile)
void	do_pg_backup_stop (BackupState *state, bool waitforarchive)
void	do_pg_abort_backup (int code, Datum arg)
void	register_persistent_abort_backup_handler (void)
SessionBackupState	get_backup_status (void)

Variables
PGDLLIMPORT int	sync_method
PGDLLIMPORT XLogRecPtr	ProcLastRecPtr
PGDLLIMPORT XLogRecPtr	XactLastRecEnd
PGDLLIMPORT XLogRecPtr	XactLastCommitEnd
PGDLLIMPORT int	wal_segment_size
PGDLLIMPORT int	min_wal_size_mb
PGDLLIMPORT int	max_wal_size_mb
PGDLLIMPORT int	wal_keep_size_mb
PGDLLIMPORT int	max_slot_wal_keep_size_mb
PGDLLIMPORT int	XLOGbuffers
PGDLLIMPORT int	XLogArchiveTimeout
PGDLLIMPORT int	wal_retrieve_retry_interval
PGDLLIMPORT char *	XLogArchiveCommand
PGDLLIMPORT bool	EnableHotStandby
PGDLLIMPORT bool	fullPageWrites
PGDLLIMPORT bool	wal_log_hints
PGDLLIMPORT int	wal_compression
PGDLLIMPORT bool	wal_init_zero
PGDLLIMPORT bool	wal_recycle
PGDLLIMPORT bool *	wal_consistency_checking
PGDLLIMPORT char *	wal_consistency_checking_string
PGDLLIMPORT bool	log_checkpoints
PGDLLIMPORT bool	track_wal_io_timing
PGDLLIMPORT int	wal_decode_buffer_size
PGDLLIMPORT int	CheckPointSegments
PGDLLIMPORT int	XLogArchiveMode
PGDLLIMPORT int	wal_level
PGDLLIMPORT CheckpointStatsData	CheckpointStats

Macro Definition Documentation

BACKUP_LABEL_FILE

#define BACKUP_LABEL_FILE   "backup_label"

Definition at line 290 of file xlog.h.

BACKUP_LABEL_OLD

#define BACKUP_LABEL_OLD   "backup_label.old"

Definition at line 291 of file xlog.h.

CHECKPOINT_CAUSE_TIME

#define CHECKPOINT_CAUSE_TIME   0x0100 /* Elapsed time */

Definition at line 144 of file xlog.h.

CHECKPOINT_CAUSE_XLOG

#define CHECKPOINT_CAUSE_XLOG   0x0080 /* XLOG consumption */

Definition at line 143 of file xlog.h.

CHECKPOINT_END_OF_RECOVERY

#define CHECKPOINT_END_OF_RECOVERY

Value:

                                             0x0002 /* Like shutdown checkpoint, but
                                             * issued at end of WAL recovery */

Definition at line 135 of file xlog.h.

CHECKPOINT_FLUSH_ALL

#define CHECKPOINT_FLUSH_ALL

Value:

                                         0x0010 /* Flush all pages, including those
                                         * belonging to unlogged tables */

Definition at line 138 of file xlog.h.

CHECKPOINT_FORCE

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

Definition at line 137 of file xlog.h.

CHECKPOINT_IMMEDIATE

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

Definition at line 136 of file xlog.h.

CHECKPOINT_IS_SHUTDOWN

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

Definition at line 134 of file xlog.h.

CHECKPOINT_REQUESTED

#define CHECKPOINT_REQUESTED   0x0040 /* Checkpoint request has been made */

Definition at line 141 of file xlog.h.

CHECKPOINT_WAIT

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

Definition at line 140 of file xlog.h.

PROMOTE_SIGNAL_FILE

#define PROMOTE_SIGNAL_FILE   "promote"

Definition at line 297 of file xlog.h.

RECOVERY_SIGNAL_FILE

#define RECOVERY_SIGNAL_FILE   "recovery.signal"

Definition at line 288 of file xlog.h.

STANDBY_SIGNAL_FILE

#define STANDBY_SIGNAL_FILE   "standby.signal"

Definition at line 289 of file xlog.h.

SYNC_METHOD_FDATASYNC

#define SYNC_METHOD_FDATASYNC   1

Definition at line 23 of file xlog.h.

SYNC_METHOD_FSYNC

#define SYNC_METHOD_FSYNC   0

Definition at line 22 of file xlog.h.

SYNC_METHOD_FSYNC_WRITETHROUGH

#define SYNC_METHOD_FSYNC_WRITETHROUGH   3

Definition at line 25 of file xlog.h.

SYNC_METHOD_OPEN

#define SYNC_METHOD_OPEN   2 /* for O_SYNC */

Definition at line 24 of file xlog.h.

SYNC_METHOD_OPEN_DSYNC

#define SYNC_METHOD_OPEN_DSYNC   4 /* for O_DSYNC */

Definition at line 26 of file xlog.h.

TABLESPACE_MAP

#define TABLESPACE_MAP   "tablespace_map"

Definition at line 293 of file xlog.h.

TABLESPACE_MAP_OLD

#define TABLESPACE_MAP_OLD   "tablespace_map.old"

Definition at line 294 of file xlog.h.

XLOG_INCLUDE_ORIGIN

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

Definition at line 149 of file xlog.h.

XLOG_MARK_UNIMPORTANT

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

Definition at line 150 of file xlog.h.

XLogArchivingActive

#define XLogArchivingActive

(

)

(AssertMacro(XLogArchiveMode == ARCHIVE_MODE_OFF || wal_level >= WAL_LEVEL_REPLICA), XLogArchiveMode > ARCHIVE_MODE_OFF)

Definition at line 94 of file xlog.h.

XLogArchivingAlways

#define XLogArchivingAlways

(

)

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

Definition at line 97 of file xlog.h.

XLogHintBitIsNeeded

#define XLogHintBitIsNeeded

(

)

(DataChecksumsEnabled() || wal_log_hints)

Definition at line 115 of file xlog.h.

XLogIsNeeded

#define XLogIsNeeded

(

)

(wal_level >= WAL_LEVEL_REPLICA)

Definition at line 104 of file xlog.h.

XLogLogicalInfoActive

#define XLogLogicalInfoActive

(

)

(wal_level >= WAL_LEVEL_LOGICAL)

Definition at line 121 of file xlog.h.

XLogStandbyInfoActive

#define XLogStandbyInfoActive

(

)

(wal_level >= WAL_LEVEL_REPLICA)

Definition at line 118 of file xlog.h.

Typedef Documentation

ArchiveMode

typedef enum ArchiveMode ArchiveMode

CheckpointStatsData

typedef struct CheckpointStatsData CheckpointStatsData

RecoveryState

typedef enum RecoveryState RecoveryState

SessionBackupState

typedef enum SessionBackupState SessionBackupState

WALAvailability

typedef enum WALAvailability WALAvailability

WalCompression

typedef enum WalCompression WalCompression

WalLevel

typedef enum WalLevel WalLevel

Enumeration Type Documentation

ArchiveMode

enum ArchiveMode

Enumerator
ARCHIVE_MODE_OFF
ARCHIVE_MODE_ON
ARCHIVE_MODE_ALWAYS

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

RecoveryState

enum RecoveryState

Enumerator
RECOVERY_STATE_CRASH
RECOVERY_STATE_ARCHIVE
RECOVERY_STATE_DONE

Definition at line 84 of file xlog.h.

{
    RECOVERY_STATE_CRASH = 0,   /* crash recovery */
    RECOVERY_STATE_ARCHIVE,     /* archive recovery */
    RECOVERY_STATE_DONE         /* currently in production */
} RecoveryState;

SessionBackupState

enum SessionBackupState

Enumerator
SESSION_BACKUP_NONE
SESSION_BACKUP_RUNNING

Definition at line 273 of file xlog.h.

{
    SESSION_BACKUP_NONE,

WALAvailability

enum WALAvailability

Enumerator
WALAVAIL_INVALID_LSN
WALAVAIL_RESERVED
WALAVAIL_EXTENDED
WALAVAIL_UNRESERVED
WALAVAIL_REMOVED

Definition at line 181 of file xlog.h.

{
    WALAVAIL_INVALID_LSN,       /* parameter error */
    WALAVAIL_RESERVED,          /* WAL segment is within max_wal_size */
    WALAVAIL_EXTENDED,          /* WAL segment is reserved by a slot or
                                 * wal_keep_size */
    WALAVAIL_UNRESERVED,        /* no longer reserved, but not removed yet */

WalCompression

enum WalCompression

Enumerator
WAL_COMPRESSION_NONE
WAL_COMPRESSION_PGLZ
WAL_COMPRESSION_LZ4
WAL_COMPRESSION_ZSTD

Definition at line 75 of file xlog.h.

{
    WAL_COMPRESSION_NONE = 0,
    WAL_COMPRESSION_PGLZ,
    WAL_COMPRESSION_LZ4,
    WAL_COMPRESSION_ZSTD
} WalCompression;

WalLevel

enum WalLevel

Enumerator
WAL_LEVEL_MINIMAL
WAL_LEVEL_REPLICA
WAL_LEVEL_LOGICAL

Definition at line 67 of file xlog.h.

{
    WAL_LEVEL_MINIMAL = 0,
    WAL_LEVEL_REPLICA,
    WAL_LEVEL_LOGICAL
} WalLevel;

Function Documentation

BootStrapXLOG()

void BootStrapXLOG

(

void

)

Definition at line 4631 of file xlog.c.

{
    CheckPoint  checkPoint;
    char       *buffer;
    XLogPageHeader page;
    XLogLongPageHeader longpage;
    XLogRecord *record;
    char       *recptr;
    uint64      sysidentifier;
    struct timeval tv;
    pg_crc32c   crc;
 
    /* allow ordinary WAL segment creation, like StartupXLOG() would */
    SetInstallXLogFileSegmentActive();
 
    /*
     * 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;
 
    /* 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 = BootstrapTimeLineID;
    checkPoint.PrevTimeLineID = BootstrapTimeLineID;
    checkPoint.fullPageWrites = fullPageWrites;
    checkPoint.nextXid =
        FullTransactionIdFromEpochAndXid(0, FirstNormalTransactionId);
    checkPoint.nextOid = FirstGenbkiObjectId;
    checkPoint.nextMulti = FirstMultiXactId;
    checkPoint.nextMultiOffset = 0;
    checkPoint.oldestXid = FirstNormalTransactionId;
    checkPoint.oldestXidDB = Template1DbOid;
    checkPoint.oldestMulti = FirstMultiXactId;
    checkPoint.oldestMultiDB = Template1DbOid;
    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 = BootstrapTimeLineID;
    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 */
    openLogTLI = BootstrapTimeLineID;
    openLogFile = XLogFileInit(1, BootstrapTimeLineID);
 
    /*
     * We needn't bother with Reserve/ReleaseExternalFD here, since we'll
     * close the file again in a moment.
     */
 
    /* Write the first page with the initial record */
    errno = 0;
    pgstat_report_wait_start(WAIT_EVENT_WAL_BOOTSTRAP_WRITE);
    if (write(openLogFile, page, XLOG_BLCKSZ) != XLOG_BLCKSZ)
    {
        /* if write didn't set errno, assume problem is no disk space */
        if (errno == 0)
            errno = ENOSPC;
        ereport(PANIC,
                (errcode_for_file_access(),
                 errmsg("could not write bootstrap write-ahead log file: %m")));
    }
    pgstat_report_wait_end();
 
    pgstat_report_wait_start(WAIT_EVENT_WAL_BOOTSTRAP_SYNC);
    if (pg_fsync(openLogFile) != 0)
        ereport(PANIC,
                (errcode_for_file_access(),
                 errmsg("could not fsync bootstrap write-ahead log file: %m")));
    pgstat_report_wait_end();
 
    if (close(openLogFile) != 0)
        ereport(PANIC,
                (errcode_for_file_access(),
                 errmsg("could not close bootstrap write-ahead log file: %m")));
 
    openLogFile = -1;
 
    /* Now create pg_control */
    InitControlFile(sysidentifier);
    ControlFile->time = checkPoint.time;
    ControlFile->checkPoint = checkPoint.redo;
    ControlFile->checkPointCopy = checkPoint;
 
    /* some additional ControlFile fields are set in WriteControlFile() */
    WriteControlFile();
 
    /* Bootstrap the commit log, too */
    BootStrapCLOG();
    BootStrapCommitTs();
    BootStrapSUBTRANS();
    BootStrapMultiXact();
 
    pfree(buffer);
 
    /*
     * Force control file to be read - in contrast to normal processing we'd
     * otherwise never run the checks and GUC related initializations therein.
     */
    ReadControlFile();
}

References AdvanceOldestClogXid(), Assert(), BootStrapCLOG(), BootStrapCommitTs(), BootStrapMultiXact(), BootStrapSUBTRANS(), BootstrapTimeLineID, ControlFileData::checkPoint, ControlFileData::checkPointCopy, close, COMP_CRC32C, ControlFile, crc, ereport, errcode_for_file_access(), errmsg(), FIN_CRC32C, FirstGenbkiObjectId, FirstMultiXactId, FirstNormalTransactionId, fullPageWrites, CheckPoint::fullPageWrites, FullTransactionIdFromEpochAndXid(), gettimeofday(), INIT_CRC32C, InitControlFile(), InvalidTransactionId, MultiXactSetNextMXact(), CheckPoint::newestCommitTsXid, CheckPoint::nextMulti, CheckPoint::nextMultiOffset, VariableCacheData::nextOid, CheckPoint::nextOid, VariableCacheData::nextXid, CheckPoint::nextXid, VariableCacheData::oidCount, CheckPoint::oldestActiveXid, CheckPoint::oldestCommitTsXid, CheckPoint::oldestMulti, CheckPoint::oldestMultiDB, CheckPoint::oldestXid, CheckPoint::oldestXidDB, openLogFile, openLogTLI, palloc(), PANIC, pfree(), pg_fsync(), pgstat_report_wait_end(), pgstat_report_wait_start(), CheckPoint::PrevTimeLineID, ReadControlFile(), CheckPoint::redo, SetCommitTsLimit(), SetInstallXLogFileSegmentActive(), SetMultiXactIdLimit(), SetTransactionIdLimit(), ShmemVariableCache, SizeOfXLogLongPHD, SizeOfXLogRecord, SizeOfXLogRecordDataHeaderShort, CheckPoint::ThisTimeLineID, CheckPoint::time, ControlFileData::time, TYPEALIGN, WAIT_EVENT_WAL_BOOTSTRAP_SYNC, WAIT_EVENT_WAL_BOOTSTRAP_WRITE, wal_segment_size, write, WriteControlFile(), XLogRecord::xl_crc, 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 BootstrapModeMain().

CheckXLogRemoved()

void CheckXLogRemoved	(	XLogSegNo	segno,
		TimeLineID	tli
	)

Definition at line 3433 of file xlog.c.

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

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

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

CreateCheckPoint()

void CreateCheckPoint

(

int

flags

)

Definition at line 6436 of file xlog.c.

{
    bool        shutdown;
    CheckPoint  checkPoint;
    XLogRecPtr  recptr;
    XLogSegNo   _logSegNo;
    XLogCtlInsert *Insert = &XLogCtl->Insert;
    uint32      freespace;
    XLogRecPtr  PriorRedoPtr;
    XLogRecPtr  curInsert;
    XLogRecPtr  last_important_lsn;
    VirtualTransactionId *vxids;
    int         nvxids;
    int         oldXLogAllowed = 0;
 
    /*
     * 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");
 
    /*
     * 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();
 
    /*
     * Let smgr prepare for checkpoint; this has to happen outside the
     * critical section and before we determine the REDO pointer.  Note that
     * smgr must not do anything that'd have to be undone if we decide no
     * checkpoint is needed.
     */
    SyncPreCheckpoint();
 
    /*
     * 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;
        UpdateControlFile();
        LWLockRelease(ControlFileLock);
    }
 
    /* 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();
            END_CRIT_SECTION();
            ereport(DEBUG1,
                    (errmsg_internal("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.
     */
    if (flags & CHECKPOINT_END_OF_RECOVERY)
        oldXLogAllowed = LocalSetXLogInsertAllowed();
 
    checkPoint.ThisTimeLineID = XLogCtl->InsertTimeLineID;
    if (flags & CHECKPOINT_END_OF_RECOVERY)
        checkPoint.PrevTimeLineID = XLogCtl->PrevTimeLineID;
    else
        checkPoint.PrevTimeLineID = checkPoint.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);
 
    /* Update the process title */
    update_checkpoint_display(flags, false, false);
 
    TRACE_POSTGRESQL_CHECKPOINT_START(flags);
 
    /*
     * Get the other info we need for the checkpoint record.
     *
     * We don't need to save oldestClogXid in the checkpoint, it only matters
     * for the short period in which clog is being truncated, and if we crash
     * during that we'll redo the clog truncation and fix up oldestClogXid
     * there.
     */
    LWLockAcquire(XidGenLock, LW_SHARED);
    checkPoint.nextXid = ShmemVariableCache->nextXid;
    checkPoint.oldestXid = ShmemVariableCache->oldestXid;
    checkPoint.oldestXidDB = ShmemVariableCache->oldestXidDB;
    LWLockRelease(XidGenLock);
 
    LWLockAcquire(CommitTsLock, LW_SHARED);
    checkPoint.oldestCommitTsXid = ShmemVariableCache->oldestCommitTsXid;
    checkPoint.newestCommitTsXid = ShmemVariableCache->newestCommitTsXid;
    LWLockRelease(CommitTsLock);
 
    LWLockAcquire(OidGenLock, LW_SHARED);
    checkPoint.nextOid = ShmemVariableCache->nextOid;
    if (!shutdown)
        checkPoint.nextOid += ShmemVariableCache->oidCount;
    LWLockRelease(OidGenLock);
 
    MultiXactGetCheckptMulti(shutdown,
                             &checkPoint.nextMulti,
                             &checkPoint.nextMultiOffset,
                             &checkPoint.oldestMulti,
                             &checkPoint.oldestMultiDB);
 
    /*
     * Having constructed the checkpoint record, ensure all shmem disk buffers
     * and commit-log buffers are flushed to disk.
     *
     * This I/O could fail for various reasons.  If so, we will fail to
     * complete the checkpoint, but there is no reason to force a system
     * panic. Accordingly, exit critical section while doing it.
     */
    END_CRIT_SECTION();
 
    /*
     * In some cases there are groups of actions that must all occur on one
     * side or the other of a checkpoint record. Before flushing the
     * checkpoint record we must explicitly wait for any backend currently
     * performing those groups of actions.
     *
     * One example is end of transaction, so we must wait for any transactions
     * that are currently in commit critical sections.  If an xact inserted
     * its commit record into XLOG just before the REDO point, then a crash
     * restart from the REDO point would not replay that record, which means
     * that our flushing had better include the xact's update of pg_xact.  So
     * we wait till he's out of his commit critical section before proceeding.
     * See notes in RecordTransactionCommit().
     *
     * Because we've already released the insertion locks, this test is a bit
     * fuzzy: it is possible that we will wait for xacts we didn't really need
     * to wait for.  But the delay should be short and it seems better to make
     * checkpoint take a bit longer than to hold off insertions longer than
     * necessary. (In fact, the whole reason we have this issue is that xact.c
     * does commit record XLOG insertion and clog update as two separate steps
     * protected by different locks, but again that seems best on grounds of
     * minimizing lock contention.)
     *
     * A transaction that has not yet set delayChkptFlags when we look cannot
     * be at risk, since it has not inserted its commit record yet; and one
     * that's already cleared it is not at risk either, since it'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, DELAY_CHKPT_START);
    if (nvxids > 0)
    {
        do
        {
            pg_usleep(10000L);  /* wait for 10 msec */
        } while (HaveVirtualXIDsDelayingChkpt(vxids, nvxids,
                                              DELAY_CHKPT_START));
    }
    pfree(vxids);
 
    CheckPointGuts(checkPoint.redo, flags);
 
    vxids = GetVirtualXIDsDelayingChkpt(&nvxids, DELAY_CHKPT_COMPLETE);
    if (nvxids > 0)
    {
        do
        {
            pg_usleep(10000L);  /* wait for 10 msec */
        } while (HaveVirtualXIDsDelayingChkpt(vxids, nvxids,
                                              DELAY_CHKPT_COMPLETE));
    }
    pfree(vxids);
 
    /*
     * 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 = oldXLogAllowed;
        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;
    /* crash recovery should always recover to the end of WAL */
    ControlFile->minRecoveryPoint = InvalidXLogRecPtr;
    ControlFile->minRecoveryPointTLI = 0;
 
    /*
     * Persist unloggedLSN value. It's reset on crash recovery, so this goes
     * unused on non-shutdown checkpoints, but seems useful to store it always
     * for debugging purposes.
     */
    SpinLockAcquire(&XLogCtl->ulsn_lck);
    ControlFile->unloggedLSN = XLogCtl->unloggedLSN;
    SpinLockRelease(&XLogCtl->ulsn_lck);
 
    UpdateControlFile();
    LWLockRelease(ControlFileLock);
 
    /* Update shared-memory copy of checkpoint XID/epoch */
    SpinLockAcquire(&XLogCtl->info_lck);
    XLogCtl->ckptFullXid = checkPoint.nextXid;
    SpinLockRelease(&XLogCtl->info_lck);
 
    /*
     * We are now done with critical updates; no need for system panic if we
     * have trouble while fooling with old log segments.
     */
    END_CRIT_SECTION();
 
    /*
     * Let smgr do post-checkpoint cleanup (eg, deleting old files).
     */
    SyncPostCheckpoint();
 
    /*
     * Update the average distance between checkpoints if the prior checkpoint
     * exists.
     */
    if (PriorRedoPtr != InvalidXLogRecPtr)
        UpdateCheckPointDistanceEstimate(RedoRecPtr - PriorRedoPtr);
 
    /*
     * Delete old log files, those no longer needed for last checkpoint to
     * prevent the disk holding the xlog from growing full.
     */
    XLByteToSeg(RedoRecPtr, _logSegNo, wal_segment_size);
    KeepLogSeg(recptr, &_logSegNo);
    if (InvalidateObsoleteReplicationSlots(_logSegNo))
    {
        /*
         * Some slots have been invalidated; recalculate the old-segment
         * horizon, starting again from RedoRecPtr.
         */
        XLByteToSeg(RedoRecPtr, _logSegNo, wal_segment_size);
        KeepLogSeg(recptr, &_logSegNo);
    }
    _logSegNo--;
    RemoveOldXlogFiles(_logSegNo, RedoRecPtr, recptr,
                       checkPoint.ThisTimeLineID);
 
    /*
     * 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, checkPoint.ThisTimeLineID);
 
    /*
     * 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(GetOldestTransactionIdConsideredRunning());
 
    /* Real work is done; log and update stats. */
    LogCheckpointEnd(false);
 
    /* Reset the process title */
    update_checkpoint_display(flags, false, true);
 
    TRACE_POSTGRESQL_CHECKPOINT_DONE(CheckpointStats.ckpt_bufs_written,
                                     NBuffers,
                                     CheckpointStats.ckpt_segs_added,
                                     CheckpointStats.ckpt_segs_removed,
                                     CheckpointStats.ckpt_segs_recycled);
}

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

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

CreateRestartPoint()

bool CreateRestartPoint

(

int

flags

)

Definition at line 7077 of file xlog.c.

{
    XLogRecPtr  lastCheckPointRecPtr;
    XLogRecPtr  lastCheckPointEndPtr;
    CheckPoint  lastCheckPoint;
    XLogRecPtr  PriorRedoPtr;
    XLogRecPtr  receivePtr;
    XLogRecPtr  replayPtr;
    TimeLineID  replayTLI;
    XLogRecPtr  endptr;
    XLogSegNo   _logSegNo;
    TimestampTz xtime;
 
    /* Concurrent checkpoint/restartpoint cannot happen */
    Assert(!IsUnderPostmaster || MyBackendType == B_CHECKPOINTER);
 
    /* 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_internal("skipping restartpoint, recovery has already ended")));
        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_internal("skipping restartpoint, already performed at %X/%X",
                                 LSN_FORMAT_ARGS(lastCheckPoint.redo))));
 
        UpdateMinRecoveryPoint(InvalidXLogRecPtr, true);
        if (flags & CHECKPOINT_IS_SHUTDOWN)
        {
            LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
            ControlFile->state = DB_SHUTDOWNED_IN_RECOVERY;
            UpdateControlFile();
            LWLockRelease(ControlFileLock);
        }
        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);
 
    /* Update the process title */
    update_checkpoint_display(flags, true, false);
 
    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 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->checkPointCopy.redo < lastCheckPoint.redo)
    {
        /*
         * Update the checkpoint information.  We do this even if the cluster
         * does not show DB_IN_ARCHIVE_RECOVERY to match with the set of WAL
         * segments recycled below.
         */
        ControlFile->checkPoint = lastCheckPointRecPtr;
        ControlFile->checkPointCopy = lastCheckPoint;
 
        /*
         * Ensure minRecoveryPoint is past the checkpoint record and update it
         * if the control file still shows DB_IN_ARCHIVE_RECOVERY.  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 backup performed in recovery 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->state == DB_IN_ARCHIVE_RECOVERY)
        {
            if (ControlFile->minRecoveryPoint < lastCheckPointEndPtr)
            {
                ControlFile->minRecoveryPoint = lastCheckPointEndPtr;
                ControlFile->minRecoveryPointTLI = lastCheckPoint.ThisTimeLineID;
 
                /* update local copy */
                LocalMinRecoveryPoint = ControlFile->minRecoveryPoint;
                LocalMinRecoveryPointTLI = ControlFile->minRecoveryPointTLI;
            }
            if (flags & CHECKPOINT_IS_SHUTDOWN)
                ControlFile->state = DB_SHUTDOWNED_IN_RECOVERY;
        }
        UpdateControlFile();
    }
    LWLockRelease(ControlFileLock);
 
    /*
     * Update the average distance between checkpoints/restartpoints if the
     * prior checkpoint exists.
     */
    if (PriorRedoPtr != InvalidXLogRecPtr)
        UpdateCheckPointDistanceEstimate(RedoRecPtr - PriorRedoPtr);
 
    /*
     * Delete old log files, those no longer needed for last restartpoint to
     * prevent the disk holding the xlog from growing full.
     */
    XLByteToSeg(RedoRecPtr, _logSegNo, wal_segment_size);
 
    /*
     * Retreat _logSegNo using the current end of xlog replayed or received,
     * whichever is later.
     */
    receivePtr = GetWalRcvFlushRecPtr(NULL, NULL);
    replayPtr = GetXLogReplayRecPtr(&replayTLI);
    endptr = (receivePtr < replayPtr) ? replayPtr : receivePtr;
    KeepLogSeg(endptr, &_logSegNo);
    if (InvalidateObsoleteReplicationSlots(_logSegNo))
    {
        /*
         * Some slots have been invalidated; recalculate the old-segment
         * horizon, starting again from RedoRecPtr.
         */
        XLByteToSeg(RedoRecPtr, _logSegNo, wal_segment_size);
        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.  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())
        replayTLI = XLogCtl->InsertTimeLineID;
 
    RemoveOldXlogFiles(_logSegNo, RedoRecPtr, endptr, replayTLI);
 
    /*
     * Make more log segments if needed.  (Do this after recycling old log
     * segments, since that may supply some of the needed files.)
     */
    PreallocXlogFiles(endptr, replayTLI);
 
    /*
     * 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(GetOldestTransactionIdConsideredRunning());
 
    /* Real work is done; log and update stats. */
    LogCheckpointEnd(true);
 
    /* Reset the process title */
    update_checkpoint_display(flags, true, true);
 
    xtime = GetLatestXTime();
    ereport((log_checkpoints ? LOG : DEBUG2),
            (errmsg("recovery restart point at %X/%X",
                    LSN_FORMAT_ARGS(lastCheckPoint.redo)),
             xtime ? errdetail("Last completed transaction was at log time %s.",
                               timestamptz_to_str(xtime)) : 0));
 
    /*
     * Finally, execute archive_cleanup_command, if any.
     */
    if (archiveCleanupCommand && strcmp(archiveCleanupCommand, "") != 0)
    {
        char        lastRestartPointFname[MAXFNAMELEN];
 
        GetOldestRestartPointFileName(lastRestartPointFname);
        shell_archive_cleanup(lastRestartPointFname);
    }
 
    return true;
}

References archiveCleanupCommand, Assert(), B_CHECKPOINTER, ControlFileData::checkPoint, CHECKPOINT_IS_SHUTDOWN, ControlFileData::checkPointCopy, CheckPointGuts(), CheckpointStats, CheckpointStatsData::ckpt_start_t, ControlFile, DB_IN_ARCHIVE_RECOVERY, DB_SHUTDOWNED_IN_RECOVERY, DEBUG2, EnableHotStandby, ereport, errdetail(), errmsg(), errmsg_internal(), GetCurrentTimestamp(), GetLatestXTime(), GetOldestRestartPointFileName(), GetOldestTransactionIdConsideredRunning(), GetWalRcvFlushRecPtr(), GetXLogReplayRecPtr(), XLogCtlData::info_lck, XLogCtlData::Insert, XLogCtlData::InsertTimeLineID, InvalidateObsoleteReplicationSlots(), InvalidXLogRecPtr, IsUnderPostmaster, KeepLogSeg(), XLogCtlData::lastCheckPoint, XLogCtlData::lastCheckPointEndPtr, XLogCtlData::lastCheckPointRecPtr, LocalMinRecoveryPoint, LocalMinRecoveryPointTLI, LOG, log_checkpoints, LogCheckpointEnd(), LogCheckpointStart(), LSN_FORMAT_ARGS, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MAXFNAMELEN, MemSet, ControlFileData::minRecoveryPoint, ControlFileData::minRecoveryPointTLI, MyBackendType, PreallocXlogFiles(), RecoveryInProgress(), CheckPoint::redo, RedoRecPtr, XLogCtlInsert::RedoRecPtr, XLogCtlData::RedoRecPtr, RemoveOldXlogFiles(), shell_archive_cleanup(), SpinLockAcquire, SpinLockRelease, ControlFileData::state, CheckPoint::ThisTimeLineID, timestamptz_to_str(), TruncateSUBTRANS(), update_checkpoint_display(), UpdateCheckPointDistanceEstimate(), UpdateControlFile(), UpdateMinRecoveryPoint(), wal_segment_size, WALInsertLockAcquireExclusive(), WALInsertLockRelease(), XLByteToSeg, XLogCtl, and XLogRecPtrIsInvalid.

Referenced by CheckpointerMain(), and ShutdownXLOG().

DataChecksumsEnabled()

bool DataChecksumsEnabled

(

void

)

Definition at line 4195 of file xlog.c.

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

References Assert(), ControlFile, and ControlFileData::data_checksum_version.

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

do_pg_abort_backup()

void do_pg_abort_backup	(	int	code,
		Datum	arg
	)

Definition at line 8818 of file xlog.c.

{
    bool        during_backup_start = DatumGetBool(arg);
 
    /* If called during backup start, there shouldn't be one already running */
    Assert(!during_backup_start || sessionBackupState == SESSION_BACKUP_NONE);
 
    if (during_backup_start || sessionBackupState != SESSION_BACKUP_NONE)
    {
        WALInsertLockAcquireExclusive();
        Assert(XLogCtl->Insert.runningBackups > 0);
        XLogCtl->Insert.runningBackups--;
 
        sessionBackupState = SESSION_BACKUP_NONE;
        WALInsertLockRelease();
 
        if (!during_backup_start)
            ereport(WARNING,
                    errmsg("aborting backup due to backend exiting before pg_backup_stop was called"));
    }
}

References arg, Assert(), DatumGetBool(), ereport, errmsg(), XLogCtlData::Insert, XLogCtlInsert::runningBackups, SESSION_BACKUP_NONE, sessionBackupState, WALInsertLockAcquireExclusive(), WALInsertLockRelease(), WARNING, and XLogCtl.

Referenced by do_pg_backup_start(), perform_base_backup(), and register_persistent_abort_backup_handler().

do_pg_backup_start()

void do_pg_backup_start	(	const char *	backupidstr,
		bool	fast,
		List **	tablespaces,
		BackupState *	state,
		StringInfo	tblspcmapfile
	)

Definition at line 8245 of file xlog.c.

{
    bool        backup_started_in_recovery;
 
    Assert(state != NULL);
    backup_started_in_recovery = RecoveryInProgress();
 
    /*
     * 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)));
 
    memcpy(state->name, backupidstr, strlen(backupidstr));
 
    /*
     * 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
     * increment runningBackups 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 forcing full-page writes has no effect during an online
     * backup from the standby.
     *
     * We must hold all the insertion locks to change the value of
     * runningBackups, to ensure adequate interlocking against
     * XLogInsertRecord().
     */
    WALInsertLockAcquireExclusive();
    XLogCtl->Insert.runningBackups++;
    WALInsertLockRelease();
 
    /*
     * Ensure we decrement runningBackups if we fail below. NB -- for this to
     * work correctly, it is critical that sessionBackupState is only updated
     * after this block is over.
     */
    PG_ENSURE_ERROR_CLEANUP(do_pg_abort_backup, DatumGetBool(true));
    {
        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_backup_start() 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_backup_start()
             * 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);
            state->checkpointloc = ControlFile->checkPoint;
            state->startpoint = ControlFile->checkPointCopy.redo;
            state->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 || state->startpoint <= recptr)
                    ereport(ERROR,
                            (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                             errmsg("WAL generated with full_page_writes=off was replayed "
                                    "since last restartpoint"),
                             errhint("This means that the backup being taken on the standby "
                                     "is corrupt and should not be used. "
                                     "Enable full_page_writes and run CHECKPOINT on the primary, "
                                     "and then try an online backup again.")));
 
                /*
                 * During recovery, since we don't use the end-of-backup WAL
                 * record and don't write the backup history file, the
                 * starting WAL location doesn't need to be unique. This means
                 * that two base backups started at the same time might use
                 * the same checkpoint as starting locations.
                 */
                gotUniqueStartpoint = true;
            }
 
            /*
             * If two base backups are started at the same time (in WAL sender
             * processes), we need to make sure that they use different
             * checkpoints as starting locations, because we use the starting
             * WAL location as a unique identifier for the base backup in the
             * end-of-backup WAL record and when we write the backup history
             * file. Perhaps it would be better generate a separate unique ID
             * for each backup instead of forcing another checkpoint, but
             * taking a checkpoint right after another is not that expensive
             * either because only few buffers have been dirtied yet.
             */
            WALInsertLockAcquireExclusive();
            if (XLogCtl->Insert.lastBackupStart < state->startpoint)
            {
                XLogCtl->Insert.lastBackupStart = state->startpoint;
                gotUniqueStartpoint = true;
            }
            WALInsertLockRelease();
        } while (!gotUniqueStartpoint);
 
        /*
         * Construct tablespace_map file.
         */
        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 escapedpath;
            char       *s;
 
            /* Skip anything that doesn't look like a tablespace */
            if (strspn(de->d_name, "0123456789") != strlen(de->d_name))
                continue;
 
            snprintf(fullpath, sizeof(fullpath), "pg_tblspc/%s", de->d_name);
 
            /*
             * Skip anything that isn't a symlink/junction.  For testing only,
             * we sometimes use allow_in_place_tablespaces to create
             * directories directly under pg_tblspc, which would fail below.
             */
            if (get_dirent_type(fullpath, de, false, ERROR) != PGFILETYPE_LNK)
                continue;
 
            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';
 
            /*
             * Build a backslash-escaped version of the link path to include
             * in the tablespace map file.
             */
            initStringInfo(&escapedpath);
            for (s = linkpath; *s; s++)
            {
                if (*s == '\n' || *s == '\r' || *s == '\\')
                    appendStringInfoChar(&escapedpath, '\\');
                appendStringInfoChar(&escapedpath, *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(linkpath);
            ti->rpath = relpath ? pstrdup(relpath) : NULL;
            ti->size = -1;
 
            if (tablespaces)
                *tablespaces = lappend(*tablespaces, ti);
 
            appendStringInfo(tblspcmapfile, "%s %s\n",
                             ti->oid, escapedpath.data);
 
            pfree(escapedpath.data);
        }
        FreeDir(tblspcdir);
 
        state->starttime = (pg_time_t) time(NULL);
    }
    PG_END_ENSURE_ERROR_CLEANUP(do_pg_abort_backup, DatumGetBool(true));
 
    state->started_in_recovery = backup_started_in_recovery;
 
    /*
     * Mark that the start phase has correctly finished for the backup.
     */
    sessionBackupState = SESSION_BACKUP_RUNNING;
}

References AllocateDir(), appendStringInfo(), appendStringInfoChar(), Assert(), backup_started_in_recovery, ControlFileData::checkPoint, CHECKPOINT_FORCE, CHECKPOINT_IMMEDIATE, CHECKPOINT_WAIT, ControlFileData::checkPointCopy, ControlFile, dirent::d_name, StringInfoData::data, DataDir, DatumGetBool(), do_pg_abort_backup(), ereport, errcode(), errhint(), errmsg(), ERROR, FreeDir(), CheckPoint::fullPageWrites, get_dirent_type(), XLogCtlData::info_lck, initStringInfo(), XLogCtlData::Insert, IS_DIR_SEP, lappend(), XLogCtlInsert::lastBackupStart, XLogCtlData::lastFpwDisableRecPtr, LW_SHARED, LWLockAcquire(), LWLockRelease(), MAXPGPATH, tablespaceinfo::oid, palloc(), tablespaceinfo::path, pfree(), PG_END_ENSURE_ERROR_CLEANUP, PG_ENSURE_ERROR_CLEANUP, PGFILETYPE_LNK, pstrdup(), ReadDir(), readlink, RecoveryInProgress(), CheckPoint::redo, relpath, RequestCheckpoint(), RequestXLogSwitch(), tablespaceinfo::rpath, XLogCtlInsert::runningBackups, SESSION_BACKUP_RUNNING, sessionBackupState, tablespaceinfo::size, snprintf, SpinLockAcquire, SpinLockRelease, CheckPoint::ThisTimeLineID, WALInsertLockAcquireExclusive(), WALInsertLockRelease(), WARNING, XLogCtl, and XLogIsNeeded.

Referenced by perform_base_backup(), and pg_backup_start().

do_pg_backup_stop()

void do_pg_backup_stop	(	BackupState *	state,
		bool	waitforarchive
	)

Definition at line 8544 of file xlog.c.

{
    bool        backup_stopped_in_recovery = false;
    char        histfilepath[MAXPGPATH];
    char        lastxlogfilename[MAXFNAMELEN];
    char        histfilename[MAXFNAMELEN];
    XLogSegNo   _logSegNo;
    FILE       *fp;
    int         seconds_before_warning;
    int         waits = 0;
    bool        reported_waiting = false;
 
    Assert(state != NULL);
 
    backup_stopped_in_recovery = RecoveryInProgress();
 
    /*
     * 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_stopped_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.")));
 
    /*
     * OK to update backup counter and session-level lock.
     *
     * Note that CHECK_FOR_INTERRUPTS() must not occur while updating them,
     * otherwise they can be updated inconsistently, which might cause
     * do_pg_abort_backup() to fail.
     */
    WALInsertLockAcquireExclusive();
 
    /*
     * It is expected that each do_pg_backup_start() call is matched by
     * exactly one do_pg_backup_stop() call.
     */
    Assert(XLogCtl->Insert.runningBackups > 0);
    XLogCtl->Insert.runningBackups--;
 
    /*
     * 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();
 
    /*
     * If we are taking an online backup from the standby, we confirm that the
     * standby has not been promoted during the backup.
     */
    if (state->started_in_recovery && !backup_stopped_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_stopped_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 (state->startpoint <= recptr)
            ereport(ERROR,
                    (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                     errmsg("WAL generated with full_page_writes=off was replayed "
                            "during online backup"),
                     errhint("This means that the backup being taken on the standby "
                             "is corrupt and should not be used. "
                             "Enable full_page_writes and run CHECKPOINT on the primary, "
                             "and then try an online backup again.")));
 
 
        LWLockAcquire(ControlFileLock, LW_SHARED);
        state->stoppoint = ControlFile->minRecoveryPoint;
        state->stoptli = ControlFile->minRecoveryPointTLI;
        LWLockRelease(ControlFileLock);
    }
    else
    {
        char       *history_file;
 
        /*
         * Write the backup-end xlog record
         */
        XLogBeginInsert();
        XLogRegisterData((char *) (&state->startpoint),
                         sizeof(state->startpoint));
        state->stoppoint = XLogInsert(RM_XLOG_ID, XLOG_BACKUP_END);
 
        /*
         * Given that we're not in recovery, InsertTimeLineID is set and can't
         * change, so we can read it without a lock.
         */
        state->stoptli = XLogCtl->InsertTimeLineID;
 
        /*
         * 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);
 
        state->stoptime = (pg_time_t) time(NULL);
 
        /*
         * Write the backup history file
         */
        XLByteToSeg(state->startpoint, _logSegNo, wal_segment_size);
        BackupHistoryFilePath(histfilepath, state->stoptli, _logSegNo,
                              state->startpoint, wal_segment_size);
        fp = AllocateFile(histfilepath, "w");
        if (!fp)
            ereport(ERROR,
                    (errcode_for_file_access(),
                     errmsg("could not create file \"%s\": %m",
                            histfilepath)));
 
        /* Build and save the contents of the backup history file */
        history_file = build_backup_content(state, true);
        fprintf(fp, "%s", history_file);
        pfree(history_file);
 
        if (fflush(fp) || ferror(fp) || FreeFile(fp))
            ereport(ERROR,
                    (errcode_for_file_access(),
                     errmsg("could not write file \"%s\": %m",
                            histfilepath)));
 
        /*
         * Clean out any no-longer-needed history files.  As a side effect,
         * this will post a .ready file for the newly created history file,
         * notifying the archiver that history file may be archived
         * immediately.
         */
        CleanupBackupHistory();
    }
 
    /*
     * If archiving is enabled, wait for all the required WAL files to be
     * archived before returning. If archiving isn't enabled, the required WAL
     * needs to be transported via streaming replication (hopefully with
     * wal_keep_size set high enough), or some more exotic mechanism like
     * polling and copying files from pg_wal with script. We have no knowledge
     * of those mechanisms, so it's up to the user to ensure that he gets all
     * the required WAL.
     *
     * We wait until both the last WAL file filled during backup and the
     * history file have been archived, and assume that the alphabetic sorting
     * property of the WAL files ensures any earlier WAL files are safely
     * archived as well.
     *
     * We wait forever, since archive_command is supposed to work and we
     * assume the admin wanted his backup to work completely. If you don't
     * wish to wait, then either waitforarchive should be passed in as false,
     * or you can set statement_timeout.  Also, some notices are issued to
     * clue in anyone who might be doing this interactively.
     */
 
    if (waitforarchive &&
        ((!backup_stopped_in_recovery && XLogArchivingActive()) ||
         (backup_stopped_in_recovery && XLogArchivingAlways())))
    {
        XLByteToPrevSeg(state->stoppoint, _logSegNo, wal_segment_size);
        XLogFileName(lastxlogfilename, state->stoptli, _logSegNo,
                     wal_segment_size);
 
        XLByteToSeg(state->startpoint, _logSegNo, wal_segment_size);
        BackupHistoryFileName(histfilename, state->stoptli, _logSegNo,
                              state->startpoint, wal_segment_size);
 
        seconds_before_warning = 60;
        waits = 0;
 
        while (XLogArchiveIsBusy(lastxlogfilename) ||
               XLogArchiveIsBusy(histfilename))
        {
            CHECK_FOR_INTERRUPTS();
 
            if (!reported_waiting && waits > 5)
            {
                ereport(NOTICE,
                        (errmsg("base backup done, waiting for required WAL segments to be archived")));
                reported_waiting = true;
            }
 
            (void) WaitLatch(MyLatch,
                             WL_LATCH_SET | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH,
                             1000L,
                             WAIT_EVENT_BACKUP_WAIT_WAL_ARCHIVE);
            ResetLatch(MyLatch);
 
            if (++waits >= seconds_before_warning)
            {
                seconds_before_warning *= 2;    /* This wraps in >10 years... */
                ereport(WARNING,
                        (errmsg("still waiting for all required WAL segments to be archived (%d seconds elapsed)",
                                waits),
                         errhint("Check that your archive_command is executing properly.  "
                                 "You can safely cancel this backup, "
                                 "but the database backup will not be usable without all the WAL segments.")));
            }
        }
 
        ereport(NOTICE,
                (errmsg("all required WAL segments have been archived")));
    }
    else if (waitforarchive)
        ereport(NOTICE,
                (errmsg("WAL archiving is not enabled; you must ensure that all required WAL segments are copied through other means to complete the backup")));
}

References AllocateFile(), Assert(), BackupHistoryFileName(), BackupHistoryFilePath(), build_backup_content(), CHECK_FOR_INTERRUPTS, CleanupBackupHistory(), ControlFile, ereport, errcode(), errcode_for_file_access(), errhint(), errmsg(), ERROR, fflush(), fprintf, FreeFile(), XLogCtlData::info_lck, XLogCtlData::Insert, XLogCtlData::InsertTimeLineID, XLogCtlData::lastFpwDisableRecPtr, LW_SHARED, LWLockAcquire(), LWLockRelease(), MAXFNAMELEN, MAXPGPATH, ControlFileData::minRecoveryPoint, ControlFileData::minRecoveryPointTLI, MyLatch, NOTICE, pfree(), RecoveryInProgress(), RequestXLogSwitch(), ResetLatch(), XLogCtlInsert::runningBackups, SESSION_BACKUP_NONE, sessionBackupState, SpinLockAcquire, SpinLockRelease, WAIT_EVENT_BACKUP_WAIT_WAL_ARCHIVE, WaitLatch(), wal_segment_size, WALInsertLockAcquireExclusive(), WALInsertLockRelease(), WARNING, WL_EXIT_ON_PM_DEATH, WL_LATCH_SET, WL_TIMEOUT, XLByteToPrevSeg, XLByteToSeg, XLOG_BACKUP_END, XLogArchiveIsBusy(), XLogArchivingActive, XLogArchivingAlways, XLogBeginInsert(), XLogCtl, XLogFileName(), XLogInsert(), XLogIsNeeded, and XLogRegisterData().

Referenced by perform_base_backup(), and pg_backup_stop().

get_backup_status()

SessionBackupState get_backup_status

(

void

)

Definition at line 8525 of file xlog.c.

{
    return sessionBackupState;
}

References sessionBackupState.

Referenced by pg_backup_start(), pg_backup_stop(), and SendBaseBackup().

GetFakeLSNForUnloggedRel()

XLogRecPtr GetFakeLSNForUnloggedRel

(

void

)

Definition at line 4211 of file xlog.c.

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

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

Referenced by gistGetFakeLSN().

GetFlushRecPtr()

XLogRecPtr GetFlushRecPtr

(

TimeLineID *

insertTLI

)

Definition at line 6073 of file xlog.c.

{
    Assert(XLogCtl->SharedRecoveryState == RECOVERY_STATE_DONE);
 
    SpinLockAcquire(&XLogCtl->info_lck);
    LogwrtResult = XLogCtl->LogwrtResult;
    SpinLockRelease(&XLogCtl->info_lck);
 
    /*
     * If we're writing and flushing WAL, the time line can't be changing, so
     * no lock is required.
     */
    if (insertTLI)
        *insertTLI = XLogCtl->InsertTimeLineID;
 
    return LogwrtResult.Flush;
}

References Assert(), XLogwrtResult::Flush, XLogCtlData::info_lck, XLogCtlData::InsertTimeLineID, XLogCtlData::LogwrtResult, LogwrtResult, RECOVERY_STATE_DONE, XLogCtlData::SharedRecoveryState, SpinLockAcquire, SpinLockRelease, and XLogCtl.

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

GetFullPageWriteInfo()

void GetFullPageWriteInfo	(	XLogRecPtr *	RedoRecPtr_p,
		bool *	doPageWrites_p
	)

Definition at line 6041 of file xlog.c.

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

References doPageWrites, and RedoRecPtr.

Referenced by XLogCheckBufferNeedsBackup(), and XLogInsert().

GetInsertRecPtr()

XLogRecPtr GetInsertRecPtr

(

void

)

Definition at line 6056 of file xlog.c.

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

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

Referenced by CheckpointerMain(), gistvacuumscan(), and IsCheckpointOnSchedule().

GetLastImportantRecPtr()

XLogRecPtr GetLastImportantRecPtr

(

void

)

Definition at line 6113 of file xlog.c.

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

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

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

GetMockAuthenticationNonce()

char* GetMockAuthenticationNonce

(

void

)

Definition at line 4185 of file xlog.c.

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

References Assert(), ControlFile, and ControlFileData::mock_authentication_nonce.

Referenced by scram_mock_salt().

GetRecoveryState()

RecoveryState GetRecoveryState

(

void

)

Definition at line 5944 of file xlog.c.

{
    RecoveryState retval;
 
    SpinLockAcquire(&XLogCtl->info_lck);
    retval = XLogCtl->SharedRecoveryState;
    SpinLockRelease(&XLogCtl->info_lck);
 
    return retval;
}

References XLogCtlData::info_lck, XLogCtlData::SharedRecoveryState, SpinLockAcquire, SpinLockRelease, and XLogCtl.

Referenced by XLogArchiveCheckDone().

GetRedoRecPtr()

XLogRecPtr GetRedoRecPtr

(

void

)

Definition at line 6011 of file xlog.c.

{
    XLogRecPtr  ptr;
 
    /*
     * The possibly not up-to-date copy in XlogCtl is enough. Even if we
     * grabbed a WAL insertion lock to read the authoritative value in
     * Insert->RedoRecPtr, 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;
}

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

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

GetSystemIdentifier()

uint64 GetSystemIdentifier

(

void

)

Definition at line 4175 of file xlog.c.

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

References Assert(), ControlFile, and ControlFileData::system_identifier.

Referenced by IdentifySystem(), ReplicationSlotNameForTablesync(), and WalReceiverMain().

GetWALAvailability()

WALAvailability GetWALAvailability

(

XLogRecPtr

targetLSN

)

Definition at line 7349 of file xlog.c.

{
    XLogRecPtr  currpos;        /* current write LSN */
    XLogSegNo   currSeg;        /* segid of currpos */
    XLogSegNo   targetSeg;      /* segid of targetLSN */
    XLogSegNo   oldestSeg;      /* actual oldest segid */
    XLogSegNo   oldestSegMaxWalSize;    /* oldest segid kept by max_wal_size */
    XLogSegNo   oldestSlotSeg;  /* oldest segid kept by slot */
    uint64      keepSegs;
 
    /*
     * slot does not reserve WAL. Either deactivated, or has never been active
     */
    if (XLogRecPtrIsInvalid(targetLSN))
        return WALAVAIL_INVALID_LSN;
 
    /*
     * Calculate the oldest segment currently reserved by all slots,
     * considering wal_keep_size and max_slot_wal_keep_size.  Initialize
     * oldestSlotSeg to the current segment.
     */
    currpos = GetXLogWriteRecPtr();
    XLByteToSeg(currpos, oldestSlotSeg, wal_segment_size);
    KeepLogSeg(currpos, &oldestSlotSeg);
 
    /*
     * Find the oldest extant segment file. We get 1 until checkpoint removes
     * the first WAL segment file since startup, which causes the status being
     * wrong under certain abnormal conditions but that doesn't actually harm.
     */
    oldestSeg = XLogGetLastRemovedSegno() + 1;
 
    /* calculate oldest segment by max_wal_size */
    XLByteToSeg(currpos, currSeg, wal_segment_size);
    keepSegs = ConvertToXSegs(max_wal_size_mb, wal_segment_size) + 1;
 
    if (currSeg > keepSegs)
        oldestSegMaxWalSize = currSeg - keepSegs;
    else
        oldestSegMaxWalSize = 1;
 
    /* the segment we care about */
    XLByteToSeg(targetLSN, targetSeg, wal_segment_size);
 
    /*
     * No point in returning reserved or extended status values if the
     * targetSeg is known to be lost.
     */
    if (targetSeg >= oldestSlotSeg)
    {
        /* show "reserved" when targetSeg is within max_wal_size */
        if (targetSeg >= oldestSegMaxWalSize)
            return WALAVAIL_RESERVED;
 
        /* being retained by slots exceeding max_wal_size */
        return WALAVAIL_EXTENDED;
    }
 
    /* WAL segments are no longer retained but haven't been removed yet */
    if (targetSeg >= oldestSeg)
        return WALAVAIL_UNRESERVED;
 
    /* Definitely lost */
    return WALAVAIL_REMOVED;
}

References ConvertToXSegs, GetXLogWriteRecPtr(), KeepLogSeg(), max_wal_size_mb, wal_segment_size, WALAVAIL_EXTENDED, WALAVAIL_INVALID_LSN, WALAVAIL_REMOVED, WALAVAIL_RESERVED, WALAVAIL_UNRESERVED, XLByteToSeg, XLogGetLastRemovedSegno(), and XLogRecPtrIsInvalid.

Referenced by pg_get_replication_slots().

GetWALInsertionTimeLine()

TimeLineID GetWALInsertionTimeLine

(

void

)

Definition at line 6096 of file xlog.c.

{
    Assert(XLogCtl->SharedRecoveryState == RECOVERY_STATE_DONE);
 
    /* Since the value can't be changing, no lock is required. */
    return XLogCtl->InsertTimeLineID;
}

References Assert(), XLogCtlData::InsertTimeLineID, RECOVERY_STATE_DONE, XLogCtlData::SharedRecoveryState, and XLogCtl.

Referenced by logical_read_xlog_page(), pg_walfile_name(), pg_walfile_name_offset(), ReadReplicationSlot(), and XLogSendPhysical().

GetXLogInsertRecPtr()

XLogRecPtr GetXLogInsertRecPtr

(

void

)

Definition at line 8859 of file xlog.c.

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

References XLogCtlData::Insert, Insert(), SpinLockAcquire, SpinLockRelease, XLogBytePosToRecPtr(), and XLogCtl.

Referenced by CreateOverwriteContrecordRecord(), GetSnapshotDataInitOldSnapshot(), gistGetFakeLSN(), logical_begin_heap_rewrite(), pg_current_wal_insert_lsn(), and ReplicationSlotReserveWal().

GetXLogWriteRecPtr()

XLogRecPtr GetXLogWriteRecPtr

(

void

)

Definition at line 8875 of file xlog.c.

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

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

Referenced by GetWALAvailability(), pg_attribute_noreturn(), pg_current_wal_lsn(), and pg_get_replication_slots().

InitializeWalConsistencyChecking()

void InitializeWalConsistencyChecking

(

void

)

Definition at line 4398 of file xlog.c.

{
    Assert(process_shared_preload_libraries_done);
 
    if (check_wal_consistency_checking_deferred)
    {
        struct config_generic *guc;
 
        guc = find_option("wal_consistency_checking", false, false, ERROR);
 
        check_wal_consistency_checking_deferred = false;
 
        set_config_option_ext("wal_consistency_checking",
                              wal_consistency_checking_string,
                              guc->scontext, guc->source, guc->srole,
                              GUC_ACTION_SET, true, ERROR, false);
 
        /* checking should not be deferred again */
        Assert(!check_wal_consistency_checking_deferred);
    }
}

References Assert(), check_wal_consistency_checking_deferred, ERROR, find_option(), GUC_ACTION_SET, process_shared_preload_libraries_done, config_generic::scontext, set_config_option_ext(), config_generic::source, config_generic::srole, and wal_consistency_checking_string.

Referenced by PostgresSingleUserMain(), and PostmasterMain().

IsInstallXLogFileSegmentActive()

bool IsInstallXLogFileSegmentActive

(

void

)

Definition at line 8934 of file xlog.c.

{
    bool        result;
 
    LWLockAcquire(ControlFileLock, LW_SHARED);
    result = XLogCtl->InstallXLogFileSegmentActive;
    LWLockRelease(ControlFileLock);
 
    return result;
}

References XLogCtlData::InstallXLogFileSegmentActive, LW_SHARED, LWLockAcquire(), LWLockRelease(), and XLogCtl.

Referenced by XLogFileRead().

issue_xlog_fsync()

void issue_xlog_fsync	(	int	fd,
		XLogSegNo	segno,
		TimeLineID	tli
	)

Definition at line 8137 of file xlog.c.

{
    char       *msg = NULL;
    instr_time  start;
 
    Assert(tli != 0);
 
    /*
     * Quick exit if fsync is disabled or write() has already synced the WAL
     * file.
     */
    if (!enableFsync ||
        sync_method == SYNC_METHOD_OPEN ||
        sync_method == SYNC_METHOD_OPEN_DSYNC)
        return;
 
    /* Measure I/O timing to sync the WAL file */
    if (track_wal_io_timing)
        INSTR_TIME_SET_CURRENT(start);
    else
        INSTR_TIME_SET_ZERO(start);
 
    pgstat_report_wait_start(WAIT_EVENT_WAL_SYNC);
    switch (sync_method)
    {
        case SYNC_METHOD_FSYNC:
            if (pg_fsync_no_writethrough(fd) != 0)
                msg = _("could not fsync file \"%s\": %m");
            break;
#ifdef HAVE_FSYNC_WRITETHROUGH
        case SYNC_METHOD_FSYNC_WRITETHROUGH:
            if (pg_fsync_writethrough(fd) != 0)
                msg = _("could not fsync write-through file \"%s\": %m");
            break;
#endif
        case SYNC_METHOD_FDATASYNC:
            if (pg_fdatasync(fd) != 0)
                msg = _("could not fdatasync file \"%s\": %m");
            break;
        case SYNC_METHOD_OPEN:
        case SYNC_METHOD_OPEN_DSYNC:
            /* not reachable */
            Assert(false);
            break;
        default:
            elog(PANIC, "unrecognized wal_sync_method: %d", sync_method);
            break;
    }
 
    /* PANIC if failed to fsync */
    if (msg)
    {
        char        xlogfname[MAXFNAMELEN];
        int         save_errno = errno;
 
        XLogFileName(xlogfname, tli, segno, wal_segment_size);
        errno = save_errno;
        ereport(PANIC,
                (errcode_for_file_access(),
                 errmsg(msg, xlogfname)));
    }
 
    pgstat_report_wait_end();
 
    /*
     * Increment the I/O timing and the number of times WAL files were synced.
     */
    if (track_wal_io_timing)
    {
        instr_time  duration;
 
        INSTR_TIME_SET_CURRENT(duration);
        INSTR_TIME_SUBTRACT(duration, start);
        PendingWalStats.wal_sync_time += INSTR_TIME_GET_MICROSEC(duration);
    }
 
    PendingWalStats.wal_sync++;
}

References _, Assert(), duration, elog(), enableFsync, ereport, errcode_for_file_access(), errmsg(), fd(), INSTR_TIME_GET_MICROSEC, INSTR_TIME_SET_CURRENT, INSTR_TIME_SET_ZERO, INSTR_TIME_SUBTRACT, MAXFNAMELEN, PANIC, PendingWalStats, pg_fdatasync(), pg_fsync_no_writethrough(), pg_fsync_writethrough(), pgstat_report_wait_end(), pgstat_report_wait_start(), sync_method, SYNC_METHOD_FDATASYNC, SYNC_METHOD_FSYNC, SYNC_METHOD_FSYNC_WRITETHROUGH, SYNC_METHOD_OPEN, SYNC_METHOD_OPEN_DSYNC, track_wal_io_timing, WAIT_EVENT_WAL_SYNC, wal_segment_size, PgStat_WalStats::wal_sync, PgStat_WalStats::wal_sync_time, and XLogFileName().

Referenced by XLogWalRcvFlush(), and XLogWrite().

LocalProcessControlFile()

void LocalProcessControlFile

(

bool

reset

)

Definition at line 4461 of file xlog.c.

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

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

Referenced by PostgresSingleUserMain(), PostmasterMain(), and PostmasterStateMachine().

ReachedEndOfBackup()

void ReachedEndOfBackup	(	XLogRecPtr	EndRecPtr,
		TimeLineID	tli
	)

Definition at line 5821 of file xlog.c.

{
    /*
     * We have reached the end of base backup, as indicated by pg_control. The
     * data on disk is now consistent (unless minRecovery point is further
     * ahead, which can happen if we crashed during previous recovery).  Reset
     * backupStartPoint and backupEndPoint, and update minRecoveryPoint to
     * make sure we don't allow starting up at an earlier point even if
     * recovery is stopped and restarted soon after this.
     */
    LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
 
    if (ControlFile->minRecoveryPoint < EndRecPtr)
    {
        ControlFile->minRecoveryPoint = EndRecPtr;
        ControlFile->minRecoveryPointTLI = tli;
    }
 
    ControlFile->backupStartPoint = InvalidXLogRecPtr;
    ControlFile->backupEndPoint = InvalidXLogRecPtr;
    ControlFile->backupEndRequired = false;
    UpdateControlFile();
 
    LWLockRelease(ControlFileLock);
}

References ControlFileData::backupEndPoint, ControlFileData::backupEndRequired, ControlFileData::backupStartPoint, ControlFile, InvalidXLogRecPtr, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), ControlFileData::minRecoveryPoint, ControlFileData::minRecoveryPointTLI, and UpdateControlFile().

Referenced by CheckRecoveryConsistency().

RecoveryInProgress()

bool RecoveryInProgress

(

void

)

Definition at line 5908 of file xlog.c.

{
    /*
     * 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->SharedRecoveryState != RECOVERY_STATE_DONE);
 
        /*
         * 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;
    }
}

References LocalRecoveryInProgress, RECOVERY_STATE_DONE, XLogCtlData::SharedRecoveryState, and XLogCtl.

Referenced by BackgroundWriterMain(), BeginReportingGUCOptions(), brin_desummarize_range(), brin_summarize_range(), btree_index_mainfork_expected(), check_transaction_isolation(), check_transaction_read_only(), CheckArchiveTimeout(), CheckLogicalDecodingRequirements(), CheckpointerMain(), ComputeXidHorizons(), CreateCheckPoint(), CreateEndOfRecoveryRecord(), CreateOverwriteContrecordRecord(), CreateRestartPoint(), do_pg_backup_start(), do_pg_backup_stop(), error_commit_ts_disabled(), get_relation_info(), GetNewMultiXactId(), GetNewObjectId(), GetNewTransactionId(), GetOldestActiveTransactionId(), GetOldestSafeDecodingTransactionId(), GetRunningTransactionData(), GetSerializableTransactionSnapshot(), GetSerializableTransactionSnapshotInt(), GetSnapshotData(), gin_clean_pending_list(), GlobalVisHorizonKindForRel(), heap_force_common(), heap_page_prune_opt(), IdentifySystem(), InitTempTableNamespace(), IsCheckpointOnSchedule(), IsFutureLSN(), LockAcquireExtended(), MaintainLatestCompletedXid(), MarkBufferDirtyHint(), perform_base_backup(), pg_create_restore_point(), pg_current_wal_flush_lsn(), pg_current_wal_insert_lsn(), pg_current_wal_lsn(), pg_get_wal_replay_pause_state(), pg_is_in_recovery(), pg_is_wal_replay_paused(), pg_logical_slot_get_changes_guts(), pg_promote(), 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(), ProcSleep(), read_local_xlog_page_guts(), ReadReplicationSlot(), recovery_create_dbdir(), ReplicationSlotReserveWal(), replorigin_check_prerequisites(), ReportChangedGUCOptions(), sendDir(), SerialSetActiveSerXmin(), show_in_hot_standby(), ShutdownXLOG(), SnapBuildWaitSnapshot(), standard_ProcessUtility(), StartLogicalReplication(), StartReplication(), StartTransaction(), TransactionIdIsInProgress(), TruncateMultiXact(), UpdateFullPageWrites(), verify_heapam(), WalReceiverMain(), WalSndWaitForWal(), XLogBackgroundFlush(), XLogInsertAllowed(), XLogNeedsFlush(), and XLogSendPhysical().

register_persistent_abort_backup_handler()

void register_persistent_abort_backup_handler

(

void

)

Definition at line 8845 of file xlog.c.

{
    static bool already_done = false;
 
    if (already_done)
        return;
    before_shmem_exit(do_pg_abort_backup, DatumGetBool(false));
    already_done = true;
}

References before_shmem_exit(), DatumGetBool(), and do_pg_abort_backup().

Referenced by pg_backup_start().

RemoveNonParentXlogFiles()

void RemoveNonParentXlogFiles	(	XLogRecPtr	switchpoint,
		TimeLineID	newTLI
	)

Definition at line 3608 of file xlog.c.

{
    DIR        *xldir;
    struct dirent *xlde;
    char        switchseg[MAXFNAMELEN];
    XLogSegNo   endLogSegNo;
    XLogSegNo   switchLogSegNo;
    XLogSegNo   recycleSegNo;
 
    /*
     * Initialize info about where to begin the work.  This will recycle,
     * somewhat arbitrarily, 10 future segments.
     */
    XLByteToPrevSeg(switchpoint, switchLogSegNo, wal_segment_size);
    XLByteToSeg(switchpoint, endLogSegNo, wal_segment_size);
    recycleSegNo = endLogSegNo + 10;
 
    /*
     * Construct a filename of the last segment to be kept.
     */
    XLogFileName(switchseg, newTLI, switchLogSegNo, wal_segment_size);
 
    elog(DEBUG2, "attempting to remove WAL segments newer than log file %s",
         switchseg);
 
    xldir = AllocateDir(XLOGDIR);
 
    while ((xlde = ReadDir(xldir, XLOGDIR)) != NULL)
    {
        /* Ignore files that are not XLOG segments */
        if (!IsXLogFileName(xlde->d_name))
            continue;
 
        /*
         * Remove files that are on a timeline older than the new one we're
         * switching to, but with a segment number >= the first segment on the
         * new timeline.
         */
        if (strncmp(xlde->d_name, switchseg, 8) < 0 &&
            strcmp(xlde->d_name + 8, switchseg + 8) > 0)
        {
            /*
             * If the file has already been marked as .ready, however, don't
             * remove it yet. It should be OK to remove it - files that are
             * not part of our timeline history are not required for recovery
             * - but seems safer to let them be archived and removed later.
             */
            if (!XLogArchiveIsReady(xlde->d_name))
                RemoveXlogFile(xlde, recycleSegNo, &endLogSegNo, newTLI);
        }
    }
 
    FreeDir(xldir);
}

References AllocateDir(), dirent::d_name, DEBUG2, elog(), FreeDir(), IsXLogFileName(), MAXFNAMELEN, ReadDir(), RemoveXlogFile(), wal_segment_size, XLByteToPrevSeg, XLByteToSeg, XLogArchiveIsReady(), XLOGDIR, and XLogFileName().

Referenced by ApplyWalRecord(), and CleanupAfterArchiveRecovery().

SetInstallXLogFileSegmentActive()

void SetInstallXLogFileSegmentActive

(

void

)

Definition at line 8926 of file xlog.c.

{
    LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
    XLogCtl->InstallXLogFileSegmentActive = true;
    LWLockRelease(ControlFileLock);
}

References XLogCtlData::InstallXLogFileSegmentActive, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), and XLogCtl.

Referenced by BootStrapXLOG(), StartupXLOG(), and WaitForWALToBecomeAvailable().

SetWalWriterSleeping()

void SetWalWriterSleeping

(

bool

sleeping

)

Definition at line 8949 of file xlog.c.

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

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

Referenced by WalWriterMain().

ShutdownXLOG()

void ShutdownXLOG	(	int	code,
		Datum	arg
	)

Definition at line 6159 of file xlog.c.

{
    /*
     * We should have an aux process resource owner to use, and we should not
     * be in a transaction that's installed some other resowner.
     */
    Assert(AuxProcessResourceOwner != NULL);
    Assert(CurrentResourceOwner == NULL ||
           CurrentResourceOwner == AuxProcessResourceOwner);
    CurrentResourceOwner = AuxProcessResourceOwner;
 
    /* 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())
            RequestXLogSwitch(false);
 
        CreateCheckPoint(CHECKPOINT_IS_SHUTDOWN | CHECKPOINT_IMMEDIATE);
    }
}

References Assert(), AuxProcessResourceOwner, CHECKPOINT_IMMEDIATE, CHECKPOINT_IS_SHUTDOWN, CreateCheckPoint(), CreateRestartPoint(), CurrentResourceOwner, ereport, errmsg(), IsPostmasterEnvironment, LOG, NOTICE, RecoveryInProgress(), RequestXLogSwitch(), WalSndInitStopping(), WalSndWaitStopping(), and XLogArchivingActive.

Referenced by HandleCheckpointerInterrupts(), and InitPostgres().

StartupXLOG()

void StartupXLOG

(

void

)

Definition at line 5020 of file xlog.c.

{
    XLogCtlInsert *Insert;
    CheckPoint  checkPoint;
    bool        wasShutdown;
    bool        didCrash;
    bool        haveTblspcMap;
    bool        haveBackupLabel;
    XLogRecPtr  EndOfLog;
    TimeLineID  EndOfLogTLI;
    TimeLineID  newTLI;
    bool        performedWalRecovery;
    EndOfWalRecoveryInfo *endOfRecoveryInfo;
    XLogRecPtr  abortedRecPtr;
    XLogRecPtr  missingContrecPtr;
    TransactionId oldestActiveXID;
    bool        promoted = false;
 
    /*
     * We should have an aux process resource owner to use, and we should not
     * be in a transaction that's installed some other resowner.
     */
    Assert(AuxProcessResourceOwner != NULL);
    Assert(CurrentResourceOwner == NULL ||
           CurrentResourceOwner == AuxProcessResourceOwner);
    CurrentResourceOwner = AuxProcessResourceOwner;
 
    /*
     * Check that contents look valid.
     */
    if (!XRecOffIsValid(ControlFile->checkPoint))
        ereport(FATAL,
                (errmsg("control file contains invalid checkpoint location")));
 
    switch (ControlFile->state)
    {
        case 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))));
            break;
 
        case DB_SHUTDOWNED_IN_RECOVERY:
            ereport(LOG,
                    (errmsg("database system was shut down in recovery at %s",
                            str_time(ControlFile->time))));
            break;
 
        case DB_SHUTDOWNING:
            ereport(LOG,
                    (errmsg("database system shutdown was interrupted; last known up at %s",
                            str_time(ControlFile->time))));
            break;
 
        case 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.")));
            break;
 
        case 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.")));
            break;
 
        case DB_IN_PRODUCTION:
            ereport(LOG,
                    (errmsg("database system was interrupted; last known up at %s",
                            str_time(ControlFile->time))));
            break;
 
        default:
            ereport(FATAL,
                    (errmsg("control file contains invalid database cluster state")));
    }
 
    /* 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();
 
    /* Set up timeout handler needed to report startup progress. */
    if (!IsBootstrapProcessingMode())
        RegisterTimeout(STARTUP_PROGRESS_TIMEOUT,
                        startup_progress_timeout_handler);
 
    /*----------
     * If we previously crashed, perform a couple of actions:
     *
     * - The pg_wal directory may still include some temporary WAL segments
     *   used when creating a new segment, so perform some clean up to not
     *   bloat this path.  This is done first as there is no point to sync
     *   this temporary data.
     *
     * - 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)
    {
        RemoveTempXlogFiles();
        SyncDataDirectory();
        didCrash = true;
    }
    else
        didCrash = false;
 
    /*
     * Prepare for WAL recovery if needed.
     *
     * InitWalRecovery analyzes the control file and the backup label file, if
     * any.  It updates the in-memory ControlFile buffer according to the
     * starting checkpoint, and sets InRecovery and ArchiveRecoveryRequested.
     * It also applies the tablespace map file, if any.
     */
    InitWalRecovery(ControlFile, &wasShutdown,
                    &haveBackupLabel, &haveTblspcMap);
    checkPoint = ControlFile->checkPointCopy;
 
    /* 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->ckptFullXid = checkPoint.nextXid;
 
    /*
     * 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();
 
    /*
     * 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 CLOG. This must be done after ShmemVariableCache->nextXid has
     * been initialized and before we accept connections or begin WAL replay.
     */
    StartupCLOG();
 
    /*
     * Startup MultiXact. We need to do this early to be able to replay
     * truncations.
     */
    StartupMultiXact();
 
    /*
     * Ditto for commit timestamps.  Activate the facility if the setting is
     * enabled in the control file, as there should be no tracking of commit
     * timestamps done when the setting was disabled.  This facility can be
     * started or stopped when replaying a XLOG_PARAMETER_CHANGE record.
     */
    if (ControlFile->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 = FirstNormalUnloggedLSN;
 
    /*
     * 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 primary, 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(checkPoint.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();
 
    /*
     * When starting with crash recovery, reset pgstat data - it might not be
     * valid. Otherwise restore pgstat data. It's safe to do this here,
     * because postmaster will not yet have started any other processes.
     *
     * NB: Restoring replication slot stats relies on slot state to have
     * already been restored from disk.
     *
     * TODO: With a bit of extra work we could just start with a pgstat file
     * associated with the checkpoint redo location we're starting from.
     */
    if (didCrash)
        pgstat_discard_stats();
    else
        pgstat_restore_stats();
 
    lastFullPageWrites = checkPoint.fullPageWrites;
 
    RedoRecPtr = XLogCtl->RedoRecPtr = XLogCtl->Insert.RedoRecPtr = checkPoint.redo;
    doPageWrites = lastFullPageWrites;
 
    /* REDO */
    if (InRecovery)
    {
        /* Initialize state for RecoveryInProgress() */
        SpinLockAcquire(&XLogCtl->info_lck);
        if (InArchiveRecovery)
            XLogCtl->SharedRecoveryState = RECOVERY_STATE_ARCHIVE;
        else
            XLogCtl->SharedRecoveryState = RECOVERY_STATE_CRASH;
        SpinLockRelease(&XLogCtl->info_lck);
 
        /*
         * Update pg_control to show that we are recovering and to show the
         * selected checkpoint as the place we are starting from. We also mark
         * pg_control with any minimum recovery stop point obtained from a
         * backup history file.
         *
         * No need to hold ControlFileLock yet, we aren't up far enough.
         */
        UpdateControlFile();
 
        /*
         * If there was a backup label file, it's done its job and the info
         * has now been propagated into pg_control.  We must get rid of the
         * label file so that if we crash during recovery, we'll pick up at
         * the latest recovery restartpoint instead of going all the way back
         * to the backup start point.  It seems prudent though to just rename
         * the file out of the way rather than delete it completely.
         */
        if (haveBackupLabel)
        {
            unlink(BACKUP_LABEL_OLD);
            durable_rename(BACKUP_LABEL_FILE, BACKUP_LABEL_OLD, FATAL);
        }
 
        /*
         * If there was a tablespace_map file, it's done its job and the
         * symlinks have been created.  We must get rid of the map file so
         * that if we crash during recovery, we don't create symlinks again.
         * It seems prudent though to just rename the file out of the way
         * rather than delete it completely.
         */
        if (haveTblspcMap)
        {
            unlink(TABLESPACE_MAP_OLD);
            durable_rename(TABLESPACE_MAP, TABLESPACE_MAP_OLD, FATAL);
        }
 
        /*
         * Initialize our local copy of minRecoveryPoint.  When doing crash
         * recovery we want to replay up to the end of WAL.  Particularly, in
         * the case of a promoted standby minRecoveryPoint value in the
         * control file is only updated after the first checkpoint.  However,
         * if the instance crashes before the first post-recovery checkpoint
         * is completed then recovery will use a stale location causing the
         * startup process to think that there are still invalid page
         * references when checking for data consistency.
         */
        if (InArchiveRecovery)
        {
            LocalMinRecoveryPoint = ControlFile->minRecoveryPoint;
            LocalMinRecoveryPointTLI = ControlFile->minRecoveryPointTLI;
        }
        else
        {
            LocalMinRecoveryPoint = InvalidXLogRecPtr;
            LocalMinRecoveryPointTLI = 0;
        }
 
        /* Check that the GUCs used to generate the WAL allow recovery */
        CheckRequiredParameterValues();
 
        /*
         * We're in recovery, so unlogged relations may be trashed and must be
         * reset.  This should be done BEFORE allowing Hot Standby
         * connections, so that read-only backends don't try to read whatever
         * garbage is left over from before.
         */
        ResetUnloggedRelations(UNLOGGED_RELATION_CLEANUP);
 
        /*
         * Likewise, delete any saved transaction snapshot files that got left
         * behind by crashed backends.
         */
        DeleteAllExportedSnapshotFiles();
 
        /*
         * Initialize for Hot Standby, if enabled. We won't let backends in
         * yet, not until we've reached the min recovery point specified in
         * control file and we've established a recovery snapshot from a
         * running-xacts WAL record.
         */
        if (ArchiveRecoveryRequested && EnableHotStandby)
        {
            TransactionId *xids;
            int         nxids;
 
            ereport(DEBUG1,
                    (errmsg_internal("initializing for hot standby")));
 
            InitRecoveryTransactionEnvironment();
 
            if (wasShutdown)
                oldestActiveXID = PrescanPreparedTransactions(&xids, &nxids);
            else
                oldestActiveXID = checkPoint.oldestActiveXid;
            Assert(TransactionIdIsValid(oldestActiveXID));
 
            /* Tell procarray about the range of xids it has to deal with */
            ProcArrayInitRecovery(XidFromFullTransactionId(ShmemVariableCache->nextXid));
 
            /*
             * Startup subtrans only.  CLOG, MultiXact and commit timestamp
             * have already been started up and other SLRUs are not maintained
             * during recovery and need not be started yet.
             */
            StartupSUBTRANS(oldestActiveXID);
 
            /*
             * If we're beginning at a shutdown checkpoint, we know that
             * nothing was running on the primary at this point. So fake-up an
             * empty running-xacts record and use that here and now. Recover
             * additional standby state for prepared transactions.
             */
            if (wasShutdown)
            {
                RunningTransactionsData running;
                TransactionId latestCompletedXid;
 
                /*
                 * Construct a RunningTransactions snapshot representing a
                 * shut down server, with only prepared transactions still
                 * alive. We're never overflowed at this point because all
                 * subxids are listed with their parent prepared transactions.
                 */
                running.xcnt = nxids;
                running.subxcnt = 0;
                running.subxid_overflow = false;
                running.nextXid = XidFromFullTransactionId(checkPoint.nextXid);
                running.oldestRunningXid = oldestActiveXID;
                latestCompletedXid = XidFromFullTransactionId(checkPoint.nextXid);
                TransactionIdRetreat(latestCompletedXid);
                Assert(TransactionIdIsNormal(latestCompletedXid));
                running.latestCompletedXid = latestCompletedXid;
                running.xids = xids;
 
                ProcArrayApplyRecoveryInfo(&running);
 
                StandbyRecoverPreparedTransactions();
            }
        }
 
        /*
         * We're all set for replaying the WAL now. Do it.
         */
        PerformWalRecovery();
        performedWalRecovery = true;
    }
    else
        performedWalRecovery = false;
 
    /*
     * Finish WAL recovery.
     */
    endOfRecoveryInfo = FinishWalRecovery();
    EndOfLog = endOfRecoveryInfo->endOfLog;
    EndOfLogTLI = endOfRecoveryInfo->endOfLogTLI;
    abortedRecPtr = endOfRecoveryInfo->abortedRecPtr;
    missingContrecPtr = endOfRecoveryInfo->missingContrecPtr;
 
    /*
     * Reset ps status display, so as no information related to recovery
     * shows up.
     */
    set_ps_display("");
 
    /*
     * When recovering from a backup (we are in recovery, and archive recovery
     * was requested), complain if we did not roll forward far enough to reach
     * the point where the database is consistent.  For regular online
     * backup-from-primary, that means reaching the end-of-backup WAL record
     * (at which point we reset backupStartPoint to be Invalid), for
     * backup-from-replica (which can't inject records into the WAL stream),
     * that point is when we reach the minRecoveryPoint in pg_control (which
     * we purposefully copy last when backing up from a replica).  For
     * pg_rewind (which creates a backup_label with a method of "pg_rewind")
     * or snapshot-style backups (which don't), backupEndRequired will be set
     * to false.
     *
     * Note: it is indeed okay to look at the local variable
     * LocalMinRecoveryPoint here, even though ControlFile->minRecoveryPoint
     * might be further ahead --- ControlFile->minRecoveryPoint cannot have
     * been advanced beyond the WAL we processed.
     */
    if (InRecovery &&
        (EndOfLog < LocalMinRecoveryPoint ||
         !XLogRecPtrIsInvalid(ControlFile->backupStartPoint)))
    {
        /*
         * Ran off end of WAL before reaching end-of-backup WAL record, or
         * minRecoveryPoint. That's a bad sign, indicating that you tried to
         * recover from an online backup but never called pg_backup_stop(), or
         * you didn't archive all the WAL needed.
         */
        if (ArchiveRecoveryRequested || ControlFile->backupEndRequired)
        {
            if (!XLogRecPtrIsInvalid(ControlFile->backupStartPoint) || ControlFile->backupEndRequired)
                ereport(FATAL,
                        (errmsg("WAL ends before end of online backup"),
                         errhint("All WAL generated while online backup was taken must be available at recovery.")));
            else
                ereport(FATAL,
                        (errmsg("WAL ends before consistent recovery point")));
        }
    }
 
    /*
     * Reset unlogged relations to the contents of their INIT fork. This is
     * done AFTER recovery is complete so as to include any unlogged relations
     * created during recovery, but BEFORE recovery is marked as having
     * completed successfully. Otherwise we'd not retry if any of the post
     * end-of-recovery steps fail.
     */
    if (InRecovery)
        ResetUnloggedRelations(UNLOGGED_RELATION_INIT);
 
    /*
     * Pre-scan prepared transactions to find out the range of XIDs present.
     * This information is not quite needed yet, but it is positioned here so
     * as potential problems are detected before any on-disk change is done.
     */
    oldestActiveXID = PrescanPreparedTransactions(NULL, NULL);
 
    /*
     * Allow ordinary WAL segment creation before possibly switching to a new
     * timeline, which creates a new segment, and after the last ReadRecord().
     */
    SetInstallXLogFileSegmentActive();
 
    /*
     * Consider whether we need to assign a new timeline ID.
     *
     * If we did archive recovery, we always assign a new ID.  This handles a
     * couple of issues.  If we stopped short of the end of WAL during
     * recovery, then we are clearly generating a new timeline and must assign
     * it a unique new ID.  Even if we ran to the end, modifying the current
     * last segment is problematic because it may result in trying to
     * overwrite an already-archived copy of that segment, and we encourage
     * DBAs to make their archive_commands reject that.  We can dodge the
     * problem by making the new active segment have a new timeline ID.
     *
     * In a normal crash recovery, we can just extend the timeline we were in.
     */
    newTLI = endOfRecoveryInfo->lastRecTLI;
    if (ArchiveRecoveryRequested)
    {
        newTLI = findNewestTimeLine(recoveryTargetTLI) + 1;
        ereport(LOG,
                (errmsg("selected new timeline ID: %u", newTLI)));
 
        /*
         * Make a writable copy of the last WAL segment.  (Note that we also
         * have a copy of the last block of the old WAL in
         * endOfRecovery->lastPage; we will use that below.)
         */
        XLogInitNewTimeline(EndOfLogTLI, EndOfLog, newTLI);
 
        /*
         * Remove the signal files out of the way, so that we don't
         * accidentally re-enter archive recovery mode in a subsequent crash.
         */
        if (endOfRecoveryInfo->standby_signal_file_found)
            durable_unlink(STANDBY_SIGNAL_FILE, FATAL);
 
        if (endOfRecoveryInfo->recovery_signal_file_found)
            durable_unlink(RECOVERY_SIGNAL_FILE, FATAL);
 
        /*
         * Write the timeline history file, and have it archived. After this
         * point (or rather, as soon as the file is archived), the timeline
         * will appear as "taken" in the WAL archive and to any standby
         * servers.  If we crash before actually switching to the new
         * timeline, standby servers will nevertheless think that we switched
         * to the new timeline, and will try to connect to the new timeline.
         * To minimize the window for that, try to do as little as possible
         * between here and writing the end-of-recovery record.
         */
        writeTimeLineHistory(newTLI, recoveryTargetTLI,
                             EndOfLog, endOfRecoveryInfo->recoveryStopReason);
 
        ereport(LOG,
                (errmsg("archive recovery complete")));
    }
 
    /* Save the selected TimeLineID in shared memory, too */
    XLogCtl->InsertTimeLineID = newTLI;
    XLogCtl->PrevTimeLineID = endOfRecoveryInfo->lastRecTLI;
 
    /*
     * Actually, if WAL ended in an incomplete record, skip the parts that
     * made it through and start writing after the portion that persisted.
     * (It's critical to first write an OVERWRITE_CONTRECORD message, which
     * we'll do as soon as we're open for writing new WAL.)
     */
    if (!XLogRecPtrIsInvalid(missingContrecPtr))
    {
        /*
         * We should only have a missingContrecPtr if we're not switching to
         * a new timeline. When a timeline switch occurs, WAL is copied from
         * the old timeline to the new only up to the end of the last complete
         * record, so there can't be an incomplete WAL record that we need to
         * disregard.
         */
        Assert(newTLI == endOfRecoveryInfo->lastRecTLI);
        Assert(!XLogRecPtrIsInvalid(abortedRecPtr));
        EndOfLog = missingContrecPtr;
    }
 
    /*
     * Prepare to write WAL starting at EndOfLog location, and init xlog
     * buffer cache using the block containing the last record from the
     * previous incarnation.
     */
    Insert = &XLogCtl->Insert;
    Insert->PrevBytePos = XLogRecPtrToBytePos(endOfRecoveryInfo->lastRec);
    Insert->CurrBytePos = XLogRecPtrToBytePos(EndOfLog);
 
    /*
     * Tricky point here: lastPage contains the *last* block that the LastRec
     * record spans, not the one it starts in.  The last block is indeed the
     * one we want to use.
     */
    if (EndOfLog % XLOG_BLCKSZ != 0)
    {
        char       *page;
        int         len;
        int         firstIdx;
 
        firstIdx = XLogRecPtrToBufIdx(EndOfLog);
        len = EndOfLog - endOfRecoveryInfo->lastPageBeginPtr;
        Assert(len < XLOG_BLCKSZ);
 
        /* Copy the valid part of the last block, and zero the rest */
        page = &XLogCtl->pages[firstIdx * XLOG_BLCKSZ];
        memcpy(page, endOfRecoveryInfo->lastPage, len);
        memset(page + len, 0, XLOG_BLCKSZ - len);
 
        XLogCtl->xlblocks[firstIdx] = endOfRecoveryInfo->lastPageBeginPtr + XLOG_BLCKSZ;
        XLogCtl->InitializedUpTo = endOfRecoveryInfo->lastPageBeginPtr + XLOG_BLCKSZ;
    }
    else
    {
        /*
         * There is no partial block to copy. Just set InitializedUpTo, and
         * let the first attempt to insert a log record to initialize the next
         * buffer.
         */
        XLogCtl->InitializedUpTo = EndOfLog;
    }
 
    LogwrtResult.Write = LogwrtResult.Flush = EndOfLog;
 
    XLogCtl->LogwrtResult = LogwrtResult;
 
    XLogCtl->LogwrtRqst.Write = EndOfLog;
    XLogCtl->LogwrtRqst.Flush = EndOfLog;
 
    /*
     * Preallocate additional log files, if wanted.
     */
    PreallocXlogFiles(EndOfLog, newTLI);
 
    /*
     * Okay, we're officially UP.
     */
    InRecovery = false;
 
    /* start the archive_timeout timer and LSN running */
    XLogCtl->lastSegSwitchTime = (pg_time_t) time(NULL);
    XLogCtl->lastSegSwitchLSN = EndOfLog;
 
    /* also initialize latestCompletedXid, to nextXid - 1 */
    LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
    ShmemVariableCache->latestCompletedXid = ShmemVariableCache->nextXid;
    FullTransactionIdRetreat(&ShmemVariableCache->latestCompletedXid);
    LWLockRelease(ProcArrayLock);
 
    /*
     * Start up subtrans, if not already done for hot standby.  (commit
     * timestamps are started below, if necessary.)
     */
    if (standbyState == STANDBY_DISABLED)
        StartupSUBTRANS(oldestActiveXID);
 
    /*
     * Perform end of recovery actions for any SLRUs that need it.
     */
    TrimCLOG();
    TrimMultiXact();
 
    /* Reload shared-memory state for prepared transactions */
    RecoverPreparedTransactions();
 
    /* Shut down xlogreader */
    ShutdownWalRecovery();
 
    /* Enable WAL writes for this backend only. */
    LocalSetXLogInsertAllowed();
 
    /* If necessary, write overwrite-contrecord before doing anything else */
    if (!XLogRecPtrIsInvalid(abortedRecPtr))
    {
        Assert(!XLogRecPtrIsInvalid(missingContrecPtr));
        CreateOverwriteContrecordRecord(abortedRecPtr, missingContrecPtr, newTLI);
    }
 
    /*
     * Update full_page_writes in shared memory and write an XLOG_FPW_CHANGE
     * record before resource manager writes cleanup WAL records or checkpoint
     * record is written.
     */
    Insert->fullPageWrites = lastFullPageWrites;
    UpdateFullPageWrites();
 
    /*
     * Emit checkpoint or end-of-recovery record in XLOG, if required.
     */
    if (performedWalRecovery)
        promoted = PerformRecoveryXLogAction();
 
    /*
     * If any of the critical GUCs have changed, log them before we allow
     * backends to write WAL.
     */
    XLogReportParameters();
 
    /* If this is archive recovery, perform post-recovery cleanup actions. */
    if (ArchiveRecoveryRequested)
        CleanupAfterArchiveRecovery(EndOfLogTLI, EndOfLog, newTLI);
 
    /*
     * Local WAL inserts enabled, so it's time to finish initialization of
     * commit timestamp.
     */
    CompleteCommitTsInitialization();
 
    /*
     * All done with end-of-recovery actions.
     *
     * Now allow backends to write WAL and update the control file status in
     * consequence.  SharedRecoveryState, that controls if backends can write
     * WAL, is updated while holding ControlFileLock to prevent other backends
     * to look at an inconsistent state of the control file in shared memory.
     * There is still a small window during which backends can write WAL and
     * the control file is still referring to a system not in DB_IN_PRODUCTION
     * state while looking at the on-disk control file.
     *
     * Also, we use info_lck to update SharedRecoveryState to ensure that
     * there are no race conditions concerning visibility of other recent
     * updates to shared memory.
     */
    LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
    ControlFile->state = DB_IN_PRODUCTION;
 
    SpinLockAcquire(&XLogCtl->info_lck);
    XLogCtl->SharedRecoveryState = RECOVERY_STATE_DONE;
    SpinLockRelease(&XLogCtl->info_lck);
 
    UpdateControlFile();
    LWLockRelease(ControlFileLock);
 
    /*
     * Shutdown the recovery environment.  This must occur after
     * RecoverPreparedTransactions() (see notes in lock_twophase_recover())
     * and after switching SharedRecoveryState to RECOVERY_STATE_DONE so as
     * any session building a snapshot will not rely on KnownAssignedXids as
     * RecoveryInProgress() would return false at this stage.  This is
     * particularly critical for prepared 2PC transactions, that would still
     * need to be included in snapshots once recovery has ended.
     */
    if (standbyState != STANDBY_DISABLED)
        ShutdownRecoveryTransactionEnvironment();
 
    /*
     * If there were cascading standby servers connected to us, nudge any wal
     * sender processes to notice that we've been promoted.
     */
    WalSndWakeup();
 
    /*
     * If this was a promotion, request an (online) checkpoint now. This isn't
     * required for consistency, but the last restartpoint might be far back,
     * and in case of a crash, recovering from it might take a longer than is
     * appropriate now that we're not in standby mode anymore.
     */
    if (promoted)
        RequestCheckpoint(CHECKPOINT_FORCE);
}

References abortedRecPtr, EndOfWalRecoveryInfo::abortedRecPtr, AdvanceOldestClogXid(), ArchiveRecoveryRequested, Assert(), AuxProcessResourceOwner, BACKUP_LABEL_FILE, BACKUP_LABEL_OLD, ControlFileData::backupEndRequired, ControlFileData::backupStartPoint, ControlFileData::checkPoint, CHECKPOINT_FORCE, ControlFileData::checkPointCopy, CheckRequiredParameterValues(), XLogCtlData::ckptFullXid, CleanupAfterArchiveRecovery(), CompleteCommitTsInitialization(), ControlFile, CreateOverwriteContrecordRecord(), CurrentResourceOwner, DB_IN_ARCHIVE_RECOVERY, DB_IN_CRASH_RECOVERY, DB_IN_PRODUCTION, DB_SHUTDOWNED, DB_SHUTDOWNED_IN_RECOVERY, DB_SHUTDOWNING, DEBUG1, DeleteAllExportedSnapshotFiles(), doPageWrites, durable_rename(), durable_unlink(), EnableHotStandby, EndOfWalRecoveryInfo::endOfLog, EndOfWalRecoveryInfo::endOfLogTLI, ereport, errhint(), errmsg(), errmsg_internal(), FATAL, findNewestTimeLine(), FinishWalRecovery(), FirstNormalUnloggedLSN, XLogwrtRqst::Flush, XLogwrtResult::Flush, CheckPoint::fullPageWrites, FullTransactionIdRetreat(), InArchiveRecovery, XLogCtlData::info_lck, XLogCtlData::InitializedUpTo, InitRecoveryTransactionEnvironment(), InitWalRecovery(), InRecovery, XLogCtlData::Insert, Insert(), XLogCtlData::InsertTimeLineID, InvalidXLogRecPtr, IsBootstrapProcessingMode, IsPostmasterEnvironment, lastFullPageWrites, EndOfWalRecoveryInfo::lastPage, EndOfWalRecoveryInfo::lastPageBeginPtr, EndOfWalRecoveryInfo::lastRec, EndOfWalRecoveryInfo::lastRecTLI, XLogCtlData::lastSegSwitchLSN, XLogCtlData::lastSegSwitchTime, VariableCacheData::latestCompletedXid, RunningTransactionsData::latestCompletedXid, len, LocalMinRecoveryPoint, LocalMinRecoveryPointTLI, LocalSetXLogInsertAllowed(), LOG, XLogCtlData::LogwrtResult, LogwrtResult, XLogCtlData::LogwrtRqst, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), ControlFileData::minRecoveryPoint, ControlFileData::minRecoveryPointTLI, missingContrecPtr, EndOfWalRecoveryInfo::missingContrecPtr, MultiXactSetNextMXact(), CheckPoint::newestCommitTsXid, CheckPoint::nextMulti, CheckPoint::nextMultiOffset, VariableCacheData::nextOid, CheckPoint::nextOid, VariableCacheData::nextXid, CheckPoint::nextXid, RunningTransactionsData::nextXid, NOTICE, VariableCacheData::oidCount, CheckPoint::oldestActiveXid, CheckPoint::oldestCommitTsXid, CheckPoint::oldestMulti, CheckPoint::oldestMultiDB, RunningTransactionsData::oldestRunningXid, CheckPoint::oldestXid, CheckPoint::oldestXidDB, XLogCtlData::pages, PerformRecoveryXLogAction(), PerformWalRecovery(), pg_usleep(), pgstat_discard_stats(), pgstat_restore_stats(), PreallocXlogFiles(), PrescanPreparedTransactions(), XLogCtlData::PrevTimeLineID, ProcArrayApplyRecoveryInfo(), ProcArrayInitRecovery(), RecoverPreparedTransactions(), RECOVERY_SIGNAL_FILE, EndOfWalRecoveryInfo::recovery_signal_file_found, RECOVERY_STATE_ARCHIVE, RECOVERY_STATE_CRASH, RECOVERY_STATE_DONE, EndOfWalRecoveryInfo::recoveryStopReason, recoveryTargetTLI, CheckPoint::redo, RedoRecPtr, XLogCtlInsert::RedoRecPtr, XLogCtlData::RedoRecPtr, RegisterTimeout(), RelationCacheInitFileRemove(), RemoveTempXlogFiles(), RequestCheckpoint(), ResetUnloggedRelations(), restoreTimeLineHistoryFiles(), restoreTwoPhaseData(), set_ps_display(), SetCommitTsLimit(), SetInstallXLogFileSegmentActive(), SetMultiXactIdLimit(), SetTransactionIdLimit(), XLogCtlData::SharedRecoveryState, ShmemVariableCache, ShutdownRecoveryTransactionEnvironment(), ShutdownWalRecovery(), SpinLockAcquire, SpinLockRelease, STANDBY_DISABLED, STANDBY_SIGNAL_FILE, EndOfWalRecoveryInfo::standby_signal_file_found, StandbyRecoverPreparedTransactions(), standbyState, STARTUP_PROGRESS_TIMEOUT, startup_progress_timeout_handler(), StartupCLOG(), StartupCommitTs(), StartupMultiXact(), StartupReorderBuffer(), StartupReplicationOrigin(), StartupReplicationSlots(), StartupSUBTRANS(), ControlFileData::state, str_time(), RunningTransactionsData::subxcnt, RunningTransactionsData::subxid_overflow, SyncDataDirectory(), TABLESPACE_MAP, TABLESPACE_MAP_OLD, CheckPoint::ThisTimeLineID, CheckPoint::time, ControlFileData::time, ControlFileData::track_commit_timestamp, TransactionIdIsNormal, TransactionIdIsValid, TransactionIdRetreat, TrimCLOG(), TrimMultiXact(), UNLOGGED_RELATION_CLEANUP, UNLOGGED_RELATION_INIT, XLogCtlData::unloggedLSN, ControlFileData::unloggedLSN, UpdateControlFile(), UpdateFullPageWrites(), ValidateXLOGDirectoryStructure(), WalSndWakeup(), XLogwrtRqst::Write, XLogwrtResult::Write, writeTimeLineHistory(), RunningTransactionsData::xcnt, XidFromFullTransactionId, RunningTransactionsData::xids, XLogCtlData::xlblocks, XLogCtl, XLogInitNewTimeline(), XLogRecPtrIsInvalid, XLogRecPtrToBufIdx, XLogRecPtrToBytePos(), XLogReportParameters(), and XRecOffIsValid.

Referenced by InitPostgres(), and StartupProcessMain().

SwitchIntoArchiveRecovery()

void SwitchIntoArchiveRecovery	(	XLogRecPtr	EndRecPtr,
		TimeLineID	replayTLI
	)

Definition at line 5783 of file xlog.c.

{
    /* initialize minRecoveryPoint to this record */
    LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
    ControlFile->state = DB_IN_ARCHIVE_RECOVERY;
    if (ControlFile->minRecoveryPoint < EndRecPtr)
    {
        ControlFile->minRecoveryPoint = EndRecPtr;
        ControlFile->minRecoveryPointTLI = replayTLI;
    }
    /* update local copy */
    LocalMinRecoveryPoint = ControlFile->minRecoveryPoint;
    LocalMinRecoveryPointTLI = ControlFile->minRecoveryPointTLI;
 
    /*
     * The startup process can update its local copy of minRecoveryPoint from
     * this point.
     */
    updateMinRecoveryPoint = true;
 
    UpdateControlFile();
 
    /*
     * We update SharedRecoveryState while holding the lock on ControlFileLock
     * so both states are consistent in shared memory.
     */
    SpinLockAcquire(&XLogCtl->info_lck);
    XLogCtl->SharedRecoveryState = RECOVERY_STATE_ARCHIVE;
    SpinLockRelease(&XLogCtl->info_lck);
 
    LWLockRelease(ControlFileLock);
}

References ControlFile, DB_IN_ARCHIVE_RECOVERY, XLogCtlData::info_lck, LocalMinRecoveryPoint, LocalMinRecoveryPointTLI, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), ControlFileData::minRecoveryPoint, ControlFileData::minRecoveryPointTLI, RECOVERY_STATE_ARCHIVE, XLogCtlData::SharedRecoveryState, SpinLockAcquire, SpinLockRelease, ControlFileData::state, UpdateControlFile(), updateMinRecoveryPoint, and XLogCtl.

Referenced by ReadRecord().

UpdateFullPageWrites()

void UpdateFullPageWrites

(

void

)

Definition at line 7632 of file xlog.c.

{
    XLogCtlInsert *Insert = &XLogCtl->Insert;
    bool        recoveryInProgress;
 
    /*
     * Do nothing if full_page_writes has not been changed.
     *
     * It's safe to check the shared full_page_writes without the lock,
     * because we assume that there is no concurrently running process which
     * can update it.
     */
    if (fullPageWrites == Insert->fullPageWrites)
        return;
 
    /*
     * Perform this outside critical section so that the WAL insert
     * initialization done by RecoveryInProgress() doesn't trigger an
     * assertion failure.
     */
    recoveryInProgress = RecoveryInProgress();
 
    START_CRIT_SECTION();
 
    /*
     * It's always safe to take full page images, even when not strictly
     * required, but not the other round. So if we're setting full_page_writes
     * to true, first set it true and then write the WAL record. If we're
     * setting it to false, first write the WAL record and then set the global
     * flag.
     */
    if (fullPageWrites)
    {
        WALInsertLockAcquireExclusive();
        Insert->fullPageWrites = true;
        WALInsertLockRelease();
    }
 
    /*
     * Write an XLOG_FPW_CHANGE record. This allows us to keep track of
     * full_page_writes during archive recovery, if required.
     */
    if (XLogStandbyInfoActive() && !recoveryInProgress)
    {
        XLogBeginInsert();
        XLogRegisterData((char *) (&fullPageWrites), sizeof(bool));
 
        XLogInsert(RM_XLOG_ID, XLOG_FPW_CHANGE);
    }
 
    if (!fullPageWrites)
    {
        WALInsertLockAcquireExclusive();
        Insert->fullPageWrites = false;
        WALInsertLockRelease();
    }
    END_CRIT_SECTION();
}

References END_CRIT_SECTION, fullPageWrites, XLogCtlData::Insert, Insert(), RecoveryInProgress(), START_CRIT_SECTION, WALInsertLockAcquireExclusive(), WALInsertLockRelease(), XLOG_FPW_CHANGE, XLogBeginInsert(), XLogCtl, XLogInsert(), XLogRegisterData(), and XLogStandbyInfoActive.

Referenced by StartupXLOG(), and UpdateSharedMemoryConfig().

xlog_desc()

void xlog_desc	(	StringInfo	buf,
		struct XLogReaderState *	record
	)

Definition at line 37 of file xlogdesc.c.

{
    char       *rec = XLogRecGetData(record);
    uint8       info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
 
    if (info == XLOG_CHECKPOINT_SHUTDOWN ||
        info == XLOG_CHECKPOINT_ONLINE)
    {
        CheckPoint *checkpoint = (CheckPoint *) rec;
 
        appendStringInfo(buf, "redo %X/%X; "
                         "tli %u; prev tli %u; fpw %s; xid %u:%u; oid %u; multi %u; offset %u; "
                         "oldest xid %u in DB %u; oldest multi %u in DB %u; "
                         "oldest/newest commit timestamp xid: %u/%u; "
                         "oldest running xid %u; %s",
                         LSN_FORMAT_ARGS(checkpoint->redo),
                         checkpoint->ThisTimeLineID,
                         checkpoint->PrevTimeLineID,
                         checkpoint->fullPageWrites ? "true" : "false",
                         EpochFromFullTransactionId(checkpoint->nextXid),
                         XidFromFullTransactionId(checkpoint->nextXid),
                         checkpoint->nextOid,
                         checkpoint->nextMulti,
                         checkpoint->nextMultiOffset,
                         checkpoint->oldestXid,
                         checkpoint->oldestXidDB,
                         checkpoint->oldestMulti,
                         checkpoint->oldestMultiDB,
                         checkpoint->oldestCommitTsXid,
                         checkpoint->newestCommitTsXid,
                         checkpoint->oldestActiveXid,
                         (info == XLOG_CHECKPOINT_SHUTDOWN) ? "shutdown" : "online");
    }
    else if (info == XLOG_NEXTOID)
    {
        Oid         nextOid;
 
        memcpy(&nextOid, rec, sizeof(Oid));
        appendStringInfo(buf, "%u", nextOid);
    }
    else if (info == XLOG_RESTORE_POINT)
    {
        xl_restore_point *xlrec = (xl_restore_point *) rec;
 
        appendStringInfoString(buf, xlrec->rp_name);
    }
    else if (info == XLOG_FPI || info == XLOG_FPI_FOR_HINT)
    {
        /* no further information to print */
    }
    else if (info == XLOG_BACKUP_END)
    {
        XLogRecPtr  startpoint;
 
        memcpy(&startpoint, rec, sizeof(XLogRecPtr));
        appendStringInfo(buf, "%X/%X", LSN_FORMAT_ARGS(startpoint));
    }
    else if (info == XLOG_PARAMETER_CHANGE)
    {
        xl_parameter_change xlrec;
        const char *wal_level_str;
        const struct config_enum_entry *entry;
 
        memcpy(&xlrec, rec, sizeof(xl_parameter_change));
 
        /* Find a string representation for wal_level */
        wal_level_str = "?";
        for (entry = wal_level_options; entry->name; entry++)
        {
            if (entry->val == xlrec.wal_level)
            {
                wal_level_str = entry->name;
                break;
            }
        }
 
        appendStringInfo(buf, "max_connections=%d max_worker_processes=%d "
                         "max_wal_senders=%d max_prepared_xacts=%d "
                         "max_locks_per_xact=%d wal_level=%s "
                         "wal_log_hints=%s track_commit_timestamp=%s",
                         xlrec.MaxConnections,
                         xlrec.max_worker_processes,
                         xlrec.max_wal_senders,
                         xlrec.max_prepared_xacts,
                         xlrec.max_locks_per_xact,
                         wal_level_str,
                         xlrec.wal_log_hints ? "on" : "off",
                         xlrec.track_commit_timestamp ? "on" : "off");
    }
    else if (info == XLOG_FPW_CHANGE)
    {
        bool        fpw;
 
        memcpy(&fpw, rec, sizeof(bool));
        appendStringInfoString(buf, fpw ? "true" : "false");
    }
    else if (info == XLOG_END_OF_RECOVERY)
    {
        xl_end_of_recovery xlrec;
 
        memcpy(&xlrec, rec, sizeof(xl_end_of_recovery));
        appendStringInfo(buf, "tli %u; prev tli %u; time %s",
                         xlrec.ThisTimeLineID, xlrec.PrevTimeLineID,
                         timestamptz_to_str(xlrec.end_time));
    }
    else if (info == XLOG_OVERWRITE_CONTRECORD)
    {
        xl_overwrite_contrecord xlrec;
 
        memcpy(&xlrec, rec, sizeof(xl_overwrite_contrecord));
        appendStringInfo(buf, "lsn %X/%X; time %s",
                         LSN_FORMAT_ARGS(xlrec.overwritten_lsn),
                         timestamptz_to_str(xlrec.overwrite_time));
    }
}

References appendStringInfo(), appendStringInfoString(), buf, xl_end_of_recovery::end_time, EpochFromFullTransactionId, CheckPoint::fullPageWrites, LSN_FORMAT_ARGS, xl_parameter_change::max_locks_per_xact, xl_parameter_change::max_prepared_xacts, xl_parameter_change::max_wal_senders, xl_parameter_change::max_worker_processes, xl_parameter_change::MaxConnections, config_enum_entry::name, CheckPoint::newestCommitTsXid, CheckPoint::nextMulti, CheckPoint::nextMultiOffset, CheckPoint::nextOid, CheckPoint::nextXid, CheckPoint::oldestActiveXid, CheckPoint::oldestCommitTsXid, CheckPoint::oldestMulti, CheckPoint::oldestMultiDB, CheckPoint::oldestXid, CheckPoint::oldestXidDB, xl_overwrite_contrecord::overwrite_time, xl_overwrite_contrecord::overwritten_lsn, xl_end_of_recovery::PrevTimeLineID, CheckPoint::PrevTimeLineID, CheckPoint::redo, xl_restore_point::rp_name, xl_end_of_recovery::ThisTimeLineID, CheckPoint::ThisTimeLineID, timestamptz_to_str(), xl_parameter_change::track_commit_timestamp, config_enum_entry::val, xl_parameter_change::wal_level, wal_level_options, wal_level_str(), xl_parameter_change::wal_log_hints, XidFromFullTransactionId, XLOG_BACKUP_END, XLOG_CHECKPOINT_ONLINE, XLOG_CHECKPOINT_SHUTDOWN, XLOG_END_OF_RECOVERY, XLOG_FPI, XLOG_FPI_FOR_HINT, XLOG_FPW_CHANGE, XLOG_NEXTOID, XLOG_OVERWRITE_CONTRECORD, XLOG_PARAMETER_CHANGE, XLOG_RESTORE_POINT, XLogRecGetData, XLogRecGetInfo, and XLR_INFO_MASK.

xlog_identify()

const char* xlog_identify

(

uint8

info

)

Definition at line 154 of file xlogdesc.c.

{
    const char *id = NULL;
 
    switch (info & ~XLR_INFO_MASK)
    {
        case XLOG_CHECKPOINT_SHUTDOWN:
            id = "CHECKPOINT_SHUTDOWN";
            break;
        case XLOG_CHECKPOINT_ONLINE:
            id = "CHECKPOINT_ONLINE";
            break;
        case XLOG_NOOP:
            id = "NOOP";
            break;
        case XLOG_NEXTOID:
            id = "NEXTOID";
            break;
        case XLOG_SWITCH:
            id = "SWITCH";
            break;
        case XLOG_BACKUP_END:
            id = "BACKUP_END";
            break;
        case XLOG_PARAMETER_CHANGE:
            id = "PARAMETER_CHANGE";
            break;
        case XLOG_RESTORE_POINT:
            id = "RESTORE_POINT";
            break;
        case XLOG_FPW_CHANGE:
            id = "FPW_CHANGE";
            break;
        case XLOG_END_OF_RECOVERY:
            id = "END_OF_RECOVERY";
            break;
        case XLOG_OVERWRITE_CONTRECORD:
            id = "OVERWRITE_CONTRECORD";
            break;
        case XLOG_FPI:
            id = "FPI";
            break;
        case XLOG_FPI_FOR_HINT:
            id = "FPI_FOR_HINT";
            break;
    }
 
    return id;
}

References XLOG_BACKUP_END, XLOG_CHECKPOINT_ONLINE, XLOG_CHECKPOINT_SHUTDOWN, XLOG_END_OF_RECOVERY, XLOG_FPI, XLOG_FPI_FOR_HINT, XLOG_FPW_CHANGE, XLOG_NEXTOID, XLOG_NOOP, XLOG_OVERWRITE_CONTRECORD, XLOG_PARAMETER_CHANGE, XLOG_RESTORE_POINT, XLOG_SWITCH, and XLR_INFO_MASK.

xlog_redo()

void xlog_redo

(

struct XLogReaderState *

record

)

Definition at line 7701 of file xlog.c.

{
    uint8       info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
    XLogRecPtr  lsn = record->EndRecPtr;
 
    /*
     * In XLOG rmgr, backup blocks are only used by XLOG_FPI and
     * XLOG_FPI_FOR_HINT records.
     */
    Assert(info == XLOG_FPI || info == XLOG_FPI_FOR_HINT ||
           !XLogRecHasAnyBlockRefs(record));
 
    if (info == XLOG_NEXTOID)
    {
        Oid         nextOid;
 
        /*
         * We used to try to take the maximum of ShmemVariableCache->nextOid
         * and the recorded nextOid, but that fails if the OID counter wraps
         * around.  Since no OID allocation should be happening during replay
         * anyway, better to just believe the record exactly.  We still take
         * OidGenLock while setting the variable, just in case.
         */
        memcpy(&nextOid, XLogRecGetData(record), sizeof(Oid));
        LWLockAcquire(OidGenLock, LW_EXCLUSIVE);
        ShmemVariableCache->nextOid = nextOid;
        ShmemVariableCache->oidCount = 0;
        LWLockRelease(OidGenLock);
    }
    else if (info == XLOG_CHECKPOINT_SHUTDOWN)
    {
        CheckPoint  checkPoint;
        TimeLineID  replayTLI;
 
        memcpy(&checkPoint, XLogRecGetData(record), sizeof(CheckPoint));
        /* In a SHUTDOWN checkpoint, believe the counters exactly */
        LWLockAcquire(XidGenLock, LW_EXCLUSIVE);
        ShmemVariableCache->nextXid = checkPoint.nextXid;
        LWLockRelease(XidGenLock);
        LWLockAcquire(OidGenLock, LW_EXCLUSIVE);
        ShmemVariableCache->nextOid = checkPoint.nextOid;
        ShmemVariableCache->oidCount = 0;
        LWLockRelease(OidGenLock);
        MultiXactSetNextMXact(checkPoint.nextMulti,
                              checkPoint.nextMultiOffset);
 
        MultiXactAdvanceOldest(checkPoint.oldestMulti,
                               checkPoint.oldestMultiDB);
 
        /*
         * No need to set oldestClogXid here as well; it'll be set when we
         * redo an xl_clog_truncate if it changed since initialization.
         */
        SetTransactionIdLimit(checkPoint.oldestXid, checkPoint.oldestXidDB);
 
        /*
         * If we see a shutdown checkpoint while waiting for an end-of-backup
         * record, the backup was canceled and the end-of-backup record will
         * never arrive.
         */
        if (ArchiveRecoveryRequested &&
            !XLogRecPtrIsInvalid(ControlFile->backupStartPoint) &&
            XLogRecPtrIsInvalid(ControlFile->backupEndPoint))
            ereport(PANIC,
                    (errmsg("online backup was canceled, recovery cannot continue")));
 
        /*
         * If we see a shutdown checkpoint, we know that nothing was running
         * on the primary at this point. So fake-up an empty running-xacts
         * record and use that here and now. Recover additional standby state
         * for prepared transactions.
         */
        if (standbyState >= STANDBY_INITIALIZED)
        {
            TransactionId *xids;
            int         nxids;
            TransactionId oldestActiveXID;
            TransactionId latestCompletedXid;
            RunningTransactionsData running;
 
            oldestActiveXID = PrescanPreparedTransactions(&xids, &nxids);
 
            /*
             * Construct a RunningTransactions snapshot representing a shut
             * down server, with only prepared transactions still alive. We're
             * never overflowed at this point because all subxids are listed
             * with their parent prepared transactions.
             */
            running.xcnt = nxids;
            running.subxcnt = 0;
            running.subxid_overflow = false;
            running.nextXid = XidFromFullTransactionId(checkPoint.nextXid);
            running.oldestRunningXid = oldestActiveXID;
            latestCompletedXid = XidFromFullTransactionId(checkPoint.nextXid);
            TransactionIdRetreat(latestCompletedXid);
            Assert(TransactionIdIsNormal(latestCompletedXid));
            running.latestCompletedXid = latestCompletedXid;
            running.xids = xids;
 
            ProcArrayApplyRecoveryInfo(&running);
 
            StandbyRecoverPreparedTransactions();
        }
 
        /* ControlFile->checkPointCopy always tracks the latest ckpt XID */
        LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
        ControlFile->checkPointCopy.nextXid = checkPoint.nextXid;
        LWLockRelease(ControlFileLock);
 
        /* Update shared-memory copy of checkpoint XID/epoch */
        SpinLockAcquire(&XLogCtl->info_lck);
        XLogCtl->ckptFullXid = checkPoint.nextXid;
        SpinLockRelease(&XLogCtl->info_lck);
 
        /*
         * We should've already switched to the new TLI before replaying this
         * record.
         */
        (void) GetCurrentReplayRecPtr(&replayTLI);
        if (checkPoint.ThisTimeLineID != replayTLI)
            ereport(PANIC,
                    (errmsg("unexpected timeline ID %u (should be %u) in shutdown checkpoint record",
                            checkPoint.ThisTimeLineID, replayTLI)));
 
        RecoveryRestartPoint(&checkPoint, record);
    }
    else if (info == XLOG_CHECKPOINT_ONLINE)
    {
        CheckPoint  checkPoint;
        TimeLineID  replayTLI;
 
        memcpy(&checkPoint, XLogRecGetData(record), sizeof(CheckPoint));
        /* In an ONLINE checkpoint, treat the XID counter as a minimum */
        LWLockAcquire(XidGenLock, LW_EXCLUSIVE);
        if (FullTransactionIdPrecedes(ShmemVariableCache->nextXid,
                                      checkPoint.nextXid))
            ShmemVariableCache->nextXid = checkPoint.nextXid;
        LWLockRelease(XidGenLock);
 
        /*
         * We ignore the nextOid counter in an ONLINE checkpoint, preferring
         * to track OID assignment through XLOG_NEXTOID records.  The nextOid
         * counter is from the start of the checkpoint and might well be stale
         * compared to later XLOG_NEXTOID records.  We could try to take the
         * maximum of the nextOid counter and our latest value, but since
         * there's no particular guarantee about the speed with which the OID
         * counter wraps around, that's a risky thing to do.  In any case,
         * users of the nextOid counter are required to avoid assignment of
         * duplicates, so that a somewhat out-of-date value should be safe.
         */
 
        /* Handle multixact */
        MultiXactAdvanceNextMXact(checkPoint.nextMulti,
                                  checkPoint.nextMultiOffset);
 
        /*
         * NB: This may perform multixact truncation when replaying WAL
         * generated by an older primary.
         */
        MultiXactAdvanceOldest(checkPoint.oldestMulti,
                               checkPoint.oldestMultiDB);
        if (TransactionIdPrecedes(ShmemVariableCache->oldestXid,
                                  checkPoint.oldestXid))
            SetTransactionIdLimit(checkPoint.oldestXid,
                                  checkPoint.oldestXidDB);
        /* ControlFile->checkPointCopy always tracks the latest ckpt XID */
        LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
        ControlFile->checkPointCopy.nextXid = checkPoint.nextXid;
        LWLockRelease(ControlFileLock);
 
        /* Update shared-memory copy of checkpoint XID/epoch */
        SpinLockAcquire(&XLogCtl->info_lck);
        XLogCtl->ckptFullXid = checkPoint.nextXid;
        SpinLockRelease(&XLogCtl->info_lck);
 
        /* TLI should not change in an on-line checkpoint */
        (void) GetCurrentReplayRecPtr(&replayTLI);
        if (checkPoint.ThisTimeLineID != replayTLI)
            ereport(PANIC,
                    (errmsg("unexpected timeline ID %u (should be %u) in online checkpoint record",
                            checkPoint.ThisTimeLineID, replayTLI)));
 
        RecoveryRestartPoint(&checkPoint, record);
    }
    else if (info == XLOG_OVERWRITE_CONTRECORD)
    {
        /* nothing to do here, handled in xlogrecovery_redo() */
    }
    else if (info == XLOG_END_OF_RECOVERY)
    {
        xl_end_of_recovery xlrec;
        TimeLineID  replayTLI;
 
        memcpy(&xlrec, XLogRecGetData(record), sizeof(xl_end_of_recovery));
 
        /*
         * For Hot Standby, we could treat this like a Shutdown Checkpoint,
         * but this case is rarer and harder to test, so the benefit doesn't
         * outweigh the potential extra cost of maintenance.
         */
 
        /*
         * We should've already switched to the new TLI before replaying this
         * record.
         */
        (void) GetCurrentReplayRecPtr(&replayTLI);
        if (xlrec.ThisTimeLineID != replayTLI)
            ereport(PANIC,
                    (errmsg("unexpected timeline ID %u (should be %u) in end-of-recovery record",
                            xlrec.ThisTimeLineID, replayTLI)));
    }
    else if (info == XLOG_NOOP)
    {
        /* nothing to do here */
    }
    else if (info == XLOG_SWITCH)
    {
        /* nothing to do here */
    }
    else if (info == XLOG_RESTORE_POINT)
    {
        /* nothing to do here, handled in xlogrecovery.c */
    }
    else if (info == XLOG_FPI || info == XLOG_FPI_FOR_HINT)
    {
        /*
         * XLOG_FPI records contain nothing else but one or more block
         * references. Every block reference must include a full-page image
         * even if full_page_writes was disabled when the record was generated
         * - otherwise there would be no point in this record.
         *
         * XLOG_FPI_FOR_HINT records are generated when a page needs to be
         * WAL-logged because of a hint bit update. They are only generated
         * when checksums and/or wal_log_hints are enabled. They may include
         * no full-page images if full_page_writes was disabled when they were
         * generated. In this case there is nothing to do here.
         *
         * No recovery conflicts are generated by these generic records - if a
         * resource manager needs to generate conflicts, it has to define a
         * separate WAL record type and redo routine.
         */
        for (uint8 block_id = 0; block_id <= XLogRecMaxBlockId(record); block_id++)
        {
            Buffer      buffer;
 
            if (!XLogRecHasBlockImage(record, block_id))
            {