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 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)
 
bool GetDefaultCharSignedness (void)
 
XLogRecPtr GetFakeLSNForUnloggedRel (void)
 
Size XLOGShmemSize (void)
 
void XLOGShmemInit (void)
 
void BootStrapXLOG (uint32 data_checksum_version)
 
void InitializeWalConsistencyChecking (void)
 
void LocalProcessControlFile (bool reset)
 
WalLevel GetActiveWalLevelOnStandby (void)
 
void StartupXLOG (void)
 
void ShutdownXLOG (int code, Datum arg)
 
bool 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)
 
TimeLineID GetWALInsertionTimeLineIfSet (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 bool * wal_consistency_checking
 
PGDLLIMPORT char * wal_consistency_checking_string
 
PGDLLIMPORT bool log_checkpoints
 
PGDLLIMPORT int CommitDelay
 
PGDLLIMPORT int CommitSiblings
 
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 303 of file xlog.h.

◆ BACKUP_LABEL_OLD

#define BACKUP_LABEL_OLD   "backup_label.old"

Definition at line 304 of file xlog.h.

◆ CHECKPOINT_CAUSE_TIME

#define CHECKPOINT_CAUSE_TIME   0x0100 /* Elapsed time */

Definition at line 149 of file xlog.h.

◆ CHECKPOINT_CAUSE_XLOG

#define CHECKPOINT_CAUSE_XLOG   0x0080 /* XLOG consumption */

Definition at line 148 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 140 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 143 of file xlog.h.

◆ CHECKPOINT_FORCE

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

Definition at line 142 of file xlog.h.

◆ CHECKPOINT_IMMEDIATE

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

Definition at line 141 of file xlog.h.

◆ CHECKPOINT_IS_SHUTDOWN

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

Definition at line 139 of file xlog.h.

◆ CHECKPOINT_REQUESTED

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

Definition at line 146 of file xlog.h.

◆ CHECKPOINT_WAIT

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

Definition at line 145 of file xlog.h.

◆ PROMOTE_SIGNAL_FILE

#define PROMOTE_SIGNAL_FILE   "promote"

Definition at line 310 of file xlog.h.

◆ RECOVERY_SIGNAL_FILE

#define RECOVERY_SIGNAL_FILE   "recovery.signal"

Definition at line 301 of file xlog.h.

◆ STANDBY_SIGNAL_FILE

#define STANDBY_SIGNAL_FILE   "standby.signal"

Definition at line 302 of file xlog.h.

◆ TABLESPACE_MAP

#define TABLESPACE_MAP   "tablespace_map"

Definition at line 306 of file xlog.h.

◆ TABLESPACE_MAP_OLD

#define TABLESPACE_MAP_OLD   "tablespace_map.old"

Definition at line 307 of file xlog.h.

◆ XLOG_INCLUDE_ORIGIN

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

Definition at line 154 of file xlog.h.

◆ XLOG_MARK_UNIMPORTANT

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

Definition at line 155 of file xlog.h.

◆ XLogArchivingActive

Definition at line 99 of file xlog.h.

◆ XLogArchivingAlways

Definition at line 102 of file xlog.h.

◆ XLogHintBitIsNeeded

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

Definition at line 120 of file xlog.h.

◆ XLogIsNeeded

#define XLogIsNeeded ( )    (wal_level >= WAL_LEVEL_REPLICA)

Definition at line 109 of file xlog.h.

◆ XLogLogicalInfoActive

#define XLogLogicalInfoActive ( )    (wal_level >= WAL_LEVEL_LOGICAL)

Definition at line 126 of file xlog.h.

◆ XLogStandbyInfoActive

#define XLogStandbyInfoActive ( )    (wal_level >= WAL_LEVEL_REPLICA)

Definition at line 123 of file xlog.h.

Typedef Documentation

◆ ArchiveMode

typedef enum ArchiveMode ArchiveMode

◆ CheckpointStatsData

◆ RecoveryState

◆ SessionBackupState

◆ WALAvailability

◆ WalCompression

◆ WalLevel

typedef enum WalLevel WalLevel

Enumeration Type Documentation

◆ ArchiveMode

Enumerator
ARCHIVE_MODE_OFF 
ARCHIVE_MODE_ON 
ARCHIVE_MODE_ALWAYS 

Definition at line 63 of file xlog.h.

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

◆ RecoveryState

Enumerator
RECOVERY_STATE_CRASH 
RECOVERY_STATE_ARCHIVE 
RECOVERY_STATE_DONE 

Definition at line 89 of file xlog.h.

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

◆ SessionBackupState

Enumerator
SESSION_BACKUP_NONE 
SESSION_BACKUP_RUNNING 

Definition at line 286 of file xlog.h.

289{
@ SESSION_BACKUP_NONE
Definition: xlog.h:288

◆ WALAvailability

Enumerator
WALAVAIL_INVALID_LSN 
WALAVAIL_RESERVED 
WALAVAIL_EXTENDED 
WALAVAIL_UNRESERVED 
WALAVAIL_REMOVED 

Definition at line 187 of file xlog.h.

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

◆ WalCompression

Enumerator
WAL_COMPRESSION_NONE 
WAL_COMPRESSION_PGLZ 
WAL_COMPRESSION_LZ4 
WAL_COMPRESSION_ZSTD 

Definition at line 80 of file xlog.h.

81{
WalCompression
Definition: xlog.h:81
@ WAL_COMPRESSION_NONE
Definition: xlog.h:82
@ WAL_COMPRESSION_LZ4
Definition: xlog.h:84
@ WAL_COMPRESSION_PGLZ
Definition: xlog.h:83
@ WAL_COMPRESSION_ZSTD
Definition: xlog.h:85

◆ WalLevel

enum WalLevel
Enumerator
WAL_LEVEL_MINIMAL 
WAL_LEVEL_REPLICA 
WAL_LEVEL_LOGICAL 

Definition at line 72 of file xlog.h.

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

◆ 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 */
29};
@ 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 ( uint32  data_checksum_version)

Definition at line 5079 of file xlog.c.

5080{
5081 CheckPoint checkPoint;
5082 char *buffer;
5083 XLogPageHeader page;
5084 XLogLongPageHeader longpage;
5085 XLogRecord *record;
5086 char *recptr;
5087 uint64 sysidentifier;
5088 struct timeval tv;
5089 pg_crc32c crc;
5090
5091 /* allow ordinary WAL segment creation, like StartupXLOG() would */
5093
5094 /*
5095 * Select a hopefully-unique system identifier code for this installation.
5096 * We use the result of gettimeofday(), including the fractional seconds
5097 * field, as being about as unique as we can easily get. (Think not to
5098 * use random(), since it hasn't been seeded and there's no portable way
5099 * to seed it other than the system clock value...) The upper half of the
5100 * uint64 value is just the tv_sec part, while the lower half contains the
5101 * tv_usec part (which must fit in 20 bits), plus 12 bits from our current
5102 * PID for a little extra uniqueness. A person knowing this encoding can
5103 * determine the initialization time of the installation, which could
5104 * perhaps be useful sometimes.
5105 */
5106 gettimeofday(&tv, NULL);
5107 sysidentifier = ((uint64) tv.tv_sec) << 32;
5108 sysidentifier |= ((uint64) tv.tv_usec) << 12;
5109 sysidentifier |= getpid() & 0xFFF;
5110
5111 /* page buffer must be aligned suitably for O_DIRECT */
5112 buffer = (char *) palloc(XLOG_BLCKSZ + XLOG_BLCKSZ);
5113 page = (XLogPageHeader) TYPEALIGN(XLOG_BLCKSZ, buffer);
5114 memset(page, 0, XLOG_BLCKSZ);
5115
5116 /*
5117 * Set up information for the initial checkpoint record
5118 *
5119 * The initial checkpoint record is written to the beginning of the WAL
5120 * segment with logid=0 logseg=1. The very first WAL segment, 0/0, is not
5121 * used, so that we can use 0/0 to mean "before any valid WAL segment".
5122 */
5126 checkPoint.fullPageWrites = fullPageWrites;
5127 checkPoint.wal_level = wal_level;
5128 checkPoint.nextXid =
5130 checkPoint.nextOid = FirstGenbkiObjectId;
5131 checkPoint.nextMulti = FirstMultiXactId;
5132 checkPoint.nextMultiOffset = 0;
5134 checkPoint.oldestXidDB = Template1DbOid;
5135 checkPoint.oldestMulti = FirstMultiXactId;
5136 checkPoint.oldestMultiDB = Template1DbOid;
5139 checkPoint.time = (pg_time_t) time(NULL);
5141
5142 TransamVariables->nextXid = checkPoint.nextXid;
5143 TransamVariables->nextOid = checkPoint.nextOid;
5145 MultiXactSetNextMXact(checkPoint.nextMulti, checkPoint.nextMultiOffset);
5146 AdvanceOldestClogXid(checkPoint.oldestXid);
5147 SetTransactionIdLimit(checkPoint.oldestXid, checkPoint.oldestXidDB);
5148 SetMultiXactIdLimit(checkPoint.oldestMulti, checkPoint.oldestMultiDB, true);
5150
5151 /* Set up the XLOG page header */
5152 page->xlp_magic = XLOG_PAGE_MAGIC;
5153 page->xlp_info = XLP_LONG_HEADER;
5156 longpage = (XLogLongPageHeader) page;
5157 longpage->xlp_sysid = sysidentifier;
5158 longpage->xlp_seg_size = wal_segment_size;
5159 longpage->xlp_xlog_blcksz = XLOG_BLCKSZ;
5160
5161 /* Insert the initial checkpoint record */
5162 recptr = ((char *) page + SizeOfXLogLongPHD);
5163 record = (XLogRecord *) recptr;
5164 record->xl_prev = 0;
5165 record->xl_xid = InvalidTransactionId;
5166 record->xl_tot_len = SizeOfXLogRecord + SizeOfXLogRecordDataHeaderShort + sizeof(checkPoint);
5168 record->xl_rmid = RM_XLOG_ID;
5169 recptr += SizeOfXLogRecord;
5170 /* fill the XLogRecordDataHeaderShort struct */
5171 *(recptr++) = (char) XLR_BLOCK_ID_DATA_SHORT;
5172 *(recptr++) = sizeof(checkPoint);
5173 memcpy(recptr, &checkPoint, sizeof(checkPoint));
5174 recptr += sizeof(checkPoint);
5175 Assert(recptr - (char *) record == record->xl_tot_len);
5176
5178 COMP_CRC32C(crc, ((char *) record) + SizeOfXLogRecord, record->xl_tot_len - SizeOfXLogRecord);
5179 COMP_CRC32C(crc, (char *) record, offsetof(XLogRecord, xl_crc));
5180 FIN_CRC32C(crc);
5181 record->xl_crc = crc;
5182
5183 /* Create first XLOG segment file */
5186
5187 /*
5188 * We needn't bother with Reserve/ReleaseExternalFD here, since we'll
5189 * close the file again in a moment.
5190 */
5191
5192 /* Write the first page with the initial record */
5193 errno = 0;
5194 pgstat_report_wait_start(WAIT_EVENT_WAL_BOOTSTRAP_WRITE);
5195 if (write(openLogFile, page, XLOG_BLCKSZ) != XLOG_BLCKSZ)
5196 {
5197 /* if write didn't set errno, assume problem is no disk space */
5198 if (errno == 0)
5199 errno = ENOSPC;
5200 ereport(PANIC,
5202 errmsg("could not write bootstrap write-ahead log file: %m")));
5203 }
5205
5206 pgstat_report_wait_start(WAIT_EVENT_WAL_BOOTSTRAP_SYNC);
5207 if (pg_fsync(openLogFile) != 0)
5208 ereport(PANIC,
5210 errmsg("could not fsync bootstrap write-ahead log file: %m")));
5212
5213 if (close(openLogFile) != 0)
5214 ereport(PANIC,
5216 errmsg("could not close bootstrap write-ahead log file: %m")));
5217
5218 openLogFile = -1;
5219
5220 /* Now create pg_control */
5221 InitControlFile(sysidentifier, data_checksum_version);
5222 ControlFile->time = checkPoint.time;
5223 ControlFile->checkPoint = checkPoint.redo;
5224 ControlFile->checkPointCopy = checkPoint;
5225
5226 /* some additional ControlFile fields are set in WriteControlFile() */
5228
5229 /* Bootstrap the commit log, too */
5230 BootStrapCLOG();
5234
5235 pfree(buffer);
5236
5237 /*
5238 * Force control file to be read - in contrast to normal processing we'd
5239 * otherwise never run the checks and GUC related initializations therein.
5240 */
5242}
#define TYPEALIGN(ALIGNVAL, LEN)
Definition: c.h:775
uint64_t uint64
Definition: c.h:503
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:876
int errmsg(const char *fmt,...)
Definition: elog.c:1070
#define PANIC
Definition: elog.h:42
#define ereport(elevel,...)
Definition: elog.h:149
int pg_fsync(int fd)
Definition: fd.c:385
Assert(PointerIsAligned(start, uint64))
#define close(a)
Definition: win32.h:12
#define write(a, b, c)
Definition: win32.h:14
void pfree(void *pointer)
Definition: mcxt.c:1524
void * palloc(Size size)
Definition: mcxt.c:1317
void MultiXactSetNextMXact(MultiXactId nextMulti, MultiXactOffset nextMultiOffset)
Definition: multixact.c:2328
void SetMultiXactIdLimit(MultiXactId oldest_datminmxid, Oid oldest_datoid, bool is_startup)
Definition: multixact.c:2362
void BootStrapMultiXact(void)
Definition: multixact.c:2034
#define FirstMultiXactId
Definition: multixact.h:25
#define XLOG_CHECKPOINT_SHUTDOWN
Definition: pg_control.h:68
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:51
MultiXactId oldestMulti
Definition: pg_control.h:50
MultiXactOffset nextMultiOffset
Definition: pg_control.h:47
TransactionId newestCommitTsXid
Definition: pg_control.h:55
TransactionId oldestXid
Definition: pg_control.h:48
TimeLineID PrevTimeLineID
Definition: pg_control.h:40
TimeLineID ThisTimeLineID
Definition: pg_control.h:39
Oid nextOid
Definition: pg_control.h:45
TransactionId oldestActiveXid
Definition: pg_control.h:64
bool fullPageWrites
Definition: pg_control.h:42
MultiXactId nextMulti
Definition: pg_control.h:46
FullTransactionId nextXid
Definition: pg_control.h:44
TransactionId oldestCommitTsXid
Definition: pg_control.h:53
pg_time_t time
Definition: pg_control.h:52
int wal_level
Definition: pg_control.h:43
XLogRecPtr redo
Definition: pg_control.h:37
Oid oldestXidDB
Definition: pg_control.h:49
CheckPoint checkPointCopy
Definition: pg_control.h:135
pg_time_t time
Definition: pg_control.h:132
XLogRecPtr checkPoint
Definition: pg_control.h:133
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:85
static void pgstat_report_wait_end(void)
Definition: wait_event.h:101
int gettimeofday(struct timeval *tp, void *tzp)
int XLogFileInit(XLogSegNo logsegno, TimeLineID logtli)
Definition: xlog.c:3386
bool fullPageWrites
Definition: xlog.c:122
static void InitControlFile(uint64 sysidentifier, uint32 data_checksum_version)
Definition: xlog.c:4210
void SetInstallXLogFileSegmentActive(void)
Definition: xlog.c:9519
static int openLogFile
Definition: xlog.c:635
int wal_level
Definition: xlog.c:131
static void WriteControlFile(void)
Definition: xlog.c:4245
int wal_segment_size
Definition: xlog.c:143
static TimeLineID openLogTLI
Definition: xlog.c:637
static ControlFileData * ControlFile
Definition: xlog.c:574
#define BootstrapTimeLineID
Definition: xlog.c:111
static void ReadControlFile(void)
Definition: xlog.c:4354
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_level, CheckPoint::wal_level, 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 3733 of file xlog.c.

3734{
3735 int save_errno = errno;
3736 XLogSegNo lastRemovedSegNo;
3737
3739 lastRemovedSegNo = XLogCtl->lastRemovedSegNo;
3741
3742 if (segno <= lastRemovedSegNo)
3743 {
3744 char filename[MAXFNAMELEN];
3745
3747 errno = save_errno;
3748 ereport(ERROR,
3750 errmsg("requested WAL segment %s has already been removed",
3751 filename)));
3752 }
3753 errno = save_errno;
3754}
#define ERROR
Definition: elog.h:39
static char * filename
Definition: pg_dumpall.c:124
#define SpinLockRelease(lock)
Definition: spin.h:61
#define SpinLockAcquire(lock)
Definition: spin.h:59
slock_t info_lck
Definition: xlog.c:553
XLogSegNo lastRemovedSegNo
Definition: xlog.c:461
static XLogCtlData * XLogCtl
Definition: xlog.c:566
#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()

bool CreateCheckPoint ( int  flags)

Definition at line 6935 of file xlog.c.

