PostgreSQL Source Code  git master
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 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 WalSyncMethod WalSyncMethod
 
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  WalSyncMethod {
  WAL_SYNC_METHOD_FSYNC = 0 , WAL_SYNC_METHOD_FDATASYNC , WAL_SYNC_METHOD_OPEN , WAL_SYNC_METHOD_FSYNC_WRITETHROUGH ,
  WAL_SYNC_METHOD_OPEN_DSYNC
}
 
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)
 
XLogSegNo XLogGetOldestSegno (TimeLineID tli)
 
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)
 
WalLevel GetActiveWalLevelOnStandby (void)
 
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)
 
Size WALReadFromBuffers (char *dstbuf, XLogRecPtr startptr, Size count, TimeLineID tli)
 
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 wal_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 boolwal_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 298 of file xlog.h.

◆ BACKUP_LABEL_OLD

#define BACKUP_LABEL_OLD   "backup_label.old"

Definition at line 299 of file xlog.h.

◆ CHECKPOINT_CAUSE_TIME

#define CHECKPOINT_CAUSE_TIME   0x0100 /* Elapsed time */

Definition at line 147 of file xlog.h.

◆ CHECKPOINT_CAUSE_XLOG

#define CHECKPOINT_CAUSE_XLOG   0x0080 /* XLOG consumption */

Definition at line 146 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 138 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 141 of file xlog.h.

◆ CHECKPOINT_FORCE

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

Definition at line 140 of file xlog.h.

◆ CHECKPOINT_IMMEDIATE

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

Definition at line 139 of file xlog.h.

◆ CHECKPOINT_IS_SHUTDOWN

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

Definition at line 137 of file xlog.h.

◆ CHECKPOINT_REQUESTED

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

Definition at line 144 of file xlog.h.

◆ CHECKPOINT_WAIT

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

Definition at line 143 of file xlog.h.

◆ PROMOTE_SIGNAL_FILE

#define PROMOTE_SIGNAL_FILE   "promote"

Definition at line 305 of file xlog.h.

◆ RECOVERY_SIGNAL_FILE

#define RECOVERY_SIGNAL_FILE   "recovery.signal"

Definition at line 296 of file xlog.h.

◆ STANDBY_SIGNAL_FILE

#define STANDBY_SIGNAL_FILE   "standby.signal"

Definition at line 297 of file xlog.h.

◆ TABLESPACE_MAP

#define TABLESPACE_MAP   "tablespace_map"

Definition at line 301 of file xlog.h.

◆ TABLESPACE_MAP_OLD

#define TABLESPACE_MAP_OLD   "tablespace_map.old"

Definition at line 302 of file xlog.h.

◆ XLOG_INCLUDE_ORIGIN

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

Definition at line 152 of file xlog.h.

◆ XLOG_MARK_UNIMPORTANT

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

Definition at line 153 of file xlog.h.

◆ XLogArchivingActive

Definition at line 97 of file xlog.h.

◆ XLogArchivingAlways

Definition at line 100 of file xlog.h.

◆ XLogHintBitIsNeeded

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

Definition at line 118 of file xlog.h.

◆ XLogIsNeeded

#define XLogIsNeeded ( )    (wal_level >= WAL_LEVEL_REPLICA)

Definition at line 107 of file xlog.h.

◆ XLogLogicalInfoActive

#define XLogLogicalInfoActive ( )    (wal_level >= WAL_LEVEL_LOGICAL)

Definition at line 124 of file xlog.h.

◆ XLogStandbyInfoActive

#define XLogStandbyInfoActive ( )    (wal_level >= WAL_LEVEL_REPLICA)

Definition at line 121 of file xlog.h.

Typedef Documentation

◆ ArchiveMode

typedef enum ArchiveMode ArchiveMode

◆ CheckpointStatsData

◆ RecoveryState

◆ SessionBackupState

◆ WALAvailability

◆ WalCompression

◆ WalLevel

typedef enum WalLevel WalLevel

◆ WalSyncMethod

Enumeration Type Documentation

◆ ArchiveMode

Enumerator
ARCHIVE_MODE_OFF 
ARCHIVE_MODE_ON 
ARCHIVE_MODE_ALWAYS 

Definition at line 61 of file xlog.h.

62 {
63  ARCHIVE_MODE_OFF = 0, /* disabled */
64  ARCHIVE_MODE_ON, /* enabled while server is running normally */
65  ARCHIVE_MODE_ALWAYS, /* enabled always (even during recovery) */
66 } ArchiveMode;
ArchiveMode
Definition: xlog.h:62
@ ARCHIVE_MODE_ALWAYS
Definition: xlog.h:65
@ ARCHIVE_MODE_OFF
Definition: xlog.h:63
@ ARCHIVE_MODE_ON
Definition: xlog.h:64

◆ RecoveryState

Enumerator
RECOVERY_STATE_CRASH 
RECOVERY_STATE_ARCHIVE 
RECOVERY_STATE_DONE 

Definition at line 87 of file xlog.h.

