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

Include dependency graph for xlog.c:

Data Structures
struct	XLogwrtRqst

struct	XLogwrtResult

struct	WALInsertLock

union	WALInsertLockPadded

struct	XLogCtlInsert

struct	XLogCtlData

Macros
#define	BootstrapTimeLineID 1

#define	NUM_XLOGINSERT_LOCKS 8

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

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

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

#define	UsableBytesInPage (XLOG_BLCKSZ - SizeOfXLogShortPHD)

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

Typedefs
typedef struct XLogwrtRqst	XLogwrtRqst

typedef struct XLogwrtResult	XLogwrtResult

typedef union WALInsertLockPadded	WALInsertLockPadded

typedef struct XLogCtlInsert	XLogCtlInsert

typedef struct XLogCtlData	XLogCtlData

Functions
static void	CleanupAfterArchiveRecovery (TimeLineID EndOfLogTLI, XLogRecPtr EndOfLog, TimeLineID newTLI)

static void	CheckRequiredParameterValues (void)

static void	XLogReportParameters (void)

static int	LocalSetXLogInsertAllowed (void)

static void	CreateEndOfRecoveryRecord (void)

static XLogRecPtr	CreateOverwriteContrecordRecord (XLogRecPtr aborted_lsn, XLogRecPtr pagePtr, TimeLineID newTLI)

static void	CheckPointGuts (XLogRecPtr checkPointRedo, int flags)

static void	KeepLogSeg (XLogRecPtr recptr, XLogSegNo *logSegNo)

static XLogRecPtr	XLogGetReplicationSlotMinimumLSN (void)

static void	AdvanceXLInsertBuffer (XLogRecPtr upto, TimeLineID tli, bool opportunistic)

static void	XLogWrite (XLogwrtRqst WriteRqst, TimeLineID tli, bool flexible)

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

static void	XLogFileClose (void)

static void	PreallocXlogFiles (XLogRecPtr endptr, TimeLineID tli)

static void	RemoveTempXlogFiles (void)

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

static void	RemoveXlogFile (const struct dirent segment_de, XLogSegNo recycleSegNo, XLogSegNo endlogSegNo, TimeLineID insertTLI)

static void	UpdateLastRemovedPtr (char *filename)

static void	ValidateXLOGDirectoryStructure (void)

static void	CleanupBackupHistory (void)

static void	UpdateMinRecoveryPoint (XLogRecPtr lsn, bool force)

static bool	PerformRecoveryXLogAction (void)

static void	InitControlFile (uint64 sysidentifier)

static void	WriteControlFile (void)

static void	ReadControlFile (void)

static void	UpdateControlFile (void)

static char *	str_time (pg_time_t tnow)

static int	get_sync_bit (int method)

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

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

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

static XLogRecPtr	WaitXLogInsertionsToFinish (XLogRecPtr upto)

static char *	GetXLogBuffer (XLogRecPtr ptr, TimeLineID tli)

static XLogRecPtr	XLogBytePosToRecPtr (uint64 bytepos)

static XLogRecPtr	XLogBytePosToEndRecPtr (uint64 bytepos)

static uint64	XLogRecPtrToBytePos (XLogRecPtr ptr)

static void	WALInsertLockAcquire (void)

static void	WALInsertLockAcquireExclusive (void)

static void	WALInsertLockRelease (void)

static void	WALInsertLockUpdateInsertingAt (XLogRecPtr insertingAt)

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

static void	CalculateCheckpointSegments (void)

void	assign_max_wal_size (int newval, void *extra)

void	assign_checkpoint_completion_target (double newval, void *extra)

static XLogSegNo	XLOGfileslop (XLogRecPtr lastredoptr)

bool	XLogCheckpointNeeded (XLogSegNo new_segno)

void	XLogSetAsyncXactLSN (XLogRecPtr asyncXactLSN)

void	XLogSetReplicationSlotMinimumLSN (XLogRecPtr lsn)

void	XLogFlush (XLogRecPtr record)

bool	XLogBackgroundFlush (void)

bool	XLogNeedsFlush (XLogRecPtr record)

static int	XLogFileInitInternal (XLogSegNo logsegno, TimeLineID logtli, bool added, char path)

int	XLogFileInit (XLogSegNo logsegno, TimeLineID logtli)

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

int	XLogFileOpen (XLogSegNo segno, TimeLineID tli)

void	CheckXLogRemoved (XLogSegNo segno, TimeLineID tli)

XLogSegNo	XLogGetLastRemovedSegno (void)

void	RemoveNonParentXlogFiles (XLogRecPtr switchpoint, TimeLineID newTLI)

uint64	GetSystemIdentifier (void)

char *	GetMockAuthenticationNonce (void)

bool	DataChecksumsEnabled (void)

XLogRecPtr	GetFakeLSNForUnloggedRel (void)

static int	XLOGChooseNumBuffers (void)

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

bool	check_wal_consistency_checking (char newval, void extra, GucSource source)

void	assign_wal_consistency_checking (const char newval, void extra)

void	InitializeWalConsistencyChecking (void)

const char *	show_archive_command (void)

const char *	show_in_hot_standby (void)

void	LocalProcessControlFile (bool reset)

Size	XLOGShmemSize (void)

void	XLOGShmemInit (void)

void	BootStrapXLOG (void)

static void	XLogInitNewTimeline (TimeLineID endTLI, XLogRecPtr endOfLog, TimeLineID newTLI)

void	StartupXLOG (void)

void	SwitchIntoArchiveRecovery (XLogRecPtr EndRecPtr, TimeLineID replayTLI)

void	ReachedEndOfBackup (XLogRecPtr EndRecPtr, TimeLineID tli)

bool	RecoveryInProgress (void)

RecoveryState	GetRecoveryState (void)

bool	XLogInsertAllowed (void)

XLogRecPtr	GetRedoRecPtr (void)

void	GetFullPageWriteInfo (XLogRecPtr RedoRecPtr_p, bool doPageWrites_p)

XLogRecPtr	GetInsertRecPtr (void)

XLogRecPtr	GetFlushRecPtr (TimeLineID *insertTLI)

TimeLineID	GetWALInsertionTimeLine (void)

XLogRecPtr	GetLastImportantRecPtr (void)

pg_time_t	GetLastSegSwitchData (XLogRecPtr *lastSwitchLSN)

void	ShutdownXLOG (int code, Datum arg)

static void	LogCheckpointStart (int flags, bool restartpoint)

static void	LogCheckpointEnd (bool restartpoint)

static void	UpdateCheckPointDistanceEstimate (uint64 nbytes)

static void	update_checkpoint_display (int flags, bool restartpoint, bool reset)

void	CreateCheckPoint (int flags)

static void	RecoveryRestartPoint (const CheckPoint checkPoint, XLogReaderState record)

bool	CreateRestartPoint (int flags)

WALAvailability	GetWALAvailability (XLogRecPtr targetLSN)

void	XLogPutNextOid (Oid nextOid)

XLogRecPtr	RequestXLogSwitch (bool mark_unimportant)

XLogRecPtr	XLogRestorePoint (const char *rpName)

void	UpdateFullPageWrites (void)

void	xlog_redo (XLogReaderState *record)

void	assign_xlog_sync_method (int new_sync_method, void *extra)

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

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

SessionBackupState	get_backup_status (void)

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)

XLogRecPtr	GetXLogInsertRecPtr (void)

XLogRecPtr	GetXLogWriteRecPtr (void)

void	GetOldestRestartPoint (XLogRecPtr oldrecptr, TimeLineID oldtli)

void	XLogShutdownWalRcv (void)

void	SetInstallXLogFileSegmentActive (void)

bool	IsInstallXLogFileSegmentActive (void)

void	SetWalWriterSleeping (bool sleeping)

Variables
uint32	bootstrap_data_checksum_version

int	max_wal_size_mb = 1024

int	min_wal_size_mb = 80

int	wal_keep_size_mb = 0

int	XLOGbuffers = -1

int	XLogArchiveTimeout = 0

int	XLogArchiveMode = ARCHIVE_MODE_OFF

char *	XLogArchiveCommand = NULL

bool	EnableHotStandby = false

bool	fullPageWrites = true

bool	wal_log_hints = false

int	wal_compression = WAL_COMPRESSION_NONE

char *	wal_consistency_checking_string = NULL

bool *	wal_consistency_checking = NULL

bool	wal_init_zero = true

bool	wal_recycle = true

bool	log_checkpoints = true

int	sync_method = DEFAULT_SYNC_METHOD

int	wal_level = WAL_LEVEL_REPLICA

int	CommitDelay = 0

int	CommitSiblings = 5

int	wal_retrieve_retry_interval = 5000

int	max_slot_wal_keep_size_mb = -1

int	wal_decode_buffer_size = 512 * 1024

bool	track_wal_io_timing = false

int	wal_segment_size = DEFAULT_XLOG_SEG_SIZE

int	CheckPointSegments

static double	CheckPointDistanceEstimate = 0

static double	PrevCheckPointDistance = 0

static bool	check_wal_consistency_checking_deferred = false

const struct config_enum_entry	sync_method_options []

const struct config_enum_entry	archive_mode_options []

CheckpointStatsData	CheckpointStats

static bool	lastFullPageWrites

static bool	LocalRecoveryInProgress = true

static int	LocalXLogInsertAllowed = -1

XLogRecPtr	ProcLastRecPtr = InvalidXLogRecPtr

XLogRecPtr	XactLastRecEnd = InvalidXLogRecPtr

XLogRecPtr	XactLastCommitEnd = InvalidXLogRecPtr

static XLogRecPtr	RedoRecPtr

static bool	doPageWrites

static SessionBackupState	sessionBackupState = SESSION_BACKUP_NONE

static XLogCtlData *	XLogCtl = NULL

static WALInsertLockPadded *	WALInsertLocks = NULL

static ControlFileData *	ControlFile = NULL

static int	UsableBytesInSegment

static XLogwrtResult	LogwrtResult = {0, 0}

static int	openLogFile = -1

static XLogSegNo	openLogSegNo = 0

static TimeLineID	openLogTLI = 0

static XLogRecPtr	LocalMinRecoveryPoint

static TimeLineID	LocalMinRecoveryPointTLI

static bool	updateMinRecoveryPoint = true

static int	MyLockNo = 0

static bool	holdingAllLocks = false

Macro Definition Documentation

◆ BootstrapTimeLineID

#define BootstrapTimeLineID 1

Definition at line 114 of file xlog.c.

◆ ConvertToXSegs

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

Definition at line 599 of file xlog.c.

◆ INSERT_FREESPACE

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

Definition at line 576 of file xlog.c.

◆ NextBufIdx

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

Definition at line 580 of file xlog.c.

◆ NUM_XLOGINSERT_LOCKS

#define NUM_XLOGINSERT_LOCKS 8

Definition at line 153 of file xlog.c.

◆ UsableBytesInPage

#define UsableBytesInPage (XLOG_BLCKSZ - SizeOfXLogShortPHD)

Definition at line 593 of file xlog.c.

◆ XLogRecPtrToBufIdx

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

Definition at line 587 of file xlog.c.

Typedef Documentation

◆ WALInsertLockPadded

typedef union WALInsertLockPadded WALInsertLockPadded

◆ XLogCtlData

typedef struct XLogCtlData XLogCtlData

◆ XLogCtlInsert

typedef struct XLogCtlInsert XLogCtlInsert

◆ XLogwrtResult

typedef struct XLogwrtResult XLogwrtResult

◆ XLogwrtRqst

typedef struct XLogwrtRqst XLogwrtRqst

Function Documentation

◆ AdvanceXLInsertBuffer()

static void AdvanceXLInsertBuffer	(	XLogRecPtr	upto,
		TimeLineID	tli,
		bool	opportunistic
	)

static

Definition at line 1775 of file xlog.c.

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

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

Referenced by GetXLogBuffer(), and XLogBackgroundFlush().

◆ assign_checkpoint_completion_target()

void assign_checkpoint_completion_target	(	double	newval,
		void *	extra
	)

Definition at line 1981 of file xlog.c.

 {
     CheckPointCompletionTarget = newval;
     CalculateCheckpointSegments();
 }

References CalculateCheckpointSegments(), CheckPointCompletionTarget, and newval.

◆ assign_max_wal_size()

void assign_max_wal_size	(	int	newval,
		void *	extra
	)

Definition at line 1974 of file xlog.c.

 {
     max_wal_size_mb = newval;
     CalculateCheckpointSegments();
 }

References CalculateCheckpointSegments(), max_wal_size_mb, and newval.

◆ assign_wal_consistency_checking()

void assign_wal_consistency_checking	(	const char *	newval,
		void *	extra
	)

Definition at line 4377 of file xlog.c.

 {
     /*
      * If some checks were deferred, it's possible that the checks will fail
      * later during InitializeWalConsistencyChecking(). But in that case, the
      * postmaster will exit anyway, so it's safe to proceed with the
      * assignment.
      *
      * Any built-in resource managers specified are assigned immediately,
      * which affects WAL created before shared_preload_libraries are
      * processed. Any custom resource managers specified won't be assigned
      * until after shared_preload_libraries are processed, but that's OK
      * because WAL for a custom resource manager can't be written before the
      * module is loaded anyway.
      */
     wal_consistency_checking = extra;
 }

References wal_consistency_checking.

◆ assign_xlog_sync_method()

void assign_xlog_sync_method	(	int	new_sync_method,
		void *	extra
	)

Definition at line 8096 of file xlog.c.

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

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

◆ BootStrapXLOG()

void BootStrapXLOG ( void )

Definition at line 4637 of file xlog.c.

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

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

Referenced by BootstrapModeMain().

◆ CalculateCheckpointSegments()

static void CalculateCheckpointSegments ( void )

static

Definition at line 1945 of file xlog.c.

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

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

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

◆ check_wal_buffers()

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

Definition at line 4257 of file xlog.c.

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

References newval, XLOGbuffers, and XLOGChooseNumBuffers().

◆ check_wal_consistency_checking()

bool check_wal_consistency_checking	(	char **	newval,
		void **	extra,
		GucSource	source
	)

Definition at line 4292 of file xlog.c.

 {
     char       *rawstring;
     List       *elemlist;
     ListCell   *l;
     bool        newwalconsistency[RM_MAX_ID + 1];
  
     /* Initialize the array */
     MemSet(newwalconsistency, 0, (RM_MAX_ID + 1) * sizeof(bool));
  
     /* Need a modifiable copy of string */
     rawstring = pstrdup(*newval);
  
     /* Parse string into list of identifiers */
     if (!SplitIdentifierString(rawstring, ',', &elemlist))
     {
         /* syntax error in list */
         GUC_check_errdetail("List syntax is invalid.");
         pfree(rawstring);
         list_free(elemlist);
         return false;
     }
  
     foreach(l, elemlist)
     {
         char       *tok = (char *) lfirst(l);
         int         rmid;
  
         /* Check for 'all'. */
         if (pg_strcasecmp(tok, "all") == 0)
         {
             for (rmid = 0; rmid <= RM_MAX_ID; rmid++)
                 if (RmgrIdExists(rmid) && GetRmgr(rmid).rm_mask != NULL)
                     newwalconsistency[rmid] = true;
         }
         else
         {
             /* Check if the token matches any known resource manager. */
             bool        found = false;
  
             for (rmid = 0; rmid <= RM_MAX_ID; rmid++)
             {
                 if (RmgrIdExists(rmid) && GetRmgr(rmid).rm_mask != NULL &&
                     pg_strcasecmp(tok, GetRmgr(rmid).rm_name) == 0)
                 {
                     newwalconsistency[rmid] = true;
                     found = true;
                     break;
                 }
             }
             if (!found)
             {
                 /*
                  * During startup, it might be a not-yet-loaded custom
                  * resource manager.  Defer checking until
                  * InitializeWalConsistencyChecking().
                  */
                 if (!process_shared_preload_libraries_done)
                 {
                     check_wal_consistency_checking_deferred = true;
                 }
                 else
                 {
                     GUC_check_errdetail("Unrecognized key word: \"%s\".", tok);
                     pfree(rawstring);
                     list_free(elemlist);
                     return false;
                 }
             }
         }
     }
  
     pfree(rawstring);
     list_free(elemlist);
  
     /* assign new value */
     *extra = guc_malloc(ERROR, (RM_MAX_ID + 1) * sizeof(bool));
     memcpy(*extra, newwalconsistency, (RM_MAX_ID + 1) * sizeof(bool));
     return true;
 }

References check_wal_consistency_checking_deferred, ERROR, GetRmgr(), GUC_check_errdetail, guc_malloc(), lfirst, list_free(), MemSet, newval, pfree(), pg_strcasecmp(), process_shared_preload_libraries_done, pstrdup(), RmgrData::rm_mask, RM_MAX_ID, RmgrIdExists(), and SplitIdentifierString().

◆ CheckPointGuts()

static void CheckPointGuts	(	XLogRecPtr	checkPointRedo,
		int	flags
	)

static

Definition at line 7000 of file xlog.c.

 {
     CheckPointRelationMap();
     CheckPointReplicationSlots();
     CheckPointSnapBuild();
     CheckPointLogicalRewriteHeap();
     CheckPointReplicationOrigin();
  
     /* Write out all dirty data in SLRUs and the main buffer pool */
     TRACE_POSTGRESQL_BUFFER_CHECKPOINT_START(flags);
     CheckpointStats.ckpt_write_t = GetCurrentTimestamp();
     CheckPointCLOG();
     CheckPointCommitTs();
     CheckPointSUBTRANS();
     CheckPointMultiXact();
     CheckPointPredicate();
     CheckPointBuffers(flags);
  
     /* Perform all queued up fsyncs */
     TRACE_POSTGRESQL_BUFFER_CHECKPOINT_SYNC_START();
     CheckpointStats.ckpt_sync_t = GetCurrentTimestamp();
     ProcessSyncRequests();
     CheckpointStats.ckpt_sync_end_t = GetCurrentTimestamp();
     TRACE_POSTGRESQL_BUFFER_CHECKPOINT_DONE();
  
     /* We deliberately delay 2PC checkpointing as long as possible */
     CheckPointTwoPhase(checkPointRedo);
 }

References CheckPointBuffers(), CheckPointCLOG(), CheckPointCommitTs(), CheckPointLogicalRewriteHeap(), CheckPointMultiXact(), CheckPointPredicate(), CheckPointRelationMap(), CheckPointReplicationOrigin(), CheckPointReplicationSlots(), CheckPointSnapBuild(), CheckpointStats, CheckPointSUBTRANS(), CheckPointTwoPhase(), CheckpointStatsData::ckpt_sync_end_t, CheckpointStatsData::ckpt_sync_t, CheckpointStatsData::ckpt_write_t, GetCurrentTimestamp(), and ProcessSyncRequests().

Referenced by CreateCheckPoint(), and CreateRestartPoint().

◆ CheckRequiredParameterValues()

static void CheckRequiredParameterValues ( void )

static

Definition at line 4981 of file xlog.c.

 {
     /*
      * For archive recovery, the WAL must be generated with at least 'replica'
      * wal_level.
      */
     if (ArchiveRecoveryRequested && ControlFile->wal_level == WAL_LEVEL_MINIMAL)
     {
         ereport(FATAL,
                 (errmsg("WAL was generated with wal_level=minimal, cannot continue recovering"),
                  errdetail("This happens if you temporarily set wal_level=minimal on the server."),
                  errhint("Use a backup taken after setting wal_level to higher than minimal.")));
     }
  
     /*
      * For Hot Standby, the WAL must be generated with 'replica' mode, and we
      * must have at least as many backend slots as the primary.
      */
     if (ArchiveRecoveryRequested && EnableHotStandby)
     {
         /* We ignore autovacuum_max_workers when we make this test. */
         RecoveryRequiresIntParameter("max_connections",
                                      MaxConnections,
                                      ControlFile->MaxConnections);
         RecoveryRequiresIntParameter("max_worker_processes",
                                      max_worker_processes,
                                      ControlFile->max_worker_processes);
         RecoveryRequiresIntParameter("max_wal_senders",
                                      max_wal_senders,
                                      ControlFile->max_wal_senders);
         RecoveryRequiresIntParameter("max_prepared_transactions",
                                      max_prepared_xacts,
                                      ControlFile->max_prepared_xacts);
         RecoveryRequiresIntParameter("max_locks_per_transaction",
                                      max_locks_per_xact,
                                      ControlFile->max_locks_per_xact);
     }
 }

References ArchiveRecoveryRequested, ControlFile, EnableHotStandby, ereport, errdetail(), errhint(), errmsg(), FATAL, max_locks_per_xact, ControlFileData::max_locks_per_xact, max_prepared_xacts, ControlFileData::max_prepared_xacts, max_wal_senders, ControlFileData::max_wal_senders, max_worker_processes, ControlFileData::max_worker_processes, MaxConnections, ControlFileData::MaxConnections, RecoveryRequiresIntParameter(), ControlFileData::wal_level, and WAL_LEVEL_MINIMAL.

Referenced by StartupXLOG(), and xlog_redo().

◆ CheckXLogRemoved()

void CheckXLogRemoved	(	XLogSegNo	segno,
		TimeLineID	tli
	)

Definition at line 3430 of file xlog.c.

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

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

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

◆ CleanupAfterArchiveRecovery()

static void CleanupAfterArchiveRecovery	(	TimeLineID	EndOfLogTLI,
		XLogRecPtr	EndOfLog,
		TimeLineID	newTLI
	)

static

Definition at line 4892 of file xlog.c.

 {
     /*
      * Execute the recovery_end_command, if any.
      */
     if (recoveryEndCommand && strcmp(recoveryEndCommand, "") != 0)
         ExecuteRecoveryCommand(recoveryEndCommand,
                                "recovery_end_command",
                                true,
                                WAIT_EVENT_RECOVERY_END_COMMAND);
  
     /*
      * We switched to a new timeline. Clean up segments on the old timeline.
      *
      * If there are any higher-numbered segments on the old timeline, remove
      * them. They might contain valid WAL, but they might also be
      * pre-allocated files containing garbage. In any case, they are not part
      * of the new timeline's history so we don't need them.
      */
     RemoveNonParentXlogFiles(EndOfLog, newTLI);
  
     /*
      * If the switch happened in the middle of a segment, what to do with the
      * last, partial segment on the old timeline? If we don't archive it, and
      * the server that created the WAL never archives it either (e.g. because
      * it was hit by a meteor), it will never make it to the archive. That's
      * OK from our point of view, because the new segment that we created with
      * the new TLI contains all the WAL from the old timeline up to the switch
      * point. But if you later try to do PITR to the "missing" WAL on the old
      * timeline, recovery won't find it in the archive. It's physically
      * present in the new file with new TLI, but recovery won't look there
      * when it's recovering to the older timeline. On the other hand, if we
      * archive the partial segment, and the original server on that timeline
      * is still running and archives the completed version of the same segment
      * later, it will fail. (We used to do that in 9.4 and below, and it
      * caused such problems).
      *
      * As a compromise, we rename the last segment with the .partial suffix,
      * and archive it. Archive recovery will never try to read .partial
      * segments, so they will normally go unused. But in the odd PITR case,
      * the administrator can copy them manually to the pg_wal directory
      * (removing the suffix). They can be useful in debugging, too.
      *
      * If a .done or .ready file already exists for the old timeline, however,
      * we had already determined that the segment is complete, so we can let
      * it be archived normally. (In particular, if it was restored from the
      * archive to begin with, it's expected to have a .done file).
      */
     if (XLogSegmentOffset(EndOfLog, wal_segment_size) != 0 &&
         XLogArchivingActive())
     {
         char        origfname[MAXFNAMELEN];
         XLogSegNo   endLogSegNo;
  
         XLByteToPrevSeg(EndOfLog, endLogSegNo, wal_segment_size);
         XLogFileName(origfname, EndOfLogTLI, endLogSegNo, wal_segment_size);
  
         if (!XLogArchiveIsReadyOrDone(origfname))
         {
             char        origpath[MAXPGPATH];
             char        partialfname[MAXFNAMELEN];
             char        partialpath[MAXPGPATH];
  
             XLogFilePath(origpath, EndOfLogTLI, endLogSegNo, wal_segment_size);
             snprintf(partialfname, MAXFNAMELEN, "%s.partial", origfname);
             snprintf(partialpath, MAXPGPATH, "%s.partial", origpath);
  
             /*
              * Make sure there's no .done or .ready file for the .partial
              * file.
              */
             XLogArchiveCleanup(partialfname);
  
             durable_rename(origpath, partialpath, ERROR);
             XLogArchiveNotify(partialfname);
         }
     }
 }

References durable_rename(), ERROR, ExecuteRecoveryCommand(), MAXFNAMELEN, MAXPGPATH, recoveryEndCommand, RemoveNonParentXlogFiles(), snprintf, WAIT_EVENT_RECOVERY_END_COMMAND, wal_segment_size, XLByteToPrevSeg, XLogArchiveCleanup(), XLogArchiveIsReadyOrDone(), XLogArchiveNotify(), XLogArchivingActive, XLogFileName(), XLogFilePath(), and XLogSegmentOffset.

Referenced by StartupXLOG().

◆ CleanupBackupHistory()

static void CleanupBackupHistory ( void )

static

Definition at line 3803 of file xlog.c.

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

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

Referenced by do_pg_backup_stop().

◆ CopyXLogRecordToWAL()

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

static

Definition at line 1161 of file xlog.c.

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

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

Referenced by XLogInsertRecord().

◆ CreateCheckPoint()

void CreateCheckPoint ( int flags )

Definition at line 6440 of file xlog.c.

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

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

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

◆ CreateEndOfRecoveryRecord()

static void CreateEndOfRecoveryRecord ( void )

static

Definition at line 6866 of file xlog.c.

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

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

Referenced by PerformRecoveryXLogAction().

◆ CreateOverwriteContrecordRecord()

static XLogRecPtr CreateOverwriteContrecordRecord	(	XLogRecPtr	aborted_lsn,
		XLogRecPtr	pagePtr,
		TimeLineID	newTLI
	)

static

Definition at line 6930 of file xlog.c.

 {
     xl_overwrite_contrecord xlrec;
     XLogRecPtr  recptr;
     XLogPageHeader pagehdr;
     XLogRecPtr  startPos;
  
     /* sanity checks */
     if (!RecoveryInProgress())
         elog(ERROR, "can only be used at end of recovery");
     if (pagePtr % XLOG_BLCKSZ != 0)
         elog(ERROR, "invalid position for missing continuation record %X/%X",
              LSN_FORMAT_ARGS(pagePtr));
  
     /* The current WAL insert position should be right after the page header */
     startPos = pagePtr;
     if (XLogSegmentOffset(startPos, wal_segment_size) == 0)
         startPos += SizeOfXLogLongPHD;
     else
         startPos += SizeOfXLogShortPHD;
     recptr = GetXLogInsertRecPtr();
     if (recptr != startPos)
         elog(ERROR, "invalid WAL insert position %X/%X for OVERWRITE_CONTRECORD",
              LSN_FORMAT_ARGS(recptr));
  
     START_CRIT_SECTION();
  
     /*
      * Initialize the XLOG page header (by GetXLogBuffer), and set the
      * XLP_FIRST_IS_OVERWRITE_CONTRECORD flag.
      *
      * No other backend is allowed to write WAL yet, so acquiring the WAL
      * insertion lock is just pro forma.
      */
     WALInsertLockAcquire();
     pagehdr = (XLogPageHeader) GetXLogBuffer(pagePtr, newTLI);
     pagehdr->xlp_info |= XLP_FIRST_IS_OVERWRITE_CONTRECORD;
     WALInsertLockRelease();
  
     /*
      * Insert the XLOG_OVERWRITE_CONTRECORD record as the first record on the
      * page.  We know it becomes the first record, because no other backend is
      * allowed to write WAL yet.
      */
     XLogBeginInsert();
     xlrec.overwritten_lsn = aborted_lsn;
     xlrec.overwrite_time = GetCurrentTimestamp();
     XLogRegisterData((char *) &xlrec, sizeof(xl_overwrite_contrecord));
     recptr = XLogInsert(RM_XLOG_ID, XLOG_OVERWRITE_CONTRECORD);
  
     /* check that the record was inserted to the right place */
     if (ProcLastRecPtr != startPos)
         elog(ERROR, "OVERWRITE_CONTRECORD was inserted to unexpected position %X/%X",
              LSN_FORMAT_ARGS(ProcLastRecPtr));
  
     XLogFlush(recptr);
  
     END_CRIT_SECTION();
  
     return recptr;
 }

References elog(), END_CRIT_SECTION, ERROR, GetCurrentTimestamp(), GetXLogBuffer(), GetXLogInsertRecPtr(), LSN_FORMAT_ARGS, xl_overwrite_contrecord::overwrite_time, xl_overwrite_contrecord::overwritten_lsn, ProcLastRecPtr, RecoveryInProgress(), SizeOfXLogLongPHD, SizeOfXLogShortPHD, START_CRIT_SECTION, wal_segment_size, WALInsertLockAcquire(), WALInsertLockRelease(), XLOG_OVERWRITE_CONTRECORD, XLogBeginInsert(), XLogFlush(), XLogInsert(), XLogRegisterData(), XLogSegmentOffset, XLP_FIRST_IS_OVERWRITE_CONTRECORD, and XLogPageHeaderData::xlp_info.

Referenced by StartupXLOG().

◆ CreateRestartPoint()

bool CreateRestartPoint ( int flags )

Definition at line 7081 of file xlog.c.

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

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

Referenced by CheckpointerMain(), and ShutdownXLOG().

◆ DataChecksumsEnabled()

bool DataChecksumsEnabled ( void )

Definition at line 4201 of file xlog.c.

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

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

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

◆ do_pg_abort_backup()

void do_pg_abort_backup	(	int	code,
		Datum	arg
	)

Definition at line 8817 of file xlog.c.

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

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

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

◆ do_pg_backup_start()

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

Definition at line 8244 of file xlog.c.

 {
     bool        backup_started_in_recovery;
  
     Assert(state != NULL);
     backup_started_in_recovery = RecoveryInProgress();
  
     /*
      * During recovery, we don't need to check WAL level. Because, if WAL
      * level is not sufficient, it's impossible to get here during recovery.
      */
     if (!backup_started_in_recovery && !XLogIsNeeded())
         ereport(ERROR,
                 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                  errmsg("WAL level not sufficient for making an online backup"),
                  errhint("wal_level must be set to \"replica\" or \"logical\" at server start.")));
  
     if (strlen(backupidstr) > MAXPGPATH)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                  errmsg("backup label too long (max %d bytes)",
                         MAXPGPATH)));
  
     memcpy(state->name, backupidstr, strlen(backupidstr));
  
     /*
      * Mark backup active in shared memory.  We must do full-page WAL writes
      * during an on-line backup even if not doing so at other times, because
      * it's quite possible for the backup dump to obtain a "torn" (partially
      * written) copy of a database page if it reads the page concurrently with
      * our write to the same page.  This can be fixed as long as the first
      * write to the page in the WAL sequence is a full-page write. Hence, we
      * increment runningBackups then force a CHECKPOINT, to ensure there are
      * no dirty pages in shared memory that might get dumped while the backup
      * is in progress without having a corresponding WAL record.  (Once the
      * backup is complete, we need not force full-page writes anymore, since
      * we expect that any pages not modified during the backup interval must
      * have been correctly captured by the backup.)
      *
      * Note that forcing full-page writes has no effect during an online
      * backup from the standby.
      *
      * We must hold all the insertion locks to change the value of
      * runningBackups, to ensure adequate interlocking against
      * XLogInsertRecord().
      */
     WALInsertLockAcquireExclusive();
     XLogCtl->Insert.runningBackups++;
     WALInsertLockRelease();
  
     /*
      * Ensure we decrement runningBackups if we fail below. NB -- for this to
      * work correctly, it is critical that sessionBackupState is only updated
      * after this block is over.
      */
     PG_ENSURE_ERROR_CLEANUP(do_pg_abort_backup, DatumGetBool(true));
     {
         bool        gotUniqueStartpoint = false;
         DIR        *tblspcdir;
         struct dirent *de;
         tablespaceinfo *ti;
         int         datadirpathlen;
  
         /*
          * Force an XLOG file switch before the checkpoint, to ensure that the
          * WAL segment the checkpoint is written to doesn't contain pages with
          * old timeline IDs.  That would otherwise happen if you called
          * pg_backup_start() right after restoring from a PITR archive: the
          * first WAL segment containing the startup checkpoint has pages in
          * the beginning with the old timeline ID.  That can cause trouble at
          * recovery: we won't have a history file covering the old timeline if
          * pg_wal directory was not included in the base backup and the WAL
          * archive was cleared too before starting the backup.
          *
          * This also ensures that we have emitted a WAL page header that has
          * XLP_BKP_REMOVABLE off before we emit the checkpoint record.
          * Therefore, if a WAL archiver (such as pglesslog) is trying to
          * compress out removable backup blocks, it won't remove any that
          * occur after this point.
          *
          * During recovery, we skip forcing XLOG file switch, which means that
          * the backup taken during recovery is not available for the special
          * recovery case described above.
          */
         if (!backup_started_in_recovery)
             RequestXLogSwitch(false);
  
         do
         {
             bool        checkpointfpw;
  
             /*
              * Force a CHECKPOINT.  Aside from being necessary to prevent torn
              * page problems, this guarantees that two successive backup runs
              * will have different checkpoint positions and hence different
              * history file names, even if nothing happened in between.
              *
              * During recovery, establish a restartpoint if possible. We use
              * the last restartpoint as the backup starting checkpoint. This
              * means that two successive backup runs can have same checkpoint
              * positions.
              *
              * Since the fact that we are executing do_pg_backup_start()
              * during recovery means that checkpointer is running, we can use
              * RequestCheckpoint() to establish a restartpoint.
              *
              * We use CHECKPOINT_IMMEDIATE only if requested by user (via
              * passing fast = true).  Otherwise this can take awhile.
              */
             RequestCheckpoint(CHECKPOINT_FORCE | CHECKPOINT_WAIT |
                               (fast ? CHECKPOINT_IMMEDIATE : 0));
  
             /*
              * Now we need to fetch the checkpoint record location, and also
              * its REDO pointer.  The oldest point in WAL that would be needed
              * to restore starting from the checkpoint is precisely the REDO
              * pointer.
              */
             LWLockAcquire(ControlFileLock, LW_SHARED);
             state->checkpointloc = ControlFile->checkPoint;
             state->startpoint = ControlFile->checkPointCopy.redo;
             state->starttli = ControlFile->checkPointCopy.ThisTimeLineID;
             checkpointfpw = ControlFile->checkPointCopy.fullPageWrites;
             LWLockRelease(ControlFileLock);
  
             if (backup_started_in_recovery)
             {
                 XLogRecPtr  recptr;
  
                 /*
                  * Check to see if all WAL replayed during online backup
                  * (i.e., since last restartpoint used as backup starting
                  * checkpoint) contain full-page writes.
                  */
                 SpinLockAcquire(&XLogCtl->info_lck);
                 recptr = XLogCtl->lastFpwDisableRecPtr;
                 SpinLockRelease(&XLogCtl->info_lck);
  
                 if (!checkpointfpw || state->startpoint <= recptr)
                     ereport(ERROR,
                             (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                              errmsg("WAL generated with full_page_writes=off was replayed "
                                     "since last restartpoint"),
                              errhint("This means that the backup being taken on the standby "
                                      "is corrupt and should not be used. "
                                      "Enable full_page_writes and run CHECKPOINT on the primary, "
                                      "and then try an online backup again.")));
  
                 /*
                  * During recovery, since we don't use the end-of-backup WAL
                  * record and don't write the backup history file, the
                  * starting WAL location doesn't need to be unique. This means
                  * that two base backups started at the same time might use
                  * the same checkpoint as starting locations.
                  */
                 gotUniqueStartpoint = true;
             }
  
             /*
              * If two base backups are started at the same time (in WAL sender
              * processes), we need to make sure that they use different
              * checkpoints as starting locations, because we use the starting
              * WAL location as a unique identifier for the base backup in the
              * end-of-backup WAL record and when we write the backup history
              * file. Perhaps it would be better generate a separate unique ID
              * for each backup instead of forcing another checkpoint, but
              * taking a checkpoint right after another is not that expensive
              * either because only few buffers have been dirtied yet.
              */
             WALInsertLockAcquireExclusive();
             if (XLogCtl->Insert.lastBackupStart < state->startpoint)
             {
                 XLogCtl->Insert.lastBackupStart = state->startpoint;
                 gotUniqueStartpoint = true;
             }
             WALInsertLockRelease();
         } while (!gotUniqueStartpoint);
  
         /*
          * Construct tablespace_map file.
          */
         datadirpathlen = strlen(DataDir);
  
         /* Collect information about all tablespaces */
         tblspcdir = AllocateDir("pg_tblspc");
         while ((de = ReadDir(tblspcdir, "pg_tblspc")) != NULL)
         {
             char        fullpath[MAXPGPATH + 10];
             char        linkpath[MAXPGPATH];
             char       *relpath = NULL;
             int         rllen;
             StringInfoData escapedpath;
             char       *s;
  
             /* Skip anything that doesn't look like a tablespace */
             if (strspn(de->d_name, "0123456789") != strlen(de->d_name))
                 continue;
  
             snprintf(fullpath, sizeof(fullpath), "pg_tblspc/%s", de->d_name);
  
             /*
              * Skip anything that isn't a symlink/junction.  For testing only,
              * we sometimes use allow_in_place_tablespaces to create
              * directories directly under pg_tblspc, which would fail below.
              */
             if (get_dirent_type(fullpath, de, false, ERROR) != PGFILETYPE_LNK)
                 continue;
  
             rllen = readlink(fullpath, linkpath, sizeof(linkpath));
             if (rllen < 0)
             {
                 ereport(WARNING,
                         (errmsg("could not read symbolic link \"%s\": %m",
                                 fullpath)));
                 continue;
             }
             else if (rllen >= sizeof(linkpath))
             {
                 ereport(WARNING,
                         (errmsg("symbolic link \"%s\" target is too long",
                                 fullpath)));
                 continue;
             }
             linkpath[rllen] = '\0';
  
             /*
              * Build a backslash-escaped version of the link path to include
              * in the tablespace map file.
              */
             initStringInfo(&escapedpath);
             for (s = linkpath; *s; s++)
             {
                 if (*s == '\n' || *s == '\r' || *s == '\\')
                     appendStringInfoChar(&escapedpath, '\\');
                 appendStringInfoChar(&escapedpath, *s);
             }
  
             /*
              * Relpath holds the relative path of the tablespace directory
              * when it's located within PGDATA, or NULL if it's located
              * elsewhere.
              */
             if (rllen > datadirpathlen &&
                 strncmp(linkpath, DataDir, datadirpathlen) == 0 &&
                 IS_DIR_SEP(linkpath[datadirpathlen]))
                 relpath = linkpath + datadirpathlen + 1;
  
             ti = palloc(sizeof(tablespaceinfo));
             ti->oid = pstrdup(de->d_name);
             ti->path = pstrdup(linkpath);
             ti->rpath = relpath ? pstrdup(relpath) : NULL;
             ti->size = -1;
  
             if (tablespaces)
                 *tablespaces = lappend(*tablespaces, ti);
  
             appendStringInfo(tblspcmapfile, "%s %s\n",
                              ti->oid, escapedpath.data);
  
             pfree(escapedpath.data);
         }
         FreeDir(tblspcdir);
  
         state->starttime = (pg_time_t) time(NULL);
     }
     PG_END_ENSURE_ERROR_CLEANUP(do_pg_abort_backup, DatumGetBool(true));
  
     state->started_in_recovery = backup_started_in_recovery;
  
     /*
      * Mark that the start phase has correctly finished for the backup.
      */
     sessionBackupState = SESSION_BACKUP_RUNNING;
 }

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

Referenced by perform_base_backup(), and pg_backup_start().

◆ do_pg_backup_stop()

void do_pg_backup_stop	(	BackupState *	state,
		bool	waitforarchive
	)

Definition at line 8543 of file xlog.c.

 {
     bool        backup_stopped_in_recovery = false;
     char        histfilepath[MAXPGPATH];
     char        lastxlogfilename[MAXFNAMELEN];
     char        histfilename[MAXFNAMELEN];
     XLogSegNo   _logSegNo;
     FILE       *fp;
     int         seconds_before_warning;
     int         waits = 0;
     bool        reported_waiting = false;
  
     Assert(state != NULL);
  
     backup_stopped_in_recovery = RecoveryInProgress();
  
     /*
      * During recovery, we don't need to check WAL level. Because, if WAL
      * level is not sufficient, it's impossible to get here during recovery.
      */
     if (!backup_stopped_in_recovery && !XLogIsNeeded())
         ereport(ERROR,
                 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                  errmsg("WAL level not sufficient for making an online backup"),
                  errhint("wal_level must be set to \"replica\" or \"logical\" at server start.")));
  
     /*
      * OK to update backup counter and session-level lock.
      *
      * Note that CHECK_FOR_INTERRUPTS() must not occur while updating them,
      * otherwise they can be updated inconsistently, which might cause
      * do_pg_abort_backup() to fail.
      */
     WALInsertLockAcquireExclusive();
  
     /*
      * It is expected that each do_pg_backup_start() call is matched by
      * exactly one do_pg_backup_stop() call.
      */
     Assert(XLogCtl->Insert.runningBackups > 0);
     XLogCtl->Insert.runningBackups--;
  
     /*
      * Clean up session-level lock.
      *
      * You might think that WALInsertLockRelease() can be called before
      * cleaning up session-level lock because session-level lock doesn't need
      * to be protected with WAL insertion lock. But since
      * CHECK_FOR_INTERRUPTS() can occur in it, session-level lock must be
      * cleaned up before it.
      */
     sessionBackupState = SESSION_BACKUP_NONE;
  
     WALInsertLockRelease();
  
     /*
      * If we are taking an online backup from the standby, we confirm that the
      * standby has not been promoted during the backup.
      */
     if (state->started_in_recovery && !backup_stopped_in_recovery)
         ereport(ERROR,
                 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                  errmsg("the standby was promoted during online backup"),
                  errhint("This means that the backup being taken is corrupt "
                          "and should not be used. "
                          "Try taking another online backup.")));
  
     /*
      * During recovery, we don't write an end-of-backup record. We assume that
      * pg_control was backed up last and its minimum recovery point can be
      * available as the backup end location. Since we don't have an
      * end-of-backup record, we use the pg_control value to check whether
      * we've reached the end of backup when starting recovery from this
      * backup. We have no way of checking if pg_control wasn't backed up last
      * however.
      *
      * We don't force a switch to new WAL file but it is still possible to
      * wait for all the required files to be archived if waitforarchive is
      * true. This is okay if we use the backup to start a standby and fetch
      * the missing WAL using streaming replication. But in the case of an
      * archive recovery, a user should set waitforarchive to true and wait for
      * them to be archived to ensure that all the required files are
      * available.
      *
      * We return the current minimum recovery point as the backup end
      * location. Note that it can be greater than the exact backup end
      * location if the minimum recovery point is updated after the backup of
      * pg_control. This is harmless for current uses.
      *
      * XXX currently a backup history file is for informational and debug
      * purposes only. It's not essential for an online backup. Furthermore,
      * even if it's created, it will not be archived during recovery because
      * an archiver is not invoked. So it doesn't seem worthwhile to write a
      * backup history file during recovery.
      */
     if (backup_stopped_in_recovery)
     {
         XLogRecPtr  recptr;
  
         /*
          * Check to see if all WAL replayed during online backup contain
          * full-page writes.
          */
         SpinLockAcquire(&XLogCtl->info_lck);
         recptr = XLogCtl->lastFpwDisableRecPtr;
         SpinLockRelease(&XLogCtl->info_lck);
  
         if (state->startpoint <= recptr)
             ereport(ERROR,
                     (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                      errmsg("WAL generated with full_page_writes=off was replayed "
                             "during online backup"),
                      errhint("This means that the backup being taken on the standby "
                              "is corrupt and should not be used. "
                              "Enable full_page_writes and run CHECKPOINT on the primary, "
                              "and then try an online backup again.")));
  
  
         LWLockAcquire(ControlFileLock, LW_SHARED);
         state->stoppoint = ControlFile->minRecoveryPoint;
         state->stoptli = ControlFile->minRecoveryPointTLI;
         LWLockRelease(ControlFileLock);
     }
     else
     {
         char       *history_file;
  
         /*
          * Write the backup-end xlog record
          */
         XLogBeginInsert();
         XLogRegisterData((char *) (&state->startpoint),
                          sizeof(state->startpoint));
         state->stoppoint = XLogInsert(RM_XLOG_ID, XLOG_BACKUP_END);
  
         /*
          * Given that we're not in recovery, InsertTimeLineID is set and can't
          * change, so we can read it without a lock.
          */
         state->stoptli = XLogCtl->InsertTimeLineID;
  
         /*
          * Force a switch to a new xlog segment file, so that the backup is
          * valid as soon as archiver moves out the current segment file.
          */
         RequestXLogSwitch(false);
  
         state->stoptime = (pg_time_t) time(NULL);
  
         /*
          * Write the backup history file
          */
         XLByteToSeg(state->startpoint, _logSegNo, wal_segment_size);
         BackupHistoryFilePath(histfilepath, state->stoptli, _logSegNo,
                               state->startpoint, wal_segment_size);
         fp = AllocateFile(histfilepath, "w");
         if (!fp)
             ereport(ERROR,
                     (errcode_for_file_access(),
                      errmsg("could not create file \"%s\": %m",
                             histfilepath)));
  
         /* Build and save the contents of the backup history file */
         history_file = build_backup_content(state, true);
         fprintf(fp, "%s", history_file);
         pfree(history_file);
  
         if (fflush(fp) || ferror(fp) || FreeFile(fp))
             ereport(ERROR,
                     (errcode_for_file_access(),
                      errmsg("could not write file \"%s\": %m",
                             histfilepath)));
  
         /*
          * Clean out any no-longer-needed history files.  As a side effect,
          * this will post a .ready file for the newly created history file,
          * notifying the archiver that history file may be archived
          * immediately.
          */
         CleanupBackupHistory();
     }
  
     /*
      * If archiving is enabled, wait for all the required WAL files to be
      * archived before returning. If archiving isn't enabled, the required WAL
      * needs to be transported via streaming replication (hopefully with
      * wal_keep_size set high enough), or some more exotic mechanism like
      * polling and copying files from pg_wal with script. We have no knowledge
      * of those mechanisms, so it's up to the user to ensure that he gets all
      * the required WAL.
      *
      * We wait until both the last WAL file filled during backup and the
      * history file have been archived, and assume that the alphabetic sorting
      * property of the WAL files ensures any earlier WAL files are safely
      * archived as well.
      *
      * We wait forever, since archive_command is supposed to work and we
      * assume the admin wanted his backup to work completely. If you don't
      * wish to wait, then either waitforarchive should be passed in as false,
      * or you can set statement_timeout.  Also, some notices are issued to
      * clue in anyone who might be doing this interactively.
      */
  
     if (waitforarchive &&
         ((!backup_stopped_in_recovery && XLogArchivingActive()) ||
          (backup_stopped_in_recovery && XLogArchivingAlways())))
     {
         XLByteToPrevSeg(state->stoppoint, _logSegNo, wal_segment_size);
         XLogFileName(lastxlogfilename, state->stoptli, _logSegNo,
                      wal_segment_size);
  
         XLByteToSeg(state->startpoint, _logSegNo, wal_segment_size);
         BackupHistoryFileName(histfilename, state->stoptli, _logSegNo,
                               state->startpoint, wal_segment_size);
  
         seconds_before_warning = 60;
         waits = 0;
  
         while (XLogArchiveIsBusy(lastxlogfilename) ||
                XLogArchiveIsBusy(histfilename))
         {
             CHECK_FOR_INTERRUPTS();
  
             if (!reported_waiting && waits > 5)
             {
                 ereport(NOTICE,
                         (errmsg("base backup done, waiting for required WAL segments to be archived")));
                 reported_waiting = true;
             }
  
             (void) WaitLatch(MyLatch,
                              WL_LATCH_SET | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH,
                              1000L,
                              WAIT_EVENT_BACKUP_WAIT_WAL_ARCHIVE);
             ResetLatch(MyLatch);
  
             if (++waits >= seconds_before_warning)
             {
                 seconds_before_warning *= 2;    /* This wraps in >10 years... */
                 ereport(WARNING,
                         (errmsg("still waiting for all required WAL segments to be archived (%d seconds elapsed)",
                                 waits),
                          errhint("Check that your archive_command is executing properly.  "
                                  "You can safely cancel this backup, "
                                  "but the database backup will not be usable without all the WAL segments.")));
             }
         }
  
         ereport(NOTICE,
                 (errmsg("all required WAL segments have been archived")));
     }
     else if (waitforarchive)
         ereport(NOTICE,
                 (errmsg("WAL archiving is not enabled; you must ensure that all required WAL segments are copied through other means to complete the backup")));
 }

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

Referenced by perform_base_backup(), and pg_backup_stop().

◆ get_backup_status()

SessionBackupState get_backup_status ( void )

Definition at line 8524 of file xlog.c.

 {
     return sessionBackupState;
 }

References sessionBackupState.

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

◆ get_sync_bit()

static int get_sync_bit ( int method )

static

Definition at line 8040 of file xlog.c.

 {
     int         o_direct_flag = 0;
  
     /* If fsync is disabled, never open in sync mode */
     if (!enableFsync)
         return 0;
  
     /*
      * Optimize writes by bypassing kernel cache with O_DIRECT when using
      * O_SYNC and O_DSYNC.  But only if archiving and streaming are disabled,
      * otherwise the archive command or walsender process will read the WAL
      * soon after writing it, which is guaranteed to cause a physical read if
      * we bypassed the kernel cache. We also skip the
      * posix_fadvise(POSIX_FADV_DONTNEED) call in XLogFileClose() for the same
      * reason.
      *
      * Never use O_DIRECT in walreceiver process for similar reasons; the WAL
      * written by walreceiver is normally read by the startup process soon
      * after it's written. Also, walreceiver performs unaligned writes, which
      * don't work with O_DIRECT, so it is required for correctness too.
      */
     if (!XLogIsNeeded() && !AmWalReceiverProcess())
         o_direct_flag = PG_O_DIRECT;
  
     switch (method)
     {
             /*
              * enum values for all sync options are defined even if they are
              * not supported on the current platform.  But if not, they are
              * not included in the enum option array, and therefore will never
              * be seen here.
              */
         case SYNC_METHOD_FSYNC:
         case SYNC_METHOD_FSYNC_WRITETHROUGH:
         case SYNC_METHOD_FDATASYNC:
             return 0;
 #ifdef O_SYNC
         case SYNC_METHOD_OPEN:
             return O_SYNC | o_direct_flag;
 #endif
 #ifdef O_DSYNC
         case SYNC_METHOD_OPEN_DSYNC:
             return O_DSYNC | o_direct_flag;
 #endif
         default:
             /* can't happen (unless we are out of sync with option array) */
             elog(ERROR, "unrecognized wal_sync_method: %d", method);
             return 0;           /* silence warning */
     }
 }

References AmWalReceiverProcess, elog(), enableFsync, ERROR, O_DSYNC, PG_O_DIRECT, SYNC_METHOD_FDATASYNC, SYNC_METHOD_FSYNC, SYNC_METHOD_FSYNC_WRITETHROUGH, SYNC_METHOD_OPEN, SYNC_METHOD_OPEN_DSYNC, and XLogIsNeeded.

Referenced by assign_xlog_sync_method(), XLogFileInit(), XLogFileInitInternal(), and XLogFileOpen().

◆ GetFakeLSNForUnloggedRel()

XLogRecPtr GetFakeLSNForUnloggedRel ( void )

Definition at line 4217 of file xlog.c.

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

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

Referenced by gistGetFakeLSN().

◆ GetFlushRecPtr()

XLogRecPtr GetFlushRecPtr ( TimeLineID * insertTLI )

Definition at line 6077 of file xlog.c.

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

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

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

◆ GetFullPageWriteInfo()

void GetFullPageWriteInfo	(	XLogRecPtr *	RedoRecPtr_p,
		bool *	doPageWrites_p
	)

Definition at line 6045 of file xlog.c.

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

References doPageWrites, and RedoRecPtr.

Referenced by XLogCheckBufferNeedsBackup(), and XLogInsert().

◆ GetInsertRecPtr()

XLogRecPtr GetInsertRecPtr ( void )

Definition at line 6060 of file xlog.c.

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

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

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

◆ GetLastImportantRecPtr()

XLogRecPtr GetLastImportantRecPtr ( void )

Definition at line 6117 of file xlog.c.

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

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

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

◆ GetLastSegSwitchData()

pg_time_t GetLastSegSwitchData ( XLogRecPtr * lastSwitchLSN )

Definition at line 6146 of file xlog.c.

 {
     pg_time_t   result;
  
     /* Need WALWriteLock, but shared lock is sufficient */
     LWLockAcquire(WALWriteLock, LW_SHARED);
     result = XLogCtl->lastSegSwitchTime;
     *lastSwitchLSN = XLogCtl->lastSegSwitchLSN;
     LWLockRelease(WALWriteLock);
  
     return result;
 }

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

Referenced by CheckArchiveTimeout().

◆ GetMockAuthenticationNonce()

char* GetMockAuthenticationNonce ( void )

Definition at line 4191 of file xlog.c.

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

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

Referenced by scram_mock_salt().

◆ GetOldestRestartPoint()

void GetOldestRestartPoint	(	XLogRecPtr *	oldrecptr,
		TimeLineID *	oldtli
	)

Definition at line 8888 of file xlog.c.

 {
     LWLockAcquire(ControlFileLock, LW_SHARED);
     *oldrecptr = ControlFile->checkPointCopy.redo;
     *oldtli = ControlFile->checkPointCopy.ThisTimeLineID;
     LWLockRelease(ControlFileLock);
 }

References ControlFileData::checkPointCopy, ControlFile, LW_SHARED, LWLockAcquire(), LWLockRelease(), CheckPoint::redo, and CheckPoint::ThisTimeLineID.

Referenced by ExecuteRecoveryCommand(), and RestoreArchivedFile().

◆ GetRecoveryState()

RecoveryState GetRecoveryState ( void )

Definition at line 5948 of file xlog.c.

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

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

Referenced by XLogArchiveCheckDone().

◆ GetRedoRecPtr()

XLogRecPtr GetRedoRecPtr ( void )

Definition at line 6015 of file xlog.c.

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

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

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

◆ GetSystemIdentifier()

uint64 GetSystemIdentifier ( void )

Definition at line 4181 of file xlog.c.

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

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

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

◆ GetWALAvailability()

WALAvailability GetWALAvailability ( XLogRecPtr targetLSN )

Definition at line 7350 of file xlog.c.

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

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

Referenced by pg_get_replication_slots().

◆ GetWALInsertionTimeLine()

TimeLineID GetWALInsertionTimeLine ( void )

Definition at line 6100 of file xlog.c.

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

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

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

◆ GetXLogBuffer()

static char * GetXLogBuffer	(	XLogRecPtr	ptr,
		TimeLineID	tli
	)

static

Definition at line 1537 of file xlog.c.

 {
     int         idx;
     XLogRecPtr  endptr;
     static uint64 cachedPage = 0;
     static char *cachedPos = NULL;
     XLogRecPtr  expectedEndPtr;
  
     /*
      * Fast path for the common case that we need to access again the same
      * page as last time.
      */
     if (ptr / XLOG_BLCKSZ == cachedPage)
     {
         Assert(((XLogPageHeader) cachedPos)->xlp_magic == XLOG_PAGE_MAGIC);
         Assert(((XLogPageHeader) cachedPos)->xlp_pageaddr == ptr - (ptr % XLOG_BLCKSZ));
         return cachedPos + ptr % XLOG_BLCKSZ;
     }
  
     /*
      * The XLog buffer cache is organized so that a page is always loaded to a
      * particular buffer.  That way we can easily calculate the buffer a given
      * page must be loaded into, from the XLogRecPtr alone.
      */
     idx = XLogRecPtrToBufIdx(ptr);
  
     /*
      * See what page is loaded in the buffer at the moment. It could be the
      * page we're looking for, or something older. It can't be anything newer
      * - that would imply the page we're looking for has already been written
      * out to disk and evicted, and the caller is responsible for making sure
      * that doesn't happen.
      *
      * However, we don't hold a lock while we read the value. If someone has
      * just initialized the page, it's possible that we get a "torn read" of
      * the XLogRecPtr if 64-bit fetches are not atomic on this platform. In
      * that case we will see a bogus value. That's ok, we'll grab the mapping
      * lock (in AdvanceXLInsertBuffer) and retry if we see anything else than
      * the page we're looking for. But it means that when we do this unlocked
      * read, we might see a value that appears to be ahead of the page we're
      * looking for. Don't PANIC on that, until we've verified the value while
      * holding the lock.
      */
     expectedEndPtr = ptr;
     expectedEndPtr += XLOG_BLCKSZ - ptr % XLOG_BLCKSZ;
  
     endptr = XLogCtl->xlblocks[idx];
     if (expectedEndPtr != endptr)
     {
         XLogRecPtr  initializedUpto;
  
         /*
          * Before calling AdvanceXLInsertBuffer(), which can block, let others
          * know how far we're finished with inserting the record.
          *
          * NB: If 'ptr' points to just after the page header, advertise a
          * position at the beginning of the page rather than 'ptr' itself. If
          * there are no other insertions running, someone might try to flush
          * up to our advertised location. If we advertised a position after
          * the page header, someone might try to flush the page header, even
          * though page might actually not be initialized yet. As the first
          * inserter on the page, we are effectively responsible for making
          * sure that it's initialized, before we let insertingAt to move past
          * the page header.
          */
         if (ptr % XLOG_BLCKSZ == SizeOfXLogShortPHD &&
             XLogSegmentOffset(ptr, wal_segment_size) > XLOG_BLCKSZ)
             initializedUpto = ptr - SizeOfXLogShortPHD;
         else if (ptr % XLOG_BLCKSZ == SizeOfXLogLongPHD &&
                  XLogSegmentOffset(ptr, wal_segment_size) < XLOG_BLCKSZ)
             initializedUpto = ptr - SizeOfXLogLongPHD;
         else
             initializedUpto = ptr;
  
         WALInsertLockUpdateInsertingAt(initializedUpto);
  
         AdvanceXLInsertBuffer(ptr, tli, false);
         endptr = XLogCtl->xlblocks[idx];
  
         if (expectedEndPtr != endptr)
             elog(PANIC, "could not find WAL buffer for %X/%X",
                  LSN_FORMAT_ARGS(ptr));
     }
     else
     {
         /*
          * Make sure the initialization of the page is visible to us, and
          * won't arrive later to overwrite the WAL data we write on the page.
          */
         pg_memory_barrier();
     }
  
     /*
      * Found the buffer holding this page. Return a pointer to the right
      * offset within the page.
      */
     cachedPage = ptr / XLOG_BLCKSZ;
     cachedPos = XLogCtl->pages + idx * (Size) XLOG_BLCKSZ;
  
     Assert(((XLogPageHeader) cachedPos)->xlp_magic == XLOG_PAGE_MAGIC);
     Assert(((XLogPageHeader) cachedPos)->xlp_pageaddr == ptr - (ptr % XLOG_BLCKSZ));
  
     return cachedPos + ptr % XLOG_BLCKSZ;
 }

References AdvanceXLInsertBuffer(), Assert(), elog(), idx(), LSN_FORMAT_ARGS, XLogCtlData::pages, PANIC, pg_memory_barrier, SizeOfXLogLongPHD, SizeOfXLogShortPHD, wal_segment_size, WALInsertLockUpdateInsertingAt(), XLogCtlData::xlblocks, XLOG_PAGE_MAGIC, XLogCtl, XLogRecPtrToBufIdx, and XLogSegmentOffset.

Referenced by CopyXLogRecordToWAL(), and CreateOverwriteContrecordRecord().

◆ GetXLogInsertRecPtr()

XLogRecPtr GetXLogInsertRecPtr ( void )

Definition at line 8858 of file xlog.c.

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

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

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

◆ GetXLogWriteRecPtr()

XLogRecPtr GetXLogWriteRecPtr ( void )

Definition at line 8874 of file xlog.c.

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

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

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

◆ InitControlFile()

static void InitControlFile ( uint64 sysidentifier )

static

Definition at line 3846 of file xlog.c.

 {
     char        mock_auth_nonce[MOCK_AUTH_NONCE_LEN];
  
     /*
      * Generate a random nonce. This is used for authentication requests that
      * will fail because the user does not exist. The nonce is used to create
      * a genuine-looking password challenge for the non-existent user, in lieu
      * of an actual stored password.
      */
     if (!pg_strong_random(mock_auth_nonce, MOCK_AUTH_NONCE_LEN))
         ereport(PANIC,
                 (errcode(ERRCODE_INTERNAL_ERROR),
                  errmsg("could not generate secret authorization token")));
  
     memset(ControlFile, 0, sizeof(ControlFileData));
     /* Initialize pg_control status fields */
     ControlFile->system_identifier = sysidentifier;
     memcpy(ControlFile->mock_authentication_nonce, mock_auth_nonce, MOCK_AUTH_NONCE_LEN);
     ControlFile->state = DB_SHUTDOWNED;
     ControlFile->unloggedLSN = FirstNormalUnloggedLSN;
  
     /* Set important parameter values for use when replaying WAL */
     ControlFile->MaxConnections = MaxConnections;
     ControlFile->max_worker_processes = max_worker_processes;
     ControlFile->max_wal_senders = max_wal_senders;
     ControlFile->max_prepared_xacts = max_prepared_xacts;
     ControlFile->max_locks_per_xact = max_locks_per_xact;
     ControlFile->wal_level = wal_level;
     ControlFile->wal_log_hints = wal_log_hints;
     ControlFile->track_commit_timestamp = track_commit_timestamp;
     ControlFile->data_checksum_version = bootstrap_data_checksum_version;
 }

References bootstrap_data_checksum_version, ControlFile, ControlFileData::data_checksum_version, DB_SHUTDOWNED, ereport, errcode(), errmsg(), FirstNormalUnloggedLSN, max_locks_per_xact, ControlFileData::max_locks_per_xact, max_prepared_xacts, ControlFileData::max_prepared_xacts, max_wal_senders, ControlFileData::max_wal_senders, max_worker_processes, ControlFileData::max_worker_processes, MaxConnections, ControlFileData::MaxConnections, MOCK_AUTH_NONCE_LEN, ControlFileData::mock_authentication_nonce, PANIC, pg_strong_random(), ControlFileData::state, ControlFileData::system_identifier, track_commit_timestamp, ControlFileData::track_commit_timestamp, ControlFileData::unloggedLSN, wal_level, ControlFileData::wal_level, wal_log_hints, and ControlFileData::wal_log_hints.

Referenced by BootStrapXLOG().

◆ InitializeWalConsistencyChecking()

void InitializeWalConsistencyChecking ( void )

Definition at line 4404 of file xlog.c.

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

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

Referenced by PostgresSingleUserMain(), and PostmasterMain().

◆ InstallXLogFileSegment()

static bool InstallXLogFileSegment	(	XLogSegNo *	segno,
		char *	tmppath,
		bool	find_free,
		XLogSegNo	max_segno,
		TimeLineID	tli
	)

static

Definition at line 3267 of file xlog.c.

 {
     char        path[MAXPGPATH];
     struct stat stat_buf;
  
     Assert(tli != 0);
  
     XLogFilePath(path, tli, *segno, wal_segment_size);
  
     LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
     if (!XLogCtl->InstallXLogFileSegmentActive)
     {
         LWLockRelease(ControlFileLock);
         return false;
     }
  
     if (!find_free)
     {
         /* Force installation: get rid of any pre-existing segment file */
         durable_unlink(path, DEBUG1);
     }
     else
     {
         /* Find a free slot to put it in */
         while (stat(path, &stat_buf) == 0)
         {
             if ((*segno) >= max_segno)
             {
                 /* Failed to find a free slot within specified range */
                 LWLockRelease(ControlFileLock);
                 return false;
             }
             (*segno)++;
             XLogFilePath(path, tli, *segno, wal_segment_size);
         }
     }
  
     Assert(access(path, F_OK) != 0 && errno == ENOENT);
     if (durable_rename(tmppath, path, LOG) != 0)
     {
         LWLockRelease(ControlFileLock);
         /* durable_rename already emitted log message */
         return false;
     }
  
     LWLockRelease(ControlFileLock);
  
     return true;
 }

References Assert(), DEBUG1, durable_rename(), durable_unlink(), XLogCtlData::InstallXLogFileSegmentActive, LOG, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MAXPGPATH, stat, wal_segment_size, XLogCtl, and XLogFilePath().

Referenced by RemoveXlogFile(), XLogFileCopy(), and XLogFileInitInternal().

◆ IsInstallXLogFileSegmentActive()

bool IsInstallXLogFileSegmentActive ( void )

Definition at line 8917 of file xlog.c.

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

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

Referenced by XLogFileRead().

◆ issue_xlog_fsync()

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

Definition at line 8138 of file xlog.c.

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

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

Referenced by XLogWalRcvFlush(), and XLogWrite().

◆ KeepLogSeg()

static void KeepLogSeg	(	XLogRecPtr	recptr,
		XLogSegNo *	logSegNo
	)

static

Definition at line 7434 of file xlog.c.

 {
     XLogSegNo   currSegNo;
     XLogSegNo   segno;
     XLogRecPtr  keep;
  
     XLByteToSeg(recptr, currSegNo, wal_segment_size);
     segno = currSegNo;
  
     /*
      * Calculate how many segments are kept by slots first, adjusting for
      * max_slot_wal_keep_size.
      */
     keep = XLogGetReplicationSlotMinimumLSN();
     if (keep != InvalidXLogRecPtr)
     {
         XLByteToSeg(keep, segno, wal_segment_size);
  
         /* Cap by max_slot_wal_keep_size ... */
         if (max_slot_wal_keep_size_mb >= 0)
         {
             uint64      slot_keep_segs;
  
             slot_keep_segs =
                 ConvertToXSegs(max_slot_wal_keep_size_mb, wal_segment_size);
  
             if (currSegNo - segno > slot_keep_segs)
                 segno = currSegNo - slot_keep_segs;
         }
     }
  
     /* but, keep at least wal_keep_size if that's set */
     if (wal_keep_size_mb > 0)
     {
         uint64      keep_segs;
  
         keep_segs = ConvertToXSegs(wal_keep_size_mb, wal_segment_size);
         if (currSegNo - segno < keep_segs)
         {
             /* avoid underflow, don't go below 1 */
             if (currSegNo <= keep_segs)
                 segno = 1;
             else
                 segno = currSegNo - keep_segs;
         }
     }
  
     /* don't delete WAL segments newer than the calculated segment */
     if (segno < *logSegNo)
         *logSegNo = segno;
 }

References ConvertToXSegs, InvalidXLogRecPtr, max_slot_wal_keep_size_mb, wal_keep_size_mb, wal_segment_size, XLByteToSeg, and XLogGetReplicationSlotMinimumLSN().

Referenced by CreateCheckPoint(), CreateRestartPoint(), and GetWALAvailability().

◆ LocalProcessControlFile()

void LocalProcessControlFile ( bool reset )

Definition at line 4467 of file xlog.c.

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

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

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

◆ LocalSetXLogInsertAllowed()

static int LocalSetXLogInsertAllowed ( void )

static

Definition at line 6000 of file xlog.c.

 {
     int         oldXLogAllowed = LocalXLogInsertAllowed;
  
     LocalXLogInsertAllowed = 1;
  
     return oldXLogAllowed;
 }

References LocalXLogInsertAllowed.

Referenced by CreateCheckPoint(), and StartupXLOG().

◆ LogCheckpointEnd()

static void LogCheckpointEnd ( bool restartpoint )

static

Definition at line 6242 of file xlog.c.

 {
     long        write_msecs,
                 sync_msecs,
                 total_msecs,
                 longest_msecs,
                 average_msecs;
     uint64      average_sync_time;
  
     CheckpointStats.ckpt_end_t = GetCurrentTimestamp();
  
     write_msecs = TimestampDifferenceMilliseconds(CheckpointStats.ckpt_write_t,
                                                   CheckpointStats.ckpt_sync_t);
  
     sync_msecs = TimestampDifferenceMilliseconds(CheckpointStats.ckpt_sync_t,
                                                  CheckpointStats.ckpt_sync_end_t);
  
     /* Accumulate checkpoint timing summary data, in milliseconds. */
     PendingCheckpointerStats.checkpoint_write_time += write_msecs;
     PendingCheckpointerStats.checkpoint_sync_time += sync_msecs;
  
     /*
      * All of the published timing statistics are accounted for.  Only
      * continue if a log message is to be written.
      */
     if (!log_checkpoints)
         return;
  
     total_msecs = TimestampDifferenceMilliseconds(CheckpointStats.ckpt_start_t,
                                                   CheckpointStats.ckpt_end_t);
  
     /*
      * Timing values returned from CheckpointStats are in microseconds.
      * Convert to milliseconds for consistent printing.
      */
     longest_msecs = (long) ((CheckpointStats.ckpt_longest_sync + 999) / 1000);
  
     average_sync_time = 0;
     if (CheckpointStats.ckpt_sync_rels > 0)
         average_sync_time = CheckpointStats.ckpt_agg_sync_time /
             CheckpointStats.ckpt_sync_rels;
     average_msecs = (long) ((average_sync_time + 999) / 1000);
  
     /*
      * ControlFileLock is not required to see ControlFile->checkPoint and
      * ->checkPointCopy here as we are the only updator of those variables at
      * this moment.
      */
     if (restartpoint)
         ereport(LOG,
                 (errmsg("restartpoint complete: wrote %d buffers (%.1f%%); "
                         "%d WAL file(s) added, %d removed, %d recycled; "
                         "write=%ld.%03d s, sync=%ld.%03d s, total=%ld.%03d s; "
                         "sync files=%d, longest=%ld.%03d s, average=%ld.%03d s; "
                         "distance=%d kB, estimate=%d kB; "
                         "lsn=%X/%X, redo lsn=%X/%X",
                         CheckpointStats.ckpt_bufs_written,
                         (double) CheckpointStats.ckpt_bufs_written * 100 / NBuffers,
                         CheckpointStats.ckpt_segs_added,
                         CheckpointStats.ckpt_segs_removed,
                         CheckpointStats.ckpt_segs_recycled,
                         write_msecs / 1000, (int) (write_msecs % 1000),
                         sync_msecs / 1000, (int) (sync_msecs % 1000),
                         total_msecs / 1000, (int) (total_msecs % 1000),
                         CheckpointStats.ckpt_sync_rels,
                         longest_msecs / 1000, (int) (longest_msecs % 1000),
                         average_msecs / 1000, (int) (average_msecs % 1000),
                         (int) (PrevCheckPointDistance / 1024.0),
                         (int) (CheckPointDistanceEstimate / 1024.0),
                         LSN_FORMAT_ARGS(ControlFile->checkPoint),
                         LSN_FORMAT_ARGS(ControlFile->checkPointCopy.redo))));
     else
         ereport(LOG,
                 (errmsg("checkpoint complete: wrote %d buffers (%.1f%%); "
                         "%d WAL file(s) added, %d removed, %d recycled; "
                         "write=%ld.%03d s, sync=%ld.%03d s, total=%ld.%03d s; "
                         "sync files=%d, longest=%ld.%03d s, average=%ld.%03d s; "
                         "distance=%d kB, estimate=%d kB; "
                         "lsn=%X/%X, redo lsn=%X/%X",
                         CheckpointStats.ckpt_bufs_written,
                         (double) CheckpointStats.ckpt_bufs_written * 100 / NBuffers,
                         CheckpointStats.ckpt_segs_added,
                         CheckpointStats.ckpt_segs_removed,
                         CheckpointStats.ckpt_segs_recycled,
                         write_msecs / 1000, (int) (write_msecs % 1000),
                         sync_msecs / 1000, (int) (sync_msecs % 1000),
                         total_msecs / 1000, (int) (total_msecs % 1000),
                         CheckpointStats.ckpt_sync_rels,
                         longest_msecs / 1000, (int) (longest_msecs % 1000),
                         average_msecs / 1000, (int) (average_msecs % 1000),
                         (int) (PrevCheckPointDistance / 1024.0),
                         (int) (CheckPointDistanceEstimate / 1024.0),
                         LSN_FORMAT_ARGS(ControlFile->checkPoint),
                         LSN_FORMAT_ARGS(ControlFile->checkPointCopy.redo))));
 }

Referenced by CreateCheckPoint(), and CreateRestartPoint().

◆ LogCheckpointStart()

static void LogCheckpointStart	(	int	flags,
		bool	restartpoint
	)

static

Definition at line 6210 of file xlog.c.

 {
     if (restartpoint)
         ereport(LOG,
         /* translator: the placeholders show checkpoint options */
                 (errmsg("restartpoint starting:%s%s%s%s%s%s%s%s",
                         (flags & CHECKPOINT_IS_SHUTDOWN) ? " shutdown" : "",
                         (flags & CHECKPOINT_END_OF_RECOVERY) ? " end-of-recovery" : "",
                         (flags & CHECKPOINT_IMMEDIATE) ? " immediate" : "",
                         (flags & CHECKPOINT_FORCE) ? " force" : "",
                         (flags & CHECKPOINT_WAIT) ? " wait" : "",
                         (flags & CHECKPOINT_CAUSE_XLOG) ? " wal" : "",
                         (flags & CHECKPOINT_CAUSE_TIME) ? " time" : "",
                         (flags & CHECKPOINT_FLUSH_ALL) ? " flush-all" : "")));
     else
         ereport(LOG,
         /* translator: the placeholders show checkpoint options */
                 (errmsg("checkpoint starting:%s%s%s%s%s%s%s%s",
                         (flags & CHECKPOINT_IS_SHUTDOWN) ? " shutdown" : "",
                         (flags & CHECKPOINT_END_OF_RECOVERY) ? " end-of-recovery" : "",
                         (flags & CHECKPOINT_IMMEDIATE) ? " immediate" : "",
                         (flags & CHECKPOINT_FORCE) ? " force" : "",
                         (flags & CHECKPOINT_WAIT) ? " wait" : "",
                         (flags & CHECKPOINT_CAUSE_XLOG) ? " wal" : "",
                         (flags & CHECKPOINT_CAUSE_TIME) ? " time" : "",
                         (flags & CHECKPOINT_FLUSH_ALL) ? " flush-all" : "")));
 }

References CHECKPOINT_CAUSE_TIME, CHECKPOINT_CAUSE_XLOG, CHECKPOINT_END_OF_RECOVERY, CHECKPOINT_FLUSH_ALL, CHECKPOINT_FORCE, CHECKPOINT_IMMEDIATE, CHECKPOINT_IS_SHUTDOWN, CHECKPOINT_WAIT, ereport, errmsg(), and LOG.

Referenced by CreateCheckPoint(), and CreateRestartPoint().

◆ PerformRecoveryXLogAction()

static bool PerformRecoveryXLogAction ( void )

static

Definition at line 5862 of file xlog.c.

 {
     bool        promoted = false;
  
     /*
      * Perform a checkpoint to update all our recovery activity to disk.
      *
      * Note that we write a shutdown checkpoint rather than an on-line one.
      * This is not particularly critical, but since we may be assigning a new
      * TLI, using a shutdown checkpoint allows us to have the rule that TLI
      * only changes in shutdown checkpoints, which allows some extra error
      * checking in xlog_redo.
      *
      * In promotion, only create a lightweight end-of-recovery record instead
      * of a full checkpoint. A checkpoint is requested later, after we're
      * fully out of recovery mode and already accepting queries.
      */
     if (ArchiveRecoveryRequested && IsUnderPostmaster &&
         PromoteIsTriggered())
     {
         promoted = true;
  
         /*
          * Insert a special WAL record to mark the end of recovery, since we
          * aren't doing a checkpoint. That means that the checkpointer process
          * may likely be in the middle of a time-smoothed restartpoint and
          * could continue to be for minutes after this.  That sounds strange,
          * but the effect is roughly the same and it would be stranger to try
          * to come out of the restartpoint and then checkpoint. We request a
          * checkpoint later anyway, just for safety.
          */
         CreateEndOfRecoveryRecord();
     }
     else
     {
         RequestCheckpoint(CHECKPOINT_END_OF_RECOVERY |
                           CHECKPOINT_IMMEDIATE |
                           CHECKPOINT_WAIT);
     }
  
     return promoted;
 }

References ArchiveRecoveryRequested, CHECKPOINT_END_OF_RECOVERY, CHECKPOINT_IMMEDIATE, CHECKPOINT_WAIT, CreateEndOfRecoveryRecord(), IsUnderPostmaster, PromoteIsTriggered(), and RequestCheckpoint().

Referenced by StartupXLOG().

◆ PreallocXlogFiles()

static void PreallocXlogFiles	(	XLogRecPtr	endptr,
		TimeLineID	tli
	)

static

Definition at line 3393 of file xlog.c.

 {
     XLogSegNo   _logSegNo;
     int         lf;
     bool        added;
     char        path[MAXPGPATH];
     uint64      offset;
  
     if (!XLogCtl->InstallXLogFileSegmentActive)
         return;                 /* unlocked check says no */
  
     XLByteToPrevSeg(endptr, _logSegNo, wal_segment_size);
     offset = XLogSegmentOffset(endptr - 1, wal_segment_size);
     if (offset >= (uint32) (0.75 * wal_segment_size))
     {
         _logSegNo++;
         lf = XLogFileInitInternal(_logSegNo, tli, &added, path);
         if (lf >= 0)
             close(lf);
         if (added)
             CheckpointStats.ckpt_segs_added++;
     }
 }

References CheckpointStats, CheckpointStatsData::ckpt_segs_added, close, XLogCtlData::InstallXLogFileSegmentActive, MAXPGPATH, wal_segment_size, XLByteToPrevSeg, XLogCtl, XLogFileInitInternal(), and XLogSegmentOffset.

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

◆ ReachedEndOfBackup()

void ReachedEndOfBackup	(	XLogRecPtr	EndRecPtr,
		TimeLineID	tli
	)

Definition at line 5825 of file xlog.c.

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

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

Referenced by CheckRecoveryConsistency().

◆ ReadControlFile()

static void ReadControlFile ( void )

static

Definition at line 3972 of file xlog.c.

 {
     pg_crc32c   crc;
     int         fd;
     static char wal_segsz_str[20];
     int         r;
  
     /*
      * Read data...
      */
     fd = BasicOpenFile(XLOG_CONTROL_FILE,
                        O_RDWR | PG_BINARY);
     if (fd < 0)
         ereport(PANIC,
                 (errcode_for_file_access(),
                  errmsg("could not open file \"%s\": %m",
                         XLOG_CONTROL_FILE)));
  
     pgstat_report_wait_start(WAIT_EVENT_CONTROL_FILE_READ);
     r = read(fd, ControlFile, sizeof(ControlFileData));
     if (r != sizeof(ControlFileData))
     {
         if (r < 0)
             ereport(PANIC,
                     (errcode_for_file_access(),
                      errmsg("could not read file \"%s\": %m",
                             XLOG_CONTROL_FILE)));
         else
             ereport(PANIC,
                     (errcode(ERRCODE_DATA_CORRUPTED),
                      errmsg("could not read file \"%s\": read %d of %zu",
                             XLOG_CONTROL_FILE, r, sizeof(ControlFileData))));
     }
     pgstat_report_wait_end();
  
     close(fd);
  
     /*
      * Check for expected pg_control format version.  If this is wrong, the
      * CRC check will likely fail because we'll be checking the wrong number
      * of bytes.  Complaining about wrong version will probably be more
      * enlightening than complaining about wrong CRC.
      */
  
     if (ControlFile->pg_control_version != PG_CONTROL_VERSION && ControlFile->pg_control_version % 65536 == 0 && ControlFile->pg_control_version / 65536 != 0)
         ereport(FATAL,
                 (errmsg("database files are incompatible with server"),
                  errdetail("The database cluster was initialized with PG_CONTROL_VERSION %d (0x%08x),"
                            " but the server was compiled with PG_CONTROL_VERSION %d (0x%08x).",
                            ControlFile->pg_control_version, ControlFile->pg_control_version,
                            PG_CONTROL_VERSION, PG_CONTROL_VERSION),
                  errhint("This could be a problem of mismatched byte ordering.  It looks like you need to initdb.")));
  
     if (ControlFile->pg_control_version != PG_CONTROL_VERSION)
         ereport(FATAL,
                 (errmsg("database files are incompatible with server"),
                  errdetail("The database cluster was initialized with PG_CONTROL_VERSION %d,"
                            " but the server was compiled with PG_CONTROL_VERSION %d.",
                            ControlFile->pg_control_version, PG_CONTROL_VERSION),
                  errhint("It looks like you need to initdb.")));
  
     /* Now check the CRC. */
     INIT_CRC32C(crc);
     COMP_CRC32C(crc,
                 (char *) ControlFile,
                 offsetof(ControlFileData, crc));
     FIN_CRC32C(crc);
  
     if (!EQ_CRC32C(crc, ControlFile->crc))
         ereport(FATAL,
                 (errmsg("incorrect checksum in control file")));
  
     /*
      * Do compatibility checking immediately.  If the database isn't
      * compatible with the backend executable, we want to abort before we can
      * possibly do any damage.
      */
     if (ControlFile->catalog_version_no != CATALOG_VERSION_NO)
         ereport(FATAL,
                 (errmsg("database files are incompatible with server"),
                  errdetail("The database cluster was initialized with CATALOG_VERSION_NO %d,"
                            " but the server was compiled with CATALOG_VERSION_NO %d.",
                            ControlFile->catalog_version_no, CATALOG_VERSION_NO),
                  errhint("It looks like you need to initdb.")));
     if (ControlFile->maxAlign != MAXIMUM_ALIGNOF)
         ereport(FATAL,
                 (errmsg("database files are incompatible with server"),
                  errdetail("The database cluster was initialized with MAXALIGN %d,"
                            " but the server was compiled with MAXALIGN %d.",
                            ControlFile->maxAlign, MAXIMUM_ALIGNOF),
                  errhint("It looks like you need to initdb.")));
     if (ControlFile->floatFormat != FLOATFORMAT_VALUE)
         ereport(FATAL,
                 (errmsg("database files are incompatible with server"),
                  errdetail("The database cluster appears to use a different floating-point number format than the server executable."),
                  errhint("It looks like you need to initdb.")));
     if (ControlFile->blcksz != BLCKSZ)
         ereport(FATAL,
                 (errmsg("database files are incompatible with server"),
                  errdetail("The database cluster was initialized with BLCKSZ %d,"
                            " but the server was compiled with BLCKSZ %d.",
                            ControlFile->blcksz, BLCKSZ),
                  errhint("It looks like you need to recompile or initdb.")));
     if (ControlFile->relseg_size != RELSEG_SIZE)
         ereport(FATAL,
                 (errmsg("database files are incompatible with server"),
                  errdetail("The database cluster was initialized with RELSEG_SIZE %d,"
                            " but the server was compiled with RELSEG_SIZE %d.",
                            ControlFile->relseg_size, RELSEG_SIZE),
                  errhint("It looks like you need to recompile or initdb.")));
     if (ControlFile->xlog_blcksz != XLOG_BLCKSZ)
         ereport(FATAL,
                 (errmsg("database files are incompatible with server"),
                  errdetail("The database cluster was initialized with XLOG_BLCKSZ %d,"
                            " but the server was compiled with XLOG_BLCKSZ %d.",
                            ControlFile->xlog_blcksz, XLOG_BLCKSZ),
                  errhint("It looks like you need to recompile or initdb.")));
     if (ControlFile->nameDataLen != NAMEDATALEN)
         ereport(FATAL,
                 (errmsg("database files are incompatible with server"),
                  errdetail("The database cluster was initialized with NAMEDATALEN %d,"
                            " but the server was compiled with NAMEDATALEN %d.",
                            ControlFile->nameDataLen, NAMEDATALEN),
                  errhint("It looks like you need to recompile or initdb.")));
     if (ControlFile->indexMaxKeys != INDEX_MAX_KEYS)
         ereport(FATAL,
                 (errmsg("database files are incompatible with server"),
                  errdetail("The database cluster was initialized with INDEX_MAX_KEYS %d,"
                            " but the server was compiled with INDEX_MAX_KEYS %d.",
                            ControlFile->indexMaxKeys, INDEX_MAX_KEYS),
                  errhint("It looks like you need to recompile or initdb.")));
     if (ControlFile->toast_max_chunk_size != TOAST_MAX_CHUNK_SIZE)
         ereport(FATAL,
                 (errmsg("database files are incompatible with server"),
                  errdetail("The database cluster was initialized with TOAST_MAX_CHUNK_SIZE %d,"
                            " but the server was compiled with TOAST_MAX_CHUNK_SIZE %d.",
                            ControlFile->toast_max_chunk_size, (int) TOAST_MAX_CHUNK_SIZE),
                  errhint("It looks like you need to recompile or initdb.")));
     if (ControlFile->loblksize != LOBLKSIZE)
         ereport(FATAL,
                 (errmsg("database files are incompatible with server"),
                  errdetail("The database cluster was initialized with LOBLKSIZE %d,"
                            " but the server was compiled with LOBLKSIZE %d.",
                            ControlFile->loblksize, (int) LOBLKSIZE),
                  errhint("It looks like you need to recompile or initdb.")));
  
 #ifdef USE_FLOAT8_BYVAL
     if (ControlFile->float8ByVal != true)
         ereport(FATAL,
                 (errmsg("database files are incompatible with server"),
                  errdetail("The database cluster was initialized without USE_FLOAT8_BYVAL"
                            " but the server was compiled with USE_FLOAT8_BYVAL."),
                  errhint("It looks like you need to recompile or initdb.")));
 #else
     if (ControlFile->float8ByVal != false)
         ereport(FATAL,
                 (errmsg("database files are incompatible with server"),
                  errdetail("The database cluster was initialized with USE_FLOAT8_BYVAL"
                            " but the server was compiled without USE_FLOAT8_BYVAL."),
                  errhint("It looks like you need to recompile or initdb.")));
 #endif
  
     wal_segment_size = ControlFile->xlog_seg_size;
  
     if (!IsValidWalSegSize(wal_segment_size))
         ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                         errmsg_plural("WAL segment size must be a power of two between 1 MB and 1 GB, but the control file specifies %d byte",
                                       "WAL segment size must be a power of two between 1 MB and 1 GB, but the control file specifies %d bytes",
                                       wal_segment_size,
                                       wal_segment_size)));
  
     snprintf(wal_segsz_str, sizeof(wal_segsz_str), "%d", wal_segment_size);
     SetConfigOption("wal_segment_size", wal_segsz_str, PGC_INTERNAL,
                     PGC_S_DYNAMIC_DEFAULT);
  
     /* check and update variables dependent on wal_segment_size */
     if (ConvertToXSegs(min_wal_size_mb, wal_segment_size) < 2)
         ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                         errmsg("\"min_wal_size\" must be at least twice \"wal_segment_size\"")));
  
     if (ConvertToXSegs(max_wal_size_mb, wal_segment_size) < 2)
         ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                         errmsg("\"max_wal_size\" must be at least twice \"wal_segment_size\"")));
  
     UsableBytesInSegment =
         (wal_segment_size / XLOG_BLCKSZ * UsableBytesInPage) -
         (SizeOfXLogLongPHD - SizeOfXLogShortPHD);
  
     CalculateCheckpointSegments();
  
     /* Make the initdb settings visible as GUC variables, too */
     SetConfigOption("data_checksums", DataChecksumsEnabled() ? "yes" : "no",
                     PGC_INTERNAL, PGC_S_DYNAMIC_DEFAULT);
 }

Data Structures

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ BootstrapTimeLineID

◆ ConvertToXSegs

◆ INSERT_FREESPACE

◆ NextBufIdx

◆ NUM_XLOGINSERT_LOCKS

◆ UsableBytesInPage

◆ XLogRecPtrToBufIdx

Typedef Documentation

◆ WALInsertLockPadded

◆ XLogCtlData

◆ XLogCtlInsert

◆ XLogwrtResult

◆ XLogwrtRqst

Function Documentation

◆ AdvanceXLInsertBuffer()

◆ assign_checkpoint_completion_target()

◆ assign_max_wal_size()

◆ assign_wal_consistency_checking()

◆ assign_xlog_sync_method()

◆ BootStrapXLOG()

◆ CalculateCheckpointSegments()

◆ check_wal_buffers()

◆ check_wal_consistency_checking()

◆ CheckPointGuts()

◆ CheckRequiredParameterValues()

◆ CheckXLogRemoved()

◆ CleanupAfterArchiveRecovery()

◆ CleanupBackupHistory()

◆ CopyXLogRecordToWAL()

◆ CreateCheckPoint()

◆ CreateEndOfRecoveryRecord()

◆ CreateOverwriteContrecordRecord()

◆ CreateRestartPoint()

◆ DataChecksumsEnabled()

◆ do_pg_abort_backup()

◆ do_pg_backup_start()

◆ do_pg_backup_stop()

◆ get_backup_status()

◆ get_sync_bit()

◆ GetFakeLSNForUnloggedRel()

◆ GetFlushRecPtr()

◆ GetFullPageWriteInfo()

◆ GetInsertRecPtr()

◆ GetLastImportantRecPtr()

◆ GetLastSegSwitchData()

◆ GetMockAuthenticationNonce()

◆ GetOldestRestartPoint()

◆ GetRecoveryState()

◆ GetRedoRecPtr()

◆ GetSystemIdentifier()

◆ GetWALAvailability()

◆ GetWALInsertionTimeLine()

◆ GetXLogBuffer()

◆ GetXLogInsertRecPtr()

◆ GetXLogWriteRecPtr()

◆ InitControlFile()

◆ InitializeWalConsistencyChecking()

◆ InstallXLogFileSegment()

◆ IsInstallXLogFileSegmentActive()

◆ issue_xlog_fsync()

◆ KeepLogSeg()

◆ LocalProcessControlFile()

◆ LocalSetXLogInsertAllowed()

◆ LogCheckpointEnd()

◆ LogCheckpointStart()

◆ PerformRecoveryXLogAction()

◆ PreallocXlogFiles()

◆ ReachedEndOfBackup()

◆ ReadControlFile()