6936{
6937 bool shutdown;
6938 CheckPoint checkPoint;
6939 XLogRecPtr recptr;
6940 XLogSegNo _logSegNo;
6942 uint32 freespace;
6943 XLogRecPtr PriorRedoPtr;
6944 XLogRecPtr last_important_lsn;
6945 VirtualTransactionId *vxids;
6946 int nvxids;
6947 int oldXLogAllowed = 0;
6948
6949 /*
6950 * An end-of-recovery checkpoint is really a shutdown checkpoint, just
6951 * issued at a different time.
6952 */
6954 shutdown = true;
6955 else
6956 shutdown = false;
6957
6958 /* sanity check */
6959 if (RecoveryInProgress() && (flags & CHECKPOINT_END_OF_RECOVERY) == 0)
6960 elog(ERROR, "can't create a checkpoint during recovery");
6961
6962 /*
6963 * Prepare to accumulate statistics.
6964 *
6965 * Note: because it is possible for log_checkpoints to change while a
6966 * checkpoint proceeds, we always accumulate stats, even if
6967 * log_checkpoints is currently off.
6968 */
6971
6972 /*
6973 * Let smgr prepare for checkpoint; this has to happen outside the
6974 * critical section and before we determine the REDO pointer. Note that
6975 * smgr must not do anything that'd have to be undone if we decide no
6976 * checkpoint is needed.
6977 */
6979
6980 /*
6981 * Use a critical section to force system panic if we have trouble.
6982 */
6984
6985 if (shutdown)
6986 {
6987 LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
6990 LWLockRelease(ControlFileLock);
6991 }
6992
6993 /* Begin filling in the checkpoint WAL record */
6994 MemSet(&checkPoint, 0, sizeof(checkPoint));
6995 checkPoint.time = (pg_time_t) time(NULL);
6996
6997 /*
6998 * For Hot Standby, derive the oldestActiveXid before we fix the redo
6999 * pointer. This allows us to begin accumulating changes to assemble our
7000 * starting snapshot of locks and transactions.
7001 */
7002 if (!shutdown && XLogStandbyInfoActive())
7004 else
7006
7007 /*
7008 * Get location of last important record before acquiring insert locks (as
7009 * GetLastImportantRecPtr() also locks WAL locks).
7010 */
7011 last_important_lsn = GetLastImportantRecPtr();
7012
7013 /*
7014 * If this isn't a shutdown or forced checkpoint, and if there has been no
7015 * WAL activity requiring a checkpoint, skip it. The idea here is to
7016 * avoid inserting duplicate checkpoints when the system is idle.
7017 */
7019 CHECKPOINT_FORCE)) == 0)
7020 {
7021 if (last_important_lsn == ControlFile->checkPoint)
7022 {
7025 (errmsg_internal("checkpoint skipped because system is idle")));
7026 return false;
7027 }
7028 }
7029
7030 /*
7031 * An end-of-recovery checkpoint is created before anyone is allowed to
7032 * write WAL. To allow us to write the checkpoint record, temporarily
7033 * enable XLogInsertAllowed.
7034 */
7035 if (flags & CHECKPOINT_END_OF_RECOVERY)
7036 oldXLogAllowed = LocalSetXLogInsertAllowed();
7037
7039 if (flags & CHECKPOINT_END_OF_RECOVERY)
7041 else
7042 checkPoint.PrevTimeLineID = checkPoint.ThisTimeLineID;
7043
7044 /*
7045 * We must block concurrent insertions while examining insert state.
7046 */
7048
7049 checkPoint.fullPageWrites = Insert->fullPageWrites;
7050 checkPoint.wal_level = wal_level;
7051
7052 if (shutdown)
7053 {
7054 XLogRecPtr curInsert = XLogBytePosToRecPtr(Insert->CurrBytePos);
7055
7056 /*
7057 * Compute new REDO record ptr = location of next XLOG record.
7058 *
7059 * Since this is a shutdown checkpoint, there can't be any concurrent
7060 * WAL insertion.
7061 */
7062 freespace = INSERT_FREESPACE(curInsert);
7063 if (freespace == 0)
7064 {
7065 if (XLogSegmentOffset(curInsert, wal_segment_size) == 0)
7066 curInsert += SizeOfXLogLongPHD;
7067 else
7068 curInsert += SizeOfXLogShortPHD;
7069 }
7070 checkPoint.redo = curInsert;
7071
7072 /*
7073 * Here we update the shared RedoRecPtr for future XLogInsert calls;
7074 * this must be done while holding all the insertion locks.
7075 *
7076 * Note: if we fail to complete the checkpoint, RedoRecPtr will be
7077 * left pointing past where it really needs to point. This is okay;
7078 * the only consequence is that XLogInsert might back up whole buffers
7079 * that it didn't really need to. We can't postpone advancing
7080 * RedoRecPtr because XLogInserts that happen while we are dumping
7081 * buffers must assume that their buffer changes are not included in
7082 * the checkpoint.
7083 */
7084 RedoRecPtr = XLogCtl->Insert.RedoRecPtr = checkPoint.redo;
7085 }
7086
7087 /*
7088 * Now we can release the WAL insertion locks, allowing other xacts to
7089 * proceed while we are flushing disk buffers.
7090 */
7092
7093 /*
7094 * If this is an online checkpoint, we have not yet determined the redo
7095 * point. We do so now by inserting the special XLOG_CHECKPOINT_REDO
7096 * record; the LSN at which it starts becomes the new redo pointer. We
7097 * don't do this for a shutdown checkpoint, because in that case no WAL
7098 * can be written between the redo point and the insertion of the
7099 * checkpoint record itself, so the checkpoint record itself serves to
7100 * mark the redo point.
7101 */
7102 if (!shutdown)
7103 {
7104 /* Include WAL level in record for WAL summarizer's benefit. */
7107 (void) XLogInsert(RM_XLOG_ID, XLOG_CHECKPOINT_REDO);
7108
7109 /*
7110 * XLogInsertRecord will have updated XLogCtl->Insert.RedoRecPtr in
7111 * shared memory and RedoRecPtr in backend-local memory, but we need
7112 * to copy that into the record that will be inserted when the
7113 * checkpoint is complete.
7114 */
7115 checkPoint.redo = RedoRecPtr;
7116 }
7117
7118 /* Update the info_lck-protected copy of RedoRecPtr as well */
7120 XLogCtl->RedoRecPtr = checkPoint.redo;
7122
7123 /*
7124 * If enabled, log checkpoint start. We postpone this until now so as not
7125 * to log anything if we decided to skip the checkpoint.
7126 */
7127 if (log_checkpoints)
7128 LogCheckpointStart(flags, false);
7129
7130 /* Update the process title */
7131 update_checkpoint_display(flags, false, false);
7132
7133 TRACE_POSTGRESQL_CHECKPOINT_START(flags);
7134
7135 /*
7136 * Get the other info we need for the checkpoint record.
7137 *
7138 * We don't need to save oldestClogXid in the checkpoint, it only matters
7139 * for the short period in which clog is being truncated, and if we crash
7140 * during that we'll redo the clog truncation and fix up oldestClogXid
7141 * there.
7142 */
7143 LWLockAcquire(XidGenLock, LW_SHARED);
7144 checkPoint.nextXid = TransamVariables->nextXid;
7145 checkPoint.oldestXid = TransamVariables->oldestXid;
7147 LWLockRelease(XidGenLock);
7148
7149 LWLockAcquire(CommitTsLock, LW_SHARED);
7152 LWLockRelease(CommitTsLock);
7153
7154 LWLockAcquire(OidGenLock, LW_SHARED);
7155 checkPoint.nextOid = TransamVariables->nextOid;
7156 if (!shutdown)
7157 checkPoint.nextOid += TransamVariables->oidCount;
7158 LWLockRelease(OidGenLock);
7159
7160 MultiXactGetCheckptMulti(shutdown,
7161 &checkPoint.nextMulti,
7162 &checkPoint.nextMultiOffset,
7163 &checkPoint.oldestMulti,
7164 &checkPoint.oldestMultiDB);
7165
7166 /*
7167 * Having constructed the checkpoint record, ensure all shmem disk buffers
7168 * and commit-log buffers are flushed to disk.
7169 *
7170 * This I/O could fail for various reasons. If so, we will fail to
7171 * complete the checkpoint, but there is no reason to force a system
7172 * panic. Accordingly, exit critical section while doing it.
7173 */
7175
7176 /*
7177 * In some cases there are groups of actions that must all occur on one
7178 * side or the other of a checkpoint record. Before flushing the
7179 * checkpoint record we must explicitly wait for any backend currently
7180 * performing those groups of actions.
7181 *
7182 * One example is end of transaction, so we must wait for any transactions
7183 * that are currently in commit critical sections. If an xact inserted
7184 * its commit record into XLOG just before the REDO point, then a crash
7185 * restart from the REDO point would not replay that record, which means
7186 * that our flushing had better include the xact's update of pg_xact. So
7187 * we wait till he's out of his commit critical section before proceeding.
7188 * See notes in RecordTransactionCommit().
7189 *
7190 * Because we've already released the insertion locks, this test is a bit
7191 * fuzzy: it is possible that we will wait for xacts we didn't really need
7192 * to wait for. But the delay should be short and it seems better to make
7193 * checkpoint take a bit longer than to hold off insertions longer than
7194 * necessary. (In fact, the whole reason we have this issue is that xact.c
7195 * does commit record XLOG insertion and clog update as two separate steps
7196 * protected by different locks, but again that seems best on grounds of
7197 * minimizing lock contention.)
7198 *
7199 * A transaction that has not yet set delayChkptFlags when we look cannot
7200 * be at risk, since it has not inserted its commit record yet; and one
7201 * that's already cleared it is not at risk either, since it's done fixing
7202 * clog and we will correctly flush the update below. So we cannot miss
7203 * any xacts we need to wait for.
7204 */
7206 if (nvxids > 0)
7207 {
7208 do
7209 {
7210 /*
7211 * Keep absorbing fsync requests while we wait. There could even
7212 * be a deadlock if we don't, if the process that prevents the
7213 * checkpoint is trying to add a request to the queue.
7214 */
7216
7217 pgstat_report_wait_start(WAIT_EVENT_CHECKPOINT_DELAY_START);
7218 pg_usleep(10000L); /* wait for 10 msec */
7220 } while (HaveVirtualXIDsDelayingChkpt(vxids, nvxids,
7222 }
7223 pfree(vxids);
7224
7225 CheckPointGuts(checkPoint.redo, flags);
7226
7228 if (nvxids > 0)
7229 {
7230 do
7231 {
7233
7234 pgstat_report_wait_start(WAIT_EVENT_CHECKPOINT_DELAY_COMPLETE);
7235 pg_usleep(10000L); /* wait for 10 msec */
7237 } while (HaveVirtualXIDsDelayingChkpt(vxids, nvxids,
7239 }
7240 pfree(vxids);
7241
7242 /*
7243 * Take a snapshot of running transactions and write this to WAL. This
7244 * allows us to reconstruct the state of running transactions during
7245 * archive recovery, if required. Skip, if this info disabled.
7246 *
7247 * If we are shutting down, or Startup process is completing crash
7248 * recovery we don't need to write running xact data.
7249 */
7250 if (!shutdown && XLogStandbyInfoActive())
7252
7254
7255 /*
7256 * Now insert the checkpoint record into XLOG.
7257 */
7259 XLogRegisterData(&checkPoint, sizeof(checkPoint));
7260 recptr = XLogInsert(RM_XLOG_ID,
7261 shutdown ? XLOG_CHECKPOINT_SHUTDOWN :
7263
7264 XLogFlush(recptr);
7265
7266 /*
7267 * We mustn't write any new WAL after a shutdown checkpoint, or it will be
7268 * overwritten at next startup. No-one should even try, this just allows
7269 * sanity-checking. In the case of an end-of-recovery checkpoint, we want
7270 * to just temporarily disable writing until the system has exited
7271 * recovery.
7272 */
7273 if (shutdown)
7274 {
7275 if (flags & CHECKPOINT_END_OF_RECOVERY)
7276 LocalXLogInsertAllowed = oldXLogAllowed;
7277 else
7278 LocalXLogInsertAllowed = 0; /* never again write WAL */
7279 }
7280
7281 /*
7282 * We now have ProcLastRecPtr = start of actual checkpoint record, recptr
7283 * = end of actual checkpoint record.
7284 */
7285 if (shutdown && checkPoint.redo != ProcLastRecPtr)
7286 ereport(PANIC,
7287 (errmsg("concurrent write-ahead log activity while database system is shutting down")));
7288
7289 /*
7290 * Remember the prior checkpoint's redo ptr for
7291 * UpdateCheckPointDistanceEstimate()
7292 */
7293 PriorRedoPtr = ControlFile->checkPointCopy.redo;
7294
7295 /*
7296 * Update the control file.
7297 */
7298 LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
7299 if (shutdown)
7302 ControlFile->checkPointCopy = checkPoint;
7303 /* crash recovery should always recover to the end of WAL */
7306
7307 /*
7308 * Persist unloggedLSN value. It's reset on crash recovery, so this goes
7309 * unused on non-shutdown checkpoints, but seems useful to store it always
7310 * for debugging purposes.
7311 */
7313
7315 LWLockRelease(ControlFileLock);
7316
7317 /* Update shared-memory copy of checkpoint XID/epoch */
7319 XLogCtl->ckptFullXid = checkPoint.nextXid;
7321
7322 /*
7323 * We are now done with critical updates; no need for system panic if we
7324 * have trouble while fooling with old log segments.
7325 */
7327
7328 /*
7329 * WAL summaries end when the next XLOG_CHECKPOINT_REDO or
7330 * XLOG_CHECKPOINT_SHUTDOWN record is reached. This is the first point
7331 * where (a) we're not inside of a critical section and (b) we can be
7332 * certain that the relevant record has been flushed to disk, which must
7333 * happen before it can be summarized.
7334 *
7335 * If this is a shutdown checkpoint, then this happens reasonably
7336 * promptly: we've only just inserted and flushed the
7337 * XLOG_CHECKPOINT_SHUTDOWN record. If this is not a shutdown checkpoint,
7338 * then this might not be very prompt at all: the XLOG_CHECKPOINT_REDO
7339 * record was written before we began flushing data to disk, and that
7340 * could be many minutes ago at this point. However, we don't XLogFlush()
7341 * after inserting that record, so we're not guaranteed that it's on disk
7342 * until after the above call that flushes the XLOG_CHECKPOINT_ONLINE
7343 * record.
7344 */
7346
7347 /*
7348 * Let smgr do post-checkpoint cleanup (eg, deleting old files).
7349 */
7351
7352 /*
7353 * Update the average distance between checkpoints if the prior checkpoint
7354 * exists.
7355 */
7356 if (PriorRedoPtr != InvalidXLogRecPtr)
7358
7359 /*
7360 * Delete old log files, those no longer needed for last checkpoint to
7361 * prevent the disk holding the xlog from growing full.
7362 */
7364 KeepLogSeg(recptr, &_logSegNo);
7366 _logSegNo, InvalidOid,
7368 {
7369 /*
7370 * Some slots have been invalidated; recalculate the old-segment
7371 * horizon, starting again from RedoRecPtr.
7372 */
7374 KeepLogSeg(recptr, &_logSegNo);
7375 }
7376 _logSegNo--;
7377 RemoveOldXlogFiles(_logSegNo, RedoRecPtr, recptr,
7378 checkPoint.ThisTimeLineID);
7379
7380 /*
7381 * Make more log segments if needed. (Do this after recycling old log
7382 * segments, since that may supply some of the needed files.)
7383 */
7384 if (!shutdown)
7385 PreallocXlogFiles(recptr, checkPoint.ThisTimeLineID);
7386
7387 /*
7388 * Truncate pg_subtrans if possible. We can throw away all data before
7389 * the oldest XMIN of any running transaction. No future transaction will
7390 * attempt to reference any pg_subtrans entry older than that (see Asserts
7391 * in subtrans.c). During recovery, though, we mustn't do this because
7392 * StartupSUBTRANS hasn't been called yet.
7393 */
7394 if (!RecoveryInProgress())
7396
7397 /* Real work is done; log and update stats. */
7398 LogCheckpointEnd(false);
7399
7400 /* Reset the process title */
7401 update_checkpoint_display(flags, false, true);
7402
7403 TRACE_POSTGRESQL_CHECKPOINT_DONE(CheckpointStats.ckpt_bufs_written,
7404 NBuffers,
7408
7409 return true;
7410}
static uint64 pg_atomic_read_membarrier_u64(volatile pg_atomic_uint64 *ptr)
Definition: atomics.h:476
TimestampTz GetCurrentTimestamp(void)
Definition: timestamp.c:1644
uint32_t uint32
Definition: c.h:502
#define MemSet(start, val, len)
Definition: c.h:991
void AbsorbSyncRequests(void)
int errmsg_internal(const char *fmt,...)
Definition: elog.c:1157
#define DEBUG1
Definition: elog.h:30
#define elog(elevel,...)
Definition: elog.h:225
static void Insert(File file)
Definition: fd.c:1312
int NBuffers
Definition: globals.c:141
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1179
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1899
@ 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:2282
#define XLOG_CHECKPOINT_REDO
Definition: pg_control.h:82
@ DB_SHUTDOWNING
Definition: pg_control.h:94
@ DB_SHUTDOWNED
Definition: pg_control.h:92
#define XLOG_CHECKPOINT_ONLINE
Definition: pg_control.h:69
#define InvalidOid
Definition: postgres_ext.h:37
#define DELAY_CHKPT_START
Definition: proc.h:120
#define DELAY_CHKPT_COMPLETE
Definition: proc.h:121
TransactionId GetOldestActiveTransactionId(void)
Definition: procarray.c:2880
TransactionId GetOldestTransactionIdConsideredRunning(void)
Definition: procarray.c:2034
bool HaveVirtualXIDsDelayingChkpt(VirtualTransactionId *vxids, int nvxids, int type)
Definition: procarray.c:3089
VirtualTransactionId * GetVirtualXIDsDelayingChkpt(int *nvxids, int type)
Definition: procarray.c:3043
void pg_usleep(long microsec)
Definition: signal.c:53
bool InvalidateObsoleteReplicationSlots(uint32 possible_causes, XLogSegNo oldestSegno, Oid dboid, TransactionId snapshotConflictHorizon)
Definition: slot.c:1976
@ RS_INVAL_WAL_REMOVED
Definition: slot.h:55
@ RS_INVAL_IDLE_TIMEOUT
Definition: slot.h:61
XLogRecPtr LogStandbySnapshot(void)
Definition: standby.c:1281
TimestampTz ckpt_start_t
Definition: xlog.h:161
int ckpt_segs_removed
Definition: xlog.h:171
int ckpt_segs_added
Definition: xlog.h:170
int ckpt_bufs_written
Definition: xlog.h:167
int ckpt_segs_recycled
Definition: xlog.h:172
XLogRecPtr minRecoveryPoint
Definition: pg_control.h:168
XLogRecPtr unloggedLSN
Definition: pg_control.h:137
TimeLineID minRecoveryPointTLI
Definition: pg_control.h:169
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:509
XLogRecPtr RedoRecPtr
Definition: xlog.c:456
XLogCtlInsert Insert
Definition: xlog.c:452
TimeLineID PrevTimeLineID
Definition: xlog.c:510
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 WakeupWalSummarizer(void)
XLogRecPtr ProcLastRecPtr
Definition: xlog.c:253
bool RecoveryInProgress(void)
Definition: xlog.c:6380
static void WALInsertLockRelease(void)
Definition: xlog.c:1445
static XLogRecPtr XLogBytePosToRecPtr(uint64 bytepos)
Definition: xlog.c:1858
static void WALInsertLockAcquireExclusive(void)
Definition: xlog.c:1416
static void UpdateControlFile(void)
Definition: xlog.c:4592
static void RemoveOldXlogFiles(XLogSegNo segno, XLogRecPtr lastredoptr, XLogRecPtr endptr, TimeLineID insertTLI)
Definition: xlog.c:3871
static void LogCheckpointStart(int flags, bool restartpoint)
Definition: xlog.c:6695
static XLogRecPtr RedoRecPtr
Definition: xlog.c:273
static void LogCheckpointEnd(bool restartpoint)
Definition: xlog.c:6727
static void PreallocXlogFiles(XLogRecPtr endptr, TimeLineID tli)
Definition: xlog.c:3696
bool log_checkpoints
Definition: xlog.c:129
static void KeepLogSeg(XLogRecPtr recptr, XLogSegNo *logSegNo)
Definition: xlog.c:7999
static int LocalSetXLogInsertAllowed(void)
Definition: xlog.c:6468
XLogRecPtr GetLastImportantRecPtr(void)
Definition: xlog.c:6602
static void UpdateCheckPointDistanceEstimate(uint64 nbytes)
Definition: xlog.c:6832
#define INSERT_FREESPACE(endptr)
Definition: xlog.c:580
static int LocalXLogInsertAllowed
Definition: xlog.c:236
CheckpointStatsData CheckpointStats
Definition: xlog.c:209
void XLogFlush(XLogRecPtr record)
Definition: xlog.c:2790
static void CheckPointGuts(XLogRecPtr checkPointRedo, int flags)
Definition: xlog.c:7556
static void update_checkpoint_display(int flags, bool restartpoint, bool reset)
Definition: xlog.c:6870
#define CHECKPOINT_END_OF_RECOVERY
Definition: xlog.h:140
#define CHECKPOINT_FORCE
Definition: xlog.h:142
#define CHECKPOINT_IS_SHUTDOWN
Definition: xlog.h:139
#define XLogStandbyInfoActive()
Definition: xlog.h:123
#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
XLogRecPtr XLogInsert(RmgrId rmid, uint8 info)
Definition: xloginsert.c:474
void XLogRegisterData(const void *data, uint32 len)
Definition: xloginsert.c:364
void XLogBeginInsert(void)
Definition: xloginsert.c:149

References AbsorbSyncRequests(), 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_IDLE_TIMEOUT, RS_INVAL_WAL_REMOVED, 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(), WakeupWalSummarizer(), wal_level, CheckPoint::wal_level, 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 7637 of file xlog.c.

7638{
7639 XLogRecPtr lastCheckPointRecPtr;
7640 XLogRecPtr lastCheckPointEndPtr;
7641 CheckPoint lastCheckPoint;
7642 XLogRecPtr PriorRedoPtr;
7643 XLogRecPtr receivePtr;
7644 XLogRecPtr replayPtr;
7645 TimeLineID replayTLI;
7646 XLogRecPtr endptr;
7647 XLogSegNo _logSegNo;
7648 TimestampTz xtime;
7649
7650 /* Concurrent checkpoint/restartpoint cannot happen */
7652
7653 /* Get a local copy of the last safe checkpoint record. */
7655 lastCheckPointRecPtr = XLogCtl->lastCheckPointRecPtr;
7656 lastCheckPointEndPtr = XLogCtl->lastCheckPointEndPtr;
7657 lastCheckPoint = XLogCtl->lastCheckPoint;
7659
7660 /*
7661 * Check that we're still in recovery mode. It's ok if we exit recovery
7662 * mode after this check, the restart point is valid anyway.
7663 */
7664 if (!RecoveryInProgress())
7665 {
7667 (errmsg_internal("skipping restartpoint, recovery has already ended")));
7668 return false;
7669 }
7670
7671 /*
7672 * If the last checkpoint record we've replayed is already our last
7673 * restartpoint, we can't perform a new restart point. We still update
7674 * minRecoveryPoint in that case, so that if this is a shutdown restart
7675 * point, we won't start up earlier than before. That's not strictly
7676 * necessary, but when hot standby is enabled, it would be rather weird if
7677 * the database opened up for read-only connections at a point-in-time
7678 * before the last shutdown. Such time travel is still possible in case of
7679 * immediate shutdown, though.
7680 *
7681 * We don't explicitly advance minRecoveryPoint when we do create a
7682 * restartpoint. It's assumed that flushing the buffers will do that as a
7683 * side-effect.
7684 */
7685 if (XLogRecPtrIsInvalid(lastCheckPointRecPtr) ||
7686 lastCheckPoint.redo <= ControlFile->checkPointCopy.redo)
7687 {
7689 (errmsg_internal("skipping restartpoint, already performed at %X/%X",
7690 LSN_FORMAT_ARGS(lastCheckPoint.redo))));
7691
7693 if (flags & CHECKPOINT_IS_SHUTDOWN)
7694 {
7695 LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
7698 LWLockRelease(ControlFileLock);
7699 }
7700 return false;
7701 }
7702
7703 /*
7704 * Update the shared RedoRecPtr so that the startup process can calculate
7705 * the number of segments replayed since last restartpoint, and request a
7706 * restartpoint if it exceeds CheckPointSegments.
7707 *
7708 * Like in CreateCheckPoint(), hold off insertions to update it, although
7709 * during recovery this is just pro forma, because no WAL insertions are
7710 * happening.
7711 */
7713 RedoRecPtr = XLogCtl->Insert.RedoRecPtr = lastCheckPoint.redo;
7715
7716 /* Also update the info_lck-protected copy */
7718 XLogCtl->RedoRecPtr = lastCheckPoint.redo;
7720
7721 /*
7722 * Prepare to accumulate statistics.
7723 *
7724 * Note: because it is possible for log_checkpoints to change while a
7725 * checkpoint proceeds, we always accumulate stats, even if
7726 * log_checkpoints is currently off.
7727 */
7730
7731 if (log_checkpoints)
7732 LogCheckpointStart(flags, true);
7733
7734 /* Update the process title */
7735 update_checkpoint_display(flags, true, false);
7736
7737 CheckPointGuts(lastCheckPoint.redo, flags);
7738
7739 /*
7740 * This location needs to be after CheckPointGuts() to ensure that some
7741 * work has already happened during this checkpoint.
7742 */
7743 INJECTION_POINT("create-restart-point");
7744
7745 /*
7746 * Remember the prior checkpoint's redo ptr for
7747 * UpdateCheckPointDistanceEstimate()
7748 */
7749 PriorRedoPtr = ControlFile->checkPointCopy.redo;
7750
7751 /*
7752 * Update pg_control, using current time. Check that it still shows an
7753 * older checkpoint, else do nothing; this is a quick hack to make sure
7754 * nothing really bad happens if somehow we get here after the
7755 * end-of-recovery checkpoint.
7756 */
7757 LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
7758 if (ControlFile->checkPointCopy.redo < lastCheckPoint.redo)
7759 {
7760 /*
7761 * Update the checkpoint information. We do this even if the cluster
7762 * does not show DB_IN_ARCHIVE_RECOVERY to match with the set of WAL
7763 * segments recycled below.
7764 */
7765 ControlFile->checkPoint = lastCheckPointRecPtr;
7766 ControlFile->checkPointCopy = lastCheckPoint;
7767
7768 /*
7769 * Ensure minRecoveryPoint is past the checkpoint record and update it
7770 * if the control file still shows DB_IN_ARCHIVE_RECOVERY. Normally,
7771 * this will have happened already while writing out dirty buffers,
7772 * but not necessarily - e.g. because no buffers were dirtied. We do
7773 * this because a backup performed in recovery uses minRecoveryPoint
7774 * to determine which WAL files must be included in the backup, and
7775 * the file (or files) containing the checkpoint record must be
7776 * included, at a minimum. Note that for an ordinary restart of
7777 * recovery there's no value in having the minimum recovery point any
7778 * earlier than this anyway, because redo will begin just after the
7779 * checkpoint record.
7780 */
7782 {
7783 if (ControlFile->minRecoveryPoint < lastCheckPointEndPtr)
7784 {
7785 ControlFile->minRecoveryPoint = lastCheckPointEndPtr;
7787
7788 /* update local copy */
7791 }
7792 if (flags & CHECKPOINT_IS_SHUTDOWN)
7794 }
7796 }
7797 LWLockRelease(ControlFileLock);
7798
7799 /*
7800 * Update the average distance between checkpoints/restartpoints if the
7801 * prior checkpoint exists.
7802 */
7803 if (PriorRedoPtr != InvalidXLogRecPtr)
7805
7806 /*
7807 * Delete old log files, those no longer needed for last restartpoint to
7808 * prevent the disk holding the xlog from growing full.
7809 */
7811
7812 /*
7813 * Retreat _logSegNo using the current end of xlog replayed or received,
7814 * whichever is later.
7815 */
7816 receivePtr = GetWalRcvFlushRecPtr(NULL, NULL);
7817 replayPtr = GetXLogReplayRecPtr(&replayTLI);
7818 endptr = (receivePtr < replayPtr) ? replayPtr : receivePtr;
7819 KeepLogSeg(endptr, &_logSegNo);
7821 _logSegNo, InvalidOid,
7823 {
7824 /*
7825 * Some slots have been invalidated; recalculate the old-segment
7826 * horizon, starting again from RedoRecPtr.
7827 */
7829 KeepLogSeg(endptr, &_logSegNo);
7830 }
7831 _logSegNo--;
7832
7833 /*
7834 * Try to recycle segments on a useful timeline. If we've been promoted
7835 * since the beginning of this restartpoint, use the new timeline chosen
7836 * at end of recovery. If we're still in recovery, use the timeline we're
7837 * currently replaying.
7838 *
7839 * There is no guarantee that the WAL segments will be useful on the
7840 * current timeline; if recovery proceeds to a new timeline right after
7841 * this, the pre-allocated WAL segments on this timeline will not be used,
7842 * and will go wasted until recycled on the next restartpoint. We'll live
7843 * with that.
7844 */
7845 if (!RecoveryInProgress())
7846 replayTLI = XLogCtl->InsertTimeLineID;
7847
7848 RemoveOldXlogFiles(_logSegNo, RedoRecPtr, endptr, replayTLI);
7849
7850 /*
7851 * Make more log segments if needed. (Do this after recycling old log
7852 * segments, since that may supply some of the needed files.)
7853 */
7854 PreallocXlogFiles(endptr, replayTLI);
7855
7856 /*
7857 * Truncate pg_subtrans if possible. We can throw away all data before
7858 * the oldest XMIN of any running transaction. No future transaction will
7859 * attempt to reference any pg_subtrans entry older than that (see Asserts
7860 * in subtrans.c). When hot standby is disabled, though, we mustn't do
7861 * this because StartupSUBTRANS hasn't been called yet.
7862 */
7863 if (EnableHotStandby)
7865
7866 /* Real work is done; log and update stats. */
7867 LogCheckpointEnd(true);
7868
7869 /* Reset the process title */
7870 update_checkpoint_display(flags, true, true);
7871
7872 xtime = GetLatestXTime();
7874 (errmsg("recovery restart point at %X/%X",
7875 LSN_FORMAT_ARGS(lastCheckPoint.redo)),
7876 xtime ? errdetail("Last completed transaction was at log time %s.",
7877 timestamptz_to_str(xtime)) : 0));
7878
7879 /*
7880 * Finally, execute archive_cleanup_command, if any.
7881 */
7882 if (archiveCleanupCommand && strcmp(archiveCleanupCommand, "") != 0)
7884 "archive_cleanup_command",
7885 false,
7886 WAIT_EVENT_ARCHIVE_CLEANUP_COMMAND);
7887
7888 return true;
7889}
const char * timestamptz_to_str(TimestampTz t)
Definition: timestamp.c:1861
int64 TimestampTz
Definition: timestamp.h:39
int errdetail(const char *fmt,...)
Definition: elog.c:1203
#define LOG
Definition: elog.h:31
#define DEBUG2
Definition: elog.h:29
bool IsUnderPostmaster
Definition: globals.c:119
#define INJECTION_POINT(name)
@ B_CHECKPOINTER
Definition: miscadmin.h:362
BackendType MyBackendType
Definition: miscinit.c:64
@ DB_IN_ARCHIVE_RECOVERY
Definition: pg_control.h:96
@ DB_SHUTDOWNED_IN_RECOVERY
Definition: pg_control.h:93
CheckPoint lastCheckPoint
Definition: xlog.c:545
XLogRecPtr lastCheckPointRecPtr
Definition: xlog.c:543
XLogRecPtr lastCheckPointEndPtr
Definition: xlog.c:544
XLogRecPtr GetWalRcvFlushRecPtr(XLogRecPtr *latestChunkStart, TimeLineID *receiveTLI)
bool EnableHotStandby
Definition: xlog.c:121
static void UpdateMinRecoveryPoint(XLogRecPtr lsn, bool force)
Definition: xlog.c:2710
static XLogRecPtr LocalMinRecoveryPoint
Definition: xlog.c:646
static TimeLineID LocalMinRecoveryPointTLI
Definition: xlog.c:647
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:85
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_IDLE_TIMEOUT, 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 9429 of file xlog.c.

9430{
9431 bool during_backup_start = DatumGetBool(arg);
9432
9433 /* If called during backup start, there shouldn't be one already running */
9434 Assert(!during_backup_start || sessionBackupState == SESSION_BACKUP_NONE);
9435
9436 if (during_backup_start || sessionBackupState != SESSION_BACKUP_NONE)
9437 {
9441
9444
9445 if (!during_backup_start)
9447 errmsg("aborting backup due to backend exiting before pg_backup_stop was called"));
9448 }
9449}
#define WARNING
Definition: elog.h:36
void * arg
static bool DatumGetBool(Datum X)
Definition: postgres.h:95
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 8827 of file xlog.c.