88 {
89  RECOVERY_STATE_CRASH = 0, /* crash recovery */
90  RECOVERY_STATE_ARCHIVE, /* archive recovery */
91  RECOVERY_STATE_DONE, /* currently in production */
RecoveryState
Definition: xlog.h:88
@ RECOVERY_STATE_CRASH
Definition: xlog.h:89
@ RECOVERY_STATE_DONE
Definition: xlog.h:91
@ RECOVERY_STATE_ARCHIVE
Definition: xlog.h:90

◆ SessionBackupState

Enumerator
SESSION_BACKUP_NONE 
SESSION_BACKUP_RUNNING 

Definition at line 281 of file xlog.h.

284 {
@ SESSION_BACKUP_NONE
Definition: xlog.h:283

◆ WALAvailability

Enumerator
WALAVAIL_INVALID_LSN 
WALAVAIL_RESERVED 
WALAVAIL_EXTENDED 
WALAVAIL_UNRESERVED 
WALAVAIL_REMOVED 

Definition at line 184 of file xlog.h.

187 {
188  WALAVAIL_INVALID_LSN, /* parameter error */
189  WALAVAIL_RESERVED, /* WAL segment is within max_wal_size */
190  WALAVAIL_EXTENDED, /* WAL segment is reserved by a slot or
191  * wal_keep_size */
192  WALAVAIL_UNRESERVED, /* no longer reserved, but not removed yet */
@ WALAVAIL_RESERVED
Definition: xlog.h:187
@ WALAVAIL_UNRESERVED
Definition: xlog.h:190
@ WALAVAIL_EXTENDED
Definition: xlog.h:188
@ WALAVAIL_INVALID_LSN
Definition: xlog.h:186

◆ WalCompression

Enumerator
WAL_COMPRESSION_NONE 
WAL_COMPRESSION_PGLZ 
WAL_COMPRESSION_LZ4 
WAL_COMPRESSION_ZSTD 

Definition at line 78 of file xlog.h.

79 {
WalCompression
Definition: xlog.h:79
@ WAL_COMPRESSION_NONE
Definition: xlog.h:80
@ WAL_COMPRESSION_LZ4
Definition: xlog.h:82
@ WAL_COMPRESSION_PGLZ
Definition: xlog.h:81
@ WAL_COMPRESSION_ZSTD
Definition: xlog.h:83

◆ WalLevel

enum WalLevel
Enumerator
WAL_LEVEL_MINIMAL 
WAL_LEVEL_REPLICA 
WAL_LEVEL_LOGICAL 

Definition at line 70 of file xlog.h.

71 {
75 } WalLevel;
WalLevel
Definition: xlog.h:71
@ WAL_LEVEL_REPLICA
Definition: xlog.h:73
@ WAL_LEVEL_LOGICAL
Definition: xlog.h:74
@ WAL_LEVEL_MINIMAL
Definition: xlog.h:72

◆ WalSyncMethod

Enumerator
WAL_SYNC_METHOD_FSYNC 
WAL_SYNC_METHOD_FDATASYNC 
WAL_SYNC_METHOD_OPEN 
WAL_SYNC_METHOD_FSYNC_WRITETHROUGH 
WAL_SYNC_METHOD_OPEN_DSYNC 

Definition at line 22 of file xlog.h.

23 {
26  WAL_SYNC_METHOD_OPEN, /* for O_SYNC */
28  WAL_SYNC_METHOD_OPEN_DSYNC /* for O_DSYNC */
WalSyncMethod
Definition: xlog.h:23
@ WAL_SYNC_METHOD_OPEN
Definition: xlog.h:26
@ WAL_SYNC_METHOD_FDATASYNC
Definition: xlog.h:25
@ WAL_SYNC_METHOD_FSYNC_WRITETHROUGH
Definition: xlog.h:27
@ WAL_SYNC_METHOD_OPEN_DSYNC
Definition: xlog.h:28
@ WAL_SYNC_METHOD_FSYNC
Definition: xlog.h:24

Function Documentation

◆ BootStrapXLOG()

void BootStrapXLOG ( void  )

Definition at line 5000 of file xlog.c.

5001 {
5002  CheckPoint checkPoint;
5003  char *buffer;
5004  XLogPageHeader page;
5005  XLogLongPageHeader longpage;
5006  XLogRecord *record;
5007  char *recptr;
5008  uint64 sysidentifier;
5009  struct timeval tv;
5010  pg_crc32c crc;
5011 
5012  /* allow ordinary WAL segment creation, like StartupXLOG() would */
5014 
5015  /*
5016  * Select a hopefully-unique system identifier code for this installation.
5017  * We use the result of gettimeofday(), including the fractional seconds
5018  * field, as being about as unique as we can easily get. (Think not to
5019  * use random(), since it hasn't been seeded and there's no portable way
5020  * to seed it other than the system clock value...) The upper half of the
5021  * uint64 value is just the tv_sec part, while the lower half contains the
5022  * tv_usec part (which must fit in 20 bits), plus 12 bits from our current
5023  * PID for a little extra uniqueness. A person knowing this encoding can
5024  * determine the initialization time of the installation, which could
5025  * perhaps be useful sometimes.
5026  */
5027  gettimeofday(&tv, NULL);
5028  sysidentifier = ((uint64) tv.tv_sec) << 32;
5029  sysidentifier |= ((uint64) tv.tv_usec) << 12;
5030  sysidentifier |= getpid() & 0xFFF;
5031 
5032  /* page buffer must be aligned suitably for O_DIRECT */
5033  buffer = (char *) palloc(XLOG_BLCKSZ + XLOG_BLCKSZ);
5034  page = (XLogPageHeader) TYPEALIGN(XLOG_BLCKSZ, buffer);
5035  memset(page, 0, XLOG_BLCKSZ);
5036 
5037  /*
5038  * Set up information for the initial checkpoint record
5039  *
5040  * The initial checkpoint record is written to the beginning of the WAL
5041  * segment with logid=0 logseg=1. The very first WAL segment, 0/0, is not
5042  * used, so that we can use 0/0 to mean "before any valid WAL segment".
5043  */
5044  checkPoint.redo = wal_segment_size + SizeOfXLogLongPHD;
5045  checkPoint.ThisTimeLineID = BootstrapTimeLineID;
5046  checkPoint.PrevTimeLineID = BootstrapTimeLineID;
5047  checkPoint.fullPageWrites = fullPageWrites;
5048  checkPoint.nextXid =
5050  checkPoint.nextOid = FirstGenbkiObjectId;
5051  checkPoint.nextMulti = FirstMultiXactId;
5052  checkPoint.nextMultiOffset = 0;
5053  checkPoint.oldestXid = FirstNormalTransactionId;
5054  checkPoint.oldestXidDB = Template1DbOid;
5055  checkPoint.oldestMulti = FirstMultiXactId;
5056  checkPoint.oldestMultiDB = Template1DbOid;
5059  checkPoint.time = (pg_time_t) time(NULL);
5061 
5062  TransamVariables->nextXid = checkPoint.nextXid;
5063  TransamVariables->nextOid = checkPoint.nextOid;
5065  MultiXactSetNextMXact(checkPoint.nextMulti, checkPoint.nextMultiOffset);
5066  AdvanceOldestClogXid(checkPoint.oldestXid);
5067  SetTransactionIdLimit(checkPoint.oldestXid, checkPoint.oldestXidDB);
5068  SetMultiXactIdLimit(checkPoint.oldestMulti, checkPoint.oldestMultiDB, true);
5070 
5071  /* Set up the XLOG page header */
5072  page->xlp_magic = XLOG_PAGE_MAGIC;
5073  page->xlp_info = XLP_LONG_HEADER;
5074  page->xlp_tli = BootstrapTimeLineID;
5076  longpage = (XLogLongPageHeader) page;
5077  longpage->xlp_sysid = sysidentifier;
5078  longpage->xlp_seg_size = wal_segment_size;
5079  longpage->xlp_xlog_blcksz = XLOG_BLCKSZ;
5080 
5081  /* Insert the initial checkpoint record */
5082  recptr = ((char *) page + SizeOfXLogLongPHD);
5083  record = (XLogRecord *) recptr;
5084  record->xl_prev = 0;
5085  record->xl_xid = InvalidTransactionId;
5086  record->xl_tot_len = SizeOfXLogRecord + SizeOfXLogRecordDataHeaderShort + sizeof(checkPoint);
5088  record->xl_rmid = RM_XLOG_ID;
5089  recptr += SizeOfXLogRecord;
5090  /* fill the XLogRecordDataHeaderShort struct */
5091  *(recptr++) = (char) XLR_BLOCK_ID_DATA_SHORT;
5092  *(recptr++) = sizeof(checkPoint);
5093  memcpy(recptr, &checkPoint, sizeof(checkPoint));
5094  recptr += sizeof(checkPoint);
5095  Assert(recptr - (char *) record == record->xl_tot_len);
5096 
5097  INIT_CRC32C(crc);
5098  COMP_CRC32C(crc, ((char *) record) + SizeOfXLogRecord, record->xl_tot_len - SizeOfXLogRecord);
5099  COMP_CRC32C(crc, (char *) record, offsetof(XLogRecord, xl_crc));
5100  FIN_CRC32C(crc);
5101  record->xl_crc = crc;
5102 
5103  /* Create first XLOG segment file */
5106 
5107  /*
5108  * We needn't bother with Reserve/ReleaseExternalFD here, since we'll
5109  * close the file again in a moment.
5110  */
5111 
5112  /* Write the first page with the initial record */
5113  errno = 0;
5114  pgstat_report_wait_start(WAIT_EVENT_WAL_BOOTSTRAP_WRITE);
5115  if (write(openLogFile, page, XLOG_BLCKSZ) != XLOG_BLCKSZ)
5116  {
5117  /* if write didn't set errno, assume problem is no disk space */
5118  if (errno == 0)
5119  errno = ENOSPC;
5120  ereport(PANIC,
5122  errmsg("could not write bootstrap write-ahead log file: %m")));
5123  }
5125 
5126  pgstat_report_wait_start(WAIT_EVENT_WAL_BOOTSTRAP_SYNC);
5127  if (pg_fsync(openLogFile) != 0)
5128  ereport(PANIC,
5130  errmsg("could not fsync bootstrap write-ahead log file: %m")));
5132 
5133  if (close(openLogFile) != 0)
5134  ereport(PANIC,
5136  errmsg("could not close bootstrap write-ahead log file: %m")));
5137 
5138  openLogFile = -1;
5139 
5140  /* Now create pg_control */
5141  InitControlFile(sysidentifier);
5142  ControlFile->time = checkPoint.time;
5143  ControlFile->checkPoint = checkPoint.redo;
5144  ControlFile->checkPointCopy = checkPoint;
5145 
5146  /* some additional ControlFile fields are set in WriteControlFile() */
5147  WriteControlFile();
5148 
5149  /* Bootstrap the commit log, too */
5150  BootStrapCLOG();
5154 
5155  pfree(buffer);
5156 
5157  /*
5158  * Force control file to be read - in contrast to normal processing we'd
5159  * otherwise never run the checks and GUC related initializations therein.
5160  */
5161  ReadControlFile();
5162 }
#define TYPEALIGN(ALIGNVAL, LEN)
Definition: c.h:804
#define Assert(condition)
Definition: c.h:858
void BootStrapCLOG(void)
Definition: clog.c:833
void BootStrapCommitTs(void)
Definition: commit_ts.c:596
void SetCommitTsLimit(TransactionId oldestXact, TransactionId newestXact)
Definition: commit_ts.c:909
int errcode_for_file_access(void)
Definition: elog.c:882
int errmsg(const char *fmt,...)
Definition: elog.c:1072
#define PANIC
Definition: elog.h:42
#define ereport(elevel,...)
Definition: elog.h:149
int pg_fsync(int fd)
Definition: fd.c:386
#define close(a)
Definition: win32.h:12
#define write(a, b, c)
Definition: win32.h:14
void pfree(void *pointer)
Definition: mcxt.c:1520
void * palloc(Size size)
Definition: mcxt.c:1316
void MultiXactSetNextMXact(MultiXactId nextMulti, MultiXactOffset nextMultiOffset)
Definition: multixact.c:2279
void SetMultiXactIdLimit(MultiXactId oldest_datminmxid, Oid oldest_datoid, bool is_startup)
Definition: multixact.c:2313
void BootStrapMultiXact(void)
Definition: multixact.c:1985
#define FirstMultiXactId
Definition: multixact.h:25
#define XLOG_CHECKPOINT_SHUTDOWN
Definition: pg_control.h:67
uint32 pg_crc32c
Definition: pg_crc32c.h:38
#define COMP_CRC32C(crc, data, len)
Definition: pg_crc32c.h:98
#define INIT_CRC32C(crc)
Definition: pg_crc32c.h:41
#define FIN_CRC32C(crc)
Definition: pg_crc32c.h:103
return crc
int64 pg_time_t
Definition: pgtime.h:23
Oid oldestMultiDB
Definition: pg_control.h:50
MultiXactId oldestMulti
Definition: pg_control.h:49
MultiXactOffset nextMultiOffset
Definition: pg_control.h:46
TransactionId newestCommitTsXid
Definition: pg_control.h:54
TransactionId oldestXid
Definition: pg_control.h:47
TimeLineID PrevTimeLineID
Definition: pg_control.h:40
TimeLineID ThisTimeLineID
Definition: pg_control.h:39
Oid nextOid
Definition: pg_control.h:44
TransactionId oldestActiveXid
Definition: pg_control.h:63
bool fullPageWrites
Definition: pg_control.h:42
MultiXactId nextMulti
Definition: pg_control.h:45
FullTransactionId nextXid
Definition: pg_control.h:43
TransactionId oldestCommitTsXid
Definition: pg_control.h:52
pg_time_t time
Definition: pg_control.h:51
XLogRecPtr redo
Definition: pg_control.h:37
Oid oldestXidDB
Definition: pg_control.h:48
CheckPoint checkPointCopy
Definition: pg_control.h:134
pg_time_t time
Definition: pg_control.h:131
XLogRecPtr checkPoint
Definition: pg_control.h:132
FullTransactionId nextXid
Definition: transam.h:220
TimeLineID xlp_tli
Definition: xlog_internal.h:40
XLogRecPtr xlp_pageaddr
Definition: xlog_internal.h:41
XLogRecPtr xl_prev
Definition: xlogrecord.h:45
uint8 xl_info
Definition: xlogrecord.h:46
uint32 xl_tot_len
Definition: xlogrecord.h:43
TransactionId xl_xid
Definition: xlogrecord.h:44
RmgrId xl_rmid
Definition: xlogrecord.h:47
void BootStrapSUBTRANS(void)
Definition: subtrans.c:270
#define InvalidTransactionId
Definition: transam.h:31
#define FirstGenbkiObjectId
Definition: transam.h:195
#define FirstNormalTransactionId
Definition: transam.h:34
static FullTransactionId FullTransactionIdFromEpochAndXid(uint32 epoch, TransactionId xid)
Definition: transam.h:71
void SetTransactionIdLimit(TransactionId oldest_datfrozenxid, Oid oldest_datoid)
Definition: varsup.c:372
void AdvanceOldestClogXid(TransactionId oldest_datfrozenxid)
Definition: varsup.c:355
TransamVariablesData * TransamVariables
Definition: varsup.c:34
static void pgstat_report_wait_start(uint32 wait_event_info)
Definition: wait_event.h:88
static void pgstat_report_wait_end(void)
Definition: wait_event.h:104
int gettimeofday(struct timeval *tp, void *tzp)
int XLogFileInit(XLogSegNo logsegno, TimeLineID logtli)
Definition: xlog.c:3369
bool fullPageWrites
Definition: xlog.c:122
static void InitControlFile(uint64 sysidentifier)
Definition: xlog.c:4193
void SetInstallXLogFileSegmentActive(void)
Definition: xlog.c:9404
static int openLogFile
Definition: xlog.c:630
static void WriteControlFile(void)
Definition: xlog.c:4228
int wal_segment_size
Definition: xlog.c:143
static TimeLineID openLogTLI
Definition: xlog.c:632
static ControlFileData * ControlFile
Definition: xlog.c:569
#define BootstrapTimeLineID
Definition: xlog.c:111
static void ReadControlFile(void)
Definition: xlog.c:4310
XLogLongPageHeaderData * XLogLongPageHeader
Definition: xlog_internal.h:71
XLogPageHeaderData * XLogPageHeader
Definition: xlog_internal.h:54
#define XLP_LONG_HEADER
Definition: xlog_internal.h:76
#define XLOG_PAGE_MAGIC
Definition: xlog_internal.h:34
#define SizeOfXLogLongPHD
Definition: xlog_internal.h:69
#define SizeOfXLogRecordDataHeaderShort
Definition: xlogrecord.h:217
#define XLR_BLOCK_ID_DATA_SHORT
Definition: xlogrecord.h:241
#define SizeOfXLogRecord
Definition: xlogrecord.h:55

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, TransamVariablesData::nextOid, CheckPoint::nextOid, TransamVariablesData::nextXid, CheckPoint::nextXid, TransamVariablesData::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(), SizeOfXLogLongPHD, SizeOfXLogRecord, SizeOfXLogRecordDataHeaderShort, CheckPoint::ThisTimeLineID, CheckPoint::time, ControlFileData::time, TransamVariables, TYPEALIGN, 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 3716 of file xlog.c.

3717 {
3718  int save_errno = errno;
3719  XLogSegNo lastRemovedSegNo;
3720 
3722  lastRemovedSegNo = XLogCtl->lastRemovedSegNo;
3724 
3725  if (segno <= lastRemovedSegNo)
3726  {
3727  char filename[MAXFNAMELEN];
3728 
3729  XLogFileName(filename, tli, segno, wal_segment_size);
3730  errno = save_errno;
3731  ereport(ERROR,
3733  errmsg("requested WAL segment %s has already been removed",
3734  filename)));
3735  }
3736  errno = save_errno;
3737 }
#define ERROR
Definition: elog.h:39
static char * filename
Definition: pg_dumpall.c:119
#define SpinLockRelease(lock)
Definition: spin.h:64
#define SpinLockAcquire(lock)
Definition: spin.h:62
slock_t info_lck
Definition: xlog.c:548
XLogSegNo lastRemovedSegNo
Definition: xlog.c:461
static XLogCtlData * XLogCtl
Definition: xlog.c:561
#define MAXFNAMELEN
static void XLogFileName(char *fname, TimeLineID tli, XLogSegNo logSegNo, int wal_segsz_bytes)
uint64 XLogSegNo
Definition: xlogdefs.h:48

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 6821 of file xlog.c.

6822 {
6823  bool shutdown;
6824  CheckPoint checkPoint;
6825  XLogRecPtr recptr;
6826  XLogSegNo _logSegNo;
6828  uint32 freespace;
6829  XLogRecPtr PriorRedoPtr;
6830  XLogRecPtr last_important_lsn;
6831  VirtualTransactionId *vxids;
6832  int nvxids;
6833  int oldXLogAllowed = 0;
6834 
6835  /*
6836  * An end-of-recovery checkpoint is really a shutdown checkpoint, just
6837  * issued at a different time.
6838  */
6840  shutdown = true;
6841  else
6842  shutdown = false;
6843 
6844  /* sanity check */
6845  if (RecoveryInProgress() && (flags & CHECKPOINT_END_OF_RECOVERY) == 0)
6846  elog(ERROR, "can't create a checkpoint during recovery");
6847 
6848  /*
6849  * Prepare to accumulate statistics.
6850  *
6851  * Note: because it is possible for log_checkpoints to change while a
6852  * checkpoint proceeds, we always accumulate stats, even if
6853  * log_checkpoints is currently off.
6854  */
6855  MemSet(&CheckpointStats, 0, sizeof(CheckpointStats));
6857 
6858  /*
6859  * Let smgr prepare for checkpoint; this has to happen outside the
6860  * critical section and before we determine the REDO pointer. Note that
6861  * smgr must not do anything that'd have to be undone if we decide no
6862  * checkpoint is needed.
6863  */
6865 
6866  /*
6867  * Use a critical section to force system panic if we have trouble.
6868  */
6870 
6871  if (shutdown)
6872  {
6873  LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
6876  LWLockRelease(ControlFileLock);
6877  }
6878 
6879  /* Begin filling in the checkpoint WAL record */
6880  MemSet(&checkPoint, 0, sizeof(checkPoint));
6881  checkPoint.time = (pg_time_t) time(NULL);
6882 
6883  /*
6884  * For Hot Standby, derive the oldestActiveXid before we fix the redo
6885  * pointer. This allows us to begin accumulating changes to assemble our
6886  * starting snapshot of locks and transactions.
6887  */
6888  if (!shutdown && XLogStandbyInfoActive())
6890  else
6892 
6893  /*
6894  * Get location of last important record before acquiring insert locks (as
6895  * GetLastImportantRecPtr() also locks WAL locks).
6896  */
6897  last_important_lsn = GetLastImportantRecPtr();
6898 
6899  /*
6900  * If this isn't a shutdown or forced checkpoint, and if there has been no
6901  * WAL activity requiring a checkpoint, skip it. The idea here is to
6902  * avoid inserting duplicate checkpoints when the system is idle.
6903  */
6905  CHECKPOINT_FORCE)) == 0)
6906  {
6907  if (last_important_lsn == ControlFile->checkPoint)
6908  {
6909  END_CRIT_SECTION();
6910  ereport(DEBUG1,
6911  (errmsg_internal("checkpoint skipped because system is idle")));
6912  return;
6913  }
6914  }
6915 
6916  /*
6917  * An end-of-recovery checkpoint is created before anyone is allowed to
6918  * write WAL. To allow us to write the checkpoint record, temporarily
6919  * enable XLogInsertAllowed.
6920  */
6921  if (flags & CHECKPOINT_END_OF_RECOVERY)
6922  oldXLogAllowed = LocalSetXLogInsertAllowed();
6923 
6924  checkPoint.ThisTimeLineID = XLogCtl->InsertTimeLineID;
6925  if (flags & CHECKPOINT_END_OF_RECOVERY)
6926  checkPoint.PrevTimeLineID = XLogCtl->PrevTimeLineID;
6927  else
6928  checkPoint.PrevTimeLineID = checkPoint.ThisTimeLineID;
6929 
6930  /*
6931  * We must block concurrent insertions while examining insert state.
6932  */
6934 
6935  checkPoint.fullPageWrites = Insert->fullPageWrites;
6936 
6937  if (shutdown)
6938  {
6939  XLogRecPtr curInsert = XLogBytePosToRecPtr(Insert->CurrBytePos);
6940 
6941  /*
6942  * Compute new REDO record ptr = location of next XLOG record.
6943  *
6944  * Since this is a shutdown checkpoint, there can't be any concurrent
6945  * WAL insertion.
6946  */
6947  freespace = INSERT_FREESPACE(curInsert);
6948  if (freespace == 0)
6949  {
6950  if (XLogSegmentOffset(curInsert, wal_segment_size) == 0)
6951  curInsert += SizeOfXLogLongPHD;
6952  else
6953  curInsert += SizeOfXLogShortPHD;
6954  }
6955  checkPoint.redo = curInsert;
6956 
6957  /*
6958  * Here we update the shared RedoRecPtr for future XLogInsert calls;
6959  * this must be done while holding all the insertion locks.
6960  *
6961  * Note: if we fail to complete the checkpoint, RedoRecPtr will be
6962  * left pointing past where it really needs to point. This is okay;
6963  * the only consequence is that XLogInsert might back up whole buffers
6964  * that it didn't really need to. We can't postpone advancing
6965  * RedoRecPtr because XLogInserts that happen while we are dumping
6966  * buffers must assume that their buffer changes are not included in
6967  * the checkpoint.
6968  */
6969  RedoRecPtr = XLogCtl->Insert.RedoRecPtr = checkPoint.redo;
6970  }
6971 
6972  /*
6973  * Now we can release the WAL insertion locks, allowing other xacts to
6974  * proceed while we are flushing disk buffers.
6975  */
6977 
6978  /*
6979  * If this is an online checkpoint, we have not yet determined the redo
6980  * point. We do so now by inserting the special XLOG_CHECKPOINT_REDO
6981  * record; the LSN at which it starts becomes the new redo pointer. We
6982  * don't do this for a shutdown checkpoint, because in that case no WAL
6983  * can be written between the redo point and the insertion of the
6984  * checkpoint record itself, so the checkpoint record itself serves to
6985  * mark the redo point.
6986  */
6987  if (!shutdown)
6988  {
6989  int dummy = 0;
6990 
6991  /* Record must have payload to avoid assertion failure. */
6992  XLogBeginInsert();
6993  XLogRegisterData((char *) &dummy, sizeof(dummy));
6994  (void) XLogInsert(RM_XLOG_ID, XLOG_CHECKPOINT_REDO);
6995 
6996  /*
6997  * XLogInsertRecord will have updated XLogCtl->Insert.RedoRecPtr in
6998  * shared memory and RedoRecPtr in backend-local memory, but we need
6999  * to copy that into the record that will be inserted when the
7000  * checkpoint is complete.
7001  */
7002  checkPoint.redo = RedoRecPtr;
7003  }
7004 
7005  /* Update the info_lck-protected copy of RedoRecPtr as well */
7007  XLogCtl->RedoRecPtr = checkPoint.redo;
7009 
7010  /*
7011  * If enabled, log checkpoint start. We postpone this until now so as not
7012  * to log anything if we decided to skip the checkpoint.
7013  */
7014  if (log_checkpoints)
7015  LogCheckpointStart(flags, false);
7016 
7017  /* Update the process title */
7018  update_checkpoint_display(flags, false, false);
7019 
7020  TRACE_POSTGRESQL_CHECKPOINT_START(flags);
7021 
7022  /*
7023  * Get the other info we need for the checkpoint record.
7024  *
7025  * We don't need to save oldestClogXid in the checkpoint, it only matters
7026  * for the short period in which clog is being truncated, and if we crash
7027  * during that we'll redo the clog truncation and fix up oldestClogXid
7028  * there.
7029  */
7030  LWLockAcquire(XidGenLock, LW_SHARED);
7031  checkPoint.nextXid = TransamVariables->nextXid;
7032  checkPoint.oldestXid = TransamVariables->oldestXid;
7034  LWLockRelease(XidGenLock);
7035 
7036  LWLockAcquire(CommitTsLock, LW_SHARED);
7039  LWLockRelease(CommitTsLock);
7040 
7041  LWLockAcquire(OidGenLock, LW_SHARED);
7042  checkPoint.nextOid = TransamVariables->nextOid;
7043  if (!shutdown)
7044  checkPoint.nextOid += TransamVariables->oidCount;
7045  LWLockRelease(OidGenLock);
7046 
7047  MultiXactGetCheckptMulti(shutdown,
7048  &checkPoint.nextMulti,
7049  &checkPoint.nextMultiOffset,
7050  &checkPoint.oldestMulti,
7051  &checkPoint.oldestMultiDB);
7052 
7053  /*
7054  * Having constructed the checkpoint record, ensure all shmem disk buffers
7055  * and commit-log buffers are flushed to disk.
7056  *
7057  * This I/O could fail for various reasons. If so, we will fail to
7058  * complete the checkpoint, but there is no reason to force a system
7059  * panic. Accordingly, exit critical section while doing it.
7060  */
7061  END_CRIT_SECTION();
7062 
7063  /*
7064  * In some cases there are groups of actions that must all occur on one
7065  * side or the other of a checkpoint record. Before flushing the
7066  * checkpoint record we must explicitly wait for any backend currently
7067  * performing those groups of actions.
7068  *
7069  * One example is end of transaction, so we must wait for any transactions
7070  * that are currently in commit critical sections. If an xact inserted
7071  * its commit record into XLOG just before the REDO point, then a crash
7072  * restart from the REDO point would not replay that record, which means
7073  * that our flushing had better include the xact's update of pg_xact. So
7074  * we wait till he's out of his commit critical section before proceeding.
7075  * See notes in RecordTransactionCommit().
7076  *
7077  * Because we've already released the insertion locks, this test is a bit
7078  * fuzzy: it is possible that we will wait for xacts we didn't really need
7079  * to wait for. But the delay should be short and it seems better to make
7080  * checkpoint take a bit longer than to hold off insertions longer than
7081  * necessary. (In fact, the whole reason we have this issue is that xact.c
7082  * does commit record XLOG insertion and clog update as two separate steps
7083  * protected by different locks, but again that seems best on grounds of
7084  * minimizing lock contention.)
7085  *
7086  * A transaction that has not yet set delayChkptFlags when we look cannot
7087  * be at risk, since it has not inserted its commit record yet; and one
7088  * that's already cleared it is not at risk either, since it's done fixing
7089  * clog and we will correctly flush the update below. So we cannot miss
7090  * any xacts we need to wait for.
7091  */
7093  if (nvxids > 0)
7094  {
7095  do
7096  {
7097  pgstat_report_wait_start(WAIT_EVENT_CHECKPOINT_DELAY_START);
7098  pg_usleep(10000L); /* wait for 10 msec */
7100  } while (HaveVirtualXIDsDelayingChkpt(vxids, nvxids,
7102  }
7103  pfree(vxids);
7104 
7105  CheckPointGuts(checkPoint.redo, flags);
7106 
7108  if (nvxids > 0)
7109  {
7110  do
7111  {
7112  pgstat_report_wait_start(WAIT_EVENT_CHECKPOINT_DELAY_COMPLETE);
7113  pg_usleep(10000L); /* wait for 10 msec */
7115  } while (HaveVirtualXIDsDelayingChkpt(vxids, nvxids,
7117  }
7118  pfree(vxids);
7119 
7120  /*
7121  * Take a snapshot of running transactions and write this to WAL. This
7122  * allows us to reconstruct the state of running transactions during
7123  * archive recovery, if required. Skip, if this info disabled.
7124  *
7125  * If we are shutting down, or Startup process is completing crash
7126  * recovery we don't need to write running xact data.
7127  */
7128  if (!shutdown && XLogStandbyInfoActive())
7130 
7132 
7133  /*
7134  * Now insert the checkpoint record into XLOG.
7135  */
7136  XLogBeginInsert();
7137  XLogRegisterData((char *) (&checkPoint), sizeof(checkPoint));
7138  recptr = XLogInsert(RM_XLOG_ID,
7139  shutdown ? XLOG_CHECKPOINT_SHUTDOWN :
7141 
7142  XLogFlush(recptr);
7143 
7144  /*
7145  * We mustn't write any new WAL after a shutdown checkpoint, or it will be
7146  * overwritten at next startup. No-one should even try, this just allows
7147  * sanity-checking. In the case of an end-of-recovery checkpoint, we want
7148  * to just temporarily disable writing until the system has exited
7149  * recovery.
7150  */
7151  if (shutdown)
7152  {
7153  if (flags & CHECKPOINT_END_OF_RECOVERY)
7154  LocalXLogInsertAllowed = oldXLogAllowed;
7155  else
7156  LocalXLogInsertAllowed = 0; /* never again write WAL */
7157  }
7158 
7159  /*
7160  * We now have ProcLastRecPtr = start of actual checkpoint record, recptr
7161  * = end of actual checkpoint record.
7162  */
7163  if (shutdown && checkPoint.redo != ProcLastRecPtr)
7164  ereport(PANIC,
7165  (errmsg("concurrent write-ahead log activity while database system is shutting down")));
7166 
7167  /*
7168  * Remember the prior checkpoint's redo ptr for
7169  * UpdateCheckPointDistanceEstimate()
7170  */
7171  PriorRedoPtr = ControlFile->checkPointCopy.redo;
7172 
7173  /*
7174  * Update the control file.
7175  */
7176  LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
7177  if (shutdown)
7180  ControlFile->checkPointCopy = checkPoint;
7181  /* crash recovery should always recover to the end of WAL */
7184 
7185  /*
7186  * Persist unloggedLSN value. It's reset on crash recovery, so this goes
7187  * unused on non-shutdown checkpoints, but seems useful to store it always
7188  * for debugging purposes.
7189  */
7191 
7193  LWLockRelease(ControlFileLock);
7194 
7195  /* Update shared-memory copy of checkpoint XID/epoch */
7197  XLogCtl->ckptFullXid = checkPoint.nextXid;
7199 
7200  /*
7201  * We are now done with critical updates; no need for system panic if we
7202  * have trouble while fooling with old log segments.
7203  */
7204  END_CRIT_SECTION();
7205 
7206  /*
7207  * WAL summaries end when the next XLOG_CHECKPOINT_REDO or
7208  * XLOG_CHECKPOINT_SHUTDOWN record is reached. This is the first point
7209  * where (a) we're not inside of a critical section and (b) we can be
7210  * certain that the relevant record has been flushed to disk, which must
7211  * happen before it can be summarized.
7212  *
7213  * If this is a shutdown checkpoint, then this happens reasonably
7214  * promptly: we've only just inserted and flushed the
7215  * XLOG_CHECKPOINT_SHUTDOWN record. If this is not a shutdown checkpoint,
7216  * then this might not be very prompt at all: the XLOG_CHECKPOINT_REDO
7217  * record was written before we began flushing data to disk, and that
7218  * could be many minutes ago at this point. However, we don't XLogFlush()
7219  * after inserting that record, so we're not guaranteed that it's on disk
7220  * until after the above call that flushes the XLOG_CHECKPOINT_ONLINE
7221  * record.
7222  */
7224 
7225  /*
7226  * Let smgr do post-checkpoint cleanup (eg, deleting old files).
7227  */
7229 
7230  /*
7231  * Update the average distance between checkpoints if the prior checkpoint
7232  * exists.
7233  */
7234  if (PriorRedoPtr != InvalidXLogRecPtr)
7236 
7237  /*
7238  * Delete old log files, those no longer needed for last checkpoint to
7239  * prevent the disk holding the xlog from growing full.
7240  */
7242  KeepLogSeg(recptr, &_logSegNo);
7244  _logSegNo, InvalidOid,
7246  {
7247  /*
7248  * Some slots have been invalidated; recalculate the old-segment
7249  * horizon, starting again from RedoRecPtr.
7250  */
7252  KeepLogSeg(recptr, &_logSegNo);
7253  }
7254  _logSegNo--;
7255  RemoveOldXlogFiles(_logSegNo, RedoRecPtr, recptr,
7256  checkPoint.ThisTimeLineID);
7257 
7258  /*
7259  * Make more log segments if needed. (Do this after recycling old log
7260  * segments, since that may supply some of the needed files.)
7261  */
7262  if (!shutdown)
7263  PreallocXlogFiles(recptr, checkPoint.ThisTimeLineID);
7264 
7265  /*
7266  * Truncate pg_subtrans if possible. We can throw away all data before
7267  * the oldest XMIN of any running transaction. No future transaction will
7268  * attempt to reference any pg_subtrans entry older than that (see Asserts
7269  * in subtrans.c). During recovery, though, we mustn't do this because
7270  * StartupSUBTRANS hasn't been called yet.
7271  */
7272  if (!RecoveryInProgress())
7274 
7275  /* Real work is done; log and update stats. */
7276  LogCheckpointEnd(false);
7277 
7278  /* Reset the process title */
7279  update_checkpoint_display(flags, false, true);
7280 
7281  TRACE_POSTGRESQL_CHECKPOINT_DONE(CheckpointStats.ckpt_bufs_written,
7282  NBuffers,
7286 }
static uint64 pg_atomic_read_membarrier_u64(volatile pg_atomic_uint64 *ptr)
Definition: atomics.h:471
TimestampTz GetCurrentTimestamp(void)
Definition: timestamp.c:1654
unsigned int uint32
Definition: c.h:506
#define MemSet(start, val, len)
Definition: c.h:1020
int errmsg_internal(const char *fmt,...)
Definition: elog.c:1159
#define DEBUG1
Definition: elog.h:30
#define elog(elevel,...)
Definition: elog.h:224
static void Insert(File file)
Definition: fd.c:1313
int NBuffers
Definition: globals.c:139
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1170
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1783
@ LW_SHARED
Definition: lwlock.h:115
@ LW_EXCLUSIVE
Definition: lwlock.h:114
#define START_CRIT_SECTION()
Definition: miscadmin.h:149
#define END_CRIT_SECTION()
Definition: miscadmin.h:151
void MultiXactGetCheckptMulti(bool is_shutdown, MultiXactId *nextMulti, MultiXactOffset *nextMultiOffset, MultiXactId *oldestMulti, Oid *oldestMultiDB)
Definition: multixact.c:2233
#define XLOG_CHECKPOINT_REDO
Definition: pg_control.h:81
@ DB_SHUTDOWNING
Definition: pg_control.h:93
@ DB_SHUTDOWNED
Definition: pg_control.h:91
#define XLOG_CHECKPOINT_ONLINE
Definition: pg_control.h:68
#define InvalidOid
Definition: postgres_ext.h:36
#define DELAY_CHKPT_START
Definition: proc.h:114
#define DELAY_CHKPT_COMPLETE
Definition: proc.h:115
VirtualTransactionId * GetVirtualXIDsDelayingChkpt(int *nvxids, int type)
Definition: procarray.c:3030
TransactionId GetOldestActiveTransactionId(void)
Definition: procarray.c:2867
TransactionId GetOldestTransactionIdConsideredRunning(void)
Definition: procarray.c:2022
bool HaveVirtualXIDsDelayingChkpt(VirtualTransactionId *vxids, int nvxids, int type)
Definition: procarray.c:3076
void pg_usleep(long microsec)
Definition: signal.c:53
bool InvalidateObsoleteReplicationSlots(ReplicationSlotInvalidationCause cause, XLogSegNo oldestSegno, Oid dboid, TransactionId snapshotConflictHorizon)
Definition: slot.c:1779
@ RS_INVAL_WAL_REMOVED
Definition: slot.h:51
XLogRecPtr LogStandbySnapshot(void)
Definition: standby.c:1285
TimestampTz ckpt_start_t
Definition: xlog.h:159
int ckpt_segs_removed
Definition: xlog.h:168
int ckpt_segs_added
Definition: xlog.h:167
int ckpt_bufs_written
Definition: xlog.h:165
int ckpt_segs_recycled
Definition: xlog.h:169
XLogRecPtr minRecoveryPoint
Definition: pg_control.h:167
XLogRecPtr unloggedLSN
Definition: pg_control.h:136
TimeLineID minRecoveryPointTLI
Definition: pg_control.h:168
TransactionId oldestCommitTsXid
Definition: transam.h:232
TransactionId newestCommitTsXid
Definition: transam.h:233
TransactionId oldestXid
Definition: transam.h:222
FullTransactionId ckptFullXid
Definition: xlog.c:457
TimeLineID InsertTimeLineID
Definition: xlog.c:504
XLogRecPtr RedoRecPtr
Definition: xlog.c:456
XLogCtlInsert Insert
Definition: xlog.c:452
TimeLineID PrevTimeLineID
Definition: xlog.c:505
pg_atomic_uint64 unloggedLSN
Definition: xlog.c:464
XLogRecPtr RedoRecPtr
Definition: xlog.c:430
void TruncateSUBTRANS(TransactionId oldestXact)
Definition: subtrans.c:411
void SyncPreCheckpoint(void)
Definition: sync.c:177
void SyncPostCheckpoint(void)
Definition: sync.c:202
void SetWalSummarizerLatch(void)
XLogRecPtr ProcLastRecPtr
Definition: xlog.c:253
bool RecoveryInProgress(void)
Definition: xlog.c:6290
static void WALInsertLockRelease(void)
Definition: xlog.c:1440
static XLogRecPtr XLogBytePosToRecPtr(uint64 bytepos)
Definition: xlog.c:1853
static void WALInsertLockAcquireExclusive(void)
Definition: xlog.c:1411
static void UpdateControlFile(void)
Definition: xlog.c:4526
static void RemoveOldXlogFiles(XLogSegNo segno, XLogRecPtr lastredoptr, XLogRecPtr endptr, TimeLineID insertTLI)
Definition: xlog.c:3854
static void LogCheckpointStart(int flags, bool restartpoint)
Definition: xlog.c:6586
static XLogRecPtr RedoRecPtr
Definition: xlog.c:273
static void LogCheckpointEnd(bool restartpoint)
Definition: xlog.c:6618
static void PreallocXlogFiles(XLogRecPtr endptr, TimeLineID tli)
Definition: xlog.c:3679
bool log_checkpoints
Definition: xlog.c:129
static void KeepLogSeg(XLogRecPtr recptr, XLogSegNo *logSegNo)
Definition: xlog.c:7874
static int LocalSetXLogInsertAllowed(void)
Definition: xlog.c:6378
XLogRecPtr GetLastImportantRecPtr(void)
Definition: xlog.c:6493
static void UpdateCheckPointDistanceEstimate(uint64 nbytes)
Definition: xlog.c:6721
#define INSERT_FREESPACE(endptr)
Definition: xlog.c:575
static int LocalXLogInsertAllowed
Definition: xlog.c:236
CheckpointStatsData CheckpointStats
Definition: xlog.c:209
void XLogFlush(XLogRecPtr record)
Definition: xlog.c:2791
static void CheckPointGuts(XLogRecPtr checkPointRedo, int flags)
Definition: xlog.c:7431
static void update_checkpoint_display(int flags, bool restartpoint, bool reset)
Definition: xlog.c:6759
#define CHECKPOINT_END_OF_RECOVERY
Definition: xlog.h:138
#define CHECKPOINT_FORCE
Definition: xlog.h:140
#define CHECKPOINT_IS_SHUTDOWN
Definition: xlog.h:137
#define XLogStandbyInfoActive()
Definition: xlog.h:121
#define XLogSegmentOffset(xlogptr, wal_segsz_bytes)
#define XLByteToSeg(xlrp, logSegNo, wal_segsz_bytes)
#define SizeOfXLogShortPHD
Definition: xlog_internal.h:52
uint64 XLogRecPtr
Definition: xlogdefs.h:21
#define InvalidXLogRecPtr
Definition: xlogdefs.h:28
void XLogRegisterData(char *data, uint32 len)
Definition: xloginsert.c:364
XLogRecPtr XLogInsert(RmgrId rmid, uint8 info)
Definition: xloginsert.c:474
void XLogBeginInsert(void)
Definition: xloginsert.c:149

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(), InvalidOid, InvalidTransactionId, InvalidXLogRecPtr, KeepLogSeg(), LocalSetXLogInsertAllowed(), LocalXLogInsertAllowed, log_checkpoints, LogCheckpointEnd(), LogCheckpointStart(), LogStandbySnapshot(), LW_EXCLUSIVE, LW_SHARED, LWLockAcquire(), LWLockRelease(), MemSet, ControlFileData::minRecoveryPoint, ControlFileData::minRecoveryPointTLI, MultiXactGetCheckptMulti(), NBuffers, TransamVariablesData::newestCommitTsXid, CheckPoint::newestCommitTsXid, CheckPoint::nextMulti, CheckPoint::nextMultiOffset, TransamVariablesData::nextOid, CheckPoint::nextOid, TransamVariablesData::nextXid, CheckPoint::nextXid, TransamVariablesData::oidCount, CheckPoint::oldestActiveXid, TransamVariablesData::oldestCommitTsXid, CheckPoint::oldestCommitTsXid, CheckPoint::oldestMulti, CheckPoint::oldestMultiDB, TransamVariablesData::oldestXid, CheckPoint::oldestXid, TransamVariablesData::oldestXidDB, CheckPoint::oldestXidDB, PANIC, pfree(), pg_atomic_read_membarrier_u64(), pg_usleep(), pgstat_report_wait_end(), pgstat_report_wait_start(), PreallocXlogFiles(), XLogCtlData::PrevTimeLineID, CheckPoint::PrevTimeLineID, ProcLastRecPtr, RecoveryInProgress(), CheckPoint::redo, RedoRecPtr, XLogCtlInsert::RedoRecPtr, XLogCtlData::RedoRecPtr, RemoveOldXlogFiles(), RS_INVAL_WAL_REMOVED, SetWalSummarizerLatch(), SizeOfXLogLongPHD, SizeOfXLogShortPHD, SpinLockAcquire, SpinLockRelease, START_CRIT_SECTION, ControlFileData::state, SyncPostCheckpoint(), SyncPreCheckpoint(), CheckPoint::ThisTimeLineID, CheckPoint::time, TransamVariables, TruncateSUBTRANS(), XLogCtlData::unloggedLSN, ControlFileData::unloggedLSN, update_checkpoint_display(), UpdateCheckPointDistanceEstimate(), UpdateControlFile(), wal_segment_size, WALInsertLockAcquireExclusive(), WALInsertLockRelease(), XLByteToSeg, XLOG_CHECKPOINT_ONLINE, XLOG_CHECKPOINT_REDO, 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 7512 of file xlog.c.

7513 {
7514  XLogRecPtr lastCheckPointRecPtr;
7515  XLogRecPtr lastCheckPointEndPtr;
7516  CheckPoint lastCheckPoint;
7517  XLogRecPtr PriorRedoPtr;
7518  XLogRecPtr receivePtr;
7519  XLogRecPtr replayPtr;
7520  TimeLineID replayTLI;
7521  XLogRecPtr endptr;
7522  XLogSegNo _logSegNo;
7523  TimestampTz xtime;
7524 
7525  /* Concurrent checkpoint/restartpoint cannot happen */
7527 
7528  /* Get a local copy of the last safe checkpoint record. */
7530  lastCheckPointRecPtr = XLogCtl->lastCheckPointRecPtr;
7531  lastCheckPointEndPtr = XLogCtl->lastCheckPointEndPtr;
7532  lastCheckPoint = XLogCtl->lastCheckPoint;
7534 
7535  /*
7536  * Check that we're still in recovery mode. It's ok if we exit recovery
7537  * mode after this check, the restart point is valid anyway.
7538  */
7539  if (!RecoveryInProgress())
7540  {
7541  ereport(DEBUG2,
7542  (errmsg_internal("skipping restartpoint, recovery has already ended")));
7543  return false;
7544  }
7545 
7546  /*
7547  * If the last checkpoint record we've replayed is already our last
7548  * restartpoint, we can't perform a new restart point. We still update
7549  * minRecoveryPoint in that case, so that if this is a shutdown restart
7550  * point, we won't start up earlier than before. That's not strictly
7551  * necessary, but when hot standby is enabled, it would be rather weird if
7552  * the database opened up for read-only connections at a point-in-time
7553  * before the last shutdown. Such time travel is still possible in case of
7554  * immediate shutdown, though.
7555  *
7556  * We don't explicitly advance minRecoveryPoint when we do create a
7557  * restartpoint. It's assumed that flushing the buffers will do that as a
7558  * side-effect.
7559  */
7560  if (XLogRecPtrIsInvalid(lastCheckPointRecPtr) ||
7561  lastCheckPoint.redo <= ControlFile->checkPointCopy.redo)
7562  {
7563  ereport(DEBUG2,
7564  (errmsg_internal("skipping restartpoint, already performed at %X/%X",
7565  LSN_FORMAT_ARGS(lastCheckPoint.redo))));
7566 
7568  if (flags & CHECKPOINT_IS_SHUTDOWN)
7569  {
7570  LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
7573  LWLockRelease(ControlFileLock);
7574  }
7575  return false;
7576  }
7577 
7578  /*
7579  * Update the shared RedoRecPtr so that the startup process can calculate
7580  * the number of segments replayed since last restartpoint, and request a
7581  * restartpoint if it exceeds CheckPointSegments.
7582  *
7583  * Like in CreateCheckPoint(), hold off insertions to update it, although
7584  * during recovery this is just pro forma, because no WAL insertions are
7585  * happening.
7586  */
7588  RedoRecPtr = XLogCtl->Insert.RedoRecPtr = lastCheckPoint.redo;
7590 
7591  /* Also update the info_lck-protected copy */
7593  XLogCtl->RedoRecPtr = lastCheckPoint.redo;
7595 
7596  /*
7597  * Prepare to accumulate statistics.
7598  *
7599  * Note: because it is possible for log_checkpoints to change while a
7600  * checkpoint proceeds, we always accumulate stats, even if
7601  * log_checkpoints is currently off.
7602  */
7603  MemSet(&CheckpointStats, 0, sizeof(CheckpointStats));
7605 
7606  if (log_checkpoints)
7607  LogCheckpointStart(flags, true);
7608 
7609  /* Update the process title */
7610  update_checkpoint_display(flags, true, false);
7611 
7612  CheckPointGuts(lastCheckPoint.redo, flags);
7613 
7614  /*
7615  * This location needs to be after CheckPointGuts() to ensure that some
7616  * work has already happened during this checkpoint.
7617  */
7618  INJECTION_POINT("create-restart-point");
7619 
7620  /*
7621  * Remember the prior checkpoint's redo ptr for
7622  * UpdateCheckPointDistanceEstimate()
7623  */
7624  PriorRedoPtr = ControlFile->checkPointCopy.redo;
7625 
7626  /*
7627  * Update pg_control, using current time. Check that it still shows an
7628  * older checkpoint, else do nothing; this is a quick hack to make sure
7629  * nothing really bad happens if somehow we get here after the
7630  * end-of-recovery checkpoint.
7631  */
7632  LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
7633  if (ControlFile->checkPointCopy.redo < lastCheckPoint.redo)
7634  {
7635  /*
7636  * Update the checkpoint information. We do this even if the cluster
7637  * does not show DB_IN_ARCHIVE_RECOVERY to match with the set of WAL
7638  * segments recycled below.
7639  */
7640  ControlFile->checkPoint = lastCheckPointRecPtr;
7641  ControlFile->checkPointCopy = lastCheckPoint;
7642 
7643  /*
7644  * Ensure minRecoveryPoint is past the checkpoint record and update it
7645  * if the control file still shows DB_IN_ARCHIVE_RECOVERY. Normally,
7646  * this will have happened already while writing out dirty buffers,
7647  * but not necessarily - e.g. because no buffers were dirtied. We do
7648  * this because a backup performed in recovery uses minRecoveryPoint
7649  * to determine which WAL files must be included in the backup, and
7650  * the file (or files) containing the checkpoint record must be
7651  * included, at a minimum. Note that for an ordinary restart of
7652  * recovery there's no value in having the minimum recovery point any
7653  * earlier than this anyway, because redo will begin just after the
7654  * checkpoint record.
7655  */
7657  {
7658  if (ControlFile->minRecoveryPoint < lastCheckPointEndPtr)
7659  {
7660  ControlFile->minRecoveryPoint = lastCheckPointEndPtr;
7662 
7663  /* update local copy */
7666  }
7667  if (flags & CHECKPOINT_IS_SHUTDOWN)
7669  }
7671  }
7672  LWLockRelease(ControlFileLock);
7673 
7674  /*
7675  * Update the average distance between checkpoints/restartpoints if the
7676  * prior checkpoint exists.
7677  */
7678  if (PriorRedoPtr != InvalidXLogRecPtr)
7680 
7681  /*
7682  * Delete old log files, those no longer needed for last restartpoint to
7683  * prevent the disk holding the xlog from growing full.
7684  */
7686 
7687  /*
7688  * Retreat _logSegNo using the current end of xlog replayed or received,
7689  * whichever is later.
7690  */
7691  receivePtr = GetWalRcvFlushRecPtr(NULL, NULL);
7692  replayPtr = GetXLogReplayRecPtr(&replayTLI);
7693  endptr = (receivePtr < replayPtr) ? replayPtr : receivePtr;
7694  KeepLogSeg(endptr, &_logSegNo);
7696  _logSegNo, InvalidOid,
7698  {
7699  /*
7700  * Some slots have been invalidated; recalculate the old-segment
7701  * horizon, starting again from RedoRecPtr.
7702  */
7704  KeepLogSeg(endptr, &_logSegNo);
7705  }
7706  _logSegNo--;
7707 
7708  /*
7709  * Try to recycle segments on a useful timeline. If we've been promoted
7710  * since the beginning of this restartpoint, use the new timeline chosen
7711  * at end of recovery. If we're still in recovery, use the timeline we're
7712  * currently replaying.
7713  *
7714  * There is no guarantee that the WAL segments will be useful on the
7715  * current timeline; if recovery proceeds to a new timeline right after
7716  * this, the pre-allocated WAL segments on this timeline will not be used,
7717  * and will go wasted until recycled on the next restartpoint. We'll live
7718  * with that.
7719  */
7720  if (!RecoveryInProgress())
7721  replayTLI = XLogCtl->InsertTimeLineID;
7722 
7723  RemoveOldXlogFiles(_logSegNo, RedoRecPtr, endptr, replayTLI);
7724 
7725  /*
7726  * Make more log segments if needed. (Do this after recycling old log
7727  * segments, since that may supply some of the needed files.)
7728  */
7729  PreallocXlogFiles(endptr, replayTLI);
7730 
7731  /*
7732  * Truncate pg_subtrans if possible. We can throw away all data before
7733  * the oldest XMIN of any running transaction. No future transaction will
7734  * attempt to reference any pg_subtrans entry older than that (see Asserts
7735  * in subtrans.c). When hot standby is disabled, though, we mustn't do
7736  * this because StartupSUBTRANS hasn't been called yet.
7737  */
7738  if (EnableHotStandby)
7740 
7741  /* Real work is done; log and update stats. */
7742  LogCheckpointEnd(true);
7743 
7744  /* Reset the process title */
7745  update_checkpoint_display(flags, true, true);
7746 
7747  xtime = GetLatestXTime();
7749  (errmsg("recovery restart point at %X/%X",
7750  LSN_FORMAT_ARGS(lastCheckPoint.redo)),
7751  xtime ? errdetail("Last completed transaction was at log time %s.",
7752  timestamptz_to_str(xtime)) : 0));
7753 
7754  /*
7755  * Finally, execute archive_cleanup_command, if any.
7756  */
7757  if (archiveCleanupCommand && strcmp(archiveCleanupCommand, "") != 0)
7759  "archive_cleanup_command",
7760  false,
7761  WAIT_EVENT_ARCHIVE_CLEANUP_COMMAND);
7762 
7763  return true;
7764 }
const char * timestamptz_to_str(TimestampTz t)
Definition: timestamp.c:1853
int64 TimestampTz
Definition: timestamp.h:39
int errdetail(const char *fmt,...)
Definition: elog.c:1205
#define LOG
Definition: elog.h:31
#define DEBUG2
Definition: elog.h:29
bool IsUnderPostmaster
Definition: globals.c:117
#define INJECTION_POINT(name)
@ B_CHECKPOINTER
Definition: miscadmin.h:357
BackendType MyBackendType
Definition: miscinit.c:63
@ DB_IN_ARCHIVE_RECOVERY
Definition: pg_control.h:95
@ DB_SHUTDOWNED_IN_RECOVERY
Definition: pg_control.h:92
CheckPoint lastCheckPoint
Definition: xlog.c:540
XLogRecPtr lastCheckPointRecPtr
Definition: xlog.c:538
XLogRecPtr lastCheckPointEndPtr
Definition: xlog.c:539
XLogRecPtr GetWalRcvFlushRecPtr(XLogRecPtr *latestChunkStart, TimeLineID *receiveTLI)
bool EnableHotStandby
Definition: xlog.c:121
static void UpdateMinRecoveryPoint(XLogRecPtr lsn, bool force)
Definition: xlog.c:2711
static XLogRecPtr LocalMinRecoveryPoint
Definition: xlog.c:641
static TimeLineID LocalMinRecoveryPointTLI
Definition: xlog.c:642
void ExecuteRecoveryCommand(const char *command, const char *commandName, bool failOnSignal, uint32 wait_event_info)
Definition: xlogarchive.c:295
#define LSN_FORMAT_ARGS(lsn)
Definition: xlogdefs.h:43
#define XLogRecPtrIsInvalid(r)
Definition: xlogdefs.h:29
uint32 TimeLineID
Definition: xlogdefs.h:59
char * archiveCleanupCommand
Definition: xlogrecovery.c:84
XLogRecPtr GetXLogReplayRecPtr(TimeLineID *replayTLI)
TimestampTz GetLatestXTime(void)

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(), ExecuteRecoveryCommand(), GetCurrentTimestamp(), GetLatestXTime(), GetOldestTransactionIdConsideredRunning(), GetWalRcvFlushRecPtr(), GetXLogReplayRecPtr(), XLogCtlData::info_lck, INJECTION_POINT, XLogCtlData::Insert, XLogCtlData::InsertTimeLineID, InvalidateObsoleteReplicationSlots(), InvalidOid, InvalidTransactionId, InvalidXLogRecPtr, IsUnderPostmaster, KeepLogSeg(), XLogCtlData::lastCheckPoint, XLogCtlData::lastCheckPointEndPtr, XLogCtlData::lastCheckPointRecPtr, LocalMinRecoveryPoint, LocalMinRecoveryPointTLI, LOG, log_checkpoints, LogCheckpointEnd(), LogCheckpointStart(), LSN_FORMAT_ARGS, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MemSet, ControlFileData::minRecoveryPoint, ControlFileData::minRecoveryPointTLI, MyBackendType, PreallocXlogFiles(), RecoveryInProgress(), CheckPoint::redo, RedoRecPtr, XLogCtlInsert::RedoRecPtr, XLogCtlData::RedoRecPtr, RemoveOldXlogFiles(), RS_INVAL_WAL_REMOVED, 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()

◆ do_pg_abort_backup()

void do_pg_abort_backup ( int  code,
Datum  arg 
)

Definition at line 9314 of file xlog.c.

9315 {
9316  bool during_backup_start = DatumGetBool(arg);
9317 
9318  /* If called during backup start, there shouldn't be one already running */
9319  Assert(!during_backup_start || sessionBackupState == SESSION_BACKUP_NONE);
9320 
9321  if (during_backup_start || sessionBackupState != SESSION_BACKUP_NONE)
9322  {
9326 
9329 
9330  if (!during_backup_start)
9331  ereport(WARNING,
9332  errmsg("aborting backup due to backend exiting before pg_backup_stop was called"));
9333  }
9334 }
#define WARNING
Definition: elog.h:36
void * arg
static bool DatumGetBool(Datum X)
Definition: postgres.h:90
int runningBackups
Definition: xlog.c:438
static SessionBackupState sessionBackupState
Definition: xlog.c:391

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 8712 of file xlog.c.

8714 {
8716 
8717  Assert(state != NULL);
8719 
8720  /*
8721  * During recovery, we don't need to check WAL level. Because, if WAL
8722  * level is not sufficient, it's impossible to get here during recovery.
8723  */
8725  ereport(ERROR,
8726  (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
8727  errmsg("WAL level not sufficient for making an online backup"),
8728  errhint("wal_level must be set to \"replica\" or \"logical\" at server start.")));
8729 
8730  if (strlen(backupidstr) > MAXPGPATH)
8731  ereport(ERROR,
8732  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
8733  errmsg("backup label too long (max %d bytes)",
8734  MAXPGPATH)));
8735 
8736  memcpy(state->name, backupidstr, strlen(backupidstr));
8737 
8738  /*
8739  * Mark backup active in shared memory. We must do full-page WAL writes
8740  * during an on-line backup even if not doing so at other times, because
8741  * it's quite possible for the backup dump to obtain a "torn" (partially
8742  * written) copy of a database page if it reads the page concurrently with
8743  * our write to the same page. This can be fixed as long as the first
8744  * write to the page in the WAL sequence is a full-page write. Hence, we
8745  * increment runningBackups then force a CHECKPOINT, to ensure there are
8746  * no dirty pages in shared memory that might get dumped while the backup
8747  * is in progress without having a corresponding WAL record. (Once the
8748  * backup is complete, we need not force full-page writes anymore, since
8749  * we expect that any pages not modified during the backup interval must
8750  * have been correctly captured by the backup.)
8751  *
8752  * Note that forcing full-page writes has no effect during an online
8753  * backup from the standby.
8754  *
8755  * We must hold all the insertion locks to change the value of
8756  * runningBackups, to ensure adequate interlocking against
8757  * XLogInsertRecord().
8758  */
8762 
8763  /*
8764  * Ensure we decrement runningBackups if we fail below. NB -- for this to
8765  * work correctly, it is critical that sessionBackupState is only updated
8766  * after this block is over.
8767  */
8769  {
8770  bool gotUniqueStartpoint = false;
8771  DIR *tblspcdir;
8772  struct dirent *de;
8773  tablespaceinfo *ti;
8774  int datadirpathlen;
8775 
8776  /*
8777  * Force an XLOG file switch before the checkpoint, to ensure that the
8778  * WAL segment the checkpoint is written to doesn't contain pages with
8779  * old timeline IDs. That would otherwise happen if you called
8780  * pg_backup_start() right after restoring from a PITR archive: the
8781  * first WAL segment containing the startup checkpoint has pages in
8782  * the beginning with the old timeline ID. That can cause trouble at
8783  * recovery: we won't have a history file covering the old timeline if
8784  * pg_wal directory was not included in the base backup and the WAL
8785  * archive was cleared too before starting the backup.
8786  *
8787  * This also ensures that we have emitted a WAL page header that has
8788  * XLP_BKP_REMOVABLE off before we emit the checkpoint record.
8789  * Therefore, if a WAL archiver (such as pglesslog) is trying to
8790  * compress out removable backup blocks, it won't remove any that
8791  * occur after this point.
8792  *
8793  * During recovery, we skip forcing XLOG file switch, which means that
8794  * the backup taken during recovery is not available for the special
8795  * recovery case described above.
8796  */
8798  RequestXLogSwitch(false);
8799 
8800  do
8801  {
8802  bool checkpointfpw;
8803 
8804  /*
8805  * Force a CHECKPOINT. Aside from being necessary to prevent torn
8806  * page problems, this guarantees that two successive backup runs
8807  * will have different checkpoint positions and hence different
8808  * history file names, even if nothing happened in between.
8809  *
8810  * During recovery, establish a restartpoint if possible. We use
8811  * the last restartpoint as the backup starting checkpoint. This
8812  * means that two successive backup runs can have same checkpoint
8813  * positions.
8814  *
8815  * Since the fact that we are executing do_pg_backup_start()
8816  * during recovery means that checkpointer is running, we can use
8817  * RequestCheckpoint() to establish a restartpoint.
8818  *
8819  * We use CHECKPOINT_IMMEDIATE only if requested by user (via
8820  * passing fast = true). Otherwise this can take awhile.
8821  */
8823  (fast ? CHECKPOINT_IMMEDIATE : 0));
8824 
8825  /*
8826  * Now we need to fetch the checkpoint record location, and also
8827  * its REDO pointer. The oldest point in WAL that would be needed
8828  * to restore starting from the checkpoint is precisely the REDO
8829  * pointer.
8830  */
8831  LWLockAcquire(ControlFileLock, LW_SHARED);
8832  state->checkpointloc = ControlFile->checkPoint;
8833  state->startpoint = ControlFile->checkPointCopy.redo;
8835  checkpointfpw = ControlFile->checkPointCopy.fullPageWrites;
8836  LWLockRelease(ControlFileLock);
8837 
8839  {
8840  XLogRecPtr recptr;
8841 
8842  /*
8843  * Check to see if all WAL replayed during online backup
8844  * (i.e., since last restartpoint used as backup starting
8845  * checkpoint) contain full-page writes.
8846  */
8848  recptr = XLogCtl->lastFpwDisableRecPtr;
8850 
8851  if (!checkpointfpw || state->startpoint <= recptr)
8852  ereport(ERROR,
8853  (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
8854  errmsg("WAL generated with full_page_writes=off was replayed "
8855  "since last restartpoint"),
8856  errhint("This means that the backup being taken on the standby "
8857  "is corrupt and should not be used. "
8858  "Enable full_page_writes and run CHECKPOINT on the primary, "
8859  "and then try an online backup again.")));
8860 
8861  /*
8862  * During recovery, since we don't use the end-of-backup WAL
8863  * record and don't write the backup history file, the
8864  * starting WAL location doesn't need to be unique. This means
8865  * that two base backups started at the same time might use
8866  * the same checkpoint as starting locations.
8867  */
8868  gotUniqueStartpoint = true;
8869  }
8870 
8871  /*
8872  * If two base backups are started at the same time (in WAL sender
8873  * processes), we need to make sure that they use different
8874  * checkpoints as starting locations, because we use the starting
8875  * WAL location as a unique identifier for the base backup in the
8876  * end-of-backup WAL record and when we write the backup history
8877  * file. Perhaps it would be better generate a separate unique ID
8878  * for each backup instead of forcing another checkpoint, but
8879  * taking a checkpoint right after another is not that expensive
8880  * either because only few buffers have been dirtied yet.
8881  */
8883  if (XLogCtl->Insert.lastBackupStart < state->startpoint)
8884  {
8885  XLogCtl->Insert.lastBackupStart = state->startpoint;
8886  gotUniqueStartpoint = true;
8887  }
8889  } while (!gotUniqueStartpoint);
8890 
8891  /*
8892  * Construct tablespace_map file.
8893  */
8894  datadirpathlen = strlen(DataDir);
8895 
8896  /* Collect information about all tablespaces */
8897  tblspcdir = AllocateDir("pg_tblspc");
8898  while ((de = ReadDir(tblspcdir, "pg_tblspc")) != NULL)
8899  {
8900  char fullpath[MAXPGPATH + 10];
8901  char linkpath[MAXPGPATH];
8902  char *relpath = NULL;
8903  char *s;
8904  PGFileType de_type;
8905  char *badp;
8906  Oid tsoid;
8907 
8908  /*
8909  * Try to parse the directory name as an unsigned integer.
8910  *
8911  * Tablespace directories should be positive integers that can be
8912  * represented in 32 bits, with no leading zeroes or trailing
8913  * garbage. If we come across a name that doesn't meet those
8914  * criteria, skip it.
8915  */
8916  if (de->d_name[0] < '1' || de->d_name[1] > '9')
8917  continue;
8918  errno = 0;
8919  tsoid = strtoul(de->d_name, &badp, 10);
8920  if (*badp != '\0' || errno == EINVAL || errno == ERANGE)
8921  continue;
8922 
8923  snprintf(fullpath, sizeof(fullpath), "pg_tblspc/%s", de->d_name);
8924 
8925  de_type = get_dirent_type(fullpath, de, false, ERROR);
8926 
8927  if (de_type == PGFILETYPE_LNK)
8928  {
8929  StringInfoData escapedpath;
8930  int rllen;
8931 
8932  rllen = readlink(fullpath, linkpath, sizeof(linkpath));
8933  if (rllen < 0)
8934  {
8935  ereport(WARNING,
8936  (errmsg("could not read symbolic link \"%s\": %m",
8937  fullpath)));
8938  continue;
8939  }
8940  else if (rllen >= sizeof(linkpath))
8941  {
8942  ereport(WARNING,
8943  (errmsg("symbolic link \"%s\" target is too long",
8944  fullpath)));
8945  continue;
8946  }
8947  linkpath[rllen] = '\0';
8948 
8949  /*
8950  * Relpath holds the relative path of the tablespace directory
8951  * when it's located within PGDATA, or NULL if it's located
8952  * elsewhere.
8953  */
8954  if (rllen > datadirpathlen &&
8955  strncmp(linkpath, DataDir, datadirpathlen) == 0 &&
8956  IS_DIR_SEP(linkpath[datadirpathlen]))
8957  relpath = pstrdup(linkpath + datadirpathlen + 1);
8958 
8959  /*
8960  * Add a backslash-escaped version of the link path to the
8961  * tablespace map file.
8962  */
8963  initStringInfo(&escapedpath);
8964  for (s = linkpath; *s; s++)
8965  {
8966  if (*s == '\n' || *s == '\r' || *s == '\\')
8967  appendStringInfoChar(&escapedpath, '\\');
8968  appendStringInfoChar(&escapedpath, *s);
8969  }
8970  appendStringInfo(tblspcmapfile, "%s %s\n",
8971  de->d_name, escapedpath.data);
8972  pfree(escapedpath.data);
8973  }
8974  else if (de_type == PGFILETYPE_DIR)
8975  {
8976  /*
8977  * It's possible to use allow_in_place_tablespaces to create
8978  * directories directly under pg_tblspc, for testing purposes
8979  * only.
8980  *
8981  * In this case, we store a relative path rather than an
8982  * absolute path into the tablespaceinfo.
8983  */
8984  snprintf(linkpath, sizeof(linkpath), "pg_tblspc/%s",
8985  de->d_name);
8986  relpath = pstrdup(linkpath);
8987  }
8988  else
8989  {
8990  /* Skip any other file type that appears here. */
8991  continue;
8992  }
8993 
8994  ti = palloc(sizeof(tablespaceinfo));
8995  ti->oid = tsoid;
8996  ti->path = pstrdup(linkpath);
8997  ti->rpath = relpath;
8998  ti->size = -1;
8999 
9000  if (tablespaces)
9001  *tablespaces = lappend(*tablespaces, ti);
9002  }
9003  FreeDir(tblspcdir);
9004 
9005  state->starttime = (pg_time_t) time(NULL);
9006  }
9008 
9009  state->started_in_recovery = backup_started_in_recovery;
9010 
9011  /*
9012  * Mark that the start phase has correctly finished for the backup.
9013  */
9015 }
static bool backup_started_in_recovery
Definition: basebackup.c:123
void RequestCheckpoint(int flags)
Definition: checkpointer.c:941
int errhint(const char *fmt,...)
Definition: elog.c:1319
int errcode(int sqlerrcode)
Definition: elog.c:859
struct dirent * ReadDir(DIR *dir, const char *dirname)
Definition: fd.c:2909
int FreeDir(DIR *dir)
Definition: fd.c:2961
DIR * AllocateDir(const char *dirname)
Definition: fd.c:2843
PGFileType get_dirent_type(const char *path, const struct dirent *de, bool look_through_symlinks, int elevel)
Definition: file_utils.c:525
PGFileType
Definition: file_utils.h:19
@ PGFILETYPE_LNK
Definition: file_utils.h:24
@ PGFILETYPE_DIR
Definition: file_utils.h:23
char * DataDir
Definition: globals.c:68
#define PG_ENSURE_ERROR_CLEANUP(cleanup_function, arg)
Definition: ipc.h:47
#define PG_END_ENSURE_ERROR_CLEANUP(cleanup_function, arg)
Definition: ipc.h:52
List * lappend(List *list, void *datum)
Definition: list.c:339
char * pstrdup(const char *in)
Definition: mcxt.c:1695
#define MAXPGPATH
#define snprintf
Definition: port.h:238
#define IS_DIR_SEP(ch)
Definition: port.h:102
unsigned int Oid
Definition: postgres_ext.h:31
#define relpath(rlocator, forknum)
Definition: relpath.h:94
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition: stringinfo.c:97
void appendStringInfoChar(StringInfo str, char ch)
Definition: stringinfo.c:194
void initStringInfo(StringInfo str)
Definition: stringinfo.c:59
Definition: dirent.c:26
XLogRecPtr lastFpwDisableRecPtr
Definition: xlog.c:546
XLogRecPtr lastBackupStart
Definition: xlog.c:439
Definition: dirent.h:10
char d_name[MAX_PATH]
Definition: dirent.h:15
Definition: regguts.h:323
char * rpath
Definition: basebackup.h:32
#define readlink(path, buf, size)
Definition: win32_port.h:236
XLogRecPtr RequestXLogSwitch(bool mark_unimportant)
Definition: xlog.c:7981
void do_pg_abort_backup(int code, Datum arg)
Definition: xlog.c:9314
@ SESSION_BACKUP_RUNNING
Definition: xlog.h:284
#define CHECKPOINT_WAIT
Definition: xlog.h:143
#define CHECKPOINT_IMMEDIATE
Definition: xlog.h:139
#define XLogIsNeeded()
Definition: xlog.h:107

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_DIR, 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 9040 of file xlog.c.

9041 {
9042  bool backup_stopped_in_recovery = false;
9043  char histfilepath[MAXPGPATH];
9044  char lastxlogfilename[MAXFNAMELEN];
9045  char histfilename[MAXFNAMELEN];
9046  XLogSegNo _logSegNo;
9047  FILE *fp;
9048  int seconds_before_warning;
9049  int waits = 0;
9050  bool reported_waiting = false;
9051 
9052  Assert(state != NULL);
9053 
9054  backup_stopped_in_recovery = RecoveryInProgress();
9055 
9056  /*
9057  * During recovery, we don't need to check WAL level. Because, if WAL
9058  * level is not sufficient, it's impossible to get here during recovery.
9059  */
9060  if (!backup_stopped_in_recovery && !XLogIsNeeded())
9061  ereport(ERROR,
9062  (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
9063  errmsg("WAL level not sufficient for making an online backup"),
9064  errhint("wal_level must be set to \"replica\" or \"logical\" at server start.")));
9065 
9066  /*
9067  * OK to update backup counter and session-level lock.
9068  *
9069  * Note that CHECK_FOR_INTERRUPTS() must not occur while updating them,
9070  * otherwise they can be updated inconsistently, which might cause
9071  * do_pg_abort_backup() to fail.
9072  */
9074 
9075  /*
9076  * It is expected that each do_pg_backup_start() call is matched by
9077  * exactly one do_pg_backup_stop() call.
9078  */
9081 
9082  /*
9083  * Clean up session-level lock.
9084  *
9085  * You might think that WALInsertLockRelease() can be called before
9086  * cleaning up session-level lock because session-level lock doesn't need
9087  * to be protected with WAL insertion lock. But since
9088  * CHECK_FOR_INTERRUPTS() can occur in it, session-level lock must be
9089  * cleaned up before it.
9090  */
9092 
9094 
9095  /*
9096  * If we are taking an online backup from the standby, we confirm that the
9097  * standby has not been promoted during the backup.
9098  */
9099  if (state->started_in_recovery && !backup_stopped_in_recovery)
9100  ereport(ERROR,
9101  (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
9102  errmsg("the standby was promoted during online backup"),
9103  errhint("This means that the backup being taken is corrupt "
9104  "and should not be used. "
9105  "Try taking another online backup.")));
9106 
9107  /*
9108  * During recovery, we don't write an end-of-backup record. We assume that
9109  * pg_control was backed up last and its minimum recovery point can be
9110  * available as the backup end location. Since we don't have an
9111  * end-of-backup record, we use the pg_control value to check whether
9112  * we've reached the end of backup when starting recovery from this
9113  * backup. We have no way of checking if pg_control wasn't backed up last
9114  * however.
9115  *
9116  * We don't force a switch to new WAL file but it is still possible to
9117  * wait for all the required files to be archived if waitforarchive is
9118  * true. This is okay if we use the backup to start a standby and fetch
9119  * the missing WAL using streaming replication. But in the case of an
9120  * archive recovery, a user should set waitforarchive to true and wait for
9121  * them to be archived to ensure that all the required files are
9122  * available.
9123  *
9124  * We return the current minimum recovery point as the backup end
9125  * location. Note that it can be greater than the exact backup end
9126  * location if the minimum recovery point is updated after the backup of
9127  * pg_control. This is harmless for current uses.
9128  *
9129  * XXX currently a backup history file is for informational and debug
9130  * purposes only. It's not essential for an online backup. Furthermore,
9131  * even if it's created, it will not be archived during recovery because
9132  * an archiver is not invoked. So it doesn't seem worthwhile to write a
9133  * backup history file during recovery.
9134  */
9135  if (backup_stopped_in_recovery)
9136  {
9137  XLogRecPtr recptr;
9138 
9139  /*
9140  * Check to see if all WAL replayed during online backup contain
9141  * full-page writes.
9142  */
9144  recptr = XLogCtl->lastFpwDisableRecPtr;
9146 
9147  if (state->startpoint <= recptr)
9148  ereport(ERROR,
9149  (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
9150  errmsg("WAL generated with full_page_writes=off was replayed "
9151  "during online backup"),
9152  errhint("This means that the backup being taken on the standby "
9153  "is corrupt and should not be used. "
9154  "Enable full_page_writes and run CHECKPOINT on the primary, "
9155  "and then try an online backup again.")));
9156 
9157 
9158  LWLockAcquire(ControlFileLock, LW_SHARED);
9159  state->stoppoint = ControlFile->minRecoveryPoint;
9161  LWLockRelease(ControlFileLock);
9162  }
9163  else
9164  {
9165  char *history_file;
9166 
9167  /*
9168  * Write the backup-end xlog record
9169  */
9170  XLogBeginInsert();
9171  XLogRegisterData((char *) (&state->startpoint),
9172  sizeof(state->startpoint));
9173  state->stoppoint = XLogInsert(RM_XLOG_ID, XLOG_BACKUP_END);
9174 
9175  /*
9176  * Given that we're not in recovery, InsertTimeLineID is set and can't
9177  * change, so we can read it without a lock.
9178  */
9179  state->stoptli = XLogCtl->InsertTimeLineID;
9180 
9181  /*
9182  * Force a switch to a new xlog segment file, so that the backup is
9183  * valid as soon as archiver moves out the current segment file.
9184  */
9185  RequestXLogSwitch(false);
9186 
9187  state->stoptime = (pg_time_t) time(NULL);
9188 
9189  /*
9190  * Write the backup history file
9191  */
9192  XLByteToSeg(state->startpoint, _logSegNo, wal_segment_size);
9193  BackupHistoryFilePath(histfilepath, state->stoptli, _logSegNo,
9194  state->startpoint, wal_segment_size);
9195  fp = AllocateFile(histfilepath, "w");
9196  if (!fp)
9197  ereport(ERROR,
9199  errmsg("could not create file \"%s\": %m",
9200  histfilepath)));
9201 
9202  /* Build and save the contents of the backup history file */
9203  history_file = build_backup_content(state, true);
9204  fprintf(fp, "%s", history_file);
9205  pfree(history_file);
9206 
9207  if (fflush(fp) || ferror(fp) || FreeFile(fp))
9208  ereport(ERROR,
9210  errmsg("could not write file \"%s\": %m",
9211  histfilepath)));
9212 
9213  /*
9214  * Clean out any no-longer-needed history files. As a side effect,
9215  * this will post a .ready file for the newly created history file,
9216  * notifying the archiver that history file may be archived
9217  * immediately.
9218  */
9220  }
9221 
9222  /*
9223  * If archiving is enabled, wait for all the required WAL files to be
9224  * archived before returning. If archiving isn't enabled, the required WAL
9225  * needs to be transported via streaming replication (hopefully with
9226  * wal_keep_size set high enough), or some more exotic mechanism like
9227  * polling and copying files from pg_wal with script. We have no knowledge
9228  * of those mechanisms, so it's up to the user to ensure that he gets all
9229  * the required WAL.
9230  *
9231  * We wait until both the last WAL file filled during backup and the
9232  * history file have been archived, and assume that the alphabetic sorting
9233  * property of the WAL files ensures any earlier WAL files are safely
9234  * archived as well.
9235  *
9236  * We wait forever, since archive_command is supposed to work and we
9237  * assume the admin wanted his backup to work completely. If you don't
9238  * wish to wait, then either waitforarchive should be passed in as false,
9239  * or you can set statement_timeout. Also, some notices are issued to
9240  * clue in anyone who might be doing this interactively.
9241  */
9242 
9243  if (waitforarchive &&
9244  ((!backup_stopped_in_recovery && XLogArchivingActive()) ||
9245  (backup_stopped_in_recovery && XLogArchivingAlways())))
9246  {
9247  XLByteToPrevSeg(state->stoppoint, _logSegNo, wal_segment_size);
9248  XLogFileName(lastxlogfilename, state->stoptli, _logSegNo,
9250 
9251  XLByteToSeg(state->startpoint, _logSegNo, wal_segment_size);
9252  BackupHistoryFileName(histfilename, state->stoptli, _logSegNo,
9253  state->startpoint, wal_segment_size);
9254 
9255  seconds_before_warning = 60;
9256  waits = 0;
9257 
9258  while (XLogArchiveIsBusy(lastxlogfilename) ||
9259  XLogArchiveIsBusy(histfilename))
9260  {
9262 
9263  if (!reported_waiting && waits > 5)
9264  {
9265  ereport(NOTICE,
9266  (errmsg("base backup done, waiting for required WAL segments to be archived")));
9267  reported_waiting = true;
9268  }
9269 
9270  (void) WaitLatch(MyLatch,
9272  1000L,
9273  WAIT_EVENT_BACKUP_WAIT_WAL_ARCHIVE);
9275 
9276  if (++waits >= seconds_before_warning)
9277  {
9278  seconds_before_warning *= 2; /* This wraps in >10 years... */
9279  ereport(WARNING,
9280  (errmsg("still waiting for all required WAL segments to be archived (%d seconds elapsed)",
9281  waits),
9282  errhint("Check that your archive_command is executing properly. "
9283  "You can safely cancel this backup, "
9284  "but the database backup will not be usable without all the WAL segments.")));
9285  }
9286  }
9287 
9288  ereport(NOTICE,
9289  (errmsg("all required WAL segments have been archived")));
9290  }
9291  else if (waitforarchive)
9292  ereport(NOTICE,
9293  (errmsg("WAL archiving is not enabled; you must ensure that all required WAL segments are copied through other means to complete the backup")));
9294 }
#define NOTICE
Definition: elog.h:35
FILE * AllocateFile(const char *name, const char *mode)
Definition: fd.c:2583
int FreeFile(FILE *file)
Definition: fd.c:2781
struct Latch * MyLatch
Definition: globals.c:60
void ResetLatch(Latch *latch)
Definition: latch.c:724
int WaitLatch(Latch *latch, int wakeEvents, long timeout, uint32 wait_event_info)
Definition: latch.c:517
#define WL_TIMEOUT
Definition: latch.h:130
#define WL_EXIT_ON_PM_DEATH
Definition: latch.h:132
#define WL_LATCH_SET
Definition: latch.h:127
static void const char fflush(stdout)
#define CHECK_FOR_INTERRUPTS()
Definition: miscadmin.h:122
#define XLOG_BACKUP_END
Definition: pg_control.h:72
#define fprintf
Definition: port.h:242
static void CleanupBackupHistory(void)
Definition: xlog.c:4150
#define XLogArchivingActive()
Definition: xlog.h:97
#define XLogArchivingAlways()
Definition: xlog.h:100
#define XLByteToPrevSeg(xlrp, logSegNo, wal_segsz_bytes)
static void BackupHistoryFileName(char *fname, TimeLineID tli, XLogSegNo logSegNo, XLogRecPtr startpoint, int wal_segsz_bytes)
static void BackupHistoryFilePath(char *path, TimeLineID tli, XLogSegNo logSegNo, XLogRecPtr startpoint, int wal_segsz_bytes)
bool XLogArchiveIsBusy(const char *xlog)
Definition: xlogarchive.c:619
char * build_backup_content(BackupState *state, bool ishistoryfile)
Definition: xlogbackup.c:29

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, 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 9021 of file xlog.c.

9022 {
9023  return sessionBackupState;
9024 }

References sessionBackupState.

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

◆ GetActiveWalLevelOnStandby()

WalLevel GetActiveWalLevelOnStandby ( void  )

Definition at line 4826 of file xlog.c.

4827 {
4828  return ControlFile->wal_level;
4829 }

References ControlFile, and ControlFileData::wal_level.

Referenced by CheckLogicalDecodingRequirements().

◆ GetFakeLSNForUnloggedRel()

XLogRecPtr GetFakeLSNForUnloggedRel ( void  )

Definition at line 4571 of file xlog.c.

4572 {
4574 }
static uint64 pg_atomic_fetch_add_u64(volatile pg_atomic_uint64 *ptr, int64 add_)
Definition: atomics.h:518

References pg_atomic_fetch_add_u64(), XLogCtlData::unloggedLSN, and XLogCtl.

Referenced by gistGetFakeLSN().

◆ GetFlushRecPtr()

XLogRecPtr GetFlushRecPtr ( TimeLineID insertTLI)

Definition at line 6455 of file xlog.c.

6456 {
6458 
6460 
6461  /*
6462  * If we're writing and flushing WAL, the time line can't be changing, so
6463  * no lock is required.
6464  */
6465  if (insertTLI)
6466  *insertTLI = XLogCtl->InsertTimeLineID;
6467 
6468  return LogwrtResult.Flush;
6469 }
RecoveryState SharedRecoveryState
Definition: xlog.c:511
XLogRecPtr Flush
Definition: xlog.c:328
#define RefreshXLogWriteResult(_target)
Definition: xlog.c:615
static XLogwrtResult LogwrtResult
Definition: xlog.c:607

References Assert, XLogwrtResult::Flush, XLogCtlData::InsertTimeLineID, LogwrtResult, RECOVERY_STATE_DONE, RefreshXLogWriteResult, XLogCtlData::SharedRecoveryState, and XLogCtl.

Referenced by binary_upgrade_logical_slot_has_caught_up(), get_flush_position(), GetCurrentLSN(), GetLatestLSN(), IdentifySystem(), 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 6423 of file xlog.c.

6424 {
6425  *RedoRecPtr_p = RedoRecPtr;
6426  *doPageWrites_p = doPageWrites;
6427 }
static bool doPageWrites
Definition: xlog.c:286

References doPageWrites, and RedoRecPtr.

Referenced by XLogCheckBufferNeedsBackup(), and XLogInsert().

◆ GetInsertRecPtr()

XLogRecPtr GetInsertRecPtr ( void  )

Definition at line 6438 of file xlog.c.

6439 {
6440  XLogRecPtr recptr;
6441 
6443  recptr = XLogCtl->LogwrtRqst.Write;
6445 
6446  return recptr;
6447 }
XLogwrtRqst LogwrtRqst
Definition: xlog.c:455
XLogRecPtr Write
Definition: xlog.c:321

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 6493 of file xlog.c.

6494 {
6496  int i;
6497 
6498  for (i = 0; i < NUM_XLOGINSERT_LOCKS; i++)
6499  {
6500  XLogRecPtr last_important;
6501 
6502  /*
6503  * Need to take a lock to prevent torn reads of the LSN, which are
6504  * possible on some of the supported platforms. WAL insert locks only
6505  * support exclusive mode, so we have to use that.
6506  */
6508  last_important = WALInsertLocks[i].l.lastImportantAt;
6509  LWLockRelease(&WALInsertLocks[i].l.lock);
6510 
6511  if (res < last_important)
6512  res = last_important;
6513  }
6514 
6515  return res;
6516 }
int i
Definition: isn.c:73
XLogRecPtr lastImportantAt
Definition: xlog.c:371
WALInsertLock l
Definition: xlog.c:383
static WALInsertLockPadded * WALInsertLocks
Definition: xlog.c:564
#define NUM_XLOGINSERT_LOCKS
Definition: xlog.c:150

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 4545 of file xlog.c.

4546 {
4547  Assert(ControlFile != NULL);
4549 }
char mock_authentication_nonce[MOCK_AUTH_NONCE_LEN]
Definition: pg_control.h:228

References Assert, ControlFile, and ControlFileData::mock_authentication_nonce.

Referenced by scram_mock_salt().

◆ GetRecoveryState()

RecoveryState GetRecoveryState ( void  )

Definition at line 6326 of file xlog.c.

6327 {
6328  RecoveryState retval;
6329 
6331  retval = XLogCtl->SharedRecoveryState;
6333 
6334  return retval;
6335 }

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

Referenced by XLogArchiveCheckDone().

◆ GetRedoRecPtr()

XLogRecPtr GetRedoRecPtr ( void  )

Definition at line 6393 of file xlog.c.

6394 {
6395  XLogRecPtr ptr;
6396 
6397  /*
6398  * The possibly not up-to-date copy in XlogCtl is enough. Even if we
6399  * grabbed a WAL insertion lock to read the authoritative value in
6400  * Insert->RedoRecPtr, someone might update it just after we've released
6401  * the lock.
6402  */
6404  ptr = XLogCtl->RedoRecPtr;
6406 
6407  if (RedoRecPtr < ptr)
6408  RedoRecPtr = ptr;
6409 
6410  return RedoRecPtr;
6411 }

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

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

◆ GetSystemIdentifier()

uint64 GetSystemIdentifier ( void  )

◆ GetWALAvailability()

WALAvailability GetWALAvailability ( XLogRecPtr  targetLSN)

Definition at line 7790 of file xlog.c.

7791 {
7792  XLogRecPtr currpos; /* current write LSN */
7793  XLogSegNo currSeg; /* segid of currpos */
7794  XLogSegNo targetSeg; /* segid of targetLSN */
7795  XLogSegNo oldestSeg; /* actual oldest segid */
7796  XLogSegNo oldestSegMaxWalSize; /* oldest segid kept by max_wal_size */
7797  XLogSegNo oldestSlotSeg; /* oldest segid kept by slot */
7798  uint64 keepSegs;
7799 
7800  /*
7801  * slot does not reserve WAL. Either deactivated, or has never been active
7802  */
7803  if (XLogRecPtrIsInvalid(targetLSN))
7804  return WALAVAIL_INVALID_LSN;
7805 
7806  /*
7807  * Calculate the oldest segment currently reserved by all slots,
7808  * considering wal_keep_size and max_slot_wal_keep_size. Initialize
7809  * oldestSlotSeg to the current segment.
7810  */
7811  currpos = GetXLogWriteRecPtr();
7812  XLByteToSeg(currpos, oldestSlotSeg, wal_segment_size);
7813  KeepLogSeg(currpos, &oldestSlotSeg);
7814 
7815  /*
7816  * Find the oldest extant segment file. We get 1 until checkpoint removes
7817  * the first WAL segment file since startup, which causes the status being
7818  * wrong under certain abnormal conditions but that doesn't actually harm.
7819  */
7820  oldestSeg = XLogGetLastRemovedSegno() + 1;
7821 
7822  /* calculate oldest segment by max_wal_size */
7823  XLByteToSeg(currpos, currSeg, wal_segment_size);
7825 
7826  if (currSeg > keepSegs)
7827  oldestSegMaxWalSize = currSeg - keepSegs;
7828  else
7829  oldestSegMaxWalSize = 1;
7830 
7831  /* the segment we care about */
7832  XLByteToSeg(targetLSN, targetSeg, wal_segment_size);
7833 
7834  /*
7835  * No point in returning reserved or extended status values if the
7836  * targetSeg is known to be lost.
7837  */
7838  if (targetSeg >= oldestSlotSeg)
7839  {
7840  /* show "reserved" when targetSeg is within max_wal_size */
7841  if (targetSeg >= oldestSegMaxWalSize)
7842  return WALAVAIL_RESERVED;
7843 
7844  /* being retained by slots exceeding max_wal_size */
7845  return WALAVAIL_EXTENDED;
7846  }
7847 
7848  /* WAL segments are no longer retained but haven't been removed yet */
7849  if (targetSeg >= oldestSeg)
7850  return WALAVAIL_UNRESERVED;
7851 
7852  /* Definitely lost */
7853  return WALAVAIL_REMOVED;
7854 }
XLogSegNo XLogGetLastRemovedSegno(void)
Definition: xlog.c:3747
int max_wal_size_mb
Definition: xlog.c:114
#define ConvertToXSegs(x, segsize)
Definition: xlog.c:598
XLogRecPtr GetXLogWriteRecPtr(void)
Definition: xlog.c:9371
@ WALAVAIL_REMOVED
Definition: xlog.h:191

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 6476 of file xlog.c.

6477 {
6479 
6480  /* Since the value can't be changing, no lock is required. */
6481  return XLogCtl->InsertTimeLineID;
6482 }

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(), WALReadFromBuffers(), and XLogSendPhysical().

◆ GetXLogInsertRecPtr()

XLogRecPtr GetXLogInsertRecPtr ( void  )

Definition at line 9355 of file xlog.c.

9356 {
9358  uint64 current_bytepos;
9359 
9360  SpinLockAcquire(&Insert->insertpos_lck);
9361  current_bytepos = Insert->CurrBytePos;
9362  SpinLockRelease(&Insert->insertpos_lck);
9363 
9364  return XLogBytePosToRecPtr(current_bytepos);
9365 }

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

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

◆ GetXLogWriteRecPtr()

XLogRecPtr GetXLogWriteRecPtr ( void  )

Definition at line 9371 of file xlog.c.

9372 {
9374 
9375  return LogwrtResult.Write;
9376 }
XLogRecPtr Write
Definition: xlog.c:327

References LogwrtResult, RefreshXLogWriteResult, and XLogwrtResult::Write.

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

◆ InitializeWalConsistencyChecking()

void InitializeWalConsistencyChecking ( void  )

Definition at line 4751 of file xlog.c.

4752 {
4754 
4756  {
4757  struct config_generic *guc;
4758 
4759  guc = find_option("wal_consistency_checking", false, false, ERROR);
4760 
4762 
4763  set_config_option_ext("wal_consistency_checking",
4765  guc->scontext, guc->source, guc->srole,
4766  GUC_ACTION_SET, true, ERROR, false);
4767 
4768  /* checking should not be deferred again */
4770  }
4771 }
struct config_generic * find_option(const char *name, bool create_placeholders, bool skip_errors, int elevel)
Definition: guc.c:1237
int set_config_option_ext(const char *name, const char *value, GucContext context, GucSource source, Oid srole, GucAction action, bool changeVal, int elevel, bool is_reload)
Definition: guc.c:3373
@ GUC_ACTION_SET
Definition: guc.h:199
bool process_shared_preload_libraries_done
Definition: miscinit.c:1779
GucContext scontext
Definition: guc_tables.h:167
GucSource source
Definition: guc_tables.h:165
char * wal_consistency_checking_string
Definition: xlog.c:125
static bool check_wal_consistency_checking_deferred
Definition: xlog.c:166

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 9412 of file xlog.c.

9413 {
9414  bool result;
9415 
9416  LWLockAcquire(ControlFileLock, LW_SHARED);
9418  LWLockRelease(ControlFileLock);
9419 
9420  return result;
9421 }
bool InstallXLogFileSegmentActive
Definition: xlog.c:521

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 8603 of file xlog.c.

8604 {
8605  char *msg = NULL;
8606  instr_time start;
8607 
8608  Assert(tli != 0);
8609 
8610  /*
8611  * Quick exit if fsync is disabled or write() has already synced the WAL
8612  * file.
8613  */
8614  if (!enableFsync ||
8617  return;
8618 
8619  /* Measure I/O timing to sync the WAL file */
8620  if (track_wal_io_timing)
8622  else
8624 
8625  pgstat_report_wait_start(WAIT_EVENT_WAL_SYNC);
8626  switch (wal_sync_method)
8627  {
8628  case WAL_SYNC_METHOD_FSYNC:
8629  if (pg_fsync_no_writethrough(fd) != 0)
8630  msg = _("could not fsync file \"%s\": %m");
8631  break;
8632 #ifdef HAVE_FSYNC_WRITETHROUGH
8634  if (pg_fsync_writethrough(fd) != 0)
8635  msg = _("could not fsync write-through file \"%s\": %m");
8636  break;
8637 #endif
8639  if (pg_fdatasync(fd) != 0)
8640  msg = _("could not fdatasync file \"%s\": %m");
8641  break;
8642  case WAL_SYNC_METHOD_OPEN:
8644  /* not reachable */
8645  Assert(false);
8646  break;
8647  default:
8648  ereport(PANIC,
8649  errcode(ERRCODE_INVALID_PARAMETER_VALUE),
8650  errmsg_internal("unrecognized wal_sync_method: %d", wal_sync_method));
8651  break;
8652  }
8653 
8654  /* PANIC if failed to fsync */
8655  if (msg)
8656  {
8657  char xlogfname[MAXFNAMELEN];
8658  int save_errno = errno;
8659 
8660  XLogFileName(xlogfname, tli, segno, wal_segment_size);
8661  errno = save_errno;
8662  ereport(PANIC,
8664  errmsg(msg, xlogfname)));
8665  }
8666 
8668 
8669  /*
8670  * Increment the I/O timing and the number of times WAL files were synced.
8671  */
8672  if (track_wal_io_timing)
8673  {
8674  instr_time end;
8675 
8678  }
8679 
8681 }
#define _(x)
Definition: elog.c:90
int pg_fsync_no_writethrough(int fd)
Definition: fd.c:441
int pg_fdatasync(int fd)
Definition: fd.c:480
int pg_fsync_writethrough(int fd)
Definition: fd.c:461
bool enableFsync
Definition: globals.c:126
return str start
#define INSTR_TIME_SET_CURRENT(t)
Definition: instr_time.h:122
#define INSTR_TIME_SET_ZERO(t)
Definition: instr_time.h:172
#define INSTR_TIME_ACCUM_DIFF(x, y, z)
Definition: instr_time.h:184
PgStat_PendingWalStats PendingWalStats
Definition: pgstat_wal.c:24
static int fd(const char *x, int i)
Definition: preproc-init.c:105
instr_time wal_sync_time
Definition: pgstat.h:456
PgStat_Counter wal_sync
Definition: pgstat.h:454
int wal_sync_method
Definition: xlog.c:130
bool track_wal_io_timing
Definition: xlog.c:137

References _, Assert, enableFsync, ereport, errcode(), errcode_for_file_access(), errmsg(), errmsg_internal(), fd(), INSTR_TIME_ACCUM_DIFF, INSTR_TIME_SET_CURRENT, INSTR_TIME_SET_ZERO, MAXFNAMELEN, PANIC, PendingWalStats, pg_fdatasync(), pg_fsync_no_writethrough(), pg_fsync_writethrough(), pgstat_report_wait_end(), pgstat_report_wait_start(), start, track_wal_io_timing, wal_segment_size, PgStat_PendingWalStats::wal_sync, wal_sync_method, WAL_SYNC_METHOD_FDATASYNC, WAL_SYNC_METHOD_FSYNC, WAL_SYNC_METHOD_FSYNC_WRITETHROUGH, WAL_SYNC_METHOD_OPEN, WAL_SYNC_METHOD_OPEN_DSYNC, PgStat_PendingWalStats::wal_sync_time, and XLogFileName().

Referenced by XLogWalRcvFlush(), and XLogWrite().

◆ LocalProcessControlFile()

void LocalProcessControlFile ( bool  reset)

Definition at line 4813 of file xlog.c.

4814 {
4815  Assert(reset || ControlFile == NULL);
4816  ControlFile = palloc(sizeof(ControlFileData));
4817  ReadControlFile();
4818 }
void reset(void)
Definition: sql-declare.c:600

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

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

◆ ReachedEndOfBackup()

void ReachedEndOfBackup ( XLogRecPtr  EndRecPtr,
TimeLineID  tli 
)

Definition at line 6203 of file xlog.c.

6204 {
6205  /*
6206  * We have reached the end of base backup, as indicated by pg_control. The
6207  * data on disk is now consistent (unless minRecoveryPoint is further
6208  * ahead, which can happen if we crashed during previous recovery). Reset
6209  * backupStartPoint and backupEndPoint, and update minRecoveryPoint to
6210  * make sure we don't allow starting up at an earlier point even if
6211  * recovery is stopped and restarted soon after this.
6212  */
6213  LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
6214 
6215  if (ControlFile->minRecoveryPoint < EndRecPtr)
6216  {
6217  ControlFile->minRecoveryPoint = EndRecPtr;
6219  }
6220 
6223  ControlFile->backupEndRequired = false;
6225 
6226  LWLockRelease(ControlFileLock);
6227 }
XLogRecPtr backupStartPoint
Definition: pg_control.h:169
bool backupEndRequired
Definition: pg_control.h:171
XLogRecPtr backupEndPoint
Definition: pg_control.h:170

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 6290 of file xlog.c.

6291 {
6292  /*
6293  * We check shared state each time only until we leave recovery mode. We
6294  * can't re-enter recovery, so there's no need to keep checking after the
6295  * shared variable has once been seen false.
6296  */
6298  return false;
6299  else
6300  {
6301  /*
6302  * use volatile pointer to make sure we make a fresh read of the
6303  * shared variable.
6304  */
6305  volatile XLogCtlData *xlogctl = XLogCtl;
6306 
6308 
6309  /*
6310  * Note: We don't need a memory barrier when we're still in recovery.
6311  * We might exit recovery immediately after return, so the caller
6312  * can't rely on 'true' meaning that we're still in recovery anyway.
6313  */
6314 
6315  return LocalRecoveryInProgress;
6316  }
6317 }
static bool LocalRecoveryInProgress
Definition: xlog.c:224

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(), CreateDecodingContext(), CreateEndOfRecoveryRecord(), CreateOverwriteContrecordRecord(), CreateRestartPoint(), do_pg_backup_start(), do_pg_backup_stop(), error_commit_ts_disabled(), get_relation_info(), GetCurrentLSN(), GetLatestLSN(), GetNewMultiXactId(), GetNewObjectId(), GetNewTransactionId(), GetOldestActiveTransactionId(), GetOldestSafeDecodingTransactionId(), GetRunningTransactionData(), GetSerializableTransactionSnapshot(), GetSerializableTransactionSnapshotInt(), GetSnapshotData(), GetStrictOldestNonRemovableTransactionId(), gin_clean_pending_list(), GlobalVisHorizonKindForRel(), heap_force_common(), heap_page_prune_opt(), IdentifySystem(), InitTempTableNamespace(), IsCheckpointOnSchedule(), LockAcquireExtended(), logical_read_xlog_page(), 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_log_standby_snapshot(), pg_logical_slot_get_changes_guts(), pg_promote(), pg_replication_slot_advance(), pg_switch_wal(), pg_sync_replication_slots(), pg_wal_replay_pause(), pg_wal_replay_resume(), pg_walfile_name(), pg_walfile_name_offset(), PhysicalWakeupLogicalWalSnd(), PrepareRedoAdd(), PrepareRedoRemove(), PreventCommandDuringRecovery(), ProcSleep(), read_local_xlog_page_guts(), ReadReplicationSlot(), recovery_create_dbdir(), ReplicationSlotAlter(), ReplicationSlotCreate(), ReplicationSlotDrop(), ReplicationSlotReserveWal(), replorigin_check_prerequisites(), ReportChangedGUCOptions(), sendDir(), SerialSetActiveSerXmin(), show_in_hot_standby(), ShutdownXLOG(), SnapBuildWaitSnapshot(), standard_ProcessUtility(), StandbySlotsHaveCaughtup(), StartLogicalReplication(), StartReplication(), StartTransaction(), TransactionIdIsInProgress(), TruncateMultiXact(), UpdateFullPageWrites(), verify_heapam(), WALReadFromBuffers(), WalReceiverMain(), WalSndWaitForWal(), xlog_decode(), XLogBackgroundFlush(), XLogFlush(), XLogInsertAllowed(), XLogNeedsFlush(), and XLogSendPhysical().

◆ register_persistent_abort_backup_handler()

void register_persistent_abort_backup_handler ( void  )

Definition at line 9341 of file xlog.c.

9342 {
9343  static bool already_done = false;
9344 
9345  if (already_done)
9346  return;
9348  already_done = true;
9349 }
void before_shmem_exit(pg_on_exit_callback function, Datum arg)
Definition: ipc.c:337

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 3929 of file xlog.c.

3930 {
3931  DIR *xldir;
3932  struct dirent *xlde;
3933  char switchseg[MAXFNAMELEN];
3934  XLogSegNo endLogSegNo;
3935  XLogSegNo switchLogSegNo;
3936  XLogSegNo recycleSegNo;
3937 
3938  /*
3939  * Initialize info about where to begin the work. This will recycle,
3940  * somewhat arbitrarily, 10 future segments.
3941  */
3942  XLByteToPrevSeg(switchpoint, switchLogSegNo, wal_segment_size);
3943  XLByteToSeg(switchpoint, endLogSegNo, wal_segment_size);
3944  recycleSegNo = endLogSegNo + 10;
3945 
3946  /*
3947  * Construct a filename of the last segment to be kept.
3948  */
3949  XLogFileName(switchseg, newTLI, switchLogSegNo, wal_segment_size);
3950 
3951  elog(DEBUG2, "attempting to remove WAL segments newer than log file %s",
3952  switchseg);
3953 
3954  xldir = AllocateDir(XLOGDIR);
3955 
3956  while ((xlde = ReadDir(xldir, XLOGDIR)) != NULL)
3957  {
3958  /* Ignore files that are not XLOG segments */
3959  if (!IsXLogFileName(xlde->d_name))
3960  continue;
3961 
3962  /*
3963  * Remove files that are on a timeline older than the new one we're
3964  * switching to, but with a segment number >= the first segment on the
3965  * new timeline.
3966  */
3967  if (strncmp(xlde->d_name, switchseg, 8) < 0 &&
3968  strcmp(xlde->d_name + 8, switchseg + 8) > 0)
3969  {
3970  /*
3971  * If the file has already been marked as .ready, however, don't
3972  * remove it yet. It should be OK to remove it - files that are
3973  * not part of our timeline history are not required for recovery
3974  * - but seems safer to let them be archived and removed later.
3975  */
3976  if (!XLogArchiveIsReady(xlde->d_name))
3977  RemoveXlogFile(xlde, recycleSegNo, &endLogSegNo, newTLI);
3978  }
3979  }
3980 
3981  FreeDir(xldir);
3982 }
static void RemoveXlogFile(const struct dirent *segment_de, XLogSegNo recycleSegNo, XLogSegNo *endlogSegNo, TimeLineID insertTLI)
Definition: xlog.c:3998
static bool IsXLogFileName(const char *fname)
#define XLOGDIR
bool XLogArchiveIsReady(const char *xlog)
Definition: xlogarchive.c:694

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 9404 of file xlog.c.

9405 {
9406  LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
9408  LWLockRelease(ControlFileLock);
9409 }

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

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

◆ SetWalWriterSleeping()

void SetWalWriterSleeping ( bool  sleeping)

Definition at line 9427 of file xlog.c.

9428 {
9430  XLogCtl->WalWriterSleeping = sleeping;
9432 }
bool WalWriterSleeping
Definition: xlog.c:528

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

Referenced by WalWriterMain().

◆ ShutdownXLOG()

void ShutdownXLOG ( int  code,
Datum  arg 
)

Definition at line 6539 of file xlog.c.

6540 {
6541  /*
6542  * We should have an aux process resource owner to use, and we should not
6543  * be in a transaction that's installed some other resowner.
6544  */
6546  Assert(CurrentResourceOwner == NULL ||
6549 
6550  /* Don't be chatty in standalone mode */
6552  (errmsg("shutting down")));
6553 
6554  /*
6555  * Signal walsenders to move to stopping state.
6556  */
6558 
6559  /*
6560  * Wait for WAL senders to be in stopping state. This prevents commands
6561  * from writing new WAL.
6562  */
6564 
6565  if (RecoveryInProgress())
6567  else
6568  {
6569  /*
6570  * If archiving is enabled, rotate the last XLOG file so that all the
6571  * remaining records are archived (postmaster wakes up the archiver
6572  * process one more time at the end of shutdown). The checkpoint
6573  * record will go to the next XLOG file and won't be archived (yet).
6574  */
6575  if (XLogArchivingActive())
6576  RequestXLogSwitch(false);
6577 
6579  }
6580 }
bool IsPostmasterEnvironment
Definition: globals.c:116
ResourceOwner CurrentResourceOwner
Definition: resowner.c:165
ResourceOwner AuxProcessResourceOwner
Definition: resowner.c:168
void WalSndInitStopping(void)
Definition: walsender.c:3745
void WalSndWaitStopping(void)
Definition: walsender.c:3771
bool CreateRestartPoint(int flags)
Definition: xlog.c:7512
void CreateCheckPoint(int flags)
Definition: xlog.c:6821

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 5388 of file xlog.c.

5389 {
5391  CheckPoint checkPoint;
5392  bool wasShutdown;
5393  bool didCrash;
5394  bool haveTblspcMap;
5395  bool haveBackupLabel;
5396  XLogRecPtr EndOfLog;
5397  TimeLineID EndOfLogTLI;
5398  TimeLineID newTLI;
5399  bool performedWalRecovery;
5400  EndOfWalRecoveryInfo *endOfRecoveryInfo;
5403  TransactionId oldestActiveXID;
5404  bool promoted = false;
5405 
5406  /*
5407  * We should have an aux process resource owner to use, and we should not
5408  * be in a transaction that's installed some other resowner.
5409  */
5411  Assert(CurrentResourceOwner == NULL ||
5414 
5415  /*
5416  * Check that contents look valid.
5417  */
5419  ereport(FATAL,
5421  errmsg("control file contains invalid checkpoint location")));
5422 
5423  switch (ControlFile->state)
5424  {
5425  case DB_SHUTDOWNED:
5426 
5427  /*
5428  * This is the expected case, so don't be chatty in standalone
5429  * mode
5430  */
5432  (errmsg("database system was shut down at %s",
5433  str_time(ControlFile->time))));
5434  break;
5435 
5437  ereport(LOG,
5438  (errmsg("database system was shut down in recovery at %s",
5439  str_time(ControlFile->time))));
5440  break;
5441 
5442  case DB_SHUTDOWNING:
5443  ereport(LOG,
5444  (errmsg("database system shutdown was interrupted; last known up at %s",
5445  str_time(ControlFile->time))));
5446  break;
5447 
5448  case DB_IN_CRASH_RECOVERY:
5449  ereport(LOG,
5450  (errmsg("database system was interrupted while in recovery at %s",
5452  errhint("This probably means that some data is corrupted and"
5453  " you will have to use the last backup for recovery.")));
5454  break;
5455 
5457  ereport(LOG,
5458  (errmsg("database system was interrupted while in recovery at log time %s",
5460  errhint("If this has occurred more than once some data might be corrupted"
5461  " and you might need to choose an earlier recovery target.")));
5462  break;
5463 
5464  case DB_IN_PRODUCTION:
5465  ereport(LOG,
5466  (errmsg("database system was interrupted; last known up at %s",
5467  str_time(ControlFile->time))));
5468  break;
5469 
5470  default:
5471  ereport(FATAL,
5473  errmsg("control file contains invalid database cluster state")));
5474  }
5475 
5476  /* This is just to allow attaching to startup process with a debugger */
5477 #ifdef XLOG_REPLAY_DELAY
5479  pg_usleep(60000000L);
5480 #endif
5481 
5482  /*
5483  * Verify that pg_wal, pg_wal/archive_status, and pg_wal/summaries exist.
5484  * In cases where someone has performed a copy for PITR, these directories
5485  * may have been excluded and need to be re-created.
5486  */
5488 
5489  /* Set up timeout handler needed to report startup progress. */
5493 
5494  /*----------
5495  * If we previously crashed, perform a couple of actions:
5496  *
5497  * - The pg_wal directory may still include some temporary WAL segments
5498  * used when creating a new segment, so perform some clean up to not
5499  * bloat this path. This is done first as there is no point to sync
5500  * this temporary data.
5501  *
5502  * - There might be data which we had written, intending to fsync it, but
5503  * which we had not actually fsync'd yet. Therefore, a power failure in
5504  * the near future might cause earlier unflushed writes to be lost, even
5505  * though more recent data written to disk from here on would be
5506  * persisted. To avoid that, fsync the entire data directory.
5507  */
5508  if (ControlFile->state != DB_SHUTDOWNED &&
5510  {
5513  didCrash = true;
5514  }
5515  else
5516  didCrash = false;
5517 
5518  /*
5519  * Prepare for WAL recovery if needed.
5520  *
5521  * InitWalRecovery analyzes the control file and the backup label file, if
5522  * any. It updates the in-memory ControlFile buffer according to the
5523  * starting checkpoint, and sets InRecovery and ArchiveRecoveryRequested.
5524  * It also applies the tablespace map file, if any.
5525  */
5526  InitWalRecovery(ControlFile, &wasShutdown,
5527  &haveBackupLabel, &haveTblspcMap);
5528  checkPoint = ControlFile->checkPointCopy;
5529 
5530  /* initialize shared memory variables from the checkpoint record */
5531  TransamVariables->nextXid = checkPoint.nextXid;
5532  TransamVariables->nextOid = checkPoint.nextOid;
5534  MultiXactSetNextMXact(checkPoint.nextMulti, checkPoint.nextMultiOffset);
5535  AdvanceOldestClogXid(checkPoint.oldestXid);
5536  SetTransactionIdLimit(checkPoint.oldestXid, checkPoint.oldestXidDB);
5537  SetMultiXactIdLimit(checkPoint.oldestMulti, checkPoint.oldestMultiDB, true);
5539  checkPoint.newestCommitTsXid);
5540  XLogCtl->ckptFullXid = checkPoint.nextXid;
5541 
5542  /*
5543  * Clear out any old relcache cache files. This is *necessary* if we do
5544  * any WAL replay, since that would probably result in the cache files
5545  * being out of sync with database reality. In theory we could leave them
5546  * in place if the database had been cleanly shut down, but it seems
5547  * safest to just remove them always and let them be rebuilt during the
5548  * first backend startup. These files needs to be removed from all
5549  * directories including pg_tblspc, however the symlinks are created only
5550  * after reading tablespace_map file in case of archive recovery from
5551  * backup, so needs to clear old relcache files here after creating
5552  * symlinks.
5553  */
5555 
5556  /*
5557  * Initialize replication slots, before there's a chance to remove
5558  * required resources.
5559  */
5561 
5562  /*
5563  * Startup logical state, needs to be setup now so we have proper data
5564  * during crash recovery.
5565  */
5567 
5568  /*
5569  * Startup CLOG. This must be done after TransamVariables->nextXid has
5570  * been initialized and before we accept connections or begin WAL replay.
5571  */
5572  StartupCLOG();
5573 
5574  /*
5575  * Startup MultiXact. We need to do this early to be able to replay
5576  * truncations.
5577  */
5578  StartupMultiXact();
5579 
5580  /*
5581  * Ditto for commit timestamps. Activate the facility if the setting is
5582  * enabled in the control file, as there should be no tracking of commit
5583  * timestamps done when the setting was disabled. This facility can be
5584  * started or stopped when replaying a XLOG_PARAMETER_CHANGE record.
5585  */
5587  StartupCommitTs();
5588 
5589  /*
5590  * Recover knowledge about replay progress of known replication partners.
5591  */
5593 
5594  /*
5595  * Initialize unlogged LSN. On a clean shutdown, it's restored from the
5596  * control file. On recovery, all unlogged relations are blown away, so
5597  * the unlogged LSN counter can be reset too.
5598  */
5602  else
5605 
5606  /*
5607  * Copy any missing timeline history files between 'now' and the recovery
5608  * target timeline from archive to pg_wal. While we don't need those files
5609  * ourselves - the history file of the recovery target timeline covers all
5610  * the previous timelines in the history too - a cascading standby server
5611  * might be interested in them. Or, if you archive the WAL from this
5612  * server to a different archive than the primary, it'd be good for all
5613  * the history files to get archived there after failover, so that you can
5614  * use one of the old timelines as a PITR target. Timeline history files
5615  * are small, so it's better to copy them unnecessarily than not copy them
5616  * and regret later.
5617  */
5619 
5620  /*
5621  * Before running in recovery, scan pg_twophase and fill in its status to
5622  * be able to work on entries generated by redo. Doing a scan before
5623  * taking any recovery action has the merit to discard any 2PC files that
5624  * are newer than the first record to replay, saving from any conflicts at
5625  * replay. This avoids as well any subsequent scans when doing recovery
5626  * of the on-disk two-phase data.
5627  */
5629 
5630  /*
5631  * When starting with crash recovery, reset pgstat data - it might not be
5632  * valid. Otherwise restore pgstat data. It's safe to do this here,
5633  * because postmaster will not yet have started any other processes.
5634  *
5635  * NB: Restoring replication slot stats relies on slot state to have
5636  * already been restored from disk.
5637  *
5638  * TODO: With a bit of extra work we could just start with a pgstat file
5639  * associated with the checkpoint redo location we're starting from.
5640  */
5641  if (didCrash)
5643  else
5645 
5646  lastFullPageWrites = checkPoint.fullPageWrites;
5647 
5650 
5651  /* REDO */
5652  if (InRecovery)
5653  {
5654  /* Initialize state for RecoveryInProgress() */
5656  if (InArchiveRecovery)
5658  else
5661 
5662  /*
5663  * Update pg_control to show that we are recovering and to show the
5664  * selected checkpoint as the place we are starting from. We also mark
5665  * pg_control with any minimum recovery stop point obtained from a
5666  * backup history file.
5667  *
5668  * No need to hold ControlFileLock yet, we aren't up far enough.
5669  */
5671 
5672  /*
5673  * If there was a backup label file, it's done its job and the info
5674  * has now been propagated into pg_control. We must get rid of the
5675  * label file so that if we crash during recovery, we'll pick up at
5676  * the latest recovery restartpoint instead of going all the way back
5677  * to the backup start point. It seems prudent though to just rename
5678  * the file out of the way rather than delete it completely.
5679  */
5680  if (haveBackupLabel)
5681  {
5682  unlink(BACKUP_LABEL_OLD);
5684  }
5685 
5686  /*
5687  * If there was a tablespace_map file, it's done its job and the
5688  * symlinks have been created. We must get rid of the map file so
5689  * that if we crash during recovery, we don't create symlinks again.
5690  * It seems prudent though to just rename the file out of the way
5691  * rather than delete it completely.
5692  */
5693  if (haveTblspcMap)
5694  {
5695  unlink(TABLESPACE_MAP_OLD);
5697  }
5698 
5699  /*
5700  * Initialize our local copy of minRecoveryPoint. When doing crash
5701  * recovery we want to replay up to the end of WAL. Particularly, in
5702  * the case of a promoted standby minRecoveryPoint value in the
5703  * control file is only updated after the first checkpoint. However,
5704  * if the instance crashes before the first post-recovery checkpoint
5705  * is completed then recovery will use a stale location causing the
5706  * startup process to think that there are still invalid page
5707  * references when checking for data consistency.
5708  */
5709  if (InArchiveRecovery)
5710  {
5713  }
5714  else
5715  {
5718  }
5719 
5720  /* Check that the GUCs used to generate the WAL allow recovery */
5722 
5723  /*
5724  * We're in recovery, so unlogged relations may be trashed and must be
5725  * reset. This should be done BEFORE allowing Hot Standby
5726  * connections, so that read-only backends don't try to read whatever
5727  * garbage is left over from before.
5728  */
5730 
5731  /*
5732  * Likewise, delete any saved transaction snapshot files that got left
5733  * behind by crashed backends.
5734  */
5736 
5737  /*
5738  * Initialize for Hot Standby, if enabled. We won't let backends in
5739  * yet, not until we've reached the min recovery point specified in
5740  * control file and we've established a recovery snapshot from a
5741  * running-xacts WAL record.
5742  */
5744  {
5745  TransactionId *xids;
5746  int nxids;
5747 
5748  ereport(DEBUG1,
5749  (errmsg_internal("initializing for hot standby")));
5750 
5752 
5753  if (wasShutdown)
5754  oldestActiveXID = PrescanPreparedTransactions(&xids, &nxids);
5755  else
5756  oldestActiveXID = checkPoint.oldestActiveXid;
5757  Assert(TransactionIdIsValid(oldestActiveXID));
5758 
5759  /* Tell procarray about the range of xids it has to deal with */
5761 
5762  /*
5763  * Startup subtrans only. CLOG, MultiXact and commit timestamp
5764  * have already been started up and other SLRUs are not maintained
5765  * during recovery and need not be started yet.
5766  */
5767  StartupSUBTRANS(oldestActiveXID);
5768 
5769  /*
5770  * If we're beginning at a shutdown checkpoint, we know that
5771  * nothing was running on the primary at this point. So fake-up an
5772  * empty running-xacts record and use that here and now. Recover
5773  * additional standby state for prepared transactions.
5774  */
5775  if (wasShutdown)
5776  {
5777  RunningTransactionsData running;
5778  TransactionId latestCompletedXid;
5779 
5780  /*
5781  * Construct a RunningTransactions snapshot representing a
5782  * shut down server, with only prepared transactions still
5783  * alive. We're never overflowed at this point because all
5784  * subxids are listed with their parent prepared transactions.
5785  */
5786  running.xcnt = nxids;
5787  running.subxcnt = 0;
5788  running.subxid_overflow = false;
5789  running.nextXid = XidFromFullTransactionId(checkPoint.nextXid);
5790  running.oldestRunningXid = oldestActiveXID;
5791  latestCompletedXid = XidFromFullTransactionId(checkPoint.nextXid);
5792  TransactionIdRetreat(latestCompletedXid);
5793  Assert(TransactionIdIsNormal(latestCompletedXid));
5794  running.latestCompletedXid = latestCompletedXid;
5795  running.xids = xids;
5796 
5797  ProcArrayApplyRecoveryInfo(&running);
5798 
5800  }
5801  }
5802 
5803  /*
5804  * We're all set for replaying the WAL now. Do it.
5805  */
5807  performedWalRecovery = true;
5808  }
5809  else
5810  performedWalRecovery = false;
5811 
5812  /*
5813  * Finish WAL recovery.
5814  */
5815  endOfRecoveryInfo = FinishWalRecovery();
5816  EndOfLog = endOfRecoveryInfo->endOfLog;
5817  EndOfLogTLI = endOfRecoveryInfo->endOfLogTLI;
5818  abortedRecPtr = endOfRecoveryInfo->abortedRecPtr;
5819  missingContrecPtr = endOfRecoveryInfo->missingContrecPtr;
5820 
5821  /*
5822  * Reset ps status display, so as no information related to recovery shows
5823  * up.
5824  */
5825  set_ps_display("");
5826 
5827  /*
5828  * When recovering from a backup (we are in recovery, and archive recovery
5829  * was requested), complain if we did not roll forward far enough to reach
5830  * the point where the database is consistent. For regular online
5831  * backup-from-primary, that means reaching the end-of-backup WAL record
5832  * (at which point we reset backupStartPoint to be Invalid), for
5833  * backup-from-replica (which can't inject records into the WAL stream),
5834  * that point is when we reach the minRecoveryPoint in pg_control (which
5835  * we purposefully copy last when backing up from a replica). For
5836  * pg_rewind (which creates a backup_label with a method of "pg_rewind")
5837  * or snapshot-style backups (which don't), backupEndRequired will be set
5838  * to false.
5839  *
5840  * Note: it is indeed okay to look at the local variable
5841  * LocalMinRecoveryPoint here, even though ControlFile->minRecoveryPoint
5842  * might be further ahead --- ControlFile->minRecoveryPoint cannot have
5843  * been advanced beyond the WAL we processed.
5844  */
5845  if (InRecovery &&
5846  (EndOfLog < LocalMinRecoveryPoint ||
5848  {
5849  /*
5850  * Ran off end of WAL before reaching end-of-backup WAL record, or
5851  * minRecoveryPoint. That's a bad sign, indicating that you tried to
5852  * recover from an online backup but never called pg_backup_stop(), or
5853  * you didn't archive all the WAL needed.
5854  */
5856  {
5858  ereport(FATAL,
5859  (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
5860  errmsg("WAL ends before end of online backup"),
5861  errhint("All WAL generated while online backup was taken must be available at recovery.")));
5862  else
5863  ereport(FATAL,
5864  (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
5865  errmsg("WAL ends before consistent recovery point")));
5866  }
5867  }
5868 
5869  /*
5870  * Reset unlogged relations to the contents of their INIT fork. This is
5871  * done AFTER recovery is complete so as to include any unlogged relations
5872  * created during recovery, but BEFORE recovery is marked as having
5873  * completed successfully. Otherwise we'd not retry if any of the post
5874  * end-of-recovery steps fail.
5875  */
5876  if (InRecovery)
5878 
5879  /*
5880  * Pre-scan prepared transactions to find out the range of XIDs present.
5881  * This information is not quite needed yet, but it is positioned here so
5882  * as potential problems are detected before any on-disk change is done.
5883  */
5884  oldestActiveXID = PrescanPreparedTransactions(NULL, NULL);
5885 
5886  /*
5887  * Allow ordinary WAL segment creation before possibly switching to a new
5888  * timeline, which creates a new segment, and after the last ReadRecord().
5889  */
5891 
5892  /*
5893  * Consider whether we need to assign a new timeline ID.
5894  *
5895  * If we did archive recovery, we always assign a new ID. This handles a
5896  * couple of issues. If we stopped short of the end of WAL during
5897  * recovery, then we are clearly generating a new timeline and must assign
5898  * it a unique new ID. Even if we ran to the end, modifying the current
5899  * last segment is problematic because it may result in trying to
5900  * overwrite an already-archived copy of that segment, and we encourage
5901  * DBAs to make their archive_commands reject that. We can dodge the
5902  * problem by making the new active segment have a new timeline ID.
5903  *
5904  * In a normal crash recovery, we can just extend the timeline we were in.
5905  */
5906  newTLI = endOfRecoveryInfo->lastRecTLI;
5908  {
5909  newTLI = findNewestTimeLine(recoveryTargetTLI) + 1;
5910  ereport(LOG,
5911  (errmsg("selected new timeline ID: %u", newTLI)));
5912 
5913  /*
5914  * Make a writable copy of the last WAL segment. (Note that we also
5915  * have a copy of the last block of the old WAL in
5916  * endOfRecovery->lastPage; we will use that below.)
5917  */
5918  XLogInitNewTimeline(EndOfLogTLI, EndOfLog, newTLI);
5919 
5920  /*
5921  * Remove the signal files out of the way, so that we don't
5922  * accidentally re-enter archive recovery mode in a subsequent crash.
5923  */
5924  if (endOfRecoveryInfo->standby_signal_file_found)
5926 
5927  if (endOfRecoveryInfo->recovery_signal_file_found)
5929 
5930  /*
5931  * Write the timeline history file, and have it archived. After this
5932  * point (or rather, as soon as the file is archived), the timeline
5933  * will appear as "taken" in the WAL archive and to any standby
5934  * servers. If we crash before actually switching to the new
5935  * timeline, standby servers will nevertheless think that we switched
5936  * to the new timeline, and will try to connect to the new timeline.
5937  * To minimize the window for that, try to do as little as possible
5938  * between here and writing the end-of-recovery record.
5939  */
5941  EndOfLog, endOfRecoveryInfo->recoveryStopReason);
5942 
5943  ereport(LOG,
5944  (errmsg("archive recovery complete")));
5945  }
5946 
5947  /* Save the selected TimeLineID in shared memory, too */
5948  XLogCtl->InsertTimeLineID = newTLI;
5949  XLogCtl->PrevTimeLineID = endOfRecoveryInfo->lastRecTLI;
5950 
5951  /*
5952  * Actually, if WAL ended in an incomplete record, skip the parts that
5953  * made it through and start writing after the portion that persisted.
5954  * (It's critical to first write an OVERWRITE_CONTRECORD message, which
5955  * we'll do as soon as we're open for writing new WAL.)
5956  */
5958  {
5959  /*
5960  * We should only have a missingContrecPtr if we're not switching to a
5961  * new timeline. When a timeline switch occurs, WAL is copied from the
5962  * old timeline to the new only up to the end of the last complete
5963  * record, so there can't be an incomplete WAL record that we need to
5964  * disregard.
5965  */
5966  Assert(newTLI == endOfRecoveryInfo->lastRecTLI);
5968  EndOfLog = missingContrecPtr;
5969  }
5970 
5971  /*
5972  * Prepare to write WAL starting at EndOfLog location, and init xlog
5973  * buffer cache using the block containing the last record from the
5974  * previous incarnation.
5975  */
5976  Insert = &XLogCtl->Insert;
5977  Insert->PrevBytePos = XLogRecPtrToBytePos(endOfRecoveryInfo->lastRec);
5978  Insert->CurrBytePos = XLogRecPtrToBytePos(EndOfLog);
5979 
5980  /*
5981  * Tricky point here: lastPage contains the *last* block that the LastRec
5982  * record spans, not the one it starts in. The last block is indeed the
5983  * one we want to use.
5984  */
5985  if (EndOfLog % XLOG_BLCKSZ != 0)
5986  {
5987  char *page;
5988  int len;
5989  int firstIdx;
5990 
5991  firstIdx = XLogRecPtrToBufIdx(EndOfLog);
5992  len = EndOfLog - endOfRecoveryInfo->lastPageBeginPtr;
5993  Assert(len < XLOG_BLCKSZ);
5994 
5995  /* Copy the valid part of the last block, and zero the rest */
5996  page = &XLogCtl->pages[firstIdx * XLOG_BLCKSZ];
5997  memcpy(page, endOfRecoveryInfo->lastPage, len);
5998  memset(page + len, 0, XLOG_BLCKSZ - len);
5999 
6000  pg_atomic_write_u64(&XLogCtl->xlblocks[firstIdx], endOfRecoveryInfo->lastPageBeginPtr + XLOG_BLCKSZ);
6001  XLogCtl->InitializedUpTo = endOfRecoveryInfo->lastPageBeginPtr + XLOG_BLCKSZ;
6002  }
6003  else
6004  {
6005  /*
6006  * There is no partial block to copy. Just set InitializedUpTo, and
6007  * let the first attempt to insert a log record to initialize the next
6008  * buffer.
6009  */
6010  XLogCtl->InitializedUpTo = EndOfLog;
6011  }
6012 
6013  /*
6014  * Update local and shared status. This is OK to do without any locks
6015  * because no other process can be reading or writing WAL yet.
6016  */
6017  LogwrtResult.Write = LogwrtResult.Flush = EndOfLog;
6021  XLogCtl->LogwrtRqst.Write = EndOfLog;
6022  XLogCtl->LogwrtRqst.Flush = EndOfLog;
6023 
6024  /*
6025  * Preallocate additional log files, if wanted.
6026  */
6027  PreallocXlogFiles(EndOfLog, newTLI);
6028 
6029  /*
6030  * Okay, we're officially UP.
6031  */
6032  InRecovery = false;
6033 
6034  /* start the archive_timeout timer and LSN running */
6035  XLogCtl->lastSegSwitchTime = (pg_time_t) time(NULL);
6036  XLogCtl->lastSegSwitchLSN = EndOfLog;
6037 
6038  /* also initialize latestCompletedXid, to nextXid - 1 */
6039  LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
6042  LWLockRelease(ProcArrayLock);
6043 
6044  /*
6045  * Start up subtrans, if not already done for hot standby. (commit
6046  * timestamps are started below, if necessary.)
6047  */
6049  StartupSUBTRANS(oldestActiveXID);
6050 
6051  /*
6052  * Perform end of recovery actions for any SLRUs that need it.
6053  */
6054  TrimCLOG();
6055  TrimMultiXact();
6056 
6057  /*
6058  * Reload shared-memory state for prepared transactions. This needs to
6059  * happen before renaming the last partial segment of the old timeline as
6060  * it may be possible that we have to recovery some transactions from it.
6061  */
6063 
6064  /* Shut down xlogreader */
6066 
6067  /* Enable WAL writes for this backend only. */
6069 
6070  /* If necessary, write overwrite-contrecord before doing anything else */
6072  {
6075  }
6076 
6077  /*
6078  * Update full_page_writes in shared memory and write an XLOG_FPW_CHANGE
6079  * record before resource manager writes cleanup WAL records or checkpoint
6080  * record is written.
6081  */
6082  Insert->fullPageWrites = lastFullPageWrites;
6084 
6085  /*
6086  * Emit checkpoint or end-of-recovery record in XLOG, if required.
6087  */
6088  if (performedWalRecovery)
6089  promoted = PerformRecoveryXLogAction();
6090 
6091  /*
6092  * If any of the critical GUCs have changed, log them before we allow
6093  * backends to write WAL.
6094  */
6096 
6097  /* If this is archive recovery, perform post-recovery cleanup actions. */
6099  CleanupAfterArchiveRecovery(EndOfLogTLI, EndOfLog, newTLI);
6100 
6101  /*
6102  * Local WAL inserts enabled, so it's time to finish initialization of
6103  * commit timestamp.
6104  */
6106 
6107  /*
6108  * All done with end-of-recovery actions.
6109  *
6110  * Now allow backends to write WAL and update the control file status in
6111  * consequence. SharedRecoveryState, that controls if backends can write
6112  * WAL, is updated while holding ControlFileLock to prevent other backends
6113  * to look at an inconsistent state of the control file in shared memory.
6114  * There is still a small window during which backends can write WAL and
6115  * the control file is still referring to a system not in DB_IN_PRODUCTION
6116  * state while looking at the on-disk control file.
6117  *
6118  * Also, we use info_lck to update SharedRecoveryState to ensure that
6119  * there are no race conditions concerning visibility of other recent
6120  * updates to shared memory.
6121  */
6122  LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
6124 
6128 
6130  LWLockRelease(ControlFileLock);
6131 
6132  /*
6133  * Shutdown the recovery environment. This must occur after
6134  * RecoverPreparedTransactions() (see notes in lock_twophase_recover())
6135  * and after switching SharedRecoveryState to RECOVERY_STATE_DONE so as
6136  * any session building a snapshot will not rely on KnownAssignedXids as
6137  * RecoveryInProgress() would return false at this stage. This is
6138  * particularly critical for prepared 2PC transactions, that would still
6139  * need to be included in snapshots once recovery has ended.
6140  */
6143 
6144  /*
6145  * If there were cascading standby servers connected to us, nudge any wal
6146  * sender processes to notice that we've been promoted.
6147  */
6148  WalSndWakeup(true, true);
6149 
6150  /*
6151  * If this was a promotion, request an (online) checkpoint now. This isn't
6152  * required for consistency, but the last restartpoint might be far back,
6153  * and in case of a crash, recovering from it might take a longer than is
6154  * appropriate now that we're not in standby mode anymore.
6155  */
6156  if (promoted)
6158 }
static void pg_atomic_write_u64(volatile pg_atomic_uint64 *ptr, uint64 val)
Definition: atomics.h:480
static void pg_atomic_write_membarrier_u64(volatile pg_atomic_uint64 *ptr, uint64 val)
Definition: atomics.h:489
TimeLineID findNewestTimeLine(TimeLineID startTLI)
Definition: timeline.c:264
void restoreTimeLineHistoryFiles(TimeLineID begin, TimeLineID end)
Definition: timeline.c:50
void writeTimeLineHistory(TimeLineID newTLI, TimeLineID parentTLI, XLogRecPtr switchpoint, char *reason)
Definition: timeline.c:304
void startup_progress_timeout_handler(void)
Definition: startup.c:303
uint32 TransactionId
Definition: c.h:652
void StartupCLOG(void)
Definition: clog.c:877
void TrimCLOG(void)
Definition: clog.c:892
void StartupCommitTs(void)
Definition: commit_ts.c:632
void CompleteCommitTsInitialization(void)
Definition: commit_ts.c:642
#define FATAL
Definition: elog.h:41
int durable_rename(const char *oldfile, const char *newfile, int elevel)
Definition: fd.c:782
int durable_unlink(const char *fname, int elevel)
Definition: fd.c:872
void SyncDataDirectory(void)
Definition: fd.c:3544
#define IsBootstrapProcessingMode()
Definition: miscadmin.h:454
void TrimMultiXact(void)
Definition: multixact.c:2129
void StartupMultiXact(void)
Definition: multixact.c:2104
void StartupReplicationOrigin(void)
Definition: origin.c:699
#define ERRCODE_DATA_CORRUPTED
Definition: pg_basebackup.c:41
@ DB_IN_PRODUCTION
Definition: pg_control.h:96
@ DB_IN_CRASH_RECOVERY
Definition: pg_control.h:94
const void size_t len
void pgstat_restore_stats(void)
Definition: pgstat.c:407
void pgstat_discard_stats(void)
Definition: pgstat.c:419
void ProcArrayApplyRecoveryInfo(RunningTransactions running)
Definition: procarray.c:1054
void ProcArrayInitRecovery(TransactionId initializedUptoXID)
Definition: procarray.c:1023
static void set_ps_display(const char *activity)
Definition: ps_status.h:40
void ResetUnloggedRelations(int op)
Definition: reinit.c:47
#define UNLOGGED_RELATION_INIT
Definition: reinit.h:28
#define UNLOGGED_RELATION_CLEANUP
Definition: reinit.h:27
void RelationCacheInitFileRemove(void)
Definition: relcache.c:6794
void StartupReorderBuffer(void)
void StartupReplicationSlots(void)
Definition: slot.c:1894
void DeleteAllExportedSnapshotFiles(void)
Definition: snapmgr.c:1567
void InitRecoveryTransactionEnvironment(void)
Definition: standby.c:94
void ShutdownRecoveryTransactionEnvironment(void)
Definition: standby.c:160
bool track_commit_timestamp
Definition: pg_control.h:184
XLogRecPtr lastPageBeginPtr
Definition: xlogrecovery.h:111
XLogRecPtr abortedRecPtr
Definition: xlogrecovery.h:120
XLogRecPtr missingContrecPtr
Definition: xlogrecovery.h:121
TimeLineID endOfLogTLI
Definition: xlogrecovery.h:109
TransactionId oldestRunningXid
Definition: standby.h:84
TransactionId nextXid
Definition: standby.h:83
TransactionId latestCompletedXid
Definition: standby.h:87
TransactionId * xids
Definition: standby.h:89
FullTransactionId latestCompletedXid
Definition: transam.h:238
XLogRecPtr InitializedUpTo
Definition: xlog.c:485
char * pages
Definition: xlog.c:492
pg_time_t lastSegSwitchTime
Definition: xlog.c:467
XLogRecPtr lastSegSwitchLSN
Definition: xlog.c:468
pg_atomic_uint64 * xlblocks
Definition: xlog.c:493
pg_atomic_uint64 logWriteResult
Definition: xlog.c:472
pg_atomic_uint64 logFlushResult
Definition: xlog.c:473
pg_atomic_uint64 logInsertResult
Definition: xlog.c:471
XLogRecPtr Flush
Definition: xlog.c:322
void StartupSUBTRANS(TransactionId oldestActiveXID)
Definition: subtrans.c:309
TimeoutId RegisterTimeout(TimeoutId id, timeout_handler_proc handler)
Definition: timeout.c:505
@ STARTUP_PROGRESS_TIMEOUT
Definition: timeout.h:38
#define TransactionIdRetreat(dest)
Definition: transam.h:141
static void FullTransactionIdRetreat(FullTransactionId *dest)
Definition: transam.h:103
#define XidFromFullTransactionId(x)
Definition: transam.h:48
#define TransactionIdIsValid(xid)
Definition: transam.h:41
#define TransactionIdIsNormal(xid)
Definition: transam.h:42
void RecoverPreparedTransactions(void)
Definition: twophase.c:2084
void restoreTwoPhaseData(void)
Definition: twophase.c:1898
TransactionId PrescanPreparedTransactions(TransactionId **xids_p, int *nxids_p)
Definition: twophase.c:1962
void StandbyRecoverPreparedTransactions(void)
Definition: twophase.c:2043
void WalSndWakeup(bool physical, bool logical)
Definition: walsender.c:3666
void UpdateFullPageWrites(void)
Definition: xlog.c:8087
static char * str_time(pg_time_t tnow)
Definition: xlog.c:5165
static void ValidateXLOGDirectoryStructure(void)
Definition: xlog.c:4088
static XLogRecPtr CreateOverwriteContrecordRecord(XLogRecPtr aborted_lsn, XLogRecPtr pagePtr, TimeLineID newTLI)
Definition: xlog.c:7361
static void XLogReportParameters(void)
Definition: xlog.c:8024
static bool PerformRecoveryXLogAction(void)
Definition: xlog.c:6240
static void CleanupAfterArchiveRecovery(TimeLineID EndOfLogTLI, XLogRecPtr EndOfLog, TimeLineID newTLI)
Definition: xlog.c:5255
static bool lastFullPageWrites
Definition: xlog.c:217
static uint64 XLogRecPtrToBytePos(XLogRecPtr ptr)
Definition: xlog.c:1936
static void XLogInitNewTimeline(TimeLineID endTLI, XLogRecPtr endOfLog, TimeLineID newTLI)
Definition: xlog.c:5180
static void CheckRequiredParameterValues(void)
Definition: xlog.c:5344
#define XLogRecPtrToBufIdx(recptr)
Definition: xlog.c:586
static void RemoveTempXlogFiles(void)
Definition: xlog.c:3821
#define TABLESPACE_MAP_OLD
Definition: xlog.h:302
#define TABLESPACE_MAP
Definition: xlog.h:301
#define STANDBY_SIGNAL_FILE
Definition: xlog.h:297
#define BACKUP_LABEL_OLD
Definition: xlog.h:299
#define BACKUP_LABEL_FILE
Definition: xlog.h:298
#define RECOVERY_SIGNAL_FILE
Definition: xlog.h:296
#define XRecOffIsValid(xlrp)
#define FirstNormalUnloggedLSN
Definition: xlogdefs.h:36
void ShutdownWalRecovery(void)
bool ArchiveRecoveryRequested
Definition: xlogrecovery.c:137
bool InArchiveRecovery
Definition: xlogrecovery.c:138
void PerformWalRecovery(void)
EndOfWalRecoveryInfo * FinishWalRecovery(void)
static XLogRecPtr missingContrecPtr
Definition: xlogrecovery.c:373
static XLogRecPtr abortedRecPtr
Definition: xlogrecovery.c:372
void InitWalRecovery(ControlFileData *ControlFile, bool *wasShutdown_ptr, bool *haveBackupLabel_ptr, bool *haveTblspcMap_ptr)
Definition: xlogrecovery.c:512
TimeLineID recoveryTargetTLI
Definition: xlogrecovery.c:122
HotStandbyState standbyState
Definition: xlogutils.c:53
bool InRecovery
Definition: xlogutils.c:50
@ STANDBY_DISABLED
Definition: xlogutils.h:49

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, errcode(), ERRCODE_DATA_CORRUPTED, 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, TransamVariablesData::latestCompletedXid, RunningTransactionsData::latestCompletedXid, len, LocalMinRecoveryPoint, LocalMinRecoveryPointTLI, LocalSetXLogInsertAllowed(), LOG, XLogCtlData::logFlushResult, XLogCtlData::logInsertResult, XLogCtlData::logWriteResult, LogwrtResult, XLogCtlData::LogwrtRqst, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), ControlFileData::minRecoveryPoint, ControlFileData::minRecoveryPointTLI, missingContrecPtr, EndOfWalRecoveryInfo::missingContrecPtr, MultiXactSetNextMXact(), CheckPoint::newestCommitTsXid, CheckPoint::nextMulti, CheckPoint::nextMultiOffset, TransamVariablesData::nextOid, CheckPoint::nextOid, TransamVariablesData::nextXid, CheckPoint::nextXid, RunningTransactionsData::nextXid, NOTICE, TransamVariablesData::oidCount, CheckPoint::oldestActiveXid, CheckPoint::oldestCommitTsXid, CheckPoint::oldestMulti, CheckPoint::oldestMultiDB, RunningTransactionsData::oldestRunningXid, CheckPoint::oldestXid, CheckPoint::oldestXidDB, XLogCtlData::pages, PerformRecoveryXLogAction(), PerformWalRecovery(), pg_atomic_write_membarrier_u64(), pg_atomic_write_u64(), 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, 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, TransamVariables, 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 6165 of file xlog.c.

6166 {
6167  /* initialize minRecoveryPoint to this record */
6168  LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
6170  if (ControlFile->minRecoveryPoint < EndRecPtr)
6171  {
6172  ControlFile->minRecoveryPoint = EndRecPtr;
6173  ControlFile->minRecoveryPointTLI = replayTLI;
6174  }
6175  /* update local copy */
6178 
6179  /*
6180  * The startup process can update its local copy of minRecoveryPoint from
6181  * this point.
6182  */
6183  updateMinRecoveryPoint = true;
6184 
6186 
6187  /*
6188  * We update SharedRecoveryState while holding the lock on ControlFileLock
6189  * so both states are consistent in shared memory.
6190  */
6194 
6195  LWLockRelease(ControlFileLock);
6196 }
static bool updateMinRecoveryPoint
Definition: xlog.c:643

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 8087 of file xlog.c.

8088 {
8090  bool recoveryInProgress;
8091 
8092  /*
8093  * Do nothing if full_page_writes has not been changed.
8094  *
8095  * It's safe to check the shared full_page_writes without the lock,
8096  * because we assume that there is no concurrently running process which
8097  * can update it.
8098  */
8099  if (fullPageWrites == Insert->fullPageWrites)
8100  return;
8101 
8102  /*
8103  * Perform this outside critical section so that the WAL insert
8104  * initialization done by RecoveryInProgress() doesn't trigger an
8105  * assertion failure.
8106  */
8107  recoveryInProgress = RecoveryInProgress();
8108 
8110 
8111  /*
8112  * It's always safe to take full page images, even when not strictly
8113  * required, but not the other round. So if we're setting full_page_writes
8114  * to true, first set it true and then write the WAL record. If we're
8115  * setting it to false, first write the WAL record and then set the global
8116  * flag.
8117  */
8118  if (fullPageWrites)
8119  {
8121  Insert->fullPageWrites = true;
8123  }
8124 
8125  /*
8126  * Write an XLOG_FPW_CHANGE record. This allows us to keep track of
8127  * full_page_writes during archive recovery, if required.
8128  */
8129  if (XLogStandbyInfoActive() && !recoveryInProgress)
8130  {
8131  XLogBeginInsert();
8132  XLogRegisterData((char *) (&fullPageWrites), sizeof(bool));
8133 
8134  XLogInsert(RM_XLOG_ID, XLOG_FPW_CHANGE);
8135  }
8136 
8137  if (!fullPageWrites)
8138  {
8140  Insert->fullPageWrites = false;
8142  }
8143  END_CRIT_SECTION();
8144 }
#define XLOG_FPW_CHANGE
Definition: pg_control.h:75

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

◆ WALReadFromBuffers()

Size WALReadFromBuffers ( char *  dstbuf,
XLogRecPtr  startptr,
Size  count,
TimeLineID  tli 
)

Definition at line 1743 of file xlog.c.

1745 {
1746  char *pdst = dstbuf;
1747  XLogRecPtr recptr = startptr;
1748  XLogRecPtr inserted;
1749  Size nbytes = count;
1750 
1751  if (RecoveryInProgress() || tli != GetWALInsertionTimeLine())
1752  return 0;
1753 
1754  Assert(!XLogRecPtrIsInvalid(startptr));
1755 
1756  /*
1757  * Caller should ensure that the requested data has been inserted into WAL
1758  * buffers before we try to read it.
1759  */
1761  if (startptr + count > inserted)
1762  ereport(ERROR,
1763  errmsg("cannot read past end of generated WAL: requested %X/%X, current position %X/%X",
1764  LSN_FORMAT_ARGS(startptr + count),
1765  LSN_FORMAT_ARGS(inserted)));
1766 
1767  /*
1768  * Loop through the buffers without a lock. For each buffer, atomically
1769  * read and verify the end pointer, then copy the data out, and finally
1770  * re-read and re-verify the end pointer.
1771  *
1772  * Once a page is evicted, it never returns to the WAL buffers, so if the
1773  * end pointer matches the expected end pointer before and after we copy
1774  * the data, then the right page must have been present during the data
1775  * copy. Read barriers are necessary to ensure that the data copy actually
1776  * happens between the two verification steps.
1777  *
1778  * If either verification fails, we simply terminate the loop and return
1779  * with the data that had been already copied out successfully.
1780  */
1781  while (nbytes > 0)
1782  {
1783  uint32 offset = recptr % XLOG_BLCKSZ;
1784  int idx = XLogRecPtrToBufIdx(recptr);
1785  XLogRecPtr expectedEndPtr;
1786  XLogRecPtr endptr;
1787  const char *page;
1788  const char *psrc;
1789  Size npagebytes;
1790 
1791  /*
1792  * Calculate the end pointer we expect in the xlblocks array if the
1793  * correct page is present.
1794  */
1795  expectedEndPtr = recptr + (XLOG_BLCKSZ - offset);
1796 
1797  /*
1798  * First verification step: check that the correct page is present in
1799  * the WAL buffers.
1800  */
1801  endptr = pg_atomic_read_u64(&XLogCtl->xlblocks[idx]);
1802  if (expectedEndPtr != endptr)
1803  break;
1804 
1805  /*
1806  * The correct page is present (or was at the time the endptr was
1807  * read; must re-verify later). Calculate pointer to source data and
1808  * determine how much data to read from this page.
1809  */
1810  page = XLogCtl->pages + idx * (Size) XLOG_BLCKSZ;
1811  psrc = page + offset;
1812  npagebytes = Min(nbytes, XLOG_BLCKSZ - offset);
1813 
1814  /*
1815  * Ensure that the data copy and the first verification step are not
1816  * reordered.
1817  */
1818  pg_read_barrier();
1819 
1820  /* data copy */
1821  memcpy(pdst, psrc, npagebytes);
1822 
1823  /*
1824  * Ensure that the data copy and the second verification step are not
1825  * reordered.
1826  */
1827  pg_read_barrier();
1828 
1829  /*
1830  * Second verification step: check that the page we read from wasn't
1831  * evicted while we were copying the data.
1832  */
1833  endptr = pg_atomic_read_u64(&XLogCtl->xlblocks[idx]);
1834  if (expectedEndPtr != endptr)
1835  break;
1836 
1837  pdst += npagebytes;
1838  recptr += npagebytes;
1839  nbytes -= npagebytes;
1840  }
1841 
1842  Assert(pdst - dstbuf <= count);
1843 
1844  return pdst - dstbuf;
1845 }
Datum idx(PG_FUNCTION_ARGS)
Definition: _int_op.c:259
#define pg_read_barrier()
Definition: atomics.h:151
static uint64 pg_atomic_read_u64(volatile pg_atomic_uint64 *ptr)
Definition: atomics.h:462
#define Min(x, y)
Definition: c.h:1004
size_t Size
Definition: c.h:605
TimeLineID GetWALInsertionTimeLine(void)
Definition: xlog.c:6476

References Assert, ereport, errmsg(), ERROR, GetWALInsertionTimeLine(), idx(), XLogCtlData::logInsertResult, LSN_FORMAT_ARGS, Min, XLogCtlData::pages, pg_atomic_read_u64(), pg_read_barrier, RecoveryInProgress(), XLogCtlData::xlblocks, XLogCtl, XLogRecPtrIsInvalid, and XLogRecPtrToBufIdx.

Referenced by XLogSendPhysical().

◆ xlog_desc()

void xlog_desc ( StringInfo  buf,
struct XLogReaderState record 
)

Definition at line 37 of file xlogdesc.c.

38 {
39  char *rec = XLogRecGetData(record);
40  uint8 info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
41 
42  if (info == XLOG_CHECKPOINT_SHUTDOWN ||
43  info == XLOG_CHECKPOINT_ONLINE)
44  {
45  CheckPoint *checkpoint = (CheckPoint *) rec;
46 
47  appendStringInfo(buf, "redo %X/%X; "
48  "tli %u; prev tli %u; fpw %s; xid %u:%u; oid %u; multi %u; offset %u; "
49  "oldest xid %u in DB %u; oldest multi %u in DB %u; "
50  "oldest/newest commit timestamp xid: %u/%u; "
51  "oldest running xid %u; %s",
52  LSN_FORMAT_ARGS(checkpoint->redo),
53  checkpoint->ThisTimeLineID,
54  checkpoint->PrevTimeLineID,
55  checkpoint->fullPageWrites ? "true" : "false",
57  XidFromFullTransactionId(checkpoint->nextXid),
58  checkpoint->nextOid,
59  checkpoint->nextMulti,
60  checkpoint->nextMultiOffset,
61  checkpoint->oldestXid,
62  checkpoint->oldestXidDB,
63  checkpoint->oldestMulti,
64  checkpoint->oldestMultiDB,
65  checkpoint->oldestCommitTsXid,
66  checkpoint->newestCommitTsXid,
67  checkpoint->oldestActiveXid,
68  (info == XLOG_CHECKPOINT_SHUTDOWN) ? "shutdown" : "online");
69  }
70  else if (info == XLOG_NEXTOID)
71  {
72  Oid nextOid;
73 
74  memcpy(&nextOid, rec, sizeof(Oid));
75  appendStringInfo(buf, "%u", nextOid);
76  }
77  else if (info == XLOG_RESTORE_POINT)
78  {
79  xl_restore_point *xlrec = (xl_restore_point *) rec;
80 
82  }
83  else if (info == XLOG_FPI || info == XLOG_FPI_FOR_HINT)
84  {
85  /* no further information to print */
86  }
87  else if (info == XLOG_BACKUP_END)
88  {
89  XLogRecPtr startpoint;
90 
91  memcpy(&startpoint, rec, sizeof(XLogRecPtr));
92  appendStringInfo(buf, "%X/%X", LSN_FORMAT_ARGS(startpoint));
93  }
94  else if (info == XLOG_PARAMETER_CHANGE)
95  {
96  xl_parameter_change xlrec;
97  const char *wal_level_str;
98  const struct config_enum_entry *entry;
99 
100  memcpy(&xlrec, rec, sizeof(xl_parameter_change));
101 
102  /* Find a string representation for wal_level */
103  wal_level_str = "?";
104  for (entry = wal_level_options; entry->name; entry++)
105  {
106  if (entry->val == xlrec.wal_level)
107  {
108  wal_level_str = entry->name;
109  break;
110  }
111  }
112 
113  appendStringInfo(buf, "max_connections=%d max_worker_processes=%d "
114  "max_wal_senders=%d max_prepared_xacts=%d "
115  "max_locks_per_xact=%d wal_level=%s "
116  "wal_log_hints=%s track_commit_timestamp=%s",
117  xlrec.MaxConnections,
118  xlrec.max_worker_processes,
119  xlrec.max_wal_senders,
120  xlrec.max_prepared_xacts,
121  xlrec.max_locks_per_xact,
123  xlrec.wal_log_hints ? "on" : "off",
124  xlrec.track_commit_timestamp ? "on" : "off");
125  }
126  else if (info == XLOG_FPW_CHANGE)
127  {
128  bool fpw;
129 
130  memcpy(&fpw, rec, sizeof(bool));
131  appendStringInfoString(buf, fpw ? "true" : "false");
132  }
133  else if (info == XLOG_END_OF_RECOVERY)
134  {
135  xl_end_of_recovery xlrec;
136 
137  memcpy(&xlrec, rec, sizeof(xl_end_of_recovery));
138  appendStringInfo(buf, "tli %u; prev tli %u; time %s",
139  xlrec.ThisTimeLineID, xlrec.PrevTimeLineID,
141  }
142  else if (info == XLOG_OVERWRITE_CONTRECORD)
143  {
145 
146  memcpy(&xlrec, rec, sizeof(xl_overwrite_contrecord));
147  appendStringInfo(buf, "lsn %X/%X; time %s",
150  }
151  else if (info == XLOG_CHECKPOINT_REDO)
152  {
153  /* No details to write out */
154  }
155 }
static const char * wal_level_str(WalLevel wal_level)
unsigned char uint8
Definition: c.h:504
#define XLOG_RESTORE_POINT
Definition: pg_control.h:74
#define XLOG_OVERWRITE_CONTRECORD
Definition: pg_control.h:80
#define XLOG_FPI
Definition: pg_control.h:78
#define XLOG_FPI_FOR_HINT
Definition: pg_control.h:77
#define XLOG_NEXTOID
Definition: pg_control.h:70
#define XLOG_PARAMETER_CHANGE
Definition: pg_control.h:73
#define XLOG_END_OF_RECOVERY
Definition: pg_control.h:76
static char * buf
Definition: pg_test_fsync.c:73
void appendStringInfoString(StringInfo str, const char *s)
Definition: stringinfo.c:182
Definition: guc.h:170
const char * name
Definition: guc.h:171
int val
Definition: guc.h:172
TimeLineID PrevTimeLineID
TimestampTz end_time
TimeLineID ThisTimeLineID
char rp_name[MAXFNAMELEN]
#define EpochFromFullTransactionId(x)
Definition: transam.h:47
const struct config_enum_entry wal_level_options[]
Definition: xlogdesc.c:27
#define XLogRecGetInfo(decoder)
Definition: xlogreader.h:410
#define XLogRecGetData(decoder)
Definition: xlogreader.h:415
#define XLR_INFO_MASK
Definition: xlogrecord.h:62

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_REDO, 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 158 of file xlogdesc.c.

159 {
160  const char *id = NULL;
161 
162  switch (info & ~XLR_INFO_MASK)
163  {
165  id = "CHECKPOINT_SHUTDOWN";
166  break;
168  id = "CHECKPOINT_ONLINE";
169  break;
170  case XLOG_NOOP:
171  id = "NOOP";
172  break;
173  case XLOG_NEXTOID:
174  id = "NEXTOID";
175  break;
176  case XLOG_SWITCH:
177  id = "SWITCH";
178  break;
179  case XLOG_BACKUP_END:
180  id = "BACKUP_END";
181  break;
183  id = "PARAMETER_CHANGE";
184  break;
185  case XLOG_RESTORE_POINT:
186  id = "RESTORE_POINT";
187  break;
188  case XLOG_FPW_CHANGE:
189  id = "FPW_CHANGE";
190  break;
192  id = "END_OF_RECOVERY";
193  break;
195  id = "OVERWRITE_CONTRECORD";
196  break;
197  case XLOG_FPI:
198  id = "FPI";
199  break;
200  case XLOG_FPI_FOR_HINT:
201  id = "FPI_FOR_HINT";
202  break;
204  id = "CHECKPOINT_REDO";
205  break;
206  }
207 
208  return id;
209 }
#define XLOG_NOOP
Definition: pg_control.h:69
#define XLOG_SWITCH
Definition: pg_control.h:71

References XLOG_BACKUP_END, XLOG_CHECKPOINT_ONLINE, XLOG_CHECKPOINT_REDO, 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 8156 of file xlog.c.

8157 {
8158  uint8 info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
8159  XLogRecPtr lsn = record->EndRecPtr;
8160 
8161  /*
8162  * In XLOG rmgr, backup blocks are only used by XLOG_FPI and
8163  * XLOG_FPI_FOR_HINT records.
8164  */
8165  Assert(info == XLOG_FPI || info == XLOG_FPI_FOR_HINT ||
8166  !XLogRecHasAnyBlockRefs(record));
8167 
8168  if (info == XLOG_NEXTOID)