/*-------------------------------------------------------------------------

 *

 * xlog.c

 *    PostgreSQL write-ahead log manager

 *

 * The Write-Ahead Log (WAL) functionality is split into several source

 * files, in addition to this one:

 *

 * xloginsert.c - Functions for constructing WAL records

 * xlogrecovery.c - WAL recovery and standby code

 * xlogreader.c - Facility for reading WAL files and parsing WAL records

 * xlogutils.c - Helper functions for WAL redo routines

 *

 * This file contains functions for coordinating database startup and

 * checkpointing, and managing the write-ahead log buffers when the

 * system is running.

 *

 * StartupXLOG() is the main entry point of the startup process.  It

 * coordinates database startup, performing WAL recovery, and the

 * transition from WAL recovery into normal operations.

 *

 * XLogInsertRecord() inserts a WAL record into the WAL buffers.  Most

 * callers should not call this directly, but use the functions in

 * xloginsert.c to construct the WAL record.  XLogFlush() can be used

 * to force the WAL to disk.

 *

 * In addition to those, there are many other functions for interrogating

 * the current system state, and for starting/stopping backups.

 *

 *

 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group

 * Portions Copyright (c) 1994, Regents of the University of California

 *

 * src/backend/access/transam/xlog.c

 *

 *-------------------------------------------------------------------------

 */

#include "postgres.h"

#include <ctype.h>

#include <math.h>

#include <time.h>

#include <fcntl.h>

#include <sys/stat.h>

#include <sys/time.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/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 "postmaster/bgwriter.h"

#include "postmaster/startup.h"

#include "postmaster/walsummarizer.h"

#include "postmaster/walwriter.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/predicate.h"

#include "storage/proc.h"

#include "storage/procarray.h"

#include "storage/reinit.h"

#include "storage/spin.h"

#include "storage/sync.h"

#include "utils/guc_hooks.h"

#include "utils/guc_tables.h"

#include "utils/injection_point.h"

#include "utils/ps_status.h"

#include "utils/relmapper.h"

#include "utils/snapmgr.h"

#include "utils/timeout.h"

#include "utils/timestamp.h"

#include "utils/varlena.h"

#ifdef WAL_DEBUG

#include "utils/memutils.h"

#endif

/* timeline ID to be used when bootstrapping */

#define BootstrapTimeLineID   1

/* User-settable parameters */

int     max_wal_size_mb = 1024; /* 1 GB */

int     min_wal_size_mb = 80; /* 80 MB */

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     wal_sync_method = DEFAULT_WAL_SYNC_METHOD;

int     wal_level = WAL_LEVEL_REPLICA;

int     CommitDelay = 0;  /* precommit delay in microseconds */

int     CommitSiblings = 5; /* # concurrent xacts needed to sleep */

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;

#ifdef WAL_DEBUG

bool    XLOG_DEBUG = false;

#endif

int     wal_segment_size = DEFAULT_XLOG_SEG_SIZE;

/*

 * Number of WAL insertion locks to use. A higher value allows more insertions

 * to happen concurrently, but adds some CPU overhead to flushing the WAL,

 * which needs to iterate all the locks.

 */

#define NUM_XLOGINSERT_LOCKS  8

/*

 * Max distance from last checkpoint, before triggering a new xlog-based

 * checkpoint.

 */

int     CheckPointSegments;

/* Estimated distance between checkpoints, in bytes */

static double CheckPointDistanceEstimate = 0;

static double PrevCheckPointDistance = 0;

/*

 * Track whether there were any deferred checks for custom resource managers

 * specified in wal_consistency_checking.

 */

static bool check_wal_consistency_checking_deferred = false;

/*

 * GUC support

 */

const struct config_enum_entry wal_sync_method_options[] = {

  {"fsync", WAL_SYNC_METHOD_FSYNC, false},

#ifdef HAVE_FSYNC_WRITETHROUGH

  {"fsync_writethrough", WAL_SYNC_METHOD_FSYNC_WRITETHROUGH, false},

#endif

  {"fdatasync", WAL_SYNC_METHOD_FDATASYNC, false},

#ifdef O_SYNC

  {"open_sync", WAL_SYNC_METHOD_OPEN, false},

#endif

#ifdef O_DSYNC

  {"open_datasync", WAL_SYNC_METHOD_OPEN_DSYNC, false},

#endif

  {NULL, 0, false}

};

/*

 * Although only "on", "off", and "always" are documented,

 * we accept all the likely variants of "on" and "off".

 */

const struct config_enum_entry archive_mode_options[] = {

  {"always", ARCHIVE_MODE_ALWAYS, false},

  {"on", ARCHIVE_MODE_ON, false},

  {"off", ARCHIVE_MODE_OFF, false},

  {"true", ARCHIVE_MODE_ON, true},

  {"false", ARCHIVE_MODE_OFF, true},

  {"yes", ARCHIVE_MODE_ON, true},

  {"no", ARCHIVE_MODE_OFF, true},

  {"1", ARCHIVE_MODE_ON, true},

  {"0", ARCHIVE_MODE_OFF, true},

  {NULL, 0, false}

};

/*

 * Statistics for current checkpoint are collected in this global struct.

 * Because only the checkpointer or a stand-alone backend can perform

 * checkpoints, this will be unused in normal backends.

 */

CheckpointStatsData CheckpointStats;

/*

 * During recovery, lastFullPageWrites keeps track of full_page_writes that

 * the replayed WAL records indicate. It's initialized with full_page_writes

 * that the recovery starting checkpoint record indicates, and then updated

 * each time XLOG_FPW_CHANGE record is replayed.

 */

static bool lastFullPageWrites;

/*

 * Local copy of the state tracked by SharedRecoveryState in shared memory,

 * It is false if SharedRecoveryState is RECOVERY_STATE_DONE.  True actually

 * means "not known, need to check the shared state".

 */

static bool LocalRecoveryInProgress = true;

/*

 * Local state for XLogInsertAllowed():

 *    1: unconditionally allowed to insert XLOG

 *    0: unconditionally not allowed to insert XLOG

 *    -1: must check RecoveryInProgress(); disallow until it is false

 * Most processes start with -1 and transition to 1 after seeing that recovery

 * is not in progress.  But we can also force the value for special cases.

 * The coding in XLogInsertAllowed() depends on the first two of these states

 * being numerically the same as bool true and false.

 */

static int  LocalXLogInsertAllowed = -1;

/*

 * ProcLastRecPtr points to the start of the last XLOG record inserted by the

 * current backend.  It is updated for all inserts.  XactLastRecEnd points to

 * end+1 of the last record, and is reset when we end a top-level transaction,

 * or start a new one; so it can be used to tell if the current transaction has

 * created any XLOG records.

 *

 * While in parallel mode, this may not be fully up to date.  When committing,

 * a transaction can assume this covers all xlog records written either by the

 * user backend or by any parallel worker which was present at any point during

 * the transaction.  But when aborting, or when still in parallel mode, other

 * parallel backends may have written WAL records at later LSNs than the value

 * stored here.  The parallel leader advances its own copy, when necessary,

 * in WaitForParallelWorkersToFinish.

 */

XLogRecPtr  ProcLastRecPtr = InvalidXLogRecPtr;

XLogRecPtr  XactLastRecEnd = InvalidXLogRecPtr;

XLogRecPtr  XactLastCommitEnd = InvalidXLogRecPtr;

/*

 * RedoRecPtr is this backend's local copy of the REDO record pointer

 * (which is almost but not quite the same as a pointer to the most recent

 * CHECKPOINT record).  We update this from the shared-memory copy,

 * XLogCtl->Insert.RedoRecPtr, whenever we can safely do so (ie, when we

 * hold an insertion lock).  See XLogInsertRecord for details.  We are also

 * allowed to update from XLogCtl->RedoRecPtr if we hold the info_lck;

 * see GetRedoRecPtr.

 *

 * NB: Code that uses this variable must be prepared not only for the

 * possibility that it may be arbitrarily out of date, but also for the

 * possibility that it might be set to InvalidXLogRecPtr. We used to

 * initialize it as a side effect of the first call to RecoveryInProgress(),

 * which meant that most code that might use it could assume that it had a

 * real if perhaps stale value. That's no longer the case.

 */

static XLogRecPtr RedoRecPtr;

/*

 * doPageWrites is this backend's local copy of (fullPageWrites ||

 * runningBackups > 0).  It is used together with RedoRecPtr to decide whether

 * a full-page image of a page need to be taken.

 *

 * NB: Initially this is false, and there's no guarantee that it will be

 * initialized to any other value before it is first used. Any code that

 * makes use of it must recheck the value after obtaining a WALInsertLock,

 * and respond appropriately if it turns out that the previous value wasn't

 * accurate.

 */

static bool doPageWrites;

/*----------

 * Shared-memory data structures for XLOG control

 *

 * LogwrtRqst indicates a byte position that we need to write and/or fsync

 * the log up to (all records before that point must be written or fsynced).

 * The positions already written/fsynced are maintained in logWriteResult

 * and logFlushResult using atomic access.

 * In addition to the shared variable, each backend has a private copy of

 * both in LogwrtResult, which is updated when convenient.

 *

 * The request bookkeeping is simpler: there is a shared XLogCtl->LogwrtRqst

 * (protected by info_lck), but we don't need to cache any copies of it.

 *

 * info_lck is only held long enough to read/update the protected variables,

 * so it's a plain spinlock.  The other locks are held longer (potentially

 * over I/O operations), so we use LWLocks for them.  These locks are:

 *

 * WALWriteLock: must be held to write WAL buffers to disk (XLogWrite or

 * XLogFlush).

 *

 * ControlFileLock: must be held to read/update control file or create

 * new log file.

 *

 *----------

 */

typedef struct XLogwrtRqst

{

  XLogRecPtr  Write;      /* last byte + 1 to write out */

  XLogRecPtr  Flush;      /* last byte + 1 to flush */

} XLogwrtRqst;

typedef struct XLogwrtResult

{

  XLogRecPtr  Write;      /* last byte + 1 written out */

  XLogRecPtr  Flush;      /* last byte + 1 flushed */

} XLogwrtResult;

/*

 * Inserting to WAL is protected by a small fixed number of WAL insertion

 * locks. To insert to the WAL, you must hold one of the locks - it doesn't

 * matter which one. To lock out other concurrent insertions, you must hold

 * of them. Each WAL insertion lock consists of a lightweight lock, plus an

 * indicator of how far the insertion has progressed (insertingAt).

 *

 * The insertingAt values are read when a process wants to flush WAL from

 * the in-memory buffers to disk, to check that all the insertions to the

 * region the process is about to write out have finished. You could simply

 * wait for all currently in-progress insertions to finish, but the

 * insertingAt indicator allows you to ignore insertions to later in the WAL,

 * so that you only wait for the insertions that are modifying the buffers

 * you're about to write out.

 *

 * This isn't just an optimization. If all the WAL buffers are dirty, an

 * inserter that's holding a WAL insert lock might need to evict an old WAL

 * buffer, which requires flushing the WAL. If it's possible for an inserter

 * to block on another inserter unnecessarily, deadlock can arise when two

 * inserters holding a WAL insert lock wait for each other to finish their

 * insertion.

 *

 * Small WAL records that don't cross a page boundary never update the value,

 * the WAL record is just copied to the page and the lock is released. But

 * to avoid the deadlock-scenario explained above, the indicator is always

 * updated before sleeping while holding an insertion lock.

 *

 * lastImportantAt contains the LSN of the last important WAL record inserted

 * using a given lock. This value is used to detect if there has been

 * important WAL activity since the last time some action, like a checkpoint,

 * was performed - allowing to not repeat the action if not. The LSN is

 * updated for all insertions, unless the XLOG_MARK_UNIMPORTANT flag was

 * set. lastImportantAt is never cleared, only overwritten by the LSN of newer

 * records.  Tracking the WAL activity directly in WALInsertLock has the

 * advantage of not needing any additional locks to update the value.

 */

typedef struct

{

  LWLock    lock;

  pg_atomic_uint64 insertingAt;

  XLogRecPtr  lastImportantAt;

} WALInsertLock;

/*

 * All the WAL insertion locks are allocated as an array in shared memory. We

 * force the array stride to be a power of 2, which saves a few cycles in

 * indexing, but more importantly also ensures that individual slots don't

 * cross cache line boundaries. (Of course, we have to also ensure that the

 * array start address is suitably aligned.)

 */

typedef union WALInsertLockPadded

{

  WALInsertLock l;

  char    pad[PG_CACHE_LINE_SIZE];

} WALInsertLockPadded;

/*

 * Session status of running backup, used for sanity checks in SQL-callable

 * functions to start and stop backups.

 */

static SessionBackupState sessionBackupState = SESSION_BACKUP_NONE;

/*

 * Shared state data for WAL insertion.

 */

typedef struct XLogCtlInsert