8829{
8831
8832 Assert(state != NULL);
8834
8835 /*
8836 * During recovery, we don't need to check WAL level. Because, if WAL
8837 * level is not sufficient, it's impossible to get here during recovery.
8838 */
8840 ereport(ERROR,
8841 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
8842 errmsg("WAL level not sufficient for making an online backup"),
8843 errhint("\"wal_level\" must be set to \"replica\" or \"logical\" at server start.")));
8844
8845 if (strlen(backupidstr) > MAXPGPATH)
8846 ereport(ERROR,
8847 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
8848 errmsg("backup label too long (max %d bytes)",
8849 MAXPGPATH)));
8850
8851 strlcpy(state->name, backupidstr, sizeof(state->name));
8852
8853 /*
8854 * Mark backup active in shared memory. We must do full-page WAL writes
8855 * during an on-line backup even if not doing so at other times, because
8856 * it's quite possible for the backup dump to obtain a "torn" (partially
8857 * written) copy of a database page if it reads the page concurrently with
8858 * our write to the same page. This can be fixed as long as the first
8859 * write to the page in the WAL sequence is a full-page write. Hence, we
8860 * increment runningBackups then force a CHECKPOINT, to ensure there are
8861 * no dirty pages in shared memory that might get dumped while the backup
8862 * is in progress without having a corresponding WAL record. (Once the
8863 * backup is complete, we need not force full-page writes anymore, since
8864 * we expect that any pages not modified during the backup interval must
8865 * have been correctly captured by the backup.)
8866 *
8867 * Note that forcing full-page writes has no effect during an online
8868 * backup from the standby.
8869 *
8870 * We must hold all the insertion locks to change the value of
8871 * runningBackups, to ensure adequate interlocking against
8872 * XLogInsertRecord().
8873 */
8877
8878 /*
8879 * Ensure we decrement runningBackups if we fail below. NB -- for this to
8880 * work correctly, it is critical that sessionBackupState is only updated
8881 * after this block is over.
8882 */
8884 {
8885 bool gotUniqueStartpoint = false;
8886 DIR *tblspcdir;
8887 struct dirent *de;
8888 tablespaceinfo *ti;
8889 int datadirpathlen;
8890
8891 /*
8892 * Force an XLOG file switch before the checkpoint, to ensure that the
8893 * WAL segment the checkpoint is written to doesn't contain pages with
8894 * old timeline IDs. That would otherwise happen if you called
8895 * pg_backup_start() right after restoring from a PITR archive: the
8896 * first WAL segment containing the startup checkpoint has pages in
8897 * the beginning with the old timeline ID. That can cause trouble at
8898 * recovery: we won't have a history file covering the old timeline if
8899 * pg_wal directory was not included in the base backup and the WAL
8900 * archive was cleared too before starting the backup.
8901 *
8902 * This also ensures that we have emitted a WAL page header that has
8903 * XLP_BKP_REMOVABLE off before we emit the checkpoint record.
8904 * Therefore, if a WAL archiver (such as pglesslog) is trying to
8905 * compress out removable backup blocks, it won't remove any that
8906 * occur after this point.
8907 *
8908 * During recovery, we skip forcing XLOG file switch, which means that
8909 * the backup taken during recovery is not available for the special
8910 * recovery case described above.
8911 */
8913 RequestXLogSwitch(false);
8914
8915 do
8916 {
8917 bool checkpointfpw;
8918
8919 /*
8920 * Force a CHECKPOINT. Aside from being necessary to prevent torn
8921 * page problems, this guarantees that two successive backup runs
8922 * will have different checkpoint positions and hence different
8923 * history file names, even if nothing happened in between.
8924 *
8925 * During recovery, establish a restartpoint if possible. We use
8926 * the last restartpoint as the backup starting checkpoint. This
8927 * means that two successive backup runs can have same checkpoint
8928 * positions.
8929 *
8930 * Since the fact that we are executing do_pg_backup_start()
8931 * during recovery means that checkpointer is running, we can use
8932 * RequestCheckpoint() to establish a restartpoint.
8933 *
8934 * We use CHECKPOINT_IMMEDIATE only if requested by user (via
8935 * passing fast = true). Otherwise this can take awhile.
8936 */
8938 (fast ? CHECKPOINT_IMMEDIATE : 0));
8939
8940 /*
8941 * Now we need to fetch the checkpoint record location, and also
8942 * its REDO pointer. The oldest point in WAL that would be needed
8943 * to restore starting from the checkpoint is precisely the REDO
8944 * pointer.
8945 */
8946 LWLockAcquire(ControlFileLock, LW_SHARED);
8947 state->checkpointloc = ControlFile->checkPoint;
8948 state->startpoint = ControlFile->checkPointCopy.redo;
8950 checkpointfpw = ControlFile->checkPointCopy.fullPageWrites;
8951 LWLockRelease(ControlFileLock);
8952
8954 {
8955 XLogRecPtr recptr;
8956
8957 /*
8958 * Check to see if all WAL replayed during online backup
8959 * (i.e., since last restartpoint used as backup starting
8960 * checkpoint) contain full-page writes.
8961 */
8963 recptr = XLogCtl->lastFpwDisableRecPtr;
8965
8966 if (!checkpointfpw || state->startpoint <= recptr)
8967 ereport(ERROR,
8968 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
8969 errmsg("WAL generated with \"full_page_writes=off\" was replayed "
8970 "since last restartpoint"),
8971 errhint("This means that the backup being taken on the standby "
8972 "is corrupt and should not be used. "
8973 "Enable \"full_page_writes\" and run CHECKPOINT on the primary, "
8974 "and then try an online backup again.")));
8975
8976 /*
8977 * During recovery, since we don't use the end-of-backup WAL
8978 * record and don't write the backup history file, the
8979 * starting WAL location doesn't need to be unique. This means
8980 * that two base backups started at the same time might use
8981 * the same checkpoint as starting locations.
8982 */
8983 gotUniqueStartpoint = true;
8984 }
8985
8986 /*
8987 * If two base backups are started at the same time (in WAL sender
8988 * processes), we need to make sure that they use different
8989 * checkpoints as starting locations, because we use the starting
8990 * WAL location as a unique identifier for the base backup in the
8991 * end-of-backup WAL record and when we write the backup history
8992 * file. Perhaps it would be better generate a separate unique ID
8993 * for each backup instead of forcing another checkpoint, but
8994 * taking a checkpoint right after another is not that expensive
8995 * either because only few buffers have been dirtied yet.
8996 */
8998 if (XLogCtl->Insert.lastBackupStart < state->startpoint)
8999 {
9000 XLogCtl->Insert.lastBackupStart = state->startpoint;
9001 gotUniqueStartpoint = true;
9002 }
9004 } while (!gotUniqueStartpoint);
9005
9006 /*
9007 * Construct tablespace_map file.
9008 */
9009 datadirpathlen = strlen(DataDir);
9010
9011 /* Collect information about all tablespaces */
9012 tblspcdir = AllocateDir(PG_TBLSPC_DIR);
9013 while ((de = ReadDir(tblspcdir, PG_TBLSPC_DIR)) != NULL)
9014 {
9015 char fullpath[MAXPGPATH + sizeof(PG_TBLSPC_DIR)];
9016 char linkpath[MAXPGPATH];
9017 char *relpath = NULL;
9018 char *s;
9019 PGFileType de_type;
9020 char *badp;
9021 Oid tsoid;
9022
9023 /*
9024 * Try to parse the directory name as an unsigned integer.
9025 *
9026 * Tablespace directories should be positive integers that can be
9027 * represented in 32 bits, with no leading zeroes or trailing
9028 * garbage. If we come across a name that doesn't meet those
9029 * criteria, skip it.
9030 */
9031 if (de->d_name[0] < '1' || de->d_name[1] > '9')
9032 continue;
9033 errno = 0;
9034 tsoid = strtoul(de->d_name, &badp, 10);
9035 if (*badp != '\0' || errno == EINVAL || errno == ERANGE)
9036 continue;
9037
9038 snprintf(fullpath, sizeof(fullpath), "%s/%s", PG_TBLSPC_DIR, de->d_name);
9039
9040 de_type = get_dirent_type(fullpath, de, false, ERROR);
9041
9042 if (de_type == PGFILETYPE_LNK)
9043 {
9044 StringInfoData escapedpath;
9045 int rllen;
9046
9047 rllen = readlink(fullpath, linkpath, sizeof(linkpath));
9048 if (rllen < 0)
9049 {
9051 (errmsg("could not read symbolic link \"%s\": %m",
9052 fullpath)));
9053 continue;
9054 }
9055 else if (rllen >= sizeof(linkpath))
9056 {
9058 (errmsg("symbolic link \"%s\" target is too long",
9059 fullpath)));
9060 continue;
9061 }
9062 linkpath[rllen] = '\0';
9063
9064 /*
9065 * Relpath holds the relative path of the tablespace directory
9066 * when it's located within PGDATA, or NULL if it's located
9067 * elsewhere.
9068 */
9069 if (rllen > datadirpathlen &&
9070 strncmp(linkpath, DataDir, datadirpathlen) == 0 &&
9071 IS_DIR_SEP(linkpath[datadirpathlen]))
9072 relpath = pstrdup(linkpath + datadirpathlen + 1);
9073
9074 /*
9075 * Add a backslash-escaped version of the link path to the
9076 * tablespace map file.
9077 */
9078 initStringInfo(&escapedpath);
9079 for (s = linkpath; *s; s++)
9080 {
9081 if (*s == '\n' || *s == '\r' || *s == '\\')
9082 appendStringInfoChar(&escapedpath, '\\');
9083 appendStringInfoChar(&escapedpath, *s);
9084 }
9085 appendStringInfo(tblspcmapfile, "%s %s\n",
9086 de->d_name, escapedpath.data);
9087 pfree(escapedpath.data);
9088 }
9089 else if (de_type == PGFILETYPE_DIR)
9090 {
9091 /*
9092 * It's possible to use allow_in_place_tablespaces to create
9093 * directories directly under pg_tblspc, for testing purposes
9094 * only.
9095 *
9096 * In this case, we store a relative path rather than an
9097 * absolute path into the tablespaceinfo.
9098 */
9099 snprintf(linkpath, sizeof(linkpath), "%s/%s",
9100 PG_TBLSPC_DIR, de->d_name);
9101 relpath = pstrdup(linkpath);
9102 }
9103 else
9104 {
9105 /* Skip any other file type that appears here. */
9106 continue;
9107 }
9108
9109 ti = palloc(sizeof(tablespaceinfo));
9110 ti->oid = tsoid;
9111 ti->path = pstrdup(linkpath);
9112 ti->rpath = relpath;
9113 ti->size = -1;
9114
9115 if (tablespaces)
9116 *tablespaces = lappend(*tablespaces, ti);
9117 }
9118 FreeDir(tblspcdir);
9119
9120 state->starttime = (pg_time_t) time(NULL);
9121 }
9123
9124 state->started_in_recovery = backup_started_in_recovery;
9125
9126 /*
9127 * Mark that the start phase has correctly finished for the backup.
9128 */
9130}
static bool backup_started_in_recovery
Definition: basebackup.c:123
void RequestCheckpoint(int flags)
Definition: checkpointer.c:997
int errhint(const char *fmt,...)
Definition: elog.c:1317
int errcode(int sqlerrcode)
Definition: elog.c:853
int FreeDir(DIR *dir)
Definition: fd.c:2983
DIR * AllocateDir(const char *dirname)
Definition: fd.c:2865
struct dirent * ReadDir(DIR *dir, const char *dirname)
Definition: fd.c:2931
PGFileType get_dirent_type(const char *path, const struct dirent *de, bool look_through_symlinks, int elevel)
Definition: file_utils.c:526
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:70
#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:1699
#define MAXPGPATH
#define snprintf
Definition: port.h:239
#define IS_DIR_SEP(ch)
Definition: port.h:103
size_t strlcpy(char *dst, const char *src, size_t siz)
Definition: strlcpy.c:45
unsigned int Oid
Definition: postgres_ext.h:32
#define relpath(rlocator, forknum)
Definition: relpath.h:150
#define PG_TBLSPC_DIR
Definition: relpath.h:41
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition: stringinfo.c:145
void appendStringInfoChar(StringInfo str, char ch)
Definition: stringinfo.c:242
void initStringInfo(StringInfo str)
Definition: stringinfo.c:97
Definition: dirent.c:26
XLogRecPtr lastFpwDisableRecPtr
Definition: xlog.c:551
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:226
XLogRecPtr RequestXLogSwitch(bool mark_unimportant)
Definition: xlog.c:8106
void do_pg_abort_backup(int code, Datum arg)
Definition: xlog.c:9429
@ SESSION_BACKUP_RUNNING
Definition: xlog.h:289
#define CHECKPOINT_WAIT
Definition: xlog.h:145
#define CHECKPOINT_IMMEDIATE
Definition: xlog.h:141
#define XLogIsNeeded()
Definition: xlog.h:109

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, PG_TBLSPC_DIR, 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, strlcpy(), 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 9155 of file xlog.c.

9156{
9157 bool backup_stopped_in_recovery = false;
9158 char histfilepath[MAXPGPATH];
9159 char lastxlogfilename[MAXFNAMELEN];
9160 char histfilename[MAXFNAMELEN];
9161 XLogSegNo _logSegNo;
9162 FILE *fp;
9163 int seconds_before_warning;
9164 int waits = 0;
9165 bool reported_waiting = false;
9166
9167 Assert(state != NULL);
9168
9169 backup_stopped_in_recovery = RecoveryInProgress();
9170
9171 /*
9172 * During recovery, we don't need to check WAL level. Because, if WAL
9173 * level is not sufficient, it's impossible to get here during recovery.
9174 */
9175 if (!backup_stopped_in_recovery && !XLogIsNeeded())
9176 ereport(ERROR,
9177 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
9178 errmsg("WAL level not sufficient for making an online backup"),
9179 errhint("\"wal_level\" must be set to \"replica\" or \"logical\" at server start.")));
9180
9181 /*
9182 * OK to update backup counter and session-level lock.
9183 *
9184 * Note that CHECK_FOR_INTERRUPTS() must not occur while updating them,
9185 * otherwise they can be updated inconsistently, which might cause
9186 * do_pg_abort_backup() to fail.
9187 */
9189
9190 /*
9191 * It is expected that each do_pg_backup_start() call is matched by
9192 * exactly one do_pg_backup_stop() call.
9193 */
9196
9197 /*
9198 * Clean up session-level lock.
9199 *
9200 * You might think that WALInsertLockRelease() can be called before
9201 * cleaning up session-level lock because session-level lock doesn't need
9202 * to be protected with WAL insertion lock. But since
9203 * CHECK_FOR_INTERRUPTS() can occur in it, session-level lock must be
9204 * cleaned up before it.
9205 */
9207
9209
9210 /*
9211 * If we are taking an online backup from the standby, we confirm that the
9212 * standby has not been promoted during the backup.
9213 */
9214 if (state->started_in_recovery && !backup_stopped_in_recovery)
9215 ereport(ERROR,
9216 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
9217 errmsg("the standby was promoted during online backup"),
9218 errhint("This means that the backup being taken is corrupt "
9219 "and should not be used. "
9220 "Try taking another online backup.")));
9221
9222 /*
9223 * During recovery, we don't write an end-of-backup record. We assume that
9224 * pg_control was backed up last and its minimum recovery point can be
9225 * available as the backup end location. Since we don't have an
9226 * end-of-backup record, we use the pg_control value to check whether
9227 * we've reached the end of backup when starting recovery from this
9228 * backup. We have no way of checking if pg_control wasn't backed up last
9229 * however.
9230 *
9231 * We don't force a switch to new WAL file but it is still possible to
9232 * wait for all the required files to be archived if waitforarchive is
9233 * true. This is okay if we use the backup to start a standby and fetch
9234 * the missing WAL using streaming replication. But in the case of an
9235 * archive recovery, a user should set waitforarchive to true and wait for
9236 * them to be archived to ensure that all the required files are
9237 * available.
9238 *
9239 * We return the current minimum recovery point as the backup end
9240 * location. Note that it can be greater than the exact backup end
9241 * location if the minimum recovery point is updated after the backup of
9242 * pg_control. This is harmless for current uses.
9243 *
9244 * XXX currently a backup history file is for informational and debug
9245 * purposes only. It's not essential for an online backup. Furthermore,
9246 * even if it's created, it will not be archived during recovery because
9247 * an archiver is not invoked. So it doesn't seem worthwhile to write a
9248 * backup history file during recovery.
9249 */
9250 if (backup_stopped_in_recovery)
9251 {
9252 XLogRecPtr recptr;
9253
9254 /*
9255 * Check to see if all WAL replayed during online backup contain
9256 * full-page writes.
9257 */
9259 recptr = XLogCtl->lastFpwDisableRecPtr;
9261
9262 if (state->startpoint <= recptr)
9263 ereport(ERROR,
9264 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
9265 errmsg("WAL generated with \"full_page_writes=off\" was replayed "
9266 "during online backup"),
9267 errhint("This means that the backup being taken on the standby "
9268 "is corrupt and should not be used. "
9269 "Enable \"full_page_writes\" and run CHECKPOINT on the primary, "
9270 "and then try an online backup again.")));
9271
9272
9273 LWLockAcquire(ControlFileLock, LW_SHARED);
9274 state->stoppoint = ControlFile->minRecoveryPoint;
9276 LWLockRelease(ControlFileLock);
9277 }
9278 else
9279 {
9280 char *history_file;
9281
9282 /*
9283 * Write the backup-end xlog record
9284 */
9286 XLogRegisterData(&state->startpoint,
9287 sizeof(state->startpoint));
9288 state->stoppoint = XLogInsert(RM_XLOG_ID, XLOG_BACKUP_END);
9289
9290 /*
9291 * Given that we're not in recovery, InsertTimeLineID is set and can't
9292 * change, so we can read it without a lock.
9293 */
9294 state->stoptli = XLogCtl->InsertTimeLineID;
9295
9296 /*
9297 * Force a switch to a new xlog segment file, so that the backup is
9298 * valid as soon as archiver moves out the current segment file.
9299 */
9300 RequestXLogSwitch(false);
9301
9302 state->stoptime = (pg_time_t) time(NULL);
9303
9304 /*
9305 * Write the backup history file
9306 */
9307 XLByteToSeg(state->startpoint, _logSegNo, wal_segment_size);
9308 BackupHistoryFilePath(histfilepath, state->stoptli, _logSegNo,
9309 state->startpoint, wal_segment_size);
9310 fp = AllocateFile(histfilepath, "w");
9311 if (!fp)
9312 ereport(ERROR,
9314 errmsg("could not create file \"%s\": %m",
9315 histfilepath)));
9316
9317 /* Build and save the contents of the backup history file */
9318 history_file = build_backup_content(state, true);
9319 fprintf(fp, "%s", history_file);
9320 pfree(history_file);
9321
9322 if (fflush(fp) || ferror(fp) || FreeFile(fp))
9323 ereport(ERROR,
9325 errmsg("could not write file \"%s\": %m",
9326 histfilepath)));
9327
9328 /*
9329 * Clean out any no-longer-needed history files. As a side effect,
9330 * this will post a .ready file for the newly created history file,
9331 * notifying the archiver that history file may be archived
9332 * immediately.
9333 */
9335 }
9336
9337 /*
9338 * If archiving is enabled, wait for all the required WAL files to be
9339 * archived before returning. If archiving isn't enabled, the required WAL
9340 * needs to be transported via streaming replication (hopefully with
9341 * wal_keep_size set high enough), or some more exotic mechanism like
9342 * polling and copying files from pg_wal with script. We have no knowledge
9343 * of those mechanisms, so it's up to the user to ensure that he gets all
9344 * the required WAL.
9345 *
9346 * We wait until both the last WAL file filled during backup and the
9347 * history file have been archived, and assume that the alphabetic sorting
9348 * property of the WAL files ensures any earlier WAL files are safely
9349 * archived as well.
9350 *
9351 * We wait forever, since archive_command is supposed to work and we
9352 * assume the admin wanted his backup to work completely. If you don't
9353 * wish to wait, then either waitforarchive should be passed in as false,
9354 * or you can set statement_timeout. Also, some notices are issued to
9355 * clue in anyone who might be doing this interactively.
9356 */
9357
9358 if (waitforarchive &&
9359 ((!backup_stopped_in_recovery && XLogArchivingActive()) ||
9360 (backup_stopped_in_recovery && XLogArchivingAlways())))
9361 {
9362 XLByteToPrevSeg(state->stoppoint, _logSegNo, wal_segment_size);
9363 XLogFileName(lastxlogfilename, state->stoptli, _logSegNo,
9365
9366 XLByteToSeg(state->startpoint, _logSegNo, wal_segment_size);
9367 BackupHistoryFileName(histfilename, state->stoptli, _logSegNo,
9368 state->startpoint, wal_segment_size);
9369
9370 seconds_before_warning = 60;
9371 waits = 0;
9372
9373 while (XLogArchiveIsBusy(lastxlogfilename) ||
9374 XLogArchiveIsBusy(histfilename))
9375 {
9377
9378 if (!reported_waiting && waits > 5)
9379 {
9381 (errmsg("base backup done, waiting for required WAL segments to be archived")));
9382 reported_waiting = true;
9383 }
9384
9385 (void) WaitLatch(MyLatch,
9387 1000L,
9388 WAIT_EVENT_BACKUP_WAIT_WAL_ARCHIVE);
9390
9391 if (++waits >= seconds_before_warning)
9392 {
9393 seconds_before_warning *= 2; /* This wraps in >10 years... */
9395 (errmsg("still waiting for all required WAL segments to be archived (%d seconds elapsed)",
9396 waits),
9397 errhint("Check that your \"archive_command\" is executing properly. "
9398 "You can safely cancel this backup, "
9399 "but the database backup will not be usable without all the WAL segments.")));
9400 }
9401 }
9402
9404 (errmsg("all required WAL segments have been archived")));
9405 }
9406 else if (waitforarchive)
9408 (errmsg("WAL archiving is not enabled; you must ensure that all required WAL segments are copied through other means to complete the backup")));
9409}
#define fprintf(file, fmt, msg)
Definition: cubescan.l:21
#define NOTICE
Definition: elog.h:35
int FreeFile(FILE *file)
Definition: fd.c:2803
FILE * AllocateFile(const char *name, const char *mode)
Definition: fd.c:2605
struct Latch * MyLatch
Definition: globals.c:62
void ResetLatch(Latch *latch)
Definition: latch.c:372
int WaitLatch(Latch *latch, int wakeEvents, long timeout, uint32 wait_event_info)
Definition: latch.c:172
#define CHECK_FOR_INTERRUPTS()
Definition: miscadmin.h:122
#define XLOG_BACKUP_END
Definition: pg_control.h:73
#define WL_TIMEOUT
Definition: waiteventset.h:37
#define WL_EXIT_ON_PM_DEATH
Definition: waiteventset.h:39
#define WL_LATCH_SET
Definition: waiteventset.h:34
static void CleanupBackupHistory(void)
Definition: xlog.c:4167
#define XLogArchivingActive()
Definition: xlog.h:99
#define XLogArchivingAlways()
Definition: xlog.h:102
#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, 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 9136 of file xlog.c.

9137{
9138 return sessionBackupState;
9139}

References sessionBackupState.

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

◆ GetActiveWalLevelOnStandby()

WalLevel GetActiveWalLevelOnStandby ( void  )

Definition at line 4905 of file xlog.c.

4906{
4907 return ControlFile->wal_level;
4908}

References ControlFile, and ControlFileData::wal_level.

Referenced by CheckLogicalDecodingRequirements().

◆ GetDefaultCharSignedness()

bool GetDefaultCharSignedness ( void  )

Definition at line 4635 of file xlog.c.

4636{
4638}
bool default_char_signedness
Definition: pg_control.h:228

References ControlFile, and ControlFileData::default_char_signedness.

Referenced by CMPTRGM_CHOOSE().

◆ GetFakeLSNForUnloggedRel()

XLogRecPtr GetFakeLSNForUnloggedRel ( void  )

Definition at line 4650 of file xlog.c.

4651{
4653}
static uint64 pg_atomic_fetch_add_u64(volatile pg_atomic_uint64 *ptr, int64 add_)
Definition: atomics.h:522

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

Referenced by gistGetFakeLSN().

◆ GetFlushRecPtr()

XLogRecPtr GetFlushRecPtr ( TimeLineID insertTLI)

Definition at line 6545 of file xlog.c.

6546{
6548
6550
6551 /*
6552 * If we're writing and flushing WAL, the time line can't be changing, so
6553 * no lock is required.
6554 */
6555 if (insertTLI)
6556 *insertTLI = XLogCtl->InsertTimeLineID;
6557
6558 return LogwrtResult.Flush;
6559}
RecoveryState SharedRecoveryState
Definition: xlog.c:516
XLogRecPtr Flush
Definition: xlog.c:328
#define RefreshXLogWriteResult(_target)
Definition: xlog.c:620
static XLogwrtResult LogwrtResult
Definition: xlog.c:612

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

6514{
6515 *RedoRecPtr_p = RedoRecPtr;
6516 *doPageWrites_p = doPageWrites;
6517}
static bool doPageWrites
Definition: xlog.c:286

References doPageWrites, and RedoRecPtr.

Referenced by XLogCheckBufferNeedsBackup(), and XLogInsert().

◆ GetInsertRecPtr()

XLogRecPtr GetInsertRecPtr ( void  )

Definition at line 6528 of file xlog.c.

6529{
6530 XLogRecPtr recptr;
6531
6533 recptr = XLogCtl->LogwrtRqst.Write;
6535
6536 return recptr;
6537}
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 6602 of file xlog.c.

6603{
6605 int i;
6606
6607 for (i = 0; i < NUM_XLOGINSERT_LOCKS; i++)
6608 {
6609 XLogRecPtr last_important;
6610
6611 /*
6612 * Need to take a lock to prevent torn reads of the LSN, which are
6613 * possible on some of the supported platforms. WAL insert locks only
6614 * support exclusive mode, so we have to use that.
6615 */
6617 last_important = WALInsertLocks[i].l.lastImportantAt;
6618 LWLockRelease(&WALInsertLocks[i].l.lock);
6619
6620 if (res < last_important)
6621 res = last_important;
6622 }
6623
6624 return res;
6625}
int i
Definition: isn.c:74
XLogRecPtr lastImportantAt
Definition: xlog.c:371
WALInsertLock l
Definition: xlog.c:383
static WALInsertLockPadded * WALInsertLocks
Definition: xlog.c:569
#define NUM_XLOGINSERT_LOCKS
Definition: xlog.c:150

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

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

◆ GetMockAuthenticationNonce()

char * GetMockAuthenticationNonce ( void  )

Definition at line 4611 of file xlog.c.

4612{
4613 Assert(ControlFile != NULL);
4615}
char mock_authentication_nonce[MOCK_AUTH_NONCE_LEN]
Definition: pg_control.h:235

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

Referenced by scram_mock_salt().

◆ GetRecoveryState()

RecoveryState GetRecoveryState ( void  )

Definition at line 6416 of file xlog.c.

6417{
6418 RecoveryState retval;
6419
6421 retval = XLogCtl->SharedRecoveryState;
6423
6424 return retval;
6425}

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

Referenced by XLogArchiveCheckDone().

◆ GetRedoRecPtr()

XLogRecPtr GetRedoRecPtr ( void  )

Definition at line 6483 of file xlog.c.

6484{
6485 XLogRecPtr ptr;
6486
6487 /*
6488 * The possibly not up-to-date copy in XlogCtl is enough. Even if we
6489 * grabbed a WAL insertion lock to read the authoritative value in
6490 * Insert->RedoRecPtr, someone might update it just after we've released
6491 * the lock.
6492 */
6494 ptr = XLogCtl->RedoRecPtr;
6496
6497 if (RedoRecPtr < ptr)
6498 RedoRecPtr = ptr;
6499
6500 return RedoRecPtr;
6501}

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

◆ GetWALAvailability()

WALAvailability GetWALAvailability ( XLogRecPtr  targetLSN)

Definition at line 7915 of file xlog.c.

7916{
7917 XLogRecPtr currpos; /* current write LSN */
7918 XLogSegNo currSeg; /* segid of currpos */
7919 XLogSegNo targetSeg; /* segid of targetLSN */
7920 XLogSegNo oldestSeg; /* actual oldest segid */
7921 XLogSegNo oldestSegMaxWalSize; /* oldest segid kept by max_wal_size */
7922 XLogSegNo oldestSlotSeg; /* oldest segid kept by slot */
7923 uint64 keepSegs;
7924
7925 /*
7926 * slot does not reserve WAL. Either deactivated, or has never been active
7927 */
7928 if (XLogRecPtrIsInvalid(targetLSN))
7929 return WALAVAIL_INVALID_LSN;
7930
7931 /*
7932 * Calculate the oldest segment currently reserved by all slots,
7933 * considering wal_keep_size and max_slot_wal_keep_size. Initialize
7934 * oldestSlotSeg to the current segment.
7935 */
7936 currpos = GetXLogWriteRecPtr();
7937 XLByteToSeg(currpos, oldestSlotSeg, wal_segment_size);
7938 KeepLogSeg(currpos, &oldestSlotSeg);
7939
7940 /*
7941 * Find the oldest extant segment file. We get 1 until checkpoint removes
7942 * the first WAL segment file since startup, which causes the status being
7943 * wrong under certain abnormal conditions but that doesn't actually harm.
7944 */
7945 oldestSeg = XLogGetLastRemovedSegno() + 1;
7946
7947 /* calculate oldest segment by max_wal_size */
7948 XLByteToSeg(currpos, currSeg, wal_segment_size);
7950
7951 if (currSeg > keepSegs)
7952 oldestSegMaxWalSize = currSeg - keepSegs;
7953 else
7954 oldestSegMaxWalSize = 1;
7955
7956 /* the segment we care about */
7957 XLByteToSeg(targetLSN, targetSeg, wal_segment_size);
7958
7959 /*
7960 * No point in returning reserved or extended status values if the
7961 * targetSeg is known to be lost.
7962 */
7963 if (targetSeg >= oldestSlotSeg)
7964 {
7965 /* show "reserved" when targetSeg is within max_wal_size */
7966 if (targetSeg >= oldestSegMaxWalSize)
7967 return WALAVAIL_RESERVED;
7968
7969 /* being retained by slots exceeding max_wal_size */
7970 return WALAVAIL_EXTENDED;
7971 }
7972
7973 /* WAL segments are no longer retained but haven't been removed yet */
7974 if (targetSeg >= oldestSeg)
7975 return WALAVAIL_UNRESERVED;
7976
7977 /* Definitely lost */
7978 return WALAVAIL_REMOVED;
7979}
XLogSegNo XLogGetLastRemovedSegno(void)
Definition: xlog.c:3764
int max_wal_size_mb
Definition: xlog.c:114
#define ConvertToXSegs(x, segsize)
Definition: xlog.c:603
XLogRecPtr GetXLogWriteRecPtr(void)
Definition: xlog.c:9486
@ WALAVAIL_REMOVED
Definition: xlog.h:194

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  )

◆ GetWALInsertionTimeLineIfSet()

TimeLineID GetWALInsertionTimeLineIfSet ( void  )

Definition at line 6582 of file xlog.c.

6583{
6584 TimeLineID insertTLI;
6585
6587 insertTLI = XLogCtl->InsertTimeLineID;
6589
6590 return insertTLI;
6591}

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

Referenced by GetLatestLSN().

◆ GetXLogInsertRecPtr()

XLogRecPtr GetXLogInsertRecPtr ( void  )

Definition at line 9470 of file xlog.c.

9471{
9473 uint64 current_bytepos;
9474
9475 SpinLockAcquire(&Insert->insertpos_lck);
9476 current_bytepos = Insert->CurrBytePos;
9477 SpinLockRelease(&Insert->insertpos_lck);
9478
9479 return XLogBytePosToRecPtr(current_bytepos);
9480}

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  )

◆ InitializeWalConsistencyChecking()

void InitializeWalConsistencyChecking ( void  )

Definition at line 4830 of file xlog.c.

4831{
4833
4835 {
4836 struct config_generic *guc;
4837
4838 guc = find_option("wal_consistency_checking", false, false, ERROR);
4839
4841
4842 set_config_option_ext("wal_consistency_checking",
4844 guc->scontext, guc->source, guc->srole,
4845 GUC_ACTION_SET, true, ERROR, false);
4846
4847 /* checking should not be deferred again */
4849 }
4850}
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:3382
struct config_generic * find_option(const char *name, bool create_placeholders, bool skip_errors, int elevel)
Definition: guc.c:1235
@ GUC_ACTION_SET
Definition: guc.h:203
bool process_shared_preload_libraries_done
Definition: miscinit.c:1838
GucContext scontext
Definition: guc_tables.h:185
GucSource source
Definition: guc_tables.h:183
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 9527 of file xlog.c.

9528{
9529 bool result;
9530
9531 LWLockAcquire(ControlFileLock, LW_SHARED);
9533 LWLockRelease(ControlFileLock);
9534
9535 return result;
9536}
bool InstallXLogFileSegmentActive
Definition: xlog.c:526

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

8730{
8731 char *msg = NULL;
8733
8734 Assert(tli != 0);
8735
8736 /*
8737 * Quick exit if fsync is disabled or write() has already synced the WAL
8738 * file.
8739 */
8740 if (!enableFsync ||
8743 return;
8744
8745 /*
8746 * Measure I/O timing to sync the WAL file for pg_stat_io.
8747 */
8749
8750 pgstat_report_wait_start(WAIT_EVENT_WAL_SYNC);
8751 switch (wal_sync_method)
8752 {
8754 if (pg_fsync_no_writethrough(fd) != 0)
8755 msg = _("could not fsync file \"%s\": %m");
8756 break;
8757#ifdef HAVE_FSYNC_WRITETHROUGH
8759 if (pg_fsync_writethrough(fd) != 0)
8760 msg = _("could not fsync write-through file \"%s\": %m");
8761 break;
8762#endif
8764 if (pg_fdatasync(fd) != 0)
8765 msg = _("could not fdatasync file \"%s\": %m");
8766 break;
8769 /* not reachable */
8770 Assert(false);
8771 break;
8772 default:
8773 ereport(PANIC,
8774 errcode(ERRCODE_INVALID_PARAMETER_VALUE),
8775 errmsg_internal("unrecognized \"wal_sync_method\": %d", wal_sync_method));
8776 break;
8777 }
8778
8779 /* PANIC if failed to fsync */
8780 if (msg)
8781 {
8782 char xlogfname[MAXFNAMELEN];
8783 int save_errno = errno;
8784
8785 XLogFileName(xlogfname, tli, segno, wal_segment_size);
8786 errno = save_errno;
8787 ereport(PANIC,
8789 errmsg(msg, xlogfname)));
8790 }
8791
8793
8795 start, 1, 0);
8796}
#define _(x)
Definition: elog.c:90
int pg_fsync_no_writethrough(int fd)
Definition: fd.c:440
int pg_fdatasync(int fd)
Definition: fd.c:479
int pg_fsync_writethrough(int fd)
Definition: fd.c:460
bool enableFsync
Definition: globals.c:128
return str start
@ IOOBJECT_WAL
Definition: pgstat.h:276
@ IOCONTEXT_NORMAL
Definition: pgstat.h:286
@ IOOP_FSYNC
Definition: pgstat.h:305
instr_time pgstat_prepare_io_time(bool track_io_guc)
Definition: pgstat_io.c:90
void pgstat_count_io_op_time(IOObject io_object, IOContext io_context, IOOp io_op, instr_time start_time, uint32 cnt, uint64 bytes)
Definition: pgstat_io.c:121
static int fd(const char *x, int i)
Definition: preproc-init.c:105
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(), IOCONTEXT_NORMAL, IOOBJECT_WAL, IOOP_FSYNC, MAXFNAMELEN, PANIC, pg_fdatasync(), pg_fsync_no_writethrough(), pg_fsync_writethrough(), pgstat_count_io_op_time(), pgstat_prepare_io_time(), pgstat_report_wait_end(), pgstat_report_wait_start(), start, track_wal_io_timing, wal_segment_size, 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, and XLogFileName().

Referenced by XLogWalRcvFlush(), and XLogWrite().

◆ LocalProcessControlFile()

void LocalProcessControlFile ( bool  reset)

Definition at line 4892 of file xlog.c.

4893{
4894 Assert(reset || ControlFile == NULL);
4897}
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 6293 of file xlog.c.

6294{
6295 /*
6296 * We have reached the end of base backup, as indicated by pg_control. The
6297 * data on disk is now consistent (unless minRecoveryPoint is further
6298 * ahead, which can happen if we crashed during previous recovery). Reset
6299 * backupStartPoint and backupEndPoint, and update minRecoveryPoint to
6300 * make sure we don't allow starting up at an earlier point even if
6301 * recovery is stopped and restarted soon after this.
6302 */
6303 LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
6304
6305 if (ControlFile->minRecoveryPoint < EndRecPtr)
6306 {
6307 ControlFile->minRecoveryPoint = EndRecPtr;
6309 }
6310
6315
6316 LWLockRelease(ControlFileLock);
6317}
XLogRecPtr backupStartPoint
Definition: pg_control.h:170
bool backupEndRequired
Definition: pg_control.h:172
XLogRecPtr backupEndPoint
Definition: pg_control.h:171

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

6381{
6382 /*
6383 * We check shared state each time only until we leave recovery mode. We
6384 * can't re-enter recovery, so there's no need to keep checking after the
6385 * shared variable has once been seen false.
6386 */
6388 return false;
6389 else
6390 {
6391 /*
6392 * use volatile pointer to make sure we make a fresh read of the
6393 * shared variable.
6394 */
6395 volatile XLogCtlData *xlogctl = XLogCtl;
6396
6398
6399 /*
6400 * Note: We don't need a memory barrier when we're still in recovery.
6401 * We might exit recovery immediately after return, so the caller
6402 * can't rely on 'true' meaning that we're still in recovery anyway.
6403 */
6404
6406 }
6407}
static bool LocalRecoveryInProgress
Definition: xlog.c:224

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

Referenced by attribute_statistics_update(), BackgroundWriterMain(), BeginReportingGUCOptions(), brin_desummarize_range(), brin_summarize_range(), btree_index_mainfork_expected(), CanInvalidateIdleSlot(), 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(), InitWalSender(), IsCheckpointOnSchedule(), LockAcquireExtended(), logical_read_xlog_page(), MaintainLatestCompletedXid(), MarkBufferDirtyHint(), perform_base_backup(), pg_clear_attribute_stats(), pg_create_restore_point(), pg_current_wal_flush_lsn(), pg_current_wal_insert_lsn(), pg_current_wal_lsn(), pg_get_sequence_data(), 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_sequence_last_value(), 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(), relation_statistics_update(), 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 9456 of file xlog.c.

9457{
9458 static bool already_done = false;
9459
9460 if (already_done)
9461 return;
9463 already_done = true;
9464}
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 3946 of file xlog.c.

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

9520{
9521 LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
9523 LWLockRelease(ControlFileLock);
9524}

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

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

◆ SetWalWriterSleeping()

void SetWalWriterSleeping ( bool  sleeping)

Definition at line 9542 of file xlog.c.

9543{
9545 XLogCtl->WalWriterSleeping = sleeping;
9547}
bool WalWriterSleeping
Definition: xlog.c:533

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

Referenced by WalWriterMain().

◆ ShutdownXLOG()

void ShutdownXLOG ( int  code,
Datum  arg 
)

Definition at line 6648 of file xlog.c.

6649{
6650 /*
6651 * We should have an aux process resource owner to use, and we should not
6652 * be in a transaction that's installed some other resowner.
6653 */
6655 Assert(CurrentResourceOwner == NULL ||
6658
6659 /* Don't be chatty in standalone mode */
6661 (errmsg("shutting down")));
6662
6663 /*
6664 * Signal walsenders to move to stopping state.
6665 */
6667
6668 /*
6669 * Wait for WAL senders to be in stopping state. This prevents commands
6670 * from writing new WAL.
6671 */
6673
6674 if (RecoveryInProgress())
6676 else
6677 {
6678 /*
6679 * If archiving is enabled, rotate the last XLOG file so that all the
6680 * remaining records are archived (postmaster wakes up the archiver
6681 * process one more time at the end of shutdown). The checkpoint
6682 * record will go to the next XLOG file and won't be archived (yet).
6683 */
6684 if (XLogArchivingActive())
6685 RequestXLogSwitch(false);
6686
6688 }
6689}
bool IsPostmasterEnvironment
Definition: globals.c:118
ResourceOwner CurrentResourceOwner
Definition: resowner.c:173
ResourceOwner AuxProcessResourceOwner
Definition: resowner.c:176
void WalSndInitStopping(void)
Definition: walsender.c:3718
void WalSndWaitStopping(void)
Definition: walsender.c:3744
bool CreateRestartPoint(int flags)
Definition: xlog.c:7637
bool CreateCheckPoint(int flags)
Definition: xlog.c:6935

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

Referenced by CheckpointerMain(), and InitPostgres().

◆ StartupXLOG()

void StartupXLOG ( void  )

Definition at line 5475 of file xlog.c.

5476{
5478 CheckPoint checkPoint;
5479 bool wasShutdown;
5480 bool didCrash;
5481 bool haveTblspcMap;
5482 bool haveBackupLabel;
5483 XLogRecPtr EndOfLog;
5484 TimeLineID EndOfLogTLI;
5485 TimeLineID newTLI;
5486 bool performedWalRecovery;
5487 EndOfWalRecoveryInfo *endOfRecoveryInfo;
5490 TransactionId oldestActiveXID;
5491 bool promoted = false;
5492
5493 /*
5494 * We should have an aux process resource owner to use, and we should not
5495 * be in a transaction that's installed some other resowner.
5496 */
5498 Assert(CurrentResourceOwner == NULL ||
5501
5502 /*
5503 * Check that contents look valid.
5504 */
5506 ereport(FATAL,
5508 errmsg("control file contains invalid checkpoint location")));
5509
5510 switch (ControlFile->state)
5511 {
5512 case DB_SHUTDOWNED:
5513
5514 /*
5515 * This is the expected case, so don't be chatty in standalone
5516 * mode
5517 */
5519 (errmsg("database system was shut down at %s",
5521 break;
5522
5524 ereport(LOG,
5525 (errmsg("database system was shut down in recovery at %s",
5527 break;
5528
5529 case DB_SHUTDOWNING:
5530 ereport(LOG,
5531 (errmsg("database system shutdown was interrupted; last known up at %s",
5533 break;
5534
5536 ereport(LOG,
5537 (errmsg("database system was interrupted while in recovery at %s",
5539 errhint("This probably means that some data is corrupted and"
5540 " you will have to use the last backup for recovery.")));
5541 break;
5542
5544 ereport(LOG,
5545 (errmsg("database system was interrupted while in recovery at log time %s",
5547 errhint("If this has occurred more than once some data might be corrupted"
5548 " and you might need to choose an earlier recovery target.")));
5549 break;
5550
5551 case DB_IN_PRODUCTION:
5552 ereport(LOG,
5553 (errmsg("database system was interrupted; last known up at %s",
5555 break;
5556
5557 default:
5558 ereport(FATAL,
5560 errmsg("control file contains invalid database cluster state")));
5561 }
5562
5563 /* This is just to allow attaching to startup process with a debugger */
5564#ifdef XLOG_REPLAY_DELAY
5566 pg_usleep(60000000L);
5567#endif
5568
5569 /*
5570 * Verify that pg_wal, pg_wal/archive_status, and pg_wal/summaries exist.
5571 * In cases where someone has performed a copy for PITR, these directories
5572 * may have been excluded and need to be re-created.
5573 */
5575
5576 /* Set up timeout handler needed to report startup progress. */
5580
5581 /*----------
5582 * If we previously crashed, perform a couple of actions:
5583 *
5584 * - The pg_wal directory may still include some temporary WAL segments
5585 * used when creating a new segment, so perform some clean up to not
5586 * bloat this path. This is done first as there is no point to sync
5587 * this temporary data.
5588 *
5589 * - There might be data which we had written, intending to fsync it, but
5590 * which we had not actually fsync'd yet. Therefore, a power failure in
5591 * the near future might cause earlier unflushed writes to be lost, even
5592 * though more recent data written to disk from here on would be
5593 * persisted. To avoid that, fsync the entire data directory.
5594 */
5597 {
5600 didCrash = true;
5601 }
5602 else
5603 didCrash = false;
5604
5605 /*
5606 * Prepare for WAL recovery if needed.
5607 *
5608 * InitWalRecovery analyzes the control file and the backup label file, if
5609 * any. It updates the in-memory ControlFile buffer according to the
5610 * starting checkpoint, and sets InRecovery and ArchiveRecoveryRequested.
5611 * It also applies the tablespace map file, if any.
5612 */
5613 InitWalRecovery(ControlFile, &wasShutdown,
5614 &haveBackupLabel, &haveTblspcMap);
5615 checkPoint = ControlFile->checkPointCopy;
5616
5617 /* initialize shared memory variables from the checkpoint record */
5618 TransamVariables->nextXid = checkPoint.nextXid;
5619 TransamVariables->nextOid = checkPoint.nextOid;
5621 MultiXactSetNextMXact(checkPoint.nextMulti, checkPoint.nextMultiOffset);
5622 AdvanceOldestClogXid(checkPoint.oldestXid);
5623 SetTransactionIdLimit(checkPoint.oldestXid, checkPoint.oldestXidDB);
5624 SetMultiXactIdLimit(checkPoint.oldestMulti, checkPoint.oldestMultiDB, true);
5626 checkPoint.newestCommitTsXid);
5627 XLogCtl->ckptFullXid = checkPoint.nextXid;
5628
5629 /*
5630 * Clear out any old relcache cache files. This is *necessary* if we do
5631 * any WAL replay, since that would probably result in the cache files
5632 * being out of sync with database reality. In theory we could leave them
5633 * in place if the database had been cleanly shut down, but it seems
5634 * safest to just remove them always and let them be rebuilt during the
5635 * first backend startup. These files needs to be removed from all
5636 * directories including pg_tblspc, however the symlinks are created only
5637 * after reading tablespace_map file in case of archive recovery from
5638 * backup, so needs to clear old relcache files here after creating
5639 * symlinks.
5640 */
5642
5643 /*
5644 * Initialize replication slots, before there's a chance to remove
5645 * required resources.
5646 */
5648
5649 /*
5650 * Startup logical state, needs to be setup now so we have proper data
5651 * during crash recovery.
5652 */
5654
5655 /*
5656 * Startup CLOG. This must be done after TransamVariables->nextXid has
5657 * been initialized and before we accept connections or begin WAL replay.
5658 */
5659 StartupCLOG();
5660
5661 /*
5662 * Startup MultiXact. We need to do this early to be able to replay
5663 * truncations.
5664 */
5666
5667 /*
5668 * Ditto for commit timestamps. Activate the facility if the setting is
5669 * enabled in the control file, as there should be no tracking of commit
5670 * timestamps done when the setting was disabled. This facility can be
5671 * started or stopped when replaying a XLOG_PARAMETER_CHANGE record.
5672 */
5675
5676 /*
5677 * Recover knowledge about replay progress of known replication partners.
5678 */
5680
5681 /*
5682 * Initialize unlogged LSN. On a clean shutdown, it's restored from the
5683 * control file. On recovery, all unlogged relations are blown away, so
5684 * the unlogged LSN counter can be reset too.
5685 */
5689 else
5692
5693 /*
5694 * Copy any missing timeline history files between 'now' and the recovery
5695 * target timeline from archive to pg_wal. While we don't need those files
5696 * ourselves - the history file of the recovery target timeline covers all
5697 * the previous timelines in the history too - a cascading standby server
5698 * might be interested in them. Or, if you archive the WAL from this
5699 * server to a different archive than the primary, it'd be good for all
5700 * the history files to get archived there after failover, so that you can
5701 * use one of the old timelines as a PITR target. Timeline history files
5702 * are small, so it's better to copy them unnecessarily than not copy them
5703 * and regret later.
5704 */
5706
5707 /*
5708 * Before running in recovery, scan pg_twophase and fill in its status to
5709 * be able to work on entries generated by redo. Doing a scan before
5710 * taking any recovery action has the merit to discard any 2PC files that
5711 * are newer than the first record to replay, saving from any conflicts at
5712 * replay. This avoids as well any subsequent scans when doing recovery
5713 * of the on-disk two-phase data.
5714 */
5716
5717 /*
5718 * When starting with crash recovery, reset pgstat data - it might not be
5719 * valid. Otherwise restore pgstat data. It's safe to do this here,
5720 * because postmaster will not yet have started any other processes.
5721 *
5722 * NB: Restoring replication slot stats relies on slot state to have
5723 * already been restored from disk.
5724 *
5725 * TODO: With a bit of extra work we could just start with a pgstat file
5726 * associated with the checkpoint redo location we're starting from.
5727 */
5728 if (didCrash)
5730 else
5732
5734
5737
5738 /* REDO */
5739 if (InRecovery)
5740 {
5741 /* Initialize state for RecoveryInProgress() */
5745 else
5748
5749 /*
5750 * Update pg_control to show that we are recovering and to show the
5751 * selected checkpoint as the place we are starting from. We also mark
5752 * pg_control with any minimum recovery stop point obtained from a
5753 * backup history file.
5754 *
5755 * No need to hold ControlFileLock yet, we aren't up far enough.
5756 */
5758
5759 /*
5760 * If there was a backup label file, it's done its job and the info
5761 * has now been propagated into pg_control. We must get rid of the
5762 * label file so that if we crash during recovery, we'll pick up at
5763 * the latest recovery restartpoint instead of going all the way back
5764 * to the backup start point. It seems prudent though to just rename
5765 * the file out of the way rather than delete it completely.
5766 */
5767 if (haveBackupLabel)
5768 {
5769 unlink(BACKUP_LABEL_OLD);
5771 }
5772
5773 /*
5774 * If there was a tablespace_map file, it's done its job and the
5775 * symlinks have been created. We must get rid of the map file so
5776 * that if we crash during recovery, we don't create symlinks again.
5777 * It seems prudent though to just rename the file out of the way
5778 * rather than delete it completely.
5779 */
5780 if (haveTblspcMap)
5781 {
5782 unlink(TABLESPACE_MAP_OLD);
5784 }
5785
5786 /*
5787 * Initialize our local copy of minRecoveryPoint. When doing crash
5788 * recovery we want to replay up to the end of WAL. Particularly, in
5789 * the case of a promoted standby minRecoveryPoint value in the
5790 * control file is only updated after the first checkpoint. However,
5791 * if the instance crashes before the first post-recovery checkpoint
5792 * is completed then recovery will use a stale location causing the
5793 * startup process to think that there are still invalid page
5794 * references when checking for data consistency.
5795 */
5797 {
5800 }
5801 else
5802 {
5805 }
5806
5807 /* Check that the GUCs used to generate the WAL allow recovery */
5809
5810 /*
5811 * We're in recovery, so unlogged relations may be trashed and must be
5812 * reset. This should be done BEFORE allowing Hot Standby
5813 * connections, so that read-only backends don't try to read whatever
5814 * garbage is left over from before.
5815 */
5817
5818 /*
5819 * Likewise, delete any saved transaction snapshot files that got left
5820 * behind by crashed backends.
5821 */
5823
5824 /*
5825 * Initialize for Hot Standby, if enabled. We won't let backends in
5826 * yet, not until we've reached the min recovery point specified in
5827 * control file and we've established a recovery snapshot from a
5828 * running-xacts WAL record.
5829 */
5831 {
5832 TransactionId *xids;
5833 int nxids;
5834
5836 (errmsg_internal("initializing for hot standby")));
5837
5839
5840 if (wasShutdown)
5841 oldestActiveXID = PrescanPreparedTransactions(&xids, &nxids);
5842 else
5843 oldestActiveXID = checkPoint.oldestActiveXid;
5844 Assert(TransactionIdIsValid(oldestActiveXID));
5845
5846 /* Tell procarray about the range of xids it has to deal with */
5848
5849 /*
5850 * Startup subtrans only. CLOG, MultiXact and commit timestamp
5851 * have already been started up and other SLRUs are not maintained
5852 * during recovery and need not be started yet.
5853 */
5854 StartupSUBTRANS(oldestActiveXID);
5855
5856 /*
5857 * If we're beginning at a shutdown checkpoint, we know that
5858 * nothing was running on the primary at this point. So fake-up an
5859 * empty running-xacts record and use that here and now. Recover
5860 * additional standby state for prepared transactions.
5861 */
5862 if (wasShutdown)
5863 {
5865 TransactionId latestCompletedXid;
5866
5867 /* Update pg_subtrans entries for any prepared transactions */
5869
5870 /*
5871 * Construct a RunningTransactions snapshot representing a
5872 * shut down server, with only prepared transactions still
5873 * alive. We're never overflowed at this point because all
5874 * subxids are listed with their parent prepared transactions.
5875 */
5876 running.xcnt = nxids;
5877 running.subxcnt = 0;
5879 running.nextXid = XidFromFullTransactionId(checkPoint.nextXid);
5880 running.oldestRunningXid = oldestActiveXID;
5881 latestCompletedXid = XidFromFullTransactionId(checkPoint.nextXid);
5882 TransactionIdRetreat(latestCompletedXid);
5883 Assert(TransactionIdIsNormal(latestCompletedXid));
5884 running.latestCompletedXid = latestCompletedXid;
5885 running.xids = xids;
5886
5888 }
5889 }
5890
5891 /*
5892 * We're all set for replaying the WAL now. Do it.
5893 */
5895 performedWalRecovery = true;
5896 }
5897 else
5898 performedWalRecovery = false;
5899
5900 /*
5901 * Finish WAL recovery.
5902 */
5903 endOfRecoveryInfo = FinishWalRecovery();
5904 EndOfLog = endOfRecoveryInfo->endOfLog;
5905 EndOfLogTLI = endOfRecoveryInfo->endOfLogTLI;
5906 abortedRecPtr = endOfRecoveryInfo->abortedRecPtr;
5907 missingContrecPtr = endOfRecoveryInfo->missingContrecPtr;
5908
5909 /*
5910 * Reset ps status display, so as no information related to recovery shows
5911 * up.
5912 */
5913 set_ps_display("");
5914
5915 /*
5916 * When recovering from a backup (we are in recovery, and archive recovery
5917 * was requested), complain if we did not roll forward far enough to reach
5918 * the point where the database is consistent. For regular online
5919 * backup-from-primary, that means reaching the end-of-backup WAL record
5920 * (at which point we reset backupStartPoint to be Invalid), for
5921 * backup-from-replica (which can't inject records into the WAL stream),
5922 * that point is when we reach the minRecoveryPoint in pg_control (which
5923 * we purposefully copy last when backing up from a replica). For
5924 * pg_rewind (which creates a backup_label with a method of "pg_rewind")
5925 * or snapshot-style backups (which don't), backupEndRequired will be set
5926 * to false.
5927 *
5928 * Note: it is indeed okay to look at the local variable
5929 * LocalMinRecoveryPoint here, even though ControlFile->minRecoveryPoint
5930 * might be further ahead --- ControlFile->minRecoveryPoint cannot have
5931 * been advanced beyond the WAL we processed.
5932 */
5933 if (InRecovery &&
5934 (EndOfLog < LocalMinRecoveryPoint ||
5936 {
5937 /*
5938 * Ran off end of WAL before reaching end-of-backup WAL record, or
5939 * minRecoveryPoint. That's a bad sign, indicating that you tried to
5940 * recover from an online backup but never called pg_backup_stop(), or
5941 * you didn't archive all the WAL needed.
5942 */
5944 {
5946 ereport(FATAL,
5947 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
5948 errmsg("WAL ends before end of online backup"),
5949 errhint("All WAL generated while online backup was taken must be available at recovery.")));
5950 else
5951 ereport(FATAL,
5952 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
5953 errmsg("WAL ends before consistent recovery point")));
5954 }
5955 }
5956
5957 /*
5958 * Reset unlogged relations to the contents of their INIT fork. This is
5959 * done AFTER recovery is complete so as to include any unlogged relations
5960 * created during recovery, but BEFORE recovery is marked as having
5961 * completed successfully. Otherwise we'd not retry if any of the post
5962 * end-of-recovery steps fail.
5963 */
5964 if (InRecovery)
5966
5967 /*
5968 * Pre-scan prepared transactions to find out the range of XIDs present.
5969 * This information is not quite needed yet, but it is positioned here so
5970 * as potential problems are detected before any on-disk change is done.
5971 */
5972 oldestActiveXID = PrescanPreparedTransactions(NULL, NULL);
5973
5974 /*
5975 * Allow ordinary WAL segment creation before possibly switching to a new
5976 * timeline, which creates a new segment, and after the last ReadRecord().
5977 */
5979
5980 /*
5981 * Consider whether we need to assign a new timeline ID.
5982 *
5983 * If we did archive recovery, we always assign a new ID. This handles a
5984 * couple of issues. If we stopped short of the end of WAL during
5985 * recovery, then we are clearly generating a new timeline and must assign
5986 * it a unique new ID. Even if we ran to the end, modifying the current
5987 * last segment is problematic because it may result in trying to
5988 * overwrite an already-archived copy of that segment, and we encourage
5989 * DBAs to make their archive_commands reject that. We can dodge the
5990 * problem by making the new active segment have a new timeline ID.
5991 *
5992 * In a normal crash recovery, we can just extend the timeline we were in.
5993 */
5994 newTLI = endOfRecoveryInfo->lastRecTLI;
5996 {
5998 ereport(LOG,
5999 (errmsg("selected new timeline ID: %u", newTLI)));
6000
6001 /*
6002 * Make a writable copy of the last WAL segment. (Note that we also
6003 * have a copy of the last block of the old WAL in
6004 * endOfRecovery->lastPage; we will use that below.)
6005 */
6006 XLogInitNewTimeline(EndOfLogTLI, EndOfLog, newTLI);
6007
6008 /*
6009 * Remove the signal files out of the way, so that we don't
6010 * accidentally re-enter archive recovery mode in a subsequent crash.
6011 */
6012 if (endOfRecoveryInfo->standby_signal_file_found)
6014
6015 if (endOfRecoveryInfo->recovery_signal_file_found)
6017
6018 /*
6019 * Write the timeline history file, and have it archived. After this
6020 * point (or rather, as soon as the file is archived), the timeline
6021 * will appear as "taken" in the WAL archive and to any standby
6022 * servers. If we crash before actually switching to the new
6023 * timeline, standby servers will nevertheless think that we switched
6024 * to the new timeline, and will try to connect to the new timeline.
6025 * To minimize the window for that, try to do as little as possible
6026 * between here and writing the end-of-recovery record.
6027 */
6029 EndOfLog, endOfRecoveryInfo->recoveryStopReason);
6030
6031 ereport(LOG,
6032 (errmsg("archive recovery complete")));
6033 }
6034
6035 /* Save the selected TimeLineID in shared memory, too */
6037 XLogCtl->InsertTimeLineID = newTLI;
6038 XLogCtl->PrevTimeLineID = endOfRecoveryInfo->lastRecTLI;
6040
6041 /*
6042 * Actually, if WAL ended in an incomplete record, skip the parts that
6043 * made it through and start writing after the portion that persisted.
6044 * (It's critical to first write an OVERWRITE_CONTRECORD message, which
6045 * we'll do as soon as we're open for writing new WAL.)
6046 */
6048 {
6049 /*
6050 * We should only have a missingContrecPtr if we're not switching to a
6051 * new timeline. When a timeline switch occurs, WAL is copied from the
6052 * old timeline to the new only up to the end of the last complete
6053 * record, so there can't be an incomplete WAL record that we need to
6054 * disregard.
6055 */
6056 Assert(newTLI == endOfRecoveryInfo->lastRecTLI);
6058 EndOfLog = missingContrecPtr;
6059 }
6060
6061 /*
6062 * Prepare to write WAL starting at EndOfLog location, and init xlog
6063 * buffer cache using the block containing the last record from the
6064 * previous incarnation.
6065 */
6066 Insert = &XLogCtl->Insert;
6067 Insert->PrevBytePos = XLogRecPtrToBytePos(endOfRecoveryInfo->lastRec);
6068 Insert->CurrBytePos = XLogRecPtrToBytePos(EndOfLog);
6069
6070 /*
6071 * Tricky point here: lastPage contains the *last* block that the LastRec
6072 * record spans, not the one it starts in. The last block is indeed the
6073 * one we want to use.
6074 */
6075 if (EndOfLog % XLOG_BLCKSZ != 0)
6076 {
6077 char *page;
6078 int len;
6079 int firstIdx;
6080
6081 firstIdx = XLogRecPtrToBufIdx(EndOfLog);
6082 len = EndOfLog - endOfRecoveryInfo->lastPageBeginPtr;
6083 Assert(len < XLOG_BLCKSZ);
6084
6085 /* Copy the valid part of the last block, and zero the rest */
6086 page = &XLogCtl->pages[firstIdx * XLOG_BLCKSZ];
6087 memcpy(page, endOfRecoveryInfo->lastPage, len);
6088 memset(page + len, 0, XLOG_BLCKSZ - len);
6089
6090 pg_atomic_write_u64(&XLogCtl->xlblocks[firstIdx], endOfRecoveryInfo->lastPageBeginPtr + XLOG_BLCKSZ);
6091 XLogCtl->InitializedUpTo = endOfRecoveryInfo->lastPageBeginPtr + XLOG_BLCKSZ;
6092 }
6093 else
6094 {
6095 /*
6096 * There is no partial block to copy. Just set InitializedUpTo, and
6097 * let the first attempt to insert a log record to initialize the next
6098 * buffer.
6099 */
6100 XLogCtl->InitializedUpTo = EndOfLog;
6101 }
6102
6103 /*
6104 * Update local and shared status. This is OK to do without any locks
6105 * because no other process can be reading or writing WAL yet.
6106 */
6107 LogwrtResult.Write = LogwrtResult.Flush = EndOfLog;
6111 XLogCtl->LogwrtRqst.Write = EndOfLog;
6112 XLogCtl->LogwrtRqst.Flush = EndOfLog;
6113
6114 /*
6115 * Preallocate additional log files, if wanted.
6116 */
6117 PreallocXlogFiles(EndOfLog, newTLI);
6118
6119 /*
6120 * Okay, we're officially UP.
6121 */
6122 InRecovery = false;
6123
6124 /* start the archive_timeout timer and LSN running */
6125 XLogCtl->lastSegSwitchTime = (pg_time_t) time(NULL);
6126 XLogCtl->lastSegSwitchLSN = EndOfLog;
6127
6128 /* also initialize latestCompletedXid, to nextXid - 1 */
6129 LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
6132 LWLockRelease(ProcArrayLock);
6133
6134 /*
6135 * Start up subtrans, if not already done for hot standby. (commit
6136 * timestamps are started below, if necessary.)
6137 */
6139 StartupSUBTRANS(oldestActiveXID);
6140
6141 /*
6142 * Perform end of recovery actions for any SLRUs that need it.
6143 */
6144 TrimCLOG();
6145 TrimMultiXact();
6146
6147 /*
6148 * Reload shared-memory state for prepared transactions. This needs to
6149 * happen before renaming the last partial segment of the old timeline as
6150 * it may be possible that we have to recover some transactions from it.
6151 */
6153
6154 /* Shut down xlogreader */
6156
6157 /* Enable WAL writes for this backend only. */
6159
6160 /* If necessary, write overwrite-contrecord before doing anything else */
6162 {
6165 }
6166
6167 /*
6168 * Update full_page_writes in shared memory and write an XLOG_FPW_CHANGE
6169 * record before resource manager writes cleanup WAL records or checkpoint
6170 * record is written.
6171 */
6172 Insert->fullPageWrites = lastFullPageWrites;
6174
6175 /*
6176 * Emit checkpoint or end-of-recovery record in XLOG, if required.
6177 */
6178 if (performedWalRecovery)
6179 promoted = PerformRecoveryXLogAction();
6180
6181 /*
6182 * If any of the critical GUCs have changed, log them before we allow
6183 * backends to write WAL.
6184 */
6186
6187 /* If this is archive recovery, perform post-recovery cleanup actions. */
6189 CleanupAfterArchiveRecovery(EndOfLogTLI, EndOfLog, newTLI);
6190
6191 /*
6192 * Local WAL inserts enabled, so it's time to finish initialization of
6193 * commit timestamp.
6194 */
6196
6197 /*
6198 * All done with end-of-recovery actions.
6199 *
6200 * Now allow backends to write WAL and update the control file status in
6201 * consequence. SharedRecoveryState, that controls if backends can write
6202 * WAL, is updated while holding ControlFileLock to prevent other backends
6203 * to look at an inconsistent state of the control file in shared memory.
6204 * There is still a small window during which backends can write WAL and
6205 * the control file is still referring to a system not in DB_IN_PRODUCTION
6206 * state while looking at the on-disk control file.
6207 *
6208 * Also, we use info_lck to update SharedRecoveryState to ensure that
6209 * there are no race conditions concerning visibility of other recent
6210 * updates to shared memory.
6211 */
6212 LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
6214
6218
6220 LWLockRelease(ControlFileLock);
6221
6222 /*
6223 * Shutdown the recovery environment. This must occur after
6224 * RecoverPreparedTransactions() (see notes in lock_twophase_recover())
6225 * and after switching SharedRecoveryState to RECOVERY_STATE_DONE so as
6226 * any session building a snapshot will not rely on KnownAssignedXids as
6227 * RecoveryInProgress() would return false at this stage. This is
6228 * particularly critical for prepared 2PC transactions, that would still
6229 * need to be included in snapshots once recovery has ended.
6230 */
6233
6234 /*
6235 * If there were cascading standby servers connected to us, nudge any wal
6236 * sender processes to notice that we've been promoted.
6237 */
6238 WalSndWakeup(true, true);
6239
6240 /*
6241 * If this was a promotion, request an (online) checkpoint now. This isn't
6242 * required for consistency, but the last restartpoint might be far back,
6243 * and in case of a crash, recovering from it might take a longer than is
6244 * appropriate now that we're not in standby mode anymore.
6245 */
6246 if (promoted)
6248}
static void pg_atomic_write_u64(volatile pg_atomic_uint64 *ptr, uint64 val)
Definition: atomics.h:485
static void pg_atomic_write_membarrier_u64(volatile pg_atomic_uint64 *ptr, uint64 val)
Definition: atomics.h:494
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:623
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:781
int durable_unlink(const char *fname, int elevel)
Definition: fd.c:871
void SyncDataDirectory(void)
Definition: fd.c:3567
#define IsBootstrapProcessingMode()
Definition: miscadmin.h:476
void TrimMultiXact(void)
Definition: multixact.c:2178
void StartupMultiXact(void)
Definition: multixact.c:2153
void StartupReplicationOrigin(void)
Definition: origin.c:699
#define ERRCODE_DATA_CORRUPTED
Definition: pg_basebackup.c:41
@ DB_IN_PRODUCTION
Definition: pg_control.h:97
@ DB_IN_CRASH_RECOVERY
Definition: pg_control.h:95
const void size_t len
void pgstat_restore_stats(void)
Definition: pgstat.c:504
void pgstat_discard_stats(void)
Definition: pgstat.c:516
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:6828
void StartupReorderBuffer(void)
void StartupReplicationSlots(void)
Definition: slot.c:2089
void DeleteAllExportedSnapshotFiles(void)
Definition: snapmgr.c:1574
void InitRecoveryTransactionEnvironment(void)
Definition: standby.c:94
void ShutdownRecoveryTransactionEnvironment(void)
Definition: standby.c:160
@ SUBXIDS_IN_SUBTRANS
Definition: standby.h:82
bool track_commit_timestamp
Definition: pg_control.h:185
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:92
TransactionId nextXid
Definition: standby.h:91
TransactionId latestCompletedXid
Definition: standby.h:95
subxids_array_status subxid_status
Definition: standby.h:90
TransactionId * xids
Definition: standby.h:97
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:2073
void restoreTwoPhaseData(void)
Definition: twophase.c:1888
TransactionId PrescanPreparedTransactions(TransactionId **xids_p, int *nxids_p)
Definition: twophase.c:1952
void StandbyRecoverPreparedTransactions(void)
Definition: twophase.c:2032
void WalSndWakeup(bool physical, bool logical)
Definition: walsender.c:3639
void UpdateFullPageWrites(void)
Definition: xlog.c:8212
static char * str_time(pg_time_t tnow)
Definition: xlog.c:5245
static void ValidateXLOGDirectoryStructure(void)
Definition: xlog.c:4105
static XLogRecPtr CreateOverwriteContrecordRecord(XLogRecPtr aborted_lsn, XLogRecPtr pagePtr, TimeLineID newTLI)
Definition: xlog.c:7486
static void XLogReportParameters(void)
Definition: xlog.c:8149
static bool PerformRecoveryXLogAction(void)
Definition: xlog.c:6330
static void CleanupAfterArchiveRecovery(TimeLineID EndOfLogTLI, XLogRecPtr EndOfLog, TimeLineID newTLI)
Definition: xlog.c:5335
static bool lastFullPageWrites
Definition: xlog.c:217
static uint64 XLogRecPtrToBytePos(XLogRecPtr ptr)
Definition: xlog.c:1941
static void XLogInitNewTimeline(TimeLineID endTLI, XLogRecPtr endOfLog, TimeLineID newTLI)
Definition: xlog.c:5260
static void CheckRequiredParameterValues(void)
Definition: xlog.c:5431
#define XLogRecPtrToBufIdx(recptr)
Definition: xlog.c:591
static void RemoveTempXlogFiles(void)
Definition: xlog.c:3838
#define TABLESPACE_MAP_OLD
Definition: xlog.h:307
#define TABLESPACE_MAP
Definition: xlog.h:306
#define STANDBY_SIGNAL_FILE
Definition: xlog.h:302
#define BACKUP_LABEL_OLD
Definition: xlog.h:304
#define BACKUP_LABEL_FILE
Definition: xlog.h:303
#define RECOVERY_SIGNAL_FILE
Definition: xlog.h:301
#define XRecOffIsValid(xlrp)
#define FirstNormalUnloggedLSN
Definition: xlogdefs.h:36
void ShutdownWalRecovery(void)
bool ArchiveRecoveryRequested
Definition: xlogrecovery.c:138
bool InArchiveRecovery
Definition: xlogrecovery.c:139
void PerformWalRecovery(void)
static XLogRecPtr missingContrecPtr
Definition: xlogrecovery.c:374
static XLogRecPtr abortedRecPtr
Definition: xlogrecovery.c:373
EndOfWalRecoveryInfo * FinishWalRecovery(void)
void InitWalRecovery(ControlFileData *ControlFile, bool *wasShutdown_ptr, bool *haveBackupLabel_ptr, bool *haveTblspcMap_ptr)
Definition: xlogrecovery.c:513
TimeLineID recoveryTargetTLI
Definition: xlogrecovery.c:123
HotStandbyState standbyState
Definition: xlogutils.c:53
bool InRecovery
Definition: xlogutils.c:50
@ STANDBY_DISABLED
Definition: xlogutils.h:52

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_status, SUBXIDS_IN_SUBTRANS, 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 6255 of file xlog.c.

6256{
6257 /* initialize minRecoveryPoint to this record */
6258 LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
6260 if (ControlFile->minRecoveryPoint < EndRecPtr)
6261 {
6262 ControlFile->minRecoveryPoint = EndRecPtr;
6263 ControlFile->minRecoveryPointTLI = replayTLI;
6264 }
6265 /* update local copy */
6268
6269 /*
6270 * The startup process can update its local copy of minRecoveryPoint from
6271 * this point.
6272 */
6274
6276
6277 /*
6278 * We update SharedRecoveryState while holding the lock on ControlFileLock
6279 * so both states are consistent in shared memory.
6280 */
6284
6285 LWLockRelease(ControlFileLock);
6286}
static bool updateMinRecoveryPoint
Definition: xlog.c:648

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

8213{
8215 bool recoveryInProgress;
8216
8217 /*
8218 * Do nothing if full_page_writes has not been changed.
8219 *
8220 * It's safe to check the shared full_page_writes without the lock,
8221 * because we assume that there is no concurrently running process which
8222 * can update it.
8223 */
8224 if (fullPageWrites == Insert->fullPageWrites)
8225 return;
8226
8227 /*
8228 * Perform this outside critical section so that the WAL insert
8229 * initialization done by RecoveryInProgress() doesn't trigger an
8230 * assertion failure.
8231 */
8232 recoveryInProgress = RecoveryInProgress();
8233
8235
8236 /*
8237 * It's always safe to take full page images, even when not strictly
8238 * required, but not the other round. So if we're setting full_page_writes
8239 * to true, first set it true and then write the WAL record. If we're
8240 * setting it to false, first write the WAL record and then set the global
8241 * flag.
8242 */
8243 if (fullPageWrites)
8244 {
8246 Insert->fullPageWrites = true;
8248 }
8249
8250 /*
8251 * Write an XLOG_FPW_CHANGE record. This allows us to keep track of
8252 * full_page_writes during archive recovery, if required.
8253 */
8254 if (XLogStandbyInfoActive() && !recoveryInProgress)
8255 {
8257 XLogRegisterData(&fullPageWrites, sizeof(bool));
8258
8259 XLogInsert(RM_XLOG_ID, XLOG_FPW_CHANGE);
8260 }
8261
8262 if (!fullPageWrites)
8263 {
8265 Insert->fullPageWrites = false;
8267 }
8269}
#define XLOG_FPW_CHANGE
Definition: pg_control.h:76

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

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

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 58 of file xlogdesc.c.

59{
60 char *rec = XLogRecGetData(record);
61 uint8 info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
62
63 if (info == XLOG_CHECKPOINT_SHUTDOWN ||
65 {
66 CheckPoint *checkpoint = (CheckPoint *) rec;
67
68 appendStringInfo(buf, "redo %X/%X; "
69 "tli %u; prev tli %u; fpw %s; wal_level %s; xid %u:%u; oid %u; multi %u; offset %u; "
70 "oldest xid %u in DB %u; oldest multi %u in DB %u; "
71 "oldest/newest commit timestamp xid: %u/%u; "
72 "oldest running xid %u; %s",
73 LSN_FORMAT_ARGS(checkpoint->redo),
74 checkpoint->ThisTimeLineID,
75 checkpoint->PrevTimeLineID,
76 checkpoint->fullPageWrites ? "true" : "false",
80 checkpoint->nextOid,
81 checkpoint->nextMulti,
82 checkpoint->nextMultiOffset,
83 checkpoint->oldestXid,
84 checkpoint->oldestXidDB,
85 checkpoint->oldestMulti,
86 checkpoint->oldestMultiDB,
87 checkpoint->oldestCommitTsXid,
88 checkpoint->newestCommitTsXid,
89 checkpoint->oldestActiveXid,
90 (info == XLOG_CHECKPOINT_SHUTDOWN) ? "shutdown" : "online");
91 }
92 else if (info == XLOG_NEXTOID)
93 {
94 Oid nextOid;
95
96 memcpy(&nextOid, rec, sizeof(Oid));
97 appendStringInfo(buf, "%u", nextOid);
98 }
99 else if (info == XLOG_RESTORE_POINT)
100 {
101 xl_restore_point *xlrec = (xl_restore_point *) rec;
102
104 }
105 else if (info == XLOG_FPI || info == XLOG_FPI_FOR_HINT)
106 {
107 /* no further information to print */
108 }
109 else if (info == XLOG_BACKUP_END)
110 {
111 XLogRecPtr startpoint;
112
113 memcpy(&startpoint, rec, sizeof(XLogRecPtr));
114 appendStringInfo(buf, "%X/%X", LSN_FORMAT_ARGS(startpoint));
115 }
116 else if (info == XLOG_PARAMETER_CHANGE)
117 {
119 const char *wal_level_str;
120
121 memcpy(&xlrec, rec, sizeof(xl_parameter_change));
123
124 appendStringInfo(buf, "max_connections=%d max_worker_processes=%d "
125 "max_wal_senders=%d max_prepared_xacts=%d "
126 "max_locks_per_xact=%d wal_level=%s "
127 "wal_log_hints=%s track_commit_timestamp=%s",
128 xlrec.MaxConnections,
130 xlrec.max_wal_senders,
131 xlrec.max_prepared_xacts,
132 xlrec.max_locks_per_xact,
134 xlrec.wal_log_hints ? "on" : "off",
135 xlrec.track_commit_timestamp ? "on" : "off");
136 }
137 else if (info == XLOG_FPW_CHANGE)
138 {
139 bool fpw;
140
141 memcpy(&fpw, rec, sizeof(bool));
142 appendStringInfoString(buf, fpw ? "true" : "false");
143 }
144 else if (info == XLOG_END_OF_RECOVERY)
145 {
146 xl_end_of_recovery xlrec;
147
148 memcpy(&xlrec, rec, sizeof(xl_end_of_recovery));
149 appendStringInfo(buf, "tli %u; prev tli %u; time %s; wal_level %s",
150 xlrec.ThisTimeLineID, xlrec.PrevTimeLineID,
153 }
154 else if (info == XLOG_OVERWRITE_CONTRECORD)
155 {
157
158 memcpy(&xlrec, rec, sizeof(xl_overwrite_contrecord));
159 appendStringInfo(buf, "lsn %X/%X; time %s",
162 }
163 else if (info == XLOG_CHECKPOINT_REDO)
164 {
165 int wal_level;
166
167 memcpy(&wal_level, rec, sizeof(int));
169 }
170}
static const char * wal_level_str(WalLevel wal_level)
uint8_t uint8
Definition: c.h:500
#define XLOG_RESTORE_POINT
Definition: pg_control.h:75
#define XLOG_OVERWRITE_CONTRECORD
Definition: pg_control.h:81
#define XLOG_FPI
Definition: pg_control.h:79
#define XLOG_FPI_FOR_HINT
Definition: pg_control.h:78
#define XLOG_NEXTOID
Definition: pg_control.h:71
#define XLOG_PARAMETER_CHANGE
Definition: pg_control.h:74
#define XLOG_END_OF_RECOVERY
Definition: pg_control.h:77
static char * buf
Definition: pg_test_fsync.c:72
void appendStringInfoString(StringInfo str, const char *s)
Definition: stringinfo.c:230
TimeLineID PrevTimeLineID
TimestampTz end_time
TimeLineID ThisTimeLineID
char rp_name[MAXFNAMELEN]
#define EpochFromFullTransactionId(x)
Definition: transam.h:47
static const char * get_wal_level_string(int wal_level)
Definition: xlogdesc.c:40
#define XLogRecGetInfo(decoder)
Definition: xlogreader.h:410
#define XLogRecGetData(decoder)
Definition: xlogreader.h:415

References appendStringInfo(), appendStringInfoString(), buf, xl_end_of_recovery::end_time, EpochFromFullTransactionId, CheckPoint::fullPageWrites, get_wal_level_string(), 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, 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, wal_level, xl_parameter_change::wal_level, xl_end_of_recovery::wal_level, CheckPoint::wal_level, 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, and XLogRecGetInfo.

◆ xlog_identify()

const char * xlog_identify ( uint8  info)

Definition at line 173 of file xlogdesc.c.

174{
175 const char *id = NULL;
176
177 switch (info & ~XLR_INFO_MASK)
178 {
180 id = "CHECKPOINT_SHUTDOWN";
181 break;
183 id = "CHECKPOINT_ONLINE";
184 break;
185 case XLOG_NOOP:
186 id = "NOOP";
187 break;
188 case XLOG_NEXTOID:
189 id = "NEXTOID";
190 break;
191 case XLOG_SWITCH:
192 id = "SWITCH";
193 break;
194 case XLOG_BACKUP_END:
195 id = "BACKUP_END";
196 break;
198 id = "PARAMETER_CHANGE";
199 break;
201 id = "RESTORE_POINT";
202 break;
203 case XLOG_FPW_CHANGE:
204 id = "FPW_CHANGE";
205 break;
207 id = "END_OF_RECOVERY";
208 break;
210 id = "OVERWRITE_CONTRECORD";
211 break;
212 case XLOG_FPI:
213 id = "FPI";
214 break;
216 id = "FPI_FOR_HINT";
217 break;
219 id = "CHECKPOINT_REDO";
220 break;
221 }
222
223 return id;
224}
#define XLOG_NOOP
Definition: pg_control.h:70
#define XLOG_SWITCH
Definition: pg_control.h:72
#define XLR_INFO_MASK
Definition: xlogrecord.h:62

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

8282{
8283 uint8 info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
8284 XLogRecPtr lsn = record->EndRecPtr;
8285
8286 /*
8287 * In XLOG rmgr, backup blocks are only used by XLOG_FPI and
8288 * XLOG_FPI_FOR_HINT records.
8289 */
8290 Assert(info == XLOG_FPI || info == XLOG_FPI_FOR_HINT ||
8291 !XLogRecHasAnyBlockRefs(record));
8292
8293 if (info == XLOG_NEXTOID)
8294 {
8295 Oid nextOid;
8296
8297 /*
8298 * We used to try to take the maximum of TransamVariables->nextOid and
8299 * the recorded nextOid, but that fails if the OID counter wraps
8300 * around. Since no OID allocation should be happening during replay
8301 * anyway, better to just believe the record exactly. We still take
8302 * OidGenLock while setting the variable, just in case.
8303 */
8304 memcpy(&nextOid, XLogRecGetData(record), sizeof(Oid));
8305 LWLockAcquire(OidGenLock, LW_EXCLUSIVE);
8306 TransamVariables->nextOid = nextOid;
8308 LWLockRelease(OidGenLock);
8309 }
8310 else if (info == XLOG_CHECKPOINT_SHUTDOWN)
8311 {
8312 CheckPoint checkPoint;
8313 TimeLineID replayTLI;
8314
8315 memcpy(&checkPoint, XLogRecGetData(record), sizeof(CheckPoint));
8316 /* In a SHUTDOWN checkpoint, believe the counters exactly */
8317 LWLockAcquire(XidGenLock, LW_EXCLUSIVE);
8318 TransamVariables->nextXid = checkPoint.nextXid;
8319 LWLockRelease(XidGenLock);
8320 LWLockAcquire(OidGenLock, LW_EXCLUSIVE);
8321 TransamVariables->nextOid = checkPoint.nextOid;
8323 LWLockRelease(OidGenLock);
8325 checkPoint.nextMultiOffset);
8326
8328 checkPoint.oldestMultiDB);
8329
8330 /*
8331 * No need to set oldestClogXid here as well; it'll be set when we
8332 * redo an xl_clog_truncate if it changed since initialization.
8333 */
8334 SetTransactionIdLimit(checkPoint.oldestXid, checkPoint.oldestXidDB);
8335
8336 /*
8337 * If we see a shutdown checkpoint while waiting for an end-of-backup
8338 * record, the backup was canceled and the end-of-backup record will
8339 * never arrive.
8340 */
8344 ereport(PANIC,
8345 (errmsg("online backup was canceled, recovery cannot continue")));
8346
8347 /*
8348 * If we see a shutdown checkpoint, we know that nothing was running
8349 * on the primary at this point. So fake-up an empty running-xacts
8350 * record and use that here and now. Recover additional standby state
8351 * for prepared transactions.
8352 */
8354 {
8355 TransactionId *xids;
8356 int nxids;
8357 TransactionId oldestActiveXID;
8358 TransactionId latestCompletedXid;
8360
8361 oldestActiveXID = PrescanPreparedTransactions(&xids, &nxids);
8362
8363 /* Update pg_subtrans entries for any prepared transactions */
8365
8366 /*
8367 * Construct a RunningTransactions snapshot representing a shut
8368 * down server, with only prepared transactions still alive. We're
8369 * never overflowed at this point because all subxids are listed
8370 * with their parent prepared transactions.
8371 */
8372 running.xcnt = nxids;
8373 running.subxcnt = 0;
8375 running.nextXid = XidFromFullTransactionId(checkPoint.nextXid);
8376 running.oldestRunningXid = oldestActiveXID;
8377 latestCompletedXid = XidFromFullTransactionId(checkPoint.nextXid);
8378 TransactionIdRetreat(latestCompletedXid);
8379 Assert(TransactionIdIsNormal(latestCompletedXid));
8380 running.latestCompletedXid = latestCompletedXid;
8381 running.xids = xids;
8382
8384 }
8385
8386 /* ControlFile->checkPointCopy always tracks the latest ckpt XID */
8387 LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
8389 LWLockRelease(ControlFileLock);
8390
8391 /* Update shared-memory copy of checkpoint XID/epoch */
8393 XLogCtl->ckptFullXid = checkPoint.nextXid;
8395
8396 /*
8397 * We should've already switched to the new TLI before replaying this
8398 * record.
8399 */
8400 (void) GetCurrentReplayRecPtr(&replayTLI);
8401 if (checkPoint.ThisTimeLineID != replayTLI)
8402 ereport(PANIC,
8403 (errmsg("unexpected timeline ID %u (should be %u) in shutdown checkpoint record",
8404 checkPoint.ThisTimeLineID, replayTLI)));
8405
8406 RecoveryRestartPoint(&checkPoint, record);
8407 }
8408 else if (info == XLOG_CHECKPOINT_ONLINE)
8409 {
8410 CheckPoint checkPoint;
8411 TimeLineID replayTLI;
8412
8413 memcpy(&checkPoint, XLogRecGetData(record), sizeof(CheckPoint));
8414 /* In an ONLINE checkpoint, treat the XID counter as a minimum */
8415 LWLockAcquire(XidGenLock, LW_EXCLUSIVE);
8417 checkPoint.nextXid))
8418 TransamVariables->nextXid = checkPoint.nextXid;
8419 LWLockRelease(XidGenLock);
8420
8421 /*
8422 * We ignore the nextOid counter in an ONLINE checkpoint, preferring
8423 * to track OID assignment through XLOG_NEXTOID records. The nextOid
8424 * counter is from the start of the checkpoint and might well be stale
8425 * compared to later XLOG_NEXTOID records. We could try to take the
8426 * maximum of the nextOid counter and our latest value, but since
8427 * there's no particular guarantee about the speed with which the OID
8428 * counter wraps around, that's a risky thing to do. In any case,
8429 * users of the nextOid counter are required to avoid assignment of
8430 * duplicates, so that a somewhat out-of-date value should be safe.
8431 */
8432
8433 /* Handle multixact */
8435 checkPoint.nextMultiOffset);
8436
8437 /*
8438 * NB: This may perform multixact truncation when replaying WAL
8439 * generated by an older primary.
8440 */
8442 checkPoint.oldestMultiDB);
8444 checkPoint.oldestXid))
8446 checkPoint.oldestXidDB);
8447 /* ControlFile->checkPointCopy always tracks the latest ckpt XID */
8448 LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
8450 LWLockRelease(ControlFileLock);
8451
8452 /* Update shared-memory copy of checkpoint XID/epoch */
8454 XLogCtl->ckptFullXid = checkPoint.nextXid;
8456
8457 /* TLI should not change in an on-line checkpoint */
8458 (void) GetCurrentReplayRecPtr(&replayTLI);
8459 if (checkPoint.ThisTimeLineID != replayTLI)
8460 ereport(PANIC,
8461 (errmsg("unexpected timeline ID %u (should be %u) in online checkpoint record",
8462 checkPoint.ThisTimeLineID, replayTLI)));
8463
8464 RecoveryRestartPoint(&checkPoint, record);
8465 }
8466 else if (info == XLOG_OVERWRITE_CONTRECORD)
8467 {
8468 /* nothing to do here, handled in xlogrecovery_redo() */
8469 }
8470 else if (info == XLOG_END_OF_RECOVERY)
8471 {
8472 xl_end_of_recovery xlrec;
8473 TimeLineID replayTLI;
8474
8475 memcpy(&xlrec, XLogRecGetData(record), sizeof(xl_end_of_recovery));
8476
8477 /*
8478 * For Hot Standby, we could treat this like a Shutdown Checkpoint,
8479 * but this case is rarer and harder to test, so the benefit doesn't
8480 * outweigh the potential extra cost of maintenance.
8481 */
8482
8483 /*
8484 * We should've already switched to the new TLI before replaying this
8485 * record.
8486 */
8487 (void) GetCurrentReplayRecPtr(&replayTLI);
8488 if (xlrec.ThisTimeLineID != replayTLI)
8489 ereport(PANIC,
8490 (errmsg("unexpected timeline ID %u (should be %u) in end-of-recovery record",
8491 xlrec.ThisTimeLineID, replayTLI)));
8492 }
8493 else if (info == XLOG_NOOP)
8494 {
8495 /* nothing to do here */
8496 }
8497 else if (info == XLOG_SWITCH)
8498 {
8499 /* nothing to do here */
8500 }
8501 else if (info == XLOG_RESTORE_POINT)
8502 {
8503 /* nothing to do here, handled in xlogrecovery.c */
8504 }
8505 else if (info == XLOG_FPI || info == XLOG_FPI_FOR_HINT)
8506 {
8507 /*
8508 * XLOG_FPI records contain nothing else but one or more block
8509 * references. Every block reference must include a full-page image
8510 * even if full_page_writes was disabled when the record was generated
8511 * - otherwise there would be no point in this record.
8512 *
8513 * XLOG_FPI_FOR_HINT records are generated when a page needs to be
8514 * WAL-logged because of a hint bit update. They are only generated
8515 * when checksums and/or wal_log_hints are enabled. They may include
8516 * no full-page images if full_page_writes was disabled when they were
8517 * generated. In this case there is nothing to do here.
8518 *
8519 * No recovery conflicts are generated by these generic records - if a
8520 * resource manager needs to generate conflicts, it has to define a
8521 * separate WAL record type and redo routine.
8522 */
8523 for (uint8 block_id = 0; block_id <= XLogRecMaxBlockId(record); block_id++)
8524 {
8525 Buffer buffer;
8526
8527 if (!XLogRecHasBlockImage(record, block_id))
8528 {
8529 if (info == XLOG_FPI)
8530 elog(ERROR, "XLOG_FPI record did not contain a full-page image");
8531 continue;
8532 }
8533
8534 if (XLogReadBufferForRedo(record, block_id, &buffer) != BLK_RESTORED)
8535 elog(ERROR, "unexpected XLogReadBufferForRedo result when restoring backup block");
8536 UnlockReleaseBuffer(buffer);
8537 }
8538 }
8539 else if (info == XLOG_BACKUP_END)
8540 {
8541 /* nothing to do here, handled in xlogrecovery_redo() */
8542 }
8543 else if (info == XLOG_PARAMETER_CHANGE)
8544 {
8545 xl_parameter_change xlrec;
8546
8547 /* Update our copy of the parameters in pg_control */
8548 memcpy(&xlrec, XLogRecGetData(record), sizeof(xl_parameter_change));
8549
8550 /*
8551 * Invalidate logical slots if we are in hot standby and the primary
8552 * does not have a WAL level sufficient for logical decoding. No need
8553 * to search for potentially conflicting logically slots if standby is
8554 * running with wal_level lower than logical, because in that case, we
8555 * would have either disallowed creation of logical slots or
8556 * invalidated existing ones.
8557 */
8558 if (InRecovery && InHotStandby &&
8559 xlrec.wal_level < WAL_LEVEL_LOGICAL &&
8562 0, InvalidOid,
8564
8565 LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
8573
8574 /*
8575 * Update minRecoveryPoint to ensure that if recovery is aborted, we
8576 * recover back up to this point before allowing hot standby again.
8577 * This is important if the max_* settings are decreased, to ensure
8578 * you don't run queries against the WAL preceding the change. The
8579 * local copies cannot be updated as long as crash recovery is
8580 * happening and we expect all the WAL to be replayed.
8581 */
8583 {
8586 }
8588 {
8589 TimeLineID replayTLI;
8590
8591 (void) GetCurrentReplayRecPtr(&replayTLI);
8593 ControlFile->minRecoveryPointTLI = replayTLI;
8594 }
8595
8599
8601 LWLockRelease(ControlFileLock);
8602
8603 /* Check to see if any parameter change gives a problem on recovery */
8605 }
8606 else if (info == XLOG_FPW_CHANGE)
8607 {
8608 bool fpw;
8609
8610 memcpy(&fpw, XLogRecGetData(record), sizeof(bool));
8611
8612 /*
8613 * Update the LSN of the last replayed XLOG_FPW_CHANGE record so that
8614 * do_pg_backup_start() and do_pg_backup_stop() can check whether
8615 * full_page_writes has been disabled during online backup.
8616 */
8617 if (!fpw)
8618 {
8623 }
8624
8625 /* Keep track of full_page_writes */
8626 lastFullPageWrites = fpw;
8627 }
8628 else if (info == XLOG_CHECKPOINT_REDO)
8629 {
8630 /* nothing to do here, just for informational purposes */
8631 }
8632}
int Buffer
Definition: buf.h:23
void UnlockReleaseBuffer(Buffer buffer)
Definition: bufmgr.c:4934
void CommitTsParameterChange(bool newvalue, bool oldvalue)
Definition: commit_ts.c:664
void MultiXactAdvanceOldest(MultiXactId oldestMulti, Oid oldestMultiDB)
Definition: multixact.c:2536
void MultiXactAdvanceNextMXact(MultiXactId minMulti, MultiXactOffset minMultiOffset)
Definition: multixact.c:2511
@ RS_INVAL_WAL_LEVEL
Definition: slot.h:59
int max_worker_processes
Definition: pg_control.h:181
int max_locks_per_xact
Definition: pg_control.h:184
int max_prepared_xacts
Definition: pg_control.h:183
XLogRecPtr EndRecPtr
Definition: xlogreader.h:207
XLogRecPtr ReadRecPtr
Definition: xlogreader.h:206
bool TransactionIdPrecedes(TransactionId id1, TransactionId id2)
Definition: transam.c:280
#define FullTransactionIdPrecedes(a, b)
Definition: transam.h:51
static void RecoveryRestartPoint(const CheckPoint *checkPoint, XLogReaderState *record)
Definition: xlog.c:7596
#define XLogRecMaxBlockId(decoder)
Definition: xlogreader.h:418
#define XLogRecHasBlockImage(decoder, block_id)
Definition: xlogreader.h:423
#define XLogRecHasAnyBlockRefs(decoder)
Definition: xlogreader.h:417
XLogRecPtr GetCurrentReplayRecPtr(TimeLineID *replayEndTLI)
XLogRedoAction XLogReadBufferForRedo(XLogReaderState *record, uint8 block_id, Buffer *buf)
Definition: xlogutils.c:303
@ STANDBY_INITIALIZED
Definition: xlogutils.h:53
#define InHotStandby
Definition: xlogutils.h:60
@ BLK_RESTORED
Definition: xlogutils.h:76

References ArchiveRecoveryRequested, Assert(), ControlFileData::backupEndPoint, ControlFileData::backupStartPoint, BLK_RESTORED, ControlFileData::checkPointCopy, CheckRequiredParameterValues(), XLogCtlData::ckptFullXid, CommitTsParameterChange(), ControlFile, elog, XLogReaderState::EndRecPtr, ereport, errmsg(), ERROR, FullTransactionIdPrecedes, GetCurrentReplayRecPtr(), InArchiveRecovery, XLogCtlData::info_lck, InHotStandby, InRecovery, InvalidateObsoleteReplicationSlots(), InvalidOid, InvalidTransactionId, InvalidXLogRecPtr, XLogCtlData::lastFpwDisableRecPtr, lastFullPageWrites, RunningTransactionsData::latestCompletedXid, LocalMinRecoveryPoint, LocalMinRecoveryPointTLI, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), xl_parameter_change::max_locks_per_xact, ControlFileData::max_locks_per_xact, xl_parameter_change::max_prepared_xacts, ControlFileData::max_prepared_xacts, xl_parameter_change::max_wal_senders, ControlFileData::max_wal_senders, xl_parameter_change::max_worker_processes, ControlFileData::max_worker_processes, xl_parameter_change::MaxConnections, ControlFileData::MaxConnections, ControlFileData::minRecoveryPoint, ControlFileData::minRecoveryPointTLI, MultiXactAdvanceNextMXact(), MultiXactAdvanceOldest(), MultiXactSetNextMXact(), CheckPoint::nextMulti, CheckPoint::nextMultiOffset, TransamVariablesData::nextOid, CheckPoint::nextOid, TransamVariablesData::nextXid, CheckPoint::nextXid, RunningTransactionsData::nextXid, TransamVariablesData::oidCount, CheckPoint::oldestMulti, CheckPoint::oldestMultiDB, RunningTransactionsData::oldestRunningXid, TransamVariablesData::oldestXid, CheckPoint::oldestXid, CheckPoint::oldestXidDB, PANIC, PrescanPreparedTransactions(), ProcArrayApplyRecoveryInfo(), XLogReaderState::ReadRecPtr, RecoveryRestartPoint(), RS_INVAL_WAL_LEVEL, SetTransactionIdLimit(), SpinLockAcquire, SpinLockRelease, STANDBY_INITIALIZED, StandbyRecoverPreparedTransactions(), standbyState, RunningTransactionsData::subxcnt, RunningTransactionsData::subxid_status, SUBXIDS_IN_SUBTRANS, xl_end_of_recovery::ThisTimeLineID, CheckPoint::ThisTimeLineID, xl_parameter_change::track_commit_timestamp, ControlFileData::track_commit_timestamp, TransactionIdIsNormal, TransactionIdPrecedes(), TransactionIdRetreat, TransamVariables, UnlockReleaseBuffer(), UpdateControlFile(), wal_level, xl_parameter_change::wal_level, ControlFileData::wal_level, WAL_LEVEL_LOGICAL, xl_parameter_change::wal_log_hints, ControlFileData::wal_log_hints, RunningTransactionsData::xcnt, XidFromFullTransactionId, RunningTransactionsData::xids, 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, XLogCtl, XLogReadBufferForRedo(), XLogRecGetData, XLogRecGetInfo, XLogRecHasAnyBlockRefs, XLogRecHasBlockImage, XLogRecMaxBlockId, and XLogRecPtrIsInvalid.

◆ XLogBackgroundFlush()

bool XLogBackgroundFlush ( void  )

Definition at line 2978 of file xlog.c.

2979{
2980 XLogwrtRqst WriteRqst;
2981 bool flexible = true;
2982 static TimestampTz lastflush;
2984 int flushblocks;
2985 TimeLineID insertTLI;
2986
2987 /* XLOG doesn't need flushing during recovery */
2988 if (RecoveryInProgress())
2989 return false;
2990
2991 /*
2992 * Since we're not in recovery, InsertTimeLineID is set and can't change,
2993 * so we can read it without a lock.
2994 */
2995 insertTLI = XLogCtl->InsertTimeLineID;
2996
2997 /* read updated LogwrtRqst */
2999 WriteRqst = XLogCtl->LogwrtRqst;
3001
3002 /* back off to last completed page boundary */
3003 WriteRqst.Write -= WriteRqst.Write % XLOG_BLCKSZ;
3004
3005 /* if we have already flushed that far, consider async commit records */
3007 if (WriteRqst.Write <= LogwrtResult.Flush)
3008 {
3010 WriteRqst.Write = XLogCtl->asyncXactLSN;
3012 flexible = false; /* ensure it all gets written */
3013 }
3014
3015 /*
3016 * If already known flushed, we're done. Just need to check if we are
3017 * holding an open file handle to a logfile that's no longer in use,
3018 * preventing the file from being deleted.
3019 */
3020 if (WriteRqst.Write <= LogwrtResult.Flush)
3021 {
3022 if (openLogFile >= 0)
3023 {
3026 {
3027 XLogFileClose();
3028 }
3029 }
3030 return false;
3031 }
3032
3033 /*
3034 * Determine how far to flush WAL, based on the wal_writer_delay and
3035 * wal_writer_flush_after GUCs.
3036 *
3037 * Note that XLogSetAsyncXactLSN() performs similar calculation based on
3038 * wal_writer_flush_after, to decide when to wake us up. Make sure the
3039 * logic is the same in both places if you change this.
3040 */
3042 flushblocks =
3043 WriteRqst.Write / XLOG_BLCKSZ - LogwrtResult.Flush / XLOG_BLCKSZ;
3044
3045 if (WalWriterFlushAfter == 0 || lastflush == 0)
3046 {
3047 /* first call, or block based limits disabled */
3048 WriteRqst.Flush = WriteRqst.Write;
3049 lastflush = now;
3050 }
3051 else if (TimestampDifferenceExceeds(lastflush, now, WalWriterDelay))
3052 {
3053 /*
3054 * Flush the writes at least every WalWriterDelay ms. This is
3055 * important to bound the amount of time it takes for an asynchronous
3056 * commit to hit disk.
3057 */
3058 WriteRqst.Flush = WriteRqst.Write;
3059 lastflush = now;
3060 }
3061 else if (flushblocks >= WalWriterFlushAfter)
3062 {
3063 /* exceeded wal_writer_flush_after blocks, flush */
3064 WriteRqst.Flush = WriteRqst.Write;
3065 lastflush = now;
3066 }
3067 else
3068 {
3069 /* no flushing, this time round */
3070 WriteRqst.Flush = 0;
3071 }
3072
3073#ifdef WAL_DEBUG
3074 if (XLOG_DEBUG)
3075 elog(LOG, "xlog bg flush request write %X/%X; flush: %X/%X, current is write %X/%X; flush %X/%X",
3076 LSN_FORMAT_ARGS(WriteRqst.Write),
3077 LSN_FORMAT_ARGS(WriteRqst.Flush),
3080#endif
3081
3083
3084 /* now wait for any in-progress insertions to finish and get write lock */
3086 LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
3088 if (WriteRqst.Write > LogwrtResult.Write ||
3089 WriteRqst.Flush > LogwrtResult.Flush)
3090 {
3091 XLogWrite(WriteRqst, insertTLI, flexible);
3092 }
3093 LWLockRelease(WALWriteLock);
3094
3096
3097 /* wake up walsenders now that we've released heavily contended locks */
3099
3100 /*
3101 * Great, done. To take some work off the critical path, try to initialize
3102 * as many of the no-longer-needed WAL buffers for future use as we can.
3103 */
3104 AdvanceXLInsertBuffer(InvalidXLogRecPtr, insertTLI, true);
3105
3106 /*
3107 * If we determined that we need to write data, but somebody else
3108 * wrote/flushed already, it should be considered as being active, to
3109 * avoid hibernating too early.
3110 */
3111 return true;
3112}
bool TimestampDifferenceExceeds(TimestampTz start_time, TimestampTz stop_time, int msec)
Definition: timestamp.c:1780
Datum now(PG_FUNCTION_ARGS)
Definition: timestamp.c:1608
XLogRecPtr asyncXactLSN
Definition: xlog.c:458
static void WalSndWakeupProcessRequests(bool physical, bool logical)
Definition: walsender.h:65
int WalWriterFlushAfter
Definition: walwriter.c:71
int WalWriterDelay
Definition: walwriter.c:70
static XLogRecPtr WaitXLogInsertionsToFinish(XLogRecPtr upto)
Definition: xlog.c:1504
static void AdvanceXLInsertBuffer(XLogRecPtr upto, TimeLineID tli, bool opportunistic)
Definition: xlog.c:1985
static void XLogWrite(XLogwrtRqst WriteRqst, TimeLineID tli, bool flexible)
Definition: xlog.c:2314
static void XLogFileClose(void)
Definition: xlog.c:3645
static XLogSegNo openLogSegNo
Definition: xlog.c:636
#define XLByteInPrevSeg(xlrp, logSegNo, wal_segsz_bytes)

References AdvanceXLInsertBuffer(), XLogCtlData::asyncXactLSN, elog, END_CRIT_SECTION, XLogwrtRqst::Flush, XLogwrtResult::Flush, GetCurrentTimestamp(), XLogCtlData::info_lck, XLogCtlData::InsertTimeLineID, InvalidXLogRecPtr, LOG, LogwrtResult, XLogCtlData::LogwrtRqst, LSN_FORMAT_ARGS, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), now(), openLogFile, openLogSegNo, RecoveryInProgress(), RefreshXLogWriteResult, SpinLockAcquire, SpinLockRelease, START_CRIT_SECTION, TimestampDifferenceExceeds(), WaitXLogInsertionsToFinish(), wal_segment_size, WalSndWakeupProcessRequests(), WalWriterDelay, WalWriterFlushAfter, XLogwrtRqst::Write, XLogwrtResult::Write, XLByteInPrevSeg, XLogCtl, XLogFileClose(), and XLogWrite().

Referenced by WalSndWaitForWal(), and WalWriterMain().

◆ XLogCheckpointNeeded()

bool XLogCheckpointNeeded ( XLogSegNo  new_segno)

Definition at line 2290 of file xlog.c.

2291{
2292 XLogSegNo old_segno;
2293
2295
2296 if (new_segno >= old_segno + (uint64) (CheckPointSegments - 1))
2297 return true;
2298 return false;
2299}
int CheckPointSegments
Definition: xlog.c:156

References CheckPointSegments, RedoRecPtr, wal_segment_size, and XLByteToSeg.

Referenced by XLogPageRead(), and XLogWrite().

◆ XLogFileInit()

int XLogFileInit ( XLogSegNo  logsegno,
TimeLineID  logtli 
)

Definition at line 3386 of file xlog.c.

3387{
3388 bool ignore_added;
3389 char path[MAXPGPATH];
3390 int fd;
3391
3392 Assert(logtli != 0);
3393
3394 fd = XLogFileInitInternal(logsegno, logtli, &ignore_added, path);
3395 if (fd >= 0)
3396 return fd;
3397
3398 /* Now open original target segment (might not be file I just made) */
3399 fd = BasicOpenFile(path, O_RDWR | PG_BINARY | O_CLOEXEC |
3401 if (fd < 0)
3402 ereport(ERROR,
3404 errmsg("could not open file \"%s\": %m", path)));
3405 return fd;
3406}
#define PG_BINARY
Definition: c.h:1244
int BasicOpenFile(const char *fileName, int fileFlags)
Definition: fd.c:1086
#define O_CLOEXEC
Definition: win32_port.h:349
static int get_sync_bit(int method)
Definition: xlog.c:8639
static int XLogFileInitInternal(XLogSegNo logsegno, TimeLineID logtli, bool *added, char *path)
Definition: xlog.c:3198

References Assert(), BasicOpenFile(), ereport, errcode_for_file_access(), errmsg(), ERROR, fd(), get_sync_bit(), MAXPGPATH, O_CLOEXEC, PG_BINARY, wal_sync_method, and XLogFileInitInternal().

Referenced by BootStrapXLOG(), XLogInitNewTimeline(), XLogWalRcvWrite(), and XLogWrite().

◆ XLogFileOpen()

int XLogFileOpen ( XLogSegNo  segno,
TimeLineID  tli 
)

Definition at line 3624 of file xlog.c.

3625{
3626 char path[MAXPGPATH];
3627 int fd;
3628
3629 XLogFilePath(path, tli, segno, wal_segment_size);
3630
3631 fd = BasicOpenFile(path, O_RDWR | PG_BINARY | O_CLOEXEC |
3633 if (fd < 0)
3634 ereport(PANIC,
3636 errmsg("could not open file \"%s\": %m", path)));
3637
3638 return fd;
3639}
static void XLogFilePath(char *path, TimeLineID tli, XLogSegNo logSegNo, int wal_segsz_bytes)

References BasicOpenFile(), ereport, errcode_for_file_access(), errmsg(), fd(), get_sync_bit(), MAXPGPATH, O_CLOEXEC, PANIC, PG_BINARY, wal_segment_size, wal_sync_method, and XLogFilePath().

Referenced by XLogWrite().

◆ XLogFlush()

void XLogFlush ( XLogRecPtr  record)

Definition at line 2790 of file xlog.c.

2791{
2792 XLogRecPtr WriteRqstPtr;
2793 XLogwrtRqst WriteRqst;
2794 TimeLineID insertTLI = XLogCtl->InsertTimeLineID;
2795
2796 /*
2797 * During REDO, we are reading not writing WAL. Therefore, instead of
2798 * trying to flush the WAL, we should update minRecoveryPoint instead. We
2799 * test XLogInsertAllowed(), not InRecovery, because we need checkpointer
2800 * to act this way too, and because when it tries to write the
2801 * end-of-recovery checkpoint, it should indeed flush.
2802 */
2803 if (!XLogInsertAllowed())
2804 {
2805 UpdateMinRecoveryPoint(record, false);
2806 return;
2807 }
2808
2809 /* Quick exit if already known flushed */
2810 if (record <= LogwrtResult.Flush)
2811 return;
2812
2813#ifdef WAL_DEBUG
2814 if (XLOG_DEBUG)
2815 elog(LOG, "xlog flush request %X/%X; write %X/%X; flush %X/%X",
2816 LSN_FORMAT_ARGS(record),
2819#endif
2820
2822
2823 /*
2824 * Since fsync is usually a horribly expensive operation, we try to
2825 * piggyback as much data as we can on each fsync: if we see any more data
2826 * entered into the xlog buffer, we'll write and fsync that too, so that
2827 * the final value of LogwrtResult.Flush is as large as possible. This
2828 * gives us some chance of avoiding another fsync immediately after.
2829 */
2830
2831 /* initialize to given target; may increase below */
2832 WriteRqstPtr = record;
2833
2834 /*
2835 * Now wait until we get the write lock, or someone else does the flush
2836 * for us.
2837 */
2838 for (;;)
2839 {
2840 XLogRecPtr insertpos;
2841
2842 /* done already? */
2844 if (record <= LogwrtResult.Flush)
2845 break;
2846
2847 /*
2848 * Before actually performing the write, wait for all in-flight
2849 * insertions to the pages we're about to write to finish.
2850 */
2852 if (WriteRqstPtr < XLogCtl->LogwrtRqst.Write)
2853 WriteRqstPtr = XLogCtl->LogwrtRqst.Write;
2855 insertpos = WaitXLogInsertionsToFinish(WriteRqstPtr);
2856
2857 /*
2858 * Try to get the write lock. If we can't get it immediately, wait
2859 * until it's released, and recheck if we still need to do the flush
2860 * or if the backend that held the lock did it for us already. This
2861 * helps to maintain a good rate of group committing when the system
2862 * is bottlenecked by the speed of fsyncing.
2863 */
2864 if (!LWLockAcquireOrWait(WALWriteLock, LW_EXCLUSIVE))
2865 {
2866 /*
2867 * The lock is now free, but we didn't acquire it yet. Before we
2868 * do, loop back to check if someone else flushed the record for
2869 * us already.
2870 */
2871 continue;
2872 }
2873
2874 /* Got the lock; recheck whether request is satisfied */
2876 if (record <= LogwrtResult.Flush)
2877 {
2878 LWLockRelease(WALWriteLock);
2879 break;
2880 }
2881
2882 /*
2883 * Sleep before flush! By adding a delay here, we may give further
2884 * backends the opportunity to join the backlog of group commit
2885 * followers; this can significantly improve transaction throughput,
2886 * at the risk of increasing transaction latency.
2887 *
2888 * We do not sleep if enableFsync is not turned on, nor if there are
2889 * fewer than CommitSiblings other backends with active transactions.
2890 */
2891 if (CommitDelay > 0 && enableFsync &&
2893 {
2895
2896 /*
2897 * Re-check how far we can now flush the WAL. It's generally not
2898 * safe to call WaitXLogInsertionsToFinish while holding
2899 * WALWriteLock, because an in-progress insertion might need to
2900 * also grab WALWriteLock to make progress. But we know that all
2901 * the insertions up to insertpos have already finished, because
2902 * that's what the earlier WaitXLogInsertionsToFinish() returned.
2903 * We're only calling it again to allow insertpos to be moved
2904 * further forward, not to actually wait for anyone.
2905 */
2906 insertpos = WaitXLogInsertionsToFinish(insertpos);
2907 }
2908
2909 /* try to write/flush later additions to XLOG as well */
2910 WriteRqst.Write = insertpos;
2911 WriteRqst.Flush = insertpos;
2912
2913 XLogWrite(WriteRqst, insertTLI, false);
2914
2915 LWLockRelease(WALWriteLock);
2916 /* done */
2917 break;
2918 }
2919
2921
2922 /* wake up walsenders now that we've released heavily contended locks */
2924
2925 /*
2926 * If we still haven't flushed to the request point then we have a
2927 * problem; most likely, the requested flush point is past end of XLOG.
2928 * This has been seen to occur when a disk page has a corrupted LSN.
2929 *
2930 * Formerly we treated this as a PANIC condition, but that hurts the
2931 * system's robustness rather than helping it: we do not want to take down
2932 * the whole system due to corruption on one data page. In particular, if
2933 * the bad page is encountered again during recovery then we would be
2934 * unable to restart the database at all! (This scenario actually
2935 * happened in the field several times with 7.1 releases.) As of 8.4, bad
2936 * LSNs encountered during recovery are UpdateMinRecoveryPoint's problem;
2937 * the only time we can reach here during recovery is while flushing the
2938 * end-of-recovery checkpoint record, and we don't expect that to have a
2939 * bad LSN.
2940 *
2941 * Note that for calls from xact.c, the ERROR will be promoted to PANIC
2942 * since xact.c calls this routine inside a critical section. However,
2943 * calls from bufmgr.c are not within critical sections and so we will not
2944 * force a restart for a bad LSN on a data page.
2945 */
2946 if (LogwrtResult.Flush < record)
2947 elog(ERROR,
2948 "xlog flush request %X/%X is not satisfied --- flushed only to %X/%X",
2949 LSN_FORMAT_ARGS(record),
2951}
bool LWLockAcquireOrWait(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1407
bool MinimumActiveBackends(int min)
Definition: procarray.c:3546
int CommitDelay
Definition: xlog.c:132
int CommitSiblings
Definition: xlog.c:133
bool XLogInsertAllowed(void)
Definition: xlog.c:6435

References CommitDelay, CommitSiblings, elog, enableFsync, END_CRIT_SECTION, ERROR, XLogwrtRqst::Flush, XLogwrtResult::Flush, XLogCtlData::info_lck, XLogCtlData::InsertTimeLineID, LOG, LogwrtResult, XLogCtlData::LogwrtRqst, LSN_FORMAT_ARGS, LW_EXCLUSIVE, LWLockAcquireOrWait(), LWLockRelease(), MinimumActiveBackends(), pg_usleep(), RecoveryInProgress(), RefreshXLogWriteResult, SpinLockAcquire, SpinLockRelease, START_CRIT_SECTION, UpdateMinRecoveryPoint(), WaitXLogInsertionsToFinish(), WalSndWakeupProcessRequests(), XLogwrtRqst::Write, XLogwrtResult::Write, XLogCtl, XLogInsertAllowed(), and XLogWrite().

Referenced by CheckPointReplicationOrigin(), CreateCheckPoint(), CreateEndOfRecoveryRecord(), CreateOverwriteContrecordRecord(), dropdb(), EndPrepare(), finish_sync_worker(), FlushBuffer(), LogLogicalMessage(), pg_truncate_visibility_map(), RecordTransactionAbortPrepared(), RecordTransactionCommit(), RecordTransactionCommitPrepared(), RelationTruncate(), ReplicationSlotReserveWal(), replorigin_get_progress(), replorigin_session_get_progress(), SlruPhysicalWritePage(), smgr_redo(), write_relmap_file(), WriteMTruncateXlogRec(), WriteTruncateXlogRec(), xact_redo_abort(), xact_redo_commit(), XLogInsertRecord(), and XLogReportParameters().

◆ XLogGetLastRemovedSegno()

XLogSegNo XLogGetLastRemovedSegno ( void  )

Definition at line 3764 of file xlog.c.

3765{
3766 XLogSegNo lastRemovedSegNo;
3767
3769 lastRemovedSegNo = XLogCtl->lastRemovedSegNo;
3771
3772 return lastRemovedSegNo;
3773}

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

Referenced by copy_replication_slot(), GetWALAvailability(), ReplicationSlotReserveWal(), and reserve_wal_for_local_slot().

◆ XLogGetOldestSegno()

XLogSegNo XLogGetOldestSegno ( TimeLineID  tli)

Definition at line 3780 of file xlog.c.

3781{
3782 DIR *xldir;
3783 struct dirent *xlde;
3784 XLogSegNo oldest_segno = 0;
3785
3786 xldir = AllocateDir(XLOGDIR);
3787 while ((xlde = ReadDir(xldir, XLOGDIR)) != NULL)
3788 {
3789 TimeLineID file_tli;
3790 XLogSegNo file_segno;
3791
3792 /* Ignore files that are not XLOG segments. */
3793 if (!IsXLogFileName(xlde->d_name))
3794 continue;
3795
3796 /* Parse filename to get TLI and segno. */
3797 XLogFromFileName(xlde->d_name, &file_tli, &file_segno,
3799
3800 /* Ignore anything that's not from the TLI of interest. */
3801 if (tli != file_tli)
3802 continue;
3803
3804 /* If it's the oldest so far, update oldest_segno. */
3805 if (oldest_segno == 0 || file_segno < oldest_segno)
3806 oldest_segno = file_segno;
3807 }
3808
3809 FreeDir(xldir);
3810 return oldest_segno;
3811}
static void XLogFromFileName(const char *fname, TimeLineID *tli, XLogSegNo *logSegNo, int wal_segsz_bytes)

References AllocateDir(), dirent::d_name, FreeDir(), IsXLogFileName(), ReadDir(), wal_segment_size, XLOGDIR, and XLogFromFileName().

Referenced by GetOldestUnsummarizedLSN(), MaybeRemoveOldWalSummaries(), and reserve_wal_for_local_slot().

◆ XLogInsertAllowed()

bool XLogInsertAllowed ( void  )

Definition at line 6435 of file xlog.c.

6436{
6437 /*
6438 * If value is "unconditionally true" or "unconditionally false", just
6439 * return it. This provides the normal fast path once recovery is known
6440 * done.
6441 */
6442 if (LocalXLogInsertAllowed >= 0)
6443 return (bool) LocalXLogInsertAllowed;
6444
6445 /*
6446 * Else, must check to see if we're still in recovery.
6447 */
6448 if (RecoveryInProgress())
6449 return false;
6450
6451 /*
6452 * On exit from recovery, reset to "unconditionally true", since there is
6453 * no need to keep checking.
6454 */
6456 return true;
6457}

References LocalXLogInsertAllowed, and RecoveryInProgress().

Referenced by XLogBeginInsert(), XLogFlush(), and XLogInsertRecord().

◆ XLogInsertRecord()

XLogRecPtr XLogInsertRecord ( struct XLogRecData rdata,
XLogRecPtr  fpw_lsn,
uint8  flags,
int  num_fpi,
bool  topxid_included 
)

Definition at line 748 of file xlog.c.

753{
755 pg_crc32c rdata_crc;
756 bool inserted;
757 XLogRecord *rechdr = (XLogRecord *) rdata->data;
758 uint8 info = rechdr->xl_info & ~XLR_INFO_MASK;
760 XLogRecPtr StartPos;
761 XLogRecPtr EndPos;
762 bool prevDoPageWrites = doPageWrites;
763 TimeLineID insertTLI;
764
765 /* Does this record type require special handling? */
766 if (unlikely(rechdr->xl_rmid == RM_XLOG_ID))
767 {
768 if (info == XLOG_SWITCH)
770 else if (info == XLOG_CHECKPOINT_REDO)
772 }
773
774 /* we assume that all of the record header is in the first chunk */
775 Assert(rdata->len >= SizeOfXLogRecord);
776
777 /* cross-check on whether we should be here or not */
778 if (!XLogInsertAllowed())
779 elog(ERROR, "cannot make new WAL entries during recovery");
780
781 /*
782 * Given that we're not in recovery, InsertTimeLineID is set and can't
783 * change, so we can read it without a lock.
784 */
785 insertTLI = XLogCtl->InsertTimeLineID;
786
787 /*----------
788 *
789 * We have now done all the preparatory work we can without holding a
790 * lock or modifying shared state. From here on, inserting the new WAL
791 * record to the shared WAL buffer cache is a two-step process:
792 *
793 * 1. Reserve the right amount of space from the WAL. The current head of
794 * reserved space is kept in Insert->CurrBytePos, and is protected by
795 * insertpos_lck.
796 *
797 * 2. Copy the record to the reserved WAL space. This involves finding the
798 * correct WAL buffer containing the reserved space, and copying the
799 * record in place. This can be done concurrently in multiple processes.
800 *
801 * To keep track of which insertions are still in-progress, each concurrent
802 * inserter acquires an insertion lock. In addition to just indicating that
803 * an insertion is in progress, the lock tells others how far the inserter
804 * has progressed. There is a small fixed number of insertion locks,
805 * determined by NUM_XLOGINSERT_LOCKS. When an inserter crosses a page
806 * boundary, it updates the value stored in the lock to the how far it has
807 * inserted, to allow the previous buffer to be flushed.
808 *
809 * Holding onto an insertion lock also protects RedoRecPtr and
810 * fullPageWrites from changing until the insertion is finished.
811 *
812 * Step 2 can usually be done completely in parallel. If the required WAL
813 * page is not initialized yet, you have to grab WALBufMappingLock to
814 * initialize it, but the WAL writer tries to do that ahead of insertions
815 * to avoid that from happening in the critical path.
816 *
817 *----------
818 */
820
821 if (likely(class == WALINSERT_NORMAL))
822 {
824
825 /*
826 * Check to see if my copy of RedoRecPtr is out of date. If so, may
827 * have to go back and have the caller recompute everything. This can
828 * only happen just after a checkpoint, so it's better to be slow in
829 * this case and fast otherwise.
830 *
831 * Also check to see if fullPageWrites was just turned on or there's a
832 * running backup (which forces full-page writes); if we weren't
833 * already doing full-page writes then go back and recompute.
834 *
835 * If we aren't doing full-page writes then RedoRecPtr doesn't
836 * actually affect the contents of the XLOG record, so we'll update
837 * our local copy but not force a recomputation. (If doPageWrites was
838 * just turned off, we could recompute the record without full pages,
839 * but we choose not to bother.)
840 */
841 if (RedoRecPtr != Insert->RedoRecPtr)
842 {
843 Assert(RedoRecPtr < Insert->RedoRecPtr);
844 RedoRecPtr = Insert->RedoRecPtr;
845 }
846 doPageWrites = (Insert->fullPageWrites || Insert->runningBackups > 0);
847
848 if (doPageWrites &&
849 (!prevDoPageWrites ||
850 (fpw_lsn != InvalidXLogRecPtr && fpw_lsn <= RedoRecPtr)))
851 {
852 /*
853 * Oops, some buffer now needs to be backed up that the caller
854 * didn't back up. Start over.
855 */
858 return InvalidXLogRecPtr;
859 }
860
861 /*
862 * Reserve space for the record in the WAL. This also sets the xl_prev
863 * pointer.
864 */
865 ReserveXLogInsertLocation(rechdr->xl_tot_len, &StartPos, &EndPos,
866 &rechdr->xl_prev);
867
868 /* Normal records are always inserted. */
869 inserted = true;
870 }
871 else if (class == WALINSERT_SPECIAL_SWITCH)
872 {
873 /*
874 * In order to insert an XLOG_SWITCH record, we need to hold all of
875 * the WAL insertion locks, not just one, so that no one else can
876 * begin inserting a record until we've figured out how much space
877 * remains in the current WAL segment and claimed all of it.
878 *
879 * Nonetheless, this case is simpler than the normal cases handled
880 * below, which must check for changes in doPageWrites and RedoRecPtr.
881 * Those checks are only needed for records that can contain buffer
882 * references, and an XLOG_SWITCH record never does.
883 */
884 Assert(fpw_lsn == InvalidXLogRecPtr);
886 inserted = ReserveXLogSwitch(&StartPos, &EndPos, &rechdr->xl_prev);
887 }
888 else
889 {
891
892 /*
893 * We need to update both the local and shared copies of RedoRecPtr,
894 * which means that we need to hold all the WAL insertion locks.
895 * However, there can't be any buffer references, so as above, we need
896 * not check RedoRecPtr before inserting the record; we just need to
897 * update it afterwards.
898 */
899 Assert(fpw_lsn == InvalidXLogRecPtr);
901 ReserveXLogInsertLocation(rechdr->xl_tot_len, &StartPos, &EndPos,
902 &rechdr->xl_prev);
903 RedoRecPtr = Insert->RedoRecPtr = StartPos;
904 inserted = true;
905 }
906
907 if (inserted)
908 {
909 /*
910 * Now that xl_prev has been filled in, calculate CRC of the record
911 * header.
912 */
913 rdata_crc = rechdr->xl_crc;
914 COMP_CRC32C(rdata_crc, rechdr, offsetof(XLogRecord, xl_crc));
915 FIN_CRC32C(rdata_crc);
916 rechdr->xl_crc = rdata_crc;
917
918 /*
919 * All the record data, including the header, is now ready to be
920 * inserted. Copy the record in the space reserved.
921 */
923 class == WALINSERT_SPECIAL_SWITCH, rdata,
924 StartPos, EndPos, insertTLI);
925
926 /*
927 * Unless record is flagged as not important, update LSN of last
928 * important record in the current slot. When holding all locks, just
929 * update the first one.
930 */
931 if ((flags & XLOG_MARK_UNIMPORTANT) == 0)
932 {
933 int lockno = holdingAllLocks ? 0 : MyLockNo;
934
935 WALInsertLocks[lockno].l.lastImportantAt = StartPos;
936 }
937 }
938 else
939 {
940 /*
941 * This was an xlog-switch record, but the current insert location was
942 * already exactly at the beginning of a segment, so there was no need
943 * to do anything.
944 */
945 }
946
947 /*
948 * Done! Let others know that we're finished.
949 */
951
953
955
956 /*
957 * Mark top transaction id is logged (if needed) so that we should not try
958 * to log it again with the next WAL record in the current subtransaction.
959 */
960 if (topxid_included)
962
963 /*
964 * Update shared LogwrtRqst.Write, if we crossed page boundary.
965 */
966 if (StartPos / XLOG_BLCKSZ != EndPos / XLOG_BLCKSZ)
967 {
969 /* advance global request to include new block(s) */
970 if (XLogCtl->LogwrtRqst.Write < EndPos)
971 XLogCtl->LogwrtRqst.Write = EndPos;
974 }
975
976 /*
977 * If this was an XLOG_SWITCH record, flush the record and the empty
978 * padding space that fills the rest of the segment, and perform
979 * end-of-segment actions (eg, notifying archiver).
980 */
981 if (class == WALINSERT_SPECIAL_SWITCH)
982 {
983 TRACE_POSTGRESQL_WAL_SWITCH();
984 XLogFlush(EndPos);
985
986 /*
987 * Even though we reserved the rest of the segment for us, which is
988 * reflected in EndPos, we return a pointer to just the end of the
989 * xlog-switch record.
990 */
991 if (inserted)
992 {
993 EndPos = StartPos + SizeOfXLogRecord;
994 if (StartPos / XLOG_BLCKSZ != EndPos / XLOG_BLCKSZ)
995 {
996 uint64 offset = XLogSegmentOffset(EndPos, wal_segment_size);
997
998 if (offset == EndPos % XLOG_BLCKSZ)
999 EndPos += SizeOfXLogLongPHD;
1000 else
1001 EndPos += SizeOfXLogShortPHD;
1002 }
1003 }
1004 }
1005
1006#ifdef WAL_DEBUG
1007 if (XLOG_DEBUG)
1008 {
1009 static XLogReaderState *debug_reader = NULL;
1010 XLogRecord *record;
1011 DecodedXLogRecord *decoded;
1013 StringInfoData recordBuf;
1014 char *errormsg = NULL;
1015 MemoryContext oldCxt;
1016
1017 oldCxt = MemoryContextSwitchTo(walDebugCxt);
1018
1020 appendStringInfo(&buf, "INSERT @ %X/%X: ", LSN_FORMAT_ARGS(EndPos));
1021
1022 /*
1023 * We have to piece together the WAL record data from the XLogRecData
1024 * entries, so that we can pass it to the rm_desc function as one
1025 * contiguous chunk.
1026 */
1027 initStringInfo(&recordBuf);
1028 for (; rdata != NULL; rdata = rdata->next)
1029 appendBinaryStringInfo(&recordBuf, rdata->data, rdata->len);
1030
1031 /* We also need temporary space to decode the record. */
1032 record = (XLogRecord *) recordBuf.data;
1033 decoded = (DecodedXLogRecord *)
1035
1036 if (!debug_reader)
1037 debug_reader = XLogReaderAllocate(wal_segment_size, NULL,
1038 XL_ROUTINE(.page_read = NULL,
1039 .segment_open = NULL,
1040 .segment_close = NULL),
1041 NULL);
1042 if (!debug_reader)
1043 {
1044 appendStringInfoString(&buf, "error decoding record: out of memory while allocating a WAL reading processor");
1045 }
1046 else if (!DecodeXLogRecord(debug_reader,
1047 decoded,
1048 record,
1049 EndPos,
1050 &errormsg))
1051 {
1052 appendStringInfo(&buf, "error decoding record: %s",
1053 errormsg ? errormsg : "no error message");
1054 }
1055 else
1056 {
1057 appendStringInfoString(&buf, " - ");
1058
1059 debug_reader->record = decoded;
1060 xlog_outdesc(&buf, debug_reader);
1061 debug_reader->record = NULL;
1062 }
1063 elog(LOG, "%s", buf.data);
1064
1065 pfree(decoded);
1066 pfree(buf.data);
1067 pfree(recordBuf.data);
1068 MemoryContextSwitchTo(oldCxt);
1069 }
1070#endif
1071
1072 /*
1073 * Update our global variables
1074 */
1075 ProcLastRecPtr = StartPos;
1076 XactLastRecEnd = EndPos;
1077
1078 /* Report WAL traffic to the instrumentation. */
1079 if (inserted)
1080 {
1081 pgWalUsage.wal_bytes += rechdr->xl_tot_len;
1083 pgWalUsage.wal_fpi += num_fpi;
1084 }
1085
1086 return EndPos;
1087}
#define likely(x)
Definition: c.h:346
#define unlikely(x)
Definition: c.h:347
WalUsage pgWalUsage
Definition: instrument.c:22
if(TABLE==NULL||TABLE_index==NULL)
Definition: isn.c:78
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:124
void appendBinaryStringInfo(StringInfo str, const void *data, int datalen)
Definition: stringinfo.c:281
uint64 wal_bytes
Definition: instrument.h:55
int64 wal_fpi
Definition: instrument.h:54
int64 wal_records
Definition: instrument.h:53
DecodedXLogRecord * record
Definition: xlogreader.h:236
const void * data
struct XLogRecData * next
pg_crc32c xl_crc
Definition: xlogrecord.h:49
void MarkSubxactTopXidLogged(void)
Definition: xact.c:591
void MarkCurrentTransactionIdLoggedIfAny(void)
Definition: xact.c:541
XLogRecPtr XactLastRecEnd
Definition: xlog.c:254
static void WALInsertLockAcquire(void)
Definition: xlog.c:1371
static void CopyXLogRecordToWAL(int write_len, bool isLogSwitch, XLogRecData *rdata, XLogRecPtr StartPos, XLogRecPtr EndPos, TimeLineID tli)
Definition: xlog.c:1225
static bool holdingAllLocks
Definition: xlog.c:652
static int MyLockNo
Definition: xlog.c:651
WalInsertClass
Definition: xlog.c:560
@ WALINSERT_SPECIAL_SWITCH
Definition: xlog.c:562
@ WALINSERT_NORMAL
Definition: xlog.c:561
@ WALINSERT_SPECIAL_CHECKPOINT
Definition: xlog.c:563
static void ReserveXLogInsertLocation(int size, XLogRecPtr *StartPos, XLogRecPtr *EndPos, XLogRecPtr *PrevPtr)
Definition: xlog.c:1108
static bool ReserveXLogSwitch(XLogRecPtr *StartPos, XLogRecPtr *EndPos, XLogRecPtr *PrevPtr)
Definition: xlog.c:1164
#define XLOG_MARK_UNIMPORTANT
Definition: xlog.h:155
XLogReaderState * XLogReaderAllocate(int wal_segment_size, const char *waldir, XLogReaderRoutine *routine, void *private_data)
Definition: xlogreader.c:107
bool DecodeXLogRecord(XLogReaderState *state, DecodedXLogRecord *decoded, XLogRecord *record, XLogRecPtr lsn, char **errormsg)
Definition: xlogreader.c:1672
size_t DecodeXLogRecordRequiredSpace(size_t xl_tot_len)
Definition: xlogreader.c:1639
#define XL_ROUTINE(...)
Definition: xlogreader.h:117
void xlog_outdesc(StringInfo buf, XLogReaderState *record)

References appendBinaryStringInfo(), appendStringInfo(), appendStringInfoString(), Assert(), buf, COMP_CRC32C, CopyXLogRecordToWAL(), XLogRecData::data, StringInfoData::data, DecodeXLogRecord(), DecodeXLogRecordRequiredSpace(), doPageWrites, elog, END_CRIT_SECTION, ERROR, FIN_CRC32C, holdingAllLocks, if(), XLogCtlData::info_lck, initStringInfo(), XLogCtlData::Insert, Insert(), XLogCtlData::InsertTimeLineID, InvalidXLogRecPtr, WALInsertLockPadded::l, WALInsertLock::lastImportantAt, XLogRecData::len, likely, LOG, LogwrtResult, XLogCtlData::LogwrtRqst, LSN_FORMAT_ARGS, MarkCurrentTransactionIdLoggedIfAny(), MarkSubxactTopXidLogged(), MemoryContextSwitchTo(), MyLockNo, XLogRecData::next, palloc(), pfree(), pgWalUsage, ProcLastRecPtr, XLogReaderState::record, RedoRecPtr, RefreshXLogWriteResult, ReserveXLogInsertLocation(), ReserveXLogSwitch(), SizeOfXLogLongPHD, SizeOfXLogRecord, SizeOfXLogShortPHD, SpinLockAcquire, SpinLockRelease, START_CRIT_SECTION, unlikely, WalUsage::wal_bytes, WalUsage::wal_fpi, WalUsage::wal_records, wal_segment_size, WALINSERT_NORMAL, WALINSERT_SPECIAL_CHECKPOINT, WALINSERT_SPECIAL_SWITCH, WALInsertLockAcquire(), WALInsertLockAcquireExclusive(), WALInsertLockRelease(), WALInsertLocks, XLogwrtRqst::Write, XactLastRecEnd, XLogRecord::xl_crc, XLogRecord::xl_info, XLogRecord::xl_prev, XLogRecord::xl_rmid, XL_ROUTINE, XLogRecord::xl_tot_len, XLOG_CHECKPOINT_REDO, XLOG_MARK_UNIMPORTANT, xlog_outdesc(), XLOG_SWITCH, XLogCtl, XLogFlush(), XLogInsertAllowed(), XLogReaderAllocate(), XLogSegmentOffset, and XLR_INFO_MASK.

Referenced by XLogInsert().

◆ XLogNeedsFlush()

bool XLogNeedsFlush ( XLogRecPtr  record)

Definition at line 3121 of file xlog.c.

3122{
3123 /*
3124 * During recovery, we don't flush WAL but update minRecoveryPoint
3125 * instead. So "needs flush" is taken to mean whether minRecoveryPoint
3126 * would need to be updated.
3127 */
3128 if (RecoveryInProgress())
3129 {
3130 /*
3131 * An invalid minRecoveryPoint means that we need to recover all the
3132 * WAL, i.e., we're doing crash recovery. We never modify the control
3133 * file's value in that case, so we can short-circuit future checks
3134 * here too. This triggers a quick exit path for the startup process,
3135 * which cannot update its local copy of minRecoveryPoint as long as
3136 * it has not replayed all WAL available when doing crash recovery.
3137 */
3139 updateMinRecoveryPoint = false;
3140
3141 /* Quick exit if already known to be updated or cannot be updated */
3143 return false;
3144
3145 /*
3146 * Update local copy of minRecoveryPoint. But if the lock is busy,
3147 * just return a conservative guess.
3148 */
3149 if (!LWLockConditionalAcquire(ControlFileLock, LW_SHARED))
3150 return true;
3153 LWLockRelease(ControlFileLock);
3154
3155 /*
3156 * Check minRecoveryPoint for any other process than the startup
3157 * process doing crash recovery, which should not update the control
3158 * file value if crash recovery is still running.
3159 */
3161 updateMinRecoveryPoint = false;
3162
3163 /* check again */
3165 return false;
3166 else
3167 return true;
3168 }
3169
3170 /* Quick exit if already known flushed */
3171 if (record <= LogwrtResult.Flush)
3172 return false;
3173
3174 /* read LogwrtResult and update local state */
3176
3177 /* check again */
3178 if (record <= LogwrtResult.Flush)
3179 return false;
3180
3181 return true;
3182}
bool LWLockConditionalAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1350

References ControlFile, XLogwrtResult::Flush, InRecovery, LocalMinRecoveryPoint, LocalMinRecoveryPointTLI, LogwrtResult, LW_SHARED, LWLockConditionalAcquire(), LWLockRelease(), ControlFileData::minRecoveryPoint, ControlFileData::minRecoveryPointTLI, RecoveryInProgress(), RefreshXLogWriteResult, updateMinRecoveryPoint, and XLogRecPtrIsInvalid.

Referenced by GetVictimBuffer(), and SetHintBits().

◆ XLogPutNextOid()

void XLogPutNextOid ( Oid  nextOid)

Definition at line 8069 of file xlog.c.

8070{
8072 XLogRegisterData(&nextOid, sizeof(Oid));
8073 (void) XLogInsert(RM_XLOG_ID, XLOG_NEXTOID);
8074
8075 /*
8076 * We need not flush the NEXTOID record immediately, because any of the
8077 * just-allocated OIDs could only reach disk as part of a tuple insert or
8078 * update that would have its own XLOG record that must follow the NEXTOID
8079 * record. Therefore, the standard buffer LSN interlock applied to those
8080 * records will ensure no such OID reaches disk before the NEXTOID record
8081 * does.
8082 *
8083 * Note, however, that the above statement only covers state "within" the
8084 * database. When we use a generated OID as a file or directory name, we
8085 * are in a sense violating the basic WAL rule, because that filesystem
8086 * change may reach disk before the NEXTOID WAL record does. The impact
8087 * of this is that if a database crash occurs immediately afterward, we
8088 * might after restart re-generate the same OID and find that it conflicts
8089 * with the leftover file or directory. But since for safety's sake we
8090 * always loop until finding a nonconflicting filename, this poses no real
8091 * problem in practice. See pgsql-hackers discussion 27-Sep-2006.
8092 */
8093}

References XLOG_NEXTOID, XLogBeginInsert(), XLogInsert(), and XLogRegisterData().

Referenced by GetNewObjectId().

◆ XLogRestorePoint()

XLogRecPtr XLogRestorePoint ( const char *  rpName)

Definition at line 8124 of file xlog.c.

8125{
8126 XLogRecPtr RecPtr;
8127 xl_restore_point xlrec;
8128
8129 xlrec.rp_time = GetCurrentTimestamp();
8130 strlcpy(xlrec.rp_name, rpName, MAXFNAMELEN);
8131
8133 XLogRegisterData(&xlrec, sizeof(xl_restore_point));
8134
8135 RecPtr = XLogInsert(RM_XLOG_ID, XLOG_RESTORE_POINT);
8136
8137 ereport(LOG,
8138 (errmsg("restore point \"%s\" created at %X/%X",
8139 rpName, LSN_FORMAT_ARGS(RecPtr))));
8140
8141 return RecPtr;
8142}
TimestampTz rp_time

References ereport, errmsg(), GetCurrentTimestamp(), LOG, LSN_FORMAT_ARGS, MAXFNAMELEN, xl_restore_point::rp_name, xl_restore_point::rp_time, strlcpy(), XLOG_RESTORE_POINT, XLogBeginInsert(), XLogInsert(), and XLogRegisterData().

Referenced by pg_create_restore_point().

◆ XLogSetAsyncXactLSN()

void XLogSetAsyncXactLSN ( XLogRecPtr  asyncXactLSN)

Definition at line 2619 of file xlog.c.

2620{
2621 XLogRecPtr WriteRqstPtr = asyncXactLSN;
2622 bool sleeping;
2623 bool wakeup = false;
2624 XLogRecPtr prevAsyncXactLSN;
2625
2627 sleeping = XLogCtl->WalWriterSleeping;
2628 prevAsyncXactLSN = XLogCtl->asyncXactLSN;
2629 if (XLogCtl->asyncXactLSN < asyncXactLSN)
2630 XLogCtl->asyncXactLSN = asyncXactLSN;
2632
2633 /*
2634 * If somebody else already called this function with a more aggressive
2635 * LSN, they will have done what we needed (and perhaps more).
2636 */
2637 if (asyncXactLSN <= prevAsyncXactLSN)
2638 return;
2639
2640 /*
2641 * If the WALWriter is sleeping, kick it to make it come out of low-power
2642 * mode, so that this async commit will reach disk within the expected
2643 * amount of time. Otherwise, determine whether it has enough WAL
2644 * available to flush, the same way that XLogBackgroundFlush() does.
2645 */
2646 if (sleeping)
2647 wakeup = true;
2648 else
2649 {
2650 int flushblocks;
2651
2653
2654 flushblocks =
2655 WriteRqstPtr / XLOG_BLCKSZ - LogwrtResult.Flush / XLOG_BLCKSZ;
2656
2657 if (WalWriterFlushAfter == 0 || flushblocks >= WalWriterFlushAfter)
2658 wakeup = true;
2659 }
2660
2661 if (wakeup)
2662 {
2663 volatile PROC_HDR *procglobal = ProcGlobal;
2664 ProcNumber walwriterProc = procglobal->walwriterProc;
2665
2666 if (walwriterProc != INVALID_PROC_NUMBER)
2667 SetLatch(&GetPGProcByNumber(walwriterProc)->procLatch);
2668 }
2669}
void SetLatch(Latch *latch)
Definition: latch.c:288
#define GetPGProcByNumber(n)
Definition: proc.h:424
#define INVALID_PROC_NUMBER
Definition: procnumber.h:26
int ProcNumber
Definition: procnumber.h:24
PROC_HDR * ProcGlobal
Definition: proc.c:78
Definition: proc.h:370
ProcNumber walwriterProc
Definition: proc.h:408
static TimestampTz wakeup[NUM_WALRCV_WAKEUPS]
Definition: walreceiver.c:129

References XLogCtlData::asyncXactLSN, XLogwrtResult::Flush, GetPGProcByNumber, XLogCtlData::info_lck, INVALID_PROC_NUMBER, LogwrtResult, ProcGlobal, RefreshXLogWriteResult, SetLatch(), SpinLockAcquire, SpinLockRelease, wakeup, WalWriterFlushAfter, PROC_HDR::walwriterProc, XLogCtlData::WalWriterSleeping, and XLogCtl.

Referenced by AbortTransaction(), LogCurrentRunningXacts(), RecordTransactionAbort(), and RecordTransactionCommit().

◆ XLogSetReplicationSlotMinimumLSN()

void XLogSetReplicationSlotMinimumLSN ( XLogRecPtr  lsn)

◆ XLOGShmemInit()

void XLOGShmemInit ( void  )

Definition at line 4964 of file xlog.c.

4965{
4966 bool foundCFile,
4967 foundXLog;
4968 char *allocptr;
4969 int i;
4970 ControlFileData *localControlFile;
4971
4972#ifdef WAL_DEBUG
4973
4974 /*
4975 * Create a memory context for WAL debugging that's exempt from the normal
4976 * "no pallocs in critical section" rule. Yes, that can lead to a PANIC if
4977 * an allocation fails, but wal_debug is not for production use anyway.
4978 */
4979 if (walDebugCxt == NULL)
4980 {
4982 "WAL Debug",
4984 MemoryContextAllowInCriticalSection(walDebugCxt, true);
4985 }
4986#endif
4987
4988
4989 XLogCtl = (XLogCtlData *)
4990 ShmemInitStruct("XLOG Ctl", XLOGShmemSize(), &foundXLog);
4991
4992 localControlFile = ControlFile;
4994 ShmemInitStruct("Control File", sizeof(ControlFileData), &foundCFile);
4995
4996 if (foundCFile || foundXLog)
4997 {
4998 /* both should be present or neither */
4999 Assert(foundCFile && foundXLog);
5000
5001 /* Initialize local copy of WALInsertLocks */
5003
5004 if (localControlFile)
5005 pfree(localControlFile);
5006 return;
5007 }
5008 memset(XLogCtl, 0, sizeof(XLogCtlData));
5009
5010 /*
5011 * Already have read control file locally, unless in bootstrap mode. Move
5012 * contents into shared memory.
5013 */
5014 if (localControlFile)
5015 {
5016 memcpy(ControlFile, localControlFile, sizeof(ControlFileData));
5017 pfree(localControlFile);
5018 }
5019
5020 /*
5021 * Since XLogCtlData contains XLogRecPtr fields, its sizeof should be a
5022 * multiple of the alignment for same, so no extra alignment padding is
5023 * needed here.
5024 */
5025 allocptr = ((char *) XLogCtl) + sizeof(XLogCtlData);
5026 XLogCtl->xlblocks = (pg_atomic_uint64 *) allocptr;
5027 allocptr += sizeof(pg_atomic_uint64) * XLOGbuffers;
5028
5029 for (i = 0; i < XLOGbuffers; i++)
5030 {
5032 }
5033
5034 /* WAL insertion locks. Ensure they're aligned to the full padded size */
5035 allocptr += sizeof(WALInsertLockPadded) -
5036 ((uintptr_t) allocptr) % sizeof(WALInsertLockPadded);
5038 (WALInsertLockPadded *) allocptr;
5039 allocptr += sizeof(WALInsertLockPadded) * NUM_XLOGINSERT_LOCKS;
5040
5041 for (i = 0; i < NUM_XLOGINSERT_LOCKS; i++)
5042 {
5046 }
5047
5048 /*
5049 * Align the start of the page buffers to a full xlog block size boundary.
5050 * This simplifies some calculations in XLOG insertion. It is also
5051 * required for O_DIRECT.
5052 */
5053 allocptr = (char *) TYPEALIGN(XLOG_BLCKSZ, allocptr);
5054 XLogCtl->pages = allocptr;
5055 memset(XLogCtl->pages, 0, (Size) XLOG_BLCKSZ * XLOGbuffers);
5056
5057 /*
5058 * Do basic initialization of XLogCtl shared data. (StartupXLOG will fill
5059 * in additional info.)
5060 */
5064 XLogCtl->WalWriterSleeping = false;
5065
5072}
static void pg_atomic_init_u64(volatile pg_atomic_uint64 *ptr, uint64 val)
Definition: atomics.h:453
struct pg_atomic_uint64 pg_atomic_uint64
void LWLockInitialize(LWLock *lock, int tranche_id)
Definition: lwlock.c:718
@ LWTRANCHE_WAL_INSERT
Definition: lwlock.h:188
MemoryContext TopMemoryContext
Definition: mcxt.c:149
void MemoryContextAllowInCriticalSection(MemoryContext context, bool allow)
Definition: mcxt.c:694
#define AllocSetContextCreate
Definition: memutils.h:129
#define ALLOCSET_DEFAULT_SIZES
Definition: memutils.h:160
void * ShmemInitStruct(const char *name, Size size, bool *foundPtr)
Definition: shmem.c:382
#define SpinLockInit(lock)
Definition: spin.h:57
int XLogCacheBlck
Definition: xlog.c:494
WALInsertLockPadded * WALInsertLocks
Definition: xlog.c:444
slock_t insertpos_lck
Definition: xlog.c:398
union WALInsertLockPadded WALInsertLockPadded
Size XLOGShmemSize(void)
Definition: xlog.c:4914
int XLOGbuffers
Definition: xlog.c:117
struct XLogCtlData XLogCtlData

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, Assert(), ControlFile, i, XLogCtlData::info_lck, XLogCtlData::Insert, XLogCtlInsert::insertpos_lck, XLogCtlData::InstallXLogFileSegmentActive, InvalidXLogRecPtr, WALInsertLockPadded::l, WALInsertLock::lastImportantAt, XLogCtlData::logFlushResult, XLogCtlData::logInsertResult, XLogCtlData::logWriteResult, LWLockInitialize(), LWTRANCHE_WAL_INSERT, MemoryContextAllowInCriticalSection(), NUM_XLOGINSERT_LOCKS, XLogCtlData::pages, pfree(), pg_atomic_init_u64(), RECOVERY_STATE_CRASH, XLogCtlData::SharedRecoveryState, ShmemInitStruct(), SpinLockInit, TopMemoryContext, TYPEALIGN, XLogCtlData::unloggedLSN, XLogCtlInsert::WALInsertLocks, WALInsertLocks, XLogCtlData::WalWriterSleeping, XLogCtlData::xlblocks, XLOGbuffers, XLogCtlData::XLogCacheBlck, XLogCtl, and XLOGShmemSize().

Referenced by CreateOrAttachShmemStructs().

◆ XLOGShmemSize()

Size XLOGShmemSize ( void  )

Definition at line 4914 of file xlog.c.

4915{
4916 Size size;
4917
4918 /*
4919 * If the value of wal_buffers is -1, use the preferred auto-tune value.
4920 * This isn't an amazingly clean place to do this, but we must wait till
4921 * NBuffers has received its final value, and must do it before using the
4922 * value of XLOGbuffers to do anything important.
4923 *
4924 * We prefer to report this value's source as PGC_S_DYNAMIC_DEFAULT.
4925 * However, if the DBA explicitly set wal_buffers = -1 in the config file,
4926 * then PGC_S_DYNAMIC_DEFAULT will fail to override that and we must force
4927 * the matter with PGC_S_OVERRIDE.
4928 */
4929 if (XLOGbuffers == -1)
4930 {
4931 char buf[32];
4932
4933 snprintf(buf, sizeof(buf), "%d", XLOGChooseNumBuffers());
4934 SetConfigOption("wal_buffers", buf, PGC_POSTMASTER,
4936 if (XLOGbuffers == -1) /* failed to apply it? */
4937 SetConfigOption("wal_buffers", buf, PGC_POSTMASTER,
4939 }
4940 Assert(XLOGbuffers > 0);
4941
4942 /* XLogCtl */
4943 size = sizeof(XLogCtlData);
4944
4945 /* WAL insertion locks, plus alignment */
4946 size = add_size(size, mul_size(sizeof(WALInsertLockPadded), NUM_XLOGINSERT_LOCKS + 1));
4947 /* xlblocks array */
4948 size = add_size(size, mul_size(sizeof(pg_atomic_uint64), XLOGbuffers));
4949 /* extra alignment padding for XLOG I/O buffers */
4950 size = add_size(size, Max(XLOG_BLCKSZ, PG_IO_ALIGN_SIZE));
4951 /* and the buffers themselves */
4952 size = add_size(size, mul_size(XLOG_BLCKSZ, XLOGbuffers));
4953
4954 /*
4955 * Note: we don't count ControlFileData, it comes out of the "slop factor"
4956 * added by CreateSharedMemoryAndSemaphores. This lets us use this
4957 * routine again below to compute the actual allocation size.
4958 */
4959
4960 return size;
4961}
#define Max(x, y)
Definition: c.h:969
void SetConfigOption(const char *name, const char *value, GucContext context, GucSource source)
Definition: guc.c:4332
@ PGC_S_DYNAMIC_DEFAULT
Definition: guc.h:114
@ PGC_S_OVERRIDE
Definition: guc.h:123
@ PGC_POSTMASTER
Definition: guc.h:74
#define PG_IO_ALIGN_SIZE
Size add_size(Size s1, Size s2)
Definition: shmem.c:488
Size mul_size(Size s1, Size s2)
Definition: shmem.c:505
static int XLOGChooseNumBuffers(void)
Definition: xlog.c:4667

References add_size(), Assert(), buf, Max, mul_size(), NUM_XLOGINSERT_LOCKS, PG_IO_ALIGN_SIZE, PGC_POSTMASTER, PGC_S_DYNAMIC_DEFAULT, PGC_S_OVERRIDE, SetConfigOption(), snprintf, XLOGbuffers, and XLOGChooseNumBuffers().

Referenced by CalculateShmemSize(), and XLOGShmemInit().

◆ XLogShutdownWalRcv()

void XLogShutdownWalRcv ( void  )

Definition at line 9508 of file xlog.c.

9509{
9511
9512 LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
9514 LWLockRelease(ControlFileLock);
9515}
void ShutdownWalRcv(void)

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

Referenced by FinishWalRecovery(), and WaitForWALToBecomeAvailable().

Variable Documentation

◆ CheckPointSegments

PGDLLIMPORT int CheckPointSegments
extern

◆ CheckpointStats

◆ CommitDelay

PGDLLIMPORT int CommitDelay
extern

Definition at line 132 of file xlog.c.

Referenced by XLogFlush().

◆ CommitSiblings

PGDLLIMPORT int CommitSiblings
extern

Definition at line 133 of file xlog.c.

Referenced by XLogFlush().

◆ EnableHotStandby

◆ fullPageWrites

PGDLLIMPORT bool fullPageWrites
extern

Definition at line 122 of file xlog.c.

Referenced by BootStrapXLOG(), and UpdateFullPageWrites().

◆ log_checkpoints

PGDLLIMPORT bool log_checkpoints
extern

◆ max_slot_wal_keep_size_mb

PGDLLIMPORT int max_slot_wal_keep_size_mb
extern

Definition at line 135 of file xlog.c.

Referenced by KeepLogSeg(), and pg_get_replication_slots().

◆ max_wal_size_mb

PGDLLIMPORT int max_wal_size_mb
extern

◆ min_wal_size_mb

PGDLLIMPORT int min_wal_size_mb
extern

Definition at line 115 of file xlog.c.

Referenced by ReadControlFile(), and XLOGfileslop().

◆ ProcLastRecPtr

PGDLLIMPORT XLogRecPtr ProcLastRecPtr
extern

◆ track_wal_io_timing

PGDLLIMPORT bool track_wal_io_timing
extern

◆ wal_compression

PGDLLIMPORT int wal_compression
extern

Definition at line 124 of file xlog.c.

Referenced by XLogCompressBackupBlock(), and XLogRecordAssemble().

◆ wal_consistency_checking

PGDLLIMPORT bool* wal_consistency_checking
extern

Definition at line 126 of file xlog.c.

Referenced by assign_wal_consistency_checking(), and XLogRecordAssemble().

◆ wal_consistency_checking_string

PGDLLIMPORT char* wal_consistency_checking_string
extern

Definition at line 125 of file xlog.c.

Referenced by InitializeWalConsistencyChecking().

◆ wal_decode_buffer_size

PGDLLIMPORT int wal_decode_buffer_size
extern

Definition at line 136 of file xlog.c.

Referenced by InitWalRecovery().

◆ wal_init_zero

PGDLLIMPORT bool wal_init_zero
extern

Definition at line 127 of file xlog.c.

Referenced by XLogFileInitInternal().

◆ wal_keep_size_mb

PGDLLIMPORT int wal_keep_size_mb
extern

Definition at line 116 of file xlog.c.

Referenced by KeepLogSeg(), and pg_get_replication_slots().

◆ wal_level

◆ wal_log_hints

PGDLLIMPORT bool wal_log_hints
extern

Definition at line 123 of file xlog.c.

Referenced by InitControlFile(), and XLogReportParameters().

◆ wal_recycle

PGDLLIMPORT bool wal_recycle
extern

Definition at line 128 of file xlog.c.

Referenced by RemoveXlogFile().

◆ wal_retrieve_retry_interval

PGDLLIMPORT int wal_retrieve_retry_interval
extern

◆ wal_segment_size

PGDLLIMPORT int wal_segment_size
extern

Definition at line 143 of file xlog.c.

Referenced by AdvanceXLInsertBuffer(), assign_wal_sync_method(), BootStrapXLOG(), build_backup_content(), CalculateCheckpointSegments(), CheckArchiveTimeout(), CheckXLogRemoved(), CleanupAfterArchiveRecovery(), copy_replication_slot(), CopyXLogRecordToWAL(), CreateCheckPoint(), CreateOverwriteContrecordRecord(), CreateRestartPoint(), do_pg_backup_stop(), ExecuteRecoveryCommand(), FinishWalRecovery(), GetOldestUnsummarizedLSN(), GetWALAvailability(), GetXLogBuffer(), InitWalRecovery(), InitXLogReaderState(), InstallXLogFileSegment(), InvalidateObsoleteReplicationSlots(), IsCheckpointOnSchedule(), issue_xlog_fsync(), KeepLogSeg(), MaybeRemoveOldWalSummaries(), perform_base_backup(), pg_control_checkpoint(), pg_get_replication_slots(), pg_split_walfile_name(), pg_walfile_name(), pg_walfile_name_offset(), PreallocXlogFiles(), ReadControlFile(), ReadRecord(), RemoveNonParentXlogFiles(), RemoveOldXlogFiles(), ReorderBufferRestoreChanges(), ReorderBufferRestoreCleanup(), ReorderBufferSerializedPath(), ReorderBufferSerializeTXN(), ReplicationSlotReserveWal(), RequestXLogStreaming(), reserve_wal_for_local_slot(), ReserveXLogSwitch(), RestoreArchivedFile(), StartReplication(), StartupDecodingContext(), SummarizeWAL(), UpdateLastRemovedPtr(), WALReadRaiseError(), WalReceiverMain(), WalSndSegmentOpen(), WriteControlFile(), XLogArchiveNotifySeg(), XLogBackgroundFlush(), XLogBytePosToEndRecPtr(), XLogBytePosToRecPtr(), XLogCheckpointNeeded(), XLOGChooseNumBuffers(), XLogFileClose(), XLogFileCopy(), XLogFileInitInternal(), XLogFileOpen(), XLogFileRead(), XLogFileReadAnyTLI(), XLOGfileslop(), XLogGetOldestSegno(), XLogInitNewTimeline(), XLogInsertRecord(), XLogPageRead(), XLogReaderAllocate(), XlogReadTwoPhaseData(), XLogRecPtrToBytePos(), XLogWalRcvClose(), XLogWalRcvWrite(), and XLogWrite().

◆ wal_sync_method

PGDLLIMPORT int wal_sync_method
extern

◆ XactLastCommitEnd

◆ XactLastRecEnd

◆ XLogArchiveCommand

PGDLLIMPORT char* XLogArchiveCommand
extern

◆ XLogArchiveMode

◆ XLogArchiveTimeout

PGDLLIMPORT int XLogArchiveTimeout
extern

Definition at line 118 of file xlog.c.

Referenced by CheckArchiveTimeout(), and CheckpointerMain().

◆ XLOGbuffers

PGDLLIMPORT int XLOGbuffers
extern

Definition at line 117 of file xlog.c.

Referenced by check_wal_buffers(), XLOGShmemInit(), and XLOGShmemSize().