Thanks to visit codestin.com
Credit goes to doxygen.postgresql.org

PostgreSQL Source Code git master
xlog.c
Go to the documentation of this file.
1/*-------------------------------------------------------------------------
2 *
3 * xlog.c
4 * PostgreSQL write-ahead log manager
5 *
6 * The Write-Ahead Log (WAL) functionality is split into several source
7 * files, in addition to this one:
8 *
9 * xloginsert.c - Functions for constructing WAL records
10 * xlogrecovery.c - WAL recovery and standby code
11 * xlogreader.c - Facility for reading WAL files and parsing WAL records
12 * xlogutils.c - Helper functions for WAL redo routines
13 *
14 * This file contains functions for coordinating database startup and
15 * checkpointing, and managing the write-ahead log buffers when the
16 * system is running.
17 *
18 * StartupXLOG() is the main entry point of the startup process. It
19 * coordinates database startup, performing WAL recovery, and the
20 * transition from WAL recovery into normal operations.
21 *
22 * XLogInsertRecord() inserts a WAL record into the WAL buffers. Most
23 * callers should not call this directly, but use the functions in
24 * xloginsert.c to construct the WAL record. XLogFlush() can be used
25 * to force the WAL to disk.
26 *
27 * In addition to those, there are many other functions for interrogating
28 * the current system state, and for starting/stopping backups.
29 *
30 *
31 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
32 * Portions Copyright (c) 1994, Regents of the University of California
33 *
34 * src/backend/access/transam/xlog.c
35 *
36 *-------------------------------------------------------------------------
37 */
38
39#include "postgres.h"
40
41#include <ctype.h>
42#include <math.h>
43#include <time.h>
44#include <fcntl.h>
45#include <sys/stat.h>
46#include <sys/time.h>
47#include <unistd.h>
48
49#include "access/clog.h"
50#include "access/commit_ts.h"
51#include "access/heaptoast.h"
52#include "access/multixact.h"
53#include "access/rewriteheap.h"
54#include "access/subtrans.h"
55#include "access/timeline.h"
56#include "access/transam.h"
57#include "access/twophase.h"
58#include "access/xact.h"
60#include "access/xlogarchive.h"
61#include "access/xloginsert.h"
62#include "access/xlogreader.h"
63#include "access/xlogrecovery.h"
64#include "access/xlogutils.h"
65#include "backup/basebackup.h"
66#include "catalog/catversion.h"
67#include "catalog/pg_control.h"
68#include "catalog/pg_database.h"
70#include "common/file_utils.h"
71#include "executor/instrument.h"
72#include "miscadmin.h"
73#include "pg_trace.h"
74#include "pgstat.h"
75#include "port/atomics.h"
76#include "postmaster/bgwriter.h"
77#include "postmaster/startup.h"
80#include "replication/origin.h"
81#include "replication/slot.h"
85#include "storage/bufmgr.h"
86#include "storage/fd.h"
87#include "storage/ipc.h"
89#include "storage/latch.h"
90#include "storage/predicate.h"
91#include "storage/proc.h"
92#include "storage/procarray.h"
93#include "storage/reinit.h"
94#include "storage/spin.h"
95#include "storage/sync.h"
96#include "utils/guc_hooks.h"
97#include "utils/guc_tables.h"
100#include "utils/ps_status.h"
101#include "utils/relmapper.h"
102#include "utils/snapmgr.h"
103#include "utils/timeout.h"
104#include "utils/timestamp.h"
105#include "utils/varlena.h"
106
107#ifdef WAL_DEBUG
108#include "utils/memutils.h"
109#endif
110
111/* timeline ID to be used when bootstrapping */
112#define BootstrapTimeLineID 1
113
114/* User-settable parameters */
115int max_wal_size_mb = 1024; /* 1 GB */
116int min_wal_size_mb = 80; /* 80 MB */
118int XLOGbuffers = -1;
122bool EnableHotStandby = false;
123bool fullPageWrites = true;
124bool wal_log_hints = false;
128bool wal_init_zero = true;
129bool wal_recycle = true;
130bool log_checkpoints = true;
133int CommitDelay = 0; /* precommit delay in microseconds */
134int CommitSiblings = 5; /* # concurrent xacts needed to sleep */
137int wal_decode_buffer_size = 512 * 1024;
139
140#ifdef WAL_DEBUG
141bool XLOG_DEBUG = false;
142#endif
143
145
146/*
147 * Number of WAL insertion locks to use. A higher value allows more insertions
148 * to happen concurrently, but adds some CPU overhead to flushing the WAL,
149 * which needs to iterate all the locks.
150 */
151#define NUM_XLOGINSERT_LOCKS 8
152
153/*
154 * Max distance from last checkpoint, before triggering a new xlog-based
155 * checkpoint.
156 */
158
159/* Estimated distance between checkpoints, in bytes */
161static double PrevCheckPointDistance = 0;
162
163/*
164 * Track whether there were any deferred checks for custom resource managers
165 * specified in wal_consistency_checking.
166 */
168
169/*
170 * GUC support
171 */
173 {"fsync", WAL_SYNC_METHOD_FSYNC, false},
174#ifdef HAVE_FSYNC_WRITETHROUGH
175 {"fsync_writethrough", WAL_SYNC_METHOD_FSYNC_WRITETHROUGH, false},
176#endif
177 {"fdatasync", WAL_SYNC_METHOD_FDATASYNC, false},
178#ifdef O_SYNC
179 {"open_sync", WAL_SYNC_METHOD_OPEN, false},
180#endif
181#ifdef O_DSYNC
182 {"open_datasync", WAL_SYNC_METHOD_OPEN_DSYNC, false},
183#endif
184 {NULL, 0, false}
185};
186
187
188/*
189 * Although only "on", "off", and "always" are documented,
190 * we accept all the likely variants of "on" and "off".
191 */
193 {"always", ARCHIVE_MODE_ALWAYS, false},
194 {"on", ARCHIVE_MODE_ON, false},
195 {"off", ARCHIVE_MODE_OFF, false},
196 {"true", ARCHIVE_MODE_ON, true},
197 {"false", ARCHIVE_MODE_OFF, true},
198 {"yes", ARCHIVE_MODE_ON, true},
199 {"no", ARCHIVE_MODE_OFF, true},
200 {"1", ARCHIVE_MODE_ON, true},
201 {"0", ARCHIVE_MODE_OFF, true},
202 {NULL, 0, false}
203};
204
205/*
206 * Statistics for current checkpoint are collected in this global struct.
207 * Because only the checkpointer or a stand-alone backend can perform
208 * checkpoints, this will be unused in normal backends.
209 */
211
212/*
213 * During recovery, lastFullPageWrites keeps track of full_page_writes that
214 * the replayed WAL records indicate. It's initialized with full_page_writes
215 * that the recovery starting checkpoint record indicates, and then updated
216 * each time XLOG_FPW_CHANGE record is replayed.
217 */
219
220/*
221 * Local copy of the state tracked by SharedRecoveryState in shared memory,
222 * It is false if SharedRecoveryState is RECOVERY_STATE_DONE. True actually
223 * means "not known, need to check the shared state".
224 */
225static bool LocalRecoveryInProgress = true;
226
227/*
228 * Local state for XLogInsertAllowed():
229 * 1: unconditionally allowed to insert XLOG
230 * 0: unconditionally not allowed to insert XLOG
231 * -1: must check RecoveryInProgress(); disallow until it is false
232 * Most processes start with -1 and transition to 1 after seeing that recovery
233 * is not in progress. But we can also force the value for special cases.
234 * The coding in XLogInsertAllowed() depends on the first two of these states
235 * being numerically the same as bool true and false.
236 */
238
239/*
240 * ProcLastRecPtr points to the start of the last XLOG record inserted by the
241 * current backend. It is updated for all inserts. XactLastRecEnd points to
242 * end+1 of the last record, and is reset when we end a top-level transaction,
243 * or start a new one; so it can be used to tell if the current transaction has
244 * created any XLOG records.
245 *
246 * While in parallel mode, this may not be fully up to date. When committing,
247 * a transaction can assume this covers all xlog records written either by the
248 * user backend or by any parallel worker which was present at any point during
249 * the transaction. But when aborting, or when still in parallel mode, other
250 * parallel backends may have written WAL records at later LSNs than the value
251 * stored here. The parallel leader advances its own copy, when necessary,
252 * in WaitForParallelWorkersToFinish.
253 */
257
258/*
259 * RedoRecPtr is this backend's local copy of the REDO record pointer
260 * (which is almost but not quite the same as a pointer to the most recent
261 * CHECKPOINT record). We update this from the shared-memory copy,
262 * XLogCtl->Insert.RedoRecPtr, whenever we can safely do so (ie, when we
263 * hold an insertion lock). See XLogInsertRecord for details. We are also
264 * allowed to update from XLogCtl->RedoRecPtr if we hold the info_lck;
265 * see GetRedoRecPtr.
266 *
267 * NB: Code that uses this variable must be prepared not only for the
268 * possibility that it may be arbitrarily out of date, but also for the
269 * possibility that it might be set to InvalidXLogRecPtr. We used to
270 * initialize it as a side effect of the first call to RecoveryInProgress(),
271 * which meant that most code that might use it could assume that it had a
272 * real if perhaps stale value. That's no longer the case.
273 */
275
276/*
277 * doPageWrites is this backend's local copy of (fullPageWrites ||
278 * runningBackups > 0). It is used together with RedoRecPtr to decide whether
279 * a full-page image of a page need to be taken.
280 *
281 * NB: Initially this is false, and there's no guarantee that it will be
282 * initialized to any other value before it is first used. Any code that
283 * makes use of it must recheck the value after obtaining a WALInsertLock,
284 * and respond appropriately if it turns out that the previous value wasn't
285 * accurate.
286 */
287static bool doPageWrites;
288
289/*----------
290 * Shared-memory data structures for XLOG control
291 *
292 * LogwrtRqst indicates a byte position that we need to write and/or fsync
293 * the log up to (all records before that point must be written or fsynced).
294 * The positions already written/fsynced are maintained in logWriteResult
295 * and logFlushResult using atomic access.
296 * In addition to the shared variable, each backend has a private copy of
297 * both in LogwrtResult, which is updated when convenient.
298 *
299 * The request bookkeeping is simpler: there is a shared XLogCtl->LogwrtRqst
300 * (protected by info_lck), but we don't need to cache any copies of it.
301 *
302 * info_lck is only held long enough to read/update the protected variables,
303 * so it's a plain spinlock. The other locks are held longer (potentially
304 * over I/O operations), so we use LWLocks for them. These locks are:
305 *
306 * WALBufMappingLock: must be held to replace a page in the WAL buffer cache.
307 * It is only held while initializing and changing the mapping. If the
308 * contents of the buffer being replaced haven't been written yet, the mapping
309 * lock is released while the write is done, and reacquired afterwards.
310 *
311 * WALWriteLock: must be held to write WAL buffers to disk (XLogWrite or
312 * XLogFlush).
313 *
314 * ControlFileLock: must be held to read/update control file or create
315 * new log file.
316 *
317 *----------
318 */
319
320typedef struct XLogwrtRqst
321{
322 XLogRecPtr Write; /* last byte + 1 to write out */
323 XLogRecPtr Flush; /* last byte + 1 to flush */
325
326typedef struct XLogwrtResult
327{
328 XLogRecPtr Write; /* last byte + 1 written out */
329 XLogRecPtr Flush; /* last byte + 1 flushed */
331
332/*
333 * Inserting to WAL is protected by a small fixed number of WAL insertion
334 * locks. To insert to the WAL, you must hold one of the locks - it doesn't
335 * matter which one. To lock out other concurrent insertions, you must hold
336 * of them. Each WAL insertion lock consists of a lightweight lock, plus an
337 * indicator of how far the insertion has progressed (insertingAt).
338 *
339 * The insertingAt values are read when a process wants to flush WAL from
340 * the in-memory buffers to disk, to check that all the insertions to the
341 * region the process is about to write out have finished. You could simply
342 * wait for all currently in-progress insertions to finish, but the
343 * insertingAt indicator allows you to ignore insertions to later in the WAL,
344 * so that you only wait for the insertions that are modifying the buffers
345 * you're about to write out.
346 *
347 * This isn't just an optimization. If all the WAL buffers are dirty, an
348 * inserter that's holding a WAL insert lock might need to evict an old WAL
349 * buffer, which requires flushing the WAL. If it's possible for an inserter
350 * to block on another inserter unnecessarily, deadlock can arise when two
351 * inserters holding a WAL insert lock wait for each other to finish their
352 * insertion.
353 *
354 * Small WAL records that don't cross a page boundary never update the value,
355 * the WAL record is just copied to the page and the lock is released. But
356 * to avoid the deadlock-scenario explained above, the indicator is always
357 * updated before sleeping while holding an insertion lock.
358 *
359 * lastImportantAt contains the LSN of the last important WAL record inserted
360 * using a given lock. This value is used to detect if there has been
361 * important WAL activity since the last time some action, like a checkpoint,
362 * was performed - allowing to not repeat the action if not. The LSN is
363 * updated for all insertions, unless the XLOG_MARK_UNIMPORTANT flag was
364 * set. lastImportantAt is never cleared, only overwritten by the LSN of newer
365 * records. Tracking the WAL activity directly in WALInsertLock has the
366 * advantage of not needing any additional locks to update the value.
367 */
368typedef struct
369{
374
375/*
376 * All the WAL insertion locks are allocated as an array in shared memory. We
377 * force the array stride to be a power of 2, which saves a few cycles in
378 * indexing, but more importantly also ensures that individual slots don't
379 * cross cache line boundaries. (Of course, we have to also ensure that the
380 * array start address is suitably aligned.)
381 */
383{
387
388/*
389 * Session status of running backup, used for sanity checks in SQL-callable
390 * functions to start and stop backups.
391 */
393
394/*
395 * Shared state data for WAL insertion.
396 */
397typedef struct XLogCtlInsert
398{
399 slock_t insertpos_lck; /* protects CurrBytePos and PrevBytePos */
400
401 /*
402 * CurrBytePos is the end of reserved WAL. The next record will be
403 * inserted at that position. PrevBytePos is the start position of the
404 * previously inserted (or rather, reserved) record - it is copied to the
405 * prev-link of the next record. These are stored as "usable byte
406 * positions" rather than XLogRecPtrs (see XLogBytePosToRecPtr()).
407 */
410
411 /*
412 * Make sure the above heavily-contended spinlock and byte positions are
413 * on their own cache line. In particular, the RedoRecPtr and full page
414 * write variables below should be on a different cache line. They are
415 * read on every WAL insertion, but updated rarely, and we don't want
416 * those reads to steal the cache line containing Curr/PrevBytePos.
417 */
419
420 /*
421 * fullPageWrites is the authoritative value used by all backends to
422 * determine whether to write full-page image to WAL. This shared value,
423 * instead of the process-local fullPageWrites, is required because, when
424 * full_page_writes is changed by SIGHUP, we must WAL-log it before it
425 * actually affects WAL-logging by backends. Checkpointer sets at startup
426 * or after SIGHUP.
427 *
428 * To read these fields, you must hold an insertion lock. To modify them,
429 * you must hold ALL the locks.
430 */
431 XLogRecPtr RedoRecPtr; /* current redo point for insertions */
433
434 /*
435 * runningBackups is a counter indicating the number of backups currently
436 * in progress. lastBackupStart is the latest checkpoint redo location
437 * used as a starting point for an online backup.
438 */
441
442 /*
443 * WAL insertion locks.
444 */
447
448/*
449 * Total shared-memory state for XLOG.
450 */
451typedef struct XLogCtlData
452{
454
455 /* Protected by info_lck: */
457 XLogRecPtr RedoRecPtr; /* a recent copy of Insert->RedoRecPtr */
458 XLogRecPtr asyncXactLSN; /* LSN of newest async commit/abort */
459 XLogRecPtr replicationSlotMinLSN; /* oldest LSN needed by any slot */
460
461 XLogSegNo lastRemovedSegNo; /* latest removed/recycled XLOG segment */
462
463 /* Fake LSN counter, for unlogged relations. */
465
466 /* Time and LSN of last xlog segment switch. Protected by WALWriteLock. */
469
470 /* These are accessed using atomics -- info_lck not needed */
471 pg_atomic_uint64 logInsertResult; /* last byte + 1 inserted to buffers */
472 pg_atomic_uint64 logWriteResult; /* last byte + 1 written out */
473 pg_atomic_uint64 logFlushResult; /* last byte + 1 flushed */
474
475 /*
476 * Latest initialized page in the cache (last byte position + 1).
477 *
478 * To change the identity of a buffer (and InitializedUpTo), you need to
479 * hold WALBufMappingLock. To change the identity of a buffer that's
480 * still dirty, the old page needs to be written out first, and for that
481 * you need WALWriteLock, and you need to ensure that there are no
482 * in-progress insertions to the page by calling
483 * WaitXLogInsertionsToFinish().
484 */
486
487 /*
488 * These values do not change after startup, although the pointed-to pages
489 * and xlblocks values certainly do. xlblocks values are protected by
490 * WALBufMappingLock.
491 */
492 char *pages; /* buffers for unwritten XLOG pages */
493 pg_atomic_uint64 *xlblocks; /* 1st byte ptr-s + XLOG_BLCKSZ */
494 int XLogCacheBlck; /* highest allocated xlog buffer index */
495
496 /*
497 * InsertTimeLineID is the timeline into which new WAL is being inserted
498 * and flushed. It is zero during recovery, and does not change once set.
499 *
500 * If we create a new timeline when the system was started up,
501 * PrevTimeLineID is the old timeline's ID that we forked off from.
502 * Otherwise it's equal to InsertTimeLineID.
503 *
504 * We set these fields while holding info_lck. Most that reads these
505 * values knows that recovery is no longer in progress and so can safely
506 * read the value without a lock, but code that could be run either during
507 * or after recovery can take info_lck while reading these values.
508 */
511
512 /*
513 * SharedRecoveryState indicates if we're still in crash or archive
514 * recovery. Protected by info_lck.
515 */
517
518 /*
519 * InstallXLogFileSegmentActive indicates whether the checkpointer should
520 * arrange for future segments by recycling and/or PreallocXlogFiles().
521 * Protected by ControlFileLock. Only the startup process changes it. If
522 * true, anyone can use InstallXLogFileSegment(). If false, the startup
523 * process owns the exclusive right to install segments, by reading from
524 * the archive and possibly replacing existing files.
525 */
527
528 /*
529 * WalWriterSleeping indicates whether the WAL writer is currently in
530 * low-power mode (and hence should be nudged if an async commit occurs).
531 * Protected by info_lck.
532 */
534
535 /*
536 * During recovery, we keep a copy of the latest checkpoint record here.
537 * lastCheckPointRecPtr points to start of checkpoint record and
538 * lastCheckPointEndPtr points to end+1 of checkpoint record. Used by the
539 * checkpointer when it wants to create a restartpoint.
540 *
541 * Protected by info_lck.
542 */
546
547 /*
548 * lastFpwDisableRecPtr points to the start of the last replayed
549 * XLOG_FPW_CHANGE record that instructs full_page_writes is disabled.
550 */
552
553 slock_t info_lck; /* locks shared variables shown above */
555
556/*
557 * Classification of XLogInsertRecord operations.
558 */
559typedef enum
560{
565
566static XLogCtlData *XLogCtl = NULL;
567
568/* a private copy of XLogCtl->Insert.WALInsertLocks, for convenience */
570
571/*
572 * We maintain an image of pg_control in shared memory.
573 */
575
576/*
577 * Calculate the amount of space left on the page after 'endptr'. Beware
578 * multiple evaluation!
579 */
580#define INSERT_FREESPACE(endptr) \
581 (((endptr) % XLOG_BLCKSZ == 0) ? 0 : (XLOG_BLCKSZ - (endptr) % XLOG_BLCKSZ))
582
583/* Macro to advance to next buffer index. */
584#define NextBufIdx(idx) \
585 (((idx) == XLogCtl->XLogCacheBlck) ? 0 : ((idx) + 1))
586
587/*
588 * XLogRecPtrToBufIdx returns the index of the WAL buffer that holds, or
589 * would hold if it was in cache, the page containing 'recptr'.
590 */
591#define XLogRecPtrToBufIdx(recptr) \
592 (((recptr) / XLOG_BLCKSZ) % (XLogCtl->XLogCacheBlck + 1))
593
594/*
595 * These are the number of bytes in a WAL page usable for WAL data.
596 */
597#define UsableBytesInPage (XLOG_BLCKSZ - SizeOfXLogShortPHD)
598
599/*
600 * Convert values of GUCs measured in megabytes to equiv. segment count.
601 * Rounds down.
602 */
603#define ConvertToXSegs(x, segsize) XLogMBVarToSegs((x), (segsize))
604
605/* The number of bytes in a WAL segment usable for WAL data. */
607
608/*
609 * Private, possibly out-of-date copy of shared LogwrtResult.
610 * See discussion above.
611 */
613
614/*
615 * Update local copy of shared XLogCtl->log{Write,Flush}Result
616 *
617 * It's critical that Flush always trails Write, so the order of the reads is
618 * important, as is the barrier. See also XLogWrite.
619 */
620#define RefreshXLogWriteResult(_target) \
621 do { \
622 _target.Flush = pg_atomic_read_u64(&XLogCtl->logFlushResult); \
623 pg_read_barrier(); \
624 _target.Write = pg_atomic_read_u64(&XLogCtl->logWriteResult); \
625 } while (0)
626
627/*
628 * openLogFile is -1 or a kernel FD for an open log file segment.
629 * openLogSegNo identifies the segment, and openLogTLI the corresponding TLI.
630 * These variables are only used to write the XLOG, and so will normally refer
631 * to the active segment.
632 *
633 * Note: call Reserve/ReleaseExternalFD to track consumption of this FD.
634 */
635static int openLogFile = -1;
638
639/*
640 * Local copies of equivalent fields in the control file. When running
641 * crash recovery, LocalMinRecoveryPoint is set to InvalidXLogRecPtr as we
642 * expect to replay all the WAL available, and updateMinRecoveryPoint is
643 * switched to false to prevent any updates while replaying records.
644 * Those values are kept consistent as long as crash recovery runs.
645 */
648static bool updateMinRecoveryPoint = true;
649
650/* For WALInsertLockAcquire/Release functions */
651static int MyLockNo = 0;
652static bool holdingAllLocks = false;
653
654#ifdef WAL_DEBUG
655static MemoryContext walDebugCxt = NULL;
656#endif
657
658static void CleanupAfterArchiveRecovery(TimeLineID EndOfLogTLI,
659 XLogRecPtr EndOfLog,
660 TimeLineID newTLI);
661static void CheckRequiredParameterValues(void);
662static void XLogReportParameters(void);
663static int LocalSetXLogInsertAllowed(void);
664static void CreateEndOfRecoveryRecord(void);
666 XLogRecPtr pagePtr,
667 TimeLineID newTLI);
668static void CheckPointGuts(XLogRecPtr checkPointRedo, int flags);
669static void KeepLogSeg(XLogRecPtr recptr, XLogSegNo *logSegNo);
671
672static void AdvanceXLInsertBuffer(XLogRecPtr upto, TimeLineID tli,
673 bool opportunistic);
674static void XLogWrite(XLogwrtRqst WriteRqst, TimeLineID tli, bool flexible);
675static bool InstallXLogFileSegment(XLogSegNo *segno, char *tmppath,
676 bool find_free, XLogSegNo max_segno,
677 TimeLineID tli);
678static void XLogFileClose(void);
679static void PreallocXlogFiles(XLogRecPtr endptr, TimeLineID tli);
680static void RemoveTempXlogFiles(void);
681static void RemoveOldXlogFiles(XLogSegNo segno, XLogRecPtr lastredoptr,
682 XLogRecPtr endptr, TimeLineID insertTLI);
683static void RemoveXlogFile(const struct dirent *segment_de,
684 XLogSegNo recycleSegNo, XLogSegNo *endlogSegNo,
685 TimeLineID insertTLI);
686static void UpdateLastRemovedPtr(char *filename);
687static void ValidateXLOGDirectoryStructure(void);
688static void CleanupBackupHistory(void);
689static void UpdateMinRecoveryPoint(XLogRecPtr lsn, bool force);
690static bool PerformRecoveryXLogAction(void);
691static void InitControlFile(uint64 sysidentifier, uint32 data_checksum_version);
692static void WriteControlFile(void);
693static void ReadControlFile(void);
694static void UpdateControlFile(void);
695static char *str_time(pg_time_t tnow, char *buf, size_t bufsize);
696
697static int get_sync_bit(int method);
698
699static void CopyXLogRecordToWAL(int write_len, bool isLogSwitch,
700 XLogRecData *rdata,
701 XLogRecPtr StartPos, XLogRecPtr EndPos,
702 TimeLineID tli);
703static void ReserveXLogInsertLocation(int size, XLogRecPtr *StartPos,
704 XLogRecPtr *EndPos, XLogRecPtr *PrevPtr);
705static bool ReserveXLogSwitch(XLogRecPtr *StartPos, XLogRecPtr *EndPos,
706 XLogRecPtr *PrevPtr);
708static char *GetXLogBuffer(XLogRecPtr ptr, TimeLineID tli);
712
713static void WALInsertLockAcquire(void);
714static void WALInsertLockAcquireExclusive(void);
715static void WALInsertLockRelease(void);
716static void WALInsertLockUpdateInsertingAt(XLogRecPtr insertingAt);
717
718/*
719 * Insert an XLOG record represented by an already-constructed chain of data
720 * chunks. This is a low-level routine; to construct the WAL record header
721 * and data, use the higher-level routines in xloginsert.c.
722 *
723 * If 'fpw_lsn' is valid, it is the oldest LSN among the pages that this
724 * WAL record applies to, that were not included in the record as full page
725 * images. If fpw_lsn <= RedoRecPtr, the function does not perform the
726 * insertion and returns InvalidXLogRecPtr. The caller can then recalculate
727 * which pages need a full-page image, and retry. If fpw_lsn is invalid, the
728 * record is always inserted.
729 *
730 * 'flags' gives more in-depth control on the record being inserted. See
731 * XLogSetRecordFlags() for details.
732 *
733 * 'topxid_included' tells whether the top-transaction id is logged along with
734 * current subtransaction. See XLogRecordAssemble().
735 *
736 * The first XLogRecData in the chain must be for the record header, and its
737 * data must be MAXALIGNed. XLogInsertRecord fills in the xl_prev and
738 * xl_crc fields in the header, the rest of the header must already be filled
739 * by the caller.
740 *
741 * Returns XLOG pointer to end of record (beginning of next record).
742 * This can be used as LSN for data pages affected by the logged action.
743 * (LSN is the XLOG point up to which the XLOG must be flushed to disk
744 * before the data page can be written out. This implements the basic
745 * WAL rule "write the log before the data".)
746 */
749 XLogRecPtr fpw_lsn,
750 uint8 flags,
751 int num_fpi,
752 bool topxid_included)
753{
755 pg_crc32c rdata_crc;
756 bool inserted;
757 XLogRecord *rechdr = (XLogRecord *) rdata->data;
758 uint8 info = rechdr->xl_info & ~XLR_INFO_MASK;
760 XLogRecPtr StartPos;
761 XLogRecPtr EndPos;
762 bool prevDoPageWrites = doPageWrites;
763 TimeLineID insertTLI;
764
765 /* Does this record type require special handling? */
766 if (unlikely(rechdr->xl_rmid == RM_XLOG_ID))
767 {
768 if (info == XLOG_SWITCH)
770 else if (info == XLOG_CHECKPOINT_REDO)
772 }
773
774 /* we assume that all of the record header is in the first chunk */
775 Assert(rdata->len >= SizeOfXLogRecord);
776
777 /* cross-check on whether we should be here or not */
778 if (!XLogInsertAllowed())
779 elog(ERROR, "cannot make new WAL entries during recovery");
780
781 /*
782 * Given that we're not in recovery, InsertTimeLineID is set and can't
783 * change, so we can read it without a lock.
784 */
785 insertTLI = XLogCtl->InsertTimeLineID;
786
787 /*----------
788 *
789 * We have now done all the preparatory work we can without holding a
790 * lock or modifying shared state. From here on, inserting the new WAL
791 * record to the shared WAL buffer cache is a two-step process:
792 *
793 * 1. Reserve the right amount of space from the WAL. The current head of
794 * reserved space is kept in Insert->CurrBytePos, and is protected by
795 * insertpos_lck.
796 *
797 * 2. Copy the record to the reserved WAL space. This involves finding the
798 * correct WAL buffer containing the reserved space, and copying the
799 * record in place. This can be done concurrently in multiple processes.
800 *
801 * To keep track of which insertions are still in-progress, each concurrent
802 * inserter acquires an insertion lock. In addition to just indicating that
803 * an insertion is in progress, the lock tells others how far the inserter
804 * has progressed. There is a small fixed number of insertion locks,
805 * determined by NUM_XLOGINSERT_LOCKS. When an inserter crosses a page
806 * boundary, it updates the value stored in the lock to the how far it has
807 * inserted, to allow the previous buffer to be flushed.
808 *
809 * Holding onto an insertion lock also protects RedoRecPtr and
810 * fullPageWrites from changing until the insertion is finished.
811 *
812 * Step 2 can usually be done completely in parallel. If the required WAL
813 * page is not initialized yet, you have to grab WALBufMappingLock to
814 * initialize it, but the WAL writer tries to do that ahead of insertions
815 * to avoid that from happening in the critical path.
816 *
817 *----------
818 */
820
821 if (likely(class == WALINSERT_NORMAL))
822 {
824
825 /*
826 * Check to see if my copy of RedoRecPtr is out of date. If so, may
827 * have to go back and have the caller recompute everything. This can
828 * only happen just after a checkpoint, so it's better to be slow in
829 * this case and fast otherwise.
830 *
831 * Also check to see if fullPageWrites was just turned on or there's a
832 * running backup (which forces full-page writes); if we weren't
833 * already doing full-page writes then go back and recompute.
834 *
835 * If we aren't doing full-page writes then RedoRecPtr doesn't
836 * actually affect the contents of the XLOG record, so we'll update
837 * our local copy but not force a recomputation. (If doPageWrites was
838 * just turned off, we could recompute the record without full pages,
839 * but we choose not to bother.)
840 */
841 if (RedoRecPtr != Insert->RedoRecPtr)
842 {
843 Assert(RedoRecPtr < Insert->RedoRecPtr);
844 RedoRecPtr = Insert->RedoRecPtr;
845 }
846 doPageWrites = (Insert->fullPageWrites || Insert->runningBackups > 0);
847
848 if (doPageWrites &&
849 (!prevDoPageWrites ||
850 (fpw_lsn != InvalidXLogRecPtr && fpw_lsn <= RedoRecPtr)))
851 {
852 /*
853 * Oops, some buffer now needs to be backed up that the caller
854 * didn't back up. Start over.
855 */
858 return InvalidXLogRecPtr;
859 }
860
861 /*
862 * Reserve space for the record in the WAL. This also sets the xl_prev
863 * pointer.
864 */
865 ReserveXLogInsertLocation(rechdr->xl_tot_len, &StartPos, &EndPos,
866 &rechdr->xl_prev);
867
868 /* Normal records are always inserted. */
869 inserted = true;
870 }
871 else if (class == WALINSERT_SPECIAL_SWITCH)
872 {
873 /*
874 * In order to insert an XLOG_SWITCH record, we need to hold all of
875 * the WAL insertion locks, not just one, so that no one else can
876 * begin inserting a record until we've figured out how much space
877 * remains in the current WAL segment and claimed all of it.
878 *
879 * Nonetheless, this case is simpler than the normal cases handled
880 * below, which must check for changes in doPageWrites and RedoRecPtr.
881 * Those checks are only needed for records that can contain buffer
882 * references, and an XLOG_SWITCH record never does.
883 */
884 Assert(fpw_lsn == InvalidXLogRecPtr);
886 inserted = ReserveXLogSwitch(&StartPos, &EndPos, &rechdr->xl_prev);
887 }
888 else
889 {
891
892 /*
893 * We need to update both the local and shared copies of RedoRecPtr,
894 * which means that we need to hold all the WAL insertion locks.
895 * However, there can't be any buffer references, so as above, we need
896 * not check RedoRecPtr before inserting the record; we just need to
897 * update it afterwards.
898 */
899 Assert(fpw_lsn == InvalidXLogRecPtr);
901 ReserveXLogInsertLocation(rechdr->xl_tot_len, &StartPos, &EndPos,
902 &rechdr->xl_prev);
903 RedoRecPtr = Insert->RedoRecPtr = StartPos;
904 inserted = true;
905 }
906
907 if (inserted)
908 {
909 /*
910 * Now that xl_prev has been filled in, calculate CRC of the record
911 * header.
912 */
913 rdata_crc = rechdr->xl_crc;
914 COMP_CRC32C(rdata_crc, rechdr, offsetof(XLogRecord, xl_crc));
915 FIN_CRC32C(rdata_crc);
916 rechdr->xl_crc = rdata_crc;
917
918 /*
919 * All the record data, including the header, is now ready to be
920 * inserted. Copy the record in the space reserved.
921 */
923 class == WALINSERT_SPECIAL_SWITCH, rdata,
924 StartPos, EndPos, insertTLI);
925
926 /*
927 * Unless record is flagged as not important, update LSN of last
928 * important record in the current slot. When holding all locks, just
929 * update the first one.
930 */
931 if ((flags & XLOG_MARK_UNIMPORTANT) == 0)
932 {
933 int lockno = holdingAllLocks ? 0 : MyLockNo;
934
935 WALInsertLocks[lockno].l.lastImportantAt = StartPos;
936 }
937 }
938 else
939 {
940 /*
941 * This was an xlog-switch record, but the current insert location was
942 * already exactly at the beginning of a segment, so there was no need
943 * to do anything.
944 */
945 }
946
947 /*
948 * Done! Let others know that we're finished.
949 */
951
953
955
956 /*
957 * Mark top transaction id is logged (if needed) so that we should not try
958 * to log it again with the next WAL record in the current subtransaction.
959 */
960 if (topxid_included)
962
963 /*
964 * Update shared LogwrtRqst.Write, if we crossed page boundary.
965 */
966 if (StartPos / XLOG_BLCKSZ != EndPos / XLOG_BLCKSZ)
967 {
969 /* advance global request to include new block(s) */
970 if (XLogCtl->LogwrtRqst.Write < EndPos)
971 XLogCtl->LogwrtRqst.Write = EndPos;
974 }
975
976 /*
977 * If this was an XLOG_SWITCH record, flush the record and the empty
978 * padding space that fills the rest of the segment, and perform
979 * end-of-segment actions (eg, notifying archiver).
980 */
981 if (class == WALINSERT_SPECIAL_SWITCH)
982 {
983 TRACE_POSTGRESQL_WAL_SWITCH();
984 XLogFlush(EndPos);
985
986 /*
987 * Even though we reserved the rest of the segment for us, which is
988 * reflected in EndPos, we return a pointer to just the end of the
989 * xlog-switch record.
990 */
991 if (inserted)
992 {
993 EndPos = StartPos + SizeOfXLogRecord;
994 if (StartPos / XLOG_BLCKSZ != EndPos / XLOG_BLCKSZ)
995 {
996 uint64 offset = XLogSegmentOffset(EndPos, wal_segment_size);
997
998 if (offset == EndPos % XLOG_BLCKSZ)
999 EndPos += SizeOfXLogLongPHD;
1000 else
1001 EndPos += SizeOfXLogShortPHD;
1002 }
1003 }
1004 }
1005
1006#ifdef WAL_DEBUG
1007 if (XLOG_DEBUG)
1008 {
1009 static XLogReaderState *debug_reader = NULL;
1010 XLogRecord *record;
1011 DecodedXLogRecord *decoded;
1013 StringInfoData recordBuf;
1014 char *errormsg = NULL;
1015 MemoryContext oldCxt;
1016
1017 oldCxt = MemoryContextSwitchTo(walDebugCxt);
1018
1020 appendStringInfo(&buf, "INSERT @ %X/%08X: ", LSN_FORMAT_ARGS(EndPos));
1021
1022 /*
1023 * We have to piece together the WAL record data from the XLogRecData
1024 * entries, so that we can pass it to the rm_desc function as one
1025 * contiguous chunk.
1026 */
1027 initStringInfo(&recordBuf);
1028 for (; rdata != NULL; rdata = rdata->next)
1029 appendBinaryStringInfo(&recordBuf, rdata->data, rdata->len);
1030
1031 /* We also need temporary space to decode the record. */
1032 record = (XLogRecord *) recordBuf.data;
1033 decoded = (DecodedXLogRecord *)
1035
1036 if (!debug_reader)
1037 debug_reader = XLogReaderAllocate(wal_segment_size, NULL,
1038 XL_ROUTINE(.page_read = NULL,
1039 .segment_open = NULL,
1040 .segment_close = NULL),
1041 NULL);
1042 if (!debug_reader)
1043 {
1044 appendStringInfoString(&buf, "error decoding record: out of memory while allocating a WAL reading processor");
1045 }
1046 else if (!DecodeXLogRecord(debug_reader,
1047 decoded,
1048 record,
1049 EndPos,
1050 &errormsg))
1051 {
1052 appendStringInfo(&buf, "error decoding record: %s",
1053 errormsg ? errormsg : "no error message");
1054 }
1055 else
1056 {
1057 appendStringInfoString(&buf, " - ");
1058
1059 debug_reader->record = decoded;
1060 xlog_outdesc(&buf, debug_reader);
1061 debug_reader->record = NULL;
1062 }
1063 elog(LOG, "%s", buf.data);
1064
1065 pfree(decoded);
1066 pfree(buf.data);
1067 pfree(recordBuf.data);
1068 MemoryContextSwitchTo(oldCxt);
1069 }
1070#endif
1071
1072 /*
1073 * Update our global variables
1074 */
1075 ProcLastRecPtr = StartPos;
1076 XactLastRecEnd = EndPos;
1077
1078 /* Report WAL traffic to the instrumentation. */
1079 if (inserted)
1080 {
1081 pgWalUsage.wal_bytes += rechdr->xl_tot_len;
1083 pgWalUsage.wal_fpi += num_fpi;
1084
1085 /* Required for the flush of pending stats WAL data */
1086 pgstat_report_fixed = true;
1087 }
1088
1089 return EndPos;
1090}
1091
1092/*
1093 * Reserves the right amount of space for a record of given size from the WAL.
1094 * *StartPos is set to the beginning of the reserved section, *EndPos to
1095 * its end+1. *PrevPtr is set to the beginning of the previous record; it is
1096 * used to set the xl_prev of this record.
1097 *
1098 * This is the performance critical part of XLogInsert that must be serialized
1099 * across backends. The rest can happen mostly in parallel. Try to keep this
1100 * section as short as possible, insertpos_lck can be heavily contended on a
1101 * busy system.
1102 *
1103 * NB: The space calculation here must match the code in CopyXLogRecordToWAL,
1104 * where we actually copy the record to the reserved space.
1105 *
1106 * NB: Testing shows that XLogInsertRecord runs faster if this code is inlined;
1107 * however, because there are two call sites, the compiler is reluctant to
1108 * inline. We use pg_attribute_always_inline here to try to convince it.
1109 */
1112 XLogRecPtr *PrevPtr)
1113{
1115 uint64 startbytepos;
1116 uint64 endbytepos;
1117 uint64 prevbytepos;
1118
1119 size = MAXALIGN(size);
1120
1121 /* All (non xlog-switch) records should contain data. */
1122 Assert(size > SizeOfXLogRecord);
1123
1124 /*
1125 * The duration the spinlock needs to be held is minimized by minimizing
1126 * the calculations that have to be done while holding the lock. The
1127 * current tip of reserved WAL is kept in CurrBytePos, as a byte position
1128 * that only counts "usable" bytes in WAL, that is, it excludes all WAL
1129 * page headers. The mapping between "usable" byte positions and physical
1130 * positions (XLogRecPtrs) can be done outside the locked region, and
1131 * because the usable byte position doesn't include any headers, reserving
1132 * X bytes from WAL is almost as simple as "CurrBytePos += X".
1133 */
1134 SpinLockAcquire(&Insert->insertpos_lck);
1135
1136 startbytepos = Insert->CurrBytePos;
1137 endbytepos = startbytepos + size;
1138 prevbytepos = Insert->PrevBytePos;
1139 Insert->CurrBytePos = endbytepos;
1140 Insert->PrevBytePos = startbytepos;
1141
1142 SpinLockRelease(&Insert->insertpos_lck);
1143
1144 *StartPos = XLogBytePosToRecPtr(startbytepos);
1145 *EndPos = XLogBytePosToEndRecPtr(endbytepos);
1146 *PrevPtr = XLogBytePosToRecPtr(prevbytepos);
1147
1148 /*
1149 * Check that the conversions between "usable byte positions" and
1150 * XLogRecPtrs work consistently in both directions.
1151 */
1152 Assert(XLogRecPtrToBytePos(*StartPos) == startbytepos);
1153 Assert(XLogRecPtrToBytePos(*EndPos) == endbytepos);
1154 Assert(XLogRecPtrToBytePos(*PrevPtr) == prevbytepos);
1155}
1156
1157/*
1158 * Like ReserveXLogInsertLocation(), but for an xlog-switch record.
1159 *
1160 * A log-switch record is handled slightly differently. The rest of the
1161 * segment will be reserved for this insertion, as indicated by the returned
1162 * *EndPos value. However, if we are already at the beginning of the current
1163 * segment, *StartPos and *EndPos are set to the current location without
1164 * reserving any space, and the function returns false.
1165*/
1166static bool
1168{
1170 uint64 startbytepos;
1171 uint64 endbytepos;
1172 uint64 prevbytepos;
1174 XLogRecPtr ptr;
1175 uint32 segleft;
1176
1177 /*
1178 * These calculations are a bit heavy-weight to be done while holding a
1179 * spinlock, but since we're holding all the WAL insertion locks, there
1180 * are no other inserters competing for it. GetXLogInsertRecPtr() does
1181 * compete for it, but that's not called very frequently.
1182 */
1183 SpinLockAcquire(&Insert->insertpos_lck);
1184
1185 startbytepos = Insert->CurrBytePos;
1186
1187 ptr = XLogBytePosToEndRecPtr(startbytepos);
1188 if (XLogSegmentOffset(ptr, wal_segment_size) == 0)
1189 {
1190 SpinLockRelease(&Insert->insertpos_lck);
1191 *EndPos = *StartPos = ptr;
1192 return false;
1193 }
1194
1195 endbytepos = startbytepos + size;
1196 prevbytepos = Insert->PrevBytePos;
1197
1198 *StartPos = XLogBytePosToRecPtr(startbytepos);
1199 *EndPos = XLogBytePosToEndRecPtr(endbytepos);
1200
1202 if (segleft != wal_segment_size)
1203 {
1204 /* consume the rest of the segment */
1205 *EndPos += segleft;
1206 endbytepos = XLogRecPtrToBytePos(*EndPos);
1207 }
1208 Insert->CurrBytePos = endbytepos;
1209 Insert->PrevBytePos = startbytepos;
1210
1211 SpinLockRelease(&Insert->insertpos_lck);
1212
1213 *PrevPtr = XLogBytePosToRecPtr(prevbytepos);
1214
1216 Assert(XLogRecPtrToBytePos(*EndPos) == endbytepos);
1217 Assert(XLogRecPtrToBytePos(*StartPos) == startbytepos);
1218 Assert(XLogRecPtrToBytePos(*PrevPtr) == prevbytepos);
1219
1220 return true;
1221}
1222
1223/*
1224 * Subroutine of XLogInsertRecord. Copies a WAL record to an already-reserved
1225 * area in the WAL.
1226 */
1227static void
1228CopyXLogRecordToWAL(int write_len, bool isLogSwitch, XLogRecData *rdata,
1229 XLogRecPtr StartPos, XLogRecPtr EndPos, TimeLineID tli)
1230{
1231 char *currpos;
1232 int freespace;
1233 int written;
1234 XLogRecPtr CurrPos;
1235 XLogPageHeader pagehdr;
1236
1237 /*
1238 * Get a pointer to the right place in the right WAL buffer to start
1239 * inserting to.
1240 */
1241 CurrPos = StartPos;
1242 currpos = GetXLogBuffer(CurrPos, tli);
1243 freespace = INSERT_FREESPACE(CurrPos);
1244
1245 /*
1246 * there should be enough space for at least the first field (xl_tot_len)
1247 * on this page.
1248 */
1249 Assert(freespace >= sizeof(uint32));
1250
1251 /* Copy record data */
1252 written = 0;
1253 while (rdata != NULL)
1254 {
1255 const char *rdata_data = rdata->data;
1256 int rdata_len = rdata->len;
1257
1258 while (rdata_len > freespace)
1259 {
1260 /*
1261 * Write what fits on this page, and continue on the next page.
1262 */
1263 Assert(CurrPos % XLOG_BLCKSZ >= SizeOfXLogShortPHD || freespace == 0);
1264 memcpy(currpos, rdata_data, freespace);
1265 rdata_data += freespace;
1266 rdata_len -= freespace;
1267 written += freespace;
1268 CurrPos += freespace;
1269
1270 /*
1271 * Get pointer to beginning of next page, and set the xlp_rem_len
1272 * in the page header. Set XLP_FIRST_IS_CONTRECORD.
1273 *
1274 * It's safe to set the contrecord flag and xlp_rem_len without a
1275 * lock on the page. All the other flags were already set when the
1276 * page was initialized, in AdvanceXLInsertBuffer, and we're the
1277 * only backend that needs to set the contrecord flag.
1278 */
1279 currpos = GetXLogBuffer(CurrPos, tli);
1280 pagehdr = (XLogPageHeader) currpos;
1281 pagehdr->xlp_rem_len = write_len - written;
1283
1284 /* skip over the page header */
1285 if (XLogSegmentOffset(CurrPos, wal_segment_size) == 0)
1286 {
1287 CurrPos += SizeOfXLogLongPHD;
1288 currpos += SizeOfXLogLongPHD;
1289 }
1290 else
1291 {
1292 CurrPos += SizeOfXLogShortPHD;
1293 currpos += SizeOfXLogShortPHD;
1294 }
1295 freespace = INSERT_FREESPACE(CurrPos);
1296 }
1297
1298 Assert(CurrPos % XLOG_BLCKSZ >= SizeOfXLogShortPHD || rdata_len == 0);
1299 memcpy(currpos, rdata_data, rdata_len);
1300 currpos += rdata_len;
1301 CurrPos += rdata_len;
1302 freespace -= rdata_len;
1303 written += rdata_len;
1304
1305 rdata = rdata->next;
1306 }
1307 Assert(written == write_len);
1308
1309 /*
1310 * If this was an xlog-switch, it's not enough to write the switch record,
1311 * we also have to consume all the remaining space in the WAL segment. We
1312 * have already reserved that space, but we need to actually fill it.
1313 */
1314 if (isLogSwitch && XLogSegmentOffset(CurrPos, wal_segment_size) != 0)
1315 {
1316 /* An xlog-switch record doesn't contain any data besides the header */
1317 Assert(write_len == SizeOfXLogRecord);
1318
1319 /* Assert that we did reserve the right amount of space */
1321
1322 /* Use up all the remaining space on the current page */
1323 CurrPos += freespace;
1324
1325 /*
1326 * Cause all remaining pages in the segment to be flushed, leaving the
1327 * XLog position where it should be, at the start of the next segment.
1328 * We do this one page at a time, to make sure we don't deadlock
1329 * against ourselves if wal_buffers < wal_segment_size.
1330 */
1331 while (CurrPos < EndPos)
1332 {
1333 /*
1334 * The minimal action to flush the page would be to call
1335 * WALInsertLockUpdateInsertingAt(CurrPos) followed by
1336 * AdvanceXLInsertBuffer(...). The page would be left initialized
1337 * mostly to zeros, except for the page header (always the short
1338 * variant, as this is never a segment's first page).
1339 *
1340 * The large vistas of zeros are good for compressibility, but the
1341 * headers interrupting them every XLOG_BLCKSZ (with values that
1342 * differ from page to page) are not. The effect varies with
1343 * compression tool, but bzip2 for instance compresses about an
1344 * order of magnitude worse if those headers are left in place.
1345 *
1346 * Rather than complicating AdvanceXLInsertBuffer itself (which is
1347 * called in heavily-loaded circumstances as well as this lightly-
1348 * loaded one) with variant behavior, we just use GetXLogBuffer
1349 * (which itself calls the two methods we need) to get the pointer
1350 * and zero most of the page. Then we just zero the page header.
1351 */
1352 currpos = GetXLogBuffer(CurrPos, tli);
1353 MemSet(currpos, 0, SizeOfXLogShortPHD);
1354
1355 CurrPos += XLOG_BLCKSZ;
1356 }
1357 }
1358 else
1359 {
1360 /* Align the end position, so that the next record starts aligned */
1361 CurrPos = MAXALIGN64(CurrPos);
1362 }
1363
1364 if (CurrPos != EndPos)
1365 ereport(PANIC,
1367 errmsg_internal("space reserved for WAL record does not match what was written"));
1368}
1369
1370/*
1371 * Acquire a WAL insertion lock, for inserting to WAL.
1372 */
1373static void
1375{
1376 bool immed;
1377
1378 /*
1379 * It doesn't matter which of the WAL insertion locks we acquire, so try
1380 * the one we used last time. If the system isn't particularly busy, it's
1381 * a good bet that it's still available, and it's good to have some
1382 * affinity to a particular lock so that you don't unnecessarily bounce
1383 * cache lines between processes when there's no contention.
1384 *
1385 * If this is the first time through in this backend, pick a lock
1386 * (semi-)randomly. This allows the locks to be used evenly if you have a
1387 * lot of very short connections.
1388 */
1389 static int lockToTry = -1;
1390
1391 if (lockToTry == -1)
1392 lockToTry = MyProcNumber % NUM_XLOGINSERT_LOCKS;
1393 MyLockNo = lockToTry;
1394
1395 /*
1396 * The insertingAt value is initially set to 0, as we don't know our
1397 * insert location yet.
1398 */
1400 if (!immed)
1401 {
1402 /*
1403 * If we couldn't get the lock immediately, try another lock next
1404 * time. On a system with more insertion locks than concurrent
1405 * inserters, this causes all the inserters to eventually migrate to a
1406 * lock that no-one else is using. On a system with more inserters
1407 * than locks, it still helps to distribute the inserters evenly
1408 * across the locks.
1409 */
1410 lockToTry = (lockToTry + 1) % NUM_XLOGINSERT_LOCKS;
1411 }
1412}
1413
1414/*
1415 * Acquire all WAL insertion locks, to prevent other backends from inserting
1416 * to WAL.
1417 */
1418static void
1420{
1421 int i;
1422
1423 /*
1424 * When holding all the locks, all but the last lock's insertingAt
1425 * indicator is set to 0xFFFFFFFFFFFFFFFF, which is higher than any real
1426 * XLogRecPtr value, to make sure that no-one blocks waiting on those.
1427 */
1428 for (i = 0; i < NUM_XLOGINSERT_LOCKS - 1; i++)
1429 {
1434 }
1435 /* Variable value reset to 0 at release */
1437
1438 holdingAllLocks = true;
1439}
1440
1441/*
1442 * Release our insertion lock (or locks, if we're holding them all).
1443 *
1444 * NB: Reset all variables to 0, so they cause LWLockWaitForVar to block the
1445 * next time the lock is acquired.
1446 */
1447static void
1449{
1450 if (holdingAllLocks)
1451 {
1452 int i;
1453
1454 for (i = 0; i < NUM_XLOGINSERT_LOCKS; i++)
1457 0);
1458
1459 holdingAllLocks = false;
1460 }
1461 else
1462 {
1465 0);
1466 }
1467}
1468
1469/*
1470 * Update our insertingAt value, to let others know that we've finished
1471 * inserting up to that point.
1472 */
1473static void
1475{
1476 if (holdingAllLocks)
1477 {
1478 /*
1479 * We use the last lock to mark our actual position, see comments in
1480 * WALInsertLockAcquireExclusive.
1481 */
1484 insertingAt);
1485 }
1486 else
1489 insertingAt);
1490}
1491
1492/*
1493 * Wait for any WAL insertions < upto to finish.
1494 *
1495 * Returns the location of the oldest insertion that is still in-progress.
1496 * Any WAL prior to that point has been fully copied into WAL buffers, and
1497 * can be flushed out to disk. Because this waits for any insertions older
1498 * than 'upto' to finish, the return value is always >= 'upto'.
1499 *
1500 * Note: When you are about to write out WAL, you must call this function
1501 * *before* acquiring WALWriteLock, to avoid deadlocks. This function might
1502 * need to wait for an insertion to finish (or at least advance to next
1503 * uninitialized page), and the inserter might need to evict an old WAL buffer
1504 * to make room for a new one, which in turn requires WALWriteLock.
1505 */
1506static XLogRecPtr
1508{
1509 uint64 bytepos;
1510 XLogRecPtr inserted;
1511 XLogRecPtr reservedUpto;
1512 XLogRecPtr finishedUpto;
1514 int i;
1515
1516 if (MyProc == NULL)
1517 elog(PANIC, "cannot wait without a PGPROC structure");
1518
1519 /*
1520 * Check if there's any work to do. Use a barrier to ensure we get the
1521 * freshest value.
1522 */
1524 if (upto <= inserted)
1525 return inserted;
1526
1527 /* Read the current insert position */
1528 SpinLockAcquire(&Insert->insertpos_lck);
1529 bytepos = Insert->CurrBytePos;
1530 SpinLockRelease(&Insert->insertpos_lck);
1531 reservedUpto = XLogBytePosToEndRecPtr(bytepos);
1532
1533 /*
1534 * No-one should request to flush a piece of WAL that hasn't even been
1535 * reserved yet. However, it can happen if there is a block with a bogus
1536 * LSN on disk, for example. XLogFlush checks for that situation and
1537 * complains, but only after the flush. Here we just assume that to mean
1538 * that all WAL that has been reserved needs to be finished. In this
1539 * corner-case, the return value can be smaller than 'upto' argument.
1540 */
1541 if (upto > reservedUpto)
1542 {
1543 ereport(LOG,
1544 errmsg("request to flush past end of generated WAL; request %X/%08X, current position %X/%08X",
1545 LSN_FORMAT_ARGS(upto), LSN_FORMAT_ARGS(reservedUpto)));
1546 upto = reservedUpto;
1547 }
1548
1549 /*
1550 * Loop through all the locks, sleeping on any in-progress insert older
1551 * than 'upto'.
1552 *
1553 * finishedUpto is our return value, indicating the point upto which all
1554 * the WAL insertions have been finished. Initialize it to the head of
1555 * reserved WAL, and as we iterate through the insertion locks, back it
1556 * out for any insertion that's still in progress.
1557 */
1558 finishedUpto = reservedUpto;
1559 for (i = 0; i < NUM_XLOGINSERT_LOCKS; i++)
1560 {
1561 XLogRecPtr insertingat = InvalidXLogRecPtr;
1562
1563 do
1564 {
1565 /*
1566 * See if this insertion is in progress. LWLockWaitForVar will
1567 * wait for the lock to be released, or for the 'value' to be set
1568 * by a LWLockUpdateVar call. When a lock is initially acquired,
1569 * its value is 0 (InvalidXLogRecPtr), which means that we don't
1570 * know where it's inserting yet. We will have to wait for it. If
1571 * it's a small insertion, the record will most likely fit on the
1572 * same page and the inserter will release the lock without ever
1573 * calling LWLockUpdateVar. But if it has to sleep, it will
1574 * advertise the insertion point with LWLockUpdateVar before
1575 * sleeping.
1576 *
1577 * In this loop we are only waiting for insertions that started
1578 * before WaitXLogInsertionsToFinish was called. The lack of
1579 * memory barriers in the loop means that we might see locks as
1580 * "unused" that have since become used. This is fine because
1581 * they only can be used for later insertions that we would not
1582 * want to wait on anyway. Not taking a lock to acquire the
1583 * current insertingAt value means that we might see older
1584 * insertingAt values. This is also fine, because if we read a
1585 * value too old, we will add ourselves to the wait queue, which
1586 * contains atomic operations.
1587 */
1588 if (LWLockWaitForVar(&WALInsertLocks[i].l.lock,
1590 insertingat, &insertingat))
1591 {
1592 /* the lock was free, so no insertion in progress */
1593 insertingat = InvalidXLogRecPtr;
1594 break;
1595 }
1596
1597 /*
1598 * This insertion is still in progress. Have to wait, unless the
1599 * inserter has proceeded past 'upto'.
1600 */
1601 } while (insertingat < upto);
1602
1603 if (insertingat != InvalidXLogRecPtr && insertingat < finishedUpto)
1604 finishedUpto = insertingat;
1605 }
1606
1607 /*
1608 * Advance the limit we know to have been inserted and return the freshest
1609 * value we know of, which might be beyond what we requested if somebody
1610 * is concurrently doing this with an 'upto' pointer ahead of us.
1611 */
1613 finishedUpto);
1614
1615 return finishedUpto;
1616}
1617
1618/*
1619 * Get a pointer to the right location in the WAL buffer containing the
1620 * given XLogRecPtr.
1621 *
1622 * If the page is not initialized yet, it is initialized. That might require
1623 * evicting an old dirty buffer from the buffer cache, which means I/O.
1624 *
1625 * The caller must ensure that the page containing the requested location
1626 * isn't evicted yet, and won't be evicted. The way to ensure that is to
1627 * hold onto a WAL insertion lock with the insertingAt position set to
1628 * something <= ptr. GetXLogBuffer() will update insertingAt if it needs
1629 * to evict an old page from the buffer. (This means that once you call
1630 * GetXLogBuffer() with a given 'ptr', you must not access anything before
1631 * that point anymore, and must not call GetXLogBuffer() with an older 'ptr'
1632 * later, because older buffers might be recycled already)
1633 */
1634static char *
1636{
1637 int idx;
1638 XLogRecPtr endptr;
1639 static uint64 cachedPage = 0;
1640 static char *cachedPos = NULL;
1641 XLogRecPtr expectedEndPtr;
1642
1643 /*
1644 * Fast path for the common case that we need to access again the same
1645 * page as last time.
1646 */
1647 if (ptr / XLOG_BLCKSZ == cachedPage)
1648 {
1649 Assert(((XLogPageHeader) cachedPos)->xlp_magic == XLOG_PAGE_MAGIC);
1650 Assert(((XLogPageHeader) cachedPos)->xlp_pageaddr == ptr - (ptr % XLOG_BLCKSZ));
1651 return cachedPos + ptr % XLOG_BLCKSZ;
1652 }
1653
1654 /*
1655 * The XLog buffer cache is organized so that a page is always loaded to a
1656 * particular buffer. That way we can easily calculate the buffer a given
1657 * page must be loaded into, from the XLogRecPtr alone.
1658 */
1659 idx = XLogRecPtrToBufIdx(ptr);
1660
1661 /*
1662 * See what page is loaded in the buffer at the moment. It could be the
1663 * page we're looking for, or something older. It can't be anything newer
1664 * - that would imply the page we're looking for has already been written
1665 * out to disk and evicted, and the caller is responsible for making sure
1666 * that doesn't happen.
1667 *
1668 * We don't hold a lock while we read the value. If someone is just about
1669 * to initialize or has just initialized the page, it's possible that we
1670 * get InvalidXLogRecPtr. That's ok, we'll grab the mapping lock (in
1671 * AdvanceXLInsertBuffer) and retry if we see anything other than the page
1672 * we're looking for.
1673 */
1674 expectedEndPtr = ptr;
1675 expectedEndPtr += XLOG_BLCKSZ - ptr % XLOG_BLCKSZ;
1676
1678 if (expectedEndPtr != endptr)
1679 {
1680 XLogRecPtr initializedUpto;
1681
1682 /*
1683 * Before calling AdvanceXLInsertBuffer(), which can block, let others
1684 * know how far we're finished with inserting the record.
1685 *
1686 * NB: If 'ptr' points to just after the page header, advertise a
1687 * position at the beginning of the page rather than 'ptr' itself. If
1688 * there are no other insertions running, someone might try to flush
1689 * up to our advertised location. If we advertised a position after
1690 * the page header, someone might try to flush the page header, even
1691 * though page might actually not be initialized yet. As the first
1692 * inserter on the page, we are effectively responsible for making
1693 * sure that it's initialized, before we let insertingAt to move past
1694 * the page header.
1695 */
1696 if (ptr % XLOG_BLCKSZ == SizeOfXLogShortPHD &&
1697 XLogSegmentOffset(ptr, wal_segment_size) > XLOG_BLCKSZ)
1698 initializedUpto = ptr - SizeOfXLogShortPHD;
1699 else if (ptr % XLOG_BLCKSZ == SizeOfXLogLongPHD &&
1700 XLogSegmentOffset(ptr, wal_segment_size) < XLOG_BLCKSZ)
1701 initializedUpto = ptr - SizeOfXLogLongPHD;
1702 else
1703 initializedUpto = ptr;
1704
1705 WALInsertLockUpdateInsertingAt(initializedUpto);
1706
1707 AdvanceXLInsertBuffer(ptr, tli, false);
1709
1710 if (expectedEndPtr != endptr)
1711 elog(PANIC, "could not find WAL buffer for %X/%08X",
1712 LSN_FORMAT_ARGS(ptr));
1713 }
1714 else
1715 {
1716 /*
1717 * Make sure the initialization of the page is visible to us, and
1718 * won't arrive later to overwrite the WAL data we write on the page.
1719 */
1721 }
1722
1723 /*
1724 * Found the buffer holding this page. Return a pointer to the right
1725 * offset within the page.
1726 */
1727 cachedPage = ptr / XLOG_BLCKSZ;
1728 cachedPos = XLogCtl->pages + idx * (Size) XLOG_BLCKSZ;
1729
1730 Assert(((XLogPageHeader) cachedPos)->xlp_magic == XLOG_PAGE_MAGIC);
1731 Assert(((XLogPageHeader) cachedPos)->xlp_pageaddr == ptr - (ptr % XLOG_BLCKSZ));
1732
1733 return cachedPos + ptr % XLOG_BLCKSZ;
1734}
1735
1736/*
1737 * Read WAL data directly from WAL buffers, if available. Returns the number
1738 * of bytes read successfully.
1739 *
1740 * Fewer than 'count' bytes may be read if some of the requested WAL data has
1741 * already been evicted.
1742 *
1743 * No locks are taken.
1744 *
1745 * Caller should ensure that it reads no further than LogwrtResult.Write
1746 * (which should have been updated by the caller when determining how far to
1747 * read). The 'tli' argument is only used as a convenient safety check so that
1748 * callers do not read from WAL buffers on a historical timeline.
1749 */
1750Size
1751WALReadFromBuffers(char *dstbuf, XLogRecPtr startptr, Size count,
1752 TimeLineID tli)
1753{
1754 char *pdst = dstbuf;
1755 XLogRecPtr recptr = startptr;
1756 XLogRecPtr inserted;
1757 Size nbytes = count;
1758
1760 return 0;
1761
1762 Assert(!XLogRecPtrIsInvalid(startptr));
1763
1764 /*
1765 * Caller should ensure that the requested data has been inserted into WAL
1766 * buffers before we try to read it.
1767 */
1769 if (startptr + count > inserted)
1770 ereport(ERROR,
1771 errmsg("cannot read past end of generated WAL: requested %X/%08X, current position %X/%08X",
1772 LSN_FORMAT_ARGS(startptr + count),
1773 LSN_FORMAT_ARGS(inserted)));
1774
1775 /*
1776 * Loop through the buffers without a lock. For each buffer, atomically
1777 * read and verify the end pointer, then copy the data out, and finally
1778 * re-read and re-verify the end pointer.
1779 *
1780 * Once a page is evicted, it never returns to the WAL buffers, so if the
1781 * end pointer matches the expected end pointer before and after we copy
1782 * the data, then the right page must have been present during the data
1783 * copy. Read barriers are necessary to ensure that the data copy actually
1784 * happens between the two verification steps.
1785 *
1786 * If either verification fails, we simply terminate the loop and return
1787 * with the data that had been already copied out successfully.
1788 */
1789 while (nbytes > 0)
1790 {
1791 uint32 offset = recptr % XLOG_BLCKSZ;
1792 int idx = XLogRecPtrToBufIdx(recptr);
1793 XLogRecPtr expectedEndPtr;
1794 XLogRecPtr endptr;
1795 const char *page;
1796 const char *psrc;
1797 Size npagebytes;
1798
1799 /*
1800 * Calculate the end pointer we expect in the xlblocks array if the
1801 * correct page is present.
1802 */
1803 expectedEndPtr = recptr + (XLOG_BLCKSZ - offset);
1804
1805 /*
1806 * First verification step: check that the correct page is present in
1807 * the WAL buffers.
1808 */
1810 if (expectedEndPtr != endptr)
1811 break;
1812
1813 /*
1814 * The correct page is present (or was at the time the endptr was
1815 * read; must re-verify later). Calculate pointer to source data and
1816 * determine how much data to read from this page.
1817 */
1818 page = XLogCtl->pages + idx * (Size) XLOG_BLCKSZ;
1819 psrc = page + offset;
1820 npagebytes = Min(nbytes, XLOG_BLCKSZ - offset);
1821
1822 /*
1823 * Ensure that the data copy and the first verification step are not
1824 * reordered.
1825 */
1827
1828 /* data copy */
1829 memcpy(pdst, psrc, npagebytes);
1830
1831 /*
1832 * Ensure that the data copy and the second verification step are not
1833 * reordered.
1834 */
1836
1837 /*
1838 * Second verification step: check that the page we read from wasn't
1839 * evicted while we were copying the data.
1840 */
1842 if (expectedEndPtr != endptr)
1843 break;
1844
1845 pdst += npagebytes;
1846 recptr += npagebytes;
1847 nbytes -= npagebytes;
1848 }
1849
1850 Assert(pdst - dstbuf <= count);
1851
1852 return pdst - dstbuf;
1853}
1854
1855/*
1856 * Converts a "usable byte position" to XLogRecPtr. A usable byte position
1857 * is the position starting from the beginning of WAL, excluding all WAL
1858 * page headers.
1859 */
1860static XLogRecPtr
1862{
1863 uint64 fullsegs;
1864 uint64 fullpages;
1865 uint64 bytesleft;
1866 uint32 seg_offset;
1867 XLogRecPtr result;
1868
1869 fullsegs = bytepos / UsableBytesInSegment;
1870 bytesleft = bytepos % UsableBytesInSegment;
1871
1872 if (bytesleft < XLOG_BLCKSZ - SizeOfXLogLongPHD)
1873 {
1874 /* fits on first page of segment */
1875 seg_offset = bytesleft + SizeOfXLogLongPHD;
1876 }
1877 else
1878 {
1879 /* account for the first page on segment with long header */
1880 seg_offset = XLOG_BLCKSZ;
1881 bytesleft -= XLOG_BLCKSZ - SizeOfXLogLongPHD;
1882
1883 fullpages = bytesleft / UsableBytesInPage;
1884 bytesleft = bytesleft % UsableBytesInPage;
1885
1886 seg_offset += fullpages * XLOG_BLCKSZ + bytesleft + SizeOfXLogShortPHD;
1887 }
1888
1889 XLogSegNoOffsetToRecPtr(fullsegs, seg_offset, wal_segment_size, result);
1890
1891 return result;
1892}
1893
1894/*
1895 * Like XLogBytePosToRecPtr, but if the position is at a page boundary,
1896 * returns a pointer to the beginning of the page (ie. before page header),
1897 * not to where the first xlog record on that page would go to. This is used
1898 * when converting a pointer to the end of a record.
1899 */
1900static XLogRecPtr
1902{
1903 uint64 fullsegs;
1904 uint64 fullpages;
1905 uint64 bytesleft;
1906 uint32 seg_offset;
1907 XLogRecPtr result;
1908
1909 fullsegs = bytepos / UsableBytesInSegment;
1910 bytesleft = bytepos % UsableBytesInSegment;
1911
1912 if (bytesleft < XLOG_BLCKSZ - SizeOfXLogLongPHD)
1913 {
1914 /* fits on first page of segment */
1915 if (bytesleft == 0)
1916 seg_offset = 0;
1917 else
1918 seg_offset = bytesleft + SizeOfXLogLongPHD;
1919 }
1920 else
1921 {
1922 /* account for the first page on segment with long header */
1923 seg_offset = XLOG_BLCKSZ;
1924 bytesleft -= XLOG_BLCKSZ - SizeOfXLogLongPHD;
1925
1926 fullpages = bytesleft / UsableBytesInPage;
1927 bytesleft = bytesleft % UsableBytesInPage;
1928
1929 if (bytesleft == 0)
1930 seg_offset += fullpages * XLOG_BLCKSZ + bytesleft;
1931 else
1932 seg_offset += fullpages * XLOG_BLCKSZ + bytesleft + SizeOfXLogShortPHD;
1933 }
1934
1935 XLogSegNoOffsetToRecPtr(fullsegs, seg_offset, wal_segment_size, result);
1936
1937 return result;
1938}
1939
1940/*
1941 * Convert an XLogRecPtr to a "usable byte position".
1942 */
1943static uint64
1945{
1946 uint64 fullsegs;
1947 uint32 fullpages;
1948 uint32 offset;
1949 uint64 result;
1950
1951 XLByteToSeg(ptr, fullsegs, wal_segment_size);
1952
1953 fullpages = (XLogSegmentOffset(ptr, wal_segment_size)) / XLOG_BLCKSZ;
1954 offset = ptr % XLOG_BLCKSZ;
1955
1956 if (fullpages == 0)
1957 {
1958 result = fullsegs * UsableBytesInSegment;
1959 if (offset > 0)
1960 {
1961 Assert(offset >= SizeOfXLogLongPHD);
1962 result += offset - SizeOfXLogLongPHD;
1963 }
1964 }
1965 else
1966 {
1967 result = fullsegs * UsableBytesInSegment +
1968 (XLOG_BLCKSZ - SizeOfXLogLongPHD) + /* account for first page */
1969 (fullpages - 1) * UsableBytesInPage; /* full pages */
1970 if (offset > 0)
1971 {
1972 Assert(offset >= SizeOfXLogShortPHD);
1973 result += offset - SizeOfXLogShortPHD;
1974 }
1975 }
1976
1977 return result;
1978}
1979
1980/*
1981 * Initialize XLOG buffers, writing out old buffers if they still contain
1982 * unwritten data, upto the page containing 'upto'. Or if 'opportunistic' is
1983 * true, initialize as many pages as we can without having to write out
1984 * unwritten data. Any new pages are initialized to zeros, with pages headers
1985 * initialized properly.
1986 */
1987static void
1988AdvanceXLInsertBuffer(XLogRecPtr upto, TimeLineID tli, bool opportunistic)
1989{
1991 int nextidx;
1992 XLogRecPtr OldPageRqstPtr;
1993 XLogwrtRqst WriteRqst;
1994 XLogRecPtr NewPageEndPtr = InvalidXLogRecPtr;
1995 XLogRecPtr NewPageBeginPtr;
1996 XLogPageHeader NewPage;
1997 int npages pg_attribute_unused() = 0;
1998
1999 LWLockAcquire(WALBufMappingLock, LW_EXCLUSIVE);
2000
2001 /*
2002 * Now that we have the lock, check if someone initialized the page
2003 * already.
2004 */
2005 while (upto >= XLogCtl->InitializedUpTo || opportunistic)
2006 {
2008
2009 /*
2010 * Get ending-offset of the buffer page we need to replace (this may
2011 * be zero if the buffer hasn't been used yet). Fall through if it's
2012 * already written out.
2013 */
2014 OldPageRqstPtr = pg_atomic_read_u64(&XLogCtl->xlblocks[nextidx]);
2015 if (LogwrtResult.Write < OldPageRqstPtr)
2016 {
2017 /*
2018 * Nope, got work to do. If we just want to pre-initialize as much
2019 * as we can without flushing, give up now.
2020 */
2021 if (opportunistic)
2022 break;
2023
2024 /* Advance shared memory write request position */
2026 if (XLogCtl->LogwrtRqst.Write < OldPageRqstPtr)
2027 XLogCtl->LogwrtRqst.Write = OldPageRqstPtr;
2029
2030 /*
2031 * Acquire an up-to-date LogwrtResult value and see if we still
2032 * need to write it or if someone else already did.
2033 */
2035 if (LogwrtResult.Write < OldPageRqstPtr)
2036 {
2037 /*
2038 * Must acquire write lock. Release WALBufMappingLock first,
2039 * to make sure that all insertions that we need to wait for
2040 * can finish (up to this same position). Otherwise we risk
2041 * deadlock.
2042 */
2043 LWLockRelease(WALBufMappingLock);
2044
2045 WaitXLogInsertionsToFinish(OldPageRqstPtr);
2046
2047 LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
2048
2050 if (LogwrtResult.Write >= OldPageRqstPtr)
2051 {
2052 /* OK, someone wrote it already */
2053 LWLockRelease(WALWriteLock);
2054 }
2055 else
2056 {
2057 /* Have to write it ourselves */
2058 TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_START();
2059 WriteRqst.Write = OldPageRqstPtr;
2060 WriteRqst.Flush = 0;
2061 XLogWrite(WriteRqst, tli, false);
2062 LWLockRelease(WALWriteLock);
2064 TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_DONE();
2065
2066 /*
2067 * Required for the flush of pending stats WAL data, per
2068 * update of pgWalUsage.
2069 */
2070 pgstat_report_fixed = true;
2071 }
2072 /* Re-acquire WALBufMappingLock and retry */
2073 LWLockAcquire(WALBufMappingLock, LW_EXCLUSIVE);
2074 continue;
2075 }
2076 }
2077
2078 /*
2079 * Now the next buffer slot is free and we can set it up to be the
2080 * next output page.
2081 */
2082 NewPageBeginPtr = XLogCtl->InitializedUpTo;
2083 NewPageEndPtr = NewPageBeginPtr + XLOG_BLCKSZ;
2084
2085 Assert(XLogRecPtrToBufIdx(NewPageBeginPtr) == nextidx);
2086
2087 NewPage = (XLogPageHeader) (XLogCtl->pages + nextidx * (Size) XLOG_BLCKSZ);
2088
2089 /*
2090 * Mark the xlblock with InvalidXLogRecPtr and issue a write barrier
2091 * before initializing. Otherwise, the old page may be partially
2092 * zeroed but look valid.
2093 */
2096
2097 /*
2098 * Be sure to re-zero the buffer so that bytes beyond what we've
2099 * written will look like zeroes and not valid XLOG records...
2100 */
2101 MemSet(NewPage, 0, XLOG_BLCKSZ);
2102
2103 /*
2104 * Fill the new page's header
2105 */
2106 NewPage->xlp_magic = XLOG_PAGE_MAGIC;
2107
2108 /* NewPage->xlp_info = 0; */ /* done by memset */
2109 NewPage->xlp_tli = tli;
2110 NewPage->xlp_pageaddr = NewPageBeginPtr;
2111
2112 /* NewPage->xlp_rem_len = 0; */ /* done by memset */
2113
2114 /*
2115 * If online backup is not in progress, mark the header to indicate
2116 * that WAL records beginning in this page have removable backup
2117 * blocks. This allows the WAL archiver to know whether it is safe to
2118 * compress archived WAL data by transforming full-block records into
2119 * the non-full-block format. It is sufficient to record this at the
2120 * page level because we force a page switch (in fact a segment
2121 * switch) when starting a backup, so the flag will be off before any
2122 * records can be written during the backup. At the end of a backup,
2123 * the last page will be marked as all unsafe when perhaps only part
2124 * is unsafe, but at worst the archiver would miss the opportunity to
2125 * compress a few records.
2126 */
2127 if (Insert->runningBackups == 0)
2128 NewPage->xlp_info |= XLP_BKP_REMOVABLE;
2129
2130 /*
2131 * If first page of an XLOG segment file, make it a long header.
2132 */
2133 if ((XLogSegmentOffset(NewPage->xlp_pageaddr, wal_segment_size)) == 0)
2134 {
2135 XLogLongPageHeader NewLongPage = (XLogLongPageHeader) NewPage;
2136
2137 NewLongPage->xlp_sysid = ControlFile->system_identifier;
2138 NewLongPage->xlp_seg_size = wal_segment_size;
2139 NewLongPage->xlp_xlog_blcksz = XLOG_BLCKSZ;
2140 NewPage->xlp_info |= XLP_LONG_HEADER;
2141 }
2142
2143 /*
2144 * Make sure the initialization of the page becomes visible to others
2145 * before the xlblocks update. GetXLogBuffer() reads xlblocks without
2146 * holding a lock.
2147 */
2149
2150 pg_atomic_write_u64(&XLogCtl->xlblocks[nextidx], NewPageEndPtr);
2151 XLogCtl->InitializedUpTo = NewPageEndPtr;
2152
2153 npages++;
2154 }
2155 LWLockRelease(WALBufMappingLock);
2156
2157#ifdef WAL_DEBUG
2158 if (XLOG_DEBUG && npages > 0)
2159 {
2160 elog(DEBUG1, "initialized %d pages, up to %X/%08X",
2161 npages, LSN_FORMAT_ARGS(NewPageEndPtr));
2162 }
2163#endif
2164}
2165
2166/*
2167 * Calculate CheckPointSegments based on max_wal_size_mb and
2168 * checkpoint_completion_target.
2169 */
2170static void
2172{
2173 double target;
2174
2175 /*-------
2176 * Calculate the distance at which to trigger a checkpoint, to avoid
2177 * exceeding max_wal_size_mb. This is based on two assumptions:
2178 *
2179 * a) we keep WAL for only one checkpoint cycle (prior to PG11 we kept
2180 * WAL for two checkpoint cycles to allow us to recover from the
2181 * secondary checkpoint if the first checkpoint failed, though we
2182 * only did this on the primary anyway, not on standby. Keeping just
2183 * one checkpoint simplifies processing and reduces disk space in
2184 * many smaller databases.)
2185 * b) during checkpoint, we consume checkpoint_completion_target *
2186 * number of segments consumed between checkpoints.
2187 *-------
2188 */
2189 target = (double) ConvertToXSegs(max_wal_size_mb, wal_segment_size) /
2191
2192 /* round down */
2193 CheckPointSegments = (int) target;
2194
2195 if (CheckPointSegments < 1)
2197}
2198
2199void
2201{
2204}
2205
2206void
2208{
2211}
2212
2213bool
2215{
2217 {
2218 GUC_check_errdetail("The WAL segment size must be a power of two between 1 MB and 1 GB.");
2219 return false;
2220 }
2221
2222 return true;
2223}
2224
2225/*
2226 * At a checkpoint, how many WAL segments to recycle as preallocated future
2227 * XLOG segments? Returns the highest segment that should be preallocated.
2228 */
2229static XLogSegNo
2231{
2232 XLogSegNo minSegNo;
2233 XLogSegNo maxSegNo;
2234 double distance;
2235 XLogSegNo recycleSegNo;
2236
2237 /*
2238 * Calculate the segment numbers that min_wal_size_mb and max_wal_size_mb
2239 * correspond to. Always recycle enough segments to meet the minimum, and
2240 * remove enough segments to stay below the maximum.
2241 */
2242 minSegNo = lastredoptr / wal_segment_size +
2244 maxSegNo = lastredoptr / wal_segment_size +
2246
2247 /*
2248 * Between those limits, recycle enough segments to get us through to the
2249 * estimated end of next checkpoint.
2250 *
2251 * To estimate where the next checkpoint will finish, assume that the
2252 * system runs steadily consuming CheckPointDistanceEstimate bytes between
2253 * every checkpoint.
2254 */
2256 /* add 10% for good measure. */
2257 distance *= 1.10;
2258
2259 recycleSegNo = (XLogSegNo) ceil(((double) lastredoptr + distance) /
2261
2262 if (recycleSegNo < minSegNo)
2263 recycleSegNo = minSegNo;
2264 if (recycleSegNo > maxSegNo)
2265 recycleSegNo = maxSegNo;
2266
2267 return recycleSegNo;
2268}
2269
2270/*
2271 * Check whether we've consumed enough xlog space that a checkpoint is needed.
2272 *
2273 * new_segno indicates a log file that has just been filled up (or read
2274 * during recovery). We measure the distance from RedoRecPtr to new_segno
2275 * and see if that exceeds CheckPointSegments.
2276 *
2277 * Note: it is caller's responsibility that RedoRecPtr is up-to-date.
2278 */
2279bool
2281{
2282 XLogSegNo old_segno;
2283
2285
2286 if (new_segno >= old_segno + (uint64) (CheckPointSegments - 1))
2287 return true;
2288 return false;
2289}
2290
2291/*
2292 * Write and/or fsync the log at least as far as WriteRqst indicates.
2293 *
2294 * If flexible == true, we don't have to write as far as WriteRqst, but
2295 * may stop at any convenient boundary (such as a cache or logfile boundary).
2296 * This option allows us to avoid uselessly issuing multiple writes when a
2297 * single one would do.
2298 *
2299 * Must be called with WALWriteLock held. WaitXLogInsertionsToFinish(WriteRqst)
2300 * must be called before grabbing the lock, to make sure the data is ready to
2301 * write.
2302 */
2303static void
2304XLogWrite(XLogwrtRqst WriteRqst, TimeLineID tli, bool flexible)
2305{
2306 bool ispartialpage;
2307 bool last_iteration;
2308 bool finishing_seg;
2309 int curridx;
2310 int npages;
2311 int startidx;
2312 uint32 startoffset;
2313
2314 /* We should always be inside a critical section here */
2316
2317 /*
2318 * Update local LogwrtResult (caller probably did this already, but...)
2319 */
2321
2322 /*
2323 * Since successive pages in the xlog cache are consecutively allocated,
2324 * we can usually gather multiple pages together and issue just one
2325 * write() call. npages is the number of pages we have determined can be
2326 * written together; startidx is the cache block index of the first one,
2327 * and startoffset is the file offset at which it should go. The latter
2328 * two variables are only valid when npages > 0, but we must initialize
2329 * all of them to keep the compiler quiet.
2330 */
2331 npages = 0;
2332 startidx = 0;
2333 startoffset = 0;
2334
2335 /*
2336 * Within the loop, curridx is the cache block index of the page to
2337 * consider writing. Begin at the buffer containing the next unwritten
2338 * page, or last partially written page.
2339 */
2341
2342 while (LogwrtResult.Write < WriteRqst.Write)
2343 {
2344 /*
2345 * Make sure we're not ahead of the insert process. This could happen
2346 * if we're passed a bogus WriteRqst.Write that is past the end of the
2347 * last page that's been initialized by AdvanceXLInsertBuffer.
2348 */
2349 XLogRecPtr EndPtr = pg_atomic_read_u64(&XLogCtl->xlblocks[curridx]);
2350
2351 if (LogwrtResult.Write >= EndPtr)
2352 elog(PANIC, "xlog write request %X/%08X is past end of log %X/%08X",
2354 LSN_FORMAT_ARGS(EndPtr));
2355
2356 /* Advance LogwrtResult.Write to end of current buffer page */
2357 LogwrtResult.Write = EndPtr;
2358 ispartialpage = WriteRqst.Write < LogwrtResult.Write;
2359
2362 {
2363 /*
2364 * Switch to new logfile segment. We cannot have any pending
2365 * pages here (since we dump what we have at segment end).
2366 */
2367 Assert(npages == 0);
2368 if (openLogFile >= 0)
2369 XLogFileClose();
2372 openLogTLI = tli;
2373
2374 /* create/use new log file */
2377 }
2378
2379 /* Make sure we have the current logfile open */
2380 if (openLogFile < 0)
2381 {
2384 openLogTLI = tli;
2387 }
2388
2389 /* Add current page to the set of pending pages-to-dump */
2390 if (npages == 0)
2391 {
2392 /* first of group */
2393 startidx = curridx;
2394 startoffset = XLogSegmentOffset(LogwrtResult.Write - XLOG_BLCKSZ,
2396 }
2397 npages++;
2398
2399 /*
2400 * Dump the set if this will be the last loop iteration, or if we are
2401 * at the last page of the cache area (since the next page won't be
2402 * contiguous in memory), or if we are at the end of the logfile
2403 * segment.
2404 */
2405 last_iteration = WriteRqst.Write <= LogwrtResult.Write;
2406
2407 finishing_seg = !ispartialpage &&
2408 (startoffset + npages * XLOG_BLCKSZ) >= wal_segment_size;
2409
2410 if (last_iteration ||
2411 curridx == XLogCtl->XLogCacheBlck ||
2412 finishing_seg)
2413 {
2414 char *from;
2415 Size nbytes;
2416 Size nleft;
2417 ssize_t written;
2419
2420 /* OK to write the page(s) */
2421 from = XLogCtl->pages + startidx * (Size) XLOG_BLCKSZ;
2422 nbytes = npages * (Size) XLOG_BLCKSZ;
2423 nleft = nbytes;
2424 do
2425 {
2426 errno = 0;
2427
2428 /*
2429 * Measure I/O timing to write WAL data, for pg_stat_io.
2430 */
2432
2433 pgstat_report_wait_start(WAIT_EVENT_WAL_WRITE);
2434 written = pg_pwrite(openLogFile, from, nleft, startoffset);
2436
2438 IOOP_WRITE, start, 1, written);
2439
2440 if (written <= 0)
2441 {
2442 char xlogfname[MAXFNAMELEN];
2443 int save_errno;
2444
2445 if (errno == EINTR)
2446 continue;
2447
2448 save_errno = errno;
2449 XLogFileName(xlogfname, tli, openLogSegNo,
2451 errno = save_errno;
2452 ereport(PANIC,
2454 errmsg("could not write to log file \"%s\" at offset %u, length %zu: %m",
2455 xlogfname, startoffset, nleft)));
2456 }
2457 nleft -= written;
2458 from += written;
2459 startoffset += written;
2460 } while (nleft > 0);
2461
2462 npages = 0;
2463
2464 /*
2465 * If we just wrote the whole last page of a logfile segment,
2466 * fsync the segment immediately. This avoids having to go back
2467 * and re-open prior segments when an fsync request comes along
2468 * later. Doing it here ensures that one and only one backend will
2469 * perform this fsync.
2470 *
2471 * This is also the right place to notify the Archiver that the
2472 * segment is ready to copy to archival storage, and to update the
2473 * timer for archive_timeout, and to signal for a checkpoint if
2474 * too many logfile segments have been used since the last
2475 * checkpoint.
2476 */
2477 if (finishing_seg)
2478 {
2480
2481 /* signal that we need to wakeup walsenders later */
2483
2484 LogwrtResult.Flush = LogwrtResult.Write; /* end of page */
2485
2486 if (XLogArchivingActive())
2488
2489 XLogCtl->lastSegSwitchTime = (pg_time_t) time(NULL);
2491
2492 /*
2493 * Request a checkpoint if we've consumed too much xlog since
2494 * the last one. For speed, we first check using the local
2495 * copy of RedoRecPtr, which might be out of date; if it looks
2496 * like a checkpoint is needed, forcibly update RedoRecPtr and
2497 * recheck.
2498 */
2500 {
2501 (void) GetRedoRecPtr();
2504 }
2505 }
2506 }
2507
2508 if (ispartialpage)
2509 {
2510 /* Only asked to write a partial page */
2511 LogwrtResult.Write = WriteRqst.Write;
2512 break;
2513 }
2514 curridx = NextBufIdx(curridx);
2515
2516 /* If flexible, break out of loop as soon as we wrote something */
2517 if (flexible && npages == 0)
2518 break;
2519 }
2520
2521 Assert(npages == 0);
2522
2523 /*
2524 * If asked to flush, do so
2525 */
2526 if (LogwrtResult.Flush < WriteRqst.Flush &&
2528 {
2529 /*
2530 * Could get here without iterating above loop, in which case we might
2531 * have no open file or the wrong one. However, we do not need to
2532 * fsync more than one file.
2533 */
2536 {
2537 if (openLogFile >= 0 &&
2540 XLogFileClose();
2541 if (openLogFile < 0)
2542 {
2545 openLogTLI = tli;
2548 }
2549
2551 }
2552
2553 /* signal that we need to wakeup walsenders later */
2555
2557 }
2558
2559 /*
2560 * Update shared-memory status
2561 *
2562 * We make sure that the shared 'request' values do not fall behind the
2563 * 'result' values. This is not absolutely essential, but it saves some
2564 * code in a couple of places.
2565 */
2572
2573 /*
2574 * We write Write first, bar, then Flush. When reading, the opposite must
2575 * be done (with a matching barrier in between), so that we always see a
2576 * Flush value that trails behind the Write value seen.
2577 */
2581
2582#ifdef USE_ASSERT_CHECKING
2583 {
2587
2593
2594 /* WAL written to disk is always ahead of WAL flushed */
2595 Assert(Write >= Flush);
2596
2597 /* WAL inserted to buffers is always ahead of WAL written */
2598 Assert(Insert >= Write);
2599 }
2600#endif
2601}
2602
2603/*
2604 * Record the LSN for an asynchronous transaction commit/abort
2605 * and nudge the WALWriter if there is work for it to do.
2606 * (This should not be called for synchronous commits.)
2607 */
2608void
2610{
2611 XLogRecPtr WriteRqstPtr = asyncXactLSN;
2612 bool sleeping;
2613 bool wakeup = false;
2614 XLogRecPtr prevAsyncXactLSN;
2615
2617 sleeping = XLogCtl->WalWriterSleeping;
2618 prevAsyncXactLSN = XLogCtl->asyncXactLSN;
2619 if (XLogCtl->asyncXactLSN < asyncXactLSN)
2620 XLogCtl->asyncXactLSN = asyncXactLSN;
2622
2623 /*
2624 * If somebody else already called this function with a more aggressive
2625 * LSN, they will have done what we needed (and perhaps more).
2626 */
2627 if (asyncXactLSN <= prevAsyncXactLSN)
2628 return;
2629
2630 /*
2631 * If the WALWriter is sleeping, kick it to make it come out of low-power
2632 * mode, so that this async commit will reach disk within the expected
2633 * amount of time. Otherwise, determine whether it has enough WAL
2634 * available to flush, the same way that XLogBackgroundFlush() does.
2635 */
2636 if (sleeping)
2637 wakeup = true;
2638 else
2639 {
2640 int flushblocks;
2641
2643
2644 flushblocks =
2645 WriteRqstPtr / XLOG_BLCKSZ - LogwrtResult.Flush / XLOG_BLCKSZ;
2646
2647 if (WalWriterFlushAfter == 0 || flushblocks >= WalWriterFlushAfter)
2648 wakeup = true;
2649 }
2650
2651 if (wakeup)
2652 {
2653 volatile PROC_HDR *procglobal = ProcGlobal;
2654 ProcNumber walwriterProc = procglobal->walwriterProc;
2655
2656 if (walwriterProc != INVALID_PROC_NUMBER)
2657 SetLatch(&GetPGProcByNumber(walwriterProc)->procLatch);
2658 }
2659}
2660
2661/*
2662 * Record the LSN up to which we can remove WAL because it's not required by
2663 * any replication slot.
2664 */
2665void
2667{
2671}
2672
2673
2674/*
2675 * Return the oldest LSN we must retain to satisfy the needs of some
2676 * replication slot.
2677 */
2678static XLogRecPtr
2680{
2681 XLogRecPtr retval;
2682
2686
2687 return retval;
2688}
2689
2690/*
2691 * Advance minRecoveryPoint in control file.
2692 *
2693 * If we crash during recovery, we must reach this point again before the
2694 * database is consistent.
2695 *
2696 * If 'force' is true, 'lsn' argument is ignored. Otherwise, minRecoveryPoint
2697 * is only updated if it's not already greater than or equal to 'lsn'.
2698 */
2699static void
2701{
2702 /* Quick check using our local copy of the variable */
2703 if (!updateMinRecoveryPoint || (!force && lsn <= LocalMinRecoveryPoint))
2704 return;
2705
2706 /*
2707 * An invalid minRecoveryPoint means that we need to recover all the WAL,
2708 * i.e., we're doing crash recovery. We never modify the control file's
2709 * value in that case, so we can short-circuit future checks here too. The
2710 * local values of minRecoveryPoint and minRecoveryPointTLI should not be
2711 * updated until crash recovery finishes. We only do this for the startup
2712 * process as it should not update its own reference of minRecoveryPoint
2713 * until it has finished crash recovery to make sure that all WAL
2714 * available is replayed in this case. This also saves from extra locks
2715 * taken on the control file from the startup process.
2716 */
2718 {
2719 updateMinRecoveryPoint = false;
2720 return;
2721 }
2722
2723 LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
2724
2725 /* update local copy */
2728
2730 updateMinRecoveryPoint = false;
2731 else if (force || LocalMinRecoveryPoint < lsn)
2732 {
2733 XLogRecPtr newMinRecoveryPoint;
2734 TimeLineID newMinRecoveryPointTLI;
2735
2736 /*
2737 * To avoid having to update the control file too often, we update it
2738 * all the way to the last record being replayed, even though 'lsn'
2739 * would suffice for correctness. This also allows the 'force' case
2740 * to not need a valid 'lsn' value.
2741 *
2742 * Another important reason for doing it this way is that the passed
2743 * 'lsn' value could be bogus, i.e., past the end of available WAL, if
2744 * the caller got it from a corrupted heap page. Accepting such a
2745 * value as the min recovery point would prevent us from coming up at
2746 * all. Instead, we just log a warning and continue with recovery.
2747 * (See also the comments about corrupt LSNs in XLogFlush.)
2748 */
2749 newMinRecoveryPoint = GetCurrentReplayRecPtr(&newMinRecoveryPointTLI);
2750 if (!force && newMinRecoveryPoint < lsn)
2751 elog(WARNING,
2752 "xlog min recovery request %X/%08X is past current point %X/%08X",
2753 LSN_FORMAT_ARGS(lsn), LSN_FORMAT_ARGS(newMinRecoveryPoint));
2754
2755 /* update control file */
2756 if (ControlFile->minRecoveryPoint < newMinRecoveryPoint)
2757 {
2758 ControlFile->minRecoveryPoint = newMinRecoveryPoint;
2759 ControlFile->minRecoveryPointTLI = newMinRecoveryPointTLI;
2761 LocalMinRecoveryPoint = newMinRecoveryPoint;
2762 LocalMinRecoveryPointTLI = newMinRecoveryPointTLI;
2763
2765 errmsg_internal("updated min recovery point to %X/%08X on timeline %u",
2766 LSN_FORMAT_ARGS(newMinRecoveryPoint),
2767 newMinRecoveryPointTLI));
2768 }
2769 }
2770 LWLockRelease(ControlFileLock);
2771}
2772
2773/*
2774 * Ensure that all XLOG data through the given position is flushed to disk.
2775 *
2776 * NOTE: this differs from XLogWrite mainly in that the WALWriteLock is not
2777 * already held, and we try to avoid acquiring it if possible.
2778 */
2779void
2781{
2782 XLogRecPtr WriteRqstPtr;
2783 XLogwrtRqst WriteRqst;
2784 TimeLineID insertTLI = XLogCtl->InsertTimeLineID;
2785
2786 /*
2787 * During REDO, we are reading not writing WAL. Therefore, instead of
2788 * trying to flush the WAL, we should update minRecoveryPoint instead. We
2789 * test XLogInsertAllowed(), not InRecovery, because we need checkpointer
2790 * to act this way too, and because when it tries to write the
2791 * end-of-recovery checkpoint, it should indeed flush.
2792 */
2793 if (!XLogInsertAllowed())
2794 {
2795 UpdateMinRecoveryPoint(record, false);
2796 return;
2797 }
2798
2799 /* Quick exit if already known flushed */
2800 if (record <= LogwrtResult.Flush)
2801 return;
2802
2803#ifdef WAL_DEBUG
2804 if (XLOG_DEBUG)
2805 elog(LOG, "xlog flush request %X/%08X; write %X/%08X; flush %X/%08X",
2806 LSN_FORMAT_ARGS(record),
2809#endif
2810
2812
2813 /*
2814 * Since fsync is usually a horribly expensive operation, we try to
2815 * piggyback as much data as we can on each fsync: if we see any more data
2816 * entered into the xlog buffer, we'll write and fsync that too, so that
2817 * the final value of LogwrtResult.Flush is as large as possible. This
2818 * gives us some chance of avoiding another fsync immediately after.
2819 */
2820
2821 /* initialize to given target; may increase below */
2822 WriteRqstPtr = record;
2823
2824 /*
2825 * Now wait until we get the write lock, or someone else does the flush
2826 * for us.
2827 */
2828 for (;;)
2829 {
2830 XLogRecPtr insertpos;
2831
2832 /* done already? */
2834 if (record <= LogwrtResult.Flush)
2835 break;
2836
2837 /*
2838 * Before actually performing the write, wait for all in-flight
2839 * insertions to the pages we're about to write to finish.
2840 */
2842 if (WriteRqstPtr < XLogCtl->LogwrtRqst.Write)
2843 WriteRqstPtr = XLogCtl->LogwrtRqst.Write;
2845 insertpos = WaitXLogInsertionsToFinish(WriteRqstPtr);
2846
2847 /*
2848 * Try to get the write lock. If we can't get it immediately, wait
2849 * until it's released, and recheck if we still need to do the flush
2850 * or if the backend that held the lock did it for us already. This
2851 * helps to maintain a good rate of group committing when the system
2852 * is bottlenecked by the speed of fsyncing.
2853 */
2854 if (!LWLockAcquireOrWait(WALWriteLock, LW_EXCLUSIVE))
2855 {
2856 /*
2857 * The lock is now free, but we didn't acquire it yet. Before we
2858 * do, loop back to check if someone else flushed the record for
2859 * us already.
2860 */
2861 continue;
2862 }
2863
2864 /* Got the lock; recheck whether request is satisfied */
2866 if (record <= LogwrtResult.Flush)
2867 {
2868 LWLockRelease(WALWriteLock);
2869 break;
2870 }
2871
2872 /*
2873 * Sleep before flush! By adding a delay here, we may give further
2874 * backends the opportunity to join the backlog of group commit
2875 * followers; this can significantly improve transaction throughput,
2876 * at the risk of increasing transaction latency.
2877 *
2878 * We do not sleep if enableFsync is not turned on, nor if there are
2879 * fewer than CommitSiblings other backends with active transactions.
2880 */
2881 if (CommitDelay > 0 && enableFsync &&
2883 {
2885
2886 /*
2887 * Re-check how far we can now flush the WAL. It's generally not
2888 * safe to call WaitXLogInsertionsToFinish while holding
2889 * WALWriteLock, because an in-progress insertion might need to
2890 * also grab WALWriteLock to make progress. But we know that all
2891 * the insertions up to insertpos have already finished, because
2892 * that's what the earlier WaitXLogInsertionsToFinish() returned.
2893 * We're only calling it again to allow insertpos to be moved
2894 * further forward, not to actually wait for anyone.
2895 */
2896 insertpos = WaitXLogInsertionsToFinish(insertpos);
2897 }
2898
2899 /* try to write/flush later additions to XLOG as well */
2900 WriteRqst.Write = insertpos;
2901 WriteRqst.Flush = insertpos;
2902
2903 XLogWrite(WriteRqst, insertTLI, false);
2904
2905 LWLockRelease(WALWriteLock);
2906 /* done */
2907 break;
2908 }
2909
2911
2912 /* wake up walsenders now that we've released heavily contended locks */
2914
2915 /*
2916 * If we still haven't flushed to the request point then we have a
2917 * problem; most likely, the requested flush point is past end of XLOG.
2918 * This has been seen to occur when a disk page has a corrupted LSN.
2919 *
2920 * Formerly we treated this as a PANIC condition, but that hurts the
2921 * system's robustness rather than helping it: we do not want to take down
2922 * the whole system due to corruption on one data page. In particular, if
2923 * the bad page is encountered again during recovery then we would be
2924 * unable to restart the database at all! (This scenario actually
2925 * happened in the field several times with 7.1 releases.) As of 8.4, bad
2926 * LSNs encountered during recovery are UpdateMinRecoveryPoint's problem;
2927 * the only time we can reach here during recovery is while flushing the
2928 * end-of-recovery checkpoint record, and we don't expect that to have a
2929 * bad LSN.
2930 *
2931 * Note that for calls from xact.c, the ERROR will be promoted to PANIC
2932 * since xact.c calls this routine inside a critical section. However,
2933 * calls from bufmgr.c are not within critical sections and so we will not
2934 * force a restart for a bad LSN on a data page.
2935 */
2936 if (LogwrtResult.Flush < record)
2937 elog(ERROR,
2938 "xlog flush request %X/%08X is not satisfied --- flushed only to %X/%08X",
2939 LSN_FORMAT_ARGS(record),
2941
2942 /*
2943 * Cross-check XLogNeedsFlush(). Some of the checks of XLogFlush() and
2944 * XLogNeedsFlush() are duplicated, and this assertion ensures that these
2945 * remain consistent.
2946 */
2947 Assert(!XLogNeedsFlush(record));
2948}
2949
2950/*
2951 * Write & flush xlog, but without specifying exactly where to.
2952 *
2953 * We normally write only completed blocks; but if there is nothing to do on
2954 * that basis, we check for unwritten async commits in the current incomplete
2955 * block, and write through the latest one of those. Thus, if async commits
2956 * are not being used, we will write complete blocks only.
2957 *
2958 * If, based on the above, there's anything to write we do so immediately. But
2959 * to avoid calling fsync, fdatasync et. al. at a rate that'd impact
2960 * concurrent IO, we only flush WAL every wal_writer_delay ms, or if there's
2961 * more than wal_writer_flush_after unflushed blocks.
2962 *
2963 * We can guarantee that async commits reach disk after at most three
2964 * wal_writer_delay cycles. (When flushing complete blocks, we allow XLogWrite
2965 * to write "flexibly", meaning it can stop at the end of the buffer ring;
2966 * this makes a difference only with very high load or long wal_writer_delay,
2967 * but imposes one extra cycle for the worst case for async commits.)
2968 *
2969 * This routine is invoked periodically by the background walwriter process.
2970 *
2971 * Returns true if there was any work to do, even if we skipped flushing due
2972 * to wal_writer_delay/wal_writer_flush_after.
2973 */
2974bool
2976{
2977 XLogwrtRqst WriteRqst;
2978 bool flexible = true;
2979 static TimestampTz lastflush;
2981 int flushblocks;
2982 TimeLineID insertTLI;
2983
2984 /* XLOG doesn't need flushing during recovery */
2985 if (RecoveryInProgress())
2986 return false;
2987
2988 /*
2989 * Since we're not in recovery, InsertTimeLineID is set and can't change,
2990 * so we can read it without a lock.
2991 */
2992 insertTLI = XLogCtl->InsertTimeLineID;
2993
2994 /* read updated LogwrtRqst */
2996 WriteRqst = XLogCtl->LogwrtRqst;
2998
2999 /* back off to last completed page boundary */
3000 WriteRqst.Write -= WriteRqst.Write % XLOG_BLCKSZ;
3001
3002 /* if we have already flushed that far, consider async commit records */
3004 if (WriteRqst.Write <= LogwrtResult.Flush)
3005 {
3007 WriteRqst.Write = XLogCtl->asyncXactLSN;
3009 flexible = false; /* ensure it all gets written */
3010 }
3011
3012 /*
3013 * If already known flushed, we're done. Just need to check if we are
3014 * holding an open file handle to a logfile that's no longer in use,
3015 * preventing the file from being deleted.
3016 */
3017 if (WriteRqst.Write <= LogwrtResult.Flush)
3018 {
3019 if (openLogFile >= 0)
3020 {
3023 {
3024 XLogFileClose();
3025 }
3026 }
3027 return false;
3028 }
3029
3030 /*
3031 * Determine how far to flush WAL, based on the wal_writer_delay and
3032 * wal_writer_flush_after GUCs.
3033 *
3034 * Note that XLogSetAsyncXactLSN() performs similar calculation based on
3035 * wal_writer_flush_after, to decide when to wake us up. Make sure the
3036 * logic is the same in both places if you change this.
3037 */
3039 flushblocks =
3040 WriteRqst.Write / XLOG_BLCKSZ - LogwrtResult.Flush / XLOG_BLCKSZ;
3041
3042 if (WalWriterFlushAfter == 0 || lastflush == 0)
3043 {
3044 /* first call, or block based limits disabled */
3045 WriteRqst.Flush = WriteRqst.Write;
3046 lastflush = now;
3047 }
3048 else if (TimestampDifferenceExceeds(lastflush, now, WalWriterDelay))
3049 {
3050 /*
3051 * Flush the writes at least every WalWriterDelay ms. This is
3052 * important to bound the amount of time it takes for an asynchronous
3053 * commit to hit disk.
3054 */
3055 WriteRqst.Flush = WriteRqst.Write;
3056 lastflush = now;
3057 }
3058 else if (flushblocks >= WalWriterFlushAfter)
3059 {
3060 /* exceeded wal_writer_flush_after blocks, flush */
3061 WriteRqst.Flush = WriteRqst.Write;
3062 lastflush = now;
3063 }
3064 else
3065 {
3066 /* no flushing, this time round */
3067 WriteRqst.Flush = 0;
3068 }
3069
3070#ifdef WAL_DEBUG
3071 if (XLOG_DEBUG)
3072 elog(LOG, "xlog bg flush request write %X/%08X; flush: %X/%08X, current is write %X/%08X; flush %X/%08X",
3073 LSN_FORMAT_ARGS(WriteRqst.Write),
3074 LSN_FORMAT_ARGS(WriteRqst.Flush),
3077#endif
3078
3080
3081 /* now wait for any in-progress insertions to finish and get write lock */
3083 LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
3085 if (WriteRqst.Write > LogwrtResult.Write ||
3086 WriteRqst.Flush > LogwrtResult.Flush)
3087 {
3088 XLogWrite(WriteRqst, insertTLI, flexible);
3089 }
3090 LWLockRelease(WALWriteLock);
3091
3093
3094 /* wake up walsenders now that we've released heavily contended locks */
3096
3097 /*
3098 * Great, done. To take some work off the critical path, try to initialize
3099 * as many of the no-longer-needed WAL buffers for future use as we can.
3100 */
3101 AdvanceXLInsertBuffer(InvalidXLogRecPtr, insertTLI, true);
3102
3103 /*
3104 * If we determined that we need to write data, but somebody else
3105 * wrote/flushed already, it should be considered as being active, to
3106 * avoid hibernating too early.
3107 */
3108 return true;
3109}
3110
3111/*
3112 * Test whether XLOG data has been flushed up to (at least) the given
3113 * position, or whether the minimum recovery point has been updated past
3114 * the given position.
3115 *
3116 * Returns true if a flush is still needed, or if the minimum recovery point
3117 * must be updated.
3118 *
3119 * It is possible that someone else is already in the process of flushing
3120 * that far, or has updated the minimum recovery point up to the given
3121 * position.
3122 */
3123bool
3125{
3126 /*
3127 * During recovery, we don't flush WAL but update minRecoveryPoint
3128 * instead. So "needs flush" is taken to mean whether minRecoveryPoint
3129 * would need to be updated.
3130 *
3131 * Using XLogInsertAllowed() rather than RecoveryInProgress() matters for
3132 * the case of an end-of-recovery checkpoint, where WAL data is flushed.
3133 * This check should be consistent with the one in XLogFlush().
3134 */
3135 if (!XLogInsertAllowed())
3136 {
3137 /*
3138 * An invalid minRecoveryPoint means that we need to recover all the
3139 * WAL, i.e., we're doing crash recovery. We never modify the control
3140 * file's value in that case, so we can short-circuit future checks
3141 * here too. This triggers a quick exit path for the startup process,
3142 * which cannot update its local copy of minRecoveryPoint as long as
3143 * it has not replayed all WAL available when doing crash recovery.
3144 */
3146 updateMinRecoveryPoint = false;
3147
3148 /* Quick exit if already known to be updated or cannot be updated */
3150 return false;
3151
3152 /*
3153 * Update local copy of minRecoveryPoint. But if the lock is busy,
3154 * just return a conservative guess.
3155 */
3156 if (!LWLockConditionalAcquire(ControlFileLock, LW_SHARED))
3157 return true;
3160 LWLockRelease(ControlFileLock);
3161
3162 /*
3163 * Check minRecoveryPoint for any other process than the startup
3164 * process doing crash recovery, which should not update the control
3165 * file value if crash recovery is still running.
3166 */
3168 updateMinRecoveryPoint = false;
3169
3170 /* check again */
3172 return false;
3173 else
3174 return true;
3175 }
3176
3177 /* Quick exit if already known flushed */
3178 if (record <= LogwrtResult.Flush)
3179 return false;
3180
3181 /* read LogwrtResult and update local state */
3183
3184 /* check again */
3185 if (record <= LogwrtResult.Flush)
3186 return false;
3187
3188 return true;
3189}
3190
3191/*
3192 * Try to make a given XLOG file segment exist.
3193 *
3194 * logsegno: identify segment.
3195 *
3196 * *added: on return, true if this call raised the number of extant segments.
3197 *
3198 * path: on return, this char[MAXPGPATH] has the path to the logsegno file.
3199 *
3200 * Returns -1 or FD of opened file. A -1 here is not an error; a caller
3201 * wanting an open segment should attempt to open "path", which usually will
3202 * succeed. (This is weird, but it's efficient for the callers.)
3203 */
3204static int
3206 bool *added, char *path)
3207{
3208 char tmppath[MAXPGPATH];
3209 XLogSegNo installed_segno;
3210 XLogSegNo max_segno;
3211 int fd;
3212 int save_errno;
3213 int open_flags = O_RDWR | O_CREAT | O_EXCL | PG_BINARY;
3214 instr_time io_start;
3215
3216 Assert(logtli != 0);
3217
3218 XLogFilePath(path, logtli, logsegno, wal_segment_size);
3219
3220 /*
3221 * Try to use existent file (checkpoint maker may have created it already)
3222 */
3223 *added = false;
3224 fd = BasicOpenFile(path, O_RDWR | PG_BINARY | O_CLOEXEC |
3226 if (fd < 0)
3227 {
3228 if (errno != ENOENT)
3229 ereport(ERROR,
3231 errmsg("could not open file \"%s\": %m", path)));
3232 }
3233 else
3234 return fd;
3235
3236 /*
3237 * Initialize an empty (all zeroes) segment. NOTE: it is possible that
3238 * another process is doing the same thing. If so, we will end up
3239 * pre-creating an extra log segment. That seems OK, and better than
3240 * holding the lock throughout this lengthy process.
3241 */
3242 elog(DEBUG2, "creating and filling new WAL file");
3243
3244 snprintf(tmppath, MAXPGPATH, XLOGDIR "/xlogtemp.%d", (int) getpid());
3245
3246 unlink(tmppath);
3247
3249 open_flags |= PG_O_DIRECT;
3250
3251 /* do not use get_sync_bit() here --- want to fsync only at end of fill */
3252 fd = BasicOpenFile(tmppath, open_flags);
3253 if (fd < 0)
3254 ereport(ERROR,
3256 errmsg("could not create file \"%s\": %m", tmppath)));
3257
3258 /* Measure I/O timing when initializing segment */
3260
3261 pgstat_report_wait_start(WAIT_EVENT_WAL_INIT_WRITE);
3262 save_errno = 0;
3263 if (wal_init_zero)
3264 {
3265 ssize_t rc;
3266
3267 /*
3268 * Zero-fill the file. With this setting, we do this the hard way to
3269 * ensure that all the file space has really been allocated. On
3270 * platforms that allow "holes" in files, just seeking to the end
3271 * doesn't allocate intermediate space. This way, we know that we
3272 * have all the space and (after the fsync below) that all the
3273 * indirect blocks are down on disk. Therefore, fdatasync(2) or
3274 * O_DSYNC will be sufficient to sync future writes to the log file.
3275 */
3277
3278 if (rc < 0)
3279 save_errno = errno;
3280 }
3281 else
3282 {
3283 /*
3284 * Otherwise, seeking to the end and writing a solitary byte is
3285 * enough.
3286 */
3287 errno = 0;
3288 if (pg_pwrite(fd, "\0", 1, wal_segment_size - 1) != 1)
3289 {
3290 /* if write didn't set errno, assume no disk space */
3291 save_errno = errno ? errno : ENOSPC;
3292 }
3293 }
3295
3296 /*
3297 * A full segment worth of data is written when using wal_init_zero. One
3298 * byte is written when not using it.
3299 */
3301 io_start, 1,
3303
3304 if (save_errno)
3305 {
3306 /*
3307 * If we fail to make the file, delete it to release disk space
3308 */
3309 unlink(tmppath);
3310
3311 close(fd);
3312
3313 errno = save_errno;
3314
3315 ereport(ERROR,
3317 errmsg("could not write to file \"%s\": %m", tmppath)));
3318 }
3319
3320 /* Measure I/O timing when flushing segment */
3322
3323 pgstat_report_wait_start(WAIT_EVENT_WAL_INIT_SYNC);
3324 if (pg_fsync(fd) != 0)
3325 {
3326 save_errno = errno;
3327 close(fd);
3328 errno = save_errno;
3329 ereport(ERROR,
3331 errmsg("could not fsync file \"%s\": %m", tmppath)));
3332 }
3334
3336 IOOP_FSYNC, io_start, 1, 0);
3337
3338 if (close(fd) != 0)
3339 ereport(ERROR,
3341 errmsg("could not close file \"%s\": %m", tmppath)));
3342
3343 /*
3344 * Now move the segment into place with its final name. Cope with
3345 * possibility that someone else has created the file while we were
3346 * filling ours: if so, use ours to pre-create a future log segment.
3347 */
3348 installed_segno = logsegno;
3349
3350 /*
3351 * XXX: What should we use as max_segno? We used to use XLOGfileslop when
3352 * that was a constant, but that was always a bit dubious: normally, at a
3353 * checkpoint, XLOGfileslop was the offset from the checkpoint record, but
3354 * here, it was the offset from the insert location. We can't do the
3355 * normal XLOGfileslop calculation here because we don't have access to
3356 * the prior checkpoint's redo location. So somewhat arbitrarily, just use
3357 * CheckPointSegments.
3358 */
3359 max_segno = logsegno + CheckPointSegments;
3360 if (InstallXLogFileSegment(&installed_segno, tmppath, true, max_segno,
3361 logtli))
3362 {
3363 *added = true;
3364 elog(DEBUG2, "done creating and filling new WAL file");
3365 }
3366 else
3367 {
3368 /*
3369 * No need for any more future segments, or InstallXLogFileSegment()
3370 * failed to rename the file into place. If the rename failed, a
3371 * caller opening the file may fail.
3372 */
3373 unlink(tmppath);
3374 elog(DEBUG2, "abandoned new WAL file");
3375 }
3376
3377 return -1;
3378}
3379
3380/*
3381 * Create a new XLOG file segment, or open a pre-existing one.
3382 *
3383 * logsegno: identify segment to be created/opened.
3384 *
3385 * Returns FD of opened file.
3386 *
3387 * Note: errors here are ERROR not PANIC because we might or might not be
3388 * inside a critical section (eg, during checkpoint there is no reason to
3389 * take down the system on failure). They will promote to PANIC if we are
3390 * in a critical section.
3391 */
3392int
3394{
3395 bool ignore_added;
3396 char path[MAXPGPATH];
3397 int fd;
3398
3399 Assert(logtli != 0);
3400
3401 fd = XLogFileInitInternal(logsegno, logtli, &ignore_added, path);
3402 if (fd >= 0)
3403 return fd;
3404
3405 /* Now open original target segment (might not be file I just made) */
3406 fd = BasicOpenFile(path, O_RDWR | PG_BINARY | O_CLOEXEC |
3408 if (fd < 0)
3409 ereport(ERROR,
3411 errmsg("could not open file \"%s\": %m", path)));
3412 return fd;
3413}
3414
3415/*
3416 * Create a new XLOG file segment by copying a pre-existing one.
3417 *
3418 * destsegno: identify segment to be created.
3419 *
3420 * srcTLI, srcsegno: identify segment to be copied (could be from
3421 * a different timeline)
3422 *
3423 * upto: how much of the source file to copy (the rest is filled with
3424 * zeros)
3425 *
3426 * Currently this is only used during recovery, and so there are no locking
3427 * considerations. But we should be just as tense as XLogFileInit to avoid
3428 * emplacing a bogus file.
3429 */
3430static void
3432 TimeLineID srcTLI, XLogSegNo srcsegno,
3433 int upto)
3434{
3435 char path[MAXPGPATH];
3436 char tmppath[MAXPGPATH];
3437 PGAlignedXLogBlock buffer;
3438 int srcfd;
3439 int fd;
3440 int nbytes;
3441
3442 /*
3443 * Open the source file
3444 */
3445 XLogFilePath(path, srcTLI, srcsegno, wal_segment_size);
3446 srcfd = OpenTransientFile(path, O_RDONLY | PG_BINARY);
3447 if (srcfd < 0)
3448 ereport(ERROR,
3450 errmsg("could not open file \"%s\": %m", path)));
3451
3452 /*
3453 * Copy into a temp file name.
3454 */
3455 snprintf(tmppath, MAXPGPATH, XLOGDIR "/xlogtemp.%d", (int) getpid());
3456
3457 unlink(tmppath);
3458
3459 /* do not use get_sync_bit() here --- want to fsync only at end of fill */
3460 fd = OpenTransientFile(tmppath, O_RDWR | O_CREAT | O_EXCL | PG_BINARY);
3461 if (fd < 0)
3462 ereport(ERROR,
3464 errmsg("could not create file \"%s\": %m", tmppath)));
3465
3466 /*
3467 * Do the data copying.
3468 */
3469 for (nbytes = 0; nbytes < wal_segment_size; nbytes += sizeof(buffer))
3470 {
3471 int nread;
3472
3473 nread = upto - nbytes;
3474
3475 /*
3476 * The part that is not read from the source file is filled with
3477 * zeros.
3478 */
3479 if (nread < sizeof(buffer))
3480 memset(buffer.data, 0, sizeof(buffer));
3481
3482 if (nread > 0)
3483 {
3484 int r;
3485
3486 if (nread > sizeof(buffer))
3487 nread = sizeof(buffer);
3488 pgstat_report_wait_start(WAIT_EVENT_WAL_COPY_READ);
3489 r = read(srcfd, buffer.data, nread);
3490 if (r != nread)
3491 {
3492 if (r < 0)
3493 ereport(ERROR,
3495 errmsg("could not read file \"%s\": %m",
3496 path)));
3497 else
3498 ereport(ERROR,
3500 errmsg("could not read file \"%s\": read %d of %zu",
3501 path, r, (Size) nread)));
3502 }
3504 }
3505 errno = 0;
3506 pgstat_report_wait_start(WAIT_EVENT_WAL_COPY_WRITE);
3507 if ((int) write(fd, buffer.data, sizeof(buffer)) != (int) sizeof(buffer))
3508 {
3509 int save_errno = errno;
3510
3511 /*
3512 * If we fail to make the file, delete it to release disk space
3513 */
3514 unlink(tmppath);
3515 /* if write didn't set errno, assume problem is no disk space */
3516 errno = save_errno ? save_errno : ENOSPC;
3517
3518 ereport(ERROR,
3520 errmsg("could not write to file \"%s\": %m", tmppath)));
3521 }
3523 }
3524
3525 pgstat_report_wait_start(WAIT_EVENT_WAL_COPY_SYNC);
3526 if (pg_fsync(fd) != 0)
3529 errmsg("could not fsync file \"%s\": %m", tmppath)));
3531
3532 if (CloseTransientFile(fd) != 0)
3533 ereport(ERROR,
3535 errmsg("could not close file \"%s\": %m", tmppath)));
3536
3537 if (CloseTransientFile(srcfd) != 0)
3538 ereport(ERROR,
3540 errmsg("could not close file \"%s\": %m", path)));
3541
3542 /*
3543 * Now move the segment into place with its final name.
3544 */
3545 if (!InstallXLogFileSegment(&destsegno, tmppath, false, 0, destTLI))
3546 elog(ERROR, "InstallXLogFileSegment should not have failed");
3547}
3548
3549/*
3550 * Install a new XLOG segment file as a current or future log segment.
3551 *
3552 * This is used both to install a newly-created segment (which has a temp
3553 * filename while it's being created) and to recycle an old segment.
3554 *
3555 * *segno: identify segment to install as (or first possible target).
3556 * When find_free is true, this is modified on return to indicate the
3557 * actual installation location or last segment searched.
3558 *
3559 * tmppath: initial name of file to install. It will be renamed into place.
3560 *
3561 * find_free: if true, install the new segment at the first empty segno
3562 * number at or after the passed numbers. If false, install the new segment
3563 * exactly where specified, deleting any existing segment file there.
3564 *
3565 * max_segno: maximum segment number to install the new file as. Fail if no
3566 * free slot is found between *segno and max_segno. (Ignored when find_free
3567 * is false.)
3568 *
3569 * tli: The timeline on which the new segment should be installed.
3570 *
3571 * Returns true if the file was installed successfully. false indicates that
3572 * max_segno limit was exceeded, the startup process has disabled this
3573 * function for now, or an error occurred while renaming the file into place.
3574 */
3575static bool
3576InstallXLogFileSegment(XLogSegNo *segno, char *tmppath,
3577 bool find_free, XLogSegNo max_segno, TimeLineID tli)
3578{
3579 char path[MAXPGPATH];
3580 struct stat stat_buf;
3581
3582 Assert(tli != 0);
3583
3584 XLogFilePath(path, tli, *segno, wal_segment_size);
3585
3586 LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
3588 {
3589 LWLockRelease(ControlFileLock);
3590 return false;
3591 }
3592
3593 if (!find_free)
3594 {
3595 /* Force installation: get rid of any pre-existing segment file */
3596 durable_unlink(path, DEBUG1);
3597 }
3598 else
3599 {
3600 /* Find a free slot to put it in */
3601 while (stat(path, &stat_buf) == 0)
3602 {
3603 if ((*segno) >= max_segno)
3604 {
3605 /* Failed to find a free slot within specified range */
3606 LWLockRelease(ControlFileLock);
3607 return false;
3608 }
3609 (*segno)++;
3610 XLogFilePath(path, tli, *segno, wal_segment_size);
3611 }
3612 }
3613
3614 Assert(access(path, F_OK) != 0 && errno == ENOENT);
3615 if (durable_rename(tmppath, path, LOG) != 0)
3616 {
3617 LWLockRelease(ControlFileLock);
3618 /* durable_rename already emitted log message */
3619 return false;
3620 }
3621
3622 LWLockRelease(ControlFileLock);
3623
3624 return true;
3625}
3626
3627/*
3628 * Open a pre-existing logfile segment for writing.
3629 */
3630int
3632{
3633 char path[MAXPGPATH];
3634 int fd;
3635
3636 XLogFilePath(path, tli, segno, wal_segment_size);
3637
3638 fd = BasicOpenFile(path, O_RDWR | PG_BINARY | O_CLOEXEC |
3640 if (fd < 0)
3641 ereport(PANIC,
3643 errmsg("could not open file \"%s\": %m", path)));
3644
3645 return fd;
3646}
3647
3648/*
3649 * Close the current logfile segment for writing.
3650 */
3651static void
3653{
3654 Assert(openLogFile >= 0);
3655
3656 /*
3657 * WAL segment files will not be re-read in normal operation, so we advise
3658 * the OS to release any cached pages. But do not do so if WAL archiving
3659 * or streaming is active, because archiver and walsender process could
3660 * use the cache to read the WAL segment.
3661 */
3662#if defined(USE_POSIX_FADVISE) && defined(POSIX_FADV_DONTNEED)
3663 if (!XLogIsNeeded() && (io_direct_flags & IO_DIRECT_WAL) == 0)
3664 (void) posix_fadvise(openLogFile, 0, 0, POSIX_FADV_DONTNEED);
3665#endif
3666
3667 if (close(openLogFile) != 0)
3668 {
3669 char xlogfname[MAXFNAMELEN];
3670 int save_errno = errno;
3671
3673 errno = save_errno;
3674 ereport(PANIC,
3676 errmsg("could not close file \"%s\": %m", xlogfname)));
3677 }
3678
3679 openLogFile = -1;
3681}
3682
3683/*
3684 * Preallocate log files beyond the specified log endpoint.
3685 *
3686 * XXX this is currently extremely conservative, since it forces only one
3687 * future log segment to exist, and even that only if we are 75% done with
3688 * the current one. This is only appropriate for very low-WAL-volume systems.
3689 * High-volume systems will be OK once they've built up a sufficient set of
3690 * recycled log segments, but the startup transient is likely to include
3691 * a lot of segment creations by foreground processes, which is not so good.
3692 *
3693 * XLogFileInitInternal() can ereport(ERROR). All known causes indicate big
3694 * trouble; for example, a full filesystem is one cause. The checkpoint WAL
3695 * and/or ControlFile updates already completed. If a RequestCheckpoint()
3696 * initiated the present checkpoint and an ERROR ends this function, the
3697 * command that called RequestCheckpoint() fails. That's not ideal, but it's
3698 * not worth contorting more functions to use caller-specified elevel values.
3699 * (With or without RequestCheckpoint(), an ERROR forestalls some inessential
3700 * reporting and resource reclamation.)
3701 */
3702static void
3704{
3705 XLogSegNo _logSegNo;
3706 int lf;
3707 bool added;
3708 char path[MAXPGPATH];
3709 uint64 offset;
3710
3712 return; /* unlocked check says no */
3713
3714 XLByteToPrevSeg(endptr, _logSegNo, wal_segment_size);
3715 offset = XLogSegmentOffset(endptr - 1, wal_segment_size);
3716 if (offset >= (uint32) (0.75 * wal_segment_size))
3717 {
3718 _logSegNo++;
3719 lf = XLogFileInitInternal(_logSegNo, tli, &added, path);
3720 if (lf >= 0)
3721 close(lf);
3722 if (added)
3724 }
3725}
3726
3727/*
3728 * Throws an error if the given log segment has already been removed or
3729 * recycled. The caller should only pass a segment that it knows to have
3730 * existed while the server has been running, as this function always
3731 * succeeds if no WAL segments have been removed since startup.
3732 * 'tli' is only used in the error message.
3733 *
3734 * Note: this function guarantees to keep errno unchanged on return.
3735 * This supports callers that use this to possibly deliver a better
3736 * error message about a missing file, while still being able to throw
3737 * a normal file-access error afterwards, if this does return.
3738 */
3739void
3741{
3742 int save_errno = errno;
3743 XLogSegNo lastRemovedSegNo;
3744
3746 lastRemovedSegNo = XLogCtl->lastRemovedSegNo;
3748
3749 if (segno <= lastRemovedSegNo)
3750 {
3751 char filename[MAXFNAMELEN];
3752
3754 errno = save_errno;
3755 ereport(ERROR,
3757 errmsg("requested WAL segment %s has already been removed",
3758 filename)));
3759 }
3760 errno = save_errno;
3761}
3762
3763/*
3764 * Return the last WAL segment removed, or 0 if no segment has been removed
3765 * since startup.
3766 *
3767 * NB: the result can be out of date arbitrarily fast, the caller has to deal
3768 * with that.
3769 */
3772{
3773 XLogSegNo lastRemovedSegNo;
3774
3776 lastRemovedSegNo = XLogCtl->lastRemovedSegNo;
3778
3779 return lastRemovedSegNo;
3780}
3781
3782/*
3783 * Return the oldest WAL segment on the given TLI that still exists in
3784 * XLOGDIR, or 0 if none.
3785 */
3788{
3789 DIR *xldir;
3790 struct dirent *xlde;
3791 XLogSegNo oldest_segno = 0;
3792
3793 xldir = AllocateDir(XLOGDIR);
3794 while ((xlde = ReadDir(xldir, XLOGDIR)) != NULL)
3795 {
3796 TimeLineID file_tli;
3797 XLogSegNo file_segno;
3798
3799 /* Ignore files that are not XLOG segments. */
3800 if (!IsXLogFileName(xlde->d_name))
3801 continue;
3802
3803 /* Parse filename to get TLI and segno. */
3804 XLogFromFileName(xlde->d_name, &file_tli, &file_segno,
3806
3807 /* Ignore anything that's not from the TLI of interest. */
3808 if (tli != file_tli)
3809 continue;
3810
3811 /* If it's the oldest so far, update oldest_segno. */
3812 if (oldest_segno == 0 || file_segno < oldest_segno)
3813 oldest_segno = file_segno;
3814 }
3815
3816 FreeDir(xldir);
3817 return oldest_segno;
3818}
3819
3820/*
3821 * Update the last removed segno pointer in shared memory, to reflect that the
3822 * given XLOG file has been removed.
3823 */
3824static void
3826{
3827 uint32 tli;
3828 XLogSegNo segno;
3829
3831
3833 if (segno > XLogCtl->lastRemovedSegNo)
3834 XLogCtl->lastRemovedSegNo = segno;
3836}
3837
3838/*
3839 * Remove all temporary log files in pg_wal
3840 *
3841 * This is called at the beginning of recovery after a previous crash,
3842 * at a point where no other processes write fresh WAL data.
3843 */
3844static void
3846{
3847 DIR *xldir;
3848 struct dirent *xlde;
3849
3850 elog(DEBUG2, "removing all temporary WAL segments");
3851
3852 xldir = AllocateDir(XLOGDIR);
3853 while ((xlde = ReadDir(xldir, XLOGDIR)) != NULL)
3854 {
3855 char path[MAXPGPATH];
3856
3857 if (strncmp(xlde->d_name, "xlogtemp.", 9) != 0)
3858 continue;
3859
3860 snprintf(path, MAXPGPATH, XLOGDIR "/%s", xlde->d_name);
3861 unlink(path);
3862 elog(DEBUG2, "removed temporary WAL segment \"%s\"", path);
3863 }
3864 FreeDir(xldir);
3865}
3866
3867/*
3868 * Recycle or remove all log files older or equal to passed segno.
3869 *
3870 * endptr is current (or recent) end of xlog, and lastredoptr is the
3871 * redo pointer of the last checkpoint. These are used to determine
3872 * whether we want to recycle rather than delete no-longer-wanted log files.
3873 *
3874 * insertTLI is the current timeline for XLOG insertion. Any recycled
3875 * segments should be reused for this timeline.
3876 */
3877static void
3879 TimeLineID insertTLI)
3880{
3881 DIR *xldir;
3882 struct dirent *xlde;
3883 char lastoff[MAXFNAMELEN];
3884 XLogSegNo endlogSegNo;
3885 XLogSegNo recycleSegNo;
3886
3887 /* Initialize info about where to try to recycle to */
3888 XLByteToSeg(endptr, endlogSegNo, wal_segment_size);
3889 recycleSegNo = XLOGfileslop(lastredoptr);
3890
3891 /*
3892 * Construct a filename of the last segment to be kept. The timeline ID
3893 * doesn't matter, we ignore that in the comparison. (During recovery,
3894 * InsertTimeLineID isn't set, so we can't use that.)
3895 */
3896 XLogFileName(lastoff, 0, segno, wal_segment_size);
3897
3898 elog(DEBUG2, "attempting to remove WAL segments older than log file %s",
3899 lastoff);
3900
3901 xldir = AllocateDir(XLOGDIR);
3902
3903 while ((xlde = ReadDir(xldir, XLOGDIR)) != NULL)
3904 {
3905 /* Ignore files that are not XLOG segments */
3906 if (!IsXLogFileName(xlde->d_name) &&
3908 continue;
3909
3910 /*
3911 * We ignore the timeline part of the XLOG segment identifiers in
3912 * deciding whether a segment is still needed. This ensures that we
3913 * won't prematurely remove a segment from a parent timeline. We could
3914 * probably be a little more proactive about removing segments of
3915 * non-parent timelines, but that would be a whole lot more
3916 * complicated.
3917 *
3918 * We use the alphanumeric sorting property of the filenames to decide
3919 * which ones are earlier than the lastoff segment.
3920 */
3921 if (strcmp(xlde->d_name + 8, lastoff + 8) <= 0)
3922 {
3923 if (XLogArchiveCheckDone(xlde->d_name))
3924 {
3925 /* Update the last removed location in shared memory first */
3927
3928 RemoveXlogFile(xlde, recycleSegNo, &endlogSegNo, insertTLI);
3929 }
3930 }
3931 }
3932
3933 FreeDir(xldir);
3934}
3935
3936/*
3937 * Recycle or remove WAL files that are not part of the given timeline's
3938 * history.
3939 *
3940 * This is called during recovery, whenever we switch to follow a new
3941 * timeline, and at the end of recovery when we create a new timeline. We
3942 * wouldn't otherwise care about extra WAL files lying in pg_wal, but they
3943 * might be leftover pre-allocated or recycled WAL segments on the old timeline
3944 * that we haven't used yet, and contain garbage. If we just leave them in
3945 * pg_wal, they will eventually be archived, and we can't let that happen.
3946 * Files that belong to our timeline history are valid, because we have
3947 * successfully replayed them, but from others we can't be sure.
3948 *
3949 * 'switchpoint' is the current point in WAL where we switch to new timeline,
3950 * and 'newTLI' is the new timeline we switch to.
3951 */
3952void
3954{
3955 DIR *xldir;
3956 struct dirent *xlde;
3957 char switchseg[MAXFNAMELEN];
3958 XLogSegNo endLogSegNo;
3959 XLogSegNo switchLogSegNo;
3960 XLogSegNo recycleSegNo;
3961
3962 /*
3963 * Initialize info about where to begin the work. This will recycle,
3964 * somewhat arbitrarily, 10 future segments.
3965 */
3966 XLByteToPrevSeg(switchpoint, switchLogSegNo, wal_segment_size);
3967 XLByteToSeg(switchpoint, endLogSegNo, wal_segment_size);
3968 recycleSegNo = endLogSegNo + 10;
3969
3970 /*
3971 * Construct a filename of the last segment to be kept.
3972 */
3973 XLogFileName(switchseg, newTLI, switchLogSegNo, wal_segment_size);
3974
3975 elog(DEBUG2, "attempting to remove WAL segments newer than log file %s",
3976 switchseg);
3977
3978 xldir = AllocateDir(XLOGDIR);
3979
3980 while ((xlde = ReadDir(xldir, XLOGDIR)) != NULL)
3981 {
3982 /* Ignore files that are not XLOG segments */
3983 if (!IsXLogFileName(xlde->d_name))
3984 continue;
3985
3986 /*
3987 * Remove files that are on a timeline older than the new one we're
3988 * switching to, but with a segment number >= the first segment on the
3989 * new timeline.
3990 */
3991 if (strncmp(xlde->d_name, switchseg, 8) < 0 &&
3992 strcmp(xlde->d_name + 8, switchseg + 8) > 0)
3993 {
3994 /*
3995 * If the file has already been marked as .ready, however, don't
3996 * remove it yet. It should be OK to remove it - files that are
3997 * not part of our timeline history are not required for recovery
3998 * - but seems safer to let them be archived and removed later.
3999 */
4000 if (!XLogArchiveIsReady(xlde->d_name))
4001 RemoveXlogFile(xlde, recycleSegNo, &endLogSegNo, newTLI);
4002 }
4003 }
4004
4005 FreeDir(xldir);
4006}
4007
4008/*
4009 * Recycle or remove a log file that's no longer needed.
4010 *
4011 * segment_de is the dirent structure of the segment to recycle or remove.
4012 * recycleSegNo is the segment number to recycle up to. endlogSegNo is
4013 * the segment number of the current (or recent) end of WAL.
4014 *
4015 * endlogSegNo gets incremented if the segment is recycled so as it is not
4016 * checked again with future callers of this function.
4017 *
4018 * insertTLI is the current timeline for XLOG insertion. Any recycled segments
4019 * should be used for this timeline.
4020 */
4021static void
4022RemoveXlogFile(const struct dirent *segment_de,
4023 XLogSegNo recycleSegNo, XLogSegNo *endlogSegNo,
4024 TimeLineID insertTLI)
4025{
4026 char path[MAXPGPATH];
4027#ifdef WIN32
4028 char newpath[MAXPGPATH];
4029#endif
4030 const char *segname = segment_de->d_name;
4031
4032 snprintf(path, MAXPGPATH, XLOGDIR "/%s", segname);
4033
4034 /*
4035 * Before deleting the file, see if it can be recycled as a future log
4036 * segment. Only recycle normal files, because we don't want to recycle
4037 * symbolic links pointing to a separate archive directory.
4038 */
4039 if (wal_recycle &&
4040 *endlogSegNo <= recycleSegNo &&
4041 XLogCtl->InstallXLogFileSegmentActive && /* callee rechecks this */
4042 get_dirent_type(path, segment_de, false, DEBUG2) == PGFILETYPE_REG &&
4043 InstallXLogFileSegment(endlogSegNo, path,
4044 true, recycleSegNo, insertTLI))
4045 {
4047 (errmsg_internal("recycled write-ahead log file \"%s\"",
4048 segname)));
4050 /* Needn't recheck that slot on future iterations */
4051 (*endlogSegNo)++;
4052 }
4053 else
4054 {
4055 /* No need for any more future segments, or recycling failed ... */
4056 int rc;
4057
4059 (errmsg_internal("removing write-ahead log file \"%s\"",
4060 segname)));
4061
4062#ifdef WIN32
4063
4064 /*
4065 * On Windows, if another process (e.g another backend) holds the file
4066 * open in FILE_SHARE_DELETE mode, unlink will succeed, but the file
4067 * will still show up in directory listing until the last handle is
4068 * closed. To avoid confusing the lingering deleted file for a live
4069 * WAL file that needs to be archived, rename it before deleting it.
4070 *
4071 * If another process holds the file open without FILE_SHARE_DELETE
4072 * flag, rename will fail. We'll try again at the next checkpoint.
4073 */
4074 snprintf(newpath, MAXPGPATH, "%s.deleted", path);
4075 if (rename(path, newpath) != 0)
4076 {
4077 ereport(LOG,
4079 errmsg("could not rename file \"%s\": %m",
4080 path)));
4081 return;
4082 }
4083 rc = durable_unlink(newpath, LOG);
4084#else
4085 rc = durable_unlink(path, LOG);
4086#endif
4087 if (rc != 0)
4088 {
4089 /* Message already logged by durable_unlink() */
4090 return;
4091 }
4093 }
4094
4095 XLogArchiveCleanup(segname);
4096}
4097
4098/*
4099 * Verify whether pg_wal, pg_wal/archive_status, and pg_wal/summaries exist.
4100 * If the latter do not exist, recreate them.
4101 *
4102 * It is not the goal of this function to verify the contents of these
4103 * directories, but to help in cases where someone has performed a cluster
4104 * copy for PITR purposes but omitted pg_wal from the copy.
4105 *
4106 * We could also recreate pg_wal if it doesn't exist, but a deliberate
4107 * policy decision was made not to. It is fairly common for pg_wal to be
4108 * a symlink, and if that was the DBA's intent then automatically making a
4109 * plain directory would result in degraded performance with no notice.
4110 */
4111static void
4113{
4114 char path[MAXPGPATH];
4115 struct stat stat_buf;
4116
4117 /* Check for pg_wal; if it doesn't exist, error out */
4118 if (stat(XLOGDIR, &stat_buf) != 0 ||
4119 !S_ISDIR(stat_buf.st_mode))
4120 ereport(FATAL,
4122 errmsg("required WAL directory \"%s\" does not exist",
4123 XLOGDIR)));
4124
4125 /* Check for archive_status */
4126 snprintf(path, MAXPGPATH, XLOGDIR "/archive_status");
4127 if (stat(path, &stat_buf) == 0)
4128 {
4129 /* Check for weird cases where it exists but isn't a directory */
4130 if (!S_ISDIR(stat_buf.st_mode))
4131 ereport(FATAL,
4133 errmsg("required WAL directory \"%s\" does not exist",
4134 path)));
4135 }
4136 else
4137 {
4138 ereport(LOG,
4139 (errmsg("creating missing WAL directory \"%s\"", path)));
4140 if (MakePGDirectory(path) < 0)
4141 ereport(FATAL,
4143 errmsg("could not create missing directory \"%s\": %m",
4144 path)));
4145 }
4146
4147 /* Check for summaries */
4148 snprintf(path, MAXPGPATH, XLOGDIR "/summaries");
4149 if (stat(path, &stat_buf) == 0)
4150 {
4151 /* Check for weird cases where it exists but isn't a directory */
4152 if (!S_ISDIR(stat_buf.st_mode))
4153 ereport(FATAL,
4154 (errmsg("required WAL directory \"%s\" does not exist",
4155 path)));
4156 }
4157 else
4158 {
4159 ereport(LOG,
4160 (errmsg("creating missing WAL directory \"%s\"", path)));
4161 if (MakePGDirectory(path) < 0)
4162 ereport(FATAL,
4163 (errmsg("could not create missing directory \"%s\": %m",
4164 path)));
4165 }
4166}
4167
4168/*
4169 * Remove previous backup history files. This also retries creation of
4170 * .ready files for any backup history files for which XLogArchiveNotify
4171 * failed earlier.
4172 */
4173static void
4175{
4176 DIR *xldir;
4177 struct dirent *xlde;
4178 char path[MAXPGPATH + sizeof(XLOGDIR)];
4179
4180 xldir = AllocateDir(XLOGDIR);
4181
4182 while ((xlde = ReadDir(xldir, XLOGDIR)) != NULL)
4183 {
4185 {
4186 if (XLogArchiveCheckDone(xlde->d_name))
4187 {
4188 elog(DEBUG2, "removing WAL backup history file \"%s\"",
4189 xlde->d_name);
4190 snprintf(path, sizeof(path), XLOGDIR "/%s", xlde->d_name);
4191 unlink(path);
4193 }
4194 }
4195 }
4196
4197 FreeDir(xldir);
4198}
4199
4200/*
4201 * I/O routines for pg_control
4202 *
4203 * *ControlFile is a buffer in shared memory that holds an image of the
4204 * contents of pg_control. WriteControlFile() initializes pg_control
4205 * given a preloaded buffer, ReadControlFile() loads the buffer from
4206 * the pg_control file (during postmaster or standalone-backend startup),
4207 * and UpdateControlFile() rewrites pg_control after we modify xlog state.
4208 * InitControlFile() fills the buffer with initial values.
4209 *
4210 * For simplicity, WriteControlFile() initializes the fields of pg_control
4211 * that are related to checking backend/database compatibility, and
4212 * ReadControlFile() verifies they are correct. We could split out the
4213 * I/O and compatibility-check functions, but there seems no need currently.
4214 */
4215
4216static void
4217InitControlFile(uint64 sysidentifier, uint32 data_checksum_version)
4218{
4219 char mock_auth_nonce[MOCK_AUTH_NONCE_LEN];
4220
4221 /*
4222 * Generate a random nonce. This is used for authentication requests that
4223 * will fail because the user does not exist. The nonce is used to create
4224 * a genuine-looking password challenge for the non-existent user, in lieu
4225 * of an actual stored password.
4226 */
4227 if (!pg_strong_random(mock_auth_nonce, MOCK_AUTH_NONCE_LEN))
4228 ereport(PANIC,
4229 (errcode(ERRCODE_INTERNAL_ERROR),
4230 errmsg("could not generate secret authorization token")));
4231
4232 memset(ControlFile, 0, sizeof(ControlFileData));
4233 /* Initialize pg_control status fields */
4234 ControlFile->system_identifier = sysidentifier;
4238
4239 /* Set important parameter values for use when replaying WAL */
4248 ControlFile->data_checksum_version = data_checksum_version;
4249}
4250
4251static void
4253{
4254 int fd;
4255 char buffer[PG_CONTROL_FILE_SIZE]; /* need not be aligned */
4256
4257 /*
4258 * Initialize version and compatibility-check fields
4259 */
4262
4263 ControlFile->maxAlign = MAXIMUM_ALIGNOF;
4265
4266 ControlFile->blcksz = BLCKSZ;
4267 ControlFile->relseg_size = RELSEG_SIZE;
4268 ControlFile->xlog_blcksz = XLOG_BLCKSZ;
4270
4273
4276
4277 ControlFile->float8ByVal = true; /* vestigial */
4278
4279 /*
4280 * Initialize the default 'char' signedness.
4281 *
4282 * The signedness of the char type is implementation-defined. For instance
4283 * on x86 architecture CPUs, the char data type is typically treated as
4284 * signed by default, whereas on aarch architecture CPUs, it is typically
4285 * treated as unsigned by default. In v17 or earlier, we accidentally let
4286 * C implementation signedness affect persistent data. This led to
4287 * inconsistent results when comparing char data across different
4288 * platforms.
4289 *
4290 * This flag can be used as a hint to ensure consistent behavior for
4291 * pre-v18 data files that store data sorted by the 'char' type on disk,
4292 * especially in cross-platform replication scenarios.
4293 *
4294 * Newly created database clusters unconditionally set the default char
4295 * signedness to true. pg_upgrade changes this flag for clusters that were
4296 * initialized on signedness=false platforms. As a result,
4297 * signedness=false setting will become rare over time. If we had known
4298 * about this problem during the last development cycle that forced initdb
4299 * (v8.3), we would have made all clusters signed or all clusters
4300 * unsigned. Making pg_upgrade the only source of signedness=false will
4301 * cause the population of database clusters to converge toward that
4302 * retrospective ideal.
4303 */
4305
4306 /* Contents are protected with a CRC */
4310 offsetof(ControlFileData, crc));
4312
4313 /*
4314 * We write out PG_CONTROL_FILE_SIZE bytes into pg_control, zero-padding
4315 * the excess over sizeof(ControlFileData). This reduces the odds of
4316 * premature-EOF errors when reading pg_control. We'll still fail when we
4317 * check the contents of the file, but hopefully with a more specific
4318 * error than "couldn't read pg_control".
4319 */
4320 memset(buffer, 0, PG_CONTROL_FILE_SIZE);
4321 memcpy(buffer, ControlFile, sizeof(ControlFileData));
4322
4324 O_RDWR | O_CREAT | O_EXCL | PG_BINARY);
4325 if (fd < 0)
4326 ereport(PANIC,
4328 errmsg("could not create file \"%s\": %m",
4330
4331 errno = 0;
4332 pgstat_report_wait_start(WAIT_EVENT_CONTROL_FILE_WRITE);
4334 {
4335 /* if write didn't set errno, assume problem is no disk space */
4336 if (errno == 0)
4337 errno = ENOSPC;
4338 ereport(PANIC,
4340 errmsg("could not write to file \"%s\": %m",
4342 }
4344
4345 pgstat_report_wait_start(WAIT_EVENT_CONTROL_FILE_SYNC);
4346 if (pg_fsync(fd) != 0)
4347 ereport(PANIC,
4349 errmsg("could not fsync file \"%s\": %m",
4352
4353 if (close(fd) != 0)
4354 ereport(PANIC,
4356 errmsg("could not close file \"%s\": %m",
4358}
4359
4360static void
4362{
4363 pg_crc32c crc;
4364 int fd;
4365 char wal_segsz_str[20];
4366 int r;
4367
4368 /*
4369 * Read data...
4370 */
4372 O_RDWR | PG_BINARY);
4373 if (fd < 0)
4374 ereport(PANIC,
4376 errmsg("could not open file \"%s\": %m",
4378
4379 pgstat_report_wait_start(WAIT_EVENT_CONTROL_FILE_READ);
4380 r = read(fd, ControlFile, sizeof(ControlFileData));
4381 if (r != sizeof(ControlFileData))
4382 {
4383 if (r < 0)
4384 ereport(PANIC,
4386 errmsg("could not read file \"%s\": %m",
4388 else
4389 ereport(PANIC,
4391 errmsg("could not read file \"%s\": read %d of %zu",
4392 XLOG_CONTROL_FILE, r, sizeof(ControlFileData))));
4393 }
4395
4396 close(fd);
4397
4398 /*
4399 * Check for expected pg_control format version. If this is wrong, the
4400 * CRC check will likely fail because we'll be checking the wrong number
4401 * of bytes. Complaining about wrong version will probably be more
4402 * enlightening than complaining about wrong CRC.
4403 */
4404
4406 ereport(FATAL,
4407 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4408 errmsg("database files are incompatible with server"),
4409 errdetail("The database cluster was initialized with PG_CONTROL_VERSION %d (0x%08x),"
4410 " but the server was compiled with PG_CONTROL_VERSION %d (0x%08x).",
4413 errhint("This could be a problem of mismatched byte ordering. It looks like you need to initdb.")));
4414
4416 ereport(FATAL,
4417 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4418 errmsg("database files are incompatible with server"),
4419 errdetail("The database cluster was initialized with PG_CONTROL_VERSION %d,"
4420 " but the server was compiled with PG_CONTROL_VERSION %d.",
4422 errhint("It looks like you need to initdb.")));
4423
4424 /* Now check the CRC. */
4428 offsetof(ControlFileData, crc));
4429 FIN_CRC32C(crc);
4430
4431 if (!EQ_CRC32C(crc, ControlFile->crc))
4432 ereport(FATAL,
4433 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4434 errmsg("incorrect checksum in control file")));
4435
4436 /*
4437 * Do compatibility checking immediately. If the database isn't
4438 * compatible with the backend executable, we want to abort before we can
4439 * possibly do any damage.
4440 */
4442 ereport(FATAL,
4443 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4444 errmsg("database files are incompatible with server"),
4445 /* translator: %s is a variable name and %d is its value */
4446 errdetail("The database cluster was initialized with %s %d,"
4447 " but the server was compiled with %s %d.",
4448 "CATALOG_VERSION_NO", ControlFile->catalog_version_no,
4449 "CATALOG_VERSION_NO", CATALOG_VERSION_NO),
4450 errhint("It looks like you need to initdb.")));
4451 if (ControlFile->maxAlign != MAXIMUM_ALIGNOF)
4452 ereport(FATAL,
4453 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4454 errmsg("database files are incompatible with server"),
4455 /* translator: %s is a variable name and %d is its value */
4456 errdetail("The database cluster was initialized with %s %d,"
4457 " but the server was compiled with %s %d.",
4458 "MAXALIGN", ControlFile->maxAlign,
4459 "MAXALIGN", MAXIMUM_ALIGNOF),
4460 errhint("It looks like you need to initdb.")));
4462 ereport(FATAL,
4463 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4464 errmsg("database files are incompatible with server"),
4465 errdetail("The database cluster appears to use a different floating-point number format than the server executable."),
4466 errhint("It looks like you need to initdb.")));
4467 if (ControlFile->blcksz != BLCKSZ)
4468 ereport(FATAL,
4469 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4470 errmsg("database files are incompatible with server"),
4471 /* translator: %s is a variable name and %d is its value */
4472 errdetail("The database cluster was initialized with %s %d,"
4473 " but the server was compiled with %s %d.",
4474 "BLCKSZ", ControlFile->blcksz,
4475 "BLCKSZ", BLCKSZ),
4476 errhint("It looks like you need to recompile or initdb.")));
4477 if (ControlFile->relseg_size != RELSEG_SIZE)
4478 ereport(FATAL,
4479 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4480 errmsg("database files are incompatible with server"),
4481 /* translator: %s is a variable name and %d is its value */
4482 errdetail("The database cluster was initialized with %s %d,"
4483 " but the server was compiled with %s %d.",
4484 "RELSEG_SIZE", ControlFile->relseg_size,
4485 "RELSEG_SIZE", RELSEG_SIZE),
4486 errhint("It looks like you need to recompile or initdb.")));
4487 if (ControlFile->xlog_blcksz != XLOG_BLCKSZ)
4488 ereport(FATAL,
4489 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4490 errmsg("database files are incompatible with server"),
4491 /* translator: %s is a variable name and %d is its value */
4492 errdetail("The database cluster was initialized with %s %d,"
4493 " but the server was compiled with %s %d.",
4494 "XLOG_BLCKSZ", ControlFile->xlog_blcksz,
4495 "XLOG_BLCKSZ", XLOG_BLCKSZ),
4496 errhint("It looks like you need to recompile or initdb.")));
4498 ereport(FATAL,
4499 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4500 errmsg("database files are incompatible with server"),
4501 /* translator: %s is a variable name and %d is its value */
4502 errdetail("The database cluster was initialized with %s %d,"
4503 " but the server was compiled with %s %d.",
4504 "NAMEDATALEN", ControlFile->nameDataLen,
4505 "NAMEDATALEN", NAMEDATALEN),
4506 errhint("It looks like you need to recompile or initdb.")));
4508 ereport(FATAL,
4509 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4510 errmsg("database files are incompatible with server"),
4511 /* translator: %s is a variable name and %d is its value */
4512 errdetail("The database cluster was initialized with %s %d,"
4513 " but the server was compiled with %s %d.",
4514 "INDEX_MAX_KEYS", ControlFile->indexMaxKeys,
4515 "INDEX_MAX_KEYS", INDEX_MAX_KEYS),
4516 errhint("It looks like you need to recompile or initdb.")));
4518 ereport(FATAL,
4519 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4520 errmsg("database files are incompatible with server"),
4521 /* translator: %s is a variable name and %d is its value */
4522 errdetail("The database cluster was initialized with %s %d,"
4523 " but the server was compiled with %s %d.",
4524 "TOAST_MAX_CHUNK_SIZE", ControlFile->toast_max_chunk_size,
4525 "TOAST_MAX_CHUNK_SIZE", (int) TOAST_MAX_CHUNK_SIZE),
4526 errhint("It looks like you need to recompile or initdb.")));
4528 ereport(FATAL,
4529 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4530 errmsg("database files are incompatible with server"),
4531 /* translator: %s is a variable name and %d is its value */
4532 errdetail("The database cluster was initialized with %s %d,"
4533 " but the server was compiled with %s %d.",
4534 "LOBLKSIZE", ControlFile->loblksize,
4535 "LOBLKSIZE", (int) LOBLKSIZE),
4536 errhint("It looks like you need to recompile or initdb.")));
4537
4538 Assert(ControlFile->float8ByVal); /* vestigial, not worth an error msg */
4539
4541
4543 ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4544 errmsg_plural("invalid WAL segment size in control file (%d byte)",
4545 "invalid WAL segment size in control file (%d bytes)",
4548 errdetail("The WAL segment size must be a power of two between 1 MB and 1 GB.")));
4549
4550 snprintf(wal_segsz_str, sizeof(wal_segsz_str), "%d", wal_segment_size);
4551 SetConfigOption("wal_segment_size", wal_segsz_str, PGC_INTERNAL,
4553
4554 /* check and update variables dependent on wal_segment_size */
4556 ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4557 /* translator: both %s are GUC names */
4558 errmsg("\"%s\" must be at least twice \"%s\"",
4559 "min_wal_size", "wal_segment_size")));
4560
4562 ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4563 /* translator: both %s are GUC names */
4564 errmsg("\"%s\" must be at least twice \"%s\"",
4565 "max_wal_size", "wal_segment_size")));
4566
4568 (wal_segment_size / XLOG_BLCKSZ * UsableBytesInPage) -
4570
4572
4573 /* Make the initdb settings visible as GUC variables, too */
4574 SetConfigOption("data_checksums", DataChecksumsEnabled() ? "yes" : "no",
4576}
4577
4578/*
4579 * Utility wrapper to update the control file. Note that the control
4580 * file gets flushed.
4581 */
4582static void
4584{
4586}
4587
4588/*
4589 * Returns the unique system identifier from control file.
4590 */
4591uint64
4593{
4594 Assert(ControlFile != NULL);
4596}
4597
4598/*
4599 * Returns the random nonce from control file.
4600 */
4601char *
4603{
4604 Assert(ControlFile != NULL);
4606}
4607
4608/*
4609 * Are checksums enabled for data pages?
4610 */
4611bool
4613{
4614 Assert(ControlFile != NULL);
4615 return (ControlFile->data_checksum_version > 0);
4616}
4617
4618/*
4619 * Return true if the cluster was initialized on a platform where the
4620 * default signedness of char is "signed". This function exists for code
4621 * that deals with pre-v18 data files that store data sorted by the 'char'
4622 * type on disk (e.g., GIN and GiST indexes). See the comments in
4623 * WriteControlFile() for details.
4624 */
4625bool
4627{
4629}
4630
4631/*
4632 * Returns a fake LSN for unlogged relations.
4633 *
4634 * Each call generates an LSN that is greater than any previous value
4635 * returned. The current counter value is saved and restored across clean
4636 * shutdowns, but like unlogged relations, does not survive a crash. This can
4637 * be used in lieu of real LSN values returned by XLogInsert, if you need an
4638 * LSN-like increasing sequence of numbers without writing any WAL.
4639 */
4642{
4644}
4645
4646/*
4647 * Auto-tune the number of XLOG buffers.
4648 *
4649 * The preferred setting for wal_buffers is about 3% of shared_buffers, with
4650 * a maximum of one XLOG segment (there is little reason to think that more
4651 * is helpful, at least so long as we force an fsync when switching log files)
4652 * and a minimum of 8 blocks (which was the default value prior to PostgreSQL
4653 * 9.1, when auto-tuning was added).
4654 *
4655 * This should not be called until NBuffers has received its final value.
4656 */
4657static int
4659{
4660 int xbuffers;
4661
4662 xbuffers = NBuffers / 32;
4663 if (xbuffers > (wal_segment_size / XLOG_BLCKSZ))
4664 xbuffers = (wal_segment_size / XLOG_BLCKSZ);
4665 if (xbuffers < 8)
4666 xbuffers = 8;
4667 return xbuffers;
4668}
4669
4670/*
4671 * GUC check_hook for wal_buffers
4672 */
4673bool
4675{
4676 /*
4677 * -1 indicates a request for auto-tune.
4678 */
4679 if (*newval == -1)
4680 {
4681 /*
4682 * If we haven't yet changed the boot_val default of -1, just let it
4683 * be. We'll fix it when XLOGShmemSize is called.
4684 */
4685 if (XLOGbuffers == -1)
4686 return true;
4687
4688 /* Otherwise, substitute the auto-tune value */
4690 }
4691
4692 /*
4693 * We clamp manually-set values to at least 4 blocks. Prior to PostgreSQL
4694 * 9.1, a minimum of 4 was enforced by guc.c, but since that is no longer
4695 * the case, we just silently treat such values as a request for the
4696 * minimum. (We could throw an error instead, but that doesn't seem very
4697 * helpful.)
4698 */
4699 if (*newval < 4)
4700 *newval = 4;
4701
4702 return true;
4703}
4704
4705/*
4706 * GUC check_hook for wal_consistency_checking
4707 */
4708bool
4710{
4711 char *rawstring;
4712 List *elemlist;
4713 ListCell *l;
4714 bool newwalconsistency[RM_MAX_ID + 1];
4715
4716 /* Initialize the array */
4717 MemSet(newwalconsistency, 0, (RM_MAX_ID + 1) * sizeof(bool));
4718
4719 /* Need a modifiable copy of string */
4720 rawstring = pstrdup(*newval);
4721
4722 /* Parse string into list of identifiers */
4723 if (!SplitIdentifierString(rawstring, ',', &elemlist))
4724 {
4725 /* syntax error in list */
4726 GUC_check_errdetail("List syntax is invalid.");
4727 pfree(rawstring);
4728 list_free(elemlist);
4729 return false;
4730 }
4731
4732 foreach(l, elemlist)
4733 {
4734 char *tok = (char *) lfirst(l);
4735 int rmid;
4736
4737 /* Check for 'all'. */
4738 if (pg_strcasecmp(tok, "all") == 0)
4739 {
4740 for (rmid = 0; rmid <= RM_MAX_ID; rmid++)
4741 if (RmgrIdExists(rmid) && GetRmgr(rmid).rm_mask != NULL)
4742 newwalconsistency[rmid] = true;
4743 }
4744 else
4745 {
4746 /* Check if the token matches any known resource manager. */
4747 bool found = false;
4748
4749 for (rmid = 0; rmid <= RM_MAX_ID; rmid++)
4750 {
4751 if (RmgrIdExists(rmid) && GetRmgr(rmid).rm_mask != NULL &&
4752 pg_strcasecmp(tok, GetRmgr(rmid).rm_name) == 0)
4753 {
4754 newwalconsistency[rmid] = true;
4755 found = true;
4756 break;
4757 }
4758 }
4759 if (!found)
4760 {
4761 /*
4762 * During startup, it might be a not-yet-loaded custom
4763 * resource manager. Defer checking until
4764 * InitializeWalConsistencyChecking().
4765 */
4767 {
4769 }
4770 else
4771 {
4772 GUC_check_errdetail("Unrecognized key word: \"%s\".", tok);
4773 pfree(rawstring);
4774 list_free(elemlist);
4775 return false;
4776 }
4777 }
4778 }
4779 }
4780
4781 pfree(rawstring);
4782 list_free(elemlist);
4783
4784 /* assign new value */
4785 *extra = guc_malloc(LOG, (RM_MAX_ID + 1) * sizeof(bool));
4786 if (!*extra)
4787 return false;
4788 memcpy(*extra, newwalconsistency, (RM_MAX_ID + 1) * sizeof(bool));
4789 return true;
4790}
4791
4792/*
4793 * GUC assign_hook for wal_consistency_checking
4794 */
4795void
4797{
4798 /*
4799 * If some checks were deferred, it's possible that the checks will fail
4800 * later during InitializeWalConsistencyChecking(). But in that case, the
4801 * postmaster will exit anyway, so it's safe to proceed with the
4802 * assignment.
4803 *
4804 * Any built-in resource managers specified are assigned immediately,
4805 * which affects WAL created before shared_preload_libraries are
4806 * processed. Any custom resource managers specified won't be assigned
4807 * until after shared_preload_libraries are processed, but that's OK
4808 * because WAL for a custom resource manager can't be written before the
4809 * module is loaded anyway.
4810 */
4812}
4813
4814/*
4815 * InitializeWalConsistencyChecking: run after loading custom resource managers
4816 *
4817 * If any unknown resource managers were specified in the
4818 * wal_consistency_checking GUC, processing was deferred. Now that
4819 * shared_preload_libraries have been loaded, process wal_consistency_checking
4820 * again.
4821 */
4822void
4824{
4826
4828 {
4829 struct config_generic *guc;
4830
4831 guc = find_option("wal_consistency_checking", false, false, ERROR);
4832
4834
4835 set_config_option_ext("wal_consistency_checking",
4837 guc->scontext, guc->source, guc->srole,
4838 GUC_ACTION_SET, true, ERROR, false);
4839
4840 /* checking should not be deferred again */
4842 }
4843}
4844
4845/*
4846 * GUC show_hook for archive_command
4847 */
4848const char *
4850{
4851 if (XLogArchivingActive())
4852 return XLogArchiveCommand;
4853 else
4854 return "(disabled)";
4855}
4856
4857/*
4858 * GUC show_hook for in_hot_standby
4859 */
4860const char *
4862{
4863 /*
4864 * We display the actual state based on shared memory, so that this GUC
4865 * reports up-to-date state if examined intra-query. The underlying
4866 * variable (in_hot_standby_guc) changes only when we transmit a new value
4867 * to the client.
4868 */
4869 return RecoveryInProgress() ? "on" : "off";
4870}
4871
4872/*
4873 * Read the control file, set respective GUCs.
4874 *
4875 * This is to be called during startup, including a crash recovery cycle,
4876 * unless in bootstrap mode, where no control file yet exists. As there's no
4877 * usable shared memory yet (its sizing can depend on the contents of the
4878 * control file!), first store the contents in local memory. XLOGShmemInit()
4879 * will then copy it to shared memory later.
4880 *
4881 * reset just controls whether previous contents are to be expected (in the
4882 * reset case, there's a dangling pointer into old shared memory), or not.
4883 */
4884void
4886{
4887 Assert(reset || ControlFile == NULL);
4890}
4891
4892/*
4893 * Get the wal_level from the control file. For a standby, this value should be
4894 * considered as its active wal_level, because it may be different from what
4895 * was originally configured on standby.
4896 */
4899{
4900 return ControlFile->wal_level;
4901}
4902
4903/*
4904 * Initialization of shared memory for XLOG
4905 */
4906Size
4908{
4909 Size size;
4910
4911 /*
4912 * If the value of wal_buffers is -1, use the preferred auto-tune value.
4913 * This isn't an amazingly clean place to do this, but we must wait till
4914 * NBuffers has received its final value, and must do it before using the
4915 * value of XLOGbuffers to do anything important.
4916 *
4917 * We prefer to report this value's source as PGC_S_DYNAMIC_DEFAULT.
4918 * However, if the DBA explicitly set wal_buffers = -1 in the config file,
4919 * then PGC_S_DYNAMIC_DEFAULT will fail to override that and we must force
4920 * the matter with PGC_S_OVERRIDE.
4921 */
4922 if (XLOGbuffers == -1)
4923 {
4924 char buf[32];
4925
4926 snprintf(buf, sizeof(buf), "%d", XLOGChooseNumBuffers());
4927 SetConfigOption("wal_buffers", buf, PGC_POSTMASTER,
4929 if (XLOGbuffers == -1) /* failed to apply it? */
4930 SetConfigOption("wal_buffers", buf, PGC_POSTMASTER,
4932 }
4933 Assert(XLOGbuffers > 0);
4934
4935 /* XLogCtl */
4936 size = sizeof(XLogCtlData);
4937
4938 /* WAL insertion locks, plus alignment */
4939 size = add_size(size, mul_size(sizeof(WALInsertLockPadded), NUM_XLOGINSERT_LOCKS + 1));
4940 /* xlblocks array */
4941 size = add_size(size, mul_size(sizeof(pg_atomic_uint64), XLOGbuffers));
4942 /* extra alignment padding for XLOG I/O buffers */
4943 size = add_size(size, Max(XLOG_BLCKSZ, PG_IO_ALIGN_SIZE));
4944 /* and the buffers themselves */
4945 size = add_size(size, mul_size(XLOG_BLCKSZ, XLOGbuffers));
4946
4947 /*
4948 * Note: we don't count ControlFileData, it comes out of the "slop factor"
4949 * added by CreateSharedMemoryAndSemaphores. This lets us use this
4950 * routine again below to compute the actual allocation size.
4951 */
4952
4953 return size;
4954}
4955
4956void
4958{
4959 bool foundCFile,
4960 foundXLog;
4961 char *allocptr;
4962 int i;
4963 ControlFileData *localControlFile;
4964
4965#ifdef WAL_DEBUG
4966
4967 /*
4968 * Create a memory context for WAL debugging that's exempt from the normal
4969 * "no pallocs in critical section" rule. Yes, that can lead to a PANIC if
4970 * an allocation fails, but wal_debug is not for production use anyway.
4971 */
4972 if (walDebugCxt == NULL)
4973 {
4975 "WAL Debug",
4977 MemoryContextAllowInCriticalSection(walDebugCxt, true);
4978 }
4979#endif
4980
4981
4982 XLogCtl = (XLogCtlData *)
4983 ShmemInitStruct("XLOG Ctl", XLOGShmemSize(), &foundXLog);
4984
4985 localControlFile = ControlFile;
4987 ShmemInitStruct("Control File", sizeof(ControlFileData), &foundCFile);
4988
4989 if (foundCFile || foundXLog)
4990 {
4991 /* both should be present or neither */
4992 Assert(foundCFile && foundXLog);
4993
4994 /* Initialize local copy of WALInsertLocks */
4996
4997 if (localControlFile)
4998 pfree(localControlFile);
4999 return;
5000 }
5001 memset(XLogCtl, 0, sizeof(XLogCtlData));
5002
5003 /*
5004 * Already have read control file locally, unless in bootstrap mode. Move
5005 * contents into shared memory.
5006 */
5007 if (localControlFile)
5008 {
5009 memcpy(ControlFile, localControlFile, sizeof(ControlFileData));
5010 pfree(localControlFile);
5011 }
5012
5013 /*
5014 * Since XLogCtlData contains XLogRecPtr fields, its sizeof should be a
5015 * multiple of the alignment for same, so no extra alignment padding is
5016 * needed here.
5017 */
5018 allocptr = ((char *) XLogCtl) + sizeof(XLogCtlData);
5019 XLogCtl->xlblocks = (pg_atomic_uint64 *) allocptr;
5020 allocptr += sizeof(pg_atomic_uint64) * XLOGbuffers;
5021
5022 for (i = 0; i < XLOGbuffers; i++)
5023 {
5025 }
5026
5027 /* WAL insertion locks. Ensure they're aligned to the full padded size */
5028 allocptr += sizeof(WALInsertLockPadded) -
5029 ((uintptr_t) allocptr) % sizeof(WALInsertLockPadded);
5031 (WALInsertLockPadded *) allocptr;
5032 allocptr += sizeof(WALInsertLockPadded) * NUM_XLOGINSERT_LOCKS;
5033
5034 for (i = 0; i < NUM_XLOGINSERT_LOCKS; i++)
5035 {
5036 LWLockInitialize(&WALInsertLocks[i].l.lock, LWTRANCHE_WAL_INSERT);
5039 }
5040
5041 /*
5042 * Align the start of the page buffers to a full xlog block size boundary.
5043 * This simplifies some calculations in XLOG insertion. It is also
5044 * required for O_DIRECT.
5045 */
5046 allocptr = (char *) TYPEALIGN(XLOG_BLCKSZ, allocptr);
5047 XLogCtl->pages = allocptr;
5048 memset(XLogCtl->pages, 0, (Size) XLOG_BLCKSZ * XLOGbuffers);
5049
5050 /*
5051 * Do basic initialization of XLogCtl shared data. (StartupXLOG will fill
5052 * in additional info.)
5053 */
5057 XLogCtl->WalWriterSleeping = false;
5058
5065}
5066
5067/*
5068 * This func must be called ONCE on system install. It creates pg_control
5069 * and the initial XLOG segment.
5070 */
5071void
5072BootStrapXLOG(uint32 data_checksum_version)
5073{
5074 CheckPoint checkPoint;
5075 char *buffer;
5076 XLogPageHeader page;
5077 XLogLongPageHeader longpage;
5078 XLogRecord *record;
5079 char *recptr;
5080 uint64 sysidentifier;
5081 struct timeval tv;
5082 pg_crc32c crc;
5083
5084 /* allow ordinary WAL segment creation, like StartupXLOG() would */
5086
5087 /*
5088 * Select a hopefully-unique system identifier code for this installation.
5089 * We use the result of gettimeofday(), including the fractional seconds
5090 * field, as being about as unique as we can easily get. (Think not to
5091 * use random(), since it hasn't been seeded and there's no portable way
5092 * to seed it other than the system clock value...) The upper half of the
5093 * uint64 value is just the tv_sec part, while the lower half contains the
5094 * tv_usec part (which must fit in 20 bits), plus 12 bits from our current
5095 * PID for a little extra uniqueness. A person knowing this encoding can
5096 * determine the initialization time of the installation, which could
5097 * perhaps be useful sometimes.
5098 */
5099 gettimeofday(&tv, NULL);
5100 sysidentifier = ((uint64) tv.tv_sec) << 32;
5101 sysidentifier |= ((uint64) tv.tv_usec) << 12;
5102 sysidentifier |= getpid() & 0xFFF;
5103
5104 /* page buffer must be aligned suitably for O_DIRECT */
5105 buffer = (char *) palloc(XLOG_BLCKSZ + XLOG_BLCKSZ);
5106 page = (XLogPageHeader) TYPEALIGN(XLOG_BLCKSZ, buffer);
5107 memset(page, 0, XLOG_BLCKSZ);
5108
5109 /*
5110 * Set up information for the initial checkpoint record
5111 *
5112 * The initial checkpoint record is written to the beginning of the WAL
5113 * segment with logid=0 logseg=1. The very first WAL segment, 0/0, is not
5114 * used, so that we can use 0/0 to mean "before any valid WAL segment".
5115 */
5119 checkPoint.fullPageWrites = fullPageWrites;
5120 checkPoint.wal_level = wal_level;
5121 checkPoint.nextXid =
5123 checkPoint.nextOid = FirstGenbkiObjectId;
5124 checkPoint.nextMulti = FirstMultiXactId;
5125 checkPoint.nextMultiOffset = 0;
5127 checkPoint.oldestXidDB = Template1DbOid;
5128 checkPoint.oldestMulti = FirstMultiXactId;
5129 checkPoint.oldestMultiDB = Template1DbOid;
5132 checkPoint.time = (pg_time_t) time(NULL);
5134
5135 TransamVariables->nextXid = checkPoint.nextXid;
5136 TransamVariables->nextOid = checkPoint.nextOid;
5138 MultiXactSetNextMXact(checkPoint.nextMulti, checkPoint.nextMultiOffset);
5139 AdvanceOldestClogXid(checkPoint.oldestXid);
5140 SetTransactionIdLimit(checkPoint.oldestXid, checkPoint.oldestXidDB);
5141 SetMultiXactIdLimit(checkPoint.oldestMulti, checkPoint.oldestMultiDB, true);
5143
5144 /* Set up the XLOG page header */
5145 page->xlp_magic = XLOG_PAGE_MAGIC;
5146 page->xlp_info = XLP_LONG_HEADER;
5149 longpage = (XLogLongPageHeader) page;
5150 longpage->xlp_sysid = sysidentifier;
5151 longpage->xlp_seg_size = wal_segment_size;
5152 longpage->xlp_xlog_blcksz = XLOG_BLCKSZ;
5153
5154 /* Insert the initial checkpoint record */
5155 recptr = ((char *) page + SizeOfXLogLongPHD);
5156 record = (XLogRecord *) recptr;
5157 record->xl_prev = 0;
5158 record->xl_xid = InvalidTransactionId;
5159 record->xl_tot_len = SizeOfXLogRecord + SizeOfXLogRecordDataHeaderShort + sizeof(checkPoint);
5161 record->xl_rmid = RM_XLOG_ID;
5162 recptr += SizeOfXLogRecord;
5163 /* fill the XLogRecordDataHeaderShort struct */
5164 *(recptr++) = (char) XLR_BLOCK_ID_DATA_SHORT;
5165 *(recptr++) = sizeof(checkPoint);
5166 memcpy(recptr, &checkPoint, sizeof(checkPoint));
5167 recptr += sizeof(checkPoint);
5168 Assert(recptr - (char *) record == record->xl_tot_len);
5169
5171 COMP_CRC32C(crc, ((char *) record) + SizeOfXLogRecord, record->xl_tot_len - SizeOfXLogRecord);
5172 COMP_CRC32C(crc, (char *) record, offsetof(XLogRecord, xl_crc));
5173 FIN_CRC32C(crc);
5174 record->xl_crc = crc;
5175
5176 /* Create first XLOG segment file */
5179
5180 /*
5181 * We needn't bother with Reserve/ReleaseExternalFD here, since we'll
5182 * close the file again in a moment.
5183 */
5184
5185 /* Write the first page with the initial record */
5186 errno = 0;
5187 pgstat_report_wait_start(WAIT_EVENT_WAL_BOOTSTRAP_WRITE);
5188 if (write(openLogFile, page, XLOG_BLCKSZ) != XLOG_BLCKSZ)
5189 {
5190 /* if write didn't set errno, assume problem is no disk space */
5191 if (errno == 0)
5192 errno = ENOSPC;
5193 ereport(PANIC,
5195 errmsg("could not write bootstrap write-ahead log file: %m")));
5196 }
5198
5199 pgstat_report_wait_start(WAIT_EVENT_WAL_BOOTSTRAP_SYNC);
5200 if (pg_fsync(openLogFile) != 0)
5201 ereport(PANIC,
5203 errmsg("could not fsync bootstrap write-ahead log file: %m")));
5205
5206 if (close(openLogFile) != 0)
5207 ereport(PANIC,
5209 errmsg("could not close bootstrap write-ahead log file: %m")));
5210
5211 openLogFile = -1;
5212
5213 /* Now create pg_control */
5214 InitControlFile(sysidentifier, data_checksum_version);
5215 ControlFile->time = checkPoint.time;
5216 ControlFile->checkPoint = checkPoint.redo;
5217 ControlFile->checkPointCopy = checkPoint;
5218
5219 /* some additional ControlFile fields are set in WriteControlFile() */
5221
5222 /* Bootstrap the commit log, too */
5223 BootStrapCLOG();
5227
5228 pfree(buffer);
5229
5230 /*
5231 * Force control file to be read - in contrast to normal processing we'd
5232 * otherwise never run the checks and GUC related initializations therein.
5233 */
5235}
5236
5237static char *
5238str_time(pg_time_t tnow, char *buf, size_t bufsize)
5239{
5241 "%Y-%m-%d %H:%M:%S %Z",
5242 pg_localtime(&tnow, log_timezone));
5243
5244 return buf;
5245}
5246
5247/*
5248 * Initialize the first WAL segment on new timeline.
5249 */
5250static void
5252{
5253 char xlogfname[MAXFNAMELEN];
5254 XLogSegNo endLogSegNo;
5255 XLogSegNo startLogSegNo;
5256
5257 /* we always switch to a new timeline after archive recovery */
5258 Assert(endTLI != newTLI);
5259
5260 /*
5261 * Update min recovery point one last time.
5262 */
5264
5265 /*
5266 * Calculate the last segment on the old timeline, and the first segment
5267 * on the new timeline. If the switch happens in the middle of a segment,
5268 * they are the same, but if the switch happens exactly at a segment
5269 * boundary, startLogSegNo will be endLogSegNo + 1.
5270 */
5271 XLByteToPrevSeg(endOfLog, endLogSegNo, wal_segment_size);
5272 XLByteToSeg(endOfLog, startLogSegNo, wal_segment_size);
5273
5274 /*
5275 * Initialize the starting WAL segment for the new timeline. If the switch
5276 * happens in the middle of a segment, copy data from the last WAL segment
5277 * of the old timeline up to the switch point, to the starting WAL segment
5278 * on the new timeline.
5279 */
5280 if (endLogSegNo == startLogSegNo)
5281 {
5282 /*
5283 * Make a copy of the file on the new timeline.
5284 *
5285 * Writing WAL isn't allowed yet, so there are no locking
5286 * considerations. But we should be just as tense as XLogFileInit to
5287 * avoid emplacing a bogus file.
5288 */
5289 XLogFileCopy(newTLI, endLogSegNo, endTLI, endLogSegNo,
5291 }
5292 else
5293 {
5294 /*
5295 * The switch happened at a segment boundary, so just create the next
5296 * segment on the new timeline.
5297 */
5298 int fd;
5299
5300 fd = XLogFileInit(startLogSegNo, newTLI);
5301
5302 if (close(fd) != 0)
5303 {
5304 int save_errno = errno;
5305
5306 XLogFileName(xlogfname, newTLI, startLogSegNo, wal_segment_size);
5307 errno = save_errno;
5308 ereport(ERROR,
5310 errmsg("could not close file \"%s\": %m", xlogfname)));
5311 }
5312 }
5313
5314 /*
5315 * Let's just make real sure there are not .ready or .done flags posted
5316 * for the new segment.
5317 */
5318 XLogFileName(xlogfname, newTLI, startLogSegNo, wal_segment_size);
5319 XLogArchiveCleanup(xlogfname);
5320}
5321
5322/*
5323 * Perform cleanup actions at the conclusion of archive recovery.
5324 */
5325static void
5327 TimeLineID newTLI)
5328{
5329 /*
5330 * Execute the recovery_end_command, if any.
5331 */
5332 if (recoveryEndCommand && strcmp(recoveryEndCommand, "") != 0)
5334 "recovery_end_command",
5335 true,
5336 WAIT_EVENT_RECOVERY_END_COMMAND);
5337
5338 /*
5339 * We switched to a new timeline. Clean up segments on the old timeline.
5340 *
5341 * If there are any higher-numbered segments on the old timeline, remove
5342 * them. They might contain valid WAL, but they might also be
5343 * pre-allocated files containing garbage. In any case, they are not part
5344 * of the new timeline's history so we don't need them.
5345 */
5346 RemoveNonParentXlogFiles(EndOfLog, newTLI);
5347
5348 /*
5349 * If the switch happened in the middle of a segment, what to do with the
5350 * last, partial segment on the old timeline? If we don't archive it, and
5351 * the server that created the WAL never archives it either (e.g. because
5352 * it was hit by a meteor), it will never make it to the archive. That's
5353 * OK from our point of view, because the new segment that we created with
5354 * the new TLI contains all the WAL from the old timeline up to the switch
5355 * point. But if you later try to do PITR to the "missing" WAL on the old
5356 * timeline, recovery won't find it in the archive. It's physically
5357 * present in the new file with new TLI, but recovery won't look there
5358 * when it's recovering to the older timeline. On the other hand, if we
5359 * archive the partial segment, and the original server on that timeline
5360 * is still running and archives the completed version of the same segment
5361 * later, it will fail. (We used to do that in 9.4 and below, and it
5362 * caused such problems).
5363 *
5364 * As a compromise, we rename the last segment with the .partial suffix,
5365 * and archive it. Archive recovery will never try to read .partial
5366 * segments, so they will normally go unused. But in the odd PITR case,
5367 * the administrator can copy them manually to the pg_wal directory
5368 * (removing the suffix). They can be useful in debugging, too.
5369 *
5370 * If a .done or .ready file already exists for the old timeline, however,
5371 * we had already determined that the segment is complete, so we can let
5372 * it be archived normally. (In particular, if it was restored from the
5373 * archive to begin with, it's expected to have a .done file).
5374 */
5375 if (XLogSegmentOffset(EndOfLog, wal_segment_size) != 0 &&
5377 {
5378 char origfname[MAXFNAMELEN];
5379 XLogSegNo endLogSegNo;
5380
5381 XLByteToPrevSeg(EndOfLog, endLogSegNo, wal_segment_size);
5382 XLogFileName(origfname, EndOfLogTLI, endLogSegNo, wal_segment_size);
5383
5384 if (!XLogArchiveIsReadyOrDone(origfname))
5385 {
5386 char origpath[MAXPGPATH];
5387 char partialfname[MAXFNAMELEN];
5388 char partialpath[MAXPGPATH];
5389
5390 /*
5391 * If we're summarizing WAL, we can't rename the partial file
5392 * until the summarizer finishes with it, else it will fail.
5393 */
5394 if (summarize_wal)
5395 WaitForWalSummarization(EndOfLog);
5396
5397 XLogFilePath(origpath, EndOfLogTLI, endLogSegNo, wal_segment_size);
5398 snprintf(partialfname, MAXFNAMELEN, "%s.partial", origfname);
5399 snprintf(partialpath, MAXPGPATH, "%s.partial", origpath);
5400
5401 /*
5402 * Make sure there's no .done or .ready file for the .partial
5403 * file.
5404 */
5405 XLogArchiveCleanup(partialfname);
5406
5407 durable_rename(origpath, partialpath, ERROR);
5408 XLogArchiveNotify(partialfname);
5409 }
5410 }
5411}
5412
5413/*
5414 * Check to see if required parameters are set high enough on this server
5415 * for various aspects of recovery operation.
5416 *
5417 * Note that all the parameters which this function tests need to be
5418 * listed in Administrator's Overview section in high-availability.sgml.
5419 * If you change them, don't forget to update the list.
5420 */
5421static void
5423{
5424 /*
5425 * For archive recovery, the WAL must be generated with at least 'replica'
5426 * wal_level.
5427 */
5429 {
5430 ereport(FATAL,
5431 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
5432 errmsg("WAL was generated with \"wal_level=minimal\", cannot continue recovering"),
5433 errdetail("This happens if you temporarily set \"wal_level=minimal\" on the server."),
5434 errhint("Use a backup taken after setting \"wal_level\" to higher than \"minimal\".")));
5435 }
5436
5437 /*
5438 * For Hot Standby, the WAL must be generated with 'replica' mode, and we
5439 * must have at least as many backend slots as the primary.
5440 */
5442 {
5443 /* We ignore autovacuum_worker_slots when we make this test. */
5444 RecoveryRequiresIntParameter("max_connections",
5447 RecoveryRequiresIntParameter("max_worker_processes",
5450 RecoveryRequiresIntParameter("max_wal_senders",
5453 RecoveryRequiresIntParameter("max_prepared_transactions",
5456 RecoveryRequiresIntParameter("max_locks_per_transaction",
5459 }
5460}
5461
5462/*
5463 * This must be called ONCE during postmaster or standalone-backend startup
5464 */
5465void
5467{
5469 CheckPoint checkPoint;
5470 bool wasShutdown;
5471 bool didCrash;
5472 bool haveTblspcMap;
5473 bool haveBackupLabel;
5474 XLogRecPtr EndOfLog;
5475 TimeLineID EndOfLogTLI;
5476 TimeLineID newTLI;
5477 bool performedWalRecovery;
5478 EndOfWalRecoveryInfo *endOfRecoveryInfo;
5481 TransactionId oldestActiveXID;
5482 bool promoted = false;
5483 char timebuf[128];
5484
5485 /*
5486 * We should have an aux process resource owner to use, and we should not
5487 * be in a transaction that's installed some other resowner.
5488 */
5490 Assert(CurrentResourceOwner == NULL ||
5493
5494 /*
5495 * Check that contents look valid.
5496 */
5498 ereport(FATAL,
5500 errmsg("control file contains invalid checkpoint location")));
5501
5502 switch (ControlFile->state)
5503 {
5504 case DB_SHUTDOWNED:
5505
5506 /*
5507 * This is the expected case, so don't be chatty in standalone
5508 * mode
5509 */
5511 (errmsg("database system was shut down at %s",
5513 timebuf, sizeof(timebuf)))));
5514 break;
5515
5517 ereport(LOG,
5518 (errmsg("database system was shut down in recovery at %s",
5520 timebuf, sizeof(timebuf)))));
5521 break;
5522
5523 case DB_SHUTDOWNING:
5524 ereport(LOG,
5525 (errmsg("database system shutdown was interrupted; last known up at %s",
5527 timebuf, sizeof(timebuf)))));
5528 break;
5529
5531 ereport(LOG,
5532 (errmsg("database system was interrupted while in recovery at %s",
5534 timebuf, sizeof(timebuf))),
5535 errhint("This probably means that some data is corrupted and"
5536 " you will have to use the last backup for recovery.")));
5537 break;
5538
5540 ereport(LOG,
5541 (errmsg("database system was interrupted while in recovery at log time %s",
5543 timebuf, sizeof(timebuf))),
5544 errhint("If this has occurred more than once some data might be corrupted"
5545 " and you might need to choose an earlier recovery target.")));
5546 break;
5547
5548 case DB_IN_PRODUCTION:
5549 ereport(LOG,
5550 (errmsg("database system was interrupted; last known up at %s",
5552 timebuf, sizeof(timebuf)))));
5553 break;
5554
5555 default:
5556 ereport(FATAL,
5558 errmsg("control file contains invalid database cluster state")));
5559 }
5560
5561 /* This is just to allow attaching to startup process with a debugger */
5562#ifdef XLOG_REPLAY_DELAY
5564 pg_usleep(60000000L);
5565#endif
5566
5567 /*
5568 * Verify that pg_wal, pg_wal/archive_status, and pg_wal/summaries exist.
5569 * In cases where someone has performed a copy for PITR, these directories
5570 * may have been excluded and need to be re-created.
5571 */
5573
5574 /* Set up timeout handler needed to report startup progress. */
5578
5579 /*----------
5580 * If we previously crashed, perform a couple of actions:
5581 *
5582 * - The pg_wal directory may still include some temporary WAL segments
5583 * used when creating a new segment, so perform some clean up to not
5584 * bloat this path. This is done first as there is no point to sync
5585 * this temporary data.
5586 *
5587 * - There might be data which we had written, intending to fsync it, but
5588 * which we had not actually fsync'd yet. Therefore, a power failure in
5589 * the near future might cause earlier unflushed writes to be lost, even
5590 * though more recent data written to disk from here on would be
5591 * persisted. To avoid that, fsync the entire data directory.
5592 */
5595 {
5598 didCrash = true;
5599 }
5600 else
5601 didCrash = false;
5602
5603 /*
5604 * Prepare for WAL recovery if needed.
5605 *
5606 * InitWalRecovery analyzes the control file and the backup label file, if
5607 * any. It updates the in-memory ControlFile buffer according to the
5608 * starting checkpoint, and sets InRecovery and ArchiveRecoveryRequested.
5609 * It also applies the tablespace map file, if any.
5610 */
5611 InitWalRecovery(ControlFile, &wasShutdown,
5612 &haveBackupLabel, &haveTblspcMap);
5613 checkPoint = ControlFile->checkPointCopy;
5614
5615 /* initialize shared memory variables from the checkpoint record */
5616 TransamVariables->nextXid = checkPoint.nextXid;
5617 TransamVariables->nextOid = checkPoint.nextOid;
5619 MultiXactSetNextMXact(checkPoint.nextMulti, checkPoint.nextMultiOffset);
5620 AdvanceOldestClogXid(checkPoint.oldestXid);
5621 SetTransactionIdLimit(checkPoint.oldestXid, checkPoint.oldestXidDB);
5622 SetMultiXactIdLimit(checkPoint.oldestMulti, checkPoint.oldestMultiDB, true);
5624 checkPoint.newestCommitTsXid);
5625
5626 /*
5627 * Clear out any old relcache cache files. This is *necessary* if we do
5628 * any WAL replay, since that would probably result in the cache files
5629 * being out of sync with database reality. In theory we could leave them
5630 * in place if the database had been cleanly shut down, but it seems
5631 * safest to just remove them always and let them be rebuilt during the
5632 * first backend startup. These files needs to be removed from all
5633 * directories including pg_tblspc, however the symlinks are created only
5634 * after reading tablespace_map file in case of archive recovery from
5635 * backup, so needs to clear old relcache files here after creating
5636 * symlinks.
5637 */
5639
5640 /*
5641 * Initialize replication slots, before there's a chance to remove
5642 * required resources.
5643 */
5645
5646 /*
5647 * Startup logical state, needs to be setup now so we have proper data
5648 * during crash recovery.
5649 */
5651
5652 /*
5653 * Startup CLOG. This must be done after TransamVariables->nextXid has
5654 * been initialized and before we accept connections or begin WAL replay.
5655 */
5656 StartupCLOG();
5657
5658 /*
5659 * Startup MultiXact. We need to do this early to be able to replay
5660 * truncations.
5661 */
5663
5664 /*
5665 * Ditto for commit timestamps. Activate the facility if the setting is
5666 * enabled in the control file, as there should be no tracking of commit
5667 * timestamps done when the setting was disabled. This facility can be
5668 * started or stopped when replaying a XLOG_PARAMETER_CHANGE record.
5669 */
5672
5673 /*
5674 * Recover knowledge about replay progress of known replication partners.
5675 */
5677
5678 /*
5679 * Initialize unlogged LSN. On a clean shutdown, it's restored from the
5680 * control file. On recovery, all unlogged relations are blown away, so
5681 * the unlogged LSN counter can be reset too.
5682 */
5686 else
5689
5690 /*
5691 * Copy any missing timeline history files between 'now' and the recovery
5692 * target timeline from archive to pg_wal. While we don't need those files
5693 * ourselves - the history file of the recovery target timeline covers all
5694 * the previous timelines in the history too - a cascading standby server
5695 * might be interested in them. Or, if you archive the WAL from this
5696 * server to a different archive than the primary, it'd be good for all
5697 * the history files to get archived there after failover, so that you can
5698 * use one of the old timelines as a PITR target. Timeline history files
5699 * are small, so it's better to copy them unnecessarily than not copy them
5700 * and regret later.
5701 */
5703
5704 /*
5705 * Before running in recovery, scan pg_twophase and fill in its status to
5706 * be able to work on entries generated by redo. Doing a scan before
5707 * taking any recovery action has the merit to discard any 2PC files that
5708 * are newer than the first record to replay, saving from any conflicts at
5709 * replay. This avoids as well any subsequent scans when doing recovery
5710 * of the on-disk two-phase data.
5711 */
5713
5714 /*
5715 * When starting with crash recovery, reset pgstat data - it might not be
5716 * valid. Otherwise restore pgstat data. It's safe to do this here,
5717 * because postmaster will not yet have started any other processes.
5718 *
5719 * NB: Restoring replication slot stats relies on slot state to have
5720 * already been restored from disk.
5721 *
5722 * TODO: With a bit of extra work we could just start with a pgstat file
5723 * associated with the checkpoint redo location we're starting from.
5724 */
5725 if (didCrash)
5727 else
5729
5731
5734
5735 /* REDO */
5736 if (InRecovery)
5737 {
5738 /* Initialize state for RecoveryInProgress() */
5742 else
5745
5746 /*
5747 * Update pg_control to show that we are recovering and to show the
5748 * selected checkpoint as the place we are starting from. We also mark
5749 * pg_control with any minimum recovery stop point obtained from a
5750 * backup history file.
5751 *
5752 * No need to hold ControlFileLock yet, we aren't up far enough.
5753 */
5755
5756 /*
5757 * If there was a backup label file, it's done its job and the info
5758 * has now been propagated into pg_control. We must get rid of the
5759 * label file so that if we crash during recovery, we'll pick up at
5760 * the latest recovery restartpoint instead of going all the way back
5761 * to the backup start point. It seems prudent though to just rename
5762 * the file out of the way rather than delete it completely.
5763 */
5764 if (haveBackupLabel)
5765 {
5766 unlink(BACKUP_LABEL_OLD);
5768 }
5769
5770 /*
5771 * If there was a tablespace_map file, it's done its job and the
5772 * symlinks have been created. We must get rid of the map file so
5773 * that if we crash during recovery, we don't create symlinks again.
5774 * It seems prudent though to just rename the file out of the way
5775 * rather than delete it completely.
5776 */
5777 if (haveTblspcMap)
5778 {
5779 unlink(TABLESPACE_MAP_OLD);
5781 }
5782
5783 /*
5784 * Initialize our local copy of minRecoveryPoint. When doing crash
5785 * recovery we want to replay up to the end of WAL. Particularly, in
5786 * the case of a promoted standby minRecoveryPoint value in the
5787 * control file is only updated after the first checkpoint. However,
5788 * if the instance crashes before the first post-recovery checkpoint
5789 * is completed then recovery will use a stale location causing the
5790 * startup process to think that there are still invalid page
5791 * references when checking for data consistency.
5792 */
5794 {
5797 }
5798 else
5799 {
5802 }
5803
5804 /* Check that the GUCs used to generate the WAL allow recovery */
5806
5807 /*
5808 * We're in recovery, so unlogged relations may be trashed and must be
5809 * reset. This should be done BEFORE allowing Hot Standby
5810 * connections, so that read-only backends don't try to read whatever
5811 * garbage is left over from before.
5812 */
5814
5815 /*
5816 * Likewise, delete any saved transaction snapshot files that got left
5817 * behind by crashed backends.
5818 */
5820
5821 /*
5822 * Initialize for Hot Standby, if enabled. We won't let backends in
5823 * yet, not until we've reached the min recovery point specified in
5824 * control file and we've established a recovery snapshot from a
5825 * running-xacts WAL record.
5826 */
5828 {
5829 TransactionId *xids;
5830 int nxids;
5831
5833 (errmsg_internal("initializing for hot standby")));
5834
5836
5837 if (wasShutdown)
5838 oldestActiveXID = PrescanPreparedTransactions(&xids, &nxids);
5839 else
5840 oldestActiveXID = checkPoint.oldestActiveXid;
5841 Assert(TransactionIdIsValid(oldestActiveXID));
5842
5843 /* Tell procarray about the range of xids it has to deal with */
5845
5846 /*
5847 * Startup subtrans only. CLOG, MultiXact and commit timestamp
5848 * have already been started up and other SLRUs are not maintained
5849 * during recovery and need not be started yet.
5850 */
5851 StartupSUBTRANS(oldestActiveXID);
5852
5853 /*
5854 * If we're beginning at a shutdown checkpoint, we know that
5855 * nothing was running on the primary at this point. So fake-up an
5856 * empty running-xacts record and use that here and now. Recover
5857 * additional standby state for prepared transactions.
5858 */
5859 if (wasShutdown)
5860 {
5862 TransactionId latestCompletedXid;
5863
5864 /* Update pg_subtrans entries for any prepared transactions */
5866
5867 /*
5868 * Construct a RunningTransactions snapshot representing a
5869 * shut down server, with only prepared transactions still
5870 * alive. We're never overflowed at this point because all
5871 * subxids are listed with their parent prepared transactions.
5872 */
5873 running.xcnt = nxids;
5874 running.subxcnt = 0;
5876 running.nextXid = XidFromFullTransactionId(checkPoint.nextXid);
5877 running.oldestRunningXid = oldestActiveXID;
5878 latestCompletedXid = XidFromFullTransactionId(checkPoint.nextXid);
5879 TransactionIdRetreat(latestCompletedXid);
5880 Assert(TransactionIdIsNormal(latestCompletedXid));
5881 running.latestCompletedXid = latestCompletedXid;
5882 running.xids = xids;
5883
5885 }
5886 }
5887
5888 /*
5889 * We're all set for replaying the WAL now. Do it.
5890 */
5892 performedWalRecovery = true;
5893 }
5894 else
5895 performedWalRecovery = false;
5896
5897 /*
5898 * Finish WAL recovery.
5899 */
5900 endOfRecoveryInfo = FinishWalRecovery();
5901 EndOfLog = endOfRecoveryInfo->endOfLog;
5902 EndOfLogTLI = endOfRecoveryInfo->endOfLogTLI;
5903 abortedRecPtr = endOfRecoveryInfo->abortedRecPtr;
5904 missingContrecPtr = endOfRecoveryInfo->missingContrecPtr;
5905
5906 /*
5907 * Reset ps status display, so as no information related to recovery shows
5908 * up.
5909 */
5910 set_ps_display("");
5911
5912 /*
5913 * When recovering from a backup (we are in recovery, and archive recovery
5914 * was requested), complain if we did not roll forward far enough to reach
5915 * the point where the database is consistent. For regular online
5916 * backup-from-primary, that means reaching the end-of-backup WAL record
5917 * (at which point we reset backupStartPoint to be Invalid), for
5918 * backup-from-replica (which can't inject records into the WAL stream),
5919 * that point is when we reach the minRecoveryPoint in pg_control (which
5920 * we purposefully copy last when backing up from a replica). For
5921 * pg_rewind (which creates a backup_label with a method of "pg_rewind")
5922 * or snapshot-style backups (which don't), backupEndRequired will be set
5923 * to false.
5924 *
5925 * Note: it is indeed okay to look at the local variable
5926 * LocalMinRecoveryPoint here, even though ControlFile->minRecoveryPoint
5927 * might be further ahead --- ControlFile->minRecoveryPoint cannot have
5928 * been advanced beyond the WAL we processed.
5929 */
5930 if (InRecovery &&
5931 (EndOfLog < LocalMinRecoveryPoint ||
5933 {
5934 /*
5935 * Ran off end of WAL before reaching end-of-backup WAL record, or
5936 * minRecoveryPoint. That's a bad sign, indicating that you tried to
5937 * recover from an online backup but never called pg_backup_stop(), or
5938 * you didn't archive all the WAL needed.
5939 */
5941 {
5943 ereport(FATAL,
5944 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
5945 errmsg("WAL ends before end of online backup"),
5946 errhint("All WAL generated while online backup was taken must be available at recovery.")));
5947 else
5948 ereport(FATAL,
5949 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
5950 errmsg("WAL ends before consistent recovery point")));
5951 }
5952 }
5953
5954 /*
5955 * Reset unlogged relations to the contents of their INIT fork. This is
5956 * done AFTER recovery is complete so as to include any unlogged relations
5957 * created during recovery, but BEFORE recovery is marked as having
5958 * completed successfully. Otherwise we'd not retry if any of the post
5959 * end-of-recovery steps fail.
5960 */
5961 if (InRecovery)
5963
5964 /*
5965 * Pre-scan prepared transactions to find out the range of XIDs present.
5966 * This information is not quite needed yet, but it is positioned here so
5967 * as potential problems are detected before any on-disk change is done.
5968 */
5969 oldestActiveXID = PrescanPreparedTransactions(NULL, NULL);
5970
5971 /*
5972 * Allow ordinary WAL segment creation before possibly switching to a new
5973 * timeline, which creates a new segment, and after the last ReadRecord().
5974 */
5976
5977 /*
5978 * Consider whether we need to assign a new timeline ID.
5979 *
5980 * If we did archive recovery, we always assign a new ID. This handles a
5981 * couple of issues. If we stopped short of the end of WAL during
5982 * recovery, then we are clearly generating a new timeline and must assign
5983 * it a unique new ID. Even if we ran to the end, modifying the current
5984 * last segment is problematic because it may result in trying to
5985 * overwrite an already-archived copy of that segment, and we encourage
5986 * DBAs to make their archive_commands reject that. We can dodge the
5987 * problem by making the new active segment have a new timeline ID.
5988 *
5989 * In a normal crash recovery, we can just extend the timeline we were in.
5990 */
5991 newTLI = endOfRecoveryInfo->lastRecTLI;
5993 {
5995 ereport(LOG,
5996 (errmsg("selected new timeline ID: %u", newTLI)));
5997
5998 /*
5999 * Make a writable copy of the last WAL segment. (Note that we also
6000 * have a copy of the last block of the old WAL in
6001 * endOfRecovery->lastPage; we will use that below.)
6002 */
6003 XLogInitNewTimeline(EndOfLogTLI, EndOfLog, newTLI);
6004
6005 /*
6006 * Remove the signal files out of the way, so that we don't
6007 * accidentally re-enter archive recovery mode in a subsequent crash.
6008 */
6009 if (endOfRecoveryInfo->standby_signal_file_found)
6011
6012 if (endOfRecoveryInfo->recovery_signal_file_found)
6014
6015 /*
6016 * Write the timeline history file, and have it archived. After this
6017 * point (or rather, as soon as the file is archived), the timeline
6018 * will appear as "taken" in the WAL archive and to any standby
6019 * servers. If we crash before actually switching to the new
6020 * timeline, standby servers will nevertheless think that we switched
6021 * to the new timeline, and will try to connect to the new timeline.
6022 * To minimize the window for that, try to do as little as possible
6023 * between here and writing the end-of-recovery record.
6024 */
6026 EndOfLog, endOfRecoveryInfo->recoveryStopReason);
6027
6028 ereport(LOG,
6029 (errmsg("archive recovery complete")));
6030 }
6031
6032 /* Save the selected TimeLineID in shared memory, too */
6034 XLogCtl->InsertTimeLineID = newTLI;
6035 XLogCtl->PrevTimeLineID = endOfRecoveryInfo->lastRecTLI;
6037
6038 /*
6039 * Actually, if WAL ended in an incomplete record, skip the parts that
6040 * made it through and start writing after the portion that persisted.
6041 * (It's critical to first write an OVERWRITE_CONTRECORD message, which
6042 * we'll do as soon as we're open for writing new WAL.)
6043 */
6045 {
6046 /*
6047 * We should only have a missingContrecPtr if we're not switching to a
6048 * new timeline. When a timeline switch occurs, WAL is copied from the
6049 * old timeline to the new only up to the end of the last complete
6050 * record, so there can't be an incomplete WAL record that we need to
6051 * disregard.
6052 */
6053 Assert(newTLI == endOfRecoveryInfo->lastRecTLI);
6055 EndOfLog = missingContrecPtr;
6056 }
6057
6058 /*
6059 * Prepare to write WAL starting at EndOfLog location, and init xlog
6060 * buffer cache using the block containing the last record from the
6061 * previous incarnation.
6062 */
6063 Insert = &XLogCtl->Insert;
6064 Insert->PrevBytePos = XLogRecPtrToBytePos(endOfRecoveryInfo->lastRec);
6065 Insert->CurrBytePos = XLogRecPtrToBytePos(EndOfLog);
6066
6067 /*
6068 * Tricky point here: lastPage contains the *last* block that the LastRec
6069 * record spans, not the one it starts in. The last block is indeed the
6070 * one we want to use.
6071 */
6072 if (EndOfLog % XLOG_BLCKSZ != 0)
6073 {
6074 char *page;
6075 int len;
6076 int firstIdx;
6077
6078 firstIdx = XLogRecPtrToBufIdx(EndOfLog);
6079 len = EndOfLog - endOfRecoveryInfo->lastPageBeginPtr;
6080 Assert(len < XLOG_BLCKSZ);
6081
6082 /* Copy the valid part of the last block, and zero the rest */
6083 page = &XLogCtl->pages[firstIdx * XLOG_BLCKSZ];
6084 memcpy(page, endOfRecoveryInfo->lastPage, len);
6085 memset(page + len, 0, XLOG_BLCKSZ - len);
6086
6087 pg_atomic_write_u64(&XLogCtl->xlblocks[firstIdx], endOfRecoveryInfo->lastPageBeginPtr + XLOG_BLCKSZ);
6088 XLogCtl->InitializedUpTo = endOfRecoveryInfo->lastPageBeginPtr + XLOG_BLCKSZ;
6089 }
6090 else
6091 {
6092 /*
6093 * There is no partial block to copy. Just set InitializedUpTo, and
6094 * let the first attempt to insert a log record to initialize the next
6095 * buffer.
6096 */
6097 XLogCtl->InitializedUpTo = EndOfLog;
6098 }
6099
6100 /*
6101 * Update local and shared status. This is OK to do without any locks
6102 * because no other process can be reading or writing WAL yet.
6103 */
6104 LogwrtResult.Write = LogwrtResult.Flush = EndOfLog;
6108 XLogCtl->LogwrtRqst.Write = EndOfLog;
6109 XLogCtl->LogwrtRqst.Flush = EndOfLog;
6110
6111 /*
6112 * Preallocate additional log files, if wanted.
6113 */
6114 PreallocXlogFiles(EndOfLog, newTLI);
6115
6116 /*
6117 * Okay, we're officially UP.
6118 */
6119 InRecovery = false;
6120
6121 /* start the archive_timeout timer and LSN running */
6122 XLogCtl->lastSegSwitchTime = (pg_time_t) time(NULL);
6123 XLogCtl->lastSegSwitchLSN = EndOfLog;
6124
6125 /* also initialize latestCompletedXid, to nextXid - 1 */
6126 LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
6129 LWLockRelease(ProcArrayLock);
6130
6131 /*
6132 * Start up subtrans, if not already done for hot standby. (commit
6133 * timestamps are started below, if necessary.)
6134 */
6136 StartupSUBTRANS(oldestActiveXID);
6137
6138 /*
6139 * Perform end of recovery actions for any SLRUs that need it.
6140 */
6141 TrimCLOG();
6142 TrimMultiXact();
6143
6144 /*
6145 * Reload shared-memory state for prepared transactions. This needs to
6146 * happen before renaming the last partial segment of the old timeline as
6147 * it may be possible that we have to recover some transactions from it.
6148 */
6150
6151 /* Shut down xlogreader */
6153
6154 /* Enable WAL writes for this backend only. */
6156
6157 /* If necessary, write overwrite-contrecord before doing anything else */
6159 {
6162 }
6163
6164 /*
6165 * Update full_page_writes in shared memory and write an XLOG_FPW_CHANGE
6166 * record before resource manager writes cleanup WAL records or checkpoint
6167 * record is written.
6168 */
6169 Insert->fullPageWrites = lastFullPageWrites;
6171
6172 /*
6173 * Emit checkpoint or end-of-recovery record in XLOG, if required.
6174 */
6175 if (performedWalRecovery)
6176 promoted = PerformRecoveryXLogAction();
6177
6178 /*
6179 * If any of the critical GUCs have changed, log them before we allow
6180 * backends to write WAL.
6181 */
6183
6184 /* If this is archive recovery, perform post-recovery cleanup actions. */
6186 CleanupAfterArchiveRecovery(EndOfLogTLI, EndOfLog, newTLI);
6187
6188 /*
6189 * Local WAL inserts enabled, so it's time to finish initialization of
6190 * commit timestamp.
6191 */
6193
6194 /* Clean up EndOfWalRecoveryInfo data to appease Valgrind leak checking */
6195 if (endOfRecoveryInfo->lastPage)
6196 pfree(endOfRecoveryInfo->lastPage);
6197 pfree(endOfRecoveryInfo->recoveryStopReason);
6198 pfree(endOfRecoveryInfo);
6199
6200 /*
6201 * All done with end-of-recovery actions.
6202 *
6203 * Now allow backends to write WAL and update the control file status in
6204 * consequence. SharedRecoveryState, that controls if backends can write
6205 * WAL, is updated while holding ControlFileLock to prevent other backends
6206 * to look at an inconsistent state of the control file in shared memory.
6207 * There is still a small window during which backends can write WAL and
6208 * the control file is still referring to a system not in DB_IN_PRODUCTION
6209 * state while looking at the on-disk control file.
6210 *
6211 * Also, we use info_lck to update SharedRecoveryState to ensure that
6212 * there are no race conditions concerning visibility of other recent
6213 * updates to shared memory.
6214 */
6215 LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
6217
6221
6223 LWLockRelease(ControlFileLock);
6224
6225 /*
6226 * Shutdown the recovery environment. This must occur after
6227 * RecoverPreparedTransactions() (see notes in lock_twophase_recover())
6228 * and after switching SharedRecoveryState to RECOVERY_STATE_DONE so as
6229 * any session building a snapshot will not rely on KnownAssignedXids as
6230 * RecoveryInProgress() would return false at this stage. This is
6231 * particularly critical for prepared 2PC transactions, that would still
6232 * need to be included in snapshots once recovery has ended.
6233 */
6236
6237 /*
6238 * If there were cascading standby servers connected to us, nudge any wal
6239 * sender processes to notice that we've been promoted.
6240 */
6241 WalSndWakeup(true, true);
6242
6243 /*
6244 * If this was a promotion, request an (online) checkpoint now. This isn't
6245 * required for consistency, but the last restartpoint might be far back,
6246 * and in case of a crash, recovering from it might take a longer than is
6247 * appropriate now that we're not in standby mode anymore.
6248 */
6249 if (promoted)
6251}
6252
6253/*
6254 * Callback from PerformWalRecovery(), called when we switch from crash
6255 * recovery to archive recovery mode. Updates the control file accordingly.
6256 */
6257void
6259{
6260 /* initialize minRecoveryPoint to this record */
6261 LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
6263 if (ControlFile->minRecoveryPoint < EndRecPtr)
6264 {
6265 ControlFile->minRecoveryPoint = EndRecPtr;
6266 ControlFile->minRecoveryPointTLI = replayTLI;
6267 }
6268 /* update local copy */
6271
6272 /*
6273 * The startup process can update its local copy of minRecoveryPoint from
6274 * this point.
6275 */
6277
6279
6280 /*
6281 * We update SharedRecoveryState while holding the lock on ControlFileLock
6282 * so both states are consistent in shared memory.
6283 */
6287
6288 LWLockRelease(ControlFileLock);
6289}
6290
6291/*
6292 * Callback from PerformWalRecovery(), called when we reach the end of backup.
6293 * Updates the control file accordingly.
6294 */
6295void
6297{
6298 /*
6299 * We have reached the end of base backup, as indicated by pg_control. The
6300 * data on disk is now consistent (unless minRecoveryPoint is further
6301 * ahead, which can happen if we crashed during previous recovery). Reset
6302 * backupStartPoint and backupEndPoint, and update minRecoveryPoint to
6303 * make sure we don't allow starting up at an earlier point even if
6304 * recovery is stopped and restarted soon after this.
6305 */
6306 LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
6307
6308 if (ControlFile->minRecoveryPoint < EndRecPtr)
6309 {
6310 ControlFile->minRecoveryPoint = EndRecPtr;
6312 }
6313
6318
6319 LWLockRelease(ControlFileLock);
6320}
6321
6322/*
6323 * Perform whatever XLOG actions are necessary at end of REDO.
6324 *
6325 * The goal here is to make sure that we'll be able to recover properly if
6326 * we crash again. If we choose to write a checkpoint, we'll write a shutdown
6327 * checkpoint rather than an on-line one. This is not particularly critical,
6328 * but since we may be assigning a new TLI, using a shutdown checkpoint allows
6329 * us to have the rule that TLI only changes in shutdown checkpoints, which
6330 * allows some extra error checking in xlog_redo.
6331 */
6332static bool
6334{
6335 bool promoted = false;
6336
6337 /*
6338 * Perform a checkpoint to update all our recovery activity to disk.
6339 *
6340 * Note that we write a shutdown checkpoint rather than an on-line one.
6341 * This is not particularly critical, but since we may be assigning a new
6342 * TLI, using a shutdown checkpoint allows us to have the rule that TLI
6343 * only changes in shutdown checkpoints, which allows some extra error
6344 * checking in xlog_redo.
6345 *
6346 * In promotion, only create a lightweight end-of-recovery record instead
6347 * of a full checkpoint. A checkpoint is requested later, after we're
6348 * fully out of recovery mode and already accepting queries.
6349 */
6352 {
6353 promoted = true;
6354
6355 /*
6356 * Insert a special WAL record to mark the end of recovery, since we
6357 * aren't doing a checkpoint. That means that the checkpointer process
6358 * may likely be in the middle of a time-smoothed restartpoint and
6359 * could continue to be for minutes after this. That sounds strange,
6360 * but the effect is roughly the same and it would be stranger to try
6361 * to come out of the restartpoint and then checkpoint. We request a
6362 * checkpoint later anyway, just for safety.
6363 */
6365 }
6366 else
6367 {
6371 }
6372
6373 return promoted;
6374}
6375
6376/*
6377 * Is the system still in recovery?
6378 *
6379 * Unlike testing InRecovery, this works in any process that's connected to
6380 * shared memory.
6381 */
6382bool
6384{
6385 /*
6386 * We check shared state each time only until we leave recovery mode. We
6387 * can't re-enter recovery, so there's no need to keep checking after the
6388 * shared variable has once been seen false.
6389 */
6391 return false;
6392 else
6393 {
6394 /*
6395 * use volatile pointer to make sure we make a fresh read of the
6396 * shared variable.
6397 */
6398 volatile XLogCtlData *xlogctl = XLogCtl;
6399
6401
6402 /*
6403 * Note: We don't need a memory barrier when we're still in recovery.
6404 * We might exit recovery immediately after return, so the caller
6405 * can't rely on 'true' meaning that we're still in recovery anyway.
6406 */
6407
6409 }
6410}
6411
6412/*
6413 * Returns current recovery state from shared memory.
6414 *
6415 * This returned state is kept consistent with the contents of the control
6416 * file. See details about the possible values of RecoveryState in xlog.h.
6417 */
6420{
6421 RecoveryState retval;
6422
6424 retval = XLogCtl->SharedRecoveryState;
6426
6427 return retval;
6428}
6429
6430/*
6431 * Is this process allowed to insert new WAL records?
6432 *
6433 * Ordinarily this is essentially equivalent to !RecoveryInProgress().
6434 * But we also have provisions for forcing the result "true" or "false"
6435 * within specific processes regardless of the global state.
6436 */
6437bool
6439{
6440 /*
6441 * If value is "unconditionally true" or "unconditionally false", just
6442 * return it. This provides the normal fast path once recovery is known
6443 * done.
6444 */
6445 if (LocalXLogInsertAllowed >= 0)
6446 return (bool) LocalXLogInsertAllowed;
6447
6448 /*
6449 * Else, must check to see if we're still in recovery.
6450 */
6451 if (RecoveryInProgress())
6452 return false;
6453
6454 /*
6455 * On exit from recovery, reset to "unconditionally true", since there is
6456 * no need to keep checking.
6457 */
6459 return true;
6460}
6461
6462/*
6463 * Make XLogInsertAllowed() return true in the current process only.
6464 *
6465 * Note: it is allowed to switch LocalXLogInsertAllowed back to -1 later,
6466 * and even call LocalSetXLogInsertAllowed() again after that.
6467 *
6468 * Returns the previous value of LocalXLogInsertAllowed.
6469 */
6470static int
6472{
6473 int oldXLogAllowed = LocalXLogInsertAllowed;
6474
6476
6477 return oldXLogAllowed;
6478}
6479
6480/*
6481 * Return the current Redo pointer from shared memory.
6482 *
6483 * As a side-effect, the local RedoRecPtr copy is updated.
6484 */
6487{
6488 XLogRecPtr ptr;
6489
6490 /*
6491 * The possibly not up-to-date copy in XlogCtl is enough. Even if we
6492 * grabbed a WAL insertion lock to read the authoritative value in
6493 * Insert->RedoRecPtr, someone might update it just after we've released
6494 * the lock.
6495 */
6497 ptr = XLogCtl->RedoRecPtr;
6499
6500 if (RedoRecPtr < ptr)
6501 RedoRecPtr = ptr;
6502
6503 return RedoRecPtr;
6504}
6505
6506/*
6507 * Return information needed to decide whether a modified block needs a
6508 * full-page image to be included in the WAL record.
6509 *
6510 * The returned values are cached copies from backend-private memory, and
6511 * possibly out-of-date or, indeed, uninitialized, in which case they will
6512 * be InvalidXLogRecPtr and false, respectively. XLogInsertRecord will
6513 * re-check them against up-to-date values, while holding the WAL insert lock.
6514 */
6515void
6516GetFullPageWriteInfo(XLogRecPtr *RedoRecPtr_p, bool *doPageWrites_p)
6517{
6518 *RedoRecPtr_p = RedoRecPtr;
6519 *doPageWrites_p = doPageWrites;
6520}
6521
6522/*
6523 * GetInsertRecPtr -- Returns the current insert position.
6524 *
6525 * NOTE: The value *actually* returned is the position of the last full
6526 * xlog page. It lags behind the real insert position by at most 1 page.
6527 * For that, we don't need to scan through WAL insertion locks, and an
6528 * approximation is enough for the current usage of this function.
6529 */
6532{
6533 XLogRecPtr recptr;
6534
6536 recptr = XLogCtl->LogwrtRqst.Write;
6538
6539 return recptr;
6540}
6541
6542/*
6543 * GetFlushRecPtr -- Returns the current flush position, ie, the last WAL
6544 * position known to be fsync'd to disk. This should only be used on a
6545 * system that is known not to be in recovery.
6546 */
6549{
6551
6553
6554 /*
6555 * If we're writing and flushing WAL, the time line can't be changing, so
6556 * no lock is required.
6557 */
6558 if (insertTLI)
6559 *insertTLI = XLogCtl->InsertTimeLineID;
6560
6561 return LogwrtResult.Flush;
6562}
6563
6564/*
6565 * GetWALInsertionTimeLine -- Returns the current timeline of a system that
6566 * is not in recovery.
6567 */
6570{
6572
6573 /* Since the value can't be changing, no lock is required. */
6574 return XLogCtl->InsertTimeLineID;
6575}
6576
6577/*
6578 * GetWALInsertionTimeLineIfSet -- If the system is not in recovery, returns
6579 * the WAL insertion timeline; else, returns 0. Wherever possible, use
6580 * GetWALInsertionTimeLine() instead, since it's cheaper. Note that this
6581 * function decides recovery has ended as soon as the insert TLI is set, which
6582 * happens before we set XLogCtl->SharedRecoveryState to RECOVERY_STATE_DONE.
6583 */
6586{
6587 TimeLineID insertTLI;
6588
6590 insertTLI = XLogCtl->InsertTimeLineID;
6592
6593 return insertTLI;
6594}
6595
6596/*
6597 * GetLastImportantRecPtr -- Returns the LSN of the last important record
6598 * inserted. All records not explicitly marked as unimportant are considered
6599 * important.
6600 *
6601 * The LSN is determined by computing the maximum of
6602 * WALInsertLocks[i].lastImportantAt.
6603 */
6606{
6608 int i;
6609
6610 for (i = 0; i < NUM_XLOGINSERT_LOCKS; i++)
6611 {
6612 XLogRecPtr last_important;
6613
6614 /*
6615 * Need to take a lock to prevent torn reads of the LSN, which are
6616 * possible on some of the supported platforms. WAL insert locks only
6617 * support exclusive mode, so we have to use that.
6618 */
6620 last_important = WALInsertLocks[i].l.lastImportantAt;
6621 LWLockRelease(&WALInsertLocks[i].l.lock);
6622
6623 if (res < last_important)
6624 res = last_important;
6625 }
6626
6627 return res;
6628}
6629
6630/*
6631 * Get the time and LSN of the last xlog segment switch
6632 */
6635{
6636 pg_time_t result;
6637
6638 /* Need WALWriteLock, but shared lock is sufficient */
6639 LWLockAcquire(WALWriteLock, LW_SHARED);
6640 result = XLogCtl->lastSegSwitchTime;
6641 *lastSwitchLSN = XLogCtl->lastSegSwitchLSN;
6642 LWLockRelease(WALWriteLock);
6643
6644 return result;
6645}
6646
6647/*
6648 * This must be called ONCE during postmaster or standalone-backend shutdown
6649 */
6650void
6652{
6653 /*
6654 * We should have an aux process resource owner to use, and we should not
6655 * be in a transaction that's installed some other resowner.
6656 */
6658 Assert(CurrentResourceOwner == NULL ||
6661
6662 /* Don't be chatty in standalone mode */
6664 (errmsg("shutting down")));
6665
6666 /*
6667 * Signal walsenders to move to stopping state.
6668 */
6670
6671 /*
6672 * Wait for WAL senders to be in stopping state. This prevents commands
6673 * from writing new WAL.
6674 */
6676
6677 if (RecoveryInProgress())
6679 else
6680 {
6681 /*
6682 * If archiving is enabled, rotate the last XLOG file so that all the
6683 * remaining records are archived (postmaster wakes up the archiver
6684 * process one more time at the end of shutdown). The checkpoint
6685 * record will go to the next XLOG file and won't be archived (yet).
6686 */
6687 if (XLogArchivingActive())
6688 RequestXLogSwitch(false);
6689
6691 }
6692}
6693
6694/*
6695 * Log start of a checkpoint.
6696 */
6697static void
6698LogCheckpointStart(int flags, bool restartpoint)
6699{
6700 if (restartpoint)
6701 ereport(LOG,
6702 /* translator: the placeholders show checkpoint options */
6703 (errmsg("restartpoint starting:%s%s%s%s%s%s%s%s",
6704 (flags & CHECKPOINT_IS_SHUTDOWN) ? " shutdown" : "",
6705 (flags & CHECKPOINT_END_OF_RECOVERY) ? " end-of-recovery" : "",
6706 (flags & CHECKPOINT_FAST) ? " fast" : "",
6707 (flags & CHECKPOINT_FORCE) ? " force" : "",
6708 (flags & CHECKPOINT_WAIT) ? " wait" : "",
6709 (flags & CHECKPOINT_CAUSE_XLOG) ? " wal" : "",
6710 (flags & CHECKPOINT_CAUSE_TIME) ? " time" : "",
6711 (flags & CHECKPOINT_FLUSH_UNLOGGED) ? " flush-unlogged" : "")));
6712 else
6713 ereport(LOG,
6714 /* translator: the placeholders show checkpoint options */
6715 (errmsg("checkpoint starting:%s%s%s%s%s%s%s%s",
6716 (flags & CHECKPOINT_IS_SHUTDOWN) ? " shutdown" : "",
6717 (flags & CHECKPOINT_END_OF_RECOVERY) ? " end-of-recovery" : "",
6718 (flags & CHECKPOINT_FAST) ? " fast" : "",
6719 (flags & CHECKPOINT_FORCE) ? " force" : "",
6720 (flags & CHECKPOINT_WAIT) ? " wait" : "",
6721 (flags & CHECKPOINT_CAUSE_XLOG) ? " wal" : "",
6722 (flags & CHECKPOINT_CAUSE_TIME) ? " time" : "",
6723 (flags & CHECKPOINT_FLUSH_UNLOGGED) ? " flush-unlogged" : "")));
6724}
6725
6726/*
6727 * Log end of a checkpoint.
6728 */
6729static void
6730LogCheckpointEnd(bool restartpoint)
6731{
6732 long write_msecs,
6733 sync_msecs,
6734 total_msecs,
6735 longest_msecs,
6736 average_msecs;
6737 uint64 average_sync_time;
6738
6740
6743
6746
6747 /* Accumulate checkpoint timing summary data, in milliseconds. */
6748 PendingCheckpointerStats.write_time += write_msecs;
6749 PendingCheckpointerStats.sync_time += sync_msecs;
6750
6751 /*
6752 * All of the published timing statistics are accounted for. Only
6753 * continue if a log message is to be written.
6754 */
6755 if (!log_checkpoints)
6756 return;
6757
6760
6761 /*
6762 * Timing values returned from CheckpointStats are in microseconds.
6763 * Convert to milliseconds for consistent printing.
6764 */
6765 longest_msecs = (long) ((CheckpointStats.ckpt_longest_sync + 999) / 1000);
6766
6767 average_sync_time = 0;
6769 average_sync_time = CheckpointStats.ckpt_agg_sync_time /
6771 average_msecs = (long) ((average_sync_time + 999) / 1000);
6772
6773 /*
6774 * ControlFileLock is not required to see ControlFile->checkPoint and
6775 * ->checkPointCopy here as we are the only updator of those variables at
6776 * this moment.
6777 */
6778 if (restartpoint)
6779 ereport(LOG,
6780 (errmsg("restartpoint complete: wrote %d buffers (%.1f%%), "
6781 "wrote %d SLRU buffers; %d WAL file(s) added, "
6782 "%d removed, %d recycled; write=%ld.%03d s, "
6783 "sync=%ld.%03d s, total=%ld.%03d s; sync files=%d, "
6784 "longest=%ld.%03d s, average=%ld.%03d s; distance=%d kB, "
6785 "estimate=%d kB; lsn=%X/%08X, redo lsn=%X/%08X",
6792 write_msecs / 1000, (int) (write_msecs % 1000),
6793 sync_msecs / 1000, (int) (sync_msecs % 1000),
6794 total_msecs / 1000, (int) (total_msecs % 1000),
6796 longest_msecs / 1000, (int) (longest_msecs % 1000),
6797 average_msecs / 1000, (int) (average_msecs % 1000),
6798 (int) (PrevCheckPointDistance / 1024.0),
6799 (int) (CheckPointDistanceEstimate / 1024.0),
6802 else
6803 ereport(LOG,
6804 (errmsg("checkpoint complete: wrote %d buffers (%.1f%%), "
6805 "wrote %d SLRU buffers; %d WAL file(s) added, "
6806 "%d removed, %d recycled; write=%ld.%03d s, "
6807 "sync=%ld.%03d s, total=%ld.%03d s; sync files=%d, "
6808 "longest=%ld.%03d s, average=%ld.%03d s; distance=%d kB, "
6809 "estimate=%d kB; lsn=%X/%08X, redo lsn=%X/%08X",
6816 write_msecs / 1000, (int) (write_msecs % 1000),
6817 sync_msecs / 1000, (int) (sync_msecs % 1000),
6818 total_msecs / 1000, (int) (total_msecs % 1000),
6820 longest_msecs / 1000, (int) (longest_msecs % 1000),
6821 average_msecs / 1000, (int) (average_msecs % 1000),
6822 (int) (PrevCheckPointDistance / 1024.0),
6823 (int) (CheckPointDistanceEstimate / 1024.0),
6826}
6827
6828/*
6829 * Update the estimate of distance between checkpoints.
6830 *
6831 * The estimate is used to calculate the number of WAL segments to keep
6832 * preallocated, see XLOGfileslop().
6833 */
6834static void
6836{
6837 /*
6838 * To estimate the number of segments consumed between checkpoints, keep a
6839 * moving average of the amount of WAL generated in previous checkpoint
6840 * cycles. However, if the load is bursty, with quiet periods and busy
6841 * periods, we want to cater for the peak load. So instead of a plain
6842 * moving average, let the average decline slowly if the previous cycle
6843 * used less WAL than estimated, but bump it up immediately if it used
6844 * more.
6845 *
6846 * When checkpoints are triggered by max_wal_size, this should converge to
6847 * CheckpointSegments * wal_segment_size,
6848 *
6849 * Note: This doesn't pay any attention to what caused the checkpoint.
6850 * Checkpoints triggered manually with CHECKPOINT command, or by e.g.
6851 * starting a base backup, are counted the same as those created
6852 * automatically. The slow-decline will largely mask them out, if they are
6853 * not frequent. If they are frequent, it seems reasonable to count them
6854 * in as any others; if you issue a manual checkpoint every 5 minutes and
6855 * never let a timed checkpoint happen, it makes sense to base the
6856 * preallocation on that 5 minute interval rather than whatever
6857 * checkpoint_timeout is set to.
6858 */
6859 PrevCheckPointDistance = nbytes;
6860 if (CheckPointDistanceEstimate < nbytes)
6862 else
6864 (0.90 * CheckPointDistanceEstimate + 0.10 * (double) nbytes);
6865}
6866
6867/*
6868 * Update the ps display for a process running a checkpoint. Note that
6869 * this routine should not do any allocations so as it can be called
6870 * from a critical section.
6871 */
6872static void
6873update_checkpoint_display(int flags, bool restartpoint, bool reset)
6874{
6875 /*
6876 * The status is reported only for end-of-recovery and shutdown
6877 * checkpoints or shutdown restartpoints. Updating the ps display is
6878 * useful in those situations as it may not be possible to rely on
6879 * pg_stat_activity to see the status of the checkpointer or the startup
6880 * process.
6881 */
6883 return;
6884
6885 if (reset)
6886 set_ps_display("");
6887 else
6888 {
6889 char activitymsg[128];
6890
6891 snprintf(activitymsg, sizeof(activitymsg), "performing %s%s%s",
6892 (flags & CHECKPOINT_END_OF_RECOVERY) ? "end-of-recovery " : "",
6893 (flags & CHECKPOINT_IS_SHUTDOWN) ? "shutdown " : "",
6894 restartpoint ? "restartpoint" : "checkpoint");
6895 set_ps_display(activitymsg);
6896 }
6897}
6898
6899
6900/*
6901 * Perform a checkpoint --- either during shutdown, or on-the-fly
6902 *
6903 * flags is a bitwise OR of the following:
6904 * CHECKPOINT_IS_SHUTDOWN: checkpoint is for database shutdown.
6905 * CHECKPOINT_END_OF_RECOVERY: checkpoint is for end of WAL recovery.
6906 * CHECKPOINT_FAST: finish the checkpoint ASAP, ignoring
6907 * checkpoint_completion_target parameter.
6908 * CHECKPOINT_FORCE: force a checkpoint even if no XLOG activity has occurred
6909 * since the last one (implied by CHECKPOINT_IS_SHUTDOWN or
6910 * CHECKPOINT_END_OF_RECOVERY).
6911 * CHECKPOINT_FLUSH_UNLOGGED: also flush buffers of unlogged tables.
6912 *
6913 * Note: flags contains other bits, of interest here only for logging purposes.
6914 * In particular note that this routine is synchronous and does not pay
6915 * attention to CHECKPOINT_WAIT.
6916 *
6917 * If !shutdown then we are writing an online checkpoint. An XLOG_CHECKPOINT_REDO
6918 * record is inserted into WAL at the logical location of the checkpoint, before
6919 * flushing anything to disk, and when the checkpoint is eventually completed,
6920 * and it is from this point that WAL replay will begin in the case of a recovery
6921 * from this checkpoint. Once everything is written to disk, an
6922 * XLOG_CHECKPOINT_ONLINE record is written to complete the checkpoint, and
6923 * points back to the earlier XLOG_CHECKPOINT_REDO record. This mechanism allows
6924 * other write-ahead log records to be written while the checkpoint is in
6925 * progress, but we must be very careful about order of operations. This function
6926 * may take many minutes to execute on a busy system.
6927 *
6928 * On the other hand, when shutdown is true, concurrent insertion into the
6929 * write-ahead log is impossible, so there is no need for two separate records.
6930 * In this case, we only insert an XLOG_CHECKPOINT_SHUTDOWN record, and it's
6931 * both the record marking the completion of the checkpoint and the location
6932 * from which WAL replay would begin if needed.
6933 *
6934 * Returns true if a new checkpoint was performed, or false if it was skipped
6935 * because the system was idle.
6936 */
6937bool
6939{
6940 bool shutdown;
6941 CheckPoint checkPoint;
6942 XLogRecPtr recptr;
6943 XLogSegNo _logSegNo;
6945 uint32 freespace;
6946 XLogRecPtr PriorRedoPtr;
6947 XLogRecPtr last_important_lsn;
6948 VirtualTransactionId *vxids;
6949 int nvxids;
6950 int oldXLogAllowed = 0;
6951
6952 /*
6953 * An end-of-recovery checkpoint is really a shutdown checkpoint, just
6954 * issued at a different time.
6955 */
6957 shutdown = true;
6958 else
6959 shutdown = false;
6960
6961 /* sanity check */
6962 if (RecoveryInProgress() && (flags & CHECKPOINT_END_OF_RECOVERY) == 0)
6963 elog(ERROR, "can't create a checkpoint during recovery");
6964
6965 /*
6966 * Prepare to accumulate statistics.
6967 *
6968 * Note: because it is possible for log_checkpoints to change while a
6969 * checkpoint proceeds, we always accumulate stats, even if
6970 * log_checkpoints is currently off.
6971 */
6974
6975 /*
6976 * Let smgr prepare for checkpoint; this has to happen outside the
6977 * critical section and before we determine the REDO pointer. Note that
6978 * smgr must not do anything that'd have to be undone if we decide no
6979 * checkpoint is needed.
6980 */
6982
6983 /*
6984 * Use a critical section to force system panic if we have trouble.
6985 */
6987
6988 if (shutdown)
6989 {
6990 LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
6993 LWLockRelease(ControlFileLock);
6994 }
6995
6996 /* Begin filling in the checkpoint WAL record */
6997 MemSet(&checkPoint, 0, sizeof(checkPoint));
6998 checkPoint.time = (pg_time_t) time(NULL);
6999
7000 /*
7001 * For Hot Standby, derive the oldestActiveXid before we fix the redo
7002 * pointer. This allows us to begin accumulating changes to assemble our
7003 * starting snapshot of locks and transactions.
7004 */
7005 if (!shutdown && XLogStandbyInfoActive())
7006 checkPoint.oldestActiveXid = GetOldestActiveTransactionId(false, true);
7007 else
7009
7010 /*
7011 * Get location of last important record before acquiring insert locks (as
7012 * GetLastImportantRecPtr() also locks WAL locks).
7013 */
7014 last_important_lsn = GetLastImportantRecPtr();
7015
7016 /*
7017 * If this isn't a shutdown or forced checkpoint, and if there has been no
7018 * WAL activity requiring a checkpoint, skip it. The idea here is to
7019 * avoid inserting duplicate checkpoints when the system is idle.
7020 */
7022 CHECKPOINT_FORCE)) == 0)
7023 {
7024 if (last_important_lsn == ControlFile->checkPoint)
7025 {
7028 (errmsg_internal("checkpoint skipped because system is idle")));
7029 return false;
7030 }
7031 }
7032
7033 /*
7034 * An end-of-recovery checkpoint is created before anyone is allowed to
7035 * write WAL. To allow us to write the checkpoint record, temporarily
7036 * enable XLogInsertAllowed.
7037 */
7038 if (flags & CHECKPOINT_END_OF_RECOVERY)
7039 oldXLogAllowed = LocalSetXLogInsertAllowed();
7040
7042 if (flags & CHECKPOINT_END_OF_RECOVERY)
7044 else
7045 checkPoint.PrevTimeLineID = checkPoint.ThisTimeLineID;
7046
7047 /*
7048 * We must block concurrent insertions while examining insert state.
7049 */
7051
7052 checkPoint.fullPageWrites = Insert->fullPageWrites;
7053 checkPoint.wal_level = wal_level;
7054
7055 if (shutdown)
7056 {
7057 XLogRecPtr curInsert = XLogBytePosToRecPtr(Insert->CurrBytePos);
7058
7059 /*
7060 * Compute new REDO record ptr = location of next XLOG record.
7061 *
7062 * Since this is a shutdown checkpoint, there can't be any concurrent
7063 * WAL insertion.
7064 */
7065 freespace = INSERT_FREESPACE(curInsert);
7066 if (freespace == 0)
7067 {
7068 if (XLogSegmentOffset(curInsert, wal_segment_size) == 0)
7069 curInsert += SizeOfXLogLongPHD;
7070 else
7071 curInsert += SizeOfXLogShortPHD;
7072 }
7073 checkPoint.redo = curInsert;
7074
7075 /*
7076 * Here we update the shared RedoRecPtr for future XLogInsert calls;
7077 * this must be done while holding all the insertion locks.
7078 *
7079 * Note: if we fail to complete the checkpoint, RedoRecPtr will be
7080 * left pointing past where it really needs to point. This is okay;
7081 * the only consequence is that XLogInsert might back up whole buffers
7082 * that it didn't really need to. We can't postpone advancing
7083 * RedoRecPtr because XLogInserts that happen while we are dumping
7084 * buffers must assume that their buffer changes are not included in
7085 * the checkpoint.
7086 */
7087 RedoRecPtr = XLogCtl->Insert.RedoRecPtr = checkPoint.redo;
7088 }
7089
7090 /*
7091 * Now we can release the WAL insertion locks, allowing other xacts to
7092 * proceed while we are flushing disk buffers.
7093 */
7095
7096 /*
7097 * If this is an online checkpoint, we have not yet determined the redo
7098 * point. We do so now by inserting the special XLOG_CHECKPOINT_REDO
7099 * record; the LSN at which it starts becomes the new redo pointer. We
7100 * don't do this for a shutdown checkpoint, because in that case no WAL
7101 * can be written between the redo point and the insertion of the
7102 * checkpoint record itself, so the checkpoint record itself serves to
7103 * mark the redo point.
7104 */
7105 if (!shutdown)
7106 {
7107 /* Include WAL level in record for WAL summarizer's benefit. */
7110 (void) XLogInsert(RM_XLOG_ID, XLOG_CHECKPOINT_REDO);
7111
7112 /*
7113 * XLogInsertRecord will have updated XLogCtl->Insert.RedoRecPtr in
7114 * shared memory and RedoRecPtr in backend-local memory, but we need
7115 * to copy that into the record that will be inserted when the
7116 * checkpoint is complete.
7117 */
7118 checkPoint.redo = RedoRecPtr;
7119 }
7120
7121 /* Update the info_lck-protected copy of RedoRecPtr as well */
7123 XLogCtl->RedoRecPtr = checkPoint.redo;
7125
7126 /*
7127 * If enabled, log checkpoint start. We postpone this until now so as not
7128 * to log anything if we decided to skip the checkpoint.
7129 */
7130 if (log_checkpoints)
7131 LogCheckpointStart(flags, false);
7132
7133 /* Update the process title */
7134 update_checkpoint_display(flags, false, false);
7135
7136 TRACE_POSTGRESQL_CHECKPOINT_START(flags);
7137
7138 /*
7139 * Get the other info we need for the checkpoint record.
7140 *
7141 * We don't need to save oldestClogXid in the checkpoint, it only matters
7142 * for the short period in which clog is being truncated, and if we crash
7143 * during that we'll redo the clog truncation and fix up oldestClogXid
7144 * there.
7145 */
7146 LWLockAcquire(XidGenLock, LW_SHARED);
7147 checkPoint.nextXid = TransamVariables->nextXid;
7148 checkPoint.oldestXid = TransamVariables->oldestXid;
7150 LWLockRelease(XidGenLock);
7151
7152 LWLockAcquire(CommitTsLock, LW_SHARED);
7155 LWLockRelease(CommitTsLock);
7156
7157 LWLockAcquire(OidGenLock, LW_SHARED);
7158 checkPoint.nextOid = TransamVariables->nextOid;
7159 if (!shutdown)
7160 checkPoint.nextOid += TransamVariables->oidCount;
7161 LWLockRelease(OidGenLock);
7162
7163 MultiXactGetCheckptMulti(shutdown,
7164 &checkPoint.nextMulti,
7165 &checkPoint.nextMultiOffset,
7166 &checkPoint.oldestMulti,
7167 &checkPoint.oldestMultiDB);
7168
7169 /*
7170 * Having constructed the checkpoint record, ensure all shmem disk buffers
7171 * and commit-log buffers are flushed to disk.
7172 *
7173 * This I/O could fail for various reasons. If so, we will fail to
7174 * complete the checkpoint, but there is no reason to force a system
7175 * panic. Accordingly, exit critical section while doing it.
7176 */
7178
7179 /*
7180 * In some cases there are groups of actions that must all occur on one
7181 * side or the other of a checkpoint record. Before flushing the
7182 * checkpoint record we must explicitly wait for any backend currently
7183 * performing those groups of actions.
7184 *
7185 * One example is end of transaction, so we must wait for any transactions
7186 * that are currently in commit critical sections. If an xact inserted
7187 * its commit record into XLOG just before the REDO point, then a crash
7188 * restart from the REDO point would not replay that record, which means
7189 * that our flushing had better include the xact's update of pg_xact. So
7190 * we wait till he's out of his commit critical section before proceeding.
7191 * See notes in RecordTransactionCommit().
7192 *
7193 * Because we've already released the insertion locks, this test is a bit
7194 * fuzzy: it is possible that we will wait for xacts we didn't really need
7195 * to wait for. But the delay should be short and it seems better to make
7196 * checkpoint take a bit longer than to hold off insertions longer than
7197 * necessary. (In fact, the whole reason we have this issue is that xact.c
7198 * does commit record XLOG insertion and clog update as two separate steps
7199 * protected by different locks, but again that seems best on grounds of
7200 * minimizing lock contention.)
7201 *
7202 * A transaction that has not yet set delayChkptFlags when we look cannot
7203 * be at risk, since it has not inserted its commit record yet; and one
7204 * that's already cleared it is not at risk either, since it's done fixing
7205 * clog and we will correctly flush the update below. So we cannot miss
7206 * any xacts we need to wait for.
7207 */
7209 if (nvxids > 0)
7210 {
7211 do
7212 {
7213 /*
7214 * Keep absorbing fsync requests while we wait. There could even
7215 * be a deadlock if we don't, if the process that prevents the
7216 * checkpoint is trying to add a request to the queue.
7217 */
7219
7220 pgstat_report_wait_start(WAIT_EVENT_CHECKPOINT_DELAY_START);
7221 pg_usleep(10000L); /* wait for 10 msec */
7223 } while (HaveVirtualXIDsDelayingChkpt(vxids, nvxids,
7225 }
7226 pfree(vxids);
7227
7228 CheckPointGuts(checkPoint.redo, flags);
7229
7231 if (nvxids > 0)
7232 {
7233 do
7234 {
7236
7237 pgstat_report_wait_start(WAIT_EVENT_CHECKPOINT_DELAY_COMPLETE);
7238 pg_usleep(10000L); /* wait for 10 msec */
7240 } while (HaveVirtualXIDsDelayingChkpt(vxids, nvxids,
7242 }
7243 pfree(vxids);
7244
7245 /*
7246 * Take a snapshot of running transactions and write this to WAL. This
7247 * allows us to reconstruct the state of running transactions during
7248 * archive recovery, if required. Skip, if this info disabled.
7249 *
7250 * If we are shutting down, or Startup process is completing crash
7251 * recovery we don't need to write running xact data.
7252 */
7253 if (!shutdown && XLogStandbyInfoActive())
7255
7257
7258 /*
7259 * Now insert the checkpoint record into XLOG.
7260 */
7262 XLogRegisterData(&checkPoint, sizeof(checkPoint));
7263 recptr = XLogInsert(RM_XLOG_ID,
7264 shutdown ? XLOG_CHECKPOINT_SHUTDOWN :
7266
7267 XLogFlush(recptr);
7268
7269 /*
7270 * We mustn't write any new WAL after a shutdown checkpoint, or it will be
7271 * overwritten at next startup. No-one should even try, this just allows
7272 * sanity-checking. In the case of an end-of-recovery checkpoint, we want
7273 * to just temporarily disable writing until the system has exited
7274 * recovery.
7275 */
7276 if (shutdown)
7277 {
7278 if (flags & CHECKPOINT_END_OF_RECOVERY)
7279 LocalXLogInsertAllowed = oldXLogAllowed;
7280 else
7281 LocalXLogInsertAllowed = 0; /* never again write WAL */
7282 }
7283
7284 /*
7285 * We now have ProcLastRecPtr = start of actual checkpoint record, recptr
7286 * = end of actual checkpoint record.
7287 */
7288 if (shutdown && checkPoint.redo != ProcLastRecPtr)
7289 ereport(PANIC,
7290 (errmsg("concurrent write-ahead log activity while database system is shutting down")));
7291
7292 /*
7293 * Remember the prior checkpoint's redo ptr for
7294 * UpdateCheckPointDistanceEstimate()
7295 */
7296 PriorRedoPtr = ControlFile->checkPointCopy.redo;
7297
7298 /*
7299 * Update the control file.
7300 */
7301 LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
7302 if (shutdown)
7305 ControlFile->checkPointCopy = checkPoint;
7306 /* crash recovery should always recover to the end of WAL */
7309
7310 /*
7311 * Persist unloggedLSN value. It's reset on crash recovery, so this goes
7312 * unused on non-shutdown checkpoints, but seems useful to store it always
7313 * for debugging purposes.
7314 */
7316
7318 LWLockRelease(ControlFileLock);
7319
7320 /*
7321 * We are now done with critical updates; no need for system panic if we
7322 * have trouble while fooling with old log segments.
7323 */
7325
7326 /*
7327 * WAL summaries end when the next XLOG_CHECKPOINT_REDO or
7328 * XLOG_CHECKPOINT_SHUTDOWN record is reached. This is the first point
7329 * where (a) we're not inside of a critical section and (b) we can be
7330 * certain that the relevant record has been flushed to disk, which must
7331 * happen before it can be summarized.
7332 *
7333 * If this is a shutdown checkpoint, then this happens reasonably
7334 * promptly: we've only just inserted and flushed the
7335 * XLOG_CHECKPOINT_SHUTDOWN record. If this is not a shutdown checkpoint,
7336 * then this might not be very prompt at all: the XLOG_CHECKPOINT_REDO
7337 * record was written before we began flushing data to disk, and that
7338 * could be many minutes ago at this point. However, we don't XLogFlush()
7339 * after inserting that record, so we're not guaranteed that it's on disk
7340 * until after the above call that flushes the XLOG_CHECKPOINT_ONLINE
7341 * record.
7342 */
7344
7345 /*
7346 * Let smgr do post-checkpoint cleanup (eg, deleting old files).
7347 */
7349
7350 /*
7351 * Update the average distance between checkpoints if the prior checkpoint
7352 * exists.
7353 */
7354 if (PriorRedoPtr != InvalidXLogRecPtr)
7356
7357 INJECTION_POINT("checkpoint-before-old-wal-removal", NULL);
7358
7359 /*
7360 * Delete old log files, those no longer needed for last checkpoint to
7361 * prevent the disk holding the xlog from growing full.
7362 */
7364 KeepLogSeg(recptr, &_logSegNo);
7366 _logSegNo, InvalidOid,
7368 {
7369 /*
7370 * Some slots have been invalidated; recalculate the old-segment
7371 * horizon, starting again from RedoRecPtr.
7372 */
7374 KeepLogSeg(recptr, &_logSegNo);
7375 }
7376 _logSegNo--;
7377 RemoveOldXlogFiles(_logSegNo, RedoRecPtr, recptr,
7378 checkPoint.ThisTimeLineID);
7379
7380 /*
7381 * Make more log segments if needed. (Do this after recycling old log
7382 * segments, since that may supply some of the needed files.)
7383 */
7384 if (!shutdown)
7385 PreallocXlogFiles(recptr, checkPoint.ThisTimeLineID);
7386
7387 /*
7388 * Truncate pg_subtrans if possible. We can throw away all data before
7389 * the oldest XMIN of any running transaction. No future transaction will
7390 * attempt to reference any pg_subtrans entry older than that (see Asserts
7391 * in subtrans.c). During recovery, though, we mustn't do this because
7392 * StartupSUBTRANS hasn't been called yet.
7393 */
7394 if (!RecoveryInProgress())
7396
7397 /* Real work is done; log and update stats. */
7398 LogCheckpointEnd(false);
7399
7400 /* Reset the process title */
7401 update_checkpoint_display(flags, false, true);
7402
7403 TRACE_POSTGRESQL_CHECKPOINT_DONE(CheckpointStats.ckpt_bufs_written,
7404 NBuffers,
7408
7409 return true;
7410}
7411
7412/*
7413 * Mark the end of recovery in WAL though without running a full checkpoint.
7414 * We can expect that a restartpoint is likely to be in progress as we
7415 * do this, though we are unwilling to wait for it to complete.
7416 *
7417 * CreateRestartPoint() allows for the case where recovery may end before
7418 * the restartpoint completes so there is no concern of concurrent behaviour.
7419 */
7420static void
7422{
7423 xl_end_of_recovery xlrec;
7424 XLogRecPtr recptr;
7425
7426 /* sanity check */
7427 if (!RecoveryInProgress())
7428 elog(ERROR, "can only be used to end recovery");
7429
7430 xlrec.end_time = GetCurrentTimestamp();
7431 xlrec.wal_level = wal_level;
7432
7437
7439
7441 XLogRegisterData(&xlrec, sizeof(xl_end_of_recovery));
7442 recptr = XLogInsert(RM_XLOG_ID, XLOG_END_OF_RECOVERY);
7443
7444 XLogFlush(recptr);
7445
7446 /*
7447 * Update the control file so that crash recovery can follow the timeline
7448 * changes to this point.
7449 */
7450 LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
7451 ControlFile->minRecoveryPoint = recptr;
7454 LWLockRelease(ControlFileLock);
7455
7457}
7458
7459/*
7460 * Write an OVERWRITE_CONTRECORD message.
7461 *
7462 * When on WAL replay we expect a continuation record at the start of a page
7463 * that is not there, recovery ends and WAL writing resumes at that point.
7464 * But it's wrong to resume writing new WAL back at the start of the record
7465 * that was broken, because downstream consumers of that WAL (physical
7466 * replicas) are not prepared to "rewind". So the first action after
7467 * finishing replay of all valid WAL must be to write a record of this type
7468 * at the point where the contrecord was missing; to support xlogreader
7469 * detecting the special case, XLP_FIRST_IS_OVERWRITE_CONTRECORD is also added
7470 * to the page header where the record occurs. xlogreader has an ad-hoc
7471 * mechanism to report metadata about the broken record, which is what we
7472 * use here.
7473 *
7474 * At replay time, XLP_FIRST_IS_OVERWRITE_CONTRECORD instructs xlogreader to
7475 * skip the record it was reading, and pass back the LSN of the skipped
7476 * record, so that its caller can verify (on "replay" of that record) that the
7477 * XLOG_OVERWRITE_CONTRECORD matches what was effectively overwritten.
7478 *
7479 * 'aborted_lsn' is the beginning position of the record that was incomplete.
7480 * It is included in the WAL record. 'pagePtr' and 'newTLI' point to the
7481 * beginning of the XLOG page where the record is to be inserted. They must
7482 * match the current WAL insert position, they're passed here just so that we
7483 * can verify that.
7484 */
7485static XLogRecPtr
7487 TimeLineID newTLI)
7488{
7490 XLogRecPtr recptr;
7491 XLogPageHeader pagehdr;
7492 XLogRecPtr startPos;
7493
7494 /* sanity checks */
7495 if (!RecoveryInProgress())
7496 elog(ERROR, "can only be used at end of recovery");
7497 if (pagePtr % XLOG_BLCKSZ != 0)
7498 elog(ERROR, "invalid position for missing continuation record %X/%08X",
7499 LSN_FORMAT_ARGS(pagePtr));
7500
7501 /* The current WAL insert position should be right after the page header */
7502 startPos = pagePtr;
7503 if (XLogSegmentOffset(startPos, wal_segment_size) == 0)
7504 startPos += SizeOfXLogLongPHD;
7505 else
7506 startPos += SizeOfXLogShortPHD;
7507 recptr = GetXLogInsertRecPtr();
7508 if (recptr != startPos)
7509 elog(ERROR, "invalid WAL insert position %X/%08X for OVERWRITE_CONTRECORD",
7510 LSN_FORMAT_ARGS(recptr));
7511
7513
7514 /*
7515 * Initialize the XLOG page header (by GetXLogBuffer), and set the
7516 * XLP_FIRST_IS_OVERWRITE_CONTRECORD flag.
7517 *
7518 * No other backend is allowed to write WAL yet, so acquiring the WAL
7519 * insertion lock is just pro forma.
7520 */
7522 pagehdr = (XLogPageHeader) GetXLogBuffer(pagePtr, newTLI);
7525
7526 /*
7527 * Insert the XLOG_OVERWRITE_CONTRECORD record as the first record on the
7528 * page. We know it becomes the first record, because no other backend is
7529 * allowed to write WAL yet.
7530 */
7532 xlrec.overwritten_lsn = aborted_lsn;
7535 recptr = XLogInsert(RM_XLOG_ID, XLOG_OVERWRITE_CONTRECORD);
7536
7537 /* check that the record was inserted to the right place */
7538 if (ProcLastRecPtr != startPos)
7539 elog(ERROR, "OVERWRITE_CONTRECORD was inserted to unexpected position %X/%08X",
7541
7542 XLogFlush(recptr);
7543
7545
7546 return recptr;
7547}
7548
7549/*
7550 * Flush all data in shared memory to disk, and fsync
7551 *
7552 * This is the common code shared between regular checkpoints and
7553 * recovery restartpoints.
7554 */
7555static void
7556CheckPointGuts(XLogRecPtr checkPointRedo, int flags)
7557{
7563
7564 /* Write out all dirty data in SLRUs and the main buffer pool */
7565 TRACE_POSTGRESQL_BUFFER_CHECKPOINT_START(flags);
7572 CheckPointBuffers(flags);
7573
7574 /* Perform all queued up fsyncs */
7575 TRACE_POSTGRESQL_BUFFER_CHECKPOINT_SYNC_START();
7579 TRACE_POSTGRESQL_BUFFER_CHECKPOINT_DONE();
7580
7581 /* We deliberately delay 2PC checkpointing as long as possible */
7582 CheckPointTwoPhase(checkPointRedo);
7583}
7584
7585/*
7586 * Save a checkpoint for recovery restart if appropriate
7587 *
7588 * This function is called each time a checkpoint record is read from XLOG.
7589 * It must determine whether the checkpoint represents a safe restartpoint or
7590 * not. If so, the checkpoint record is stashed in shared memory so that
7591 * CreateRestartPoint can consult it. (Note that the latter function is
7592 * executed by the checkpointer, while this one will be executed by the
7593 * startup process.)
7594 */
7595static void
7597{
7598 /*
7599 * Also refrain from creating a restartpoint if we have seen any
7600 * references to non-existent pages. Restarting recovery from the
7601 * restartpoint would not see the references, so we would lose the
7602 * cross-check that the pages belonged to a relation that was dropped
7603 * later.
7604 */
7606 {
7607 elog(DEBUG2,
7608 "could not record restart point at %X/%08X because there are unresolved references to invalid pages",
7609 LSN_FORMAT_ARGS(checkPoint->redo));
7610 return;
7611 }
7612
7613 /*
7614 * Copy the checkpoint record to shared memory, so that checkpointer can
7615 * work out the next time it wants to perform a restartpoint.
7616 */
7620 XLogCtl->lastCheckPoint = *checkPoint;
7622}
7623
7624/*
7625 * Establish a restartpoint if possible.
7626 *
7627 * This is similar to CreateCheckPoint, but is used during WAL recovery
7628 * to establish a point from which recovery can roll forward without
7629 * replaying the entire recovery log.
7630 *
7631 * Returns true if a new restartpoint was established. We can only establish
7632 * a restartpoint if we have replayed a safe checkpoint record since last
7633 * restartpoint.
7634 */
7635bool
7637{
7638 XLogRecPtr lastCheckPointRecPtr;
7639 XLogRecPtr lastCheckPointEndPtr;
7640 CheckPoint lastCheckPoint;
7641 XLogRecPtr PriorRedoPtr;
7642 XLogRecPtr receivePtr;
7643 XLogRecPtr replayPtr;
7644 TimeLineID replayTLI;
7645 XLogRecPtr endptr;
7646 XLogSegNo _logSegNo;
7647 TimestampTz xtime;
7648
7649 /* Concurrent checkpoint/restartpoint cannot happen */
7651
7652 /* Get a local copy of the last safe checkpoint record. */
7654 lastCheckPointRecPtr = XLogCtl->lastCheckPointRecPtr;
7655 lastCheckPointEndPtr = XLogCtl->lastCheckPointEndPtr;
7656 lastCheckPoint = XLogCtl->lastCheckPoint;
7658
7659 /*
7660 * Check that we're still in recovery mode. It's ok if we exit recovery
7661 * mode after this check, the restart point is valid anyway.
7662 */
7663 if (!RecoveryInProgress())
7664 {
7666 (errmsg_internal("skipping restartpoint, recovery has already ended")));
7667 return false;
7668 }
7669
7670 /*
7671 * If the last checkpoint record we've replayed is already our last
7672 * restartpoint, we can't perform a new restart point. We still update
7673 * minRecoveryPoint in that case, so that if this is a shutdown restart
7674 * point, we won't start up earlier than before. That's not strictly
7675 * necessary, but when hot standby is enabled, it would be rather weird if
7676 * the database opened up for read-only connections at a point-in-time
7677 * before the last shutdown. Such time travel is still possible in case of
7678 * immediate shutdown, though.
7679 *
7680 * We don't explicitly advance minRecoveryPoint when we do create a
7681 * restartpoint. It's assumed that flushing the buffers will do that as a
7682 * side-effect.
7683 */
7684 if (XLogRecPtrIsInvalid(lastCheckPointRecPtr) ||
7685 lastCheckPoint.redo <= ControlFile->checkPointCopy.redo)
7686 {
7688 errmsg_internal("skipping restartpoint, already performed at %X/%08X",
7689 LSN_FORMAT_ARGS(lastCheckPoint.redo)));
7690
7692 if (flags & CHECKPOINT_IS_SHUTDOWN)
7693 {
7694 LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
7697 LWLockRelease(ControlFileLock);
7698 }
7699 return false;
7700 }
7701
7702 /*
7703 * Update the shared RedoRecPtr so that the startup process can calculate
7704 * the number of segments replayed since last restartpoint, and request a
7705 * restartpoint if it exceeds CheckPointSegments.
7706 *
7707 * Like in CreateCheckPoint(), hold off insertions to update it, although
7708 * during recovery this is just pro forma, because no WAL insertions are
7709 * happening.
7710 */
7712 RedoRecPtr = XLogCtl->Insert.RedoRecPtr = lastCheckPoint.redo;
7714
7715 /* Also update the info_lck-protected copy */
7717 XLogCtl->RedoRecPtr = lastCheckPoint.redo;
7719
7720 /*
7721 * Prepare to accumulate statistics.
7722 *
7723 * Note: because it is possible for log_checkpoints to change while a
7724 * checkpoint proceeds, we always accumulate stats, even if
7725 * log_checkpoints is currently off.
7726 */
7729
7730 if (log_checkpoints)
7731 LogCheckpointStart(flags, true);
7732
7733 /* Update the process title */
7734 update_checkpoint_display(flags, true, false);
7735
7736 CheckPointGuts(lastCheckPoint.redo, flags);
7737
7738 /*
7739 * This location needs to be after CheckPointGuts() to ensure that some
7740 * work has already happened during this checkpoint.
7741 */
7742 INJECTION_POINT("create-restart-point", NULL);
7743
7744 /*
7745 * Remember the prior checkpoint's redo ptr for
7746 * UpdateCheckPointDistanceEstimate()
7747 */
7748 PriorRedoPtr = ControlFile->checkPointCopy.redo;
7749
7750 /*
7751 * Update pg_control, using current time. Check that it still shows an
7752 * older checkpoint, else do nothing; this is a quick hack to make sure
7753 * nothing really bad happens if somehow we get here after the
7754 * end-of-recovery checkpoint.
7755 */
7756 LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
7757 if (ControlFile->checkPointCopy.redo < lastCheckPoint.redo)
7758 {
7759 /*
7760 * Update the checkpoint information. We do this even if the cluster
7761 * does not show DB_IN_ARCHIVE_RECOVERY to match with the set of WAL
7762 * segments recycled below.
7763 */
7764 ControlFile->checkPoint = lastCheckPointRecPtr;
7765 ControlFile->checkPointCopy = lastCheckPoint;
7766
7767 /*
7768 * Ensure minRecoveryPoint is past the checkpoint record and update it
7769 * if the control file still shows DB_IN_ARCHIVE_RECOVERY. Normally,
7770 * this will have happened already while writing out dirty buffers,
7771 * but not necessarily - e.g. because no buffers were dirtied. We do
7772 * this because a backup performed in recovery uses minRecoveryPoint
7773 * to determine which WAL files must be included in the backup, and
7774 * the file (or files) containing the checkpoint record must be
7775 * included, at a minimum. Note that for an ordinary restart of
7776 * recovery there's no value in having the minimum recovery point any
7777 * earlier than this anyway, because redo will begin just after the
7778 * checkpoint record.
7779 */
7781 {
7782 if (ControlFile->minRecoveryPoint < lastCheckPointEndPtr)
7783 {
7784 ControlFile->minRecoveryPoint = lastCheckPointEndPtr;
7786
7787 /* update local copy */
7790 }
7791 if (flags & CHECKPOINT_IS_SHUTDOWN)
7793 }
7795 }
7796 LWLockRelease(ControlFileLock);
7797
7798 /*
7799 * Update the average distance between checkpoints/restartpoints if the
7800 * prior checkpoint exists.
7801 */
7802 if (PriorRedoPtr != InvalidXLogRecPtr)
7804
7805 /*
7806 * Delete old log files, those no longer needed for last restartpoint to
7807 * prevent the disk holding the xlog from growing full.
7808 */
7810
7811 /*
7812 * Retreat _logSegNo using the current end of xlog replayed or received,
7813 * whichever is later.
7814 */
7815 receivePtr = GetWalRcvFlushRecPtr(NULL, NULL);
7816 replayPtr = GetXLogReplayRecPtr(&replayTLI);
7817 endptr = (receivePtr < replayPtr) ? replayPtr : receivePtr;
7818 KeepLogSeg(endptr, &_logSegNo);
7820 _logSegNo, InvalidOid,
7822 {
7823 /*
7824 * Some slots have been invalidated; recalculate the old-segment
7825 * horizon, starting again from RedoRecPtr.
7826 */
7828 KeepLogSeg(endptr, &_logSegNo);
7829 }
7830 _logSegNo--;
7831
7832 /*
7833 * Try to recycle segments on a useful timeline. If we've been promoted
7834 * since the beginning of this restartpoint, use the new timeline chosen
7835 * at end of recovery. If we're still in recovery, use the timeline we're
7836 * currently replaying.
7837 *
7838 * There is no guarantee that the WAL segments will be useful on the
7839 * current timeline; if recovery proceeds to a new timeline right after
7840 * this, the pre-allocated WAL segments on this timeline will not be used,
7841 * and will go wasted until recycled on the next restartpoint. We'll live
7842 * with that.
7843 */
7844 if (!RecoveryInProgress())
7845 replayTLI = XLogCtl->InsertTimeLineID;
7846
7847 RemoveOldXlogFiles(_logSegNo, RedoRecPtr, endptr, replayTLI);
7848
7849 /*
7850 * Make more log segments if needed. (Do this after recycling old log
7851 * segments, since that may supply some of the needed files.)
7852 */
7853 PreallocXlogFiles(endptr, replayTLI);
7854
7855 /*
7856 * Truncate pg_subtrans if possible. We can throw away all data before
7857 * the oldest XMIN of any running transaction. No future transaction will
7858 * attempt to reference any pg_subtrans entry older than that (see Asserts
7859 * in subtrans.c). When hot standby is disabled, though, we mustn't do
7860 * this because StartupSUBTRANS hasn't been called yet.
7861 */
7862 if (EnableHotStandby)
7864
7865 /* Real work is done; log and update stats. */
7866 LogCheckpointEnd(true);
7867
7868 /* Reset the process title */
7869 update_checkpoint_display(flags, true, true);
7870
7871 xtime = GetLatestXTime();
7873 errmsg("recovery restart point at %X/%08X",
7874 LSN_FORMAT_ARGS(lastCheckPoint.redo)),
7875 xtime ? errdetail("Last completed transaction was at log time %s.",
7876 timestamptz_to_str(xtime)) : 0);
7877
7878 /*
7879 * Finally, execute archive_cleanup_command, if any.
7880 */
7881 if (archiveCleanupCommand && strcmp(archiveCleanupCommand, "") != 0)
7883 "archive_cleanup_command",
7884 false,
7885 WAIT_EVENT_ARCHIVE_CLEANUP_COMMAND);
7886
7887 return true;
7888}
7889
7890/*
7891 * Report availability of WAL for the given target LSN
7892 * (typically a slot's restart_lsn)
7893 *
7894 * Returns one of the following enum values:
7895 *
7896 * * WALAVAIL_RESERVED means targetLSN is available and it is in the range of
7897 * max_wal_size.
7898 *
7899 * * WALAVAIL_EXTENDED means it is still available by preserving extra
7900 * segments beyond max_wal_size. If max_slot_wal_keep_size is smaller
7901 * than max_wal_size, this state is not returned.
7902 *
7903 * * WALAVAIL_UNRESERVED means it is being lost and the next checkpoint will
7904 * remove reserved segments. The walsender using this slot may return to the
7905 * above.
7906 *
7907 * * WALAVAIL_REMOVED means it has been removed. A replication stream on
7908 * a slot with this LSN cannot continue. (Any associated walsender
7909 * processes should have been terminated already.)
7910 *
7911 * * WALAVAIL_INVALID_LSN means the slot hasn't been set to reserve WAL.
7912 */
7915{
7916 XLogRecPtr currpos; /* current write LSN */
7917 XLogSegNo currSeg; /* segid of currpos */
7918 XLogSegNo targetSeg; /* segid of targetLSN */
7919 XLogSegNo oldestSeg; /* actual oldest segid */
7920 XLogSegNo oldestSegMaxWalSize; /* oldest segid kept by max_wal_size */
7921 XLogSegNo oldestSlotSeg; /* oldest segid kept by slot */
7922 uint64 keepSegs;
7923
7924 /*
7925 * slot does not reserve WAL. Either deactivated, or has never been active
7926 */
7927 if (XLogRecPtrIsInvalid(targetLSN))
7928 return WALAVAIL_INVALID_LSN;
7929
7930 /*
7931 * Calculate the oldest segment currently reserved by all slots,
7932 * considering wal_keep_size and max_slot_wal_keep_size. Initialize
7933 * oldestSlotSeg to the current segment.
7934 */
7935 currpos = GetXLogWriteRecPtr();
7936 XLByteToSeg(currpos, oldestSlotSeg, wal_segment_size);
7937 KeepLogSeg(currpos, &oldestSlotSeg);
7938
7939 /*
7940 * Find the oldest extant segment file. We get 1 until checkpoint removes
7941 * the first WAL segment file since startup, which causes the status being
7942 * wrong under certain abnormal conditions but that doesn't actually harm.
7943 */
7944 oldestSeg = XLogGetLastRemovedSegno() + 1;
7945
7946 /* calculate oldest segment by max_wal_size */
7947 XLByteToSeg(currpos, currSeg, wal_segment_size);
7949
7950 if (currSeg > keepSegs)
7951 oldestSegMaxWalSize = currSeg - keepSegs;
7952 else
7953 oldestSegMaxWalSize = 1;
7954
7955 /* the segment we care about */
7956 XLByteToSeg(targetLSN, targetSeg, wal_segment_size);
7957
7958 /*
7959 * No point in returning reserved or extended status values if the
7960 * targetSeg is known to be lost.
7961 */
7962 if (targetSeg >= oldestSlotSeg)
7963 {
7964 /* show "reserved" when targetSeg is within max_wal_size */
7965 if (targetSeg >= oldestSegMaxWalSize)
7966 return WALAVAIL_RESERVED;
7967
7968 /* being retained by slots exceeding max_wal_size */
7969 return WALAVAIL_EXTENDED;
7970 }
7971
7972 /* WAL segments are no longer retained but haven't been removed yet */
7973 if (targetSeg >= oldestSeg)
7974 return WALAVAIL_UNRESERVED;
7975
7976 /* Definitely lost */
7977 return WALAVAIL_REMOVED;
7978}
7979
7980
7981/*
7982 * Retreat *logSegNo to the last segment that we need to retain because of
7983 * either wal_keep_size or replication slots.
7984 *
7985 * This is calculated by subtracting wal_keep_size from the given xlog
7986 * location, recptr and by making sure that that result is below the
7987 * requirement of replication slots. For the latter criterion we do consider
7988 * the effects of max_slot_wal_keep_size: reserve at most that much space back
7989 * from recptr.
7990 *
7991 * Note about replication slots: if this function calculates a value
7992 * that's further ahead than what slots need reserved, then affected
7993 * slots need to be invalidated and this function invoked again.
7994 * XXX it might be a good idea to rewrite this function so that
7995 * invalidation is optionally done here, instead.
7996 */
7997static void
7999{
8000 XLogSegNo currSegNo;
8001 XLogSegNo segno;
8002 XLogRecPtr keep;
8003
8004 XLByteToSeg(recptr, currSegNo, wal_segment_size);
8005 segno = currSegNo;
8006
8007 /* Calculate how many segments are kept by slots. */
8009 if (keep != InvalidXLogRecPtr && keep < recptr)
8010 {
8011 XLByteToSeg(keep, segno, wal_segment_size);
8012
8013 /*
8014 * Account for max_slot_wal_keep_size to avoid keeping more than
8015 * configured. However, don't do that during a binary upgrade: if
8016 * slots were to be invalidated because of this, it would not be
8017 * possible to preserve logical ones during the upgrade.
8018 */
8020 {
8021 uint64 slot_keep_segs;
8022
8023 slot_keep_segs =
8025
8026 if (currSegNo - segno > slot_keep_segs)
8027 segno = currSegNo - slot_keep_segs;
8028 }
8029 }
8030
8031 /*
8032 * If WAL summarization is in use, don't remove WAL that has yet to be
8033 * summarized.
8034 */
8035 keep = GetOldestUnsummarizedLSN(NULL, NULL);
8036 if (keep != InvalidXLogRecPtr)
8037 {
8038 XLogSegNo unsummarized_segno;
8039
8040 XLByteToSeg(keep, unsummarized_segno, wal_segment_size);
8041 if (unsummarized_segno < segno)
8042 segno = unsummarized_segno;
8043 }
8044
8045 /* but, keep at least wal_keep_size if that's set */
8046 if (wal_keep_size_mb > 0)
8047 {
8048 uint64 keep_segs;
8049
8051 if (currSegNo - segno < keep_segs)
8052 {
8053 /* avoid underflow, don't go below 1 */
8054 if (currSegNo <= keep_segs)
8055 segno = 1;
8056 else
8057 segno = currSegNo - keep_segs;
8058 }
8059 }
8060
8061 /* don't delete WAL segments newer than the calculated segment */
8062 if (segno < *logSegNo)
8063 *logSegNo = segno;
8064}
8065
8066/*
8067 * Write a NEXTOID log record
8068 */
8069void
8071{
8073 XLogRegisterData(&nextOid, sizeof(Oid));
8074 (void) XLogInsert(RM_XLOG_ID, XLOG_NEXTOID);
8075
8076 /*
8077 * We need not flush the NEXTOID record immediately, because any of the
8078 * just-allocated OIDs could only reach disk as part of a tuple insert or
8079 * update that would have its own XLOG record that must follow the NEXTOID
8080 * record. Therefore, the standard buffer LSN interlock applied to those
8081 * records will ensure no such OID reaches disk before the NEXTOID record
8082 * does.
8083 *
8084 * Note, however, that the above statement only covers state "within" the
8085 * database. When we use a generated OID as a file or directory name, we
8086 * are in a sense violating the basic WAL rule, because that filesystem
8087 * change may reach disk before the NEXTOID WAL record does. The impact
8088 * of this is that if a database crash occurs immediately afterward, we
8089 * might after restart re-generate the same OID and find that it conflicts
8090 * with the leftover file or directory. But since for safety's sake we
8091 * always loop until finding a nonconflicting filename, this poses no real
8092 * problem in practice. See pgsql-hackers discussion 27-Sep-2006.
8093 */
8094}
8095
8096/*
8097 * Write an XLOG SWITCH record.
8098 *
8099 * Here we just blindly issue an XLogInsert request for the record.
8100 * All the magic happens inside XLogInsert.
8101 *
8102 * The return value is either the end+1 address of the switch record,
8103 * or the end+1 address of the prior segment if we did not need to
8104 * write a switch record because we are already at segment start.
8105 */
8107RequestXLogSwitch(bool mark_unimportant)
8108{
8109 XLogRecPtr RecPtr;
8110
8111 /* XLOG SWITCH has no data */
8113
8114 if (mark_unimportant)
8116 RecPtr = XLogInsert(RM_XLOG_ID, XLOG_SWITCH);
8117
8118 return RecPtr;
8119}
8120
8121/*
8122 * Write a RESTORE POINT record
8123 */
8125XLogRestorePoint(const char *rpName)
8126{
8127 XLogRecPtr RecPtr;
8128 xl_restore_point xlrec;
8129
8130 xlrec.rp_time = GetCurrentTimestamp();
8131 strlcpy(xlrec.rp_name, rpName, MAXFNAMELEN);
8132
8134 XLogRegisterData(&xlrec, sizeof(xl_restore_point));
8135
8136 RecPtr = XLogInsert(RM_XLOG_ID, XLOG_RESTORE_POINT);
8137
8138 ereport(LOG,
8139 errmsg("restore point \"%s\" created at %X/%08X",
8140 rpName, LSN_FORMAT_ARGS(RecPtr)));
8141
8142 return RecPtr;
8143}
8144
8145/*
8146 * Check if any of the GUC parameters that are critical for hot standby
8147 * have changed, and update the value in pg_control file if necessary.
8148 */
8149static void
8151{
8160 {
8161 /*
8162 * The change in number of backend slots doesn't need to be WAL-logged
8163 * if archiving is not enabled, as you can't start archive recovery
8164 * with wal_level=minimal anyway. We don't really care about the
8165 * values in pg_control either if wal_level=minimal, but seems better
8166 * to keep them up-to-date to avoid confusion.
8167 */
8169 {
8170 xl_parameter_change xlrec;
8171 XLogRecPtr recptr;
8172
8178 xlrec.wal_level = wal_level;
8181
8183 XLogRegisterData(&xlrec, sizeof(xlrec));
8184
8185 recptr = XLogInsert(RM_XLOG_ID, XLOG_PARAMETER_CHANGE);
8186 XLogFlush(recptr);
8187 }
8188
8189 LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
8190
8200
8201 LWLockRelease(ControlFileLock);
8202 }
8203}
8204
8205/*
8206 * Update full_page_writes in shared memory, and write an
8207 * XLOG_FPW_CHANGE record if necessary.
8208 *
8209 * Note: this function assumes there is no other process running
8210 * concurrently that could update it.
8211 */
8212void
8214{
8216 bool recoveryInProgress;
8217
8218 /*
8219 * Do nothing if full_page_writes has not been changed.
8220 *
8221 * It's safe to check the shared full_page_writes without the lock,
8222 * because we assume that there is no concurrently running process which
8223 * can update it.
8224 */
8225 if (fullPageWrites == Insert->fullPageWrites)
8226 return;
8227
8228 /*
8229 * Perform this outside critical section so that the WAL insert
8230 * initialization done by RecoveryInProgress() doesn't trigger an
8231 * assertion failure.
8232 */
8233 recoveryInProgress = RecoveryInProgress();
8234
8236
8237 /*
8238 * It's always safe to take full page images, even when not strictly
8239 * required, but not the other round. So if we're setting full_page_writes
8240 * to true, first set it true and then write the WAL record. If we're
8241 * setting it to false, first write the WAL record and then set the global
8242 * flag.
8243 */
8244 if (fullPageWrites)
8245 {
8247 Insert->fullPageWrites = true;
8249 }
8250
8251 /*
8252 * Write an XLOG_FPW_CHANGE record. This allows us to keep track of
8253 * full_page_writes during archive recovery, if required.
8254 */
8255 if (XLogStandbyInfoActive() && !recoveryInProgress)
8256 {
8258 XLogRegisterData(&fullPageWrites, sizeof(bool));
8259
8260 XLogInsert(RM_XLOG_ID, XLOG_FPW_CHANGE);
8261 }
8262
8263 if (!fullPageWrites)
8264 {
8266 Insert->fullPageWrites = false;
8268 }
8270}
8271
8272/*
8273 * XLOG resource manager's routines
8274 *
8275 * Definitions of info values are in include/catalog/pg_control.h, though
8276 * not all record types are related to control file updates.
8277 *
8278 * NOTE: Some XLOG record types that are directly related to WAL recovery
8279 * are handled in xlogrecovery_redo().
8280 */
8281void
8283{
8284 uint8 info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
8285 XLogRecPtr lsn = record->EndRecPtr;
8286
8287 /*
8288 * In XLOG rmgr, backup blocks are only used by XLOG_FPI and
8289 * XLOG_FPI_FOR_HINT records.
8290 */
8291 Assert(info == XLOG_FPI || info == XLOG_FPI_FOR_HINT ||
8292 !XLogRecHasAnyBlockRefs(record));
8293
8294 if (info == XLOG_NEXTOID)
8295 {
8296 Oid nextOid;
8297
8298 /*
8299 * We used to try to take the maximum of TransamVariables->nextOid and
8300 * the recorded nextOid, but that fails if the OID counter wraps
8301 * around. Since no OID allocation should be happening during replay
8302 * anyway, better to just believe the record exactly. We still take
8303 * OidGenLock while setting the variable, just in case.
8304 */
8305 memcpy(&nextOid, XLogRecGetData(record), sizeof(Oid));
8306 LWLockAcquire(OidGenLock, LW_EXCLUSIVE);
8307 TransamVariables->nextOid = nextOid;
8309 LWLockRelease(OidGenLock);
8310 }
8311 else if (info == XLOG_CHECKPOINT_SHUTDOWN)
8312 {
8313 CheckPoint checkPoint;
8314 TimeLineID replayTLI;
8315
8316 memcpy(&checkPoint, XLogRecGetData(record), sizeof(CheckPoint));
8317 /* In a SHUTDOWN checkpoint, believe the counters exactly */
8318 LWLockAcquire(XidGenLock, LW_EXCLUSIVE);
8319 TransamVariables->nextXid = checkPoint.nextXid;
8320 LWLockRelease(XidGenLock);
8321 LWLockAcquire(OidGenLock, LW_EXCLUSIVE);
8322 TransamVariables->nextOid = checkPoint.nextOid;
8324 LWLockRelease(OidGenLock);
8326 checkPoint.nextMultiOffset);
8327
8329 checkPoint.oldestMultiDB);
8330
8331 /*
8332 * No need to set oldestClogXid here as well; it'll be set when we
8333 * redo an xl_clog_truncate if it changed since initialization.
8334 */
8335 SetTransactionIdLimit(checkPoint.oldestXid, checkPoint.oldestXidDB);
8336
8337 /*
8338 * If we see a shutdown checkpoint while waiting for an end-of-backup
8339 * record, the backup was canceled and the end-of-backup record will
8340 * never arrive.
8341 */
8345 ereport(PANIC,
8346 (errmsg("online backup was canceled, recovery cannot continue")));
8347
8348 /*
8349 * If we see a shutdown checkpoint, we know that nothing was running
8350 * on the primary at this point. So fake-up an empty running-xacts
8351 * record and use that here and now. Recover additional standby state
8352 * for prepared transactions.
8353 */
8355 {
8356 TransactionId *xids;
8357 int nxids;
8358 TransactionId oldestActiveXID;
8359 TransactionId latestCompletedXid;
8361
8362 oldestActiveXID = PrescanPreparedTransactions(&xids, &nxids);
8363
8364 /* Update pg_subtrans entries for any prepared transactions */
8366
8367 /*
8368 * Construct a RunningTransactions snapshot representing a shut
8369 * down server, with only prepared transactions still alive. We're
8370 * never overflowed at this point because all subxids are listed
8371 * with their parent prepared transactions.
8372 */
8373 running.xcnt = nxids;
8374 running.subxcnt = 0;
8376 running.nextXid = XidFromFullTransactionId(checkPoint.nextXid);
8377 running.oldestRunningXid = oldestActiveXID;
8378 latestCompletedXid = XidFromFullTransactionId(checkPoint.nextXid);
8379 TransactionIdRetreat(latestCompletedXid);
8380 Assert(TransactionIdIsNormal(latestCompletedXid));
8381 running.latestCompletedXid = latestCompletedXid;
8382 running.xids = xids;
8383
8385 }
8386
8387 /* ControlFile->checkPointCopy always tracks the latest ckpt XID */
8388 LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
8390 LWLockRelease(ControlFileLock);
8391
8392 /*
8393 * We should've already switched to the new TLI before replaying this
8394 * record.
8395 */
8396 (void) GetCurrentReplayRecPtr(&replayTLI);
8397 if (checkPoint.ThisTimeLineID != replayTLI)
8398 ereport(PANIC,
8399 (errmsg("unexpected timeline ID %u (should be %u) in shutdown checkpoint record",
8400 checkPoint.ThisTimeLineID, replayTLI)));
8401
8402 RecoveryRestartPoint(&checkPoint, record);
8403
8404 /*
8405 * After replaying a checkpoint record, free all smgr objects.
8406 * Otherwise we would never do so for dropped relations, as the
8407 * startup does not process shared invalidation messages or call
8408 * AtEOXact_SMgr().
8409 */
8411 }
8412 else if (info == XLOG_CHECKPOINT_ONLINE)
8413 {
8414 CheckPoint checkPoint;
8415 TimeLineID replayTLI;
8416
8417 memcpy(&checkPoint, XLogRecGetData(record), sizeof(CheckPoint));
8418 /* In an ONLINE checkpoint, treat the XID counter as a minimum */
8419 LWLockAcquire(XidGenLock, LW_EXCLUSIVE);
8421 checkPoint.nextXid))
8422 TransamVariables->nextXid = checkPoint.nextXid;
8423 LWLockRelease(XidGenLock);
8424
8425 /*
8426 * We ignore the nextOid counter in an ONLINE checkpoint, preferring
8427 * to track OID assignment through XLOG_NEXTOID records. The nextOid
8428 * counter is from the start of the checkpoint and might well be stale
8429 * compared to later XLOG_NEXTOID records. We could try to take the
8430 * maximum of the nextOid counter and our latest value, but since
8431 * there's no particular guarantee about the speed with which the OID
8432 * counter wraps around, that's a risky thing to do. In any case,
8433 * users of the nextOid counter are required to avoid assignment of
8434 * duplicates, so that a somewhat out-of-date value should be safe.
8435 */
8436
8437 /* Handle multixact */
8439 checkPoint.nextMultiOffset);
8440
8441 /*
8442 * NB: This may perform multixact truncation when replaying WAL
8443 * generated by an older primary.
8444 */
8446 checkPoint.oldestMultiDB);
8448 checkPoint.oldestXid))
8450 checkPoint.oldestXidDB);
8451 /* ControlFile->checkPointCopy always tracks the latest ckpt XID */
8452 LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
8454 LWLockRelease(ControlFileLock);
8455
8456 /* TLI should not change in an on-line checkpoint */
8457 (void) GetCurrentReplayRecPtr(&replayTLI);
8458 if (checkPoint.ThisTimeLineID != replayTLI)
8459 ereport(PANIC,
8460 (errmsg("unexpected timeline ID %u (should be %u) in online checkpoint record",
8461 checkPoint.ThisTimeLineID, replayTLI)));
8462
8463 RecoveryRestartPoint(&checkPoint, record);
8464
8465 /*
8466 * After replaying a checkpoint record, free all smgr objects.
8467 * Otherwise we would never do so for dropped relations, as the
8468 * startup does not process shared invalidation messages or call
8469 * AtEOXact_SMgr().
8470 */
8472 }
8473 else if (info == XLOG_OVERWRITE_CONTRECORD)
8474 {
8475 /* nothing to do here, handled in xlogrecovery_redo() */
8476 }
8477 else if (info == XLOG_END_OF_RECOVERY)
8478 {
8479 xl_end_of_recovery xlrec;
8480 TimeLineID replayTLI;
8481
8482 memcpy(&xlrec, XLogRecGetData(record), sizeof(xl_end_of_recovery));
8483
8484 /*
8485 * For Hot Standby, we could treat this like a Shutdown Checkpoint,
8486 * but this case is rarer and harder to test, so the benefit doesn't
8487 * outweigh the potential extra cost of maintenance.
8488 */
8489
8490 /*
8491 * We should've already switched to the new TLI before replaying this
8492 * record.
8493 */
8494 (void) GetCurrentReplayRecPtr(&replayTLI);
8495 if (xlrec.ThisTimeLineID != replayTLI)
8496 ereport(PANIC,
8497 (errmsg("unexpected timeline ID %u (should be %u) in end-of-recovery record",
8498 xlrec.ThisTimeLineID, replayTLI)));
8499 }
8500 else if (info == XLOG_NOOP)
8501 {
8502 /* nothing to do here */
8503 }
8504 else if (info == XLOG_SWITCH)
8505 {
8506 /* nothing to do here */
8507 }
8508 else if (info == XLOG_RESTORE_POINT)
8509 {
8510 /* nothing to do here, handled in xlogrecovery.c */
8511 }
8512 else if (info == XLOG_FPI || info == XLOG_FPI_FOR_HINT)
8513 {
8514 /*
8515 * XLOG_FPI records contain nothing else but one or more block
8516 * references. Every block reference must include a full-page image
8517 * even if full_page_writes was disabled when the record was generated
8518 * - otherwise there would be no point in this record.
8519 *
8520 * XLOG_FPI_FOR_HINT records are generated when a page needs to be
8521 * WAL-logged because of a hint bit update. They are only generated
8522 * when checksums and/or wal_log_hints are enabled. They may include
8523 * no full-page images if full_page_writes was disabled when they were
8524 * generated. In this case there is nothing to do here.
8525 *
8526 * No recovery conflicts are generated by these generic records - if a
8527 * resource manager needs to generate conflicts, it has to define a
8528 * separate WAL record type and redo routine.
8529 */
8530 for (uint8 block_id = 0; block_id <= XLogRecMaxBlockId(record); block_id++)
8531 {
8532 Buffer buffer;
8533
8534 if (!XLogRecHasBlockImage(record, block_id))
8535 {
8536 if (info == XLOG_FPI)
8537 elog(ERROR, "XLOG_FPI record did not contain a full-page image");
8538 continue;
8539 }
8540
8541 if (XLogReadBufferForRedo(record, block_id, &buffer) != BLK_RESTORED)
8542 elog(ERROR, "unexpected XLogReadBufferForRedo result when restoring backup block");
8543 UnlockReleaseBuffer(buffer);
8544 }
8545 }
8546 else if (info == XLOG_BACKUP_END)
8547 {
8548 /* nothing to do here, handled in xlogrecovery_redo() */
8549 }
8550 else if (info == XLOG_PARAMETER_CHANGE)
8551 {
8552 xl_parameter_change xlrec;
8553
8554 /* Update our copy of the parameters in pg_control */
8555 memcpy(&xlrec, XLogRecGetData(record), sizeof(xl_parameter_change));
8556
8557 /*
8558 * Invalidate logical slots if we are in hot standby and the primary
8559 * does not have a WAL level sufficient for logical decoding. No need
8560 * to search for potentially conflicting logically slots if standby is
8561 * running with wal_level lower than logical, because in that case, we
8562 * would have either disallowed creation of logical slots or
8563 * invalidated existing ones.
8564 */
8565 if (InRecovery && InHotStandby &&
8566 xlrec.wal_level < WAL_LEVEL_LOGICAL &&
8569 0, InvalidOid,
8571
8572 LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
8580
8581 /*
8582 * Update minRecoveryPoint to ensure that if recovery is aborted, we
8583 * recover back up to this point before allowing hot standby again.
8584 * This is important if the max_* settings are decreased, to ensure
8585 * you don't run queries against the WAL preceding the change. The
8586 * local copies cannot be updated as long as crash recovery is
8587 * happening and we expect all the WAL to be replayed.
8588 */
8590 {
8593 }
8595 {
8596 TimeLineID replayTLI;
8597
8598 (void) GetCurrentReplayRecPtr(&replayTLI);
8600 ControlFile->minRecoveryPointTLI = replayTLI;
8601 }
8602
8606
8608 LWLockRelease(ControlFileLock);
8609
8610 /* Check to see if any parameter change gives a problem on recovery */
8612 }
8613 else if (info == XLOG_FPW_CHANGE)
8614 {
8615 bool fpw;
8616
8617 memcpy(&fpw, XLogRecGetData(record), sizeof(bool));
8618
8619 /*
8620 * Update the LSN of the last replayed XLOG_FPW_CHANGE record so that
8621 * do_pg_backup_start() and do_pg_backup_stop() can check whether
8622 * full_page_writes has been disabled during online backup.
8623 */
8624 if (!fpw)
8625 {
8630 }
8631
8632 /* Keep track of full_page_writes */
8633 lastFullPageWrites = fpw;
8634 }
8635 else if (info == XLOG_CHECKPOINT_REDO)
8636 {
8637 /* nothing to do here, just for informational purposes */
8638 }
8639}
8640
8641/*
8642 * Return the extra open flags used for opening a file, depending on the
8643 * value of the GUCs wal_sync_method, fsync and debug_io_direct.
8644 */
8645static int
8646get_sync_bit(int method)
8647{
8648 int o_direct_flag = 0;
8649
8650 /*
8651 * Use O_DIRECT if requested, except in walreceiver process. The WAL
8652 * written by walreceiver is normally read by the startup process soon
8653 * after it's written. Also, walreceiver performs unaligned writes, which
8654 * don't work with O_DIRECT, so it is required for correctness too.
8655 */
8657 o_direct_flag = PG_O_DIRECT;
8658
8659 /* If fsync is disabled, never open in sync mode */
8660 if (!enableFsync)
8661 return o_direct_flag;
8662
8663 switch (method)
8664 {
8665 /*
8666 * enum values for all sync options are defined even if they are
8667 * not supported on the current platform. But if not, they are
8668 * not included in the enum option array, and therefore will never
8669 * be seen here.
8670 */
8674 return o_direct_flag;
8675#ifdef O_SYNC
8677 return O_SYNC | o_direct_flag;
8678#endif
8679#ifdef O_DSYNC
8681 return O_DSYNC | o_direct_flag;
8682#endif
8683 default:
8684 /* can't happen (unless we are out of sync with option array) */
8685 elog(ERROR, "unrecognized \"wal_sync_method\": %d", method);
8686 return 0; /* silence warning */
8687 }
8688}
8689
8690/*
8691 * GUC support
8692 */
8693void
8694assign_wal_sync_method(int new_wal_sync_method, void *extra)
8695{
8696 if (wal_sync_method != new_wal_sync_method)
8697 {
8698 /*
8699 * To ensure that no blocks escape unsynced, force an fsync on the
8700 * currently open log segment (if any). Also, if the open flag is
8701 * changing, close the log file so it will be reopened (with new flag
8702 * bit) at next use.
8703 */
8704 if (openLogFile >= 0)
8705 {
8706 pgstat_report_wait_start(WAIT_EVENT_WAL_SYNC_METHOD_ASSIGN);
8707 if (pg_fsync(openLogFile) != 0)
8708 {
8709 char xlogfname[MAXFNAMELEN];
8710 int save_errno;
8711
8712 save_errno = errno;
8715 errno = save_errno;
8716 ereport(PANIC,
8718 errmsg("could not fsync file \"%s\": %m", xlogfname)));
8719 }
8720
8722 if (get_sync_bit(wal_sync_method) != get_sync_bit(new_wal_sync_method))
8723 XLogFileClose();
8724 }
8725 }
8726}
8727
8728
8729/*
8730 * Issue appropriate kind of fsync (if any) for an XLOG output file.
8731 *
8732 * 'fd' is a file descriptor for the XLOG file to be fsync'd.
8733 * 'segno' is for error reporting purposes.
8734 */
8735void
8737{
8738 char *msg = NULL;
8740
8741 Assert(tli != 0);
8742
8743 /*
8744 * Quick exit if fsync is disabled or write() has already synced the WAL
8745 * file.
8746 */
8747 if (!enableFsync ||
8750 return;
8751
8752 /*
8753 * Measure I/O timing to sync the WAL file for pg_stat_io.
8754 */
8756
8757 pgstat_report_wait_start(WAIT_EVENT_WAL_SYNC);
8758 switch (wal_sync_method)
8759 {
8761 if (pg_fsync_no_writethrough(fd) != 0)
8762 msg = _("could not fsync file \"%s\": %m");
8763 break;
8764#ifdef HAVE_FSYNC_WRITETHROUGH
8766 if (pg_fsync_writethrough(fd) != 0)
8767 msg = _("could not fsync write-through file \"%s\": %m");
8768 break;
8769#endif
8771 if (pg_fdatasync(fd) != 0)
8772 msg = _("could not fdatasync file \"%s\": %m");
8773 break;
8776 /* not reachable */
8777 Assert(false);
8778 break;
8779 default:
8780 ereport(PANIC,
8781 errcode(ERRCODE_INVALID_PARAMETER_VALUE),
8782 errmsg_internal("unrecognized \"wal_sync_method\": %d", wal_sync_method));
8783 break;
8784 }
8785
8786 /* PANIC if failed to fsync */
8787 if (msg)
8788 {
8789 char xlogfname[MAXFNAMELEN];
8790 int save_errno = errno;
8791
8792 XLogFileName(xlogfname, tli, segno, wal_segment_size);
8793 errno = save_errno;
8794 ereport(PANIC,
8796 errmsg(msg, xlogfname)));
8797 }
8798
8800
8802 start, 1, 0);
8803}
8804
8805/*
8806 * do_pg_backup_start is the workhorse of the user-visible pg_backup_start()
8807 * function. It creates the necessary starting checkpoint and constructs the
8808 * backup state and tablespace map.
8809 *
8810 * Input parameters are "state" (the backup state), "fast" (if true, we do
8811 * the checkpoint in fast mode), and "tablespaces" (if non-NULL, indicates a
8812 * list of tablespaceinfo structs describing the cluster's tablespaces.).
8813 *
8814 * The tablespace map contents are appended to passed-in parameter
8815 * tablespace_map and the caller is responsible for including it in the backup
8816 * archive as 'tablespace_map'. The tablespace_map file is required mainly for
8817 * tar format in windows as native windows utilities are not able to create
8818 * symlinks while extracting files from tar. However for consistency and
8819 * platform-independence, we do it the same way everywhere.
8820 *
8821 * It fills in "state" with the information required for the backup, such
8822 * as the minimum WAL location that must be present to restore from this
8823 * backup (starttli) and the corresponding timeline ID (starttli).
8824 *
8825 * Every successfully started backup must be stopped by calling
8826 * do_pg_backup_stop() or do_pg_abort_backup(). There can be many
8827 * backups active at the same time.
8828 *
8829 * It is the responsibility of the caller of this function to verify the
8830 * permissions of the calling user!
8831 */
8832void
8833do_pg_backup_start(const char *backupidstr, bool fast, List **tablespaces,
8834 BackupState *state, StringInfo tblspcmapfile)
8835{
8837
8838 Assert(state != NULL);
8840
8841 /*
8842 * During recovery, we don't need to check WAL level. Because, if WAL
8843 * level is not sufficient, it's impossible to get here during recovery.
8844 */
8846 ereport(ERROR,
8847 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
8848 errmsg("WAL level not sufficient for making an online backup"),
8849 errhint("\"wal_level\" must be set to \"replica\" or \"logical\" at server start.")));
8850
8851 if (strlen(backupidstr) > MAXPGPATH)
8852 ereport(ERROR,
8853 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
8854 errmsg("backup label too long (max %d bytes)",
8855 MAXPGPATH)));
8856
8857 strlcpy(state->name, backupidstr, sizeof(state->name));
8858
8859 /*
8860 * Mark backup active in shared memory. We must do full-page WAL writes
8861 * during an on-line backup even if not doing so at other times, because
8862 * it's quite possible for the backup dump to obtain a "torn" (partially
8863 * written) copy of a database page if it reads the page concurrently with
8864 * our write to the same page. This can be fixed as long as the first
8865 * write to the page in the WAL sequence is a full-page write. Hence, we
8866 * increment runningBackups then force a CHECKPOINT, to ensure there are
8867 * no dirty pages in shared memory that might get dumped while the backup
8868 * is in progress without having a corresponding WAL record. (Once the
8869 * backup is complete, we need not force full-page writes anymore, since
8870 * we expect that any pages not modified during the backup interval must
8871 * have been correctly captured by the backup.)
8872 *
8873 * Note that forcing full-page writes has no effect during an online
8874 * backup from the standby.
8875 *
8876 * We must hold all the insertion locks to change the value of
8877 * runningBackups, to ensure adequate interlocking against
8878 * XLogInsertRecord().
8879 */
8883
8884 /*
8885 * Ensure we decrement runningBackups if we fail below. NB -- for this to
8886 * work correctly, it is critical that sessionBackupState is only updated
8887 * after this block is over.
8888 */
8890 {
8891 bool gotUniqueStartpoint = false;
8892 DIR *tblspcdir;
8893 struct dirent *de;
8894 tablespaceinfo *ti;
8895 int datadirpathlen;
8896
8897 /*
8898 * Force an XLOG file switch before the checkpoint, to ensure that the
8899 * WAL segment the checkpoint is written to doesn't contain pages with
8900 * old timeline IDs. That would otherwise happen if you called
8901 * pg_backup_start() right after restoring from a PITR archive: the
8902 * first WAL segment containing the startup checkpoint has pages in
8903 * the beginning with the old timeline ID. That can cause trouble at
8904 * recovery: we won't have a history file covering the old timeline if
8905 * pg_wal directory was not included in the base backup and the WAL
8906 * archive was cleared too before starting the backup.
8907 *
8908 * This also ensures that we have emitted a WAL page header that has
8909 * XLP_BKP_REMOVABLE off before we emit the checkpoint record.
8910 * Therefore, if a WAL archiver (such as pglesslog) is trying to
8911 * compress out removable backup blocks, it won't remove any that
8912 * occur after this point.
8913 *
8914 * During recovery, we skip forcing XLOG file switch, which means that
8915 * the backup taken during recovery is not available for the special
8916 * recovery case described above.
8917 */
8919 RequestXLogSwitch(false);
8920
8921 do
8922 {
8923 bool checkpointfpw;
8924
8925 /*
8926 * Force a CHECKPOINT. Aside from being necessary to prevent torn
8927 * page problems, this guarantees that two successive backup runs
8928 * will have different checkpoint positions and hence different
8929 * history file names, even if nothing happened in between.
8930 *
8931 * During recovery, establish a restartpoint if possible. We use
8932 * the last restartpoint as the backup starting checkpoint. This
8933 * means that two successive backup runs can have same checkpoint
8934 * positions.
8935 *
8936 * Since the fact that we are executing do_pg_backup_start()
8937 * during recovery means that checkpointer is running, we can use
8938 * RequestCheckpoint() to establish a restartpoint.
8939 *
8940 * We use CHECKPOINT_FAST only if requested by user (via passing
8941 * fast = true). Otherwise this can take awhile.
8942 */
8944 (fast ? CHECKPOINT_FAST : 0));
8945
8946 /*
8947 * Now we need to fetch the checkpoint record location, and also
8948 * its REDO pointer. The oldest point in WAL that would be needed
8949 * to restore starting from the checkpoint is precisely the REDO
8950 * pointer.
8951 */
8952 LWLockAcquire(ControlFileLock, LW_SHARED);
8953 state->checkpointloc = ControlFile->checkPoint;
8954 state->startpoint = ControlFile->checkPointCopy.redo;
8956 checkpointfpw = ControlFile->checkPointCopy.fullPageWrites;
8957 LWLockRelease(ControlFileLock);
8958
8960 {
8961 XLogRecPtr recptr;
8962
8963 /*
8964 * Check to see if all WAL replayed during online backup
8965 * (i.e., since last restartpoint used as backup starting
8966 * checkpoint) contain full-page writes.
8967 */
8969 recptr = XLogCtl->lastFpwDisableRecPtr;
8971
8972 if (!checkpointfpw || state->startpoint <= recptr)
8973 ereport(ERROR,
8974 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
8975 errmsg("WAL generated with \"full_page_writes=off\" was replayed "
8976 "since last restartpoint"),
8977 errhint("This means that the backup being taken on the standby "
8978 "is corrupt and should not be used. "
8979 "Enable \"full_page_writes\" and run CHECKPOINT on the primary, "
8980 "and then try an online backup again.")));
8981
8982 /*
8983 * During recovery, since we don't use the end-of-backup WAL
8984 * record and don't write the backup history file, the
8985 * starting WAL location doesn't need to be unique. This means
8986 * that two base backups started at the same time might use
8987 * the same checkpoint as starting locations.
8988 */
8989 gotUniqueStartpoint = true;
8990 }
8991
8992 /*
8993 * If two base backups are started at the same time (in WAL sender
8994 * processes), we need to make sure that they use different
8995 * checkpoints as starting locations, because we use the starting
8996 * WAL location as a unique identifier for the base backup in the
8997 * end-of-backup WAL record and when we write the backup history
8998 * file. Perhaps it would be better generate a separate unique ID
8999 * for each backup instead of forcing another checkpoint, but
9000 * taking a checkpoint right after another is not that expensive
9001 * either because only few buffers have been dirtied yet.
9002 */
9004 if (XLogCtl->Insert.lastBackupStart < state->startpoint)
9005 {
9006 XLogCtl->Insert.lastBackupStart = state->startpoint;
9007 gotUniqueStartpoint = true;
9008 }
9010 } while (!gotUniqueStartpoint);
9011
9012 /*
9013 * Construct tablespace_map file.
9014 */
9015 datadirpathlen = strlen(DataDir);
9016
9017 /* Collect information about all tablespaces */
9018 tblspcdir = AllocateDir(PG_TBLSPC_DIR);
9019 while ((de = ReadDir(tblspcdir, PG_TBLSPC_DIR)) != NULL)
9020 {
9021 char fullpath[MAXPGPATH + sizeof(PG_TBLSPC_DIR)];
9022 char linkpath[MAXPGPATH];
9023 char *relpath = NULL;
9024 char *s;
9025 PGFileType de_type;
9026 char *badp;
9027 Oid tsoid;
9028
9029 /*
9030 * Try to parse the directory name as an unsigned integer.
9031 *
9032 * Tablespace directories should be positive integers that can be
9033 * represented in 32 bits, with no leading zeroes or trailing
9034 * garbage. If we come across a name that doesn't meet those
9035 * criteria, skip it.
9036 */
9037 if (de->d_name[0] < '1' || de->d_name[1] > '9')
9038 continue;
9039 errno = 0;
9040 tsoid = strtoul(de->d_name, &badp, 10);
9041 if (*badp != '\0' || errno == EINVAL || errno == ERANGE)
9042 continue;
9043
9044 snprintf(fullpath, sizeof(fullpath), "%s/%s", PG_TBLSPC_DIR, de->d_name);
9045
9046 de_type = get_dirent_type(fullpath, de, false, ERROR);
9047
9048 if (de_type == PGFILETYPE_LNK)
9049 {
9050 StringInfoData escapedpath;
9051 int rllen;
9052
9053 rllen = readlink(fullpath, linkpath, sizeof(linkpath));
9054 if (rllen < 0)
9055 {
9057 (errmsg("could not read symbolic link \"%s\": %m",
9058 fullpath)));
9059 continue;
9060 }
9061 else if (rllen >= sizeof(linkpath))
9062 {
9064 (errmsg("symbolic link \"%s\" target is too long",
9065 fullpath)));
9066 continue;
9067 }
9068 linkpath[rllen] = '\0';
9069
9070 /*
9071 * Relpath holds the relative path of the tablespace directory
9072 * when it's located within PGDATA, or NULL if it's located
9073 * elsewhere.
9074 */
9075 if (rllen > datadirpathlen &&
9076 strncmp(linkpath, DataDir, datadirpathlen) == 0 &&
9077 IS_DIR_SEP(linkpath[datadirpathlen]))
9078 relpath = pstrdup(linkpath + datadirpathlen + 1);
9079
9080 /*
9081 * Add a backslash-escaped version of the link path to the
9082 * tablespace map file.
9083 */
9084 initStringInfo(&escapedpath);
9085 for (s = linkpath; *s; s++)
9086 {
9087 if (*s == '\n' || *s == '\r' || *s == '\\')
9088 appendStringInfoChar(&escapedpath, '\\');
9089 appendStringInfoChar(&escapedpath, *s);
9090 }
9091 appendStringInfo(tblspcmapfile, "%s %s\n",
9092 de->d_name, escapedpath.data);
9093 pfree(escapedpath.data);
9094 }
9095 else if (de_type == PGFILETYPE_DIR)
9096 {
9097 /*
9098 * It's possible to use allow_in_place_tablespaces to create
9099 * directories directly under pg_tblspc, for testing purposes
9100 * only.
9101 *
9102 * In this case, we store a relative path rather than an
9103 * absolute path into the tablespaceinfo.
9104 */
9105 snprintf(linkpath, sizeof(linkpath), "%s/%s",
9106 PG_TBLSPC_DIR, de->d_name);
9107 relpath = pstrdup(linkpath);
9108 }
9109 else
9110 {
9111 /* Skip any other file type that appears here. */
9112 continue;
9113 }
9114
9115 ti = palloc(sizeof(tablespaceinfo));
9116 ti->oid = tsoid;
9117 ti->path = pstrdup(linkpath);
9118 ti->rpath = relpath;
9119 ti->size = -1;
9120
9121 if (tablespaces)
9122 *tablespaces = lappend(*tablespaces, ti);
9123 }
9124 FreeDir(tblspcdir);
9125
9126 state->starttime = (pg_time_t) time(NULL);
9127 }
9129
9130 state->started_in_recovery = backup_started_in_recovery;
9131
9132 /*
9133 * Mark that the start phase has correctly finished for the backup.
9134 */
9136}
9137
9138/*
9139 * Utility routine to fetch the session-level status of a backup running.
9140 */
9143{
9144 return sessionBackupState;
9145}
9146
9147/*
9148 * do_pg_backup_stop
9149 *
9150 * Utility function called at the end of an online backup. It creates history
9151 * file (if required), resets sessionBackupState and so on. It can optionally
9152 * wait for WAL segments to be archived.
9153 *
9154 * "state" is filled with the information necessary to restore from this
9155 * backup with its stop LSN (stoppoint), its timeline ID (stoptli), etc.
9156 *
9157 * It is the responsibility of the caller of this function to verify the
9158 * permissions of the calling user!
9159 */
9160void
9162{
9163 bool backup_stopped_in_recovery = false;
9164 char histfilepath[MAXPGPATH];
9165 char lastxlogfilename[MAXFNAMELEN];
9166 char histfilename[MAXFNAMELEN];
9167 XLogSegNo _logSegNo;
9168 FILE *fp;
9169 int seconds_before_warning;
9170 int waits = 0;
9171 bool reported_waiting = false;
9172
9173 Assert(state != NULL);
9174
9175 backup_stopped_in_recovery = RecoveryInProgress();
9176
9177 /*
9178 * During recovery, we don't need to check WAL level. Because, if WAL
9179 * level is not sufficient, it's impossible to get here during recovery.
9180 */
9181 if (!backup_stopped_in_recovery && !XLogIsNeeded())
9182 ereport(ERROR,
9183 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
9184 errmsg("WAL level not sufficient for making an online backup"),
9185 errhint("\"wal_level\" must be set to \"replica\" or \"logical\" at server start.")));
9186
9187 /*
9188 * OK to update backup counter and session-level lock.
9189 *
9190 * Note that CHECK_FOR_INTERRUPTS() must not occur while updating them,
9191 * otherwise they can be updated inconsistently, which might cause
9192 * do_pg_abort_backup() to fail.
9193 */
9195
9196 /*
9197 * It is expected that each do_pg_backup_start() call is matched by
9198 * exactly one do_pg_backup_stop() call.
9199 */
9202
9203 /*
9204 * Clean up session-level lock.
9205 *
9206 * You might think that WALInsertLockRelease() can be called before
9207 * cleaning up session-level lock because session-level lock doesn't need
9208 * to be protected with WAL insertion lock. But since
9209 * CHECK_FOR_INTERRUPTS() can occur in it, session-level lock must be
9210 * cleaned up before it.
9211 */
9213
9215
9216 /*
9217 * If we are taking an online backup from the standby, we confirm that the
9218 * standby has not been promoted during the backup.
9219 */
9220 if (state->started_in_recovery && !backup_stopped_in_recovery)
9221 ereport(ERROR,
9222 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
9223 errmsg("the standby was promoted during online backup"),
9224 errhint("This means that the backup being taken is corrupt "
9225 "and should not be used. "
9226 "Try taking another online backup.")));
9227
9228 /*
9229 * During recovery, we don't write an end-of-backup record. We assume that
9230 * pg_control was backed up last and its minimum recovery point can be
9231 * available as the backup end location. Since we don't have an
9232 * end-of-backup record, we use the pg_control value to check whether
9233 * we've reached the end of backup when starting recovery from this
9234 * backup. We have no way of checking if pg_control wasn't backed up last
9235 * however.
9236 *
9237 * We don't force a switch to new WAL file but it is still possible to
9238 * wait for all the required files to be archived if waitforarchive is
9239 * true. This is okay if we use the backup to start a standby and fetch
9240 * the missing WAL using streaming replication. But in the case of an
9241 * archive recovery, a user should set waitforarchive to true and wait for
9242 * them to be archived to ensure that all the required files are
9243 * available.
9244 *
9245 * We return the current minimum recovery point as the backup end
9246 * location. Note that it can be greater than the exact backup end
9247 * location if the minimum recovery point is updated after the backup of
9248 * pg_control. This is harmless for current uses.
9249 *
9250 * XXX currently a backup history file is for informational and debug
9251 * purposes only. It's not essential for an online backup. Furthermore,
9252 * even if it's created, it will not be archived during recovery because
9253 * an archiver is not invoked. So it doesn't seem worthwhile to write a
9254 * backup history file during recovery.
9255 */
9256 if (backup_stopped_in_recovery)
9257 {
9258 XLogRecPtr recptr;
9259
9260 /*
9261 * Check to see if all WAL replayed during online backup contain
9262 * full-page writes.
9263 */
9265 recptr = XLogCtl->lastFpwDisableRecPtr;
9267
9268 if (state->startpoint <= recptr)
9269 ereport(ERROR,
9270 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
9271 errmsg("WAL generated with \"full_page_writes=off\" was replayed "
9272 "during online backup"),
9273 errhint("This means that the backup being taken on the standby "
9274 "is corrupt and should not be used. "
9275 "Enable \"full_page_writes\" and run CHECKPOINT on the primary, "
9276 "and then try an online backup again.")));
9277
9278
9279 LWLockAcquire(ControlFileLock, LW_SHARED);
9280 state->stoppoint = ControlFile->minRecoveryPoint;
9282 LWLockRelease(ControlFileLock);
9283 }
9284 else
9285 {
9286 char *history_file;
9287
9288 /*
9289 * Write the backup-end xlog record
9290 */
9292 XLogRegisterData(&state->startpoint,
9293 sizeof(state->startpoint));
9294 state->stoppoint = XLogInsert(RM_XLOG_ID, XLOG_BACKUP_END);
9295
9296 /*
9297 * Given that we're not in recovery, InsertTimeLineID is set and can't
9298 * change, so we can read it without a lock.
9299 */
9300 state->stoptli = XLogCtl->InsertTimeLineID;
9301
9302 /*
9303 * Force a switch to a new xlog segment file, so that the backup is
9304 * valid as soon as archiver moves out the current segment file.
9305 */
9306 RequestXLogSwitch(false);
9307
9308 state->stoptime = (pg_time_t) time(NULL);
9309
9310 /*
9311 * Write the backup history file
9312 */
9313 XLByteToSeg(state->startpoint, _logSegNo, wal_segment_size);
9314 BackupHistoryFilePath(histfilepath, state->stoptli, _logSegNo,
9315 state->startpoint, wal_segment_size);
9316 fp = AllocateFile(histfilepath, "w");
9317 if (!fp)
9318 ereport(ERROR,
9320 errmsg("could not create file \"%s\": %m",
9321 histfilepath)));
9322
9323 /* Build and save the contents of the backup history file */
9324 history_file = build_backup_content(state, true);
9325 fprintf(fp, "%s", history_file);
9326 pfree(history_file);
9327
9328 if (fflush(fp) || ferror(fp) || FreeFile(fp))
9329 ereport(ERROR,
9331 errmsg("could not write file \"%s\": %m",
9332 histfilepath)));
9333
9334 /*
9335 * Clean out any no-longer-needed history files. As a side effect,
9336 * this will post a .ready file for the newly created history file,
9337 * notifying the archiver that history file may be archived
9338 * immediately.
9339 */
9341 }
9342
9343 /*
9344 * If archiving is enabled, wait for all the required WAL files to be
9345 * archived before returning. If archiving isn't enabled, the required WAL
9346 * needs to be transported via streaming replication (hopefully with
9347 * wal_keep_size set high enough), or some more exotic mechanism like
9348 * polling and copying files from pg_wal with script. We have no knowledge
9349 * of those mechanisms, so it's up to the user to ensure that he gets all
9350 * the required WAL.
9351 *
9352 * We wait until both the last WAL file filled during backup and the
9353 * history file have been archived, and assume that the alphabetic sorting
9354 * property of the WAL files ensures any earlier WAL files are safely
9355 * archived as well.
9356 *
9357 * We wait forever, since archive_command is supposed to work and we
9358 * assume the admin wanted his backup to work completely. If you don't
9359 * wish to wait, then either waitforarchive should be passed in as false,
9360 * or you can set statement_timeout. Also, some notices are issued to
9361 * clue in anyone who might be doing this interactively.
9362 */
9363
9364 if (waitforarchive &&
9365 ((!backup_stopped_in_recovery && XLogArchivingActive()) ||
9366 (backup_stopped_in_recovery && XLogArchivingAlways())))
9367 {
9368 XLByteToPrevSeg(state->stoppoint, _logSegNo, wal_segment_size);
9369 XLogFileName(lastxlogfilename, state->stoptli, _logSegNo,
9371
9372 XLByteToSeg(state->startpoint, _logSegNo, wal_segment_size);
9373 BackupHistoryFileName(histfilename, state->stoptli, _logSegNo,
9374 state->startpoint, wal_segment_size);
9375
9376 seconds_before_warning = 60;
9377 waits = 0;
9378
9379 while (XLogArchiveIsBusy(lastxlogfilename) ||
9380 XLogArchiveIsBusy(histfilename))
9381 {
9383
9384 if (!reported_waiting && waits > 5)
9385 {
9387 (errmsg("base backup done, waiting for required WAL segments to be archived")));
9388 reported_waiting = true;
9389 }
9390
9391 (void) WaitLatch(MyLatch,
9393 1000L,
9394 WAIT_EVENT_BACKUP_WAIT_WAL_ARCHIVE);
9396
9397 if (++waits >= seconds_before_warning)
9398 {
9399 seconds_before_warning *= 2; /* This wraps in >10 years... */
9401 (errmsg("still waiting for all required WAL segments to be archived (%d seconds elapsed)",
9402 waits),
9403 errhint("Check that your \"archive_command\" is executing properly. "
9404 "You can safely cancel this backup, "
9405 "but the database backup will not be usable without all the WAL segments.")));
9406 }
9407 }
9408
9410 (errmsg("all required WAL segments have been archived")));
9411 }
9412 else if (waitforarchive)
9414 (errmsg("WAL archiving is not enabled; you must ensure that all required WAL segments are copied through other means to complete the backup")));
9415}
9416
9417
9418/*
9419 * do_pg_abort_backup: abort a running backup
9420 *
9421 * This does just the most basic steps of do_pg_backup_stop(), by taking the
9422 * system out of backup mode, thus making it a lot more safe to call from
9423 * an error handler.
9424 *
9425 * 'arg' indicates that it's being called during backup setup; so
9426 * sessionBackupState has not been modified yet, but runningBackups has
9427 * already been incremented. When it's false, then it's invoked as a
9428 * before_shmem_exit handler, and therefore we must not change state
9429 * unless sessionBackupState indicates that a backup is actually running.
9430 *
9431 * NB: This gets used as a PG_ENSURE_ERROR_CLEANUP callback and
9432 * before_shmem_exit handler, hence the odd-looking signature.
9433 */
9434void
9436{
9437 bool during_backup_start = DatumGetBool(arg);
9438
9439 /* If called during backup start, there shouldn't be one already running */
9440 Assert(!during_backup_start || sessionBackupState == SESSION_BACKUP_NONE);
9441
9442 if (during_backup_start || sessionBackupState != SESSION_BACKUP_NONE)
9443 {
9447
9450
9451 if (!during_backup_start)
9453 errmsg("aborting backup due to backend exiting before pg_backup_stop was called"));
9454 }
9455}
9456
9457/*
9458 * Register a handler that will warn about unterminated backups at end of
9459 * session, unless this has already been done.
9460 */
9461void
9463{
9464 static bool already_done = false;
9465
9466 if (already_done)
9467 return;
9469 already_done = true;
9470}
9471
9472/*
9473 * Get latest WAL insert pointer
9474 */
9477{
9479 uint64 current_bytepos;
9480
9481 SpinLockAcquire(&Insert->insertpos_lck);
9482 current_bytepos = Insert->CurrBytePos;
9483 SpinLockRelease(&Insert->insertpos_lck);
9484
9485 return XLogBytePosToRecPtr(current_bytepos);
9486}
9487
9488/*
9489 * Get latest WAL write pointer
9490 */
9493{
9495
9496 return LogwrtResult.Write;
9497}
9498
9499/*
9500 * Returns the redo pointer of the last checkpoint or restartpoint. This is
9501 * the oldest point in WAL that we still need, if we have to restart recovery.
9502 */
9503void
9505{
9506 LWLockAcquire(ControlFileLock, LW_SHARED);
9507 *oldrecptr = ControlFile->checkPointCopy.redo;
9509 LWLockRelease(ControlFileLock);
9510}
9511
9512/* Thin wrapper around ShutdownWalRcv(). */
9513void
9515{
9517
9518 LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
9520 LWLockRelease(ControlFileLock);
9521}
9522
9523/* Enable WAL file recycling and preallocation. */
9524void
9526{
9527 LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
9529 LWLockRelease(ControlFileLock);
9530}
9531
9532bool
9534{
9535 bool result;
9536
9537 LWLockAcquire(ControlFileLock, LW_SHARED);
9539 LWLockRelease(ControlFileLock);
9540
9541 return result;
9542}
9543
9544/*
9545 * Update the WalWriterSleeping flag.
9546 */
9547void
9549{
9551 XLogCtl->WalWriterSleeping = sleeping;
9553}
Datum idx(PG_FUNCTION_ARGS)
Definition: _int_op.c:262
static void pg_atomic_write_u64(volatile pg_atomic_uint64 *ptr, uint64 val)
Definition: atomics.h:483
#define pg_memory_barrier()
Definition: atomics.h:141
#define pg_read_barrier()
Definition: atomics.h:154
static uint64 pg_atomic_read_membarrier_u64(volatile pg_atomic_uint64 *ptr)
Definition: atomics.h:474
#define pg_write_barrier()
Definition: atomics.h:155
static uint64 pg_atomic_monotonic_advance_u64(volatile pg_atomic_uint64 *ptr, uint64 target)
Definition: atomics.h:583
static uint64 pg_atomic_fetch_add_u64(volatile pg_atomic_uint64 *ptr, int64 add_)
Definition: atomics.h:520
static void pg_atomic_init_u64(volatile pg_atomic_uint64 *ptr, uint64 val)
Definition: atomics.h:451
static void pg_atomic_write_membarrier_u64(volatile pg_atomic_uint64 *ptr, uint64 val)
Definition: atomics.h:492
static uint64 pg_atomic_read_u64(volatile pg_atomic_uint64 *ptr)
Definition: atomics.h:465
TimeLineID findNewestTimeLine(TimeLineID startTLI)
Definition: timeline.c:264
void restoreTimeLineHistoryFiles(TimeLineID begin, TimeLineID end)
Definition: timeline.c:50
void writeTimeLineHistory(TimeLineID newTLI, TimeLineID parentTLI, XLogRecPtr switchpoint, char *reason)
Definition: timeline.c:304
void startup_progress_timeout_handler(void)
Definition: startup.c:303
long TimestampDifferenceMilliseconds(TimestampTz start_time, TimestampTz stop_time)
Definition: timestamp.c:1757
bool TimestampDifferenceExceeds(TimestampTz start_time, TimestampTz stop_time, int msec)
Definition: timestamp.c:1781
TimestampTz GetCurrentTimestamp(void)
Definition: timestamp.c:1645
const char * timestamptz_to_str(TimestampTz t)
Definition: timestamp.c:1862
Datum now(PG_FUNCTION_ARGS)
Definition: timestamp.c:1609
static bool backup_started_in_recovery
Definition: basebackup.c:123
int Buffer
Definition: buf.h:23
void CheckPointBuffers(int flags)
Definition: bufmgr.c:4184
void UnlockReleaseBuffer(Buffer buffer)
Definition: bufmgr.c:5355
#define Min(x, y)
Definition: c.h:1004
#define pg_attribute_unused()
Definition: c.h:132
#define likely(x)
Definition: c.h:402
#define MAXALIGN(LEN)
Definition: c.h:811
#define TYPEALIGN(ALIGNVAL, LEN)
Definition: c.h:804
uint8_t uint8
Definition: c.h:537
#define Max(x, y)
Definition: c.h:998
#define PG_BINARY
Definition: c.h:1273
#define pg_attribute_always_inline
Definition: c.h:269
uint64_t uint64
Definition: c.h:540
#define unlikely(x)
Definition: c.h:403
uint32_t uint32
Definition: c.h:539
#define MAXALIGN64(LEN)
Definition: c.h:836
#define PG_UINT64_MAX
Definition: c.h:599
#define MemSet(start, val, len)
Definition: c.h:1020
uint32 TransactionId
Definition: c.h:658
size_t Size
Definition: c.h:611
#define CATALOG_VERSION_NO
Definition: catversion.h:60
void AbsorbSyncRequests(void)
double CheckPointCompletionTarget
Definition: checkpointer.c:159
void RequestCheckpoint(int flags)
void BootStrapCLOG(void)
Definition: clog.c:831
void StartupCLOG(void)
Definition: clog.c:842
void CheckPointCLOG(void)
Definition: clog.c:902
void TrimCLOG(void)
Definition: clog.c:857
void StartupCommitTs(void)
Definition: commit_ts.c:608
void CommitTsParameterChange(bool newvalue, bool oldvalue)
Definition: commit_ts.c:640
bool track_commit_timestamp
Definition: commit_ts.c:109
void CompleteCommitTsInitialization(void)
Definition: commit_ts.c:618
void BootStrapCommitTs(void)
Definition: commit_ts.c:594
void SetCommitTsLimit(TransactionId oldestXact, TransactionId newestXact)
Definition: commit_ts.c:887
void CheckPointCommitTs(void)
Definition: commit_ts.c:794
void update_controlfile(const char *DataDir, ControlFileData *ControlFile, bool do_sync)
#define fprintf(file, fmt, msg)
Definition: cubescan.l:21
int64 TimestampTz
Definition: timestamp.h:39
int errmsg_plural(const char *fmt_singular, const char *fmt_plural, unsigned long n,...)
Definition: elog.c:1184
int errmsg_internal(const char *fmt,...)
Definition: elog.c:1161
int errcode_for_file_access(void)
Definition: elog.c:877
int errdetail(const char *fmt,...)
Definition: elog.c:1207
int errhint(const char *fmt,...)
Definition: elog.c:1321
int errcode(int sqlerrcode)
Definition: elog.c:854
int errmsg(const char *fmt,...)
Definition: elog.c:1071
#define _(x)
Definition: elog.c:91
#define LOG
Definition: elog.h:31
#define FATAL
Definition: elog.h:41
#define WARNING
Definition: elog.h:36
#define DEBUG2
Definition: elog.h:29
#define PANIC
Definition: elog.h:42
#define DEBUG1
Definition: elog.h:30
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:226
#define NOTICE
Definition: elog.h:35
#define ereport(elevel,...)
Definition: elog.h:150
struct pg_atomic_uint64 pg_atomic_uint64
int MakePGDirectory(const char *directoryName)
Definition: fd.c:3975
int FreeDir(DIR *dir)
Definition: fd.c:3022
int pg_fsync_no_writethrough(int fd)
Definition: fd.c:438
int io_direct_flags
Definition: fd.c:168
int durable_rename(const char *oldfile, const char *newfile, int elevel)
Definition: fd.c:779
int pg_fdatasync(int fd)
Definition: fd.c:477
int CloseTransientFile(int fd)
Definition: fd.c:2868
int BasicOpenFile(const char *fileName, int fileFlags)
Definition: fd.c:1086
int FreeFile(FILE *file)
Definition: fd.c:2840
int pg_fsync_writethrough(int fd)
Definition: fd.c:458
void ReleaseExternalFD(void)
Definition: fd.c:1238
int data_sync_elevel(int elevel)
Definition: fd.c:3998
static void Insert(File file)
Definition: fd.c:1314
DIR * AllocateDir(const char *dirname)
Definition: fd.c:2904
int durable_unlink(const char *fname, int elevel)
Definition: fd.c:869
void ReserveExternalFD(void)
Definition: fd.c:1220
struct dirent * ReadDir(DIR *dir, const char *dirname)
Definition: fd.c:2970
int pg_fsync(int fd)
Definition: fd.c:386
FILE * AllocateFile(const char *name, const char *mode)
Definition: fd.c:2641
int OpenTransientFile(const char *fileName, int fileFlags)
Definition: fd.c:2691
void SyncDataDirectory(void)
Definition: fd.c:3606
#define IO_DIRECT_WAL
Definition: fd.h:55
#define IO_DIRECT_WAL_INIT
Definition: fd.h:56
#define PG_O_DIRECT
Definition: fd.h:97
ssize_t pg_pwrite_zeros(int fd, size_t size, off_t offset)
Definition: file_utils.c:709
PGFileType get_dirent_type(const char *path, const struct dirent *de, bool look_through_symlinks, int elevel)
Definition: file_utils.c:547
PGFileType
Definition: file_utils.h:19
@ PGFILETYPE_LNK
Definition: file_utils.h:24
@ PGFILETYPE_DIR
Definition: file_utils.h:23
@ PGFILETYPE_REG
Definition: file_utils.h:22
bool IsBinaryUpgrade
Definition: globals.c:121
int NBuffers
Definition: globals.c:142
bool enableFsync
Definition: globals.c:129
ProcNumber MyProcNumber
Definition: globals.c:90
bool IsUnderPostmaster
Definition: globals.c:120
int MaxConnections
Definition: globals.c:143
volatile uint32 CritSectionCount
Definition: globals.c:45
char * DataDir
Definition: globals.c:71
bool IsPostmasterEnvironment
Definition: globals.c:119
struct Latch * MyLatch
Definition: globals.c:63
int max_worker_processes
Definition: globals.c:144
int set_config_option_ext(const char *name, const char *value, GucContext context, GucSource source, Oid srole, GucAction action, bool changeVal, int elevel, bool is_reload)
Definition: guc.c:3387
void SetConfigOption(const char *name, const char *value, GucContext context, GucSource source)
Definition: guc.c:4337
void * guc_malloc(int elevel, size_t size)
Definition: guc.c:639
#define newval
struct config_generic * find_option(const char *name, bool create_placeholders, bool skip_errors, int elevel)
Definition: guc.c:1236
@ GUC_ACTION_SET
Definition: guc.h:203
#define GUC_check_errdetail
Definition: guc.h:505
GucSource
Definition: guc.h:112
@ PGC_S_DYNAMIC_DEFAULT
Definition: guc.h:114
@ PGC_S_OVERRIDE
Definition: guc.h:123
@ PGC_INTERNAL
Definition: guc.h:73
@ PGC_POSTMASTER
Definition: guc.h:74
Assert(PointerIsAligned(start, uint64))
return str start
#define TOAST_MAX_CHUNK_SIZE
Definition: heaptoast.h:84
#define bufsize
Definition: indent_globs.h:36
#define INJECTION_POINT(name, arg)
WalUsage pgWalUsage
Definition: instrument.c:22
#define close(a)
Definition: win32.h:12
#define write(a, b, c)
Definition: win32.h:14
#define read(a, b, c)
Definition: win32.h:13
void before_shmem_exit(pg_on_exit_callback function, Datum arg)
Definition: ipc.c:337
#define PG_ENSURE_ERROR_CLEANUP(cleanup_function, arg)
Definition: ipc.h:47
#define PG_END_ENSURE_ERROR_CLEANUP(cleanup_function, arg)
Definition: ipc.h:52
int i
Definition: isn.c:77
if(TABLE==NULL||TABLE_index==NULL)
Definition: isn.c:81
#define LOBLKSIZE
Definition: large_object.h:70
void SetLatch(Latch *latch)
Definition: latch.c:290
void ResetLatch(Latch *latch)
Definition: latch.c:374
int WaitLatch(Latch *latch, int wakeEvents, long timeout, uint32 wait_event_info)
Definition: latch.c:172
List * lappend(List *list, void *datum)
Definition: list.c:339
void list_free(List *list)
Definition: list.c:1546
int max_locks_per_xact
Definition: lock.c:53
void LWLockUpdateVar(LWLock *lock, pg_atomic_uint64 *valptr, uint64 val)
Definition: lwlock.c:1726
void LWLockReleaseClearVar(LWLock *lock, pg_atomic_uint64 *valptr, uint64 val)
Definition: lwlock.c:1923
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1174
bool LWLockWaitForVar(LWLock *lock, pg_atomic_uint64 *valptr, uint64 oldval, uint64 *newval)
Definition: lwlock.c:1590
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1894
void LWLockInitialize(LWLock *lock, int tranche_id)
Definition: lwlock.c:698
bool LWLockConditionalAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1345
bool LWLockAcquireOrWait(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1402
@ LW_SHARED
Definition: lwlock.h:113
@ LW_EXCLUSIVE
Definition: lwlock.h:112
char * pstrdup(const char *in)
Definition: mcxt.c:1759
void pfree(void *pointer)
Definition: mcxt.c:1594
MemoryContext TopMemoryContext
Definition: mcxt.c:166
void * palloc(Size size)
Definition: mcxt.c:1365
void MemoryContextAllowInCriticalSection(MemoryContext context, bool allow)
Definition: mcxt.c:740
#define AllocSetContextCreate
Definition: memutils.h:129
#define ALLOCSET_DEFAULT_SIZES
Definition: memutils.h:160
#define IsBootstrapProcessingMode()
Definition: miscadmin.h:476
#define START_CRIT_SECTION()
Definition: miscadmin.h:149
#define CHECK_FOR_INTERRUPTS()
Definition: miscadmin.h:122
@ B_CHECKPOINTER
Definition: miscadmin.h:362
#define END_CRIT_SECTION()
Definition: miscadmin.h:151
#define AmWalReceiverProcess()
Definition: miscadmin.h:390
bool process_shared_preload_libraries_done
Definition: miscinit.c:1787
BackendType MyBackendType
Definition: miscinit.c:64
void MultiXactSetNextMXact(MultiXactId nextMulti, MultiXactOffset nextMultiOffset)
Definition: multixact.c:2258
void MultiXactAdvanceOldest(MultiXactId oldestMulti, Oid oldestMultiDB)
Definition: multixact.c:2466
void MultiXactGetCheckptMulti(bool is_shutdown, MultiXactId *nextMulti, MultiXactOffset *nextMultiOffset, MultiXactId *oldestMulti, Oid *oldestMultiDB)
Definition: multixact.c:2212
void SetMultiXactIdLimit(MultiXactId oldest_datminmxid, Oid oldest_datoid, bool is_startup)
Definition: multixact.c:2292
void CheckPointMultiXact(void)
Definition: multixact.c:2234
void TrimMultiXact(void)
Definition: multixact.c:2108
void MultiXactAdvanceNextMXact(MultiXactId minMulti, MultiXactOffset minMultiOffset)
Definition: multixact.c:2441
void BootStrapMultiXact(void)
Definition: multixact.c:2025
void StartupMultiXact(void)
Definition: multixact.c:2083
#define FirstMultiXactId
Definition: multixact.h:26
void StartupReplicationOrigin(void)
Definition: origin.c:722
void CheckPointReplicationOrigin(void)
Definition: origin.c:596
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:124
void * arg
#define ERRCODE_DATA_CORRUPTED
Definition: pg_basebackup.c:42
#define INDEX_MAX_KEYS
#define NAMEDATALEN
#define MAXPGPATH
#define DEFAULT_XLOG_SEG_SIZE
#define PG_IO_ALIGN_SIZE
#define PG_CACHE_LINE_SIZE
#define FLOATFORMAT_VALUE
Definition: pg_control.h:201
#define XLOG_RESTORE_POINT
Definition: pg_control.h:75
#define XLOG_FPW_CHANGE
Definition: pg_control.h:76
#define XLOG_CHECKPOINT_REDO
Definition: pg_control.h:82
#define PG_CONTROL_VERSION
Definition: pg_control.h:25
#define XLOG_OVERWRITE_CONTRECORD
Definition: pg_control.h:81
#define XLOG_FPI
Definition: pg_control.h:79
#define XLOG_FPI_FOR_HINT
Definition: pg_control.h:78
#define MOCK_AUTH_NONCE_LEN
Definition: pg_control.h:28
#define XLOG_NEXTOID
Definition: pg_control.h:71
@ DB_IN_PRODUCTION
Definition: pg_control.h:97
@ DB_SHUTDOWNING
Definition: pg_control.h:94
@ DB_IN_ARCHIVE_RECOVERY
Definition: pg_control.h:96
@ DB_SHUTDOWNED_IN_RECOVERY
Definition: pg_control.h:93
@ DB_SHUTDOWNED
Definition: pg_control.h:92
@ DB_IN_CRASH_RECOVERY
Definition: pg_control.h:95
#define XLOG_NOOP
Definition: pg_control.h:70
#define XLOG_CHECKPOINT_SHUTDOWN
Definition: pg_control.h:68
#define PG_CONTROL_FILE_SIZE
Definition: pg_control.h:256
#define XLOG_SWITCH
Definition: pg_control.h:72
#define XLOG_BACKUP_END
Definition: pg_control.h:73
#define XLOG_PARAMETER_CHANGE
Definition: pg_control.h:74
#define XLOG_CHECKPOINT_ONLINE
Definition: pg_control.h:69
#define XLOG_END_OF_RECOVERY
Definition: pg_control.h:77
uint32 pg_crc32c
Definition: pg_crc32c.h:38
#define COMP_CRC32C(crc, data, len)
Definition: pg_crc32c.h:153
#define EQ_CRC32C(c1, c2)
Definition: pg_crc32c.h:42
#define INIT_CRC32C(crc)
Definition: pg_crc32c.h:41
#define FIN_CRC32C(crc)
Definition: pg_crc32c.h:158
const void size_t len
return crc
static char * filename
Definition: pg_dumpall.c:120
#define lfirst(lc)
Definition: pg_list.h:172
static rewind_source * source
Definition: pg_rewind.c:89
static char * buf
Definition: pg_test_fsync.c:72
bool pgstat_report_fixed
Definition: pgstat.c:218
void pgstat_restore_stats(void)
Definition: pgstat.c:505
void pgstat_discard_stats(void)
Definition: pgstat.c:517
@ IOOBJECT_WAL
Definition: pgstat.h:277
@ IOCONTEXT_INIT
Definition: pgstat.h:286
@ IOCONTEXT_NORMAL
Definition: pgstat.h:287
@ IOOP_FSYNC
Definition: pgstat.h:306
@ IOOP_WRITE
Definition: pgstat.h:314
PgStat_CheckpointerStats PendingCheckpointerStats
instr_time pgstat_prepare_io_time(bool track_io_guc)
Definition: pgstat_io.c:91
void pgstat_count_io_op_time(IOObject io_object, IOContext io_context, IOOp io_op, instr_time start_time, uint32 cnt, uint64 bytes)
Definition: pgstat_io.c:122
int64 pg_time_t
Definition: pgtime.h:23
size_t pg_strftime(char *s, size_t maxsize, const char *format, const struct pg_tm *t)
Definition: strftime.c:128
struct pg_tm * pg_localtime(const pg_time_t *timep, const pg_tz *tz)
Definition: localtime.c:1344
PGDLLIMPORT pg_tz * log_timezone
Definition: pgtz.c:31
bool pg_strong_random(void *buf, size_t len)
int pg_strcasecmp(const char *s1, const char *s2)
Definition: pgstrcasecmp.c:36
#define pg_pwrite
Definition: port.h:227
#define snprintf
Definition: port.h:239
#define IS_DIR_SEP(ch)
Definition: port.h:103
size_t strlcpy(char *dst, const char *src, size_t siz)
Definition: strlcpy.c:45
static bool DatumGetBool(Datum X)
Definition: postgres.h:100
static Datum BoolGetDatum(bool X)
Definition: postgres.h:112
uint64_t Datum
Definition: postgres.h:70
#define InvalidOid
Definition: postgres_ext.h:37
unsigned int Oid
Definition: postgres_ext.h:32
void CheckPointPredicate(void)
Definition: predicate.c:1041
static int fd(const char *x, int i)
Definition: preproc-init.c:105
short access
Definition: preproc-type.c:36
#define GetPGProcByNumber(n)
Definition: proc.h:440
#define DELAY_CHKPT_START
Definition: proc.h:135
#define DELAY_CHKPT_COMPLETE
Definition: proc.h:136
bool MinimumActiveBackends(int min)
Definition: procarray.c:3508
TransactionId GetOldestTransactionIdConsideredRunning(void)
Definition: procarray.c:1982
bool HaveVirtualXIDsDelayingChkpt(VirtualTransactionId *vxids, int nvxids, int type)
Definition: procarray.c:3051
void ProcArrayApplyRecoveryInfo(RunningTransactions running)
Definition: procarray.c:1054
TransactionId GetOldestActiveTransactionId(bool inCommitOnly, bool allDbs)
Definition: procarray.c:2833
void ProcArrayInitRecovery(TransactionId initializedUptoXID)
Definition: procarray.c:1023
VirtualTransactionId * GetVirtualXIDsDelayingChkpt(int *nvxids, int type)
Definition: procarray.c:3005
#define INVALID_PROC_NUMBER
Definition: procnumber.h:26
int ProcNumber
Definition: procnumber.h:24
static void set_ps_display(const char *activity)
Definition: ps_status.h:40
void ResetUnloggedRelations(int op)
Definition: reinit.c:47
#define UNLOGGED_RELATION_INIT
Definition: reinit.h:28
#define UNLOGGED_RELATION_CLEANUP
Definition: reinit.h:27
void RelationCacheInitFileRemove(void)
Definition: relcache.c:6900
void CheckPointRelationMap(void)
Definition: relmapper.c:611
#define relpath(rlocator, forknum)
Definition: relpath.h:150
#define PG_TBLSPC_DIR
Definition: relpath.h:41
void StartupReorderBuffer(void)
ResourceOwner CurrentResourceOwner
Definition: resowner.c:173
ResourceOwner AuxProcessResourceOwner
Definition: resowner.c:176
void CheckPointLogicalRewriteHeap(void)
Definition: rewriteheap.c:1155
#define RM_MAX_ID
Definition: rmgr.h:33
Size add_size(Size s1, Size s2)
Definition: shmem.c:493
Size mul_size(Size s1, Size s2)
Definition: shmem.c:510
void * ShmemInitStruct(const char *name, Size size, bool *foundPtr)
Definition: shmem.c:387
void pg_usleep(long microsec)
Definition: signal.c:53
void CheckPointReplicationSlots(bool is_shutdown)
Definition: slot.c:2115
void StartupReplicationSlots(void)
Definition: slot.c:2187
bool InvalidateObsoleteReplicationSlots(uint32 possible_causes, XLogSegNo oldestSegno, Oid dboid, TransactionId snapshotConflictHorizon)
Definition: slot.c:2055
@ RS_INVAL_WAL_REMOVED
Definition: slot.h:62
@ RS_INVAL_IDLE_TIMEOUT
Definition: slot.h:68
@ RS_INVAL_WAL_LEVEL
Definition: slot.h:66
void smgrdestroyall(void)
Definition: smgr.c:386
void CheckPointSnapBuild(void)
Definition: snapbuild.c:1970
void DeleteAllExportedSnapshotFiles(void)
Definition: snapmgr.c:1585
#define SpinLockInit(lock)
Definition: spin.h:57
#define SpinLockRelease(lock)
Definition: spin.h:61
#define SpinLockAcquire(lock)
Definition: spin.h:59
void reset(void)
Definition: sql-declare.c:600
PGPROC * MyProc
Definition: proc.c:66
PROC_HDR * ProcGlobal
Definition: proc.c:78
XLogRecPtr LogStandbySnapshot(void)
Definition: standby.c:1282
void InitRecoveryTransactionEnvironment(void)
Definition: standby.c:95
void ShutdownRecoveryTransactionEnvironment(void)
Definition: standby.c:161
@ SUBXIDS_IN_SUBTRANS
Definition: standby.h:82
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition: stringinfo.c:145
void appendBinaryStringInfo(StringInfo str, const void *data, int datalen)
Definition: stringinfo.c:281
void appendStringInfoString(StringInfo str, const char *s)
Definition: stringinfo.c:230
void appendStringInfoChar(StringInfo str, char ch)
Definition: stringinfo.c:242
void initStringInfo(StringInfo str)
Definition: stringinfo.c:97
Oid oldestMultiDB
Definition: pg_control.h:51
MultiXactId oldestMulti
Definition: pg_control.h:50
MultiXactOffset nextMultiOffset
Definition: pg_control.h:47
TransactionId newestCommitTsXid
Definition: pg_control.h:55
TransactionId oldestXid
Definition: pg_control.h:48
TimeLineID PrevTimeLineID
Definition: pg_control.h:40
TimeLineID ThisTimeLineID
Definition: pg_control.h:39
Oid nextOid
Definition: pg_control.h:45
TransactionId oldestActiveXid
Definition: pg_control.h:64
bool fullPageWrites
Definition: pg_control.h:42
MultiXactId nextMulti
Definition: pg_control.h:46
FullTransactionId nextXid
Definition: pg_control.h:44
TransactionId oldestCommitTsXid
Definition: pg_control.h:53
pg_time_t time
Definition: pg_control.h:52
int wal_level
Definition: pg_control.h:43
XLogRecPtr redo
Definition: pg_control.h:37
Oid oldestXidDB
Definition: pg_control.h:49
uint64 ckpt_agg_sync_time
Definition: xlog.h:176
uint64 ckpt_longest_sync
Definition: xlog.h:175
TimestampTz ckpt_start_t
Definition: xlog.h:161
TimestampTz ckpt_end_t
Definition: xlog.h:165
int ckpt_segs_removed
Definition: xlog.h:171
TimestampTz ckpt_write_t
Definition: xlog.h:162
int ckpt_segs_added
Definition: xlog.h:170
TimestampTz ckpt_sync_end_t
Definition: xlog.h:164
TimestampTz ckpt_sync_t
Definition: xlog.h:163
int ckpt_bufs_written
Definition: xlog.h:167
int ckpt_segs_recycled
Definition: xlog.h:172
int ckpt_slru_written
Definition: xlog.h:168
int ckpt_sync_rels
Definition: xlog.h:174
char mock_authentication_nonce[MOCK_AUTH_NONCE_LEN]
Definition: pg_control.h:235
int max_worker_processes
Definition: pg_control.h:181
uint32 pg_control_version
Definition: pg_control.h:125
uint32 xlog_seg_size
Definition: pg_control.h:211
XLogRecPtr backupStartPoint
Definition: pg_control.h:170
bool track_commit_timestamp
Definition: pg_control.h:185
bool backupEndRequired
Definition: pg_control.h:172
int max_locks_per_xact
Definition: pg_control.h:184
uint32 nameDataLen
Definition: pg_control.h:213
CheckPoint checkPointCopy
Definition: pg_control.h:135
XLogRecPtr backupEndPoint
Definition: pg_control.h:171
XLogRecPtr minRecoveryPoint
Definition: pg_control.h:168
uint32 data_checksum_version
Definition: pg_control.h:222
XLogRecPtr unloggedLSN
Definition: pg_control.h:137
uint32 indexMaxKeys
Definition: pg_control.h:214
uint32 relseg_size
Definition: pg_control.h:208
pg_time_t time
Definition: pg_control.h:132
bool default_char_signedness
Definition: pg_control.h:228
XLogRecPtr checkPoint
Definition: pg_control.h:133
uint64 system_identifier
Definition: pg_control.h:110
uint32 catalog_version_no
Definition: pg_control.h:126
double floatFormat
Definition: pg_control.h:200
int max_prepared_xacts
Definition: pg_control.h:183
uint32 xlog_blcksz
Definition: pg_control.h:210
TimeLineID minRecoveryPointTLI
Definition: pg_control.h:169
uint32 loblksize
Definition: pg_control.h:217
pg_crc32c crc
Definition: pg_control.h:238
uint32 toast_max_chunk_size
Definition: pg_control.h:216
Definition: dirent.c:26
XLogRecPtr lastPageBeginPtr
Definition: xlogrecovery.h:121
XLogRecPtr abortedRecPtr
Definition: xlogrecovery.h:130
XLogRecPtr missingContrecPtr
Definition: xlogrecovery.h:131
TimeLineID endOfLogTLI
Definition: xlogrecovery.h:119
Definition: lwlock.h:42
Definition: pg_list.h:54
Definition: proc.h:386
ProcNumber walwriterProc
Definition: proc.h:424
PgStat_Counter sync_time
Definition: pgstat.h:263
PgStat_Counter write_time
Definition: pgstat.h:262
void(* rm_mask)(char *pagedata, BlockNumber blkno)
TransactionId oldestRunningXid
Definition: standby.h:92
TransactionId nextXid
Definition: standby.h:91
TransactionId latestCompletedXid
Definition: standby.h:95
subxids_array_status subxid_status
Definition: standby.h:90
TransactionId * xids
Definition: standby.h:97
TransactionId oldestCommitTsXid
Definition: transam.h:232
TransactionId newestCommitTsXid
Definition: transam.h:233
FullTransactionId latestCompletedXid
Definition: transam.h:238
FullTransactionId nextXid
Definition: transam.h:220
TransactionId oldestXid
Definition: transam.h:222
pg_atomic_uint64 insertingAt
Definition: xlog.c:371
XLogRecPtr lastImportantAt
Definition: xlog.c:372
LWLock lock
Definition: xlog.c:370
int64 wal_buffers_full
Definition: instrument.h:56
uint64 wal_bytes
Definition: instrument.h:55
int64 wal_fpi
Definition: instrument.h:54
int64 wal_records
Definition: instrument.h:53
CheckPoint lastCheckPoint
Definition: xlog.c:545
XLogwrtRqst LogwrtRqst
Definition: xlog.c:456
slock_t info_lck
Definition: xlog.c:553
XLogRecPtr InitializedUpTo
Definition: xlog.c:485
char * pages
Definition: xlog.c:492
pg_time_t lastSegSwitchTime
Definition: xlog.c:467
XLogRecPtr replicationSlotMinLSN
Definition: xlog.c:459
RecoveryState SharedRecoveryState
Definition: xlog.c:516
TimeLineID InsertTimeLineID
Definition: xlog.c:509
XLogRecPtr lastSegSwitchLSN
Definition: xlog.c:468
XLogSegNo lastRemovedSegNo
Definition: xlog.c:461
pg_atomic_uint64 * xlblocks
Definition: xlog.c:493
pg_atomic_uint64 logWriteResult
Definition: xlog.c:472
int XLogCacheBlck
Definition: xlog.c:494
XLogRecPtr RedoRecPtr
Definition: xlog.c:457
XLogRecPtr lastCheckPointRecPtr
Definition: xlog.c:543
XLogRecPtr lastFpwDisableRecPtr
Definition: xlog.c:551
XLogCtlInsert Insert
Definition: xlog.c:453
bool InstallXLogFileSegmentActive
Definition: xlog.c:526
bool WalWriterSleeping
Definition: xlog.c:533
XLogRecPtr asyncXactLSN
Definition: xlog.c:458
XLogRecPtr lastCheckPointEndPtr
Definition: xlog.c:544
pg_atomic_uint64 logFlushResult
Definition: xlog.c:473
pg_atomic_uint64 logInsertResult
Definition: xlog.c:471
TimeLineID PrevTimeLineID
Definition: xlog.c:510
pg_atomic_uint64 unloggedLSN
Definition: xlog.c:464
WALInsertLockPadded * WALInsertLocks
Definition: xlog.c:445
XLogRecPtr RedoRecPtr
Definition: xlog.c:431
uint64 PrevBytePos
Definition: xlog.c:409
char pad[PG_CACHE_LINE_SIZE]
Definition: xlog.c:418
int runningBackups
Definition: xlog.c:439
slock_t insertpos_lck
Definition: xlog.c:399
uint64 CurrBytePos
Definition: xlog.c:408
bool fullPageWrites
Definition: xlog.c:432
XLogRecPtr lastBackupStart
Definition: xlog.c:440
TimeLineID xlp_tli
Definition: xlog_internal.h:40
XLogRecPtr xlp_pageaddr
Definition: xlog_internal.h:41
DecodedXLogRecord * record
Definition: xlogreader.h:236
XLogRecPtr EndRecPtr
Definition: xlogreader.h:207
XLogRecPtr ReadRecPtr
Definition: xlogreader.h:206
const void * data
struct XLogRecData * next
XLogRecPtr xl_prev
Definition: xlogrecord.h:45
pg_crc32c xl_crc
Definition: xlogrecord.h:49
uint8 xl_info
Definition: xlogrecord.h:46
uint32 xl_tot_len
Definition: xlogrecord.h:43
TransactionId xl_xid
Definition: xlogrecord.h:44
RmgrId xl_rmid
Definition: xlogrecord.h:47
XLogRecPtr Flush
Definition: xlog.c:329
XLogRecPtr Write
Definition: xlog.c:328
XLogRecPtr Flush
Definition: xlog.c:323
XLogRecPtr Write
Definition: xlog.c:322
Definition: guc.h:174
GucContext scontext
Definition: guc_tables.h:185
GucSource source
Definition: guc_tables.h:183
Definition: dirent.h:10
char d_name[MAX_PATH]
Definition: dirent.h:15
unsigned short st_mode
Definition: win32_port.h:258
Definition: regguts.h:323
char * rpath
Definition: basebackup.h:32
TimeLineID PrevTimeLineID
TimestampTz end_time
TimeLineID ThisTimeLineID
char rp_name[MAXFNAMELEN]
TimestampTz rp_time
void StartupSUBTRANS(TransactionId oldestActiveXID)
Definition: subtrans.c:283
void CheckPointSUBTRANS(void)
Definition: subtrans.c:329
void BootStrapSUBTRANS(void)
Definition: subtrans.c:269
void TruncateSUBTRANS(TransactionId oldestXact)
Definition: subtrans.c:385
void ProcessSyncRequests(void)
Definition: sync.c:286
void SyncPreCheckpoint(void)
Definition: sync.c:177
void SyncPostCheckpoint(void)
Definition: sync.c:202
TimeoutId RegisterTimeout(TimeoutId id, timeout_handler_proc handler)
Definition: timeout.c:505
@ STARTUP_PROGRESS_TIMEOUT
Definition: timeout.h:38
bool TransactionIdPrecedes(TransactionId id1, TransactionId id2)
Definition: transam.c:280
#define TransactionIdRetreat(dest)
Definition: transam.h:141
#define InvalidTransactionId
Definition: transam.h:31
static void FullTransactionIdRetreat(FullTransactionId *dest)
Definition: transam.h:103
#define XidFromFullTransactionId(x)
Definition: transam.h:48
#define FirstGenbkiObjectId
Definition: transam.h:195
#define FirstNormalTransactionId
Definition: transam.h:34
#define TransactionIdIsValid(xid)
Definition: transam.h:41
static FullTransactionId FullTransactionIdFromEpochAndXid(uint32 epoch, TransactionId xid)
Definition: transam.h:71
#define TransactionIdIsNormal(xid)
Definition: transam.h:42
#define FullTransactionIdPrecedes(a, b)
Definition: transam.h:51
void RecoverPreparedTransactions(void)
Definition: twophase.c:2083
void restoreTwoPhaseData(void)
Definition: twophase.c:1904
int max_prepared_xacts
Definition: twophase.c:116
TransactionId PrescanPreparedTransactions(TransactionId **xids_p, int *nxids_p)
Definition: twophase.c:1966
void StandbyRecoverPreparedTransactions(void)
Definition: twophase.c:2045
void CheckPointTwoPhase(XLogRecPtr redo_horizon)
Definition: twophase.c:1822
char data[XLOG_BLCKSZ]
Definition: c.h:1148
WALInsertLock l
Definition: xlog.c:384
char pad[PG_CACHE_LINE_SIZE]
Definition: xlog.c:385
bool SplitIdentifierString(char *rawstring, char separator, List **namelist)
Definition: varlena.c:2744
void SetTransactionIdLimit(TransactionId oldest_datfrozenxid, Oid oldest_datoid)
Definition: varsup.c:372
void AdvanceOldestClogXid(TransactionId oldest_datfrozenxid)
Definition: varsup.c:355
TransamVariablesData * TransamVariables
Definition: varsup.c:34
static void pgstat_report_wait_start(uint32 wait_event_info)
Definition: wait_event.h:69
static void pgstat_report_wait_end(void)
Definition: wait_event.h:85
#define WL_TIMEOUT
Definition: waiteventset.h:37
#define WL_EXIT_ON_PM_DEATH
Definition: waiteventset.h:39
#define WL_LATCH_SET
Definition: waiteventset.h:34
static TimestampTz wakeup[NUM_WALRCV_WAKEUPS]
Definition: walreceiver.c:130
XLogRecPtr Flush
Definition: walreceiver.c:112
XLogRecPtr Write
Definition: walreceiver.c:111
XLogRecPtr GetWalRcvFlushRecPtr(XLogRecPtr *latestChunkStart, TimeLineID *receiveTLI)
void ShutdownWalRcv(void)
void WalSndWakeup(bool physical, bool logical)
Definition: walsender.c:3779
int max_wal_senders
Definition: walsender.c:129
void WalSndInitStopping(void)
Definition: walsender.c:3858
void WalSndWaitStopping(void)
Definition: walsender.c:3884
static void WalSndWakeupProcessRequests(bool physical, bool logical)
Definition: walsender.h:65
#define WalSndWakeupRequest()
Definition: walsender.h:58
bool summarize_wal
void WaitForWalSummarization(XLogRecPtr lsn)
void WakeupWalSummarizer(void)
XLogRecPtr GetOldestUnsummarizedLSN(TimeLineID *tli, bool *lsn_is_exact)
int WalWriterFlushAfter
Definition: walwriter.c:71
int WalWriterDelay
Definition: walwriter.c:70
#define stat
Definition: win32_port.h:274
#define EINTR
Definition: win32_port.h:364
#define S_ISDIR(m)
Definition: win32_port.h:315
#define readlink(path, buf, size)
Definition: win32_port.h:226
#define O_CLOEXEC
Definition: win32_port.h:349
#define O_DSYNC
Definition: win32_port.h:342
int gettimeofday(struct timeval *tp, void *tzp)
void MarkSubxactTopXidLogged(void)
Definition: xact.c:591
void MarkCurrentTransactionIdLoggedIfAny(void)
Definition: xact.c:541
int XLogFileInit(XLogSegNo logsegno, TimeLineID logtli)
Definition: xlog.c:3393
void assign_wal_sync_method(int new_wal_sync_method, void *extra)
Definition: xlog.c:8694
static void CreateEndOfRecoveryRecord(void)
Definition: xlog.c:7421
uint64 GetSystemIdentifier(void)
Definition: xlog.c:4592
int wal_decode_buffer_size
Definition: xlog.c:137
XLogRecPtr ProcLastRecPtr
Definition: xlog.c:254
static XLogCtlData * XLogCtl
Definition: xlog.c:566
bool fullPageWrites
Definition: xlog.c:123
void UpdateFullPageWrites(void)
Definition: xlog.c:8213
bool RecoveryInProgress(void)
Definition: xlog.c:6383
static void CleanupBackupHistory(void)
Definition: xlog.c:4174
void GetFullPageWriteInfo(XLogRecPtr *RedoRecPtr_p, bool *doPageWrites_p)
Definition: xlog.c:6516
TimeLineID GetWALInsertionTimeLine(void)
Definition: xlog.c:6569
XLogRecPtr RequestXLogSwitch(bool mark_unimportant)
Definition: xlog.c:8107
void do_pg_abort_backup(int code, Datum arg)
Definition: xlog.c:9435
XLogSegNo XLogGetLastRemovedSegno(void)
Definition: xlog.c:3771
char * XLogArchiveCommand
Definition: xlog.c:121
struct XLogCtlInsert XLogCtlInsert
int wal_keep_size_mb
Definition: xlog.c:117
Size WALReadFromBuffers(char *dstbuf, XLogRecPtr startptr, Size count, TimeLineID tli)
Definition: xlog.c:1751
static XLogRecPtr WaitXLogInsertionsToFinish(XLogRecPtr upto)
Definition: xlog.c:1507
static void WALInsertLockRelease(void)
Definition: xlog.c:1448
static XLogRecPtr XLogBytePosToRecPtr(uint64 bytepos)
Definition: xlog.c:1861
bool EnableHotStandby
Definition: xlog.c:122
static void WALInsertLockUpdateInsertingAt(XLogRecPtr insertingAt)
Definition: xlog.c:1474
XLogRecPtr GetRedoRecPtr(void)
Definition: xlog.c:6486
void assign_wal_consistency_checking(const char *newval, void *extra)
Definition: xlog.c:4796
static void InitControlFile(uint64 sysidentifier, uint32 data_checksum_version)
Definition: xlog.c:4217
void SetInstallXLogFileSegmentActive(void)
Definition: xlog.c:9525
static void AdvanceXLInsertBuffer(XLogRecPtr upto, TimeLineID tli, bool opportunistic)
Definition: xlog.c:1988
static void WALInsertLockAcquireExclusive(void)
Definition: xlog.c:1419
static void UpdateControlFile(void)
Definition: xlog.c:4583
void StartupXLOG(void)
Definition: xlog.c:5466
bool IsInstallXLogFileSegmentActive(void)
Definition: xlog.c:9533
static int openLogFile
Definition: xlog.c:635
void BootStrapXLOG(uint32 data_checksum_version)
Definition: xlog.c:5072
XLogRecPtr XactLastRecEnd
Definition: xlog.c:255
bool CreateRestartPoint(int flags)
Definition: xlog.c:7636
static void ValidateXLOGDirectoryStructure(void)
Definition: xlog.c:4112
int CommitDelay
Definition: xlog.c:133
static void RemoveOldXlogFiles(XLogSegNo segno, XLogRecPtr lastredoptr, XLogRecPtr endptr, TimeLineID insertTLI)
Definition: xlog.c:3878
static XLogRecPtr CreateOverwriteContrecordRecord(XLogRecPtr aborted_lsn, XLogRecPtr pagePtr, TimeLineID newTLI)
Definition: xlog.c:7486
XLogRecPtr GetInsertRecPtr(void)
Definition: xlog.c:6531
bool wal_init_zero
Definition: xlog.c:128
static void CalculateCheckpointSegments(void)
Definition: xlog.c:2171
int XLogArchiveMode
Definition: xlog.c:120
SessionBackupState get_backup_status(void)
Definition: xlog.c:9142
static void XLogReportParameters(void)
Definition: xlog.c:8150
#define RefreshXLogWriteResult(_target)
Definition: xlog.c:620
void CheckXLogRemoved(XLogSegNo segno, TimeLineID tli)
Definition: xlog.c:3740
int wal_level
Definition: xlog.c:132
static void LogCheckpointStart(int flags, bool restartpoint)
Definition: xlog.c:6698
static XLogRecPtr RedoRecPtr
Definition: xlog.c:274
void assign_checkpoint_completion_target(double newval, void *extra)
Definition: xlog.c:2207
static XLogRecPtr XLogGetReplicationSlotMinimumLSN(void)
Definition: xlog.c:2679
XLogRecPtr XLogInsertRecord(XLogRecData *rdata, XLogRecPtr fpw_lsn, uint8 flags, int num_fpi, bool topxid_included)
Definition: xlog.c:748
static bool InstallXLogFileSegment(XLogSegNo *segno, char *tmppath, bool find_free, XLogSegNo max_segno, TimeLineID tli)
Definition: xlog.c:3576
static void WriteControlFile(void)
Definition: xlog.c:4252
int wal_segment_size
Definition: xlog.c:144
struct XLogwrtResult XLogwrtResult
WALAvailability GetWALAvailability(XLogRecPtr targetLSN)
Definition: xlog.c:7914
const char * show_archive_command(void)
Definition: xlog.c:4849
#define UsableBytesInPage
Definition: xlog.c:597
int max_wal_size_mb
Definition: xlog.c:115
void XLOGShmemInit(void)
Definition: xlog.c:4957
void ShutdownXLOG(int code, Datum arg)
Definition: xlog.c:6651
bool DataChecksumsEnabled(void)
Definition: xlog.c:4612
static bool PerformRecoveryXLogAction(void)
Definition: xlog.c:6333
RecoveryState GetRecoveryState(void)
Definition: xlog.c:6419
int XLogArchiveTimeout
Definition: xlog.c:119
static void CleanupAfterArchiveRecovery(TimeLineID EndOfLogTLI, XLogRecPtr EndOfLog, TimeLineID newTLI)
Definition: xlog.c:5326
#define ConvertToXSegs(x, segsize)
Definition: xlog.c:603
bool wal_recycle
Definition: xlog.c:129
static void RemoveXlogFile(const struct dirent *segment_de, XLogSegNo recycleSegNo, XLogSegNo *endlogSegNo, TimeLineID insertTLI)
Definition: xlog.c:4022
pg_time_t GetLastSegSwitchData(XLogRecPtr *lastSwitchLSN)
Definition: xlog.c:6634
static int XLOGChooseNumBuffers(void)
Definition: xlog.c:4658
static XLogRecPtr XLogBytePosToEndRecPtr(uint64 bytepos)
Definition: xlog.c:1901
static int get_sync_bit(int method)
Definition: xlog.c:8646
static XLogwrtResult LogwrtResult
Definition: xlog.c:612
void XLogSetReplicationSlotMinimumLSN(XLogRecPtr lsn)
Definition: xlog.c:2666
static void LogCheckpointEnd(bool restartpoint)
Definition: xlog.c:6730
union WALInsertLockPadded WALInsertLockPadded
void SwitchIntoArchiveRecovery(XLogRecPtr EndRecPtr, TimeLineID replayTLI)
Definition: xlog.c:6258
static bool lastFullPageWrites
Definition: xlog.c:218
char * wal_consistency_checking_string
Definition: xlog.c:126
static void WALInsertLockAcquire(void)
Definition: xlog.c:1374
int CommitSiblings
Definition: xlog.c:134
static void CopyXLogRecordToWAL(int write_len, bool isLogSwitch, XLogRecData *rdata, XLogRecPtr StartPos, XLogRecPtr EndPos, TimeLineID tli)
Definition: xlog.c:1228
bool GetDefaultCharSignedness(void)
Definition: xlog.c:4626
static double CheckPointDistanceEstimate
Definition: xlog.c:160
static uint64 XLogRecPtrToBytePos(XLogRecPtr ptr)
Definition: xlog.c:1944
const char * show_in_hot_standby(void)
Definition: xlog.c:4861
XLogRecPtr GetXLogInsertRecPtr(void)
Definition: xlog.c:9476
Size XLOGShmemSize(void)
Definition: xlog.c:4907
void SetWalWriterSleeping(bool sleeping)
Definition: xlog.c:9548
bool wal_log_hints
Definition: xlog.c:124
static void XLogInitNewTimeline(TimeLineID endTLI, XLogRecPtr endOfLog, TimeLineID newTLI)
Definition: xlog.c:5251
static void CheckRequiredParameterValues(void)
Definition: xlog.c:5422
#define XLogRecPtrToBufIdx(recptr)
Definition: xlog.c:591
int wal_sync_method
Definition: xlog.c:131
int XLogFileOpen(XLogSegNo segno, TimeLineID tli)
Definition: xlog.c:3631
int max_slot_wal_keep_size_mb
Definition: xlog.c:136
XLogRecPtr GetFlushRecPtr(TimeLineID *insertTLI)
Definition: xlog.c:6548
static void PreallocXlogFiles(XLogRecPtr endptr, TimeLineID tli)
Definition: xlog.c:3703
static bool doPageWrites
Definition: xlog.c:287
static bool holdingAllLocks
Definition: xlog.c:652
static TimeLineID openLogTLI
Definition: xlog.c:637
XLogRecPtr XactLastCommitEnd
Definition: xlog.c:256
WalLevel GetActiveWalLevelOnStandby(void)
Definition: xlog.c:4898
bool log_checkpoints
Definition: xlog.c:130
static void KeepLogSeg(XLogRecPtr recptr, XLogSegNo *logSegNo)
Definition: xlog.c:7998
static void XLogWrite(XLogwrtRqst WriteRqst, TimeLineID tli, bool flexible)
Definition: xlog.c:2304
void InitializeWalConsistencyChecking(void)
Definition: xlog.c:4823
static void UpdateMinRecoveryPoint(XLogRecPtr lsn, bool force)
Definition: xlog.c:2700
static int LocalSetXLogInsertAllowed(void)
Definition: xlog.c:6471
void assign_max_wal_size(int newval, void *extra)
Definition: xlog.c:2200
void RemoveNonParentXlogFiles(XLogRecPtr switchpoint, TimeLineID newTLI)
Definition: xlog.c:3953
XLogRecPtr GetLastImportantRecPtr(void)
Definition: xlog.c:6605
void xlog_redo(XLogReaderState *record)
Definition: xlog.c:8282
static int MyLockNo
Definition: xlog.c:651
static void RecoveryRestartPoint(const CheckPoint *checkPoint, XLogReaderState *record)
Definition: xlog.c:7596
bool XLogNeedsFlush(XLogRecPtr record)
Definition: xlog.c:3124
void register_persistent_abort_backup_handler(void)
Definition: xlog.c:9462
static double PrevCheckPointDistance
Definition: xlog.c:161
void ReachedEndOfBackup(XLogRecPtr EndRecPtr, TimeLineID tli)
Definition: xlog.c:6296
void LocalProcessControlFile(bool reset)
Definition: xlog.c:4885
static void XLogFileClose(void)
Definition: xlog.c:3652
int wal_compression
Definition: xlog.c:125
static void UpdateCheckPointDistanceEstimate(uint64 nbytes)
Definition: xlog.c:6835
static bool LocalRecoveryInProgress
Definition: xlog.c:225
XLogSegNo XLogGetOldestSegno(TimeLineID tli)
Definition: xlog.c:3787
XLogRecPtr GetXLogWriteRecPtr(void)
Definition: xlog.c:9492
static WALInsertLockPadded * WALInsertLocks
Definition: xlog.c:569
static XLogSegNo openLogSegNo
Definition: xlog.c:636
#define INSERT_FREESPACE(endptr)
Definition: xlog.c:580
int wal_retrieve_retry_interval
Definition: xlog.c:135
int XLOGbuffers
Definition: xlog.c:118
bool XLogBackgroundFlush(void)
Definition: xlog.c:2975
const struct config_enum_entry archive_mode_options[]
Definition: xlog.c:192
void GetOldestRestartPoint(XLogRecPtr *oldrecptr, TimeLineID *oldtli)
Definition: xlog.c:9504
char * GetMockAuthenticationNonce(void)
Definition: xlog.c:4602
bool track_wal_io_timing
Definition: xlog.c:138
static XLogSegNo XLOGfileslop(XLogRecPtr lastredoptr)
Definition: xlog.c:2230
static int UsableBytesInSegment
Definition: xlog.c:606
static char * GetXLogBuffer(XLogRecPtr ptr, TimeLineID tli)
Definition: xlog.c:1635
WalInsertClass
Definition: xlog.c:560
@ WALINSERT_SPECIAL_SWITCH
Definition: xlog.c:562
@ WALINSERT_NORMAL
Definition: xlog.c:561
@ WALINSERT_SPECIAL_CHECKPOINT
Definition: xlog.c:563
bool XLogInsertAllowed(void)
Definition: xlog.c:6438
void do_pg_backup_start(const char *backupidstr, bool fast, List **tablespaces, BackupState *state, StringInfo tblspcmapfile)
Definition: xlog.c:8833
static ControlFileData * ControlFile
Definition: xlog.c:574
bool check_wal_segment_size(int *newval, void **extra, GucSource source)
Definition: xlog.c:2214
static void XLogFileCopy(TimeLineID destTLI, XLogSegNo destsegno, TimeLineID srcTLI, XLogSegNo srcsegno, int upto)
Definition: xlog.c:3431
static int LocalXLogInsertAllowed
Definition: xlog.c:237
static void RemoveTempXlogFiles(void)
Definition: xlog.c:3845
XLogRecPtr XLogRestorePoint(const char *rpName)
Definition: xlog.c:8125
static XLogRecPtr LocalMinRecoveryPoint
Definition: xlog.c:646
#define NUM_XLOGINSERT_LOCKS
Definition: xlog.c:151
struct XLogwrtRqst XLogwrtRqst
TimeLineID GetWALInsertionTimeLineIfSet(void)
Definition: xlog.c:6585
void do_pg_backup_stop(BackupState *state, bool waitforarchive)
Definition: xlog.c:9161
bool check_wal_consistency_checking(char **newval, void **extra, GucSource source)
Definition: xlog.c:4709
const struct config_enum_entry wal_sync_method_options[]
Definition: xlog.c:172
int min_wal_size_mb
Definition: xlog.c:116
bool CreateCheckPoint(int flags)
Definition: xlog.c:6938
#define BootstrapTimeLineID
Definition: xlog.c:112
CheckpointStatsData CheckpointStats
Definition: xlog.c:210
bool check_wal_buffers(int *newval, void **extra, GucSource source)
Definition: xlog.c:4674
XLogRecPtr GetFakeLSNForUnloggedRel(void)
Definition: xlog.c:4641
static char * str_time(pg_time_t tnow, char *buf, size_t bufsize)
Definition: xlog.c:5238
void XLogPutNextOid(Oid nextOid)
Definition: xlog.c:8070
void XLogFlush(XLogRecPtr record)
Definition: xlog.c:2780
static void ReadControlFile(void)
Definition: xlog.c:4361
static SessionBackupState sessionBackupState
Definition: xlog.c:392
static void CheckPointGuts(XLogRecPtr checkPointRedo, int flags)
Definition: xlog.c:7556
static bool updateMinRecoveryPoint
Definition: xlog.c:648
int CheckPointSegments
Definition: xlog.c:157
static bool check_wal_consistency_checking_deferred
Definition: xlog.c:167
static void ReserveXLogInsertLocation(int size, XLogRecPtr *StartPos, XLogRecPtr *EndPos, XLogRecPtr *PrevPtr)
Definition: xlog.c:1111
void XLogShutdownWalRcv(void)
Definition: xlog.c:9514
#define NextBufIdx(idx)
Definition: xlog.c:584
static void UpdateLastRemovedPtr(char *filename)
Definition: xlog.c:3825
static TimeLineID LocalMinRecoveryPointTLI
Definition: xlog.c:647
void issue_xlog_fsync(int fd, XLogSegNo segno, TimeLineID tli)
Definition: xlog.c:8736
struct XLogCtlData XLogCtlData
static bool ReserveXLogSwitch(XLogRecPtr *StartPos, XLogRecPtr *EndPos, XLogRecPtr *PrevPtr)
Definition: xlog.c:1167
void XLogSetAsyncXactLSN(XLogRecPtr asyncXactLSN)
Definition: xlog.c:2609
bool XLogCheckpointNeeded(XLogSegNo new_segno)
Definition: xlog.c:2280
bool * wal_consistency_checking
Definition: xlog.c:127
static int XLogFileInitInternal(XLogSegNo logsegno, TimeLineID logtli, bool *added, char *path)
Definition: xlog.c:3205
static void update_checkpoint_display(int flags, bool restartpoint, bool reset)
Definition: xlog.c:6873
#define XLogArchivingActive()
Definition: xlog.h:99
#define TABLESPACE_MAP_OLD
Definition: xlog.h:307
#define XLOG_MARK_UNIMPORTANT
Definition: xlog.h:155
#define TABLESPACE_MAP
Definition: xlog.h:306
@ ARCHIVE_MODE_ALWAYS
Definition: xlog.h:67
@ ARCHIVE_MODE_OFF
Definition: xlog.h:65
@ ARCHIVE_MODE_ON
Definition: xlog.h:66
#define CHECKPOINT_FLUSH_UNLOGGED
Definition: xlog.h:143
#define STANDBY_SIGNAL_FILE
Definition: xlog.h:302
#define CHECKPOINT_CAUSE_XLOG
Definition: xlog.h:148
WALAvailability
Definition: xlog.h:188
@ WALAVAIL_REMOVED
Definition: xlog.h:194
@ WALAVAIL_RESERVED
Definition: xlog.h:190
@ WALAVAIL_UNRESERVED
Definition: xlog.h:193
@ WALAVAIL_EXTENDED
Definition: xlog.h:191
@ WALAVAIL_INVALID_LSN
Definition: xlog.h:189
#define BACKUP_LABEL_OLD
Definition: xlog.h:304
#define CHECKPOINT_END_OF_RECOVERY
Definition: xlog.h:140
@ WAL_COMPRESSION_NONE
Definition: xlog.h:82
#define BACKUP_LABEL_FILE
Definition: xlog.h:303
#define CHECKPOINT_CAUSE_TIME
Definition: xlog.h:149
#define CHECKPOINT_FORCE
Definition: xlog.h:142
SessionBackupState
Definition: xlog.h:287
@ SESSION_BACKUP_RUNNING
Definition: xlog.h:289
@ SESSION_BACKUP_NONE
Definition: xlog.h:288
#define CHECKPOINT_WAIT
Definition: xlog.h:145
#define CHECKPOINT_FAST
Definition: xlog.h:141
#define RECOVERY_SIGNAL_FILE
Definition: xlog.h:301
#define CHECKPOINT_IS_SHUTDOWN
Definition: xlog.h:139
#define XLogArchivingAlways()
Definition: xlog.h:102
WalLevel
Definition: xlog.h:73
@ WAL_LEVEL_REPLICA
Definition: xlog.h:75
@ WAL_LEVEL_LOGICAL
Definition: xlog.h:76
@ WAL_LEVEL_MINIMAL
Definition: xlog.h:74
RecoveryState
Definition: xlog.h:90
@ RECOVERY_STATE_CRASH
Definition: xlog.h:91
@ RECOVERY_STATE_DONE
Definition: xlog.h:93
@ RECOVERY_STATE_ARCHIVE
Definition: xlog.h:92
#define XLogIsNeeded()
Definition: xlog.h:109
@ WAL_SYNC_METHOD_OPEN
Definition: xlog.h:26
@ WAL_SYNC_METHOD_FDATASYNC
Definition: xlog.h:25
@ WAL_SYNC_METHOD_FSYNC_WRITETHROUGH
Definition: xlog.h:27
@ WAL_SYNC_METHOD_OPEN_DSYNC
Definition: xlog.h:28
@ WAL_SYNC_METHOD_FSYNC
Definition: xlog.h:24
#define XLogStandbyInfoActive()
Definition: xlog.h:123
#define XLP_FIRST_IS_CONTRECORD
Definition: xlog_internal.h:74
static RmgrData GetRmgr(RmgrId rmid)
#define IsValidWalSegSize(size)
Definition: xlog_internal.h:96
XLogLongPageHeaderData * XLogLongPageHeader
Definition: xlog_internal.h:71
#define XLP_FIRST_IS_OVERWRITE_CONTRECORD
Definition: xlog_internal.h:80
#define XLOG_CONTROL_FILE
#define XLogSegmentOffset(xlogptr, wal_segsz_bytes)
static bool IsXLogFileName(const char *fname)
static void XLogFromFileName(const char *fname, TimeLineID *tli, XLogSegNo *logSegNo, int wal_segsz_bytes)
#define XLByteToPrevSeg(xlrp, logSegNo, wal_segsz_bytes)
#define XLogSegNoOffsetToRecPtr(segno, offset, wal_segsz_bytes, dest)
#define MAXFNAMELEN
XLogPageHeaderData * XLogPageHeader
Definition: xlog_internal.h:54
#define XLOGDIR
#define XLP_LONG_HEADER
Definition: xlog_internal.h:76
static bool IsBackupHistoryFileName(const char *fname)
#define XLP_BKP_REMOVABLE
Definition: xlog_internal.h:78
#define XLOG_PAGE_MAGIC
Definition: xlog_internal.h:34
#define XLByteToSeg(xlrp, logSegNo, wal_segsz_bytes)
static void BackupHistoryFileName(char *fname, TimeLineID tli, XLogSegNo logSegNo, XLogRecPtr startpoint, int wal_segsz_bytes)
static void XLogFilePath(char *path, TimeLineID tli, XLogSegNo logSegNo, int wal_segsz_bytes)
#define XRecOffIsValid(xlrp)
#define SizeOfXLogShortPHD
Definition: xlog_internal.h:52
#define SizeOfXLogLongPHD
Definition: xlog_internal.h:69
static void XLogFileName(char *fname, TimeLineID tli, XLogSegNo logSegNo, int wal_segsz_bytes)
static void BackupHistoryFilePath(char *path, TimeLineID tli, XLogSegNo logSegNo, XLogRecPtr startpoint, int wal_segsz_bytes)
static bool RmgrIdExists(RmgrId rmid)
#define XLByteInPrevSeg(xlrp, logSegNo, wal_segsz_bytes)
static bool IsPartialXLogFileName(const char *fname)
bool XLogArchiveIsReadyOrDone(const char *xlog)
Definition: xlogarchive.c:664
bool XLogArchiveIsBusy(const char *xlog)
Definition: xlogarchive.c:619
bool XLogArchiveIsReady(const char *xlog)
Definition: xlogarchive.c:694
void XLogArchiveNotifySeg(XLogSegNo segno, TimeLineID tli)
Definition: xlogarchive.c:492
void ExecuteRecoveryCommand(const char *command, const char *commandName, bool failOnSignal, uint32 wait_event_info)
Definition: xlogarchive.c:295
bool XLogArchiveCheckDone(const char *xlog)
Definition: xlogarchive.c:565
void XLogArchiveNotify(const char *xlog)
Definition: xlogarchive.c:444
void XLogArchiveCleanup(const char *xlog)
Definition: xlogarchive.c:712
char * build_backup_content(BackupState *state, bool ishistoryfile)
Definition: xlogbackup.c:29
#define LSN_FORMAT_ARGS(lsn)
Definition: xlogdefs.h:46
#define FirstNormalUnloggedLSN
Definition: xlogdefs.h:36
#define XLogRecPtrIsInvalid(r)
Definition: xlogdefs.h:29
uint64 XLogRecPtr
Definition: xlogdefs.h:21
#define InvalidXLogRecPtr
Definition: xlogdefs.h:28
uint32 TimeLineID
Definition: xlogdefs.h:62
#define DEFAULT_WAL_SYNC_METHOD
Definition: xlogdefs.h:82
uint64 XLogSegNo
Definition: xlogdefs.h:51
XLogRecPtr XLogInsert(RmgrId rmid, uint8 info)
Definition: xloginsert.c:474
void XLogRegisterData(const void *data, uint32 len)
Definition: xloginsert.c:364
void XLogSetRecordFlags(uint8 flags)
Definition: xloginsert.c:456
void XLogBeginInsert(void)
Definition: xloginsert.c:149
XLogReaderState * XLogReaderAllocate(int wal_segment_size, const char *waldir, XLogReaderRoutine *routine, void *private_data)
Definition: xlogreader.c:107
bool DecodeXLogRecord(XLogReaderState *state, DecodedXLogRecord *decoded, XLogRecord *record, XLogRecPtr lsn, char **errormsg)
Definition: xlogreader.c:1682
size_t DecodeXLogRecordRequiredSpace(size_t xl_tot_len)
Definition: xlogreader.c:1649
#define XLogRecGetInfo(decoder)
Definition: xlogreader.h:410
#define XLogRecGetData(decoder)
Definition: xlogreader.h:415
#define XL_ROUTINE(...)
Definition: xlogreader.h:117
#define XLogRecMaxBlockId(decoder)
Definition: xlogreader.h:418
#define XLogRecHasBlockImage(decoder, block_id)
Definition: xlogreader.h:423
#define XLogRecHasAnyBlockRefs(decoder)
Definition: xlogreader.h:417
#define SizeOfXLogRecordDataHeaderShort
Definition: xlogrecord.h:217
#define XLR_BLOCK_ID_DATA_SHORT
Definition: xlogrecord.h:241
#define XLR_INFO_MASK
Definition: xlogrecord.h:62
#define SizeOfXLogRecord
Definition: xlogrecord.h:55
void ShutdownWalRecovery(void)
bool ArchiveRecoveryRequested
Definition: xlogrecovery.c:139
bool InArchiveRecovery
Definition: xlogrecovery.c:140
void RecoveryRequiresIntParameter(const char *param_name, int currValue, int minValue)
void PerformWalRecovery(void)
char * archiveCleanupCommand
Definition: xlogrecovery.c:86
XLogRecPtr GetCurrentReplayRecPtr(TimeLineID *replayEndTLI)
void xlog_outdesc(StringInfo buf, XLogReaderState *record)
bool PromoteIsTriggered(void)
static XLogRecPtr missingContrecPtr
Definition: xlogrecovery.c:380
XLogRecPtr GetXLogReplayRecPtr(TimeLineID *replayTLI)
static XLogRecPtr abortedRecPtr
Definition: xlogrecovery.c:379
EndOfWalRecoveryInfo * FinishWalRecovery(void)
void InitWalRecovery(ControlFileData *ControlFile, bool *wasShutdown_ptr, bool *haveBackupLabel_ptr, bool *haveTblspcMap_ptr)
Definition: xlogrecovery.c:519
char * recoveryEndCommand
Definition: xlogrecovery.c:85
TimeLineID recoveryTargetTLI
Definition: xlogrecovery.c:124
TimestampTz GetLatestXTime(void)
bool XLogHaveInvalidPages(void)
Definition: xlogutils.c:224
XLogRedoAction XLogReadBufferForRedo(XLogReaderState *record, uint8 block_id, Buffer *buf)
Definition: xlogutils.c:303
HotStandbyState standbyState
Definition: xlogutils.c:53
bool InRecovery
Definition: xlogutils.c:50
@ STANDBY_DISABLED
Definition: xlogutils.h:52
@ STANDBY_INITIALIZED
Definition: xlogutils.h:53
#define InHotStandby
Definition: xlogutils.h:60
@ BLK_RESTORED
Definition: xlogutils.h:76