{

  slock_t   insertpos_lck;  /* protects CurrBytePos and PrevBytePos */

  /*

   * CurrBytePos is the end of reserved WAL. The next record will be

   * inserted at that position. PrevBytePos is the start position of the

   * previously inserted (or rather, reserved) record - it is copied to the

   * prev-link of the next record. These are stored as "usable byte

   * positions" rather than XLogRecPtrs (see XLogBytePosToRecPtr()).

   */

  uint64    CurrBytePos;

  uint64    PrevBytePos;

  /*

   * Make sure the above heavily-contended spinlock and byte positions are

   * on their own cache line. In particular, the RedoRecPtr and full page

   * write variables below should be on a different cache line. They are

   * read on every WAL insertion, but updated rarely, and we don't want

   * those reads to steal the cache line containing Curr/PrevBytePos.

   */

  char    pad[PG_CACHE_LINE_SIZE];

  /*

   * fullPageWrites is the authoritative value used by all backends to

   * determine whether to write full-page image to WAL. This shared value,

   * instead of the process-local fullPageWrites, is required because, when

   * full_page_writes is changed by SIGHUP, we must WAL-log it before it

   * actually affects WAL-logging by backends.  Checkpointer sets at startup

   * or after SIGHUP.

   *

   * To read these fields, you must hold an insertion lock. To modify them,

   * you must hold ALL the locks.

   */

  XLogRecPtr  RedoRecPtr;   /* current redo point for insertions */

  bool    fullPageWrites;

  /*

   * runningBackups is a counter indicating the number of backups currently

   * in progress. lastBackupStart is the latest checkpoint redo location

   * used as a starting point for an online backup.

   */

  int     runningBackups;

  XLogRecPtr  lastBackupStart;

  /*

   * WAL insertion locks.

   */

  WALInsertLockPadded *WALInsertLocks;

} XLogCtlInsert;

/*

 * Total shared-memory state for XLOG.

 */

typedef struct XLogCtlData

{

  XLogCtlInsert Insert;

  /* Protected by info_lck: */

  XLogwrtRqst LogwrtRqst;

  XLogRecPtr  RedoRecPtr;   /* a recent copy of Insert->RedoRecPtr */

  FullTransactionId ckptFullXid;  /* nextXid of latest checkpoint */

  XLogRecPtr  asyncXactLSN; /* LSN of newest async commit/abort */

  XLogRecPtr  replicationSlotMinLSN;  /* oldest LSN needed by any slot */

  XLogSegNo lastRemovedSegNo; /* latest removed/recycled XLOG segment */

  /* Fake LSN counter, for unlogged relations. */

  pg_atomic_uint64 unloggedLSN;

  /* Time and LSN of last xlog segment switch. Protected by WALWriteLock. */

  pg_time_t lastSegSwitchTime;

  XLogRecPtr  lastSegSwitchLSN;

  /* These are accessed using atomics -- info_lck not needed */

  pg_atomic_uint64 logInsertResult; /* last byte + 1 inserted to buffers */

  pg_atomic_uint64 logWriteResult;  /* last byte + 1 written out */

  pg_atomic_uint64 logFlushResult;  /* last byte + 1 flushed */

  /*

   * First initialized page in the cache (first byte position).

   */

  XLogRecPtr  InitializedFrom;

  /*

   * Latest reserved for initialization page in the cache (last byte

   * position + 1).

   *

   * To change the identity of a buffer, you need to advance

   * InitializeReserved first.  To change the identity of a buffer that's

   * still dirty, the old page needs to be written out first, and for that

   * you need WALWriteLock, and you need to ensure that there are no

   * in-progress insertions to the page by calling

   * WaitXLogInsertionsToFinish().

   */

  pg_atomic_uint64 InitializeReserved;

  /*

   * Latest initialized page in the cache (last byte position + 1).

   *

   * InitializedUpTo is updated after the buffer initialization.  After

   * update, waiters got notification using InitializedUpToCondVar.

   */

  pg_atomic_uint64 InitializedUpTo;

  ConditionVariable InitializedUpToCondVar;

  /*

   * These values do not change after startup, although the pointed-to pages

   * and xlblocks values certainly do.  xlblocks values are changed

   * lock-free according to the check for the xlog write position and are

   * accompanied by changes of InitializeReserved and InitializedUpTo.

   */

  char     *pages;      /* buffers for unwritten XLOG pages */

  pg_atomic_uint64 *xlblocks; /* 1st byte ptr-s + XLOG_BLCKSZ */

  int     XLogCacheBlck;  /* highest allocated xlog buffer index */

  /*

   * InsertTimeLineID is the timeline into which new WAL is being inserted

   * and flushed. It is zero during recovery, and does not change once set.

   *

   * If we create a new timeline when the system was started up,

   * PrevTimeLineID is the old timeline's ID that we forked off from.

   * Otherwise it's equal to InsertTimeLineID.

   *

   * We set these fields while holding info_lck. Most that reads these

   * values knows that recovery is no longer in progress and so can safely

   * read the value without a lock, but code that could be run either during

   * or after recovery can take info_lck while reading these values.

   */

  TimeLineID  InsertTimeLineID;

  TimeLineID  PrevTimeLineID;

  /*

   * SharedRecoveryState indicates if we're still in crash or archive

   * recovery.  Protected by info_lck.

   */

  RecoveryState SharedRecoveryState;

  /*

   * InstallXLogFileSegmentActive indicates whether the checkpointer should

   * arrange for future segments by recycling and/or PreallocXlogFiles().

   * Protected by ControlFileLock.  Only the startup process changes it.  If

   * true, anyone can use InstallXLogFileSegment().  If false, the startup

   * process owns the exclusive right to install segments, by reading from

   * the archive and possibly replacing existing files.

   */

  bool    InstallXLogFileSegmentActive;

  /*

   * WalWriterSleeping indicates whether the WAL writer is currently in

   * low-power mode (and hence should be nudged if an async commit occurs).

   * Protected by info_lck.

   */

  bool    WalWriterSleeping;

  /*

   * During recovery, we keep a copy of the latest checkpoint record here.

   * lastCheckPointRecPtr points to start of checkpoint record and

   * lastCheckPointEndPtr points to end+1 of checkpoint record.  Used by the

   * checkpointer when it wants to create a restartpoint.

   *

   * Protected by info_lck.

   */

  XLogRecPtr  lastCheckPointRecPtr;

  XLogRecPtr  lastCheckPointEndPtr;

  CheckPoint  lastCheckPoint;

  /*

   * lastFpwDisableRecPtr points to the start of the last replayed

   * XLOG_FPW_CHANGE record that instructs full_page_writes is disabled.

   */

  XLogRecPtr  lastFpwDisableRecPtr;

  slock_t   info_lck;   /* locks shared variables shown above */

} XLogCtlData;

/*

 * Classification of XLogInsertRecord operations.

 */

typedef enum

{

  WALINSERT_NORMAL,

  WALINSERT_SPECIAL_SWITCH,

  WALINSERT_SPECIAL_CHECKPOINT

} WalInsertClass;

static XLogCtlData *XLogCtl = NULL;

/* a private copy of XLogCtl->Insert.WALInsertLocks, for convenience */

static WALInsertLockPadded *WALInsertLocks = NULL;

/*

 * We maintain an image of pg_control in shared memory.

 */

static ControlFileData *ControlFile = NULL;

/*

 * Calculate the amount of space left on the page after 'endptr'. Beware

 * multiple evaluation!

 */

#define INSERT_FREESPACE(endptr)  \

  (((endptr) % XLOG_BLCKSZ == 0) ? 0 : (XLOG_BLCKSZ - (endptr) % XLOG_BLCKSZ))

/* Macro to advance to next buffer index. */

#define NextBufIdx(idx)   \

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

/*

 * XLogRecPtrToBufIdx returns the index of the WAL buffer that holds, or

 * would hold if it was in cache, the page containing 'recptr'.

 */

#define XLogRecPtrToBufIdx(recptr)  \

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

/*

 * These are the number of bytes in a WAL page usable for WAL data.

 */

#define UsableBytesInPage (XLOG_BLCKSZ - SizeOfXLogShortPHD)

/*

 * Convert values of GUCs measured in megabytes to equiv. segment count.

 * Rounds down.

 */

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

/* The number of bytes in a WAL segment usable for WAL data. */

static int  UsableBytesInSegment;

/*

 * Private, possibly out-of-date copy of shared LogwrtResult.

 * See discussion above.

 */

static XLogwrtResult LogwrtResult = {0, 0};

/*

 * Update local copy of shared XLogCtl->log{Write,Flush}Result

 *

 * It's critical that Flush always trails Write, so the order of the reads is

 * important, as is the barrier.  See also XLogWrite.

 */

#define RefreshXLogWriteResult(_target) \

  do { \

    _target.Flush = pg_atomic_read_u64(&XLogCtl->logFlushResult); \

    pg_read_barrier(); \

    _target.Write = pg_atomic_read_u64(&XLogCtl->logWriteResult); \

  } while (0)

/*

 * openLogFile is -1 or a kernel FD for an open log file segment.

 * openLogSegNo identifies the segment, and openLogTLI the corresponding TLI.

 * These variables are only used to write the XLOG, and so will normally refer

 * to the active segment.

 *

 * Note: call Reserve/ReleaseExternalFD to track consumption of this FD.

 */

static int  openLogFile = -1;

static XLogSegNo openLogSegNo = 0;

static TimeLineID openLogTLI = 0;

/*

 * Local copies of equivalent fields in the control file.  When running

 * crash recovery, LocalMinRecoveryPoint is set to InvalidXLogRecPtr as we

 * expect to replay all the WAL available, and updateMinRecoveryPoint is

 * switched to false to prevent any updates while replaying records.

 * Those values are kept consistent as long as crash recovery runs.

 */

static XLogRecPtr LocalMinRecoveryPoint;

static TimeLineID LocalMinRecoveryPointTLI;

static bool updateMinRecoveryPoint = true;

/* For WALInsertLockAcquire/Release functions */

static int  MyLockNo = 0;

static bool holdingAllLocks = false;

#ifdef WAL_DEBUG

static MemoryContext walDebugCxt = NULL;

#endif

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, uint32 data_checksum_version);

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

/*

 * Insert an XLOG record represented by an already-constructed chain of data

 * chunks.  This is a low-level routine; to construct the WAL record header

 * and data, use the higher-level routines in xloginsert.c.

 *

 * If 'fpw_lsn' is valid, it is the oldest LSN among the pages that this

 * WAL record applies to, that were not included in the record as full page

 * images.  If fpw_lsn <= RedoRecPtr, the function does not perform the

 * insertion and returns InvalidXLogRecPtr.  The caller can then recalculate

 * which pages need a full-page image, and retry.  If fpw_lsn is invalid, the

 * record is always inserted.

 *

 * 'flags' gives more in-depth control on the record being inserted. See

 * XLogSetRecordFlags() for details.

 *

 * 'topxid_included' tells whether the top-transaction id is logged along with

 * current subtransaction. See XLogRecordAssemble().

 *

 * The first XLogRecData in the chain must be for the record header, and its

 * data must be MAXALIGNed.  XLogInsertRecord fills in the xl_prev and

 * xl_crc fields in the header, the rest of the header must already be filled

 * by the caller.

 *

 * Returns XLOG pointer to end of record (beginning of next record).

 * This can be used as LSN for data pages affected by the logged action.

 * (LSN is the XLOG point up to which the XLOG must be flushed to disk

 * before the data page can be written out.  This implements the basic

 * WAL rule "write the log before the data".)

 */

XLogRecPtr

XLogInsertRecord(XLogRecData *rdata,

         XLogRecPtr fpw_lsn,

         uint8 flags,

         int num_fpi,

         bool topxid_included)

{

  XLogCtlInsert *Insert = &XLogCtl->Insert;

  pg_crc32c rdata_crc;

  bool    inserted;

  XLogRecord *rechdr = (XLogRecord *) rdata->data;

  uint8   info = rechdr->xl_info & ~XLR_INFO_MASK;

  WalInsertClass class = WALINSERT_NORMAL;

  XLogRecPtr  StartPos;

  XLogRecPtr  EndPos;

  bool    prevDoPageWrites = doPageWrites;

  TimeLineID  insertTLI;

  /* Does this record type require special handling? */

  if (unlikely(rechdr->xl_rmid == RM_XLOG_ID))

  {

    if (info == XLOG_SWITCH)

      class = WALINSERT_SPECIAL_SWITCH;

    else if (info == XLOG_CHECKPOINT_REDO)

      class = WALINSERT_SPECIAL_CHECKPOINT;

  }

  /* we assume that all of the record header is in the first chunk */

  Assert(rdata->len >= SizeOfXLogRecord);

  /* cross-check on whether we should be here or not */

  if (!XLogInsertAllowed())

    elog(ERROR, "cannot make new WAL entries during recovery");

  /*

   * Given that we're not in recovery, InsertTimeLineID is set and can't

   * change, so we can read it without a lock.

   */

  insertTLI = XLogCtl->InsertTimeLineID;

  /*----------

   *

   * We have now done all the preparatory work we can without holding a

   * lock or modifying shared state. From here on, inserting the new WAL

   * record to the shared WAL buffer cache is a two-step process:

   *

   * 1. Reserve the right amount of space from the WAL. The current head of

   *    reserved space is kept in Insert->CurrBytePos, and is protected by

   *    insertpos_lck.

   *

   * 2. Copy the record to the reserved WAL space. This involves finding the

   *    correct WAL buffer containing the reserved space, and copying the

   *    record in place. This can be done concurrently in multiple processes.

   *

   * To keep track of which insertions are still in-progress, each concurrent

   * inserter acquires an insertion lock. In addition to just indicating that

   * an insertion is in progress, the lock tells others how far the inserter

   * has progressed. There is a small fixed number of insertion locks,

   * determined by NUM_XLOGINSERT_LOCKS. When an inserter crosses a page

   * boundary, it updates the value stored in the lock to the how far it has

   * inserted, to allow the previous buffer to be flushed.

   *

   * Holding onto an insertion lock also protects RedoRecPtr and

   * fullPageWrites from changing until the insertion is finished.

   *

   * Step 2 can usually be done completely in parallel. If the required WAL

   * page is not initialized yet, you have to go through AdvanceXLInsertBuffer,

   * which will ensure it is initialized. But the WAL writer tries to do that

   * ahead of insertions to avoid that from happening in the critical path.

   *

   *----------

   */

  START_CRIT_SECTION();

  if (likely(class == WALINSERT_NORMAL))

  {

    WALInsertLockAcquire();

    /*

     * Check to see if my copy of RedoRecPtr is out of date. If so, may

     * have to go back and have the caller recompute everything. This can

     * only happen just after a checkpoint, so it's better to be slow in

     * this case and fast otherwise.

     *

     * Also check to see if fullPageWrites was just turned on or there's a

     * running backup (which forces full-page writes); if we weren't

     * already doing full-page writes then go back and recompute.

     *

     * If we aren't doing full-page writes then RedoRecPtr doesn't

     * actually affect the contents of the XLOG record, so we'll update

     * our local copy but not force a recomputation.  (If doPageWrites was

     * just turned off, we could recompute the record without full pages,

     * but we choose not to bother.)

     */

    if (RedoRecPtr != Insert->RedoRecPtr)

    {

      Assert(RedoRecPtr < Insert->RedoRecPtr);

      RedoRecPtr = Insert->RedoRecPtr;

    }

    doPageWrites = (Insert->fullPageWrites || Insert->runningBackups > 0);

    if (doPageWrites &&

      (!prevDoPageWrites ||

       (fpw_lsn != InvalidXLogRecPtr && fpw_lsn <= RedoRecPtr)))

    {

      /*

       * Oops, some buffer now needs to be backed up that the caller

       * didn't back up.  Start over.

       */

      WALInsertLockRelease();

      END_CRIT_SECTION();

      return InvalidXLogRecPtr;

    }

    /*

     * Reserve space for the record in the WAL. This also sets the xl_prev

     * pointer.

     */

    ReserveXLogInsertLocation(rechdr->xl_tot_len, &StartPos, &EndPos,

                  &rechdr->xl_prev);

    /* Normal records are always inserted. */

    inserted = true;

  }

  else if (class == WALINSERT_SPECIAL_SWITCH)

  {

    /*

     * In order to insert an XLOG_SWITCH record, we need to hold all of

     * the WAL insertion locks, not just one, so that no one else can

     * begin inserting a record until we've figured out how much space

     * remains in the current WAL segment and claimed all of it.

     *

     * Nonetheless, this case is simpler than the normal cases handled

     * below, which must check for changes in doPageWrites and RedoRecPtr.

     * Those checks are only needed for records that can contain buffer

     * references, and an XLOG_SWITCH record never does.

     */

    Assert(fpw_lsn == InvalidXLogRecPtr);

    WALInsertLockAcquireExclusive();

    inserted = ReserveXLogSwitch(&StartPos, &EndPos, &rechdr->xl_prev);

  }

  else

  {

    Assert(class == WALINSERT_SPECIAL_CHECKPOINT);

    /*

     * We need to update both the local and shared copies of RedoRecPtr,

     * which means that we need to hold all the WAL insertion locks.

     * However, there can't be any buffer references, so as above, we need

     * not check RedoRecPtr before inserting the record; we just need to

     * update it afterwards.

     */

    Assert(fpw_lsn == InvalidXLogRecPtr);

    WALInsertLockAcquireExclusive();

    ReserveXLogInsertLocation(rechdr->xl_tot_len, &StartPos, &EndPos,

                  &rechdr->xl_prev);

    RedoRecPtr = Insert->RedoRecPtr = StartPos;

    inserted = true;

  }

  if (inserted)

  {

    /*

     * Now that xl_prev has been filled in, calculate CRC of the record

     * header.

     */

    rdata_crc = rechdr->xl_crc;

    COMP_CRC32C(rdata_crc, rechdr, offsetof(XLogRecord, xl_crc));

    FIN_CRC32C(rdata_crc);

    rechdr->xl_crc = rdata_crc;

    /*

     * All the record data, including the header, is now ready to be

     * inserted. Copy the record in the space reserved.

     */

    CopyXLogRecordToWAL(rechdr->xl_tot_len,

              class == WALINSERT_SPECIAL_SWITCH, rdata,

              StartPos, EndPos, insertTLI);

    /*

     * Unless record is flagged as not important, update LSN of last

     * important record in the current slot. When holding all locks, just

     * update the first one.

     */

    if ((flags & XLOG_MARK_UNIMPORTANT) == 0)

    {

      int     lockno = holdingAllLocks ? 0 : MyLockNo;

      WALInsertLocks[lockno].l.lastImportantAt = StartPos;

    }

  }

  else

  {

    /*

     * This was an xlog-switch record, but the current insert location was

     * already exactly at the beginning of a segment, so there was no need

     * to do anything.

     */

  }

  /*

   * Done! Let others know that we're finished.

   */

  WALInsertLockRelease();

  END_CRIT_SECTION();

  MarkCurrentTransactionIdLoggedIfAny();

  /*

   * Mark top transaction id is logged (if needed) so that we should not try

   * to log it again with the next WAL record in the current subtransaction.

   */

  if (topxid_included)

    MarkSubxactTopXidLogged();

  /*

   * Update shared LogwrtRqst.Write, if we crossed page boundary.

   */

  if (StartPos / XLOG_BLCKSZ != EndPos / XLOG_BLCKSZ)

  {

    SpinLockAcquire(&XLogCtl->info_lck);

    /* advance global request to include new block(s) */

    if (XLogCtl->LogwrtRqst.Write < EndPos)

      XLogCtl->LogwrtRqst.Write = EndPos;

    SpinLockRelease(&XLogCtl->info_lck);

    RefreshXLogWriteResult(LogwrtResult);

  }

  /*

   * If this was an XLOG_SWITCH record, flush the record and the empty

   * padding space that fills the rest of the segment, and perform

   * end-of-segment actions (eg, notifying archiver).

   */

  if (class == WALINSERT_SPECIAL_SWITCH)

  {

    TRACE_POSTGRESQL_WAL_SWITCH();

    XLogFlush(EndPos);

    /*

     * Even though we reserved the rest of the segment for us, which is

     * reflected in EndPos, we return a pointer to just the end of the

     * xlog-switch record.

     */

    if (inserted)

    {

      EndPos = StartPos + SizeOfXLogRecord;

      if (StartPos / XLOG_BLCKSZ != EndPos / XLOG_BLCKSZ)

      {

        uint64    offset = XLogSegmentOffset(EndPos, wal_segment_size);

        if (offset == EndPos % XLOG_BLCKSZ)

          EndPos += SizeOfXLogLongPHD;

        else

          EndPos += SizeOfXLogShortPHD;

      }

    }

  }

#ifdef WAL_DEBUG

  if (XLOG_DEBUG)

  {

    static XLogReaderState *debug_reader = NULL;

    XLogRecord *record;

    DecodedXLogRecord *decoded;

    StringInfoData buf;

    StringInfoData recordBuf;

    char     *errormsg = NULL;

    MemoryContext oldCxt;

    oldCxt = MemoryContextSwitchTo(walDebugCxt);

    initStringInfo(&buf);

    appendStringInfo(&buf, "INSERT @ %X/%X: ", LSN_FORMAT_ARGS(EndPos));

    /*

     * We have to piece together the WAL record data from the XLogRecData

     * entries, so that we can pass it to the rm_desc function as one

     * contiguous chunk.

     */

    initStringInfo(&recordBuf);

    for (; rdata != NULL; rdata = rdata->next)

      appendBinaryStringInfo(&recordBuf, rdata->data, rdata->len);

    /* We also need temporary space to decode the record. */

    record = (XLogRecord *) recordBuf.data;

    decoded = (DecodedXLogRecord *)

      palloc(DecodeXLogRecordRequiredSpace(record->xl_tot_len));

    if (!debug_reader)

      debug_reader = XLogReaderAllocate(wal_segment_size, NULL,

                        XL_ROUTINE(.page_read = NULL,

                             .segment_open = NULL,

                             .segment_close = NULL),

                        NULL);

    if (!debug_reader)

    {

      appendStringInfoString(&buf, "error decoding record: out of memory while allocating a WAL reading processor");

    }

    else if (!DecodeXLogRecord(debug_reader,

                   decoded,

                   record,

                   EndPos,

                   &errormsg))

    {

      appendStringInfo(&buf, "error decoding record: %s",

               errormsg ? errormsg : "no error message");

    }

    else

    {

      appendStringInfoString(&buf, " - ");

      debug_reader->record = decoded;

      xlog_outdesc(&buf, debug_reader);

      debug_reader->record = NULL;

    }

    elog(LOG, "%s", buf.data);

    pfree(decoded);

    pfree(buf.data);

    pfree(recordBuf.data);

    MemoryContextSwitchTo(oldCxt);

  }