Debian Codegraph @

src/backend/access/transam/xlog.c

raw
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"
59 #include "access/xlog_internal.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"
69 #include "common/controldata_utils.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"
78 #include "postmaster/walsummarizer.h"
79 #include "postmaster/walwriter.h"
80 #include "replication/origin.h"
81 #include "replication/slot.h"
82 #include "replication/snapbuild.h"
83 #include "replication/walreceiver.h"
84 #include "replication/walsender.h"
85 #include "storage/bufmgr.h"
86 #include "storage/fd.h"
87 #include "storage/ipc.h"
88 #include "storage/large_object.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"
98 #include "utils/injection_point.h"
99 #include "utils/pgstat_internal.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 */
115 int max_wal_size_mb = 1024; /* 1 GB */
116 int min_wal_size_mb = 80; /* 80 MB */
117 int wal_keep_size_mb = 0;
118 int XLOGbuffers = -1;
119 int XLogArchiveTimeout = 0;
120 int XLogArchiveMode = ARCHIVE_MODE_OFF;
121 char *XLogArchiveCommand = NULL;
122 bool EnableHotStandby = false;
123 bool fullPageWrites = true;
124 bool wal_log_hints = false;
125 int wal_compression = WAL_COMPRESSION_NONE;
126 char *wal_consistency_checking_string = NULL;
127 bool *wal_consistency_checking = NULL;
128 bool wal_init_zero = true;
129 bool wal_recycle = true;
130 bool log_checkpoints = true;
131 int wal_sync_method = DEFAULT_WAL_SYNC_METHOD;
132 int wal_level = WAL_LEVEL_REPLICA;
133 int CommitDelay = 0; /* precommit delay in microseconds */
134 int CommitSiblings = 5; /* # concurrent xacts needed to sleep */
135 int wal_retrieve_retry_interval = 5000;
136 int max_slot_wal_keep_size_mb = -1;
137 int wal_decode_buffer_size = 512 * 1024;
138 bool track_wal_io_timing = false;
139
140 #ifdef WAL_DEBUG
141 bool XLOG_DEBUG = false;
142 #endif
143
144 int wal_segment_size = DEFAULT_XLOG_SEG_SIZE;
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 */
157 int CheckPointSegments;
158
159 /* Estimated distance between checkpoints, in bytes */
160 static double CheckPointDistanceEstimate = 0;
161 static double PrevCheckPointDistance = 0;
162
163 /*
164 * Track whether there were any deferred checks for custom resource managers
165 * specified in wal_consistency_checking.
166 */
167 static bool check_wal_consistency_checking_deferred = false;
168
169 /*
170 * GUC support
171 */
172 const struct config_enum_entry wal_sync_method_options[] = {
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 */
192 const struct config_enum_entry archive_mode_options[] = {
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 */
210 CheckpointStatsData CheckpointStats;
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 */
218 static bool lastFullPageWrites;
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 */
225 static 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 */
237 static int LocalXLogInsertAllowed = -1;
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 */
254 XLogRecPtr ProcLastRecPtr = InvalidXLogRecPtr;
255 XLogRecPtr XactLastRecEnd = InvalidXLogRecPtr;
256 XLogRecPtr XactLastCommitEnd = InvalidXLogRecPtr;
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 */
274 static XLogRecPtr RedoRecPtr;
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 */
287 static 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
320 typedef struct XLogwrtRqst
321 {
322 XLogRecPtr Write; /* last byte + 1 to write out */
323 XLogRecPtr Flush; /* last byte + 1 to flush */
324 } XLogwrtRqst;
325
326 typedef struct XLogwrtResult
327 {
328 XLogRecPtr Write; /* last byte + 1 written out */
329 XLogRecPtr Flush; /* last byte + 1 flushed */
330 } XLogwrtResult;
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 */
368 typedef struct
369 {
370 LWLock lock;
371 pg_atomic_uint64 insertingAt;
372 XLogRecPtr lastImportantAt;
373 } WALInsertLock;
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 */
382 typedef union WALInsertLockPadded
383 {
384 WALInsertLock l;
385 char pad[PG_CACHE_LINE_SIZE];
386 } WALInsertLockPadded;
387
388 /*
389 * Session status of running backup, used for sanity checks in SQL-callable
390 * functions to start and stop backups.
391 */
392 static SessionBackupState sessionBackupState = SESSION_BACKUP_NONE;
393
394 /*
395 * Shared state data for WAL insertion.
396 */
397 typedef 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 */
408 uint64 CurrBytePos;
409 uint64 PrevBytePos;
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 */
418 char pad[PG_CACHE_LINE_SIZE];
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 */
432 bool fullPageWrites;
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 */
439 int runningBackups;
440 XLogRecPtr lastBackupStart;
441
442 /*
443 * WAL insertion locks.
444 */
445 WALInsertLockPadded *WALInsertLocks;
446 } XLogCtlInsert;
447
448 /*
449 * Total shared-memory state for XLOG.
450 */
451 typedef struct XLogCtlData
452 {
453 XLogCtlInsert Insert;
454
455 /* Protected by info_lck: */
456 XLogwrtRqst LogwrtRqst;
457 XLogRecPtr RedoRecPtr; /* a recent copy of Insert->RedoRecPtr */
458 FullTransactionId ckptFullXid; /* nextXid of latest checkpoint */
459 XLogRecPtr asyncXactLSN; /* LSN of newest async commit/abort */
460 XLogRecPtr replicationSlotMinLSN; /* oldest LSN needed by any slot */
461
462 XLogSegNo lastRemovedSegNo; /* latest removed/recycled XLOG segment */
463
464 /* Fake LSN counter, for unlogged relations. */
465 pg_atomic_uint64 unloggedLSN;
466
467 /* Time and LSN of last xlog segment switch. Protected by WALWriteLock. */
468 pg_time_t lastSegSwitchTime;
469 XLogRecPtr lastSegSwitchLSN;
470
471 /* These are accessed using atomics -- info_lck not needed */
472 pg_atomic_uint64 logInsertResult; /* last byte + 1 inserted to buffers */
473 pg_atomic_uint64 logWriteResult; /* last byte + 1 written out */
474 pg_atomic_uint64 logFlushResult; /* last byte + 1 flushed */
475
476 /*
477 * Latest initialized page in the cache (last byte position + 1).
478 *
479 * To change the identity of a buffer (and InitializedUpTo), you need to
480 * hold WALBufMappingLock. To change the identity of a buffer that's
481 * still dirty, the old page needs to be written out first, and for that
482 * you need WALWriteLock, and you need to ensure that there are no
483 * in-progress insertions to the page by calling
484 * WaitXLogInsertionsToFinish().
485 */
486 XLogRecPtr InitializedUpTo;
487
488 /*
489 * These values do not change after startup, although the pointed-to pages
490 * and xlblocks values certainly do. xlblocks values are protected by
491 * WALBufMappingLock.
492 */
493 char *pages; /* buffers for unwritten XLOG pages */
494 pg_atomic_uint64 *xlblocks; /* 1st byte ptr-s + XLOG_BLCKSZ */
495 int XLogCacheBlck; /* highest allocated xlog buffer index */
496
497 /*
498 * InsertTimeLineID is the timeline into which new WAL is being inserted
499 * and flushed. It is zero during recovery, and does not change once set.
500 *
501 * If we create a new timeline when the system was started up,
502 * PrevTimeLineID is the old timeline's ID that we forked off from.
503 * Otherwise it's equal to InsertTimeLineID.
504 *
505 * We set these fields while holding info_lck. Most that reads these
506 * values knows that recovery is no longer in progress and so can safely
507 * read the value without a lock, but code that could be run either during
508 * or after recovery can take info_lck while reading these values.
509 */
510 TimeLineID InsertTimeLineID;
511 TimeLineID PrevTimeLineID;
512
513 /*
514 * SharedRecoveryState indicates if we're still in crash or archive
515 * recovery. Protected by info_lck.
516 */
517 RecoveryState SharedRecoveryState;
518
519 /*
520 * InstallXLogFileSegmentActive indicates whether the checkpointer should
521 * arrange for future segments by recycling and/or PreallocXlogFiles().
522 * Protected by ControlFileLock. Only the startup process changes it. If
523 * true, anyone can use InstallXLogFileSegment(). If false, the startup
524 * process owns the exclusive right to install segments, by reading from
525 * the archive and possibly replacing existing files.
526 */
527 bool InstallXLogFileSegmentActive;
528
529 /*
530 * WalWriterSleeping indicates whether the WAL writer is currently in
531 * low-power mode (and hence should be nudged if an async commit occurs).
532 * Protected by info_lck.
533 */
534 bool WalWriterSleeping;
535
536 /*
537 * During recovery, we keep a copy of the latest checkpoint record here.
538 * lastCheckPointRecPtr points to start of checkpoint record and
539 * lastCheckPointEndPtr points to end+1 of checkpoint record. Used by the
540 * checkpointer when it wants to create a restartpoint.
541 *
542 * Protected by info_lck.
543 */
544 XLogRecPtr lastCheckPointRecPtr;
545 XLogRecPtr lastCheckPointEndPtr;
546 CheckPoint lastCheckPoint;
547
548 /*
549 * lastFpwDisableRecPtr points to the start of the last replayed
550 * XLOG_FPW_CHANGE record that instructs full_page_writes is disabled.
551 */
552 XLogRecPtr lastFpwDisableRecPtr;
553
554 slock_t info_lck; /* locks shared variables shown above */
555 } XLogCtlData;
556
557 /*
558 * Classification of XLogInsertRecord operations.
559 */
560 typedef enum
561 {
562 WALINSERT_NORMAL,
563 WALINSERT_SPECIAL_SWITCH,
564 WALINSERT_SPECIAL_CHECKPOINT
565 } WalInsertClass;
566
567 static XLogCtlData *XLogCtl = NULL;
568
569 /* a private copy of XLogCtl->Insert.WALInsertLocks, for convenience */
570 static WALInsertLockPadded *WALInsertLocks = NULL;
571
572 /*
573 * We maintain an image of pg_control in shared memory.
574 */
575 static ControlFileData *ControlFile = NULL;
576
577 /*
578 * Calculate the amount of space left on the page after 'endptr'. Beware
579 * multiple evaluation!
580 */
581 #define INSERT_FREESPACE(endptr) \
582 (((endptr) % XLOG_BLCKSZ == 0) ? 0 : (XLOG_BLCKSZ - (endptr) % XLOG_BLCKSZ))
583
584 /* Macro to advance to next buffer index. */
585 #define NextBufIdx(idx) \
586 (((idx) == XLogCtl->XLogCacheBlck) ? 0 : ((idx) + 1))
587
588 /*
589 * XLogRecPtrToBufIdx returns the index of the WAL buffer that holds, or
590 * would hold if it was in cache, the page containing 'recptr'.
591 */
592 #define XLogRecPtrToBufIdx(recptr) \
593 (((recptr) / XLOG_BLCKSZ) % (XLogCtl->XLogCacheBlck + 1))
594
595 /*
596 * These are the number of bytes in a WAL page usable for WAL data.
597 */
598 #define UsableBytesInPage (XLOG_BLCKSZ - SizeOfXLogShortPHD)
599
600 /*
601 * Convert values of GUCs measured in megabytes to equiv. segment count.
602 * Rounds down.
603 */
604 #define ConvertToXSegs(x, segsize) XLogMBVarToSegs((x), (segsize))
605
606 /* The number of bytes in a WAL segment usable for WAL data. */
607 static int UsableBytesInSegment;
608
609 /*
610 * Private, possibly out-of-date copy of shared LogwrtResult.
611 * See discussion above.
612 */
613 static XLogwrtResult LogwrtResult = {0, 0};
614
615 /*
616 * Update local copy of shared XLogCtl->log{Write,Flush}Result
617 *
618 * It's critical that Flush always trails Write, so the order of the reads is
619 * important, as is the barrier. See also XLogWrite.
620 */
621 #define RefreshXLogWriteResult(_target) \
622 do { \
623 _target.Flush = pg_atomic_read_u64(&XLogCtl->logFlushResult); \
624 pg_read_barrier(); \
625 _target.Write = pg_atomic_read_u64(&XLogCtl->logWriteResult); \
626 } while (0)
627
628 /*
629 * openLogFile is -1 or a kernel FD for an open log file segment.
630 * openLogSegNo identifies the segment, and openLogTLI the corresponding TLI.
631 * These variables are only used to write the XLOG, and so will normally refer
632 * to the active segment.
633 *
634 * Note: call Reserve/ReleaseExternalFD to track consumption of this FD.
635 */
636 static int openLogFile = -1;
637 static XLogSegNo openLogSegNo = 0;
638 static TimeLineID openLogTLI = 0;
639
640 /*
641 * Local copies of equivalent fields in the control file. When running
642 * crash recovery, LocalMinRecoveryPoint is set to InvalidXLogRecPtr as we
643 * expect to replay all the WAL available, and updateMinRecoveryPoint is
644 * switched to false to prevent any updates while replaying records.
645 * Those values are kept consistent as long as crash recovery runs.
646 */
647 static XLogRecPtr LocalMinRecoveryPoint;
648 static TimeLineID LocalMinRecoveryPointTLI;
649 static bool updateMinRecoveryPoint = true;
650
651 /* For WALInsertLockAcquire/Release functions */
652 static int MyLockNo = 0;
653 static bool holdingAllLocks = false;
654
655 #ifdef WAL_DEBUG
656 static MemoryContext walDebugCxt = NULL;
657 #endif
658
659 static void CleanupAfterArchiveRecovery(TimeLineID EndOfLogTLI,
660 XLogRecPtr EndOfLog,
661 TimeLineID newTLI);
662 static void CheckRequiredParameterValues(void);
663 static void XLogReportParameters(void);
664 static int LocalSetXLogInsertAllowed(void);
665 static void CreateEndOfRecoveryRecord(void);
666 static XLogRecPtr CreateOverwriteContrecordRecord(XLogRecPtr aborted_lsn,
667 XLogRecPtr pagePtr,
668 TimeLineID newTLI);
669 static void CheckPointGuts(XLogRecPtr checkPointRedo, int flags);
670 static void KeepLogSeg(XLogRecPtr recptr, XLogSegNo *logSegNo);
671
672 static void AdvanceXLInsertBuffer(XLogRecPtr upto, TimeLineID tli,
673 bool opportunistic);
674 static void XLogWrite(XLogwrtRqst WriteRqst, TimeLineID tli, bool flexible);
675 static bool InstallXLogFileSegment(XLogSegNo *segno, char *tmppath,
676 bool find_free, XLogSegNo max_segno,
677 TimeLineID tli);
678 static void XLogFileClose(void);
679 static void PreallocXlogFiles(XLogRecPtr endptr, TimeLineID tli);
680 static void RemoveTempXlogFiles(void);
681 static void RemoveOldXlogFiles(XLogSegNo segno, XLogRecPtr lastredoptr,
682 XLogRecPtr endptr, TimeLineID insertTLI);
683 static void RemoveXlogFile(const struct dirent *segment_de,
684 XLogSegNo recycleSegNo, XLogSegNo *endlogSegNo,
685 TimeLineID insertTLI);
686 static void UpdateLastRemovedPtr(char *filename);
687 static void ValidateXLOGDirectoryStructure(void);
688 static void CleanupBackupHistory(void);
689 static void UpdateMinRecoveryPoint(XLogRecPtr lsn, bool force);
690 static bool PerformRecoveryXLogAction(void);
691 static void InitControlFile(uint64 sysidentifier, uint32 data_checksum_version);
692 static void WriteControlFile(void);
693 static void ReadControlFile(void);
694 static void UpdateControlFile(void);
695 static char *str_time(pg_time_t tnow);
696
697 static int get_sync_bit(int method);
698
699 static void CopyXLogRecordToWAL(int write_len, bool isLogSwitch,
700 XLogRecData *rdata,
701 XLogRecPtr StartPos, XLogRecPtr EndPos,
702 TimeLineID tli);
703 static void ReserveXLogInsertLocation(int size, XLogRecPtr *StartPos,
704 XLogRecPtr *EndPos, XLogRecPtr *PrevPtr);
705 static bool ReserveXLogSwitch(XLogRecPtr *StartPos, XLogRecPtr *EndPos,
706 XLogRecPtr *PrevPtr);
707 static XLogRecPtr WaitXLogInsertionsToFinish(XLogRecPtr upto);
708 static char *GetXLogBuffer(XLogRecPtr ptr, TimeLineID tli);
709 static XLogRecPtr XLogBytePosToRecPtr(uint64 bytepos);
710 static XLogRecPtr XLogBytePosToEndRecPtr(uint64 bytepos);
711 static uint64 XLogRecPtrToBytePos(XLogRecPtr ptr);
712
713 static void WALInsertLockAcquire(void);
714 static void WALInsertLockAcquireExclusive(void);
715 static void WALInsertLockRelease(void);
716 static 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 */
747 XLogRecPtr
748 XLogInsertRecord(XLogRecData *rdata,
749 XLogRecPtr fpw_lsn,
750 uint8 flags,
751 int num_fpi,
752 bool topxid_included)
753 {
754 XLogCtlInsert *Insert = &XLogCtl->Insert;
755 pg_crc32c rdata_crc;
756 bool inserted;
757 XLogRecord *rechdr = (XLogRecord *) rdata->data;
758 uint8 info = rechdr->xl_info & ~XLR_INFO_MASK;
759 WalInsertClass class = WALINSERT_NORMAL;
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)
769 class = WALINSERT_SPECIAL_SWITCH;
770 else if (info == XLOG_CHECKPOINT_REDO)
771 class = WALINSERT_SPECIAL_CHECKPOINT;
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 */
819 START_CRIT_SECTION();
820
821 if (likely(class == WALINSERT_NORMAL))
822 {
823 WALInsertLockAcquire();
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 */
856 WALInsertLockRelease();
857 END_CRIT_SECTION();
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);
885 WALInsertLockAcquireExclusive();
886 inserted = ReserveXLogSwitch(&StartPos, &EndPos, &rechdr->xl_prev);
887 }
888 else
889 {
890 Assert(class == WALINSERT_SPECIAL_CHECKPOINT);
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);
900 WALInsertLockAcquireExclusive();
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 */
922 CopyXLogRecordToWAL(rechdr->xl_tot_len,
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 */
950 WALInsertLockRelease();
951
952 END_CRIT_SECTION();
953
954 MarkCurrentTransactionIdLoggedIfAny();
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)
961 MarkSubxactTopXidLogged();
962
963 /*
964 * Update shared LogwrtRqst.Write, if we crossed page boundary.
965 */
966 if (StartPos / XLOG_BLCKSZ != EndPos / XLOG_BLCKSZ)
967 {
968 SpinLockAcquire(&XLogCtl->info_lck);
969 /* advance global request to include new block(s) */
970 if (XLogCtl->LogwrtRqst.Write < EndPos)
971 XLogCtl->LogwrtRqst.Write = EndPos;
972 SpinLockRelease(&XLogCtl->info_lck);
973 RefreshXLogWriteResult(LogwrtResult);
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;
1012 StringInfoData buf;
1013 StringInfoData recordBuf;
1014 char *errormsg = NULL;
1015 MemoryContext oldCxt;
1016
1017 oldCxt = MemoryContextSwitchTo(walDebugCxt);
1018
1019 initStringInfo(&buf);
1020 appendStringInfo(&buf, "INSERT @ %X/%X: ", LSN_FORMAT_ARGS(EndPos));
1021
1022 /*
1023 * We have to piece together the WAL record data from the XLogRecData
1024 * entries, so that we can pass it to the rm_desc function as one
1025 * contiguous chunk.
1026 */
1027 initStringInfo(&recordBuf);
1028 for (; rdata != NULL; rdata = rdata->next)
1029 appendBinaryStringInfo(&recordBuf, rdata->data, rdata->len);
1030
1031 /* We also need temporary space to decode the record. */
1032 record = (XLogRecord *) recordBuf.data;
1033 decoded = (DecodedXLogRecord *)
1034 palloc(DecodeXLogRecordRequiredSpace(record->xl_tot_len));
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;
1082 pgWalUsage.wal_records++;
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_always_inline here to try to convince it.
1109 */
1110 static pg_always_inline void
1111 ReserveXLogInsertLocation(int size, XLogRecPtr *StartPos, XLogRecPtr *EndPos,
1112 XLogRecPtr *PrevPtr)
1113 {
1114 XLogCtlInsert *Insert = &XLogCtl->Insert;
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 */
1166 static bool
1167 ReserveXLogSwitch(XLogRecPtr *StartPos, XLogRecPtr *EndPos, XLogRecPtr *PrevPtr)
1168 {
1169 XLogCtlInsert *Insert = &XLogCtl->Insert;
1170 uint64 startbytepos;
1171 uint64 endbytepos;
1172 uint64 prevbytepos;
1173 uint32 size = MAXALIGN(SizeOfXLogRecord);
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
1201 segleft = wal_segment_size - XLogSegmentOffset(*EndPos, wal_segment_size);
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
1215 Assert(XLogSegmentOffset(*EndPos, wal_segment_size) == 0);
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 */
1227 static void
1228 CopyXLogRecordToWAL(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;
1282 pagehdr->xlp_info |= XLP_FIRST_IS_CONTRECORD;
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 */
1320 Assert(XLogSegmentOffset(EndPos, wal_segment_size) == 0);
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,
1366 errcode(ERRCODE_DATA_CORRUPTED),
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 */
1373 static void
1374 WALInsertLockAcquire(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 */
1399 immed = LWLockAcquire(&WALInsertLocks[MyLockNo].l.lock, LW_EXCLUSIVE);
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 */
1418 static void
1419 WALInsertLockAcquireExclusive(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 {
1430 LWLockAcquire(&WALInsertLocks[i].l.lock, LW_EXCLUSIVE);
1431 LWLockUpdateVar(&WALInsertLocks[i].l.lock,
1432 &WALInsertLocks[i].l.insertingAt,
1433 PG_UINT64_MAX);
1434 }
1435 /* Variable value reset to 0 at release */
1436 LWLockAcquire(&WALInsertLocks[i].l.lock, LW_EXCLUSIVE);
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 */
1447 static void
1448 WALInsertLockRelease(void)
1449 {
1450 if (holdingAllLocks)
1451 {
1452 int i;
1453
1454 for (i = 0; i < NUM_XLOGINSERT_LOCKS; i++)
1455 LWLockReleaseClearVar(&WALInsertLocks[i].l.lock,
1456 &WALInsertLocks[i].l.insertingAt,
1457 0);
1458
1459 holdingAllLocks = false;
1460 }
1461 else
1462 {
1463 LWLockReleaseClearVar(&WALInsertLocks[MyLockNo].l.lock,
1464 &WALInsertLocks[MyLockNo].l.insertingAt,
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 */
1473 static void
1474 WALInsertLockUpdateInsertingAt(XLogRecPtr insertingAt)
1475 {
1476 if (holdingAllLocks)
1477 {
1478 /*
1479 * We use the last lock to mark our actual position, see comments in
1480 * WALInsertLockAcquireExclusive.
1481 */
1482 LWLockUpdateVar(&WALInsertLocks[NUM_XLOGINSERT_LOCKS - 1].l.lock,
1483 &WALInsertLocks[NUM_XLOGINSERT_LOCKS - 1].l.insertingAt,
1484 insertingAt);
1485 }
1486 else
1487 LWLockUpdateVar(&WALInsertLocks[MyLockNo].l.lock,
1488 &WALInsertLocks[MyLockNo].l.insertingAt,
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 */
1506 static XLogRecPtr
1507 WaitXLogInsertionsToFinish(XLogRecPtr upto)
1508 {
1509 uint64 bytepos;
1510 XLogRecPtr inserted;
1511 XLogRecPtr reservedUpto;
1512 XLogRecPtr finishedUpto;
1513 XLogCtlInsert *Insert = &XLogCtl->Insert;
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 */
1523 inserted = pg_atomic_read_membarrier_u64(&XLogCtl->logInsertResult);
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/%X, current position %X/%X",
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,
1589 &WALInsertLocks[i].l.insertingAt,
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 */
1612 finishedUpto = pg_atomic_monotonic_advance_u64(&XLogCtl->logInsertResult,
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 */
1634 static char *
1635 GetXLogBuffer(XLogRecPtr ptr, TimeLineID tli)
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
1677 endptr = pg_atomic_read_u64(&XLogCtl->xlblocks[idx]);
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);
1708 endptr = pg_atomic_read_u64(&XLogCtl->xlblocks[idx]);
1709
1710 if (expectedEndPtr != endptr)
1711 elog(PANIC, "could not find WAL buffer for %X/%X",
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 */
1720 pg_memory_barrier();
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 */
1750 Size
1751 WALReadFromBuffers(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
1759 if (RecoveryInProgress() || tli != GetWALInsertionTimeLine())
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 */
1768 inserted = pg_atomic_read_u64(&XLogCtl->logInsertResult);
1769 if (startptr + count > inserted)
1770 ereport(ERROR,
1771 errmsg("cannot read past end of generated WAL: requested %X/%X, current position %X/%X",
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 */
1809 endptr = pg_atomic_read_u64(&XLogCtl->xlblocks[idx]);
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 */
1826 pg_read_barrier();
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 */
1835 pg_read_barrier();
1836
1837 /*
1838 * Second verification step: check that the page we read from wasn't
1839 * evicted while we were copying the data.
1840 */
1841 endptr = pg_atomic_read_u64(&XLogCtl->xlblocks[idx]);
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 */
1860 static XLogRecPtr
1861 XLogBytePosToRecPtr(uint64 bytepos)
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 */
1900 static XLogRecPtr
1901 XLogBytePosToEndRecPtr(uint64 bytepos)
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 */
1943 static uint64
1944 XLogRecPtrToBytePos(XLogRecPtr ptr)
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 */
1987 static void
1988 AdvanceXLInsertBuffer(XLogRecPtr upto, TimeLineID tli, bool opportunistic)
1989 {
1990 XLogCtlInsert *Insert = &XLogCtl->Insert;
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 {
2007 nextidx = XLogRecPtrToBufIdx(XLogCtl->InitializedUpTo);
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 */
2025 SpinLockAcquire(&XLogCtl->info_lck);
2026 if (XLogCtl->LogwrtRqst.Write < OldPageRqstPtr)
2027 XLogCtl->LogwrtRqst.Write = OldPageRqstPtr;
2028 SpinLockRelease(&XLogCtl->info_lck);
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 */
2034 RefreshXLogWriteResult(LogwrtResult);
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
2049 RefreshXLogWriteResult(LogwrtResult);
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);
2063 pgWalUsage.wal_buffers_full++;
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 */
2094 pg_atomic_write_u64(&XLogCtl->xlblocks[nextidx], InvalidXLogRecPtr);
2095 pg_write_barrier();
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 */
2148 pg_write_barrier();
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/%X",
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 */
2170 static void
2171 CalculateCheckpointSegments(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) /
2190 (1.0 + CheckPointCompletionTarget);
2191
2192 /* round down */
2193 CheckPointSegments = (int) target;
2194
2195 if (CheckPointSegments < 1)
2196 CheckPointSegments = 1;
2197 }
2198
2199 void
2200 assign_max_wal_size(int newval, void *extra)
2201 {
2202 max_wal_size_mb = newval;
2203 CalculateCheckpointSegments();
2204 }
2205
2206 void
2207 assign_checkpoint_completion_target(double newval, void *extra)
2208 {
2209 CheckPointCompletionTarget = newval;
2210 CalculateCheckpointSegments();
2211 }
2212
2213 bool
2214 check_wal_segment_size(int *newval, void **extra, GucSource source)
2215 {
2216 if (!IsValidWalSegSize(*newval))
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 */
2229 static XLogSegNo
2230 XLOGfileslop(XLogRecPtr lastredoptr)
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 +
2243 ConvertToXSegs(min_wal_size_mb, wal_segment_size) - 1;
2244 maxSegNo = lastredoptr / wal_segment_size +
2245 ConvertToXSegs(max_wal_size_mb, wal_segment_size) - 1;
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 */
2255 distance = (1.0 + CheckPointCompletionTarget) * CheckPointDistanceEstimate;
2256 /* add 10% for good measure. */
2257 distance *= 1.10;
2258
2259 recycleSegNo = (XLogSegNo) ceil(((double) lastredoptr + distance) /
2260 wal_segment_size);
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 */
2279 bool
2280 XLogCheckpointNeeded(XLogSegNo new_segno)
2281 {
2282 XLogSegNo old_segno;
2283
2284 XLByteToSeg(RedoRecPtr, old_segno, wal_segment_size);
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 */
2303 static void
2304 XLogWrite(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 */
2315 Assert(CritSectionCount > 0);
2316
2317 /*
2318 * Update local LogwrtResult (caller probably did this already, but...)
2319 */
2320 RefreshXLogWriteResult(LogwrtResult);
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 */
2340 curridx = XLogRecPtrToBufIdx(LogwrtResult.Write);
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/%X is past end of log %X/%X",
2353 LSN_FORMAT_ARGS(LogwrtResult.Write),
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
2360 if (!XLByteInPrevSeg(LogwrtResult.Write, openLogSegNo,
2361 wal_segment_size))
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();
2370 XLByteToPrevSeg(LogwrtResult.Write, openLogSegNo,
2371 wal_segment_size);
2372 openLogTLI = tli;
2373
2374 /* create/use new log file */
2375 openLogFile = XLogFileInit(openLogSegNo, tli);
2376 ReserveExternalFD();
2377 }
2378
2379 /* Make sure we have the current logfile open */
2380 if (openLogFile < 0)
2381 {
2382 XLByteToPrevSeg(LogwrtResult.Write, openLogSegNo,
2383 wal_segment_size);
2384 openLogTLI = tli;
2385 openLogFile = XLogFileOpen(openLogSegNo, tli);
2386 ReserveExternalFD();
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,
2395 wal_segment_size);
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;
2418 instr_time start;
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 */
2431 start = pgstat_prepare_io_time(track_wal_io_timing);
2432
2433 pgstat_report_wait_start(WAIT_EVENT_WAL_WRITE);
2434 written = pg_pwrite(openLogFile, from, nleft, startoffset);
2435 pgstat_report_wait_end();
2436
2437 if (written <= 0)
2438 {
2439 char xlogfname[MAXFNAMELEN];
2440 int save_errno;
2441
2442 if (errno == EINTR)
2443 continue;
2444
2445 save_errno = errno;
2446 XLogFileName(xlogfname, tli, openLogSegNo,
2447 wal_segment_size);
2448 errno = save_errno;
2449 ereport(PANIC,
2450 (errcode_for_file_access(),
2451 errmsg("could not write to log file \"%s\" at offset %u, length %zu: %m",
2452 xlogfname, startoffset, nleft)));
2453 }
2454
2455 pgstat_count_io_op_time(IOOBJECT_WAL, IOCONTEXT_NORMAL,
2456 IOOP_WRITE, start, 1, written);
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 {
2479 issue_xlog_fsync(openLogFile, openLogSegNo, tli);
2480
2481 /* signal that we need to wakeup walsenders later */
2482 WalSndWakeupRequest();
2483
2484 LogwrtResult.Flush = LogwrtResult.Write; /* end of page */
2485
2486 if (XLogArchivingActive())
2487 XLogArchiveNotifySeg(openLogSegNo, tli);
2488
2489 XLogCtl->lastSegSwitchTime = (pg_time_t) time(NULL);
2490 XLogCtl->lastSegSwitchLSN = LogwrtResult.Flush;
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 */
2499 if (IsUnderPostmaster && XLogCheckpointNeeded(openLogSegNo))
2500 {
2501 (void) GetRedoRecPtr();
2502 if (XLogCheckpointNeeded(openLogSegNo))
2503 RequestCheckpoint(CHECKPOINT_CAUSE_XLOG);
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 &&
2527 LogwrtResult.Flush < LogwrtResult.Write)
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 */
2534 if (wal_sync_method != WAL_SYNC_METHOD_OPEN &&
2535 wal_sync_method != WAL_SYNC_METHOD_OPEN_DSYNC)
2536 {
2537 if (openLogFile >= 0 &&
2538 !XLByteInPrevSeg(LogwrtResult.Write, openLogSegNo,
2539 wal_segment_size))
2540 XLogFileClose();
2541 if (openLogFile < 0)
2542 {
2543 XLByteToPrevSeg(LogwrtResult.Write, openLogSegNo,
2544 wal_segment_size);
2545 openLogTLI = tli;
2546 openLogFile = XLogFileOpen(openLogSegNo, tli);
2547 ReserveExternalFD();
2548 }
2549
2550 issue_xlog_fsync(openLogFile, openLogSegNo, tli);
2551 }
2552
2553 /* signal that we need to wakeup walsenders later */
2554 WalSndWakeupRequest();
2555
2556 LogwrtResult.Flush = LogwrtResult.Write;
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 */
2566 SpinLockAcquire(&XLogCtl->info_lck);
2567 if (XLogCtl->LogwrtRqst.Write < LogwrtResult.Write)
2568 XLogCtl->LogwrtRqst.Write = LogwrtResult.Write;
2569 if (XLogCtl->LogwrtRqst.Flush < LogwrtResult.Flush)
2570 XLogCtl->LogwrtRqst.Flush = LogwrtResult.Flush;
2571 SpinLockRelease(&XLogCtl->info_lck);
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 */
2578 pg_atomic_write_u64(&XLogCtl->logWriteResult, LogwrtResult.Write);
2579 pg_write_barrier();
2580 pg_atomic_write_u64(&XLogCtl->logFlushResult, LogwrtResult.Flush);
2581
2582 #ifdef USE_ASSERT_CHECKING
2583 {
2584 XLogRecPtr Flush;
2585 XLogRecPtr Write;
2586 XLogRecPtr Insert;
2587
2588 Flush = pg_atomic_read_u64(&XLogCtl->logFlushResult);
2589 pg_read_barrier();
2590 Write = pg_atomic_read_u64(&XLogCtl->logWriteResult);
2591 pg_read_barrier();
2592 Insert = pg_atomic_read_u64(&XLogCtl->logInsertResult);
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 */
2608 void
2609 XLogSetAsyncXactLSN(XLogRecPtr asyncXactLSN)
2610 {
2611 XLogRecPtr WriteRqstPtr = asyncXactLSN;
2612 bool sleeping;
2613 bool wakeup = false;
2614 XLogRecPtr prevAsyncXactLSN;
2615
2616 SpinLockAcquire(&XLogCtl->info_lck);
2617 sleeping = XLogCtl->WalWriterSleeping;
2618 prevAsyncXactLSN = XLogCtl->asyncXactLSN;
2619 if (XLogCtl->asyncXactLSN < asyncXactLSN)
2620 XLogCtl->asyncXactLSN = asyncXactLSN;
2621 SpinLockRelease(&XLogCtl->info_lck);
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
2642 RefreshXLogWriteResult(LogwrtResult);
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 */
2665 void
2666 XLogSetReplicationSlotMinimumLSN(XLogRecPtr lsn)
2667 {
2668 SpinLockAcquire(&XLogCtl->info_lck);
2669 XLogCtl->replicationSlotMinLSN = lsn;
2670 SpinLockRelease(&XLogCtl->info_lck);
2671 }
2672
2673
2674 /*
2675 * Return the oldest LSN we must retain to satisfy the needs of some
2676 * replication slot.
2677 */
2678 XLogRecPtr
2679 XLogGetReplicationSlotMinimumLSN(void)
2680 {
2681 XLogRecPtr retval;
2682
2683 SpinLockAcquire(&XLogCtl->info_lck);
2684 retval = XLogCtl->replicationSlotMinLSN;
2685 SpinLockRelease(&XLogCtl->info_lck);
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 */
2699 static void
2700 UpdateMinRecoveryPoint(XLogRecPtr lsn, bool force)
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 */
2717 if (XLogRecPtrIsInvalid(LocalMinRecoveryPoint) && InRecovery)
2718 {
2719 updateMinRecoveryPoint = false;
2720 return;
2721 }
2722
2723 LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
2724
2725 /* update local copy */
2726 LocalMinRecoveryPoint = ControlFile->minRecoveryPoint;
2727 LocalMinRecoveryPointTLI = ControlFile->minRecoveryPointTLI;
2728
2729 if (XLogRecPtrIsInvalid(LocalMinRecoveryPoint))
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/%X is past current point %X/%X",
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;
2760 UpdateControlFile();
2761 LocalMinRecoveryPoint = newMinRecoveryPoint;
2762 LocalMinRecoveryPointTLI = newMinRecoveryPointTLI;
2763
2764 ereport(DEBUG2,
2765 (errmsg_internal("updated min recovery point to %X/%X 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 */
2779 void
2780 XLogFlush(XLogRecPtr record)
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/%X; write %X/%X; flush %X/%X",
2806 LSN_FORMAT_ARGS(record),
2807 LSN_FORMAT_ARGS(LogwrtResult.Write),
2808 LSN_FORMAT_ARGS(LogwrtResult.Flush));
2809 #endif
2810
2811 START_CRIT_SECTION();
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? */
2833 RefreshXLogWriteResult(LogwrtResult);
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 */
2841 SpinLockAcquire(&XLogCtl->info_lck);
2842 if (WriteRqstPtr < XLogCtl->LogwrtRqst.Write)
2843 WriteRqstPtr = XLogCtl->LogwrtRqst.Write;
2844 SpinLockRelease(&XLogCtl->info_lck);
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 */
2865 RefreshXLogWriteResult(LogwrtResult);
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 &&
2882 MinimumActiveBackends(CommitSiblings))
2883 {
2884 pg_usleep(CommitDelay);
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
2910 END_CRIT_SECTION();
2911
2912 /* wake up walsenders now that we've released heavily contended locks */
2913 WalSndWakeupProcessRequests(true, !RecoveryInProgress());
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/%X is not satisfied --- flushed only to %X/%X",
2939 LSN_FORMAT_ARGS(record),
2940 LSN_FORMAT_ARGS(LogwrtResult.Flush));
2941 }
2942
2943 /*
2944 * Write & flush xlog, but without specifying exactly where to.
2945 *
2946 * We normally write only completed blocks; but if there is nothing to do on
2947 * that basis, we check for unwritten async commits in the current incomplete
2948 * block, and write through the latest one of those. Thus, if async commits
2949 * are not being used, we will write complete blocks only.
2950 *
2951 * If, based on the above, there's anything to write we do so immediately. But
2952 * to avoid calling fsync, fdatasync et. al. at a rate that'd impact
2953 * concurrent IO, we only flush WAL every wal_writer_delay ms, or if there's
2954 * more than wal_writer_flush_after unflushed blocks.
2955 *
2956 * We can guarantee that async commits reach disk after at most three
2957 * wal_writer_delay cycles. (When flushing complete blocks, we allow XLogWrite
2958 * to write "flexibly", meaning it can stop at the end of the buffer ring;
2959 * this makes a difference only with very high load or long wal_writer_delay,
2960 * but imposes one extra cycle for the worst case for async commits.)
2961 *
2962 * This routine is invoked periodically by the background walwriter process.
2963 *
2964 * Returns true if there was any work to do, even if we skipped flushing due
2965 * to wal_writer_delay/wal_writer_flush_after.
2966 */
2967 bool
2968 XLogBackgroundFlush(void)
2969 {
2970 XLogwrtRqst WriteRqst;
2971 bool flexible = true;
2972 static TimestampTz lastflush;
2973 TimestampTz now;
2974 int flushblocks;
2975 TimeLineID insertTLI;
2976
2977 /* XLOG doesn't need flushing during recovery */
2978 if (RecoveryInProgress())
2979 return false;
2980
2981 /*
2982 * Since we're not in recovery, InsertTimeLineID is set and can't change,
2983 * so we can read it without a lock.
2984 */
2985 insertTLI = XLogCtl->InsertTimeLineID;
2986
2987 /* read updated LogwrtRqst */
2988 SpinLockAcquire(&XLogCtl->info_lck);
2989 WriteRqst = XLogCtl->LogwrtRqst;
2990 SpinLockRelease(&XLogCtl->info_lck);
2991
2992 /* back off to last completed page boundary */
2993 WriteRqst.Write -= WriteRqst.Write % XLOG_BLCKSZ;
2994
2995 /* if we have already flushed that far, consider async commit records */
2996 RefreshXLogWriteResult(LogwrtResult);
2997 if (WriteRqst.Write <= LogwrtResult.Flush)
2998 {
2999 SpinLockAcquire(&XLogCtl->info_lck);
3000 WriteRqst.Write = XLogCtl->asyncXactLSN;
3001 SpinLockRelease(&XLogCtl->info_lck);
3002 flexible = false; /* ensure it all gets written */
3003 }
3004
3005 /*
3006 * If already known flushed, we're done. Just need to check if we are
3007 * holding an open file handle to a logfile that's no longer in use,
3008 * preventing the file from being deleted.
3009 */
3010 if (WriteRqst.Write <= LogwrtResult.Flush)
3011 {
3012 if (openLogFile >= 0)
3013 {
3014 if (!XLByteInPrevSeg(LogwrtResult.Write, openLogSegNo,
3015 wal_segment_size))
3016 {
3017 XLogFileClose();
3018 }
3019 }
3020 return false;
3021 }
3022
3023 /*
3024 * Determine how far to flush WAL, based on the wal_writer_delay and
3025 * wal_writer_flush_after GUCs.
3026 *
3027 * Note that XLogSetAsyncXactLSN() performs similar calculation based on
3028 * wal_writer_flush_after, to decide when to wake us up. Make sure the
3029 * logic is the same in both places if you change this.
3030 */
3031 now = GetCurrentTimestamp();
3032 flushblocks =
3033 WriteRqst.Write / XLOG_BLCKSZ - LogwrtResult.Flush / XLOG_BLCKSZ;
3034
3035 if (WalWriterFlushAfter == 0 || lastflush == 0)
3036 {
3037 /* first call, or block based limits disabled */
3038 WriteRqst.Flush = WriteRqst.Write;
3039 lastflush = now;
3040 }
3041 else if (TimestampDifferenceExceeds(lastflush, now, WalWriterDelay))
3042 {
3043 /*
3044 * Flush the writes at least every WalWriterDelay ms. This is
3045 * important to bound the amount of time it takes for an asynchronous
3046 * commit to hit disk.
3047 */
3048 WriteRqst.Flush = WriteRqst.Write;
3049 lastflush = now;
3050 }
3051 else if (flushblocks >= WalWriterFlushAfter)
3052 {
3053 /* exceeded wal_writer_flush_after blocks, flush */
3054 WriteRqst.Flush = WriteRqst.Write;
3055 lastflush = now;
3056 }
3057 else
3058 {
3059 /* no flushing, this time round */
3060 WriteRqst.Flush = 0;
3061 }
3062
3063 #ifdef WAL_DEBUG
3064 if (XLOG_DEBUG)
3065 elog(LOG, "xlog bg flush request write %X/%X; flush: %X/%X, current is write %X/%X; flush %X/%X",
3066 LSN_FORMAT_ARGS(WriteRqst.Write),
3067 LSN_FORMAT_ARGS(WriteRqst.Flush),
3068 LSN_FORMAT_ARGS(LogwrtResult.Write),
3069 LSN_FORMAT_ARGS(LogwrtResult.Flush));
3070 #endif
3071
3072 START_CRIT_SECTION();
3073
3074 /* now wait for any in-progress insertions to finish and get write lock */
3075 WaitXLogInsertionsToFinish(WriteRqst.Write);
3076 LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
3077 RefreshXLogWriteResult(LogwrtResult);
3078 if (WriteRqst.Write > LogwrtResult.Write ||
3079 WriteRqst.Flush > LogwrtResult.Flush)
3080 {
3081 XLogWrite(WriteRqst, insertTLI, flexible);
3082 }
3083 LWLockRelease(WALWriteLock);
3084
3085 END_CRIT_SECTION();
3086
3087 /* wake up walsenders now that we've released heavily contended locks */
3088 WalSndWakeupProcessRequests(true, !RecoveryInProgress());
3089
3090 /*
3091 * Great, done. To take some work off the critical path, try to initialize
3092 * as many of the no-longer-needed WAL buffers for future use as we can.
3093 */
3094 AdvanceXLInsertBuffer(InvalidXLogRecPtr, insertTLI, true);
3095
3096 /*
3097 * If we determined that we need to write data, but somebody else
3098 * wrote/flushed already, it should be considered as being active, to
3099 * avoid hibernating too early.
3100 */
3101 return true;
3102 }
3103
3104 /*
3105 * Test whether XLOG data has been flushed up to (at least) the given position.
3106 *
3107 * Returns true if a flush is still needed. (It may be that someone else
3108 * is already in process of flushing that far, however.)
3109 */
3110 bool
3111 XLogNeedsFlush(XLogRecPtr record)
3112 {
3113 /*
3114 * During recovery, we don't flush WAL but update minRecoveryPoint
3115 * instead. So "needs flush" is taken to mean whether minRecoveryPoint
3116 * would need to be updated.
3117 */
3118 if (RecoveryInProgress())
3119 {
3120 /*
3121 * An invalid minRecoveryPoint means that we need to recover all the
3122 * WAL, i.e., we're doing crash recovery. We never modify the control
3123 * file's value in that case, so we can short-circuit future checks
3124 * here too. This triggers a quick exit path for the startup process,
3125 * which cannot update its local copy of minRecoveryPoint as long as
3126 * it has not replayed all WAL available when doing crash recovery.
3127 */
3128 if (XLogRecPtrIsInvalid(LocalMinRecoveryPoint) && InRecovery)
3129 updateMinRecoveryPoint = false;
3130
3131 /* Quick exit if already known to be updated or cannot be updated */
3132 if (record <= LocalMinRecoveryPoint || !updateMinRecoveryPoint)
3133 return false;
3134
3135 /*
3136 * Update local copy of minRecoveryPoint. But if the lock is busy,
3137 * just return a conservative guess.
3138 */
3139 if (!LWLockConditionalAcquire(ControlFileLock, LW_SHARED))
3140 return true;
3141 LocalMinRecoveryPoint = ControlFile->minRecoveryPoint;
3142 LocalMinRecoveryPointTLI = ControlFile->minRecoveryPointTLI;
3143 LWLockRelease(ControlFileLock);
3144
3145 /*
3146 * Check minRecoveryPoint for any other process than the startup
3147 * process doing crash recovery, which should not update the control
3148 * file value if crash recovery is still running.
3149 */
3150 if (XLogRecPtrIsInvalid(LocalMinRecoveryPoint))
3151 updateMinRecoveryPoint = false;
3152
3153 /* check again */
3154 if (record <= LocalMinRecoveryPoint || !updateMinRecoveryPoint)
3155 return false;
3156 else
3157 return true;
3158 }
3159
3160 /* Quick exit if already known flushed */
3161 if (record <= LogwrtResult.Flush)
3162 return false;
3163
3164 /* read LogwrtResult and update local state */
3165 RefreshXLogWriteResult(LogwrtResult);
3166
3167 /* check again */
3168 if (record <= LogwrtResult.Flush)
3169 return false;
3170
3171 return true;
3172 }
3173
3174 /*
3175 * Try to make a given XLOG file segment exist.
3176 *
3177 * logsegno: identify segment.
3178 *
3179 * *added: on return, true if this call raised the number of extant segments.
3180 *
3181 * path: on return, this char[MAXPGPATH] has the path to the logsegno file.
3182 *
3183 * Returns -1 or FD of opened file. A -1 here is not an error; a caller
3184 * wanting an open segment should attempt to open "path", which usually will
3185 * succeed. (This is weird, but it's efficient for the callers.)
3186 */
3187 static int
3188 XLogFileInitInternal(XLogSegNo logsegno, TimeLineID logtli,
3189 bool *added, char *path)
3190 {
3191 char tmppath[MAXPGPATH];
3192 XLogSegNo installed_segno;
3193 XLogSegNo max_segno;
3194 int fd;
3195 int save_errno;
3196 int open_flags = O_RDWR | O_CREAT | O_EXCL | PG_BINARY;
3197 instr_time io_start;
3198
3199 Assert(logtli != 0);
3200
3201 XLogFilePath(path, logtli, logsegno, wal_segment_size);
3202
3203 /*
3204 * Try to use existent file (checkpoint maker may have created it already)
3205 */
3206 *added = false;
3207 fd = BasicOpenFile(path, O_RDWR | PG_BINARY | O_CLOEXEC |
3208 get_sync_bit(wal_sync_method));
3209 if (fd < 0)
3210 {
3211 if (errno != ENOENT)
3212 ereport(ERROR,
3213 (errcode_for_file_access(),
3214 errmsg("could not open file \"%s\": %m", path)));
3215 }
3216 else
3217 return fd;
3218
3219 /*
3220 * Initialize an empty (all zeroes) segment. NOTE: it is possible that
3221 * another process is doing the same thing. If so, we will end up
3222 * pre-creating an extra log segment. That seems OK, and better than
3223 * holding the lock throughout this lengthy process.
3224 */
3225 elog(DEBUG2, "creating and filling new WAL file");
3226
3227 snprintf(tmppath, MAXPGPATH, XLOGDIR "/xlogtemp.%d", (int) getpid());
3228
3229 unlink(tmppath);
3230
3231 if (io_direct_flags & IO_DIRECT_WAL_INIT)
3232 open_flags |= PG_O_DIRECT;
3233
3234 /* do not use get_sync_bit() here --- want to fsync only at end of fill */
3235 fd = BasicOpenFile(tmppath, open_flags);
3236 if (fd < 0)
3237 ereport(ERROR,
3238 (errcode_for_file_access(),
3239 errmsg("could not create file \"%s\": %m", tmppath)));
3240
3241 /* Measure I/O timing when initializing segment */
3242 io_start = pgstat_prepare_io_time(track_wal_io_timing);
3243
3244 pgstat_report_wait_start(WAIT_EVENT_WAL_INIT_WRITE);
3245 save_errno = 0;
3246 if (wal_init_zero)
3247 {
3248 ssize_t rc;
3249
3250 /*
3251 * Zero-fill the file. With this setting, we do this the hard way to
3252 * ensure that all the file space has really been allocated. On
3253 * platforms that allow "holes" in files, just seeking to the end
3254 * doesn't allocate intermediate space. This way, we know that we
3255 * have all the space and (after the fsync below) that all the
3256 * indirect blocks are down on disk. Therefore, fdatasync(2) or
3257 * O_DSYNC will be sufficient to sync future writes to the log file.
3258 */
3259 rc = pg_pwrite_zeros(fd, wal_segment_size, 0);
3260
3261 if (rc < 0)
3262 save_errno = errno;
3263 }
3264 else
3265 {
3266 /*
3267 * Otherwise, seeking to the end and writing a solitary byte is
3268 * enough.
3269 */
3270 errno = 0;
3271 if (pg_pwrite(fd, "\0", 1, wal_segment_size - 1) != 1)
3272 {
3273 /* if write didn't set errno, assume no disk space */
3274 save_errno = errno ? errno : ENOSPC;
3275 }
3276 }
3277 pgstat_report_wait_end();
3278
3279 if (save_errno)
3280 {
3281 /*
3282 * If we fail to make the file, delete it to release disk space
3283 */
3284 unlink(tmppath);
3285
3286 close(fd);
3287
3288 errno = save_errno;
3289
3290 ereport(ERROR,
3291 (errcode_for_file_access(),
3292 errmsg("could not write to file \"%s\": %m", tmppath)));
3293 }
3294
3295 /*
3296 * A full segment worth of data is written when using wal_init_zero. One
3297 * byte is written when not using it.
3298 */
3299 pgstat_count_io_op_time(IOOBJECT_WAL, IOCONTEXT_INIT, IOOP_WRITE,
3300 io_start, 1,
3301 wal_init_zero ? wal_segment_size : 1);
3302
3303 /* Measure I/O timing when flushing segment */
3304 io_start = pgstat_prepare_io_time(track_wal_io_timing);
3305
3306 pgstat_report_wait_start(WAIT_EVENT_WAL_INIT_SYNC);
3307 if (pg_fsync(fd) != 0)
3308 {
3309 save_errno = errno;
3310 close(fd);
3311 errno = save_errno;
3312 ereport(ERROR,
3313 (errcode_for_file_access(),
3314 errmsg("could not fsync file \"%s\": %m", tmppath)));
3315 }
3316 pgstat_report_wait_end();
3317
3318 pgstat_count_io_op_time(IOOBJECT_WAL, IOCONTEXT_INIT,
3319 IOOP_FSYNC, io_start, 1, 0);
3320
3321 if (close(fd) != 0)
3322 ereport(ERROR,
3323 (errcode_for_file_access(),
3324 errmsg("could not close file \"%s\": %m", tmppath)));
3325
3326 /*
3327 * Now move the segment into place with its final name. Cope with
3328 * possibility that someone else has created the file while we were
3329 * filling ours: if so, use ours to pre-create a future log segment.
3330 */
3331 installed_segno = logsegno;
3332
3333 /*
3334 * XXX: What should we use as max_segno? We used to use XLOGfileslop when
3335 * that was a constant, but that was always a bit dubious: normally, at a
3336 * checkpoint, XLOGfileslop was the offset from the checkpoint record, but
3337 * here, it was the offset from the insert location. We can't do the
3338 * normal XLOGfileslop calculation here because we don't have access to
3339 * the prior checkpoint's redo location. So somewhat arbitrarily, just use
3340 * CheckPointSegments.
3341 */
3342 max_segno = logsegno + CheckPointSegments;
3343 if (InstallXLogFileSegment(&installed_segno, tmppath, true, max_segno,
3344 logtli))
3345 {
3346 *added = true;
3347 elog(DEBUG2, "done creating and filling new WAL file");
3348 }
3349 else
3350 {
3351 /*
3352 * No need for any more future segments, or InstallXLogFileSegment()
3353 * failed to rename the file into place. If the rename failed, a
3354 * caller opening the file may fail.
3355 */
3356 unlink(tmppath);
3357 elog(DEBUG2, "abandoned new WAL file");
3358 }
3359
3360 return -1;
3361 }
3362
3363 /*
3364 * Create a new XLOG file segment, or open a pre-existing one.
3365 *
3366 * logsegno: identify segment to be created/opened.
3367 *
3368 * Returns FD of opened file.
3369 *
3370 * Note: errors here are ERROR not PANIC because we might or might not be
3371 * inside a critical section (eg, during checkpoint there is no reason to
3372 * take down the system on failure). They will promote to PANIC if we are
3373 * in a critical section.
3374 */
3375 int
3376 XLogFileInit(XLogSegNo logsegno, TimeLineID logtli)
3377 {
3378 bool ignore_added;
3379 char path[MAXPGPATH];
3380 int fd;
3381
3382 Assert(logtli != 0);
3383
3384 fd = XLogFileInitInternal(logsegno, logtli, &ignore_added, path);
3385 if (fd >= 0)
3386 return fd;
3387
3388 /* Now open original target segment (might not be file I just made) */
3389 fd = BasicOpenFile(path, O_RDWR | PG_BINARY | O_CLOEXEC |
3390 get_sync_bit(wal_sync_method));
3391 if (fd < 0)
3392 ereport(ERROR,
3393 (errcode_for_file_access(),
3394 errmsg("could not open file \"%s\": %m", path)));
3395 return fd;
3396 }
3397
3398 /*
3399 * Create a new XLOG file segment by copying a pre-existing one.
3400 *
3401 * destsegno: identify segment to be created.
3402 *
3403 * srcTLI, srcsegno: identify segment to be copied (could be from
3404 * a different timeline)
3405 *
3406 * upto: how much of the source file to copy (the rest is filled with
3407 * zeros)
3408 *
3409 * Currently this is only used during recovery, and so there are no locking
3410 * considerations. But we should be just as tense as XLogFileInit to avoid
3411 * emplacing a bogus file.
3412 */
3413 static void
3414 XLogFileCopy(TimeLineID destTLI, XLogSegNo destsegno,
3415 TimeLineID srcTLI, XLogSegNo srcsegno,
3416 int upto)
3417 {
3418 char path[MAXPGPATH];
3419 char tmppath[MAXPGPATH];
3420 PGAlignedXLogBlock buffer;
3421 int srcfd;
3422 int fd;
3423 int nbytes;
3424
3425 /*
3426 * Open the source file
3427 */
3428 XLogFilePath(path, srcTLI, srcsegno, wal_segment_size);
3429 srcfd = OpenTransientFile(path, O_RDONLY | PG_BINARY);
3430 if (srcfd < 0)
3431 ereport(ERROR,
3432 (errcode_for_file_access(),
3433 errmsg("could not open file \"%s\": %m", path)));
3434
3435 /*
3436 * Copy into a temp file name.
3437 */
3438 snprintf(tmppath, MAXPGPATH, XLOGDIR "/xlogtemp.%d", (int) getpid());
3439
3440 unlink(tmppath);
3441
3442 /* do not use get_sync_bit() here --- want to fsync only at end of fill */
3443 fd = OpenTransientFile(tmppath, O_RDWR | O_CREAT | O_EXCL | PG_BINARY);
3444 if (fd < 0)
3445 ereport(ERROR,
3446 (errcode_for_file_access(),
3447 errmsg("could not create file \"%s\": %m", tmppath)));
3448
3449 /*
3450 * Do the data copying.
3451 */
3452 for (nbytes = 0; nbytes < wal_segment_size; nbytes += sizeof(buffer))
3453 {
3454 int nread;
3455
3456 nread = upto - nbytes;
3457
3458 /*
3459 * The part that is not read from the source file is filled with
3460 * zeros.
3461 */
3462 if (nread < sizeof(buffer))
3463 memset(buffer.data, 0, sizeof(buffer));
3464
3465 if (nread > 0)
3466 {
3467 int r;
3468
3469 if (nread > sizeof(buffer))
3470 nread = sizeof(buffer);
3471 pgstat_report_wait_start(WAIT_EVENT_WAL_COPY_READ);
3472 r = read(srcfd, buffer.data, nread);
3473 if (r != nread)
3474 {
3475 if (r < 0)
3476 ereport(ERROR,
3477 (errcode_for_file_access(),
3478 errmsg("could not read file \"%s\": %m",
3479 path)));
3480 else
3481 ereport(ERROR,
3482 (errcode(ERRCODE_DATA_CORRUPTED),
3483 errmsg("could not read file \"%s\": read %d of %zu",
3484 path, r, (Size) nread)));
3485 }
3486 pgstat_report_wait_end();
3487 }
3488 errno = 0;
3489 pgstat_report_wait_start(WAIT_EVENT_WAL_COPY_WRITE);
3490 if ((int) write(fd, buffer.data, sizeof(buffer)) != (int) sizeof(buffer))
3491 {
3492 int save_errno = errno;
3493
3494 /*
3495 * If we fail to make the file, delete it to release disk space
3496 */
3497 unlink(tmppath);
3498 /* if write didn't set errno, assume problem is no disk space */
3499 errno = save_errno ? save_errno : ENOSPC;
3500
3501 ereport(ERROR,
3502 (errcode_for_file_access(),
3503 errmsg("could not write to file \"%s\": %m", tmppath)));
3504 }
3505 pgstat_report_wait_end();
3506 }
3507
3508 pgstat_report_wait_start(WAIT_EVENT_WAL_COPY_SYNC);
3509 if (pg_fsync(fd) != 0)
3510 ereport(data_sync_elevel(ERROR),
3511 (errcode_for_file_access(),
3512 errmsg("could not fsync file \"%s\": %m", tmppath)));
3513 pgstat_report_wait_end();
3514
3515 if (CloseTransientFile(fd) != 0)
3516 ereport(ERROR,
3517 (errcode_for_file_access(),
3518 errmsg("could not close file \"%s\": %m", tmppath)));
3519
3520 if (CloseTransientFile(srcfd) != 0)
3521 ereport(ERROR,
3522 (errcode_for_file_access(),
3523 errmsg("could not close file \"%s\": %m", path)));
3524
3525 /*
3526 * Now move the segment into place with its final name.
3527 */
3528 if (!InstallXLogFileSegment(&destsegno, tmppath, false, 0, destTLI))
3529 elog(ERROR, "InstallXLogFileSegment should not have failed");
3530 }
3531
3532 /*
3533 * Install a new XLOG segment file as a current or future log segment.
3534 *
3535 * This is used both to install a newly-created segment (which has a temp
3536 * filename while it's being created) and to recycle an old segment.
3537 *
3538 * *segno: identify segment to install as (or first possible target).
3539 * When find_free is true, this is modified on return to indicate the
3540 * actual installation location or last segment searched.
3541 *
3542 * tmppath: initial name of file to install. It will be renamed into place.
3543 *
3544 * find_free: if true, install the new segment at the first empty segno
3545 * number at or after the passed numbers. If false, install the new segment
3546 * exactly where specified, deleting any existing segment file there.
3547 *
3548 * max_segno: maximum segment number to install the new file as. Fail if no
3549 * free slot is found between *segno and max_segno. (Ignored when find_free
3550 * is false.)
3551 *
3552 * tli: The timeline on which the new segment should be installed.
3553 *
3554 * Returns true if the file was installed successfully. false indicates that
3555 * max_segno limit was exceeded, the startup process has disabled this
3556 * function for now, or an error occurred while renaming the file into place.
3557 */
3558 static bool
3559 InstallXLogFileSegment(XLogSegNo *segno, char *tmppath,
3560 bool find_free, XLogSegNo max_segno, TimeLineID tli)
3561 {
3562 char path[MAXPGPATH];
3563 struct stat stat_buf;
3564
3565 Assert(tli != 0);
3566
3567 XLogFilePath(path, tli, *segno, wal_segment_size);
3568
3569 LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
3570 if (!XLogCtl->InstallXLogFileSegmentActive)
3571 {
3572 LWLockRelease(ControlFileLock);
3573 return false;
3574 }
3575
3576 if (!find_free)
3577 {
3578 /* Force installation: get rid of any pre-existing segment file */
3579 durable_unlink(path, DEBUG1);
3580 }
3581 else
3582 {
3583 /* Find a free slot to put it in */
3584 while (stat(path, &stat_buf) == 0)
3585 {
3586 if ((*segno) >= max_segno)
3587 {
3588 /* Failed to find a free slot within specified range */
3589 LWLockRelease(ControlFileLock);
3590 return false;
3591 }
3592 (*segno)++;
3593 XLogFilePath(path, tli, *segno, wal_segment_size);
3594 }
3595 }
3596
3597 Assert(access(path, F_OK) != 0 && errno == ENOENT);
3598 if (durable_rename(tmppath, path, LOG) != 0)
3599 {
3600 LWLockRelease(ControlFileLock);
3601 /* durable_rename already emitted log message */
3602 return false;
3603 }
3604
3605 LWLockRelease(ControlFileLock);
3606
3607 return true;
3608 }
3609
3610 /*
3611 * Open a pre-existing logfile segment for writing.
3612 */
3613 int
3614 XLogFileOpen(XLogSegNo segno, TimeLineID tli)
3615 {
3616 char path[MAXPGPATH];
3617 int fd;
3618
3619 XLogFilePath(path, tli, segno, wal_segment_size);
3620
3621 fd = BasicOpenFile(path, O_RDWR | PG_BINARY | O_CLOEXEC |
3622 get_sync_bit(wal_sync_method));
3623 if (fd < 0)
3624 ereport(PANIC,
3625 (errcode_for_file_access(),
3626 errmsg("could not open file \"%s\": %m", path)));
3627
3628 return fd;
3629 }
3630
3631 /*
3632 * Close the current logfile segment for writing.
3633 */
3634 static void
3635 XLogFileClose(void)
3636 {
3637 Assert(openLogFile >= 0);
3638
3639 /*
3640 * WAL segment files will not be re-read in normal operation, so we advise
3641 * the OS to release any cached pages. But do not do so if WAL archiving
3642 * or streaming is active, because archiver and walsender process could
3643 * use the cache to read the WAL segment.
3644 */
3645 #if defined(USE_POSIX_FADVISE) && defined(POSIX_FADV_DONTNEED)
3646 if (!XLogIsNeeded() && (io_direct_flags & IO_DIRECT_WAL) == 0)
3647 (void) posix_fadvise(openLogFile, 0, 0, POSIX_FADV_DONTNEED);
3648 #endif
3649
3650 if (close(openLogFile) != 0)
3651 {
3652 char xlogfname[MAXFNAMELEN];
3653 int save_errno = errno;
3654
3655 XLogFileName(xlogfname, openLogTLI, openLogSegNo, wal_segment_size);
3656 errno = save_errno;
3657 ereport(PANIC,
3658 (errcode_for_file_access(),
3659 errmsg("could not close file \"%s\": %m", xlogfname)));
3660 }
3661
3662 openLogFile = -1;
3663 ReleaseExternalFD();
3664 }
3665
3666 /*
3667 * Preallocate log files beyond the specified log endpoint.
3668 *
3669 * XXX this is currently extremely conservative, since it forces only one
3670 * future log segment to exist, and even that only if we are 75% done with
3671 * the current one. This is only appropriate for very low-WAL-volume systems.
3672 * High-volume systems will be OK once they've built up a sufficient set of
3673 * recycled log segments, but the startup transient is likely to include
3674 * a lot of segment creations by foreground processes, which is not so good.
3675 *
3676 * XLogFileInitInternal() can ereport(ERROR). All known causes indicate big
3677 * trouble; for example, a full filesystem is one cause. The checkpoint WAL
3678 * and/or ControlFile updates already completed. If a RequestCheckpoint()
3679 * initiated the present checkpoint and an ERROR ends this function, the
3680 * command that called RequestCheckpoint() fails. That's not ideal, but it's
3681 * not worth contorting more functions to use caller-specified elevel values.
3682 * (With or without RequestCheckpoint(), an ERROR forestalls some inessential
3683 * reporting and resource reclamation.)
3684 */
3685 static void
3686 PreallocXlogFiles(XLogRecPtr endptr, TimeLineID tli)
3687 {
3688 XLogSegNo _logSegNo;
3689 int lf;
3690 bool added;
3691 char path[MAXPGPATH];
3692 uint64 offset;
3693
3694 if (!XLogCtl->InstallXLogFileSegmentActive)
3695 return; /* unlocked check says no */
3696
3697 XLByteToPrevSeg(endptr, _logSegNo, wal_segment_size);
3698 offset = XLogSegmentOffset(endptr - 1, wal_segment_size);
3699 if (offset >= (uint32) (0.75 * wal_segment_size))
3700 {
3701 _logSegNo++;
3702 lf = XLogFileInitInternal(_logSegNo, tli, &added, path);
3703 if (lf >= 0)
3704 close(lf);
3705 if (added)
3706 CheckpointStats.ckpt_segs_added++;
3707 }
3708 }
3709
3710 /*
3711 * Throws an error if the given log segment has already been removed or
3712 * recycled. The caller should only pass a segment that it knows to have
3713 * existed while the server has been running, as this function always
3714 * succeeds if no WAL segments have been removed since startup.
3715 * 'tli' is only used in the error message.
3716 *
3717 * Note: this function guarantees to keep errno unchanged on return.
3718 * This supports callers that use this to possibly deliver a better
3719 * error message about a missing file, while still being able to throw
3720 * a normal file-access error afterwards, if this does return.
3721 */
3722 void
3723 CheckXLogRemoved(XLogSegNo segno, TimeLineID tli)
3724 {
3725 int save_errno = errno;
3726 XLogSegNo lastRemovedSegNo;
3727
3728 SpinLockAcquire(&XLogCtl->info_lck);
3729 lastRemovedSegNo = XLogCtl->lastRemovedSegNo;
3730 SpinLockRelease(&XLogCtl->info_lck);
3731
3732 if (segno <= lastRemovedSegNo)
3733 {
3734 char filename[MAXFNAMELEN];
3735
3736 XLogFileName(filename, tli, segno, wal_segment_size);
3737 errno = save_errno;
3738 ereport(ERROR,
3739 (errcode_for_file_access(),
3740 errmsg("requested WAL segment %s has already been removed",
3741 filename)));
3742 }
3743 errno = save_errno;
3744 }
3745
3746 /*
3747 * Return the last WAL segment removed, or 0 if no segment has been removed
3748 * since startup.
3749 *
3750 * NB: the result can be out of date arbitrarily fast, the caller has to deal
3751 * with that.
3752 */
3753 XLogSegNo
3754 XLogGetLastRemovedSegno(void)
3755 {
3756 XLogSegNo lastRemovedSegNo;
3757
3758 SpinLockAcquire(&XLogCtl->info_lck);
3759 lastRemovedSegNo = XLogCtl->lastRemovedSegNo;
3760 SpinLockRelease(&XLogCtl->info_lck);
3761
3762 return lastRemovedSegNo;
3763 }
3764
3765 /*
3766 * Return the oldest WAL segment on the given TLI that still exists in
3767 * XLOGDIR, or 0 if none.
3768 */
3769 XLogSegNo
3770 XLogGetOldestSegno(TimeLineID tli)
3771 {
3772 DIR *xldir;
3773 struct dirent *xlde;
3774 XLogSegNo oldest_segno = 0;
3775
3776 xldir = AllocateDir(XLOGDIR);
3777 while ((xlde = ReadDir(xldir, XLOGDIR)) != NULL)
3778 {
3779 TimeLineID file_tli;
3780 XLogSegNo file_segno;
3781
3782 /* Ignore files that are not XLOG segments. */
3783 if (!IsXLogFileName(xlde->d_name))
3784 continue;
3785
3786 /* Parse filename to get TLI and segno. */
3787 XLogFromFileName(xlde->d_name, &file_tli, &file_segno,
3788 wal_segment_size);
3789
3790 /* Ignore anything that's not from the TLI of interest. */
3791 if (tli != file_tli)
3792 continue;
3793
3794 /* If it's the oldest so far, update oldest_segno. */
3795 if (oldest_segno == 0 || file_segno < oldest_segno)
3796 oldest_segno = file_segno;
3797 }
3798
3799 FreeDir(xldir);
3800 return oldest_segno;
3801 }
3802
3803 /*
3804 * Update the last removed segno pointer in shared memory, to reflect that the
3805 * given XLOG file has been removed.
3806 */
3807 static void
3808 UpdateLastRemovedPtr(char *filename)
3809 {
3810 uint32 tli;
3811 XLogSegNo segno;
3812
3813 XLogFromFileName(filename, &tli, &segno, wal_segment_size);
3814
3815 SpinLockAcquire(&XLogCtl->info_lck);
3816 if (segno > XLogCtl->lastRemovedSegNo)
3817 XLogCtl->lastRemovedSegNo = segno;
3818 SpinLockRelease(&XLogCtl->info_lck);
3819 }
3820
3821 /*
3822 * Remove all temporary log files in pg_wal
3823 *
3824 * This is called at the beginning of recovery after a previous crash,
3825 * at a point where no other processes write fresh WAL data.
3826 */
3827 static void
3828 RemoveTempXlogFiles(void)
3829 {
3830 DIR *xldir;
3831 struct dirent *xlde;
3832
3833 elog(DEBUG2, "removing all temporary WAL segments");
3834
3835 xldir = AllocateDir(XLOGDIR);
3836 while ((xlde = ReadDir(xldir, XLOGDIR)) != NULL)
3837 {
3838 char path[MAXPGPATH];
3839
3840 if (strncmp(xlde->d_name, "xlogtemp.", 9) != 0)
3841 continue;
3842
3843 snprintf(path, MAXPGPATH, XLOGDIR "/%s", xlde->d_name);
3844 unlink(path);
3845 elog(DEBUG2, "removed temporary WAL segment \"%s\"", path);
3846 }
3847 FreeDir(xldir);
3848 }
3849
3850 /*
3851 * Recycle or remove all log files older or equal to passed segno.
3852 *
3853 * endptr is current (or recent) end of xlog, and lastredoptr is the
3854 * redo pointer of the last checkpoint. These are used to determine
3855 * whether we want to recycle rather than delete no-longer-wanted log files.
3856 *
3857 * insertTLI is the current timeline for XLOG insertion. Any recycled
3858 * segments should be reused for this timeline.
3859 */
3860 static void
3861 RemoveOldXlogFiles(XLogSegNo segno, XLogRecPtr lastredoptr, XLogRecPtr endptr,
3862 TimeLineID insertTLI)
3863 {
3864 DIR *xldir;
3865 struct dirent *xlde;
3866 char lastoff[MAXFNAMELEN];
3867 XLogSegNo endlogSegNo;
3868 XLogSegNo recycleSegNo;
3869
3870 /* Initialize info about where to try to recycle to */
3871 XLByteToSeg(endptr, endlogSegNo, wal_segment_size);
3872 recycleSegNo = XLOGfileslop(lastredoptr);
3873
3874 /*
3875 * Construct a filename of the last segment to be kept. The timeline ID
3876 * doesn't matter, we ignore that in the comparison. (During recovery,
3877 * InsertTimeLineID isn't set, so we can't use that.)
3878 */
3879 XLogFileName(lastoff, 0, segno, wal_segment_size);
3880
3881 elog(DEBUG2, "attempting to remove WAL segments older than log file %s",
3882 lastoff);
3883
3884 xldir = AllocateDir(XLOGDIR);
3885
3886 while ((xlde = ReadDir(xldir, XLOGDIR)) != NULL)
3887 {
3888 /* Ignore files that are not XLOG segments */
3889 if (!IsXLogFileName(xlde->d_name) &&
3890 !IsPartialXLogFileName(xlde->d_name))
3891 continue;
3892
3893 /*
3894 * We ignore the timeline part of the XLOG segment identifiers in
3895 * deciding whether a segment is still needed. This ensures that we
3896 * won't prematurely remove a segment from a parent timeline. We could
3897 * probably be a little more proactive about removing segments of
3898 * non-parent timelines, but that would be a whole lot more
3899 * complicated.
3900 *
3901 * We use the alphanumeric sorting property of the filenames to decide
3902 * which ones are earlier than the lastoff segment.
3903 */
3904 if (strcmp(xlde->d_name + 8, lastoff + 8) <= 0)
3905 {
3906 if (XLogArchiveCheckDone(xlde->d_name))
3907 {
3908 /* Update the last removed location in shared memory first */
3909 UpdateLastRemovedPtr(xlde->d_name);
3910
3911 RemoveXlogFile(xlde, recycleSegNo, &endlogSegNo, insertTLI);
3912 }
3913 }
3914 }
3915
3916 FreeDir(xldir);
3917 }
3918
3919 /*
3920 * Recycle or remove WAL files that are not part of the given timeline's
3921 * history.
3922 *
3923 * This is called during recovery, whenever we switch to follow a new
3924 * timeline, and at the end of recovery when we create a new timeline. We
3925 * wouldn't otherwise care about extra WAL files lying in pg_wal, but they
3926 * might be leftover pre-allocated or recycled WAL segments on the old timeline
3927 * that we haven't used yet, and contain garbage. If we just leave them in
3928 * pg_wal, they will eventually be archived, and we can't let that happen.
3929 * Files that belong to our timeline history are valid, because we have
3930 * successfully replayed them, but from others we can't be sure.
3931 *
3932 * 'switchpoint' is the current point in WAL where we switch to new timeline,
3933 * and 'newTLI' is the new timeline we switch to.
3934 */
3935 void
3936 RemoveNonParentXlogFiles(XLogRecPtr switchpoint, TimeLineID newTLI)
3937 {
3938 DIR *xldir;
3939 struct dirent *xlde;
3940 char switchseg[MAXFNAMELEN];
3941 XLogSegNo endLogSegNo;
3942 XLogSegNo switchLogSegNo;
3943 XLogSegNo recycleSegNo;
3944
3945 /*
3946 * Initialize info about where to begin the work. This will recycle,
3947 * somewhat arbitrarily, 10 future segments.
3948 */
3949 XLByteToPrevSeg(switchpoint, switchLogSegNo, wal_segment_size);
3950 XLByteToSeg(switchpoint, endLogSegNo, wal_segment_size);
3951 recycleSegNo = endLogSegNo + 10;
3952
3953 /*
3954 * Construct a filename of the last segment to be kept.
3955 */
3956 XLogFileName(switchseg, newTLI, switchLogSegNo, wal_segment_size);
3957
3958 elog(DEBUG2, "attempting to remove WAL segments newer than log file %s",
3959 switchseg);
3960
3961 xldir = AllocateDir(XLOGDIR);
3962
3963 while ((xlde = ReadDir(xldir, XLOGDIR)) != NULL)
3964 {
3965 /* Ignore files that are not XLOG segments */
3966 if (!IsXLogFileName(xlde->d_name))
3967 continue;
3968
3969 /*
3970 * Remove files that are on a timeline older than the new one we're
3971 * switching to, but with a segment number >= the first segment on the
3972 * new timeline.
3973 */
3974 if (strncmp(xlde->d_name, switchseg, 8) < 0 &&
3975 strcmp(xlde->d_name + 8, switchseg + 8) > 0)
3976 {
3977 /*
3978 * If the file has already been marked as .ready, however, don't
3979 * remove it yet. It should be OK to remove it - files that are
3980 * not part of our timeline history are not required for recovery
3981 * - but seems safer to let them be archived and removed later.
3982 */
3983 if (!XLogArchiveIsReady(xlde->d_name))
3984 RemoveXlogFile(xlde, recycleSegNo, &endLogSegNo, newTLI);
3985 }
3986 }
3987
3988 FreeDir(xldir);
3989 }
3990
3991 /*
3992 * Recycle or remove a log file that's no longer needed.
3993 *
3994 * segment_de is the dirent structure of the segment to recycle or remove.
3995 * recycleSegNo is the segment number to recycle up to. endlogSegNo is
3996 * the segment number of the current (or recent) end of WAL.
3997 *
3998 * endlogSegNo gets incremented if the segment is recycled so as it is not
3999 * checked again with future callers of this function.
4000 *
4001 * insertTLI is the current timeline for XLOG insertion. Any recycled segments
4002 * should be used for this timeline.
4003 */
4004 static void
4005 RemoveXlogFile(const struct dirent *segment_de,
4006 XLogSegNo recycleSegNo, XLogSegNo *endlogSegNo,
4007 TimeLineID insertTLI)
4008 {
4009 char path[MAXPGPATH];
4010 #ifdef WIN32
4011 char newpath[MAXPGPATH];
4012 #endif
4013 const char *segname = segment_de->d_name;
4014
4015 snprintf(path, MAXPGPATH, XLOGDIR "/%s", segname);
4016
4017 /*
4018 * Before deleting the file, see if it can be recycled as a future log
4019 * segment. Only recycle normal files, because we don't want to recycle
4020 * symbolic links pointing to a separate archive directory.
4021 */
4022 if (wal_recycle &&
4023 *endlogSegNo <= recycleSegNo &&
4024 XLogCtl->InstallXLogFileSegmentActive && /* callee rechecks this */
4025 get_dirent_type(path, segment_de, false, DEBUG2) == PGFILETYPE_REG &&
4026 InstallXLogFileSegment(endlogSegNo, path,
4027 true, recycleSegNo, insertTLI))
4028 {
4029 ereport(DEBUG2,
4030 (errmsg_internal("recycled write-ahead log file \"%s\"",
4031 segname)));
4032 CheckpointStats.ckpt_segs_recycled++;
4033 /* Needn't recheck that slot on future iterations */
4034 (*endlogSegNo)++;
4035 }
4036 else
4037 {
4038 /* No need for any more future segments, or recycling failed ... */
4039 int rc;
4040
4041 ereport(DEBUG2,
4042 (errmsg_internal("removing write-ahead log file \"%s\"",
4043 segname)));
4044
4045 #ifdef WIN32
4046
4047 /*
4048 * On Windows, if another process (e.g another backend) holds the file
4049 * open in FILE_SHARE_DELETE mode, unlink will succeed, but the file
4050 * will still show up in directory listing until the last handle is
4051 * closed. To avoid confusing the lingering deleted file for a live
4052 * WAL file that needs to be archived, rename it before deleting it.
4053 *
4054 * If another process holds the file open without FILE_SHARE_DELETE
4055 * flag, rename will fail. We'll try again at the next checkpoint.
4056 */
4057 snprintf(newpath, MAXPGPATH, "%s.deleted", path);
4058 if (rename(path, newpath) != 0)
4059 {
4060 ereport(LOG,
4061 (errcode_for_file_access(),
4062 errmsg("could not rename file \"%s\": %m",
4063 path)));
4064 return;
4065 }
4066 rc = durable_unlink(newpath, LOG);
4067 #else
4068 rc = durable_unlink(path, LOG);
4069 #endif
4070 if (rc != 0)
4071 {
4072 /* Message already logged by durable_unlink() */
4073 return;
4074 }
4075 CheckpointStats.ckpt_segs_removed++;
4076 }
4077
4078 XLogArchiveCleanup(segname);
4079 }
4080
4081 /*
4082 * Verify whether pg_wal, pg_wal/archive_status, and pg_wal/summaries exist.
4083 * If the latter do not exist, recreate them.
4084 *
4085 * It is not the goal of this function to verify the contents of these
4086 * directories, but to help in cases where someone has performed a cluster
4087 * copy for PITR purposes but omitted pg_wal from the copy.
4088 *
4089 * We could also recreate pg_wal if it doesn't exist, but a deliberate
4090 * policy decision was made not to. It is fairly common for pg_wal to be
4091 * a symlink, and if that was the DBA's intent then automatically making a
4092 * plain directory would result in degraded performance with no notice.
4093 */
4094 static void
4095 ValidateXLOGDirectoryStructure(void)
4096 {
4097 char path[MAXPGPATH];
4098 struct stat stat_buf;
4099
4100 /* Check for pg_wal; if it doesn't exist, error out */
4101 if (stat(XLOGDIR, &stat_buf) != 0 ||
4102 !S_ISDIR(stat_buf.st_mode))
4103 ereport(FATAL,
4104 (errcode_for_file_access(),
4105 errmsg("required WAL directory \"%s\" does not exist",
4106 XLOGDIR)));
4107
4108 /* Check for archive_status */
4109 snprintf(path, MAXPGPATH, XLOGDIR "/archive_status");
4110 if (stat(path, &stat_buf) == 0)
4111 {
4112 /* Check for weird cases where it exists but isn't a directory */
4113 if (!S_ISDIR(stat_buf.st_mode))
4114 ereport(FATAL,
4115 (errcode_for_file_access(),
4116 errmsg("required WAL directory \"%s\" does not exist",
4117 path)));
4118 }
4119 else
4120 {
4121 ereport(LOG,
4122 (errmsg("creating missing WAL directory \"%s\"", path)));
4123 if (MakePGDirectory(path) < 0)
4124 ereport(FATAL,
4125 (errcode_for_file_access(),
4126 errmsg("could not create missing directory \"%s\": %m",
4127 path)));
4128 }
4129
4130 /* Check for summaries */
4131 snprintf(path, MAXPGPATH, XLOGDIR "/summaries");
4132 if (stat(path, &stat_buf) == 0)
4133 {
4134 /* Check for weird cases where it exists but isn't a directory */
4135 if (!S_ISDIR(stat_buf.st_mode))
4136 ereport(FATAL,
4137 (errmsg("required WAL directory \"%s\" does not exist",
4138 path)));
4139 }
4140 else
4141 {
4142 ereport(LOG,
4143 (errmsg("creating missing WAL directory \"%s\"", path)));
4144 if (MakePGDirectory(path) < 0)
4145 ereport(FATAL,
4146 (errmsg("could not create missing directory \"%s\": %m",
4147 path)));
4148 }
4149 }
4150
4151 /*
4152 * Remove previous backup history files. This also retries creation of
4153 * .ready files for any backup history files for which XLogArchiveNotify
4154 * failed earlier.
4155 */
4156 static void
4157 CleanupBackupHistory(void)
4158 {
4159 DIR *xldir;
4160 struct dirent *xlde;
4161 char path[MAXPGPATH + sizeof(XLOGDIR)];
4162
4163 xldir = AllocateDir(XLOGDIR);
4164
4165 while ((xlde = ReadDir(xldir, XLOGDIR)) != NULL)
4166 {
4167 if (IsBackupHistoryFileName(xlde->d_name))
4168 {
4169 if (XLogArchiveCheckDone(xlde->d_name))
4170 {
4171 elog(DEBUG2, "removing WAL backup history file \"%s\"",
4172 xlde->d_name);
4173 snprintf(path, sizeof(path), XLOGDIR "/%s", xlde->d_name);
4174 unlink(path);
4175 XLogArchiveCleanup(xlde->d_name);
4176 }
4177 }
4178 }
4179
4180 FreeDir(xldir);
4181 }
4182
4183 /*
4184 * I/O routines for pg_control
4185 *
4186 * *ControlFile is a buffer in shared memory that holds an image of the
4187 * contents of pg_control. WriteControlFile() initializes pg_control
4188 * given a preloaded buffer, ReadControlFile() loads the buffer from
4189 * the pg_control file (during postmaster or standalone-backend startup),
4190 * and UpdateControlFile() rewrites pg_control after we modify xlog state.
4191 * InitControlFile() fills the buffer with initial values.
4192 *
4193 * For simplicity, WriteControlFile() initializes the fields of pg_control
4194 * that are related to checking backend/database compatibility, and
4195 * ReadControlFile() verifies they are correct. We could split out the
4196 * I/O and compatibility-check functions, but there seems no need currently.
4197 */
4198
4199 static void
4200 InitControlFile(uint64 sysidentifier, uint32 data_checksum_version)
4201 {
4202 char mock_auth_nonce[MOCK_AUTH_NONCE_LEN];
4203
4204 /*
4205 * Generate a random nonce. This is used for authentication requests that
4206 * will fail because the user does not exist. The nonce is used to create
4207 * a genuine-looking password challenge for the non-existent user, in lieu
4208 * of an actual stored password.
4209 */
4210 if (!pg_strong_random(mock_auth_nonce, MOCK_AUTH_NONCE_LEN))
4211 ereport(PANIC,
4212 (errcode(ERRCODE_INTERNAL_ERROR),
4213 errmsg("could not generate secret authorization token")));
4214
4215 memset(ControlFile, 0, sizeof(ControlFileData));
4216 /* Initialize pg_control status fields */
4217 ControlFile->system_identifier = sysidentifier;
4218 memcpy(ControlFile->mock_authentication_nonce, mock_auth_nonce, MOCK_AUTH_NONCE_LEN);
4219 ControlFile->state = DB_SHUTDOWNED;
4220 ControlFile->unloggedLSN = FirstNormalUnloggedLSN;
4221
4222 /* Set important parameter values for use when replaying WAL */
4223 ControlFile->MaxConnections = MaxConnections;
4224 ControlFile->max_worker_processes = max_worker_processes;
4225 ControlFile->max_wal_senders = max_wal_senders;
4226 ControlFile->max_prepared_xacts = max_prepared_xacts;
4227 ControlFile->max_locks_per_xact = max_locks_per_xact;
4228 ControlFile->wal_level = wal_level;
4229 ControlFile->wal_log_hints = wal_log_hints;
4230 ControlFile->track_commit_timestamp = track_commit_timestamp;
4231 ControlFile->data_checksum_version = data_checksum_version;
4232 }
4233
4234 static void
4235 WriteControlFile(void)
4236 {
4237 int fd;
4238 char buffer[PG_CONTROL_FILE_SIZE]; /* need not be aligned */
4239
4240 /*
4241 * Initialize version and compatibility-check fields
4242 */
4243 ControlFile->pg_control_version = PG_CONTROL_VERSION;
4244 ControlFile->catalog_version_no = CATALOG_VERSION_NO;
4245
4246 ControlFile->maxAlign = MAXIMUM_ALIGNOF;
4247 ControlFile->floatFormat = FLOATFORMAT_VALUE;
4248
4249 ControlFile->blcksz = BLCKSZ;
4250 ControlFile->relseg_size = RELSEG_SIZE;
4251 ControlFile->xlog_blcksz = XLOG_BLCKSZ;
4252 ControlFile->xlog_seg_size = wal_segment_size;
4253
4254 ControlFile->nameDataLen = NAMEDATALEN;
4255 ControlFile->indexMaxKeys = INDEX_MAX_KEYS;
4256
4257 ControlFile->toast_max_chunk_size = TOAST_MAX_CHUNK_SIZE;
4258 ControlFile->loblksize = LOBLKSIZE;
4259
4260 ControlFile->float8ByVal = FLOAT8PASSBYVAL;
4261
4262 /*
4263 * Initialize the default 'char' signedness.
4264 *
4265 * The signedness of the char type is implementation-defined. For instance
4266 * on x86 architecture CPUs, the char data type is typically treated as
4267 * signed by default, whereas on aarch architecture CPUs, it is typically
4268 * treated as unsigned by default. In v17 or earlier, we accidentally let
4269 * C implementation signedness affect persistent data. This led to
4270 * inconsistent results when comparing char data across different
4271 * platforms.
4272 *
4273 * This flag can be used as a hint to ensure consistent behavior for
4274 * pre-v18 data files that store data sorted by the 'char' type on disk,
4275 * especially in cross-platform replication scenarios.
4276 *
4277 * Newly created database clusters unconditionally set the default char
4278 * signedness to true. pg_upgrade changes this flag for clusters that were
4279 * initialized on signedness=false platforms. As a result,
4280 * signedness=false setting will become rare over time. If we had known
4281 * about this problem during the last development cycle that forced initdb
4282 * (v8.3), we would have made all clusters signed or all clusters
4283 * unsigned. Making pg_upgrade the only source of signedness=false will
4284 * cause the population of database clusters to converge toward that
4285 * retrospective ideal.
4286 */
4287 ControlFile->default_char_signedness = true;
4288
4289 /* Contents are protected with a CRC */
4290 INIT_CRC32C(ControlFile->crc);
4291 COMP_CRC32C(ControlFile->crc,
4292 ControlFile,
4293 offsetof(ControlFileData, crc));
4294 FIN_CRC32C(ControlFile->crc);
4295
4296 /*
4297 * We write out PG_CONTROL_FILE_SIZE bytes into pg_control, zero-padding
4298 * the excess over sizeof(ControlFileData). This reduces the odds of
4299 * premature-EOF errors when reading pg_control. We'll still fail when we
4300 * check the contents of the file, but hopefully with a more specific
4301 * error than "couldn't read pg_control".
4302 */
4303 memset(buffer, 0, PG_CONTROL_FILE_SIZE);
4304 memcpy(buffer, ControlFile, sizeof(ControlFileData));
4305
4306 fd = BasicOpenFile(XLOG_CONTROL_FILE,
4307 O_RDWR | O_CREAT | O_EXCL | PG_BINARY);
4308 if (fd < 0)
4309 ereport(PANIC,
4310 (errcode_for_file_access(),
4311 errmsg("could not create file \"%s\": %m",
4312 XLOG_CONTROL_FILE)));
4313
4314 errno = 0;
4315 pgstat_report_wait_start(WAIT_EVENT_CONTROL_FILE_WRITE);
4316 if (write(fd, buffer, PG_CONTROL_FILE_SIZE) != PG_CONTROL_FILE_SIZE)
4317 {
4318 /* if write didn't set errno, assume problem is no disk space */
4319 if (errno == 0)
4320 errno = ENOSPC;
4321 ereport(PANIC,
4322 (errcode_for_file_access(),
4323 errmsg("could not write to file \"%s\": %m",
4324 XLOG_CONTROL_FILE)));
4325 }
4326 pgstat_report_wait_end();
4327
4328 pgstat_report_wait_start(WAIT_EVENT_CONTROL_FILE_SYNC);
4329 if (pg_fsync(fd) != 0)
4330 ereport(PANIC,
4331 (errcode_for_file_access(),
4332 errmsg("could not fsync file \"%s\": %m",
4333 XLOG_CONTROL_FILE)));
4334 pgstat_report_wait_end();
4335
4336 if (close(fd) != 0)
4337 ereport(PANIC,
4338 (errcode_for_file_access(),
4339 errmsg("could not close file \"%s\": %m",
4340 XLOG_CONTROL_FILE)));
4341 }
4342
4343 static void
4344 ReadControlFile(void)
4345 {
4346 pg_crc32c crc;
4347 int fd;
4348 char wal_segsz_str[20];
4349 int r;
4350
4351 /*
4352 * Read data...
4353 */
4354 fd = BasicOpenFile(XLOG_CONTROL_FILE,
4355 O_RDWR | PG_BINARY);
4356 if (fd < 0)
4357 ereport(PANIC,
4358 (errcode_for_file_access(),
4359 errmsg("could not open file \"%s\": %m",
4360 XLOG_CONTROL_FILE)));
4361
4362 pgstat_report_wait_start(WAIT_EVENT_CONTROL_FILE_READ);
4363 r = read(fd, ControlFile, sizeof(ControlFileData));
4364 if (r != sizeof(ControlFileData))
4365 {
4366 if (r < 0)
4367 ereport(PANIC,
4368 (errcode_for_file_access(),
4369 errmsg("could not read file \"%s\": %m",
4370 XLOG_CONTROL_FILE)));
4371 else
4372 ereport(PANIC,
4373 (errcode(ERRCODE_DATA_CORRUPTED),
4374 errmsg("could not read file \"%s\": read %d of %zu",
4375 XLOG_CONTROL_FILE, r, sizeof(ControlFileData))));
4376 }
4377 pgstat_report_wait_end();
4378
4379 close(fd);
4380
4381 /*
4382 * Check for expected pg_control format version. If this is wrong, the
4383 * CRC check will likely fail because we'll be checking the wrong number
4384 * of bytes. Complaining about wrong version will probably be more
4385 * enlightening than complaining about wrong CRC.
4386 */
4387
4388 if (ControlFile->pg_control_version != PG_CONTROL_VERSION && ControlFile->pg_control_version % 65536 == 0 && ControlFile->pg_control_version / 65536 != 0)
4389 ereport(FATAL,
4390 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4391 errmsg("database files are incompatible with server"),
4392 errdetail("The database cluster was initialized with PG_CONTROL_VERSION %d (0x%08x),"
4393 " but the server was compiled with PG_CONTROL_VERSION %d (0x%08x).",
4394 ControlFile->pg_control_version, ControlFile->pg_control_version,
4395 PG_CONTROL_VERSION, PG_CONTROL_VERSION),
4396 errhint("This could be a problem of mismatched byte ordering. It looks like you need to initdb.")));
4397
4398 if (ControlFile->pg_control_version != PG_CONTROL_VERSION)
4399 ereport(FATAL,
4400 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4401 errmsg("database files are incompatible with server"),
4402 errdetail("The database cluster was initialized with PG_CONTROL_VERSION %d,"
4403 " but the server was compiled with PG_CONTROL_VERSION %d.",
4404 ControlFile->pg_control_version, PG_CONTROL_VERSION),
4405 errhint("It looks like you need to initdb.")));
4406
4407 /* Now check the CRC. */
4408 INIT_CRC32C(crc);
4409 COMP_CRC32C(crc,
4410 ControlFile,
4411 offsetof(ControlFileData, crc));
4412 FIN_CRC32C(crc);
4413
4414 if (!EQ_CRC32C(crc, ControlFile->crc))
4415 ereport(FATAL,
4416 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4417 errmsg("incorrect checksum in control file")));
4418
4419 /*
4420 * Do compatibility checking immediately. If the database isn't
4421 * compatible with the backend executable, we want to abort before we can
4422 * possibly do any damage.
4423 */
4424 if (ControlFile->catalog_version_no != CATALOG_VERSION_NO)
4425 ereport(FATAL,
4426 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4427 errmsg("database files are incompatible with server"),
4428 /* translator: %s is a variable name and %d is its value */
4429 errdetail("The database cluster was initialized with %s %d,"
4430 " but the server was compiled with %s %d.",
4431 "CATALOG_VERSION_NO", ControlFile->catalog_version_no,
4432 "CATALOG_VERSION_NO", CATALOG_VERSION_NO),
4433 errhint("It looks like you need to initdb.")));
4434 if (ControlFile->maxAlign != MAXIMUM_ALIGNOF)
4435 ereport(FATAL,
4436 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4437 errmsg("database files are incompatible with server"),
4438 /* translator: %s is a variable name and %d is its value */
4439 errdetail("The database cluster was initialized with %s %d,"
4440 " but the server was compiled with %s %d.",
4441 "MAXALIGN", ControlFile->maxAlign,
4442 "MAXALIGN", MAXIMUM_ALIGNOF),
4443 errhint("It looks like you need to initdb.")));
4444 if (ControlFile->floatFormat != FLOATFORMAT_VALUE)
4445 ereport(FATAL,
4446 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4447 errmsg("database files are incompatible with server"),
4448 errdetail("The database cluster appears to use a different floating-point number format than the server executable."),
4449 errhint("It looks like you need to initdb.")));
4450 if (ControlFile->blcksz != BLCKSZ)
4451 ereport(FATAL,
4452 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4453 errmsg("database files are incompatible with server"),
4454 /* translator: %s is a variable name and %d is its value */
4455 errdetail("The database cluster was initialized with %s %d,"
4456 " but the server was compiled with %s %d.",
4457 "BLCKSZ", ControlFile->blcksz,
4458 "BLCKSZ", BLCKSZ),
4459 errhint("It looks like you need to recompile or initdb.")));
4460 if (ControlFile->relseg_size != RELSEG_SIZE)
4461 ereport(FATAL,
4462 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4463 errmsg("database files are incompatible with server"),
4464 /* translator: %s is a variable name and %d is its value */
4465 errdetail("The database cluster was initialized with %s %d,"
4466 " but the server was compiled with %s %d.",
4467 "RELSEG_SIZE", ControlFile->relseg_size,
4468 "RELSEG_SIZE", RELSEG_SIZE),
4469 errhint("It looks like you need to recompile or initdb.")));
4470 if (ControlFile->xlog_blcksz != XLOG_BLCKSZ)
4471 ereport(FATAL,
4472 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4473 errmsg("database files are incompatible with server"),
4474 /* translator: %s is a variable name and %d is its value */
4475 errdetail("The database cluster was initialized with %s %d,"
4476 " but the server was compiled with %s %d.",
4477 "XLOG_BLCKSZ", ControlFile->xlog_blcksz,
4478 "XLOG_BLCKSZ", XLOG_BLCKSZ),
4479 errhint("It looks like you need to recompile or initdb.")));
4480 if (ControlFile->nameDataLen != NAMEDATALEN)
4481 ereport(FATAL,
4482 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4483 errmsg("database files are incompatible with server"),
4484 /* translator: %s is a variable name and %d is its value */
4485 errdetail("The database cluster was initialized with %s %d,"
4486 " but the server was compiled with %s %d.",
4487 "NAMEDATALEN", ControlFile->nameDataLen,
4488 "NAMEDATALEN", NAMEDATALEN),
4489 errhint("It looks like you need to recompile or initdb.")));
4490 if (ControlFile->indexMaxKeys != INDEX_MAX_KEYS)
4491 ereport(FATAL,
4492 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4493 errmsg("database files are incompatible with server"),
4494 /* translator: %s is a variable name and %d is its value */
4495 errdetail("The database cluster was initialized with %s %d,"
4496 " but the server was compiled with %s %d.",
4497 "INDEX_MAX_KEYS", ControlFile->indexMaxKeys,
4498 "INDEX_MAX_KEYS", INDEX_MAX_KEYS),
4499 errhint("It looks like you need to recompile or initdb.")));
4500 if (ControlFile->toast_max_chunk_size != TOAST_MAX_CHUNK_SIZE)
4501 ereport(FATAL,
4502 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4503 errmsg("database files are incompatible with server"),
4504 /* translator: %s is a variable name and %d is its value */
4505 errdetail("The database cluster was initialized with %s %d,"
4506 " but the server was compiled with %s %d.",
4507 "TOAST_MAX_CHUNK_SIZE", ControlFile->toast_max_chunk_size,
4508 "TOAST_MAX_CHUNK_SIZE", (int) TOAST_MAX_CHUNK_SIZE),
4509 errhint("It looks like you need to recompile or initdb.")));
4510 if (ControlFile->loblksize != LOBLKSIZE)
4511 ereport(FATAL,
4512 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4513 errmsg("database files are incompatible with server"),
4514 /* translator: %s is a variable name and %d is its value */
4515 errdetail("The database cluster was initialized with %s %d,"
4516 " but the server was compiled with %s %d.",
4517 "LOBLKSIZE", ControlFile->loblksize,
4518 "LOBLKSIZE", (int) LOBLKSIZE),
4519 errhint("It looks like you need to recompile or initdb.")));
4520
4521 #ifdef USE_FLOAT8_BYVAL
4522 if (ControlFile->float8ByVal != true)
4523 ereport(FATAL,
4524 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4525 errmsg("database files are incompatible with server"),
4526 errdetail("The database cluster was initialized without USE_FLOAT8_BYVAL"
4527 " but the server was compiled with USE_FLOAT8_BYVAL."),
4528 errhint("It looks like you need to recompile or initdb.")));
4529 #else
4530 if (ControlFile->float8ByVal != false)
4531 ereport(FATAL,
4532 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
4533 errmsg("database files are incompatible with server"),
4534 errdetail("The database cluster was initialized with USE_FLOAT8_BYVAL"
4535 " but the server was compiled without USE_FLOAT8_BYVAL."),
4536 errhint("It looks like you need to recompile or initdb.")));
4537 #endif
4538
4539 wal_segment_size = ControlFile->xlog_seg_size;
4540
4541 if (!IsValidWalSegSize(wal_segment_size))
4542 ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4543 errmsg_plural("invalid WAL segment size in control file (%d byte)",
4544 "invalid WAL segment size in control file (%d bytes)",
4545 wal_segment_size,
4546 wal_segment_size),
4547 errdetail("The WAL segment size must be a power of two between 1 MB and 1 GB.")));
4548
4549 snprintf(wal_segsz_str, sizeof(wal_segsz_str), "%d", wal_segment_size);
4550 SetConfigOption("wal_segment_size", wal_segsz_str, PGC_INTERNAL,
4551 PGC_S_DYNAMIC_DEFAULT);
4552
4553 /* check and update variables dependent on wal_segment_size */
4554 if (ConvertToXSegs(min_wal_size_mb, wal_segment_size) < 2)
4555 ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4556 /* translator: both %s are GUC names */
4557 errmsg("\"%s\" must be at least twice \"%s\"",
4558 "min_wal_size", "wal_segment_size")));
4559
4560 if (ConvertToXSegs(max_wal_size_mb, wal_segment_size) < 2)
4561 ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4562 /* translator: both %s are GUC names */
4563 errmsg("\"%s\" must be at least twice \"%s\"",
4564 "max_wal_size", "wal_segment_size")));
4565
4566 UsableBytesInSegment =
4567 (wal_segment_size / XLOG_BLCKSZ * UsableBytesInPage) -
4568 (SizeOfXLogLongPHD - SizeOfXLogShortPHD);
4569
4570 CalculateCheckpointSegments();
4571
4572 /* Make the initdb settings visible as GUC variables, too */
4573 SetConfigOption("data_checksums", DataChecksumsEnabled() ? "yes" : "no",
4574 PGC_INTERNAL, PGC_S_DYNAMIC_DEFAULT);
4575 }
4576
4577 /*
4578 * Utility wrapper to update the control file. Note that the control
4579 * file gets flushed.
4580 */
4581 static void
4582 UpdateControlFile(void)
4583 {
4584 update_controlfile(DataDir, ControlFile, true);
4585 }
4586
4587 /*
4588 * Returns the unique system identifier from control file.
4589 */
4590 uint64
4591 GetSystemIdentifier(void)
4592 {
4593 Assert(ControlFile != NULL);
4594 return ControlFile->system_identifier;
4595 }
4596
4597 /*
4598 * Returns the random nonce from control file.
4599 */
4600 char *
4601 GetMockAuthenticationNonce(void)
4602 {
4603 Assert(ControlFile != NULL);
4604 return ControlFile->mock_authentication_nonce;
4605 }
4606
4607 /*
4608 * Are checksums enabled for data pages?
4609 */
4610 bool
4611 DataChecksumsEnabled(void)
4612 {
4613 Assert(ControlFile != NULL);
4614 return (ControlFile->data_checksum_version > 0);
4615 }
4616
4617 /*
4618 * Return true if the cluster was initialized on a platform where the
4619 * default signedness of char is "signed". This function exists for code
4620 * that deals with pre-v18 data files that store data sorted by the 'char'
4621 * type on disk (e.g., GIN and GiST indexes). See the comments in
4622 * WriteControlFile() for details.
4623 */
4624 bool
4625 GetDefaultCharSignedness(void)
4626 {
4627 return ControlFile->default_char_signedness;
4628 }
4629
4630 /*
4631 * Returns a fake LSN for unlogged relations.
4632 *
4633 * Each call generates an LSN that is greater than any previous value
4634 * returned. The current counter value is saved and restored across clean
4635 * shutdowns, but like unlogged relations, does not survive a crash. This can
4636 * be used in lieu of real LSN values returned by XLogInsert, if you need an
4637 * LSN-like increasing sequence of numbers without writing any WAL.
4638 */
4639 XLogRecPtr
4640 GetFakeLSNForUnloggedRel(void)
4641 {
4642 return pg_atomic_fetch_add_u64(&XLogCtl->unloggedLSN, 1);
4643 }
4644
4645 /*
4646 * Auto-tune the number of XLOG buffers.
4647 *
4648 * The preferred setting for wal_buffers is about 3% of shared_buffers, with
4649 * a maximum of one XLOG segment (there is little reason to think that more
4650 * is helpful, at least so long as we force an fsync when switching log files)
4651 * and a minimum of 8 blocks (which was the default value prior to PostgreSQL
4652 * 9.1, when auto-tuning was added).
4653 *
4654 * This should not be called until NBuffers has received its final value.
4655 */
4656 static int
4657 XLOGChooseNumBuffers(void)
4658 {
4659 int xbuffers;
4660
4661 xbuffers = NBuffers / 32;
4662 if (xbuffers > (wal_segment_size / XLOG_BLCKSZ))
4663 xbuffers = (wal_segment_size / XLOG_BLCKSZ);
4664 if (xbuffers < 8)
4665 xbuffers = 8;
4666 return xbuffers;
4667 }
4668
4669 /*
4670 * GUC check_hook for wal_buffers
4671 */
4672 bool
4673 check_wal_buffers(int *newval, void **extra, GucSource source)
4674 {
4675 /*
4676 * -1 indicates a request for auto-tune.
4677 */
4678 if (*newval == -1)
4679 {
4680 /*
4681 * If we haven't yet changed the boot_val default of -1, just let it
4682 * be. We'll fix it when XLOGShmemSize is called.
4683 */
4684 if (XLOGbuffers == -1)
4685 return true;
4686
4687 /* Otherwise, substitute the auto-tune value */
4688 *newval = XLOGChooseNumBuffers();
4689 }
4690
4691 /*
4692 * We clamp manually-set values to at least 4 blocks. Prior to PostgreSQL
4693 * 9.1, a minimum of 4 was enforced by guc.c, but since that is no longer
4694 * the case, we just silently treat such values as a request for the
4695 * minimum. (We could throw an error instead, but that doesn't seem very
4696 * helpful.)
4697 */
4698 if (*newval < 4)
4699 *newval = 4;
4700
4701 return true;
4702 }
4703
4704 /*
4705 * GUC check_hook for wal_consistency_checking
4706 */
4707 bool
4708 check_wal_consistency_checking(char **newval, void **extra, GucSource source)
4709 {
4710 char *rawstring;
4711 List *elemlist;
4712 ListCell *l;
4713 bool newwalconsistency[RM_MAX_ID + 1];
4714
4715 /* Initialize the array */
4716 MemSet(newwalconsistency, 0, (RM_MAX_ID + 1) * sizeof(bool));
4717
4718 /* Need a modifiable copy of string */
4719 rawstring = pstrdup(*newval);
4720
4721 /* Parse string into list of identifiers */
4722 if (!SplitIdentifierString(rawstring, ',', &elemlist))
4723 {
4724 /* syntax error in list */
4725 GUC_check_errdetail("List syntax is invalid.");
4726 pfree(rawstring);
4727 list_free(elemlist);
4728 return false;
4729 }
4730
4731 foreach(l, elemlist)
4732 {
4733 char *tok = (char *) lfirst(l);
4734 int rmid;
4735
4736 /* Check for 'all'. */
4737 if (pg_strcasecmp(tok, "all") == 0)
4738 {
4739 for (rmid = 0; rmid <= RM_MAX_ID; rmid++)
4740 if (RmgrIdExists(rmid) && GetRmgr(rmid).rm_mask != NULL)
4741 newwalconsistency[rmid] = true;
4742 }
4743 else
4744 {
4745 /* Check if the token matches any known resource manager. */
4746 bool found = false;
4747
4748 for (rmid = 0; rmid <= RM_MAX_ID; rmid++)
4749 {
4750 if (RmgrIdExists(rmid) && GetRmgr(rmid).rm_mask != NULL &&
4751 pg_strcasecmp(tok, GetRmgr(rmid).rm_name) == 0)
4752 {
4753 newwalconsistency[rmid] = true;
4754 found = true;
4755 break;
4756 }
4757 }
4758 if (!found)
4759 {
4760 /*
4761 * During startup, it might be a not-yet-loaded custom
4762 * resource manager. Defer checking until
4763 * InitializeWalConsistencyChecking().
4764 */
4765 if (!process_shared_preload_libraries_done)
4766 {
4767 check_wal_consistency_checking_deferred = true;
4768 }
4769 else
4770 {
4771 GUC_check_errdetail("Unrecognized key word: \"%s\".", tok);
4772 pfree(rawstring);
4773 list_free(elemlist);
4774 return false;
4775 }
4776 }
4777 }
4778 }
4779
4780 pfree(rawstring);
4781 list_free(elemlist);
4782
4783 /* assign new value */
4784 *extra = guc_malloc(LOG, (RM_MAX_ID + 1) * sizeof(bool));
4785 if (!*extra)
4786 return false;
4787 memcpy(*extra, newwalconsistency, (RM_MAX_ID + 1) * sizeof(bool));
4788 return true;
4789 }
4790
4791 /*
4792 * GUC assign_hook for wal_consistency_checking
4793 */
4794 void
4795 assign_wal_consistency_checking(const char *newval, void *extra)
4796 {
4797 /*
4798 * If some checks were deferred, it's possible that the checks will fail
4799 * later during InitializeWalConsistencyChecking(). But in that case, the
4800 * postmaster will exit anyway, so it's safe to proceed with the
4801 * assignment.
4802 *
4803 * Any built-in resource managers specified are assigned immediately,
4804 * which affects WAL created before shared_preload_libraries are
4805 * processed. Any custom resource managers specified won't be assigned
4806 * until after shared_preload_libraries are processed, but that's OK
4807 * because WAL for a custom resource manager can't be written before the
4808 * module is loaded anyway.
4809 */
4810 wal_consistency_checking = extra;
4811 }
4812
4813 /*
4814 * InitializeWalConsistencyChecking: run after loading custom resource managers
4815 *
4816 * If any unknown resource managers were specified in the
4817 * wal_consistency_checking GUC, processing was deferred. Now that
4818 * shared_preload_libraries have been loaded, process wal_consistency_checking
4819 * again.
4820 */
4821 void
4822 InitializeWalConsistencyChecking(void)
4823 {
4824 Assert(process_shared_preload_libraries_done);
4825
4826 if (check_wal_consistency_checking_deferred)
4827 {
4828 struct config_generic *guc;
4829
4830 guc = find_option("wal_consistency_checking", false, false, ERROR);
4831
4832 check_wal_consistency_checking_deferred = false;
4833
4834 set_config_option_ext("wal_consistency_checking",
4835 wal_consistency_checking_string,
4836 guc->scontext, guc->source, guc->srole,
4837 GUC_ACTION_SET, true, ERROR, false);
4838
4839 /* checking should not be deferred again */
4840 Assert(!check_wal_consistency_checking_deferred);
4841 }
4842 }
4843
4844 /*
4845 * GUC show_hook for archive_command
4846 */
4847 const char *
4848 show_archive_command(void)
4849 {
4850 if (XLogArchivingActive())
4851 return XLogArchiveCommand;
4852 else
4853 return "(disabled)";
4854 }
4855
4856 /*
4857 * GUC show_hook for in_hot_standby
4858 */
4859 const char *
4860 show_in_hot_standby(void)
4861 {
4862 /*
4863 * We display the actual state based on shared memory, so that this GUC
4864 * reports up-to-date state if examined intra-query. The underlying
4865 * variable (in_hot_standby_guc) changes only when we transmit a new value
4866 * to the client.
4867 */
4868 return RecoveryInProgress() ? "on" : "off";
4869 }
4870
4871 /*
4872 * Read the control file, set respective GUCs.
4873 *
4874 * This is to be called during startup, including a crash recovery cycle,
4875 * unless in bootstrap mode, where no control file yet exists. As there's no
4876 * usable shared memory yet (its sizing can depend on the contents of the
4877 * control file!), first store the contents in local memory. XLOGShmemInit()
4878 * will then copy it to shared memory later.
4879 *
4880 * reset just controls whether previous contents are to be expected (in the
4881 * reset case, there's a dangling pointer into old shared memory), or not.
4882 */
4883 void
4884 LocalProcessControlFile(bool reset)
4885 {
4886 Assert(reset || ControlFile == NULL);
4887 ControlFile = palloc(sizeof(ControlFileData));
4888 ReadControlFile();
4889 }
4890
4891 /*
4892 * Get the wal_level from the control file. For a standby, this value should be
4893 * considered as its active wal_level, because it may be different from what
4894 * was originally configured on standby.
4895 */
4896 WalLevel
4897 GetActiveWalLevelOnStandby(void)
4898 {
4899 return ControlFile->wal_level;
4900 }
4901
4902 /*
4903 * Initialization of shared memory for XLOG
4904 */
4905 Size
4906 XLOGShmemSize(void)
4907 {
4908 Size size;
4909
4910 /*
4911 * If the value of wal_buffers is -1, use the preferred auto-tune value.
4912 * This isn't an amazingly clean place to do this, but we must wait till
4913 * NBuffers has received its final value, and must do it before using the
4914 * value of XLOGbuffers to do anything important.
4915 *
4916 * We prefer to report this value's source as PGC_S_DYNAMIC_DEFAULT.
4917 * However, if the DBA explicitly set wal_buffers = -1 in the config file,
4918 * then PGC_S_DYNAMIC_DEFAULT will fail to override that and we must force
4919 * the matter with PGC_S_OVERRIDE.
4920 */
4921 if (XLOGbuffers == -1)
4922 {
4923 char buf[32];
4924
4925 snprintf(buf, sizeof(buf), "%d", XLOGChooseNumBuffers());
4926 SetConfigOption("wal_buffers", buf, PGC_POSTMASTER,
4927 PGC_S_DYNAMIC_DEFAULT);
4928 if (XLOGbuffers == -1) /* failed to apply it? */
4929 SetConfigOption("wal_buffers", buf, PGC_POSTMASTER,
4930 PGC_S_OVERRIDE);
4931 }
4932 Assert(XLOGbuffers > 0);
4933
4934 /* XLogCtl */
4935 size = sizeof(XLogCtlData);
4936
4937 /* WAL insertion locks, plus alignment */
4938 size = add_size(size, mul_size(sizeof(WALInsertLockPadded), NUM_XLOGINSERT_LOCKS + 1));
4939 /* xlblocks array */
4940 size = add_size(size, mul_size(sizeof(pg_atomic_uint64), XLOGbuffers));
4941 /* extra alignment padding for XLOG I/O buffers */
4942 size = add_size(size, Max(XLOG_BLCKSZ, PG_IO_ALIGN_SIZE));
4943 /* and the buffers themselves */
4944 size = add_size(size, mul_size(XLOG_BLCKSZ, XLOGbuffers));
4945
4946 /*
4947 * Note: we don't count ControlFileData, it comes out of the "slop factor"
4948 * added by CreateSharedMemoryAndSemaphores. This lets us use this
4949 * routine again below to compute the actual allocation size.
4950 */
4951
4952 return size;
4953 }
4954
4955 void
4956 XLOGShmemInit(void)
4957 {
4958 bool foundCFile,
4959 foundXLog;
4960 char *allocptr;
4961 int i;
4962 ControlFileData *localControlFile;
4963
4964 #ifdef WAL_DEBUG
4965
4966 /*
4967 * Create a memory context for WAL debugging that's exempt from the normal
4968 * "no pallocs in critical section" rule. Yes, that can lead to a PANIC if
4969 * an allocation fails, but wal_debug is not for production use anyway.
4970 */
4971 if (walDebugCxt == NULL)
4972 {
4973 walDebugCxt = AllocSetContextCreate(TopMemoryContext,
4974 "WAL Debug",
4975 ALLOCSET_DEFAULT_SIZES);
4976 MemoryContextAllowInCriticalSection(walDebugCxt, true);
4977 }
4978 #endif
4979
4980
4981 XLogCtl = (XLogCtlData *)
4982 ShmemInitStruct("XLOG Ctl", XLOGShmemSize(), &foundXLog);
4983
4984 localControlFile = ControlFile;
4985 ControlFile = (ControlFileData *)
4986 ShmemInitStruct("Control File", sizeof(ControlFileData), &foundCFile);
4987
4988 if (foundCFile || foundXLog)
4989 {
4990 /* both should be present or neither */
4991 Assert(foundCFile && foundXLog);
4992
4993 /* Initialize local copy of WALInsertLocks */
4994 WALInsertLocks = XLogCtl->Insert.WALInsertLocks;
4995
4996 if (localControlFile)
4997 pfree(localControlFile);
4998 return;
4999 }
5000 memset(XLogCtl, 0, sizeof(XLogCtlData));
5001
5002 /*
5003 * Already have read control file locally, unless in bootstrap mode. Move
5004 * contents into shared memory.
5005 */
5006 if (localControlFile)
5007 {
5008 memcpy(ControlFile, localControlFile, sizeof(ControlFileData));
5009 pfree(localControlFile);
5010 }
5011
5012 /*
5013 * Since XLogCtlData contains XLogRecPtr fields, its sizeof should be a
5014 * multiple of the alignment for same, so no extra alignment padding is
5015 * needed here.
5016 */
5017 allocptr = ((char *) XLogCtl) + sizeof(XLogCtlData);
5018 XLogCtl->xlblocks = (pg_atomic_uint64 *) allocptr;
5019 allocptr += sizeof(pg_atomic_uint64) * XLOGbuffers;
5020
5021 for (i = 0; i < XLOGbuffers; i++)
5022 {
5023 pg_atomic_init_u64(&XLogCtl->xlblocks[i], InvalidXLogRecPtr);
5024 }
5025
5026 /* WAL insertion locks. Ensure they're aligned to the full padded size */
5027 allocptr += sizeof(WALInsertLockPadded) -
5028 ((uintptr_t) allocptr) % sizeof(WALInsertLockPadded);
5029 WALInsertLocks = XLogCtl->Insert.WALInsertLocks =
5030 (WALInsertLockPadded *) allocptr;
5031 allocptr += sizeof(WALInsertLockPadded) * NUM_XLOGINSERT_LOCKS;
5032
5033 for (i = 0; i < NUM_XLOGINSERT_LOCKS; i++)
5034 {
5035 LWLockInitialize(&WALInsertLocks[i].l.lock, LWTRANCHE_WAL_INSERT);
5036 pg_atomic_init_u64(&WALInsertLocks[i].l.insertingAt, InvalidXLogRecPtr);
5037 WALInsertLocks[i].l.lastImportantAt = InvalidXLogRecPtr;
5038 }
5039
5040 /*
5041 * Align the start of the page buffers to a full xlog block size boundary.
5042 * This simplifies some calculations in XLOG insertion. It is also
5043 * required for O_DIRECT.
5044 */
5045 allocptr = (char *) TYPEALIGN(XLOG_BLCKSZ, allocptr);
5046 XLogCtl->pages = allocptr;
5047 memset(XLogCtl->pages, 0, (Size) XLOG_BLCKSZ * XLOGbuffers);
5048
5049 /*
5050 * Do basic initialization of XLogCtl shared data. (StartupXLOG will fill
5051 * in additional info.)
5052 */
5053 XLogCtl->XLogCacheBlck = XLOGbuffers - 1;
5054 XLogCtl->SharedRecoveryState = RECOVERY_STATE_CRASH;
5055 XLogCtl->InstallXLogFileSegmentActive = false;
5056 XLogCtl->WalWriterSleeping = false;
5057
5058 SpinLockInit(&XLogCtl->Insert.insertpos_lck);
5059 SpinLockInit(&XLogCtl->info_lck);
5060 pg_atomic_init_u64(&XLogCtl->logInsertResult, InvalidXLogRecPtr);
5061 pg_atomic_init_u64(&XLogCtl->logWriteResult, InvalidXLogRecPtr);
5062 pg_atomic_init_u64(&XLogCtl->logFlushResult, InvalidXLogRecPtr);
5063 pg_atomic_init_u64(&XLogCtl->unloggedLSN, InvalidXLogRecPtr);
5064 }
5065
5066 /*
5067 * This func must be called ONCE on system install. It creates pg_control
5068 * and the initial XLOG segment.
5069 */
5070 void
5071 BootStrapXLOG(uint32 data_checksum_version)
5072 {
5073 CheckPoint checkPoint;
5074 char *buffer;
5075 XLogPageHeader page;
5076 XLogLongPageHeader longpage;
5077 XLogRecord *record;
5078 char *recptr;
5079 uint64 sysidentifier;
5080 struct timeval tv;
5081 pg_crc32c crc;
5082
5083 /* allow ordinary WAL segment creation, like StartupXLOG() would */
5084 SetInstallXLogFileSegmentActive();
5085
5086 /*
5087 * Select a hopefully-unique system identifier code for this installation.
5088 * We use the result of gettimeofday(), including the fractional seconds
5089 * field, as being about as unique as we can easily get. (Think not to
5090 * use random(), since it hasn't been seeded and there's no portable way
5091 * to seed it other than the system clock value...) The upper half of the
5092 * uint64 value is just the tv_sec part, while the lower half contains the
5093 * tv_usec part (which must fit in 20 bits), plus 12 bits from our current
5094 * PID for a little extra uniqueness. A person knowing this encoding can
5095 * determine the initialization time of the installation, which could
5096 * perhaps be useful sometimes.
5097 */
5098 gettimeofday(&tv, NULL);
5099 sysidentifier = ((uint64) tv.tv_sec) << 32;
5100 sysidentifier |= ((uint64) tv.tv_usec) << 12;
5101 sysidentifier |= getpid() & 0xFFF;
5102
5103 /* page buffer must be aligned suitably for O_DIRECT */
5104 buffer = (char *) palloc(XLOG_BLCKSZ + XLOG_BLCKSZ);
5105 page = (XLogPageHeader) TYPEALIGN(XLOG_BLCKSZ, buffer);
5106 memset(page, 0, XLOG_BLCKSZ);
5107
5108 /*
5109 * Set up information for the initial checkpoint record
5110 *
5111 * The initial checkpoint record is written to the beginning of the WAL
5112 * segment with logid=0 logseg=1. The very first WAL segment, 0/0, is not
5113 * used, so that we can use 0/0 to mean "before any valid WAL segment".
5114 */
5115 checkPoint.redo = wal_segment_size + SizeOfXLogLongPHD;
5116 checkPoint.ThisTimeLineID = BootstrapTimeLineID;
5117 checkPoint.PrevTimeLineID = BootstrapTimeLineID;
5118 checkPoint.fullPageWrites = fullPageWrites;
5119 checkPoint.wal_level = wal_level;
5120 checkPoint.nextXid =
5121 FullTransactionIdFromEpochAndXid(0, FirstNormalTransactionId);
5122 checkPoint.nextOid = FirstGenbkiObjectId;
5123 checkPoint.nextMulti = FirstMultiXactId;
5124 checkPoint.nextMultiOffset = 0;
5125 checkPoint.oldestXid = FirstNormalTransactionId;
5126 checkPoint.oldestXidDB = Template1DbOid;
5127 checkPoint.oldestMulti = FirstMultiXactId;
5128 checkPoint.oldestMultiDB = Template1DbOid;
5129 checkPoint.oldestCommitTsXid = InvalidTransactionId;
5130 checkPoint.newestCommitTsXid = InvalidTransactionId;
5131 checkPoint.time = (pg_time_t) time(NULL);
5132 checkPoint.oldestActiveXid = InvalidTransactionId;
5133
5134 TransamVariables->nextXid = checkPoint.nextXid;
5135 TransamVariables->nextOid = checkPoint.nextOid;
5136 TransamVariables->oidCount = 0;
5137 MultiXactSetNextMXact(checkPoint.nextMulti, checkPoint.nextMultiOffset);
5138 AdvanceOldestClogXid(checkPoint.oldestXid);
5139 SetTransactionIdLimit(checkPoint.oldestXid, checkPoint.oldestXidDB);
5140 SetMultiXactIdLimit(checkPoint.oldestMulti, checkPoint.oldestMultiDB, true);
5141 SetCommitTsLimit(InvalidTransactionId, InvalidTransactionId);
5142
5143 /* Set up the XLOG page header */
5144 page->xlp_magic = XLOG_PAGE_MAGIC;
5145 page->xlp_info = XLP_LONG_HEADER;
5146 page->xlp_tli = BootstrapTimeLineID;
5147 page->xlp_pageaddr = wal_segment_size;
5148 longpage = (XLogLongPageHeader) page;
5149 longpage->xlp_sysid = sysidentifier;
5150 longpage->xlp_seg_size = wal_segment_size;
5151 longpage->xlp_xlog_blcksz = XLOG_BLCKSZ;
5152
5153 /* Insert the initial checkpoint record */
5154 recptr = ((char *) page + SizeOfXLogLongPHD);
5155 record = (XLogRecord *) recptr;
5156 record->xl_prev = 0;
5157 record->xl_xid = InvalidTransactionId;
5158 record->xl_tot_len = SizeOfXLogRecord + SizeOfXLogRecordDataHeaderShort + sizeof(checkPoint);
5159 record->xl_info = XLOG_CHECKPOINT_SHUTDOWN;
5160 record->xl_rmid = RM_XLOG_ID;
5161 recptr += SizeOfXLogRecord;
5162 /* fill the XLogRecordDataHeaderShort struct */
5163 *(recptr++) = (char) XLR_BLOCK_ID_DATA_SHORT;
5164 *(recptr++) = sizeof(checkPoint);
5165 memcpy(recptr, &checkPoint, sizeof(checkPoint));
5166 recptr += sizeof(checkPoint);
5167 Assert(recptr - (char *) record == record->xl_tot_len);
5168
5169 INIT_CRC32C(crc);
5170 COMP_CRC32C(crc, ((char *) record) + SizeOfXLogRecord, record->xl_tot_len - SizeOfXLogRecord);
5171 COMP_CRC32C(crc, (char *) record, offsetof(XLogRecord, xl_crc));
5172 FIN_CRC32C(crc);
5173 record->xl_crc = crc;
5174
5175 /* Create first XLOG segment file */
5176 openLogTLI = BootstrapTimeLineID;
5177 openLogFile = XLogFileInit(1, BootstrapTimeLineID);
5178
5179 /*
5180 * We needn't bother with Reserve/ReleaseExternalFD here, since we'll
5181 * close the file again in a moment.
5182 */
5183
5184 /* Write the first page with the initial record */
5185 errno = 0;
5186 pgstat_report_wait_start(WAIT_EVENT_WAL_BOOTSTRAP_WRITE);
5187 if (write(openLogFile, page, XLOG_BLCKSZ) != XLOG_BLCKSZ)
5188 {
5189 /* if write didn't set errno, assume problem is no disk space */
5190 if (errno == 0)
5191 errno = ENOSPC;
5192 ereport(PANIC,
5193 (errcode_for_file_access(),
5194 errmsg("could not write bootstrap write-ahead log file: %m")));
5195 }
5196 pgstat_report_wait_end();
5197
5198 pgstat_report_wait_start(WAIT_EVENT_WAL_BOOTSTRAP_SYNC);
5199 if (pg_fsync(openLogFile) != 0)
5200 ereport(PANIC,
5201 (errcode_for_file_access(),
5202 errmsg("could not fsync bootstrap write-ahead log file: %m")));
5203 pgstat_report_wait_end();
5204
5205 if (close(openLogFile) != 0)
5206 ereport(PANIC,
5207 (errcode_for_file_access(),
5208 errmsg("could not close bootstrap write-ahead log file: %m")));
5209
5210 openLogFile = -1;
5211
5212 /* Now create pg_control */
5213 InitControlFile(sysidentifier, data_checksum_version);
5214 ControlFile->time = checkPoint.time;
5215 ControlFile->checkPoint = checkPoint.redo;
5216 ControlFile->checkPointCopy = checkPoint;
5217
5218 /* some additional ControlFile fields are set in WriteControlFile() */
5219 WriteControlFile();
5220
5221 /* Bootstrap the commit log, too */
5222 BootStrapCLOG();
5223 BootStrapCommitTs();
5224 BootStrapSUBTRANS();
5225 BootStrapMultiXact();
5226
5227 pfree(buffer);
5228
5229 /*
5230 * Force control file to be read - in contrast to normal processing we'd
5231 * otherwise never run the checks and GUC related initializations therein.
5232 */
5233 ReadControlFile();
5234 }
5235
5236 static char *
5237 str_time(pg_time_t tnow)
5238 {
5239 char *buf = palloc(128);
5240
5241 pg_strftime(buf, 128,
5242 "%Y-%m-%d %H:%M:%S %Z",
5243 pg_localtime(&tnow, log_timezone));
5244
5245 return buf;
5246 }
5247
5248 /*
5249 * Initialize the first WAL segment on new timeline.
5250 */
5251 static void
5252 XLogInitNewTimeline(TimeLineID endTLI, XLogRecPtr endOfLog, TimeLineID newTLI)
5253 {
5254 char xlogfname[MAXFNAMELEN];
5255 XLogSegNo endLogSegNo;
5256 XLogSegNo startLogSegNo;
5257
5258 /* we always switch to a new timeline after archive recovery */
5259 Assert(endTLI != newTLI);
5260
5261 /*
5262 * Update min recovery point one last time.
5263 */
5264 UpdateMinRecoveryPoint(InvalidXLogRecPtr, true);
5265
5266 /*
5267 * Calculate the last segment on the old timeline, and the first segment
5268 * on the new timeline. If the switch happens in the middle of a segment,
5269 * they are the same, but if the switch happens exactly at a segment
5270 * boundary, startLogSegNo will be endLogSegNo + 1.
5271 */
5272 XLByteToPrevSeg(endOfLog, endLogSegNo, wal_segment_size);
5273 XLByteToSeg(endOfLog, startLogSegNo, wal_segment_size);
5274
5275 /*
5276 * Initialize the starting WAL segment for the new timeline. If the switch
5277 * happens in the middle of a segment, copy data from the last WAL segment
5278 * of the old timeline up to the switch point, to the starting WAL segment
5279 * on the new timeline.
5280 */
5281 if (endLogSegNo == startLogSegNo)
5282 {
5283 /*
5284 * Make a copy of the file on the new timeline.
5285 *
5286 * Writing WAL isn't allowed yet, so there are no locking
5287 * considerations. But we should be just as tense as XLogFileInit to
5288 * avoid emplacing a bogus file.
5289 */
5290 XLogFileCopy(newTLI, endLogSegNo, endTLI, endLogSegNo,
5291 XLogSegmentOffset(endOfLog, wal_segment_size));
5292 }
5293 else
5294 {
5295 /*
5296 * The switch happened at a segment boundary, so just create the next
5297 * segment on the new timeline.
5298 */
5299 int fd;
5300
5301 fd = XLogFileInit(startLogSegNo, newTLI);
5302
5303 if (close(fd) != 0)
5304 {
5305 int save_errno = errno;
5306
5307 XLogFileName(xlogfname, newTLI, startLogSegNo, wal_segment_size);
5308 errno = save_errno;
5309 ereport(ERROR,
5310 (errcode_for_file_access(),
5311 errmsg("could not close file \"%s\": %m", xlogfname)));
5312 }
5313 }
5314
5315 /*
5316 * Let's just make real sure there are not .ready or .done flags posted
5317 * for the new segment.
5318 */
5319 XLogFileName(xlogfname, newTLI, startLogSegNo, wal_segment_size);
5320 XLogArchiveCleanup(xlogfname);
5321 }
5322
5323 /*
5324 * Perform cleanup actions at the conclusion of archive recovery.
5325 */
5326 static void
5327 CleanupAfterArchiveRecovery(TimeLineID EndOfLogTLI, XLogRecPtr EndOfLog,
5328 TimeLineID newTLI)
5329 {
5330 /*
5331 * Execute the recovery_end_command, if any.
5332 */
5333 if (recoveryEndCommand && strcmp(recoveryEndCommand, "") != 0)
5334 ExecuteRecoveryCommand(recoveryEndCommand,
5335 "recovery_end_command",
5336 true,
5337 WAIT_EVENT_RECOVERY_END_COMMAND);
5338
5339 /*
5340 * We switched to a new timeline. Clean up segments on the old timeline.
5341 *
5342 * If there are any higher-numbered segments on the old timeline, remove
5343 * them. They might contain valid WAL, but they might also be
5344 * pre-allocated files containing garbage. In any case, they are not part
5345 * of the new timeline's history so we don't need them.
5346 */
5347 RemoveNonParentXlogFiles(EndOfLog, newTLI);
5348
5349 /*
5350 * If the switch happened in the middle of a segment, what to do with the
5351 * last, partial segment on the old timeline? If we don't archive it, and
5352 * the server that created the WAL never archives it either (e.g. because
5353 * it was hit by a meteor), it will never make it to the archive. That's
5354 * OK from our point of view, because the new segment that we created with
5355 * the new TLI contains all the WAL from the old timeline up to the switch
5356 * point. But if you later try to do PITR to the "missing" WAL on the old
5357 * timeline, recovery won't find it in the archive. It's physically
5358 * present in the new file with new TLI, but recovery won't look there
5359 * when it's recovering to the older timeline. On the other hand, if we
5360 * archive the partial segment, and the original server on that timeline
5361 * is still running and archives the completed version of the same segment
5362 * later, it will fail. (We used to do that in 9.4 and below, and it
5363 * caused such problems).
5364 *
5365 * As a compromise, we rename the last segment with the .partial suffix,
5366 * and archive it. Archive recovery will never try to read .partial
5367 * segments, so they will normally go unused. But in the odd PITR case,
5368 * the administrator can copy them manually to the pg_wal directory
5369 * (removing the suffix). They can be useful in debugging, too.
5370 *
5371 * If a .done or .ready file already exists for the old timeline, however,
5372 * we had already determined that the segment is complete, so we can let
5373 * it be archived normally. (In particular, if it was restored from the
5374 * archive to begin with, it's expected to have a .done file).
5375 */
5376 if (XLogSegmentOffset(EndOfLog, wal_segment_size) != 0 &&
5377 XLogArchivingActive())
5378 {
5379 char origfname[MAXFNAMELEN];
5380 XLogSegNo endLogSegNo;
5381
5382 XLByteToPrevSeg(EndOfLog, endLogSegNo, wal_segment_size);
5383 XLogFileName(origfname, EndOfLogTLI, endLogSegNo, wal_segment_size);
5384
5385 if (!XLogArchiveIsReadyOrDone(origfname))
5386 {
5387 char origpath[MAXPGPATH];
5388 char partialfname[MAXFNAMELEN];
5389 char partialpath[MAXPGPATH];
5390
5391 /*
5392 * If we're summarizing WAL, we can't rename the partial file
5393 * until the summarizer finishes with it, else it will fail.
5394 */
5395 if (summarize_wal)
5396 WaitForWalSummarization(EndOfLog);
5397
5398 XLogFilePath(origpath, EndOfLogTLI, endLogSegNo, wal_segment_size);
5399 snprintf(partialfname, MAXFNAMELEN, "%s.partial", origfname);
5400 snprintf(partialpath, MAXPGPATH, "%s.partial", origpath);
5401
5402 /*
5403 * Make sure there's no .done or .ready file for the .partial
5404 * file.
5405 */
5406 XLogArchiveCleanup(partialfname);
5407
5408 durable_rename(origpath, partialpath, ERROR);
5409 XLogArchiveNotify(partialfname);
5410 }
5411 }
5412 }
5413
5414 /*
5415 * Check to see if required parameters are set high enough on this server
5416 * for various aspects of recovery operation.
5417 *
5418 * Note that all the parameters which this function tests need to be
5419 * listed in Administrator's Overview section in high-availability.sgml.
5420 * If you change them, don't forget to update the list.
5421 */
5422 static void
5423 CheckRequiredParameterValues(void)
5424 {
5425 /*
5426 * For archive recovery, the WAL must be generated with at least 'replica'
5427 * wal_level.
5428 */
5429 if (ArchiveRecoveryRequested && ControlFile->wal_level == WAL_LEVEL_MINIMAL)
5430 {
5431 ereport(FATAL,
5432 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
5433 errmsg("WAL was generated with \"wal_level=minimal\", cannot continue recovering"),
5434 errdetail("This happens if you temporarily set \"wal_level=minimal\" on the server."),
5435 errhint("Use a backup taken after setting \"wal_level\" to higher than \"minimal\".")));
5436 }
5437
5438 /*
5439 * For Hot Standby, the WAL must be generated with 'replica' mode, and we
5440 * must have at least as many backend slots as the primary.
5441 */
5442 if (ArchiveRecoveryRequested && EnableHotStandby)
5443 {
5444 /* We ignore autovacuum_worker_slots when we make this test. */
5445 RecoveryRequiresIntParameter("max_connections",
5446 MaxConnections,
5447 ControlFile->MaxConnections);
5448 RecoveryRequiresIntParameter("max_worker_processes",
5449 max_worker_processes,
5450 ControlFile->max_worker_processes);
5451 RecoveryRequiresIntParameter("max_wal_senders",
5452 max_wal_senders,
5453 ControlFile->max_wal_senders);
5454 RecoveryRequiresIntParameter("max_prepared_transactions",
5455 max_prepared_xacts,
5456 ControlFile->max_prepared_xacts);
5457 RecoveryRequiresIntParameter("max_locks_per_transaction",
5458 max_locks_per_xact,
5459 ControlFile->max_locks_per_xact);
5460 }
5461 }
5462
5463 /*
5464 * This must be called ONCE during postmaster or standalone-backend startup
5465 */
5466 void
5467 StartupXLOG(void)
5468 {
5469 XLogCtlInsert *Insert;
5470 CheckPoint checkPoint;
5471 bool wasShutdown;
5472 bool didCrash;
5473 bool haveTblspcMap;
5474 bool haveBackupLabel;
5475 XLogRecPtr EndOfLog;
5476 TimeLineID EndOfLogTLI;
5477 TimeLineID newTLI;
5478 bool performedWalRecovery;
5479 EndOfWalRecoveryInfo *endOfRecoveryInfo;
5480 XLogRecPtr abortedRecPtr;
5481 XLogRecPtr missingContrecPtr;
5482 TransactionId oldestActiveXID;
5483 bool promoted = false;
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 */
5489 Assert(AuxProcessResourceOwner != NULL);
5490 Assert(CurrentResourceOwner == NULL ||
5491 CurrentResourceOwner == AuxProcessResourceOwner);
5492 CurrentResourceOwner = AuxProcessResourceOwner;
5493
5494 /*
5495 * Check that contents look valid.
5496 */
5497 if (!XRecOffIsValid(ControlFile->checkPoint))
5498 ereport(FATAL,
5499 (errcode(ERRCODE_DATA_CORRUPTED),
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 */
5510 ereport(IsPostmasterEnvironment ? LOG : NOTICE,
5511 (errmsg("database system was shut down at %s",
5512 str_time(ControlFile->time))));
5513 break;
5514
5515 case DB_SHUTDOWNED_IN_RECOVERY:
5516 ereport(LOG,
5517 (errmsg("database system was shut down in recovery at %s",
5518 str_time(ControlFile->time))));
5519 break;
5520
5521 case DB_SHUTDOWNING:
5522 ereport(LOG,
5523 (errmsg("database system shutdown was interrupted; last known up at %s",
5524 str_time(ControlFile->time))));
5525 break;
5526
5527 case DB_IN_CRASH_RECOVERY:
5528 ereport(LOG,
5529 (errmsg("database system was interrupted while in recovery at %s",
5530 str_time(ControlFile->time)),
5531 errhint("This probably means that some data is corrupted and"
5532 " you will have to use the last backup for recovery.")));
5533 break;
5534
5535 case DB_IN_ARCHIVE_RECOVERY:
5536 ereport(LOG,
5537 (errmsg("database system was interrupted while in recovery at log time %s",
5538 str_time(ControlFile->checkPointCopy.time)),
5539 errhint("If this has occurred more than once some data might be corrupted"
5540 " and you might need to choose an earlier recovery target.")));
5541 break;
5542
5543 case DB_IN_PRODUCTION:
5544 ereport(LOG,
5545 (errmsg("database system was interrupted; last known up at %s",
5546 str_time(ControlFile->time))));
5547 break;
5548
5549 default:
5550 ereport(FATAL,
5551 (errcode(ERRCODE_DATA_CORRUPTED),
5552 errmsg("control file contains invalid database cluster state")));
5553 }
5554
5555 /* This is just to allow attaching to startup process with a debugger */
5556 #ifdef XLOG_REPLAY_DELAY
5557 if (ControlFile->state != DB_SHUTDOWNED)
5558 pg_usleep(60000000L);
5559 #endif
5560
5561 /*
5562 * Verify that pg_wal, pg_wal/archive_status, and pg_wal/summaries exist.
5563 * In cases where someone has performed a copy for PITR, these directories
5564 * may have been excluded and need to be re-created.
5565 */
5566 ValidateXLOGDirectoryStructure();
5567
5568 /* Set up timeout handler needed to report startup progress. */
5569 if (!IsBootstrapProcessingMode())
5570 RegisterTimeout(STARTUP_PROGRESS_TIMEOUT,
5571 startup_progress_timeout_handler);
5572
5573 /*----------
5574 * If we previously crashed, perform a couple of actions:
5575 *
5576 * - The pg_wal directory may still include some temporary WAL segments
5577 * used when creating a new segment, so perform some clean up to not
5578 * bloat this path. This is done first as there is no point to sync
5579 * this temporary data.
5580 *
5581 * - There might be data which we had written, intending to fsync it, but
5582 * which we had not actually fsync'd yet. Therefore, a power failure in
5583 * the near future might cause earlier unflushed writes to be lost, even
5584 * though more recent data written to disk from here on would be
5585 * persisted. To avoid that, fsync the entire data directory.
5586 */
5587 if (ControlFile->state != DB_SHUTDOWNED &&
5588 ControlFile->state != DB_SHUTDOWNED_IN_RECOVERY)
5589 {
5590 RemoveTempXlogFiles();
5591 SyncDataDirectory();
5592 didCrash = true;
5593 }
5594 else
5595 didCrash = false;
5596
5597 /*
5598 * Prepare for WAL recovery if needed.
5599 *
5600 * InitWalRecovery analyzes the control file and the backup label file, if
5601 * any. It updates the in-memory ControlFile buffer according to the
5602 * starting checkpoint, and sets InRecovery and ArchiveRecoveryRequested.
5603 * It also applies the tablespace map file, if any.
5604 */
5605 InitWalRecovery(ControlFile, &wasShutdown,
5606 &haveBackupLabel, &haveTblspcMap);
5607 checkPoint = ControlFile->checkPointCopy;
5608
5609 /* initialize shared memory variables from the checkpoint record */
5610 TransamVariables->nextXid = checkPoint.nextXid;
5611 TransamVariables->nextOid = checkPoint.nextOid;
5612 TransamVariables->oidCount = 0;
5613 MultiXactSetNextMXact(checkPoint.nextMulti, checkPoint.nextMultiOffset);
5614 AdvanceOldestClogXid(checkPoint.oldestXid);
5615 SetTransactionIdLimit(checkPoint.oldestXid, checkPoint.oldestXidDB);
5616 SetMultiXactIdLimit(checkPoint.oldestMulti, checkPoint.oldestMultiDB, true);
5617 SetCommitTsLimit(checkPoint.oldestCommitTsXid,
5618 checkPoint.newestCommitTsXid);
5619 XLogCtl->ckptFullXid = checkPoint.nextXid;
5620
5621 /*
5622 * Clear out any old relcache cache files. This is *necessary* if we do
5623 * any WAL replay, since that would probably result in the cache files
5624 * being out of sync with database reality. In theory we could leave them
5625 * in place if the database had been cleanly shut down, but it seems
5626 * safest to just remove them always and let them be rebuilt during the
5627 * first backend startup. These files needs to be removed from all
5628 * directories including pg_tblspc, however the symlinks are created only
5629 * after reading tablespace_map file in case of archive recovery from
5630 * backup, so needs to clear old relcache files here after creating
5631 * symlinks.
5632 */
5633 RelationCacheInitFileRemove();
5634
5635 /*
5636 * Initialize replication slots, before there's a chance to remove
5637 * required resources.
5638 */
5639 StartupReplicationSlots();
5640
5641 /*
5642 * Startup logical state, needs to be setup now so we have proper data
5643 * during crash recovery.
5644 */
5645 StartupReorderBuffer();
5646
5647 /*
5648 * Startup CLOG. This must be done after TransamVariables->nextXid has
5649 * been initialized and before we accept connections or begin WAL replay.
5650 */
5651 StartupCLOG();
5652
5653 /*
5654 * Startup MultiXact. We need to do this early to be able to replay
5655 * truncations.
5656 */
5657 StartupMultiXact();
5658
5659 /*
5660 * Ditto for commit timestamps. Activate the facility if the setting is
5661 * enabled in the control file, as there should be no tracking of commit
5662 * timestamps done when the setting was disabled. This facility can be
5663 * started or stopped when replaying a XLOG_PARAMETER_CHANGE record.
5664 */
5665 if (ControlFile->track_commit_timestamp)
5666 StartupCommitTs();
5667
5668 /*
5669 * Recover knowledge about replay progress of known replication partners.
5670 */
5671 StartupReplicationOrigin();
5672
5673 /*
5674 * Initialize unlogged LSN. On a clean shutdown, it's restored from the
5675 * control file. On recovery, all unlogged relations are blown away, so
5676 * the unlogged LSN counter can be reset too.
5677 */
5678 if (ControlFile->state == DB_SHUTDOWNED)
5679 pg_atomic_write_membarrier_u64(&XLogCtl->unloggedLSN,
5680 ControlFile->unloggedLSN);
5681 else
5682 pg_atomic_write_membarrier_u64(&XLogCtl->unloggedLSN,
5683 FirstNormalUnloggedLSN);
5684
5685 /*
5686 * Copy any missing timeline history files between 'now' and the recovery
5687 * target timeline from archive to pg_wal. While we don't need those files
5688 * ourselves - the history file of the recovery target timeline covers all
5689 * the previous timelines in the history too - a cascading standby server
5690 * might be interested in them. Or, if you archive the WAL from this
5691 * server to a different archive than the primary, it'd be good for all
5692 * the history files to get archived there after failover, so that you can
5693 * use one of the old timelines as a PITR target. Timeline history files
5694 * are small, so it's better to copy them unnecessarily than not copy them
5695 * and regret later.
5696 */
5697 restoreTimeLineHistoryFiles(checkPoint.ThisTimeLineID, recoveryTargetTLI);
5698
5699 /*
5700 * Before running in recovery, scan pg_twophase and fill in its status to
5701 * be able to work on entries generated by redo. Doing a scan before
5702 * taking any recovery action has the merit to discard any 2PC files that
5703 * are newer than the first record to replay, saving from any conflicts at
5704 * replay. This avoids as well any subsequent scans when doing recovery
5705 * of the on-disk two-phase data.
5706 */
5707 restoreTwoPhaseData();
5708
5709 /*
5710 * When starting with crash recovery, reset pgstat data - it might not be
5711 * valid. Otherwise restore pgstat data. It's safe to do this here,
5712 * because postmaster will not yet have started any other processes.
5713 *
5714 * NB: Restoring replication slot stats relies on slot state to have
5715 * already been restored from disk.
5716 *
5717 * TODO: With a bit of extra work we could just start with a pgstat file
5718 * associated with the checkpoint redo location we're starting from.
5719 */
5720 if (didCrash)
5721 pgstat_discard_stats();
5722 else
5723 pgstat_restore_stats();
5724
5725 lastFullPageWrites = checkPoint.fullPageWrites;
5726
5727 RedoRecPtr = XLogCtl->RedoRecPtr = XLogCtl->Insert.RedoRecPtr = checkPoint.redo;
5728 doPageWrites = lastFullPageWrites;
5729
5730 /* REDO */
5731 if (InRecovery)
5732 {
5733 /* Initialize state for RecoveryInProgress() */
5734 SpinLockAcquire(&XLogCtl->info_lck);
5735 if (InArchiveRecovery)
5736 XLogCtl->SharedRecoveryState = RECOVERY_STATE_ARCHIVE;
5737 else
5738 XLogCtl->SharedRecoveryState = RECOVERY_STATE_CRASH;
5739 SpinLockRelease(&XLogCtl->info_lck);
5740
5741 /*
5742 * Update pg_control to show that we are recovering and to show the
5743 * selected checkpoint as the place we are starting from. We also mark
5744 * pg_control with any minimum recovery stop point obtained from a
5745 * backup history file.
5746 *
5747 * No need to hold ControlFileLock yet, we aren't up far enough.
5748 */
5749 UpdateControlFile();
5750
5751 /*
5752 * If there was a backup label file, it's done its job and the info
5753 * has now been propagated into pg_control. We must get rid of the
5754 * label file so that if we crash during recovery, we'll pick up at
5755 * the latest recovery restartpoint instead of going all the way back
5756 * to the backup start point. It seems prudent though to just rename
5757 * the file out of the way rather than delete it completely.
5758 */
5759 if (haveBackupLabel)
5760 {
5761 unlink(BACKUP_LABEL_OLD);
5762 durable_rename(BACKUP_LABEL_FILE, BACKUP_LABEL_OLD, FATAL);
5763 }
5764
5765 /*
5766 * If there was a tablespace_map file, it's done its job and the
5767 * symlinks have been created. We must get rid of the map file so
5768 * that if we crash during recovery, we don't create symlinks again.
5769 * It seems prudent though to just rename the file out of the way
5770 * rather than delete it completely.
5771 */
5772 if (haveTblspcMap)
5773 {
5774 unlink(TABLESPACE_MAP_OLD);
5775 durable_rename(TABLESPACE_MAP, TABLESPACE_MAP_OLD, FATAL);
5776 }
5777
5778 /*
5779 * Initialize our local copy of minRecoveryPoint. When doing crash
5780 * recovery we want to replay up to the end of WAL. Particularly, in
5781 * the case of a promoted standby minRecoveryPoint value in the
5782 * control file is only updated after the first checkpoint. However,
5783 * if the instance crashes before the first post-recovery checkpoint
5784 * is completed then recovery will use a stale location causing the
5785 * startup process to think that there are still invalid page
5786 * references when checking for data consistency.
5787 */
5788 if (InArchiveRecovery)
5789 {
5790 LocalMinRecoveryPoint = ControlFile->minRecoveryPoint;
5791 LocalMinRecoveryPointTLI = ControlFile->minRecoveryPointTLI;
5792 }
5793 else
5794 {
5795 LocalMinRecoveryPoint = InvalidXLogRecPtr;
5796 LocalMinRecoveryPointTLI = 0;
5797 }
5798
5799 /* Check that the GUCs used to generate the WAL allow recovery */
5800 CheckRequiredParameterValues();
5801
5802 /*
5803 * We're in recovery, so unlogged relations may be trashed and must be
5804 * reset. This should be done BEFORE allowing Hot Standby
5805 * connections, so that read-only backends don't try to read whatever
5806 * garbage is left over from before.
5807 */
5808 ResetUnloggedRelations(UNLOGGED_RELATION_CLEANUP);
5809
5810 /*
5811 * Likewise, delete any saved transaction snapshot files that got left
5812 * behind by crashed backends.
5813 */
5814 DeleteAllExportedSnapshotFiles();
5815
5816 /*
5817 * Initialize for Hot Standby, if enabled. We won't let backends in
5818 * yet, not until we've reached the min recovery point specified in
5819 * control file and we've established a recovery snapshot from a
5820 * running-xacts WAL record.
5821 */
5822 if (ArchiveRecoveryRequested && EnableHotStandby)
5823 {
5824 TransactionId *xids;
5825 int nxids;
5826
5827 ereport(DEBUG1,
5828 (errmsg_internal("initializing for hot standby")));
5829
5830 InitRecoveryTransactionEnvironment();
5831
5832 if (wasShutdown)
5833 oldestActiveXID = PrescanPreparedTransactions(&xids, &nxids);
5834 else
5835 oldestActiveXID = checkPoint.oldestActiveXid;
5836 Assert(TransactionIdIsValid(oldestActiveXID));
5837
5838 /* Tell procarray about the range of xids it has to deal with */
5839 ProcArrayInitRecovery(XidFromFullTransactionId(TransamVariables->nextXid));
5840
5841 /*
5842 * Startup subtrans only. CLOG, MultiXact and commit timestamp
5843 * have already been started up and other SLRUs are not maintained
5844 * during recovery and need not be started yet.
5845 */
5846 StartupSUBTRANS(oldestActiveXID);
5847
5848 /*
5849 * If we're beginning at a shutdown checkpoint, we know that
5850 * nothing was running on the primary at this point. So fake-up an
5851 * empty running-xacts record and use that here and now. Recover
5852 * additional standby state for prepared transactions.
5853 */
5854 if (wasShutdown)
5855 {
5856 RunningTransactionsData running;
5857 TransactionId latestCompletedXid;
5858
5859 /* Update pg_subtrans entries for any prepared transactions */
5860 StandbyRecoverPreparedTransactions();
5861
5862 /*
5863 * Construct a RunningTransactions snapshot representing a
5864 * shut down server, with only prepared transactions still
5865 * alive. We're never overflowed at this point because all
5866 * subxids are listed with their parent prepared transactions.
5867 */
5868 running.xcnt = nxids;
5869 running.subxcnt = 0;
5870 running.subxid_status = SUBXIDS_IN_SUBTRANS;
5871 running.nextXid = XidFromFullTransactionId(checkPoint.nextXid);
5872 running.oldestRunningXid = oldestActiveXID;
5873 latestCompletedXid = XidFromFullTransactionId(checkPoint.nextXid);
5874 TransactionIdRetreat(latestCompletedXid);
5875 Assert(TransactionIdIsNormal(latestCompletedXid));
5876 running.latestCompletedXid = latestCompletedXid;
5877 running.xids = xids;
5878
5879 ProcArrayApplyRecoveryInfo(&running);
5880 }
5881 }
5882
5883 /*
5884 * We're all set for replaying the WAL now. Do it.
5885 */
5886 PerformWalRecovery();
5887 performedWalRecovery = true;
5888 }
5889 else
5890 performedWalRecovery = false;
5891
5892 /*
5893 * Finish WAL recovery.
5894 */
5895 endOfRecoveryInfo = FinishWalRecovery();
5896 EndOfLog = endOfRecoveryInfo->endOfLog;
5897 EndOfLogTLI = endOfRecoveryInfo->endOfLogTLI;
5898 abortedRecPtr = endOfRecoveryInfo->abortedRecPtr;
5899 missingContrecPtr = endOfRecoveryInfo->missingContrecPtr;
5900
5901 /*
5902 * Reset ps status display, so as no information related to recovery shows
5903 * up.
5904 */
5905 set_ps_display("");
5906
5907 /*
5908 * When recovering from a backup (we are in recovery, and archive recovery
5909 * was requested), complain if we did not roll forward far enough to reach
5910 * the point where the database is consistent. For regular online
5911 * backup-from-primary, that means reaching the end-of-backup WAL record
5912 * (at which point we reset backupStartPoint to be Invalid), for
5913 * backup-from-replica (which can't inject records into the WAL stream),
5914 * that point is when we reach the minRecoveryPoint in pg_control (which
5915 * we purposefully copy last when backing up from a replica). For
5916 * pg_rewind (which creates a backup_label with a method of "pg_rewind")
5917 * or snapshot-style backups (which don't), backupEndRequired will be set
5918 * to false.
5919 *
5920 * Note: it is indeed okay to look at the local variable
5921 * LocalMinRecoveryPoint here, even though ControlFile->minRecoveryPoint
5922 * might be further ahead --- ControlFile->minRecoveryPoint cannot have
5923 * been advanced beyond the WAL we processed.
5924 */
5925 if (InRecovery &&
5926 (EndOfLog < LocalMinRecoveryPoint ||
5927 !XLogRecPtrIsInvalid(ControlFile->backupStartPoint)))
5928 {
5929 /*
5930 * Ran off end of WAL before reaching end-of-backup WAL record, or
5931 * minRecoveryPoint. That's a bad sign, indicating that you tried to
5932 * recover from an online backup but never called pg_backup_stop(), or
5933 * you didn't archive all the WAL needed.
5934 */
5935 if (ArchiveRecoveryRequested || ControlFile->backupEndRequired)
5936 {
5937 if (!XLogRecPtrIsInvalid(ControlFile->backupStartPoint) || ControlFile->backupEndRequired)
5938 ereport(FATAL,
5939 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
5940 errmsg("WAL ends before end of online backup"),
5941 errhint("All WAL generated while online backup was taken must be available at recovery.")));
5942 else
5943 ereport(FATAL,
5944 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
5945 errmsg("WAL ends before consistent recovery point")));
5946 }
5947 }
5948
5949 /*
5950 * Reset unlogged relations to the contents of their INIT fork. This is
5951 * done AFTER recovery is complete so as to include any unlogged relations
5952 * created during recovery, but BEFORE recovery is marked as having
5953 * completed successfully. Otherwise we'd not retry if any of the post
5954 * end-of-recovery steps fail.
5955 */
5956 if (InRecovery)
5957 ResetUnloggedRelations(UNLOGGED_RELATION_INIT);
5958
5959 /*
5960 * Pre-scan prepared transactions to find out the range of XIDs present.
5961 * This information is not quite needed yet, but it is positioned here so
5962 * as potential problems are detected before any on-disk change is done.
5963 */
5964 oldestActiveXID = PrescanPreparedTransactions(NULL, NULL);
5965
5966 /*
5967 * Allow ordinary WAL segment creation before possibly switching to a new
5968 * timeline, which creates a new segment, and after the last ReadRecord().
5969 */
5970 SetInstallXLogFileSegmentActive();
5971
5972 /*
5973 * Consider whether we need to assign a new timeline ID.
5974 *
5975 * If we did archive recovery, we always assign a new ID. This handles a
5976 * couple of issues. If we stopped short of the end of WAL during
5977 * recovery, then we are clearly generating a new timeline and must assign
5978 * it a unique new ID. Even if we ran to the end, modifying the current
5979 * last segment is problematic because it may result in trying to
5980 * overwrite an already-archived copy of that segment, and we encourage
5981 * DBAs to make their archive_commands reject that. We can dodge the
5982 * problem by making the new active segment have a new timeline ID.
5983 *
5984 * In a normal crash recovery, we can just extend the timeline we were in.
5985 */
5986 newTLI = endOfRecoveryInfo->lastRecTLI;
5987 if (ArchiveRecoveryRequested)
5988 {
5989 newTLI = findNewestTimeLine(recoveryTargetTLI) + 1;
5990 ereport(LOG,
5991 (errmsg("selected new timeline ID: %u", newTLI)));
5992
5993 /*
5994 * Make a writable copy of the last WAL segment. (Note that we also
5995 * have a copy of the last block of the old WAL in
5996 * endOfRecovery->lastPage; we will use that below.)
5997 */
5998 XLogInitNewTimeline(EndOfLogTLI, EndOfLog, newTLI);
5999
6000 /*
6001 * Remove the signal files out of the way, so that we don't
6002 * accidentally re-enter archive recovery mode in a subsequent crash.
6003 */
6004 if (endOfRecoveryInfo->standby_signal_file_found)
6005 durable_unlink(STANDBY_SIGNAL_FILE, FATAL);
6006
6007 if (endOfRecoveryInfo->recovery_signal_file_found)
6008 durable_unlink(RECOVERY_SIGNAL_FILE, FATAL);
6009
6010 /*
6011 * Write the timeline history file, and have it archived. After this
6012 * point (or rather, as soon as the file is archived), the timeline
6013 * will appear as "taken" in the WAL archive and to any standby
6014 * servers. If we crash before actually switching to the new
6015 * timeline, standby servers will nevertheless think that we switched
6016 * to the new timeline, and will try to connect to the new timeline.
6017 * To minimize the window for that, try to do as little as possible
6018 * between here and writing the end-of-recovery record.
6019 */
6020 writeTimeLineHistory(newTLI, recoveryTargetTLI,
6021 EndOfLog, endOfRecoveryInfo->recoveryStopReason);
6022
6023 ereport(LOG,
6024 (errmsg("archive recovery complete")));
6025 }
6026
6027 /* Save the selected TimeLineID in shared memory, too */
6028 SpinLockAcquire(&XLogCtl->info_lck);
6029 XLogCtl->InsertTimeLineID = newTLI;
6030 XLogCtl->PrevTimeLineID = endOfRecoveryInfo->lastRecTLI;
6031 SpinLockRelease(&XLogCtl->info_lck);
6032
6033 /*
6034 * Actually, if WAL ended in an incomplete record, skip the parts that
6035 * made it through and start writing after the portion that persisted.
6036 * (It's critical to first write an OVERWRITE_CONTRECORD message, which
6037 * we'll do as soon as we're open for writing new WAL.)
6038 */
6039 if (!XLogRecPtrIsInvalid(missingContrecPtr))
6040 {
6041 /*
6042 * We should only have a missingContrecPtr if we're not switching to a
6043 * new timeline. When a timeline switch occurs, WAL is copied from the
6044 * old timeline to the new only up to the end of the last complete
6045 * record, so there can't be an incomplete WAL record that we need to
6046 * disregard.
6047 */
6048 Assert(newTLI == endOfRecoveryInfo->lastRecTLI);
6049 Assert(!XLogRecPtrIsInvalid(abortedRecPtr));
6050 EndOfLog = missingContrecPtr;
6051 }
6052
6053 /*
6054 * Prepare to write WAL starting at EndOfLog location, and init xlog
6055 * buffer cache using the block containing the last record from the
6056 * previous incarnation.
6057 */
6058 Insert = &XLogCtl->Insert;
6059 Insert->PrevBytePos = XLogRecPtrToBytePos(endOfRecoveryInfo->lastRec);
6060 Insert->CurrBytePos = XLogRecPtrToBytePos(EndOfLog);
6061
6062 /*
6063 * Tricky point here: lastPage contains the *last* block that the LastRec
6064 * record spans, not the one it starts in. The last block is indeed the
6065 * one we want to use.
6066 */
6067 if (EndOfLog % XLOG_BLCKSZ != 0)
6068 {
6069 char *page;
6070 int len;
6071 int firstIdx;
6072
6073 firstIdx = XLogRecPtrToBufIdx(EndOfLog);
6074 len = EndOfLog - endOfRecoveryInfo->lastPageBeginPtr;
6075 Assert(len < XLOG_BLCKSZ);
6076
6077 /* Copy the valid part of the last block, and zero the rest */
6078 page = &XLogCtl->pages[firstIdx * XLOG_BLCKSZ];
6079 memcpy(page, endOfRecoveryInfo->lastPage, len);
6080 memset(page + len, 0, XLOG_BLCKSZ - len);
6081
6082 pg_atomic_write_u64(&XLogCtl->xlblocks[firstIdx], endOfRecoveryInfo->lastPageBeginPtr + XLOG_BLCKSZ);
6083 XLogCtl->InitializedUpTo = endOfRecoveryInfo->lastPageBeginPtr + XLOG_BLCKSZ;
6084 }
6085 else
6086 {
6087 /*
6088 * There is no partial block to copy. Just set InitializedUpTo, and
6089 * let the first attempt to insert a log record to initialize the next
6090 * buffer.
6091 */
6092 XLogCtl->InitializedUpTo = EndOfLog;
6093 }
6094
6095 /*
6096 * Update local and shared status. This is OK to do without any locks
6097 * because no other process can be reading or writing WAL yet.
6098 */
6099 LogwrtResult.Write = LogwrtResult.Flush = EndOfLog;
6100 pg_atomic_write_u64(&XLogCtl->logInsertResult, EndOfLog);
6101 pg_atomic_write_u64(&XLogCtl->logWriteResult, EndOfLog);
6102 pg_atomic_write_u64(&XLogCtl->logFlushResult, EndOfLog);
6103 XLogCtl->LogwrtRqst.Write = EndOfLog;
6104 XLogCtl->LogwrtRqst.Flush = EndOfLog;
6105
6106 /*
6107 * Preallocate additional log files, if wanted.
6108 */
6109 PreallocXlogFiles(EndOfLog, newTLI);
6110
6111 /*
6112 * Okay, we're officially UP.
6113 */
6114 InRecovery = false;
6115
6116 /* start the archive_timeout timer and LSN running */
6117 XLogCtl->lastSegSwitchTime = (pg_time_t) time(NULL);
6118 XLogCtl->lastSegSwitchLSN = EndOfLog;
6119
6120 /* also initialize latestCompletedXid, to nextXid - 1 */
6121 LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
6122 TransamVariables->latestCompletedXid = TransamVariables->nextXid;
6123 FullTransactionIdRetreat(&TransamVariables->latestCompletedXid);
6124 LWLockRelease(ProcArrayLock);
6125
6126 /*
6127 * Start up subtrans, if not already done for hot standby. (commit
6128 * timestamps are started below, if necessary.)
6129 */
6130 if (standbyState == STANDBY_DISABLED)
6131 StartupSUBTRANS(oldestActiveXID);
6132
6133 /*
6134 * Perform end of recovery actions for any SLRUs that need it.
6135 */
6136 TrimCLOG();
6137 TrimMultiXact();
6138
6139 /*
6140 * Reload shared-memory state for prepared transactions. This needs to
6141 * happen before renaming the last partial segment of the old timeline as
6142 * it may be possible that we have to recover some transactions from it.
6143 */
6144 RecoverPreparedTransactions();
6145
6146 /* Shut down xlogreader */
6147 ShutdownWalRecovery();
6148
6149 /* Enable WAL writes for this backend only. */
6150 LocalSetXLogInsertAllowed();
6151
6152 /* If necessary, write overwrite-contrecord before doing anything else */
6153 if (!XLogRecPtrIsInvalid(abortedRecPtr))
6154 {
6155 Assert(!XLogRecPtrIsInvalid(missingContrecPtr));
6156 CreateOverwriteContrecordRecord(abortedRecPtr, missingContrecPtr, newTLI);
6157 }
6158
6159 /*
6160 * Update full_page_writes in shared memory and write an XLOG_FPW_CHANGE
6161 * record before resource manager writes cleanup WAL records or checkpoint
6162 * record is written.
6163 */
6164 Insert->fullPageWrites = lastFullPageWrites;
6165 UpdateFullPageWrites();
6166
6167 /*
6168 * Emit checkpoint or end-of-recovery record in XLOG, if required.
6169 */
6170 if (performedWalRecovery)
6171 promoted = PerformRecoveryXLogAction();
6172
6173 /*
6174 * If any of the critical GUCs have changed, log them before we allow
6175 * backends to write WAL.
6176 */
6177 XLogReportParameters();
6178
6179 /* If this is archive recovery, perform post-recovery cleanup actions. */
6180 if (ArchiveRecoveryRequested)
6181 CleanupAfterArchiveRecovery(EndOfLogTLI, EndOfLog, newTLI);
6182
6183 INJECTION_POINT("promotion-after-wal-segment-cleanup", NULL);
6184
6185 /*
6186 * Local WAL inserts enabled, so it's time to finish initialization of
6187 * commit timestamp.
6188 */
6189 CompleteCommitTsInitialization();
6190
6191 /*
6192 * All done with end-of-recovery actions.
6193 *
6194 * Now allow backends to write WAL and update the control file status in
6195 * consequence. SharedRecoveryState, that controls if backends can write
6196 * WAL, is updated while holding ControlFileLock to prevent other backends
6197 * to look at an inconsistent state of the control file in shared memory.
6198 * There is still a small window during which backends can write WAL and
6199 * the control file is still referring to a system not in DB_IN_PRODUCTION
6200 * state while looking at the on-disk control file.
6201 *
6202 * Also, we use info_lck to update SharedRecoveryState to ensure that
6203 * there are no race conditions concerning visibility of other recent
6204 * updates to shared memory.
6205 */
6206 LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
6207 ControlFile->state = DB_IN_PRODUCTION;
6208
6209 SpinLockAcquire(&XLogCtl->info_lck);
6210 XLogCtl->SharedRecoveryState = RECOVERY_STATE_DONE;
6211 SpinLockRelease(&XLogCtl->info_lck);
6212
6213 UpdateControlFile();
6214 LWLockRelease(ControlFileLock);
6215
6216 /*
6217 * Shutdown the recovery environment. This must occur after
6218 * RecoverPreparedTransactions() (see notes in lock_twophase_recover())
6219 * and after switching SharedRecoveryState to RECOVERY_STATE_DONE so as
6220 * any session building a snapshot will not rely on KnownAssignedXids as
6221 * RecoveryInProgress() would return false at this stage. This is
6222 * particularly critical for prepared 2PC transactions, that would still
6223 * need to be included in snapshots once recovery has ended.
6224 */
6225 if (standbyState != STANDBY_DISABLED)
6226 ShutdownRecoveryTransactionEnvironment();
6227
6228 /*
6229 * If there were cascading standby servers connected to us, nudge any wal
6230 * sender processes to notice that we've been promoted.
6231 */
6232 WalSndWakeup(true, true);
6233
6234 /*
6235 * If this was a promotion, request an (online) checkpoint now. This isn't
6236 * required for consistency, but the last restartpoint might be far back,
6237 * and in case of a crash, recovering from it might take a longer than is
6238 * appropriate now that we're not in standby mode anymore.
6239 */
6240 if (promoted)
6241 RequestCheckpoint(CHECKPOINT_FORCE);
6242 }
6243
6244 /*
6245 * Callback from PerformWalRecovery(), called when we switch from crash
6246 * recovery to archive recovery mode. Updates the control file accordingly.
6247 */
6248 void
6249 SwitchIntoArchiveRecovery(XLogRecPtr EndRecPtr, TimeLineID replayTLI)
6250 {
6251 /* initialize minRecoveryPoint to this record */
6252 LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
6253 ControlFile->state = DB_IN_ARCHIVE_RECOVERY;
6254 if (ControlFile->minRecoveryPoint < EndRecPtr)
6255 {
6256 ControlFile->minRecoveryPoint = EndRecPtr;
6257 ControlFile->minRecoveryPointTLI = replayTLI;
6258 }
6259 /* update local copy */
6260 LocalMinRecoveryPoint = ControlFile->minRecoveryPoint;
6261 LocalMinRecoveryPointTLI = ControlFile->minRecoveryPointTLI;
6262
6263 /*
6264 * The startup process can update its local copy of minRecoveryPoint from
6265 * this point.
6266 */
6267 updateMinRecoveryPoint = true;
6268
6269 UpdateControlFile();
6270
6271 /*
6272 * We update SharedRecoveryState while holding the lock on ControlFileLock
6273 * so both states are consistent in shared memory.
6274 */
6275 SpinLockAcquire(&XLogCtl->info_lck);
6276 XLogCtl->SharedRecoveryState = RECOVERY_STATE_ARCHIVE;
6277 SpinLockRelease(&XLogCtl->info_lck);
6278
6279 LWLockRelease(ControlFileLock);
6280 }
6281
6282 /*
6283 * Callback from PerformWalRecovery(), called when we reach the end of backup.
6284 * Updates the control file accordingly.
6285 */
6286 void
6287 ReachedEndOfBackup(XLogRecPtr EndRecPtr, TimeLineID tli)
6288 {
6289 /*
6290 * We have reached the end of base backup, as indicated by pg_control. The
6291 * data on disk is now consistent (unless minRecoveryPoint is further
6292 * ahead, which can happen if we crashed during previous recovery). Reset
6293 * backupStartPoint and backupEndPoint, and update minRecoveryPoint to
6294 * make sure we don't allow starting up at an earlier point even if
6295 * recovery is stopped and restarted soon after this.
6296 */
6297 LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
6298
6299 if (ControlFile->minRecoveryPoint < EndRecPtr)
6300 {
6301 ControlFile->minRecoveryPoint = EndRecPtr;
6302 ControlFile->minRecoveryPointTLI = tli;
6303 }
6304
6305 ControlFile->backupStartPoint = InvalidXLogRecPtr;
6306 ControlFile->backupEndPoint = InvalidXLogRecPtr;
6307 ControlFile->backupEndRequired = false;
6308 UpdateControlFile();
6309
6310 LWLockRelease(ControlFileLock);
6311 }
6312
6313 /*
6314 * Perform whatever XLOG actions are necessary at end of REDO.
6315 *
6316 * The goal here is to make sure that we'll be able to recover properly if
6317 * we crash again. If we choose to write a checkpoint, we'll write a shutdown
6318 * checkpoint rather than an on-line one. This is not particularly critical,
6319 * but since we may be assigning a new TLI, using a shutdown checkpoint allows
6320 * us to have the rule that TLI only changes in shutdown checkpoints, which
6321 * allows some extra error checking in xlog_redo.
6322 */
6323 static bool
6324 PerformRecoveryXLogAction(void)
6325 {
6326 bool promoted = false;
6327
6328 /*
6329 * Perform a checkpoint to update all our recovery activity to disk.
6330 *
6331 * Note that we write a shutdown checkpoint rather than an on-line one.
6332 * This is not particularly critical, but since we may be assigning a new
6333 * TLI, using a shutdown checkpoint allows us to have the rule that TLI
6334 * only changes in shutdown checkpoints, which allows some extra error
6335 * checking in xlog_redo.
6336 *
6337 * In promotion, only create a lightweight end-of-recovery record instead
6338 * of a full checkpoint. A checkpoint is requested later, after we're
6339 * fully out of recovery mode and already accepting queries.
6340 */
6341 if (ArchiveRecoveryRequested && IsUnderPostmaster &&
6342 PromoteIsTriggered())
6343 {
6344 promoted = true;
6345
6346 /*
6347 * Insert a special WAL record to mark the end of recovery, since we
6348 * aren't doing a checkpoint. That means that the checkpointer process
6349 * may likely be in the middle of a time-smoothed restartpoint and
6350 * could continue to be for minutes after this. That sounds strange,
6351 * but the effect is roughly the same and it would be stranger to try
6352 * to come out of the restartpoint and then checkpoint. We request a
6353 * checkpoint later anyway, just for safety.
6354 */
6355 CreateEndOfRecoveryRecord();
6356 }
6357 else
6358 {
6359 RequestCheckpoint(CHECKPOINT_END_OF_RECOVERY |
6360 CHECKPOINT_IMMEDIATE |
6361 CHECKPOINT_WAIT);
6362 }
6363
6364 return promoted;
6365 }
6366
6367 /*
6368 * Is the system still in recovery?
6369 *
6370 * Unlike testing InRecovery, this works in any process that's connected to
6371 * shared memory.
6372 */
6373 bool
6374 RecoveryInProgress(void)
6375 {
6376 /*
6377 * We check shared state each time only until we leave recovery mode. We
6378 * can't re-enter recovery, so there's no need to keep checking after the
6379 * shared variable has once been seen false.
6380 */
6381 if (!LocalRecoveryInProgress)
6382 return false;
6383 else
6384 {
6385 /*
6386 * use volatile pointer to make sure we make a fresh read of the
6387 * shared variable.
6388 */
6389 volatile XLogCtlData *xlogctl = XLogCtl;
6390
6391 LocalRecoveryInProgress = (xlogctl->SharedRecoveryState != RECOVERY_STATE_DONE);
6392
6393 /*
6394 * Note: We don't need a memory barrier when we're still in recovery.
6395 * We might exit recovery immediately after return, so the caller
6396 * can't rely on 'true' meaning that we're still in recovery anyway.
6397 */
6398
6399 return LocalRecoveryInProgress;
6400 }
6401 }
6402
6403 /*
6404 * Returns current recovery state from shared memory.
6405 *
6406 * This returned state is kept consistent with the contents of the control
6407 * file. See details about the possible values of RecoveryState in xlog.h.
6408 */
6409 RecoveryState
6410 GetRecoveryState(void)
6411 {
6412 RecoveryState retval;
6413
6414 SpinLockAcquire(&XLogCtl->info_lck);
6415 retval = XLogCtl->SharedRecoveryState;
6416 SpinLockRelease(&XLogCtl->info_lck);
6417
6418 return retval;
6419 }
6420
6421 /*
6422 * Is this process allowed to insert new WAL records?
6423 *
6424 * Ordinarily this is essentially equivalent to !RecoveryInProgress().
6425 * But we also have provisions for forcing the result "true" or "false"
6426 * within specific processes regardless of the global state.
6427 */
6428 bool
6429 XLogInsertAllowed(void)
6430 {
6431 /*
6432 * If value is "unconditionally true" or "unconditionally false", just
6433 * return it. This provides the normal fast path once recovery is known
6434 * done.
6435 */
6436 if (LocalXLogInsertAllowed >= 0)
6437 return (bool) LocalXLogInsertAllowed;
6438
6439 /*
6440 * Else, must check to see if we're still in recovery.
6441 */
6442 if (RecoveryInProgress())
6443 return false;
6444
6445 /*
6446 * On exit from recovery, reset to "unconditionally true", since there is
6447 * no need to keep checking.
6448 */
6449 LocalXLogInsertAllowed = 1;
6450 return true;
6451 }
6452
6453 /*
6454 * Make XLogInsertAllowed() return true in the current process only.
6455 *
6456 * Note: it is allowed to switch LocalXLogInsertAllowed back to -1 later,
6457 * and even call LocalSetXLogInsertAllowed() again after that.
6458 *
6459 * Returns the previous value of LocalXLogInsertAllowed.
6460 */
6461 static int
6462 LocalSetXLogInsertAllowed(void)
6463 {
6464 int oldXLogAllowed = LocalXLogInsertAllowed;
6465
6466 LocalXLogInsertAllowed = 1;
6467
6468 return oldXLogAllowed;
6469 }
6470
6471 /*
6472 * Return the current Redo pointer from shared memory.
6473 *
6474 * As a side-effect, the local RedoRecPtr copy is updated.
6475 */
6476 XLogRecPtr
6477 GetRedoRecPtr(void)
6478 {
6479 XLogRecPtr ptr;
6480
6481 /*
6482 * The possibly not up-to-date copy in XlogCtl is enough. Even if we
6483 * grabbed a WAL insertion lock to read the authoritative value in
6484 * Insert->RedoRecPtr, someone might update it just after we've released
6485 * the lock.
6486 */
6487 SpinLockAcquire(&XLogCtl->info_lck);
6488 ptr = XLogCtl->RedoRecPtr;
6489 SpinLockRelease(&XLogCtl->info_lck);
6490
6491 if (RedoRecPtr < ptr)
6492 RedoRecPtr = ptr;
6493
6494 return RedoRecPtr;
6495 }
6496
6497 /*
6498 * Return information needed to decide whether a modified block needs a
6499 * full-page image to be included in the WAL record.
6500 *
6501 * The returned values are cached copies from backend-private memory, and
6502 * possibly out-of-date or, indeed, uninitialized, in which case they will
6503 * be InvalidXLogRecPtr and false, respectively. XLogInsertRecord will
6504 * re-check them against up-to-date values, while holding the WAL insert lock.
6505 */
6506 void
6507 GetFullPageWriteInfo(XLogRecPtr *RedoRecPtr_p, bool *doPageWrites_p)
6508 {
6509 *RedoRecPtr_p = RedoRecPtr;
6510 *doPageWrites_p = doPageWrites;
6511 }
6512
6513 /*
6514 * GetInsertRecPtr -- Returns the current insert position.
6515 *
6516 * NOTE: The value *actually* returned is the position of the last full
6517 * xlog page. It lags behind the real insert position by at most 1 page.
6518 * For that, we don't need to scan through WAL insertion locks, and an
6519 * approximation is enough for the current usage of this function.
6520 */
6521 XLogRecPtr
6522 GetInsertRecPtr(void)
6523 {
6524 XLogRecPtr recptr;
6525
6526 SpinLockAcquire(&XLogCtl->info_lck);
6527 recptr = XLogCtl->LogwrtRqst.Write;
6528 SpinLockRelease(&XLogCtl->info_lck);
6529
6530 return recptr;
6531 }
6532
6533 /*
6534 * GetFlushRecPtr -- Returns the current flush position, ie, the last WAL
6535 * position known to be fsync'd to disk. This should only be used on a
6536 * system that is known not to be in recovery.
6537 */
6538 XLogRecPtr
6539 GetFlushRecPtr(TimeLineID *insertTLI)
6540 {
6541 Assert(XLogCtl->SharedRecoveryState == RECOVERY_STATE_DONE);
6542
6543 RefreshXLogWriteResult(LogwrtResult);
6544
6545 /*
6546 * If we're writing and flushing WAL, the time line can't be changing, so
6547 * no lock is required.
6548 */
6549 if (insertTLI)
6550 *insertTLI = XLogCtl->InsertTimeLineID;
6551
6552 return LogwrtResult.Flush;
6553 }
6554
6555 /*
6556 * GetWALInsertionTimeLine -- Returns the current timeline of a system that
6557 * is not in recovery.
6558 */
6559 TimeLineID
6560 GetWALInsertionTimeLine(void)
6561 {
6562 Assert(XLogCtl->SharedRecoveryState == RECOVERY_STATE_DONE);
6563
6564 /* Since the value can't be changing, no lock is required. */
6565 return XLogCtl->InsertTimeLineID;
6566 }
6567
6568 /*
6569 * GetWALInsertionTimeLineIfSet -- If the system is not in recovery, returns
6570 * the WAL insertion timeline; else, returns 0. Wherever possible, use
6571 * GetWALInsertionTimeLine() instead, since it's cheaper. Note that this
6572 * function decides recovery has ended as soon as the insert TLI is set, which
6573 * happens before we set XLogCtl->SharedRecoveryState to RECOVERY_STATE_DONE.
6574 */
6575 TimeLineID
6576 GetWALInsertionTimeLineIfSet(void)
6577 {
6578 TimeLineID insertTLI;
6579
6580 SpinLockAcquire(&XLogCtl->info_lck);
6581 insertTLI = XLogCtl->InsertTimeLineID;
6582 SpinLockRelease(&XLogCtl->info_lck);
6583
6584 return insertTLI;
6585 }
6586
6587 /*
6588 * GetLastImportantRecPtr -- Returns the LSN of the last important record
6589 * inserted. All records not explicitly marked as unimportant are considered
6590 * important.
6591 *
6592 * The LSN is determined by computing the maximum of
6593 * WALInsertLocks[i].lastImportantAt.
6594 */
6595 XLogRecPtr
6596 GetLastImportantRecPtr(void)
6597 {
6598 XLogRecPtr res = InvalidXLogRecPtr;
6599 int i;
6600
6601 for (i = 0; i < NUM_XLOGINSERT_LOCKS; i++)
6602 {
6603 XLogRecPtr last_important;
6604
6605 /*
6606 * Need to take a lock to prevent torn reads of the LSN, which are
6607 * possible on some of the supported platforms. WAL insert locks only
6608 * support exclusive mode, so we have to use that.
6609 */
6610 LWLockAcquire(&WALInsertLocks[i].l.lock, LW_EXCLUSIVE);
6611 last_important = WALInsertLocks[i].l.lastImportantAt;
6612 LWLockRelease(&WALInsertLocks[i].l.lock);
6613
6614 if (res < last_important)
6615 res = last_important;
6616 }
6617
6618 return res;
6619 }
6620
6621 /*
6622 * Get the time and LSN of the last xlog segment switch
6623 */
6624 pg_time_t
6625 GetLastSegSwitchData(XLogRecPtr *lastSwitchLSN)
6626 {
6627 pg_time_t result;
6628
6629 /* Need WALWriteLock, but shared lock is sufficient */
6630 LWLockAcquire(WALWriteLock, LW_SHARED);
6631 result = XLogCtl->lastSegSwitchTime;
6632 *lastSwitchLSN = XLogCtl->lastSegSwitchLSN;
6633 LWLockRelease(WALWriteLock);
6634
6635 return result;
6636 }
6637
6638 /*
6639 * This must be called ONCE during postmaster or standalone-backend shutdown
6640 */
6641 void
6642 ShutdownXLOG(int code, Datum arg)
6643 {
6644 /*
6645 * We should have an aux process resource owner to use, and we should not
6646 * be in a transaction that's installed some other resowner.
6647 */
6648 Assert(AuxProcessResourceOwner != NULL);
6649 Assert(CurrentResourceOwner == NULL ||
6650 CurrentResourceOwner == AuxProcessResourceOwner);
6651 CurrentResourceOwner = AuxProcessResourceOwner;
6652
6653 /* Don't be chatty in standalone mode */
6654 ereport(IsPostmasterEnvironment ? LOG : NOTICE,
6655 (errmsg("shutting down")));
6656
6657 /*
6658 * Signal walsenders to move to stopping state.
6659 */
6660 WalSndInitStopping();
6661
6662 /*
6663 * Wait for WAL senders to be in stopping state. This prevents commands
6664 * from writing new WAL.
6665 */
6666 WalSndWaitStopping();
6667
6668 if (RecoveryInProgress())
6669 CreateRestartPoint(CHECKPOINT_IS_SHUTDOWN | CHECKPOINT_IMMEDIATE);
6670 else
6671 {
6672 /*
6673 * If archiving is enabled, rotate the last XLOG file so that all the
6674 * remaining records are archived (postmaster wakes up the archiver
6675 * process one more time at the end of shutdown). The checkpoint
6676 * record will go to the next XLOG file and won't be archived (yet).
6677 */
6678 if (XLogArchivingActive())
6679 RequestXLogSwitch(false);
6680
6681 CreateCheckPoint(CHECKPOINT_IS_SHUTDOWN | CHECKPOINT_IMMEDIATE);
6682 }
6683 }
6684
6685 /*
6686 * Log start of a checkpoint.
6687 */
6688 static void
6689 LogCheckpointStart(int flags, bool restartpoint)
6690 {
6691 if (restartpoint)
6692 ereport(LOG,
6693 /* translator: the placeholders show checkpoint options */
6694 (errmsg("restartpoint starting:%s%s%s%s%s%s%s%s",
6695 (flags & CHECKPOINT_IS_SHUTDOWN) ? " shutdown" : "",
6696 (flags & CHECKPOINT_END_OF_RECOVERY) ? " end-of-recovery" : "",
6697 (flags & CHECKPOINT_IMMEDIATE) ? " immediate" : "",
6698 (flags & CHECKPOINT_FORCE) ? " force" : "",
6699 (flags & CHECKPOINT_WAIT) ? " wait" : "",
6700 (flags & CHECKPOINT_CAUSE_XLOG) ? " wal" : "",
6701 (flags & CHECKPOINT_CAUSE_TIME) ? " time" : "",
6702 (flags & CHECKPOINT_FLUSH_ALL) ? " flush-all" : "")));
6703 else
6704 ereport(LOG,
6705 /* translator: the placeholders show checkpoint options */
6706 (errmsg("checkpoint starting:%s%s%s%s%s%s%s%s",
6707 (flags & CHECKPOINT_IS_SHUTDOWN) ? " shutdown" : "",
6708 (flags & CHECKPOINT_END_OF_RECOVERY) ? " end-of-recovery" : "",
6709 (flags & CHECKPOINT_IMMEDIATE) ? " immediate" : "",
6710 (flags & CHECKPOINT_FORCE) ? " force" : "",
6711 (flags & CHECKPOINT_WAIT) ? " wait" : "",
6712 (flags & CHECKPOINT_CAUSE_XLOG) ? " wal" : "",
6713 (flags & CHECKPOINT_CAUSE_TIME) ? " time" : "",
6714 (flags & CHECKPOINT_FLUSH_ALL) ? " flush-all" : "")));
6715 }
6716
6717 /*
6718 * Log end of a checkpoint.
6719 */
6720 static void
6721 LogCheckpointEnd(bool restartpoint)
6722 {
6723 long write_msecs,
6724 sync_msecs,
6725 total_msecs,
6726 longest_msecs,
6727 average_msecs;
6728 uint64 average_sync_time;
6729
6730 CheckpointStats.ckpt_end_t = GetCurrentTimestamp();
6731
6732 write_msecs = TimestampDifferenceMilliseconds(CheckpointStats.ckpt_write_t,
6733 CheckpointStats.ckpt_sync_t);
6734
6735 sync_msecs = TimestampDifferenceMilliseconds(CheckpointStats.ckpt_sync_t,
6736 CheckpointStats.ckpt_sync_end_t);
6737
6738 /* Accumulate checkpoint timing summary data, in milliseconds. */
6739 PendingCheckpointerStats.write_time += write_msecs;
6740 PendingCheckpointerStats.sync_time += sync_msecs;
6741
6742 /*
6743 * All of the published timing statistics are accounted for. Only
6744 * continue if a log message is to be written.
6745 */
6746 if (!log_checkpoints)
6747 return;
6748
6749 total_msecs = TimestampDifferenceMilliseconds(CheckpointStats.ckpt_start_t,
6750 CheckpointStats.ckpt_end_t);
6751
6752 /*
6753 * Timing values returned from CheckpointStats are in microseconds.
6754 * Convert to milliseconds for consistent printing.
6755 */
6756 longest_msecs = (long) ((CheckpointStats.ckpt_longest_sync + 999) / 1000);
6757
6758 average_sync_time = 0;
6759 if (CheckpointStats.ckpt_sync_rels > 0)
6760 average_sync_time = CheckpointStats.ckpt_agg_sync_time /
6761 CheckpointStats.ckpt_sync_rels;
6762 average_msecs = (long) ((average_sync_time + 999) / 1000);
6763
6764 /*
6765 * ControlFileLock is not required to see ControlFile->checkPoint and
6766 * ->checkPointCopy here as we are the only updator of those variables at
6767 * this moment.
6768 */
6769 if (restartpoint)
6770 ereport(LOG,
6771 (errmsg("restartpoint complete: wrote %d buffers (%.1f%%), "
6772 "wrote %d SLRU buffers; %d WAL file(s) added, "
6773 "%d removed, %d recycled; write=%ld.%03d s, "
6774 "sync=%ld.%03d s, total=%ld.%03d s; sync files=%d, "
6775 "longest=%ld.%03d s, average=%ld.%03d s; distance=%d kB, "
6776 "estimate=%d kB; lsn=%X/%X, redo lsn=%X/%X",
6777 CheckpointStats.ckpt_bufs_written,
6778 (double) CheckpointStats.ckpt_bufs_written * 100 / NBuffers,
6779 CheckpointStats.ckpt_slru_written,
6780 CheckpointStats.ckpt_segs_added,
6781 CheckpointStats.ckpt_segs_removed,
6782 CheckpointStats.ckpt_segs_recycled,
6783 write_msecs / 1000, (int) (write_msecs % 1000),
6784 sync_msecs / 1000, (int) (sync_msecs % 1000),
6785 total_msecs / 1000, (int) (total_msecs % 1000),
6786 CheckpointStats.ckpt_sync_rels,
6787 longest_msecs / 1000, (int) (longest_msecs % 1000),
6788 average_msecs / 1000, (int) (average_msecs % 1000),
6789 (int) (PrevCheckPointDistance / 1024.0),
6790 (int) (CheckPointDistanceEstimate / 1024.0),
6791 LSN_FORMAT_ARGS(ControlFile->checkPoint),
6792 LSN_FORMAT_ARGS(ControlFile->checkPointCopy.redo))));
6793 else
6794 ereport(LOG,
6795 (errmsg("checkpoint complete: wrote %d buffers (%.1f%%), "
6796 "wrote %d SLRU buffers; %d WAL file(s) added, "
6797 "%d removed, %d recycled; write=%ld.%03d s, "
6798 "sync=%ld.%03d s, total=%ld.%03d s; sync files=%d, "
6799 "longest=%ld.%03d s, average=%ld.%03d s; distance=%d kB, "
6800 "estimate=%d kB; lsn=%X/%X, redo lsn=%X/%X",
6801 CheckpointStats.ckpt_bufs_written,
6802 (double) CheckpointStats.ckpt_bufs_written * 100 / NBuffers,
6803 CheckpointStats.ckpt_slru_written,
6804 CheckpointStats.ckpt_segs_added,
6805 CheckpointStats.ckpt_segs_removed,
6806 CheckpointStats.ckpt_segs_recycled,
6807 write_msecs / 1000, (int) (write_msecs % 1000),
6808 sync_msecs / 1000, (int) (sync_msecs % 1000),
6809 total_msecs / 1000, (int) (total_msecs % 1000),
6810 CheckpointStats.ckpt_sync_rels,
6811 longest_msecs / 1000, (int) (longest_msecs % 1000),
6812 average_msecs / 1000, (int) (average_msecs % 1000),
6813 (int) (PrevCheckPointDistance / 1024.0),
6814 (int) (CheckPointDistanceEstimate / 1024.0),
6815 LSN_FORMAT_ARGS(ControlFile->checkPoint),
6816 LSN_FORMAT_ARGS(ControlFile->checkPointCopy.redo))));
6817 }
6818
6819 /*
6820 * Update the estimate of distance between checkpoints.
6821 *
6822 * The estimate is used to calculate the number of WAL segments to keep
6823 * preallocated, see XLOGfileslop().
6824 */
6825 static void
6826 UpdateCheckPointDistanceEstimate(uint64 nbytes)
6827 {
6828 /*
6829 * To estimate the number of segments consumed between checkpoints, keep a
6830 * moving average of the amount of WAL generated in previous checkpoint
6831 * cycles. However, if the load is bursty, with quiet periods and busy
6832 * periods, we want to cater for the peak load. So instead of a plain
6833 * moving average, let the average decline slowly if the previous cycle
6834 * used less WAL than estimated, but bump it up immediately if it used
6835 * more.
6836 *
6837 * When checkpoints are triggered by max_wal_size, this should converge to
6838 * CheckpointSegments * wal_segment_size,
6839 *
6840 * Note: This doesn't pay any attention to what caused the checkpoint.
6841 * Checkpoints triggered manually with CHECKPOINT command, or by e.g.
6842 * starting a base backup, are counted the same as those created
6843 * automatically. The slow-decline will largely mask them out, if they are
6844 * not frequent. If they are frequent, it seems reasonable to count them
6845 * in as any others; if you issue a manual checkpoint every 5 minutes and
6846 * never let a timed checkpoint happen, it makes sense to base the
6847 * preallocation on that 5 minute interval rather than whatever
6848 * checkpoint_timeout is set to.
6849 */
6850 PrevCheckPointDistance = nbytes;
6851 if (CheckPointDistanceEstimate < nbytes)
6852 CheckPointDistanceEstimate = nbytes;
6853 else
6854 CheckPointDistanceEstimate =
6855 (0.90 * CheckPointDistanceEstimate + 0.10 * (double) nbytes);
6856 }
6857
6858 /*
6859 * Update the ps display for a process running a checkpoint. Note that
6860 * this routine should not do any allocations so as it can be called
6861 * from a critical section.
6862 */
6863 static void
6864 update_checkpoint_display(int flags, bool restartpoint, bool reset)
6865 {
6866 /*
6867 * The status is reported only for end-of-recovery and shutdown
6868 * checkpoints or shutdown restartpoints. Updating the ps display is
6869 * useful in those situations as it may not be possible to rely on
6870 * pg_stat_activity to see the status of the checkpointer or the startup
6871 * process.
6872 */
6873 if ((flags & (CHECKPOINT_END_OF_RECOVERY | CHECKPOINT_IS_SHUTDOWN)) == 0)
6874 return;
6875
6876 if (reset)
6877 set_ps_display("");
6878 else
6879 {
6880 char activitymsg[128];
6881
6882 snprintf(activitymsg, sizeof(activitymsg), "performing %s%s%s",
6883 (flags & CHECKPOINT_END_OF_RECOVERY) ? "end-of-recovery " : "",
6884 (flags & CHECKPOINT_IS_SHUTDOWN) ? "shutdown " : "",
6885 restartpoint ? "restartpoint" : "checkpoint");
6886 set_ps_display(activitymsg);
6887 }
6888 }
6889
6890
6891 /*
6892 * Perform a checkpoint --- either during shutdown, or on-the-fly
6893 *
6894 * flags is a bitwise OR of the following:
6895 * CHECKPOINT_IS_SHUTDOWN: checkpoint is for database shutdown.
6896 * CHECKPOINT_END_OF_RECOVERY: checkpoint is for end of WAL recovery.
6897 * CHECKPOINT_IMMEDIATE: finish the checkpoint ASAP,
6898 * ignoring checkpoint_completion_target parameter.
6899 * CHECKPOINT_FORCE: force a checkpoint even if no XLOG activity has occurred
6900 * since the last one (implied by CHECKPOINT_IS_SHUTDOWN or
6901 * CHECKPOINT_END_OF_RECOVERY).
6902 * CHECKPOINT_FLUSH_ALL: also flush buffers of unlogged tables.
6903 *
6904 * Note: flags contains other bits, of interest here only for logging purposes.
6905 * In particular note that this routine is synchronous and does not pay
6906 * attention to CHECKPOINT_WAIT.
6907 *
6908 * If !shutdown then we are writing an online checkpoint. An XLOG_CHECKPOINT_REDO
6909 * record is inserted into WAL at the logical location of the checkpoint, before
6910 * flushing anything to disk, and when the checkpoint is eventually completed,
6911 * and it is from this point that WAL replay will begin in the case of a recovery
6912 * from this checkpoint. Once everything is written to disk, an
6913 * XLOG_CHECKPOINT_ONLINE record is written to complete the checkpoint, and
6914 * points back to the earlier XLOG_CHECKPOINT_REDO record. This mechanism allows
6915 * other write-ahead log records to be written while the checkpoint is in
6916 * progress, but we must be very careful about order of operations. This function
6917 * may take many minutes to execute on a busy system.
6918 *
6919 * On the other hand, when shutdown is true, concurrent insertion into the
6920 * write-ahead log is impossible, so there is no need for two separate records.
6921 * In this case, we only insert an XLOG_CHECKPOINT_SHUTDOWN record, and it's
6922 * both the record marking the completion of the checkpoint and the location
6923 * from which WAL replay would begin if needed.
6924 *
6925 * Returns true if a new checkpoint was performed, or false if it was skipped
6926 * because the system was idle.
6927 */
6928 bool
6929 CreateCheckPoint(int flags)
6930 {
6931 bool shutdown;
6932 CheckPoint checkPoint;
6933 XLogRecPtr recptr;
6934 XLogSegNo _logSegNo;
6935 XLogCtlInsert *Insert = &XLogCtl->Insert;
6936 uint32 freespace;
6937 XLogRecPtr PriorRedoPtr;
6938 XLogRecPtr last_important_lsn;
6939 VirtualTransactionId *vxids;
6940 int nvxids;
6941 int oldXLogAllowed = 0;
6942
6943 /*
6944 * An end-of-recovery checkpoint is really a shutdown checkpoint, just
6945 * issued at a different time.
6946 */
6947 if (flags & (CHECKPOINT_IS_SHUTDOWN | CHECKPOINT_END_OF_RECOVERY))
6948 shutdown = true;
6949 else
6950 shutdown = false;
6951
6952 /* sanity check */
6953 if (RecoveryInProgress() && (flags & CHECKPOINT_END_OF_RECOVERY) == 0)
6954 elog(ERROR, "can't create a checkpoint during recovery");
6955
6956 /*
6957 * Prepare to accumulate statistics.
6958 *
6959 * Note: because it is possible for log_checkpoints to change while a
6960 * checkpoint proceeds, we always accumulate stats, even if
6961 * log_checkpoints is currently off.
6962 */
6963 MemSet(&CheckpointStats, 0, sizeof(CheckpointStats));
6964 CheckpointStats.ckpt_start_t = GetCurrentTimestamp();
6965
6966 /*
6967 * Let smgr prepare for checkpoint; this has to happen outside the
6968 * critical section and before we determine the REDO pointer. Note that
6969 * smgr must not do anything that'd have to be undone if we decide no
6970 * checkpoint is needed.
6971 */
6972 SyncPreCheckpoint();
6973
6974 /*
6975 * Use a critical section to force system panic if we have trouble.
6976 */
6977 START_CRIT_SECTION();
6978
6979 if (shutdown)
6980 {
6981 LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
6982 ControlFile->state = DB_SHUTDOWNING;
6983 UpdateControlFile();
6984 LWLockRelease(ControlFileLock);
6985 }
6986
6987 /* Begin filling in the checkpoint WAL record */
6988 MemSet(&checkPoint, 0, sizeof(checkPoint));
6989 checkPoint.time = (pg_time_t) time(NULL);
6990
6991 /*
6992 * For Hot Standby, derive the oldestActiveXid before we fix the redo
6993 * pointer. This allows us to begin accumulating changes to assemble our
6994 * starting snapshot of locks and transactions.
6995 */
6996 if (!shutdown && XLogStandbyInfoActive())
6997 checkPoint.oldestActiveXid = GetOldestActiveTransactionId();
6998 else
6999 checkPoint.oldestActiveXid = InvalidTransactionId;
7000
7001 /*
7002 * Get location of last important record before acquiring insert locks (as
7003 * GetLastImportantRecPtr() also locks WAL locks).
7004 */
7005 last_important_lsn = GetLastImportantRecPtr();
7006
7007 /*
7008 * If this isn't a shutdown or forced checkpoint, and if there has been no
7009 * WAL activity requiring a checkpoint, skip it. The idea here is to
7010 * avoid inserting duplicate checkpoints when the system is idle.
7011 */
7012 if ((flags & (CHECKPOINT_IS_SHUTDOWN | CHECKPOINT_END_OF_RECOVERY |
7013 CHECKPOINT_FORCE)) == 0)
7014 {
7015 if (last_important_lsn == ControlFile->checkPoint)
7016 {
7017 END_CRIT_SECTION();
7018 ereport(DEBUG1,
7019 (errmsg_internal("checkpoint skipped because system is idle")));
7020 return false;
7021 }
7022 }
7023
7024 /*
7025 * An end-of-recovery checkpoint is created before anyone is allowed to
7026 * write WAL. To allow us to write the checkpoint record, temporarily
7027 * enable XLogInsertAllowed.
7028 */
7029 if (flags & CHECKPOINT_END_OF_RECOVERY)
7030 oldXLogAllowed = LocalSetXLogInsertAllowed();
7031
7032 checkPoint.ThisTimeLineID = XLogCtl->InsertTimeLineID;
7033 if (flags & CHECKPOINT_END_OF_RECOVERY)
7034 checkPoint.PrevTimeLineID = XLogCtl->PrevTimeLineID;
7035 else
7036 checkPoint.PrevTimeLineID = checkPoint.ThisTimeLineID;
7037
7038 /*
7039 * We must block concurrent insertions while examining insert state.
7040 */
7041 WALInsertLockAcquireExclusive();
7042
7043 checkPoint.fullPageWrites = Insert->fullPageWrites;
7044 checkPoint.wal_level = wal_level;
7045
7046 if (shutdown)
7047 {
7048 XLogRecPtr curInsert = XLogBytePosToRecPtr(Insert->CurrBytePos);
7049
7050 /*
7051 * Compute new REDO record ptr = location of next XLOG record.
7052 *
7053 * Since this is a shutdown checkpoint, there can't be any concurrent
7054 * WAL insertion.
7055 */
7056 freespace = INSERT_FREESPACE(curInsert);
7057 if (freespace == 0)
7058 {
7059 if (XLogSegmentOffset(curInsert, wal_segment_size) == 0)
7060 curInsert += SizeOfXLogLongPHD;
7061 else
7062 curInsert += SizeOfXLogShortPHD;
7063 }
7064 checkPoint.redo = curInsert;
7065
7066 /*
7067 * Here we update the shared RedoRecPtr for future XLogInsert calls;
7068 * this must be done while holding all the insertion locks.
7069 *
7070 * Note: if we fail to complete the checkpoint, RedoRecPtr will be
7071 * left pointing past where it really needs to point. This is okay;
7072 * the only consequence is that XLogInsert might back up whole buffers
7073 * that it didn't really need to. We can't postpone advancing
7074 * RedoRecPtr because XLogInserts that happen while we are dumping
7075 * buffers must assume that their buffer changes are not included in
7076 * the checkpoint.
7077 */
7078 RedoRecPtr = XLogCtl->Insert.RedoRecPtr = checkPoint.redo;
7079 }
7080
7081 /*
7082 * Now we can release the WAL insertion locks, allowing other xacts to
7083 * proceed while we are flushing disk buffers.
7084 */
7085 WALInsertLockRelease();
7086
7087 /*
7088 * If this is an online checkpoint, we have not yet determined the redo
7089 * point. We do so now by inserting the special XLOG_CHECKPOINT_REDO
7090 * record; the LSN at which it starts becomes the new redo pointer. We
7091 * don't do this for a shutdown checkpoint, because in that case no WAL
7092 * can be written between the redo point and the insertion of the
7093 * checkpoint record itself, so the checkpoint record itself serves to
7094 * mark the redo point.
7095 */
7096 if (!shutdown)
7097 {
7098 /* Include WAL level in record for WAL summarizer's benefit. */
7099 XLogBeginInsert();
7100 XLogRegisterData(&wal_level, sizeof(wal_level));
7101 (void) XLogInsert(RM_XLOG_ID, XLOG_CHECKPOINT_REDO);
7102
7103 /*
7104 * XLogInsertRecord will have updated XLogCtl->Insert.RedoRecPtr in
7105 * shared memory and RedoRecPtr in backend-local memory, but we need
7106 * to copy that into the record that will be inserted when the
7107 * checkpoint is complete.
7108 */
7109 checkPoint.redo = RedoRecPtr;
7110 }
7111
7112 /* Update the info_lck-protected copy of RedoRecPtr as well */
7113 SpinLockAcquire(&XLogCtl->info_lck);
7114 XLogCtl->RedoRecPtr = checkPoint.redo;
7115 SpinLockRelease(&XLogCtl->info_lck);
7116
7117 /*
7118 * If enabled, log checkpoint start. We postpone this until now so as not
7119 * to log anything if we decided to skip the checkpoint.
7120 */
7121 if (log_checkpoints)
7122 LogCheckpointStart(flags, false);
7123
7124 /* Update the process title */
7125 update_checkpoint_display(flags, false, false);
7126
7127 TRACE_POSTGRESQL_CHECKPOINT_START(flags);
7128
7129 /*
7130 * Get the other info we need for the checkpoint record.
7131 *
7132 * We don't need to save oldestClogXid in the checkpoint, it only matters
7133 * for the short period in which clog is being truncated, and if we crash
7134 * during that we'll redo the clog truncation and fix up oldestClogXid
7135 * there.
7136 */
7137 LWLockAcquire(XidGenLock, LW_SHARED);
7138 checkPoint.nextXid = TransamVariables->nextXid;
7139 checkPoint.oldestXid = TransamVariables->oldestXid;
7140 checkPoint.oldestXidDB = TransamVariables->oldestXidDB;
7141 LWLockRelease(XidGenLock);
7142
7143 LWLockAcquire(CommitTsLock, LW_SHARED);
7144 checkPoint.oldestCommitTsXid = TransamVariables->oldestCommitTsXid;
7145 checkPoint.newestCommitTsXid = TransamVariables->newestCommitTsXid;
7146 LWLockRelease(CommitTsLock);
7147
7148 LWLockAcquire(OidGenLock, LW_SHARED);
7149 checkPoint.nextOid = TransamVariables->nextOid;
7150 if (!shutdown)
7151 checkPoint.nextOid += TransamVariables->oidCount;
7152 LWLockRelease(OidGenLock);
7153
7154 MultiXactGetCheckptMulti(shutdown,
7155 &checkPoint.nextMulti,
7156 &checkPoint.nextMultiOffset,
7157 &checkPoint.oldestMulti,
7158 &checkPoint.oldestMultiDB);
7159
7160 /*
7161 * Having constructed the checkpoint record, ensure all shmem disk buffers
7162 * and commit-log buffers are flushed to disk.
7163 *
7164 * This I/O could fail for various reasons. If so, we will fail to
7165 * complete the checkpoint, but there is no reason to force a system
7166 * panic. Accordingly, exit critical section while doing it.
7167 */
7168 END_CRIT_SECTION();
7169
7170 /*
7171 * In some cases there are groups of actions that must all occur on one
7172 * side or the other of a checkpoint record. Before flushing the
7173 * checkpoint record we must explicitly wait for any backend currently
7174 * performing those groups of actions.
7175 *
7176 * One example is end of transaction, so we must wait for any transactions
7177 * that are currently in commit critical sections. If an xact inserted
7178 * its commit record into XLOG just before the REDO point, then a crash
7179 * restart from the REDO point would not replay that record, which means
7180 * that our flushing had better include the xact's update of pg_xact. So
7181 * we wait till he's out of his commit critical section before proceeding.
7182 * See notes in RecordTransactionCommit().
7183 *
7184 * Because we've already released the insertion locks, this test is a bit
7185 * fuzzy: it is possible that we will wait for xacts we didn't really need
7186 * to wait for. But the delay should be short and it seems better to make
7187 * checkpoint take a bit longer than to hold off insertions longer than
7188 * necessary. (In fact, the whole reason we have this issue is that xact.c
7189 * does commit record XLOG insertion and clog update as two separate steps
7190 * protected by different locks, but again that seems best on grounds of
7191 * minimizing lock contention.)
7192 *
7193 * A transaction that has not yet set delayChkptFlags when we look cannot
7194 * be at risk, since it has not inserted its commit record yet; and one
7195 * that's already cleared it is not at risk either, since it's done fixing
7196 * clog and we will correctly flush the update below. So we cannot miss
7197 * any xacts we need to wait for.
7198 */
7199 vxids = GetVirtualXIDsDelayingChkpt(&nvxids, DELAY_CHKPT_START);
7200 if (nvxids > 0)
7201 {
7202 do
7203 {
7204 /*
7205 * Keep absorbing fsync requests while we wait. There could even
7206 * be a deadlock if we don't, if the process that prevents the
7207 * checkpoint is trying to add a request to the queue.
7208 */
7209 AbsorbSyncRequests();
7210
7211 pgstat_report_wait_start(WAIT_EVENT_CHECKPOINT_DELAY_START);
7212 pg_usleep(10000L); /* wait for 10 msec */
7213 pgstat_report_wait_end();
7214 } while (HaveVirtualXIDsDelayingChkpt(vxids, nvxids,
7215 DELAY_CHKPT_START));
7216 }
7217 pfree(vxids);
7218
7219 CheckPointGuts(checkPoint.redo, flags);
7220
7221 vxids = GetVirtualXIDsDelayingChkpt(&nvxids, DELAY_CHKPT_COMPLETE);
7222 if (nvxids > 0)
7223 {
7224 do
7225 {
7226 AbsorbSyncRequests();
7227
7228 pgstat_report_wait_start(WAIT_EVENT_CHECKPOINT_DELAY_COMPLETE);
7229 pg_usleep(10000L); /* wait for 10 msec */
7230 pgstat_report_wait_end();
7231 } while (HaveVirtualXIDsDelayingChkpt(vxids, nvxids,
7232 DELAY_CHKPT_COMPLETE));
7233 }
7234 pfree(vxids);
7235
7236 /*
7237 * Take a snapshot of running transactions and write this to WAL. This
7238 * allows us to reconstruct the state of running transactions during
7239 * archive recovery, if required. Skip, if this info disabled.
7240 *
7241 * If we are shutting down, or Startup process is completing crash
7242 * recovery we don't need to write running xact data.
7243 */
7244 if (!shutdown && XLogStandbyInfoActive())
7245 LogStandbySnapshot();
7246
7247 START_CRIT_SECTION();
7248
7249 /*
7250 * Now insert the checkpoint record into XLOG.
7251 */
7252 XLogBeginInsert();
7253 XLogRegisterData(&checkPoint, sizeof(checkPoint));
7254 recptr = XLogInsert(RM_XLOG_ID,
7255 shutdown ? XLOG_CHECKPOINT_SHUTDOWN :
7256 XLOG_CHECKPOINT_ONLINE);
7257
7258 XLogFlush(recptr);
7259
7260 /*
7261 * We mustn't write any new WAL after a shutdown checkpoint, or it will be
7262 * overwritten at next startup. No-one should even try, this just allows
7263 * sanity-checking. In the case of an end-of-recovery checkpoint, we want
7264 * to just temporarily disable writing until the system has exited
7265 * recovery.
7266 */
7267 if (shutdown)
7268 {
7269 if (flags & CHECKPOINT_END_OF_RECOVERY)
7270 LocalXLogInsertAllowed = oldXLogAllowed;
7271 else
7272 LocalXLogInsertAllowed = 0; /* never again write WAL */
7273 }
7274
7275 /*
7276 * We now have ProcLastRecPtr = start of actual checkpoint record, recptr
7277 * = end of actual checkpoint record.
7278 */
7279 if (shutdown && checkPoint.redo != ProcLastRecPtr)
7280 ereport(PANIC,
7281 (errmsg("concurrent write-ahead log activity while database system is shutting down")));
7282
7283 /*
7284 * Remember the prior checkpoint's redo ptr for
7285 * UpdateCheckPointDistanceEstimate()
7286 */
7287 PriorRedoPtr = ControlFile->checkPointCopy.redo;
7288
7289 /*
7290 * Update the control file.
7291 */
7292 LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
7293 if (shutdown)
7294 ControlFile->state = DB_SHUTDOWNED;
7295 ControlFile->checkPoint = ProcLastRecPtr;
7296 ControlFile->checkPointCopy = checkPoint;
7297 /* crash recovery should always recover to the end of WAL */
7298 ControlFile->minRecoveryPoint = InvalidXLogRecPtr;
7299 ControlFile->minRecoveryPointTLI = 0;
7300
7301 /*
7302 * Persist unloggedLSN value. It's reset on crash recovery, so this goes
7303 * unused on non-shutdown checkpoints, but seems useful to store it always
7304 * for debugging purposes.
7305 */
7306 ControlFile->unloggedLSN = pg_atomic_read_membarrier_u64(&XLogCtl->unloggedLSN);
7307
7308 UpdateControlFile();
7309 LWLockRelease(ControlFileLock);
7310
7311 /* Update shared-memory copy of checkpoint XID/epoch */
7312 SpinLockAcquire(&XLogCtl->info_lck);
7313 XLogCtl->ckptFullXid = checkPoint.nextXid;
7314 SpinLockRelease(&XLogCtl->info_lck);
7315
7316 /*
7317 * We are now done with critical updates; no need for system panic if we
7318 * have trouble while fooling with old log segments.
7319 */
7320 END_CRIT_SECTION();
7321
7322 /*
7323 * WAL summaries end when the next XLOG_CHECKPOINT_REDO or
7324 * XLOG_CHECKPOINT_SHUTDOWN record is reached. This is the first point
7325 * where (a) we're not inside of a critical section and (b) we can be
7326 * certain that the relevant record has been flushed to disk, which must
7327 * happen before it can be summarized.
7328 *
7329 * If this is a shutdown checkpoint, then this happens reasonably
7330 * promptly: we've only just inserted and flushed the
7331 * XLOG_CHECKPOINT_SHUTDOWN record. If this is not a shutdown checkpoint,
7332 * then this might not be very prompt at all: the XLOG_CHECKPOINT_REDO
7333 * record was written before we began flushing data to disk, and that
7334 * could be many minutes ago at this point. However, we don't XLogFlush()
7335 * after inserting that record, so we're not guaranteed that it's on disk
7336 * until after the above call that flushes the XLOG_CHECKPOINT_ONLINE
7337 * record.
7338 */
7339 WakeupWalSummarizer();
7340
7341 /*
7342 * Let smgr do post-checkpoint cleanup (eg, deleting old files).
7343 */
7344 SyncPostCheckpoint();
7345
7346 /*
7347 * Update the average distance between checkpoints if the prior checkpoint
7348 * exists.
7349 */
7350 if (PriorRedoPtr != InvalidXLogRecPtr)
7351 UpdateCheckPointDistanceEstimate(RedoRecPtr - PriorRedoPtr);
7352
7353 INJECTION_POINT("checkpoint-before-old-wal-removal", NULL);
7354
7355 /*
7356 * Delete old log files, those no longer needed for last checkpoint to
7357 * prevent the disk holding the xlog from growing full.
7358 */
7359 XLByteToSeg(RedoRecPtr, _logSegNo, wal_segment_size);
7360 KeepLogSeg(recptr, &_logSegNo);
7361 if (InvalidateObsoleteReplicationSlots(RS_INVAL_WAL_REMOVED | RS_INVAL_IDLE_TIMEOUT,
7362 _logSegNo, InvalidOid,
7363 InvalidTransactionId))
7364 {
7365 /*
7366 * Some slots have been invalidated; recalculate the old-segment
7367 * horizon, starting again from RedoRecPtr.
7368 */
7369 XLByteToSeg(RedoRecPtr, _logSegNo, wal_segment_size);
7370 KeepLogSeg(recptr, &_logSegNo);
7371 }
7372 _logSegNo--;
7373 RemoveOldXlogFiles(_logSegNo, RedoRecPtr, recptr,
7374 checkPoint.ThisTimeLineID);
7375
7376 /*
7377 * Make more log segments if needed. (Do this after recycling old log
7378 * segments, since that may supply some of the needed files.)
7379 */
7380 if (!shutdown)
7381 PreallocXlogFiles(recptr, checkPoint.ThisTimeLineID);
7382
7383 /*
7384 * Truncate pg_subtrans if possible. We can throw away all data before
7385 * the oldest XMIN of any running transaction. No future transaction will
7386 * attempt to reference any pg_subtrans entry older than that (see Asserts
7387 * in subtrans.c). During recovery, though, we mustn't do this because
7388 * StartupSUBTRANS hasn't been called yet.
7389 */
7390 if (!RecoveryInProgress())
7391 TruncateSUBTRANS(GetOldestTransactionIdConsideredRunning());
7392
7393 /* Real work is done; log and update stats. */
7394 LogCheckpointEnd(false);
7395
7396 /* Reset the process title */
7397 update_checkpoint_display(flags, false, true);
7398
7399 TRACE_POSTGRESQL_CHECKPOINT_DONE(CheckpointStats.ckpt_bufs_written,
7400 NBuffers,
7401 CheckpointStats.ckpt_segs_added,
7402 CheckpointStats.ckpt_segs_removed,
7403 CheckpointStats.ckpt_segs_recycled);
7404
7405 return true;
7406 }
7407
7408 /*
7409 * Mark the end of recovery in WAL though without running a full checkpoint.
7410 * We can expect that a restartpoint is likely to be in progress as we
7411 * do this, though we are unwilling to wait for it to complete.
7412 *
7413 * CreateRestartPoint() allows for the case where recovery may end before
7414 * the restartpoint completes so there is no concern of concurrent behaviour.
7415 */
7416 static void
7417 CreateEndOfRecoveryRecord(void)
7418 {
7419 xl_end_of_recovery xlrec;
7420 XLogRecPtr recptr;
7421
7422 /* sanity check */
7423 if (!RecoveryInProgress())
7424 elog(ERROR, "can only be used to end recovery");
7425
7426 xlrec.end_time = GetCurrentTimestamp();
7427 xlrec.wal_level = wal_level;
7428
7429 WALInsertLockAcquireExclusive();
7430 xlrec.ThisTimeLineID = XLogCtl->InsertTimeLineID;
7431 xlrec.PrevTimeLineID = XLogCtl->PrevTimeLineID;
7432 WALInsertLockRelease();
7433
7434 START_CRIT_SECTION();
7435
7436 XLogBeginInsert();
7437 XLogRegisterData(&xlrec, sizeof(xl_end_of_recovery));
7438 recptr = XLogInsert(RM_XLOG_ID, XLOG_END_OF_RECOVERY);
7439
7440 XLogFlush(recptr);
7441
7442 /*
7443 * Update the control file so that crash recovery can follow the timeline
7444 * changes to this point.
7445 */
7446 LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
7447 ControlFile->minRecoveryPoint = recptr;
7448 ControlFile->minRecoveryPointTLI = xlrec.ThisTimeLineID;
7449 UpdateControlFile();
7450 LWLockRelease(ControlFileLock);
7451
7452 END_CRIT_SECTION();
7453 }
7454
7455 /*
7456 * Write an OVERWRITE_CONTRECORD message.
7457 *
7458 * When on WAL replay we expect a continuation record at the start of a page
7459 * that is not there, recovery ends and WAL writing resumes at that point.
7460 * But it's wrong to resume writing new WAL back at the start of the record
7461 * that was broken, because downstream consumers of that WAL (physical
7462 * replicas) are not prepared to "rewind". So the first action after
7463 * finishing replay of all valid WAL must be to write a record of this type
7464 * at the point where the contrecord was missing; to support xlogreader
7465 * detecting the special case, XLP_FIRST_IS_OVERWRITE_CONTRECORD is also added
7466 * to the page header where the record occurs. xlogreader has an ad-hoc
7467 * mechanism to report metadata about the broken record, which is what we
7468 * use here.
7469 *
7470 * At replay time, XLP_FIRST_IS_OVERWRITE_CONTRECORD instructs xlogreader to
7471 * skip the record it was reading, and pass back the LSN of the skipped
7472 * record, so that its caller can verify (on "replay" of that record) that the
7473 * XLOG_OVERWRITE_CONTRECORD matches what was effectively overwritten.
7474 *
7475 * 'aborted_lsn' is the beginning position of the record that was incomplete.
7476 * It is included in the WAL record. 'pagePtr' and 'newTLI' point to the
7477 * beginning of the XLOG page where the record is to be inserted. They must
7478 * match the current WAL insert position, they're passed here just so that we
7479 * can verify that.
7480 */
7481 static XLogRecPtr
7482 CreateOverwriteContrecordRecord(XLogRecPtr aborted_lsn, XLogRecPtr pagePtr,
7483 TimeLineID newTLI)
7484 {
7485 xl_overwrite_contrecord xlrec;
7486 XLogRecPtr recptr;
7487 XLogPageHeader pagehdr;
7488 XLogRecPtr startPos;
7489
7490 /* sanity checks */
7491 if (!RecoveryInProgress())
7492 elog(ERROR, "can only be used at end of recovery");
7493 if (pagePtr % XLOG_BLCKSZ != 0)
7494 elog(ERROR, "invalid position for missing continuation record %X/%X",
7495 LSN_FORMAT_ARGS(pagePtr));
7496
7497 /* The current WAL insert position should be right after the page header */
7498 startPos = pagePtr;
7499 if (XLogSegmentOffset(startPos, wal_segment_size) == 0)
7500 startPos += SizeOfXLogLongPHD;
7501 else
7502 startPos += SizeOfXLogShortPHD;
7503 recptr = GetXLogInsertRecPtr();
7504 if (recptr != startPos)
7505 elog(ERROR, "invalid WAL insert position %X/%X for OVERWRITE_CONTRECORD",
7506 LSN_FORMAT_ARGS(recptr));
7507
7508 START_CRIT_SECTION();
7509
7510 /*
7511 * Initialize the XLOG page header (by GetXLogBuffer), and set the
7512 * XLP_FIRST_IS_OVERWRITE_CONTRECORD flag.
7513 *
7514 * No other backend is allowed to write WAL yet, so acquiring the WAL
7515 * insertion lock is just pro forma.
7516 */
7517 WALInsertLockAcquire();
7518 pagehdr = (XLogPageHeader) GetXLogBuffer(pagePtr, newTLI);
7519 pagehdr->xlp_info |= XLP_FIRST_IS_OVERWRITE_CONTRECORD;
7520 WALInsertLockRelease();
7521
7522 /*
7523 * Insert the XLOG_OVERWRITE_CONTRECORD record as the first record on the
7524 * page. We know it becomes the first record, because no other backend is
7525 * allowed to write WAL yet.
7526 */
7527 XLogBeginInsert();
7528 xlrec.overwritten_lsn = aborted_lsn;
7529 xlrec.overwrite_time = GetCurrentTimestamp();
7530 XLogRegisterData(&xlrec, sizeof(xl_overwrite_contrecord));
7531 recptr = XLogInsert(RM_XLOG_ID, XLOG_OVERWRITE_CONTRECORD);
7532
7533 /* check that the record was inserted to the right place */
7534 if (ProcLastRecPtr != startPos)
7535 elog(ERROR, "OVERWRITE_CONTRECORD was inserted to unexpected position %X/%X",
7536 LSN_FORMAT_ARGS(ProcLastRecPtr));
7537
7538 XLogFlush(recptr);
7539
7540 END_CRIT_SECTION();
7541
7542 return recptr;
7543 }
7544
7545 /*
7546 * Flush all data in shared memory to disk, and fsync
7547 *
7548 * This is the common code shared between regular checkpoints and
7549 * recovery restartpoints.
7550 */
7551 static void
7552 CheckPointGuts(XLogRecPtr checkPointRedo, int flags)
7553 {
7554 CheckPointRelationMap();
7555 CheckPointReplicationSlots(flags & CHECKPOINT_IS_SHUTDOWN);
7556 CheckPointSnapBuild();
7557 CheckPointLogicalRewriteHeap();
7558 CheckPointReplicationOrigin();
7559
7560 /* Write out all dirty data in SLRUs and the main buffer pool */
7561 TRACE_POSTGRESQL_BUFFER_CHECKPOINT_START(flags);
7562 CheckpointStats.ckpt_write_t = GetCurrentTimestamp();
7563 CheckPointCLOG();
7564 CheckPointCommitTs();
7565 CheckPointSUBTRANS();
7566 CheckPointMultiXact();
7567 CheckPointPredicate();
7568 CheckPointBuffers(flags);
7569
7570 /* Perform all queued up fsyncs */
7571 TRACE_POSTGRESQL_BUFFER_CHECKPOINT_SYNC_START();
7572 CheckpointStats.ckpt_sync_t = GetCurrentTimestamp();
7573 ProcessSyncRequests();
7574 CheckpointStats.ckpt_sync_end_t = GetCurrentTimestamp();
7575 TRACE_POSTGRESQL_BUFFER_CHECKPOINT_DONE();
7576
7577 /* We deliberately delay 2PC checkpointing as long as possible */
7578 CheckPointTwoPhase(checkPointRedo);
7579 }
7580
7581 /*
7582 * Save a checkpoint for recovery restart if appropriate
7583 *
7584 * This function is called each time a checkpoint record is read from XLOG.
7585 * It must determine whether the checkpoint represents a safe restartpoint or
7586 * not. If so, the checkpoint record is stashed in shared memory so that
7587 * CreateRestartPoint can consult it. (Note that the latter function is
7588 * executed by the checkpointer, while this one will be executed by the
7589 * startup process.)
7590 */
7591 static void
7592 RecoveryRestartPoint(const CheckPoint *checkPoint, XLogReaderState *record)
7593 {
7594 /*
7595 * Also refrain from creating a restartpoint if we have seen any
7596 * references to non-existent pages. Restarting recovery from the
7597 * restartpoint would not see the references, so we would lose the
7598 * cross-check that the pages belonged to a relation that was dropped
7599 * later.
7600 */
7601 if (XLogHaveInvalidPages())
7602 {
7603 elog(DEBUG2,
7604 "could not record restart point at %X/%X because there "
7605 "are unresolved references to invalid pages",
7606 LSN_FORMAT_ARGS(checkPoint->redo));
7607 return;
7608 }
7609
7610 /*
7611 * Copy the checkpoint record to shared memory, so that checkpointer can
7612 * work out the next time it wants to perform a restartpoint.
7613 */
7614 SpinLockAcquire(&XLogCtl->info_lck);
7615 XLogCtl->lastCheckPointRecPtr = record->ReadRecPtr;
7616 XLogCtl->lastCheckPointEndPtr = record->EndRecPtr;
7617 XLogCtl->lastCheckPoint = *checkPoint;
7618 SpinLockRelease(&XLogCtl->info_lck);
7619 }
7620
7621 /*
7622 * Establish a restartpoint if possible.
7623 *
7624 * This is similar to CreateCheckPoint, but is used during WAL recovery
7625 * to establish a point from which recovery can roll forward without
7626 * replaying the entire recovery log.
7627 *
7628 * Returns true if a new restartpoint was established. We can only establish
7629 * a restartpoint if we have replayed a safe checkpoint record since last
7630 * restartpoint.
7631 */
7632 bool
7633 CreateRestartPoint(int flags)
7634 {
7635 XLogRecPtr lastCheckPointRecPtr;
7636 XLogRecPtr lastCheckPointEndPtr;
7637 CheckPoint lastCheckPoint;
7638 XLogRecPtr PriorRedoPtr;
7639 XLogRecPtr receivePtr;
7640 XLogRecPtr replayPtr;
7641 TimeLineID replayTLI;
7642 XLogRecPtr endptr;
7643 XLogSegNo _logSegNo;
7644 TimestampTz xtime;
7645
7646 /* Concurrent checkpoint/restartpoint cannot happen */
7647 Assert(!IsUnderPostmaster || MyBackendType == B_CHECKPOINTER);
7648
7649 /* Get a local copy of the last safe checkpoint record. */
7650 SpinLockAcquire(&XLogCtl->info_lck);
7651 lastCheckPointRecPtr = XLogCtl->lastCheckPointRecPtr;
7652 lastCheckPointEndPtr = XLogCtl->lastCheckPointEndPtr;
7653 lastCheckPoint = XLogCtl->lastCheckPoint;
7654 SpinLockRelease(&XLogCtl->info_lck);
7655
7656 /*
7657 * Check that we're still in recovery mode. It's ok if we exit recovery
7658 * mode after this check, the restart point is valid anyway.
7659 */
7660 if (!RecoveryInProgress())
7661 {
7662 ereport(DEBUG2,
7663 (errmsg_internal("skipping restartpoint, recovery has already ended")));
7664 return false;
7665 }
7666
7667 /*
7668 * If the last checkpoint record we've replayed is already our last
7669 * restartpoint, we can't perform a new restart point. We still update
7670 * minRecoveryPoint in that case, so that if this is a shutdown restart
7671 * point, we won't start up earlier than before. That's not strictly
7672 * necessary, but when hot standby is enabled, it would be rather weird if
7673 * the database opened up for read-only connections at a point-in-time
7674 * before the last shutdown. Such time travel is still possible in case of
7675 * immediate shutdown, though.
7676 *
7677 * We don't explicitly advance minRecoveryPoint when we do create a
7678 * restartpoint. It's assumed that flushing the buffers will do that as a
7679 * side-effect.
7680 */
7681 if (XLogRecPtrIsInvalid(lastCheckPointRecPtr) ||
7682 lastCheckPoint.redo <= ControlFile->checkPointCopy.redo)
7683 {
7684 ereport(DEBUG2,
7685 (errmsg_internal("skipping restartpoint, already performed at %X/%X",
7686 LSN_FORMAT_ARGS(lastCheckPoint.redo))));
7687
7688 UpdateMinRecoveryPoint(InvalidXLogRecPtr, true);
7689 if (flags & CHECKPOINT_IS_SHUTDOWN)
7690 {
7691 LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
7692 ControlFile->state = DB_SHUTDOWNED_IN_RECOVERY;
7693 UpdateControlFile();
7694 LWLockRelease(ControlFileLock);
7695 }
7696 return false;
7697 }
7698
7699 /*
7700 * Update the shared RedoRecPtr so that the startup process can calculate
7701 * the number of segments replayed since last restartpoint, and request a
7702 * restartpoint if it exceeds CheckPointSegments.
7703 *
7704 * Like in CreateCheckPoint(), hold off insertions to update it, although
7705 * during recovery this is just pro forma, because no WAL insertions are
7706 * happening.
7707 */
7708 WALInsertLockAcquireExclusive();
7709 RedoRecPtr = XLogCtl->Insert.RedoRecPtr = lastCheckPoint.redo;
7710 WALInsertLockRelease();
7711
7712 /* Also update the info_lck-protected copy */
7713 SpinLockAcquire(&XLogCtl->info_lck);
7714 XLogCtl->RedoRecPtr = lastCheckPoint.redo;
7715 SpinLockRelease(&XLogCtl->info_lck);
7716
7717 /*
7718 * Prepare to accumulate statistics.
7719 *
7720 * Note: because it is possible for log_checkpoints to change while a
7721 * checkpoint proceeds, we always accumulate stats, even if
7722 * log_checkpoints is currently off.
7723 */
7724 MemSet(&CheckpointStats, 0, sizeof(CheckpointStats));
7725 CheckpointStats.ckpt_start_t = GetCurrentTimestamp();
7726
7727 if (log_checkpoints)
7728 LogCheckpointStart(flags, true);
7729
7730 /* Update the process title */
7731 update_checkpoint_display(flags, true, false);
7732
7733 CheckPointGuts(lastCheckPoint.redo, flags);
7734
7735 /*
7736 * This location needs to be after CheckPointGuts() to ensure that some
7737 * work has already happened during this checkpoint.
7738 */
7739 INJECTION_POINT("create-restart-point", NULL);
7740
7741 /*
7742 * Remember the prior checkpoint's redo ptr for
7743 * UpdateCheckPointDistanceEstimate()
7744 */
7745 PriorRedoPtr = ControlFile->checkPointCopy.redo;
7746
7747 /*
7748 * Update pg_control, using current time. Check that it still shows an
7749 * older checkpoint, else do nothing; this is a quick hack to make sure
7750 * nothing really bad happens if somehow we get here after the
7751 * end-of-recovery checkpoint.
7752 */
7753 LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
7754 if (ControlFile->checkPointCopy.redo < lastCheckPoint.redo)
7755 {
7756 /*
7757 * Update the checkpoint information. We do this even if the cluster
7758 * does not show DB_IN_ARCHIVE_RECOVERY to match with the set of WAL
7759 * segments recycled below.
7760 */
7761 ControlFile->checkPoint = lastCheckPointRecPtr;
7762 ControlFile->checkPointCopy = lastCheckPoint;
7763
7764 /*
7765 * Ensure minRecoveryPoint is past the checkpoint record and update it
7766 * if the control file still shows DB_IN_ARCHIVE_RECOVERY. Normally,
7767 * this will have happened already while writing out dirty buffers,
7768 * but not necessarily - e.g. because no buffers were dirtied. We do
7769 * this because a backup performed in recovery uses minRecoveryPoint
7770 * to determine which WAL files must be included in the backup, and
7771 * the file (or files) containing the checkpoint record must be
7772 * included, at a minimum. Note that for an ordinary restart of
7773 * recovery there's no value in having the minimum recovery point any
7774 * earlier than this anyway, because redo will begin just after the
7775 * checkpoint record.
7776 */
7777 if (ControlFile->state == DB_IN_ARCHIVE_RECOVERY)
7778 {
7779 if (ControlFile->minRecoveryPoint < lastCheckPointEndPtr)
7780 {
7781 ControlFile->minRecoveryPoint = lastCheckPointEndPtr;
7782 ControlFile->minRecoveryPointTLI = lastCheckPoint.ThisTimeLineID;
7783
7784 /* update local copy */
7785 LocalMinRecoveryPoint = ControlFile->minRecoveryPoint;
7786 LocalMinRecoveryPointTLI = ControlFile->minRecoveryPointTLI;
7787 }
7788 if (flags & CHECKPOINT_IS_SHUTDOWN)
7789 ControlFile->state = DB_SHUTDOWNED_IN_RECOVERY;
7790 }
7791 UpdateControlFile();
7792 }
7793 LWLockRelease(ControlFileLock);
7794
7795 /*
7796 * Update the average distance between checkpoints/restartpoints if the
7797 * prior checkpoint exists.
7798 */
7799 if (PriorRedoPtr != InvalidXLogRecPtr)
7800 UpdateCheckPointDistanceEstimate(RedoRecPtr - PriorRedoPtr);
7801
7802 /*
7803 * Delete old log files, those no longer needed for last restartpoint to
7804 * prevent the disk holding the xlog from growing full.
7805 */
7806 XLByteToSeg(RedoRecPtr, _logSegNo, wal_segment_size);
7807
7808 /*
7809 * Retreat _logSegNo using the current end of xlog replayed or received,
7810 * whichever is later.
7811 */
7812 receivePtr = GetWalRcvFlushRecPtr(NULL, NULL);
7813 replayPtr = GetXLogReplayRecPtr(&replayTLI);
7814 endptr = (receivePtr < replayPtr) ? replayPtr : receivePtr;
7815 KeepLogSeg(endptr, &_logSegNo);
7816
7817 INJECTION_POINT("restartpoint-before-slot-invalidation", NULL);
7818
7819 if (InvalidateObsoleteReplicationSlots(RS_INVAL_WAL_REMOVED | RS_INVAL_IDLE_TIMEOUT,
7820 _logSegNo, InvalidOid,
7821 InvalidTransactionId))
7822 {
7823 /*
7824 * Some slots have been invalidated; recalculate the old-segment
7825 * horizon, starting again from RedoRecPtr.
7826 */
7827 XLByteToSeg(RedoRecPtr, _logSegNo, wal_segment_size);
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)
7863 TruncateSUBTRANS(GetOldestTransactionIdConsideredRunning());
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();
7872 ereport((log_checkpoints ? LOG : DEBUG2),
7873 (errmsg("recovery restart point at %X/%X",
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)
7882 ExecuteRecoveryCommand(archiveCleanupCommand,
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 */
7913 WALAvailability
7914 GetWALAvailability(XLogRecPtr targetLSN)
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);
7948 keepSegs = ConvertToXSegs(max_wal_size_mb, wal_segment_size) + 1;
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 */
7997 static void
7998 KeepLogSeg(XLogRecPtr recptr, XLogSegNo *logSegNo)
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. */
8008 keep = XLogGetReplicationSlotMinimumLSN();
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 */
8019 if (max_slot_wal_keep_size_mb >= 0 && !IsBinaryUpgrade)
8020 {
8021 uint64 slot_keep_segs;
8022
8023 slot_keep_segs =
8024 ConvertToXSegs(max_slot_wal_keep_size_mb, wal_segment_size);
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
8050 keep_segs = ConvertToXSegs(wal_keep_size_mb, wal_segment_size);
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 */
8069 void
8070 XLogPutNextOid(Oid nextOid)
8071 {
8072 XLogBeginInsert();
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 */
8106 XLogRecPtr
8107 RequestXLogSwitch(bool mark_unimportant)
8108 {
8109 XLogRecPtr RecPtr;
8110
8111 /* XLOG SWITCH has no data */
8112 XLogBeginInsert();
8113
8114 if (mark_unimportant)
8115 XLogSetRecordFlags(XLOG_MARK_UNIMPORTANT);
8116 RecPtr = XLogInsert(RM_XLOG_ID, XLOG_SWITCH);
8117
8118 return RecPtr;
8119 }
8120
8121 /*
8122 * Write a RESTORE POINT record
8123 */
8124 XLogRecPtr
8125 XLogRestorePoint(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
8133 XLogBeginInsert();
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/%X",
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 */
8149 static void
8150 XLogReportParameters(void)
8151 {
8152 if (wal_level != ControlFile->wal_level ||
8153 wal_log_hints != ControlFile->wal_log_hints ||
8154 MaxConnections != ControlFile->MaxConnections ||
8155 max_worker_processes != ControlFile->max_worker_processes ||
8156 max_wal_senders != ControlFile->max_wal_senders ||
8157 max_prepared_xacts != ControlFile->max_prepared_xacts ||
8158 max_locks_per_xact != ControlFile->max_locks_per_xact ||
8159 track_commit_timestamp != ControlFile->track_commit_timestamp)
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 */
8168 if (wal_level != ControlFile->wal_level || XLogIsNeeded())
8169 {
8170 xl_parameter_change xlrec;
8171 XLogRecPtr recptr;
8172
8173 xlrec.MaxConnections = MaxConnections;
8174 xlrec.max_worker_processes = max_worker_processes;
8175 xlrec.max_wal_senders = max_wal_senders;
8176 xlrec.max_prepared_xacts = max_prepared_xacts;
8177 xlrec.max_locks_per_xact = max_locks_per_xact;
8178 xlrec.wal_level = wal_level;
8179 xlrec.wal_log_hints = wal_log_hints;
8180 xlrec.track_commit_timestamp = track_commit_timestamp;
8181
8182 XLogBeginInsert();
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
8191 ControlFile->MaxConnections = MaxConnections;
8192 ControlFile->max_worker_processes = max_worker_processes;
8193 ControlFile->max_wal_senders = max_wal_senders;
8194 ControlFile->max_prepared_xacts = max_prepared_xacts;
8195 ControlFile->max_locks_per_xact = max_locks_per_xact;
8196 ControlFile->wal_level = wal_level;
8197 ControlFile->wal_log_hints = wal_log_hints;
8198 ControlFile->track_commit_timestamp = track_commit_timestamp;
8199 UpdateControlFile();
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 */
8212 void
8213 UpdateFullPageWrites(void)
8214 {
8215 XLogCtlInsert *Insert = &XLogCtl->Insert;
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
8235 START_CRIT_SECTION();
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 {
8246 WALInsertLockAcquireExclusive();
8247 Insert->fullPageWrites = true;
8248 WALInsertLockRelease();
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 {
8257 XLogBeginInsert();
8258 XLogRegisterData(&fullPageWrites, sizeof(bool));
8259
8260 XLogInsert(RM_XLOG_ID, XLOG_FPW_CHANGE);
8261 }
8262
8263 if (!fullPageWrites)
8264 {
8265 WALInsertLockAcquireExclusive();
8266 Insert->fullPageWrites = false;
8267 WALInsertLockRelease();
8268 }
8269 END_CRIT_SECTION();
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 */
8281 void
8282 xlog_redo(XLogReaderState *record)
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;
8308 TransamVariables->oidCount = 0;
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;
8323 TransamVariables->oidCount = 0;
8324 LWLockRelease(OidGenLock);
8325 MultiXactSetNextMXact(checkPoint.nextMulti,
8326 checkPoint.nextMultiOffset);
8327
8328 MultiXactAdvanceOldest(checkPoint.oldestMulti,
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 */
8342 if (ArchiveRecoveryRequested &&
8343 !XLogRecPtrIsInvalid(ControlFile->backupStartPoint) &&
8344 XLogRecPtrIsInvalid(ControlFile->backupEndPoint))
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 */
8354 if (standbyState >= STANDBY_INITIALIZED)
8355 {
8356 TransactionId *xids;
8357 int nxids;
8358 TransactionId oldestActiveXID;
8359 TransactionId latestCompletedXid;
8360 RunningTransactionsData running;
8361
8362 oldestActiveXID = PrescanPreparedTransactions(&xids, &nxids);
8363
8364 /* Update pg_subtrans entries for any prepared transactions */
8365 StandbyRecoverPreparedTransactions();
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;
8375 running.subxid_status = SUBXIDS_IN_SUBTRANS;
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
8384 ProcArrayApplyRecoveryInfo(&running);
8385 }
8386
8387 /* ControlFile->checkPointCopy always tracks the latest ckpt XID */
8388 LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
8389 ControlFile->checkPointCopy.nextXid = checkPoint.nextXid;
8390 LWLockRelease(ControlFileLock);
8391
8392 /* Update shared-memory copy of checkpoint XID/epoch */
8393 SpinLockAcquire(&XLogCtl->info_lck);
8394 XLogCtl->ckptFullXid = checkPoint.nextXid;
8395 SpinLockRelease(&XLogCtl->info_lck);
8396
8397 /*
8398 * We should've already switched to the new TLI before replaying this
8399 * record.
8400 */
8401 (void) GetCurrentReplayRecPtr(&replayTLI);
8402 if (checkPoint.ThisTimeLineID != replayTLI)
8403 ereport(PANIC,
8404 (errmsg("unexpected timeline ID %u (should be %u) in shutdown checkpoint record",
8405 checkPoint.ThisTimeLineID, replayTLI)));
8406
8407 RecoveryRestartPoint(&checkPoint, record);
8408
8409 /*
8410 * After replaying a checkpoint record, free all smgr objects.
8411 * Otherwise we would never do so for dropped relations, as the
8412 * startup does not process shared invalidation messages or call
8413 * AtEOXact_SMgr().
8414 */
8415 smgrdestroyall();
8416 }
8417 else if (info == XLOG_CHECKPOINT_ONLINE)
8418 {
8419 CheckPoint checkPoint;
8420 TimeLineID replayTLI;
8421
8422 memcpy(&checkPoint, XLogRecGetData(record), sizeof(CheckPoint));
8423 /* In an ONLINE checkpoint, treat the XID counter as a minimum */
8424 LWLockAcquire(XidGenLock, LW_EXCLUSIVE);
8425 if (FullTransactionIdPrecedes(TransamVariables->nextXid,
8426 checkPoint.nextXid))
8427 TransamVariables->nextXid = checkPoint.nextXid;
8428 LWLockRelease(XidGenLock);
8429
8430 /*
8431 * We ignore the nextOid counter in an ONLINE checkpoint, preferring
8432 * to track OID assignment through XLOG_NEXTOID records. The nextOid
8433 * counter is from the start of the checkpoint and might well be stale
8434 * compared to later XLOG_NEXTOID records. We could try to take the
8435 * maximum of the nextOid counter and our latest value, but since
8436 * there's no particular guarantee about the speed with which the OID
8437 * counter wraps around, that's a risky thing to do. In any case,
8438 * users of the nextOid counter are required to avoid assignment of
8439 * duplicates, so that a somewhat out-of-date value should be safe.
8440 */
8441
8442 /* Handle multixact */
8443 MultiXactAdvanceNextMXact(checkPoint.nextMulti,
8444 checkPoint.nextMultiOffset);
8445
8446 /*
8447 * NB: This may perform multixact truncation when replaying WAL
8448 * generated by an older primary.
8449 */
8450 MultiXactAdvanceOldest(checkPoint.oldestMulti,
8451 checkPoint.oldestMultiDB);
8452 if (TransactionIdPrecedes(TransamVariables->oldestXid,
8453 checkPoint.oldestXid))
8454 SetTransactionIdLimit(checkPoint.oldestXid,
8455 checkPoint.oldestXidDB);
8456 /* ControlFile->checkPointCopy always tracks the latest ckpt XID */
8457 LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
8458 ControlFile->checkPointCopy.nextXid = checkPoint.nextXid;
8459 LWLockRelease(ControlFileLock);
8460
8461 /* Update shared-memory copy of checkpoint XID/epoch */
8462 SpinLockAcquire(&XLogCtl->info_lck);
8463 XLogCtl->ckptFullXid = checkPoint.nextXid;
8464 SpinLockRelease(&XLogCtl->info_lck);
8465
8466 /* TLI should not change in an on-line checkpoint */
8467 (void) GetCurrentReplayRecPtr(&replayTLI);
8468 if (checkPoint.ThisTimeLineID != replayTLI)
8469 ereport(PANIC,
8470 (errmsg("unexpected timeline ID %u (should be %u) in online checkpoint record",
8471 checkPoint.ThisTimeLineID, replayTLI)));
8472
8473 RecoveryRestartPoint(&checkPoint, record);
8474
8475 /*
8476 * After replaying a checkpoint record, free all smgr objects.
8477 * Otherwise we would never do so for dropped relations, as the
8478 * startup does not process shared invalidation messages or call
8479 * AtEOXact_SMgr().
8480 */
8481 smgrdestroyall();
8482 }
8483 else if (info == XLOG_OVERWRITE_CONTRECORD)
8484 {
8485 /* nothing to do here, handled in xlogrecovery_redo() */
8486 }
8487 else if (info == XLOG_END_OF_RECOVERY)
8488 {
8489 xl_end_of_recovery xlrec;
8490 TimeLineID replayTLI;
8491
8492 memcpy(&xlrec, XLogRecGetData(record), sizeof(xl_end_of_recovery));
8493
8494 /*
8495 * For Hot Standby, we could treat this like a Shutdown Checkpoint,
8496 * but this case is rarer and harder to test, so the benefit doesn't
8497 * outweigh the potential extra cost of maintenance.
8498 */
8499
8500 /*
8501 * We should've already switched to the new TLI before replaying this
8502 * record.
8503 */
8504 (void) GetCurrentReplayRecPtr(&replayTLI);
8505 if (xlrec.ThisTimeLineID != replayTLI)
8506 ereport(PANIC,
8507 (errmsg("unexpected timeline ID %u (should be %u) in end-of-recovery record",
8508 xlrec.ThisTimeLineID, replayTLI)));
8509 }
8510 else if (info == XLOG_NOOP)
8511 {
8512 /* nothing to do here */
8513 }
8514 else if (info == XLOG_SWITCH)
8515 {
8516 /* nothing to do here */
8517 }
8518 else if (info == XLOG_RESTORE_POINT)
8519 {
8520 /* nothing to do here, handled in xlogrecovery.c */
8521 }
8522 else if (info == XLOG_FPI || info == XLOG_FPI_FOR_HINT)
8523 {
8524 /*
8525 * XLOG_FPI records contain nothing else but one or more block
8526 * references. Every block reference must include a full-page image
8527 * even if full_page_writes was disabled when the record was generated
8528 * - otherwise there would be no point in this record.
8529 *
8530 * XLOG_FPI_FOR_HINT records are generated when a page needs to be
8531 * WAL-logged because of a hint bit update. They are only generated
8532 * when checksums and/or wal_log_hints are enabled. They may include
8533 * no full-page images if full_page_writes was disabled when they were
8534 * generated. In this case there is nothing to do here.
8535 *
8536 * No recovery conflicts are generated by these generic records - if a
8537 * resource manager needs to generate conflicts, it has to define a
8538 * separate WAL record type and redo routine.
8539 */
8540 for (uint8 block_id = 0; block_id <= XLogRecMaxBlockId(record); block_id++)
8541 {
8542 Buffer buffer;
8543
8544 if (!XLogRecHasBlockImage(record, block_id))
8545 {
8546 if (info == XLOG_FPI)
8547 elog(ERROR, "XLOG_FPI record did not contain a full-page image");
8548 continue;
8549 }
8550
8551 if (XLogReadBufferForRedo(record, block_id, &buffer) != BLK_RESTORED)
8552 elog(ERROR, "unexpected XLogReadBufferForRedo result when restoring backup block");
8553 UnlockReleaseBuffer(buffer);
8554 }
8555 }
8556 else if (info == XLOG_BACKUP_END)
8557 {
8558 /* nothing to do here, handled in xlogrecovery_redo() */
8559 }
8560 else if (info == XLOG_PARAMETER_CHANGE)
8561 {
8562 xl_parameter_change xlrec;
8563
8564 /* Update our copy of the parameters in pg_control */
8565 memcpy(&xlrec, XLogRecGetData(record), sizeof(xl_parameter_change));
8566
8567 /*
8568 * Invalidate logical slots if we are in hot standby and the primary
8569 * does not have a WAL level sufficient for logical decoding. No need
8570 * to search for potentially conflicting logically slots if standby is
8571 * running with wal_level lower than logical, because in that case, we
8572 * would have either disallowed creation of logical slots or
8573 * invalidated existing ones.
8574 */
8575 if (InRecovery && InHotStandby &&
8576 xlrec.wal_level < WAL_LEVEL_LOGICAL &&
8577 wal_level >= WAL_LEVEL_LOGICAL)
8578 InvalidateObsoleteReplicationSlots(RS_INVAL_WAL_LEVEL,
8579 0, InvalidOid,
8580 InvalidTransactionId);
8581
8582 LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
8583 ControlFile->MaxConnections = xlrec.MaxConnections;
8584 ControlFile->max_worker_processes = xlrec.max_worker_processes;
8585 ControlFile->max_wal_senders = xlrec.max_wal_senders;
8586 ControlFile->max_prepared_xacts = xlrec.max_prepared_xacts;
8587 ControlFile->max_locks_per_xact = xlrec.max_locks_per_xact;
8588 ControlFile->wal_level = xlrec.wal_level;
8589 ControlFile->wal_log_hints = xlrec.wal_log_hints;
8590
8591 /*
8592 * Update minRecoveryPoint to ensure that if recovery is aborted, we
8593 * recover back up to this point before allowing hot standby again.
8594 * This is important if the max_* settings are decreased, to ensure
8595 * you don't run queries against the WAL preceding the change. The
8596 * local copies cannot be updated as long as crash recovery is
8597 * happening and we expect all the WAL to be replayed.
8598 */
8599 if (InArchiveRecovery)
8600 {
8601 LocalMinRecoveryPoint = ControlFile->minRecoveryPoint;
8602 LocalMinRecoveryPointTLI = ControlFile->minRecoveryPointTLI;
8603 }
8604 if (LocalMinRecoveryPoint != InvalidXLogRecPtr && LocalMinRecoveryPoint < lsn)
8605 {
8606 TimeLineID replayTLI;
8607
8608 (void) GetCurrentReplayRecPtr(&replayTLI);
8609 ControlFile->minRecoveryPoint = lsn;
8610 ControlFile->minRecoveryPointTLI = replayTLI;
8611 }
8612
8613 CommitTsParameterChange(xlrec.track_commit_timestamp,
8614 ControlFile->track_commit_timestamp);
8615 ControlFile->track_commit_timestamp = xlrec.track_commit_timestamp;
8616
8617 UpdateControlFile();
8618 LWLockRelease(ControlFileLock);
8619
8620 /* Check to see if any parameter change gives a problem on recovery */
8621 CheckRequiredParameterValues();
8622 }
8623 else if (info == XLOG_FPW_CHANGE)
8624 {
8625 bool fpw;
8626
8627 memcpy(&fpw, XLogRecGetData(record), sizeof(bool));
8628
8629 /*
8630 * Update the LSN of the last replayed XLOG_FPW_CHANGE record so that
8631 * do_pg_backup_start() and do_pg_backup_stop() can check whether
8632 * full_page_writes has been disabled during online backup.
8633 */
8634 if (!fpw)
8635 {
8636 SpinLockAcquire(&XLogCtl->info_lck);
8637 if (XLogCtl->lastFpwDisableRecPtr < record->ReadRecPtr)
8638 XLogCtl->lastFpwDisableRecPtr = record->ReadRecPtr;
8639 SpinLockRelease(&XLogCtl->info_lck);
8640 }
8641
8642 /* Keep track of full_page_writes */
8643 lastFullPageWrites = fpw;
8644 }
8645 else if (info == XLOG_CHECKPOINT_REDO)
8646 {
8647 /* nothing to do here, just for informational purposes */
8648 }
8649 }
8650
8651 /*
8652 * Return the extra open flags used for opening a file, depending on the
8653 * value of the GUCs wal_sync_method, fsync and debug_io_direct.
8654 */
8655 static int
8656 get_sync_bit(int method)
8657 {
8658 int o_direct_flag = 0;
8659
8660 /*
8661 * Use O_DIRECT if requested, except in walreceiver process. The WAL
8662 * written by walreceiver is normally read by the startup process soon
8663 * after it's written. Also, walreceiver performs unaligned writes, which
8664 * don't work with O_DIRECT, so it is required for correctness too.
8665 */
8666 if ((io_direct_flags & IO_DIRECT_WAL) && !AmWalReceiverProcess())
8667 o_direct_flag = PG_O_DIRECT;
8668
8669 /* If fsync is disabled, never open in sync mode */
8670 if (!enableFsync)
8671 return o_direct_flag;
8672
8673 switch (method)
8674 {
8675 /*
8676 * enum values for all sync options are defined even if they are
8677 * not supported on the current platform. But if not, they are
8678 * not included in the enum option array, and therefore will never
8679 * be seen here.
8680 */
8681 case WAL_SYNC_METHOD_FSYNC:
8682 case WAL_SYNC_METHOD_FSYNC_WRITETHROUGH:
8683 case WAL_SYNC_METHOD_FDATASYNC:
8684 return o_direct_flag;
8685 #ifdef O_SYNC
8686 case WAL_SYNC_METHOD_OPEN:
8687 return O_SYNC | o_direct_flag;
8688 #endif
8689 #ifdef O_DSYNC
8690 case WAL_SYNC_METHOD_OPEN_DSYNC:
8691 return O_DSYNC | o_direct_flag;
8692 #endif
8693 default:
8694 /* can't happen (unless we are out of sync with option array) */
8695 elog(ERROR, "unrecognized \"wal_sync_method\": %d", method);
8696 return 0; /* silence warning */
8697 }
8698 }
8699
8700 /*
8701 * GUC support
8702 */
8703 void
8704 assign_wal_sync_method(int new_wal_sync_method, void *extra)
8705 {
8706 if (wal_sync_method != new_wal_sync_method)
8707 {
8708 /*
8709 * To ensure that no blocks escape unsynced, force an fsync on the
8710 * currently open log segment (if any). Also, if the open flag is
8711 * changing, close the log file so it will be reopened (with new flag
8712 * bit) at next use.
8713 */
8714 if (openLogFile >= 0)
8715 {
8716 pgstat_report_wait_start(WAIT_EVENT_WAL_SYNC_METHOD_ASSIGN);
8717 if (pg_fsync(openLogFile) != 0)
8718 {
8719 char xlogfname[MAXFNAMELEN];
8720 int save_errno;
8721
8722 save_errno = errno;
8723 XLogFileName(xlogfname, openLogTLI, openLogSegNo,
8724 wal_segment_size);
8725 errno = save_errno;
8726 ereport(PANIC,
8727 (errcode_for_file_access(),
8728 errmsg("could not fsync file \"%s\": %m", xlogfname)));
8729 }
8730
8731 pgstat_report_wait_end();
8732 if (get_sync_bit(wal_sync_method) != get_sync_bit(new_wal_sync_method))
8733 XLogFileClose();
8734 }
8735 }
8736 }
8737
8738
8739 /*
8740 * Issue appropriate kind of fsync (if any) for an XLOG output file.
8741 *
8742 * 'fd' is a file descriptor for the XLOG file to be fsync'd.
8743 * 'segno' is for error reporting purposes.
8744 */
8745 void
8746 issue_xlog_fsync(int fd, XLogSegNo segno, TimeLineID tli)
8747 {
8748 char *msg = NULL;
8749 instr_time start;
8750
8751 Assert(tli != 0);
8752
8753 /*
8754 * Quick exit if fsync is disabled or write() has already synced the WAL
8755 * file.
8756 */
8757 if (!enableFsync ||
8758 wal_sync_method == WAL_SYNC_METHOD_OPEN ||
8759 wal_sync_method == WAL_SYNC_METHOD_OPEN_DSYNC)
8760 return;
8761
8762 /*
8763 * Measure I/O timing to sync the WAL file for pg_stat_io.
8764 */
8765 start = pgstat_prepare_io_time(track_wal_io_timing);
8766
8767 pgstat_report_wait_start(WAIT_EVENT_WAL_SYNC);
8768 switch (wal_sync_method)
8769 {
8770 case WAL_SYNC_METHOD_FSYNC:
8771 if (pg_fsync_no_writethrough(fd) != 0)
8772 msg = _("could not fsync file \"%s\": %m");
8773 break;
8774 #ifdef HAVE_FSYNC_WRITETHROUGH
8775 case WAL_SYNC_METHOD_FSYNC_WRITETHROUGH:
8776 if (pg_fsync_writethrough(fd) != 0)
8777 msg = _("could not fsync write-through file \"%s\": %m");
8778 break;
8779 #endif
8780 case WAL_SYNC_METHOD_FDATASYNC:
8781 if (pg_fdatasync(fd) != 0)
8782 msg = _("could not fdatasync file \"%s\": %m");
8783 break;
8784 case WAL_SYNC_METHOD_OPEN:
8785 case WAL_SYNC_METHOD_OPEN_DSYNC:
8786 /* not reachable */
8787 Assert(false);
8788 break;
8789 default:
8790 ereport(PANIC,
8791 errcode(ERRCODE_INVALID_PARAMETER_VALUE),
8792 errmsg_internal("unrecognized \"wal_sync_method\": %d", wal_sync_method));
8793 break;
8794 }
8795
8796 /* PANIC if failed to fsync */
8797 if (msg)
8798 {
8799 char xlogfname[MAXFNAMELEN];
8800 int save_errno = errno;
8801
8802 XLogFileName(xlogfname, tli, segno, wal_segment_size);
8803 errno = save_errno;
8804 ereport(PANIC,
8805 (errcode_for_file_access(),
8806 errmsg(msg, xlogfname)));
8807 }
8808
8809 pgstat_report_wait_end();
8810
8811 pgstat_count_io_op_time(IOOBJECT_WAL, IOCONTEXT_NORMAL, IOOP_FSYNC,
8812 start, 1, 0);
8813 }
8814
8815 /*
8816 * do_pg_backup_start is the workhorse of the user-visible pg_backup_start()
8817 * function. It creates the necessary starting checkpoint and constructs the
8818 * backup state and tablespace map.
8819 *
8820 * Input parameters are "state" (the backup state), "fast" (if true, we do
8821 * the checkpoint in immediate mode to make it faster), and "tablespaces"
8822 * (if non-NULL, indicates a list of tablespaceinfo structs describing the
8823 * cluster's tablespaces.).
8824 *
8825 * The tablespace map contents are appended to passed-in parameter
8826 * tablespace_map and the caller is responsible for including it in the backup
8827 * archive as 'tablespace_map'. The tablespace_map file is required mainly for
8828 * tar format in windows as native windows utilities are not able to create
8829 * symlinks while extracting files from tar. However for consistency and
8830 * platform-independence, we do it the same way everywhere.
8831 *
8832 * It fills in "state" with the information required for the backup, such
8833 * as the minimum WAL location that must be present to restore from this
8834 * backup (starttli) and the corresponding timeline ID (starttli).
8835 *
8836 * Every successfully started backup must be stopped by calling
8837 * do_pg_backup_stop() or do_pg_abort_backup(). There can be many
8838 * backups active at the same time.
8839 *
8840 * It is the responsibility of the caller of this function to verify the
8841 * permissions of the calling user!
8842 */
8843 void
8844 do_pg_backup_start(const char *backupidstr, bool fast, List **tablespaces,
8845 BackupState *state, StringInfo tblspcmapfile)
8846 {
8847 bool backup_started_in_recovery;
8848
8849 Assert(state != NULL);
8850 backup_started_in_recovery = RecoveryInProgress();
8851
8852 /*
8853 * During recovery, we don't need to check WAL level. Because, if WAL
8854 * level is not sufficient, it's impossible to get here during recovery.
8855 */
8856 if (!backup_started_in_recovery && !XLogIsNeeded())
8857 ereport(ERROR,
8858 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
8859 errmsg("WAL level not sufficient for making an online backup"),
8860 errhint("\"wal_level\" must be set to \"replica\" or \"logical\" at server start.")));
8861
8862 if (strlen(backupidstr) > MAXPGPATH)
8863 ereport(ERROR,
8864 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
8865 errmsg("backup label too long (max %d bytes)",
8866 MAXPGPATH)));
8867
8868 strlcpy(state->name, backupidstr, sizeof(state->name));
8869
8870 /*
8871 * Mark backup active in shared memory. We must do full-page WAL writes
8872 * during an on-line backup even if not doing so at other times, because
8873 * it's quite possible for the backup dump to obtain a "torn" (partially
8874 * written) copy of a database page if it reads the page concurrently with
8875 * our write to the same page. This can be fixed as long as the first
8876 * write to the page in the WAL sequence is a full-page write. Hence, we
8877 * increment runningBackups then force a CHECKPOINT, to ensure there are
8878 * no dirty pages in shared memory that might get dumped while the backup
8879 * is in progress without having a corresponding WAL record. (Once the
8880 * backup is complete, we need not force full-page writes anymore, since
8881 * we expect that any pages not modified during the backup interval must
8882 * have been correctly captured by the backup.)
8883 *
8884 * Note that forcing full-page writes has no effect during an online
8885 * backup from the standby.
8886 *
8887 * We must hold all the insertion locks to change the value of
8888 * runningBackups, to ensure adequate interlocking against
8889 * XLogInsertRecord().
8890 */
8891 WALInsertLockAcquireExclusive();
8892 XLogCtl->Insert.runningBackups++;
8893 WALInsertLockRelease();
8894
8895 /*
8896 * Ensure we decrement runningBackups if we fail below. NB -- for this to
8897 * work correctly, it is critical that sessionBackupState is only updated
8898 * after this block is over.
8899 */
8900 PG_ENSURE_ERROR_CLEANUP(do_pg_abort_backup, DatumGetBool(true));
8901 {
8902 bool gotUniqueStartpoint = false;
8903 DIR *tblspcdir;
8904 struct dirent *de;
8905 tablespaceinfo *ti;
8906 int datadirpathlen;
8907
8908 /*
8909 * Force an XLOG file switch before the checkpoint, to ensure that the
8910 * WAL segment the checkpoint is written to doesn't contain pages with
8911 * old timeline IDs. That would otherwise happen if you called
8912 * pg_backup_start() right after restoring from a PITR archive: the
8913 * first WAL segment containing the startup checkpoint has pages in
8914 * the beginning with the old timeline ID. That can cause trouble at
8915 * recovery: we won't have a history file covering the old timeline if
8916 * pg_wal directory was not included in the base backup and the WAL
8917 * archive was cleared too before starting the backup.
8918 *
8919 * This also ensures that we have emitted a WAL page header that has
8920 * XLP_BKP_REMOVABLE off before we emit the checkpoint record.
8921 * Therefore, if a WAL archiver (such as pglesslog) is trying to
8922 * compress out removable backup blocks, it won't remove any that
8923 * occur after this point.
8924 *
8925 * During recovery, we skip forcing XLOG file switch, which means that
8926 * the backup taken during recovery is not available for the special
8927 * recovery case described above.
8928 */
8929 if (!backup_started_in_recovery)
8930 RequestXLogSwitch(false);
8931
8932 do
8933 {
8934 bool checkpointfpw;
8935
8936 /*
8937 * Force a CHECKPOINT. Aside from being necessary to prevent torn
8938 * page problems, this guarantees that two successive backup runs
8939 * will have different checkpoint positions and hence different
8940 * history file names, even if nothing happened in between.
8941 *
8942 * During recovery, establish a restartpoint if possible. We use
8943 * the last restartpoint as the backup starting checkpoint. This
8944 * means that two successive backup runs can have same checkpoint
8945 * positions.
8946 *
8947 * Since the fact that we are executing do_pg_backup_start()
8948 * during recovery means that checkpointer is running, we can use
8949 * RequestCheckpoint() to establish a restartpoint.
8950 *
8951 * We use CHECKPOINT_IMMEDIATE only if requested by user (via
8952 * passing fast = true). Otherwise this can take awhile.
8953 */
8954 RequestCheckpoint(CHECKPOINT_FORCE | CHECKPOINT_WAIT |
8955 (fast ? CHECKPOINT_IMMEDIATE : 0));
8956
8957 /*
8958 * Now we need to fetch the checkpoint record location, and also
8959 * its REDO pointer. The oldest point in WAL that would be needed
8960 * to restore starting from the checkpoint is precisely the REDO
8961 * pointer.
8962 */
8963 LWLockAcquire(ControlFileLock, LW_SHARED);
8964 state->checkpointloc = ControlFile->checkPoint;
8965 state->startpoint = ControlFile->checkPointCopy.redo;
8966 state->starttli = ControlFile->checkPointCopy.ThisTimeLineID;
8967 checkpointfpw = ControlFile->checkPointCopy.fullPageWrites;
8968 LWLockRelease(ControlFileLock);
8969
8970 if (backup_started_in_recovery)
8971 {
8972 XLogRecPtr recptr;
8973
8974 /*
8975 * Check to see if all WAL replayed during online backup
8976 * (i.e., since last restartpoint used as backup starting
8977 * checkpoint) contain full-page writes.
8978 */
8979 SpinLockAcquire(&XLogCtl->info_lck);
8980 recptr = XLogCtl->lastFpwDisableRecPtr;
8981 SpinLockRelease(&XLogCtl->info_lck);
8982
8983 if (!checkpointfpw || state->startpoint <= recptr)
8984 ereport(ERROR,
8985 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
8986 errmsg("WAL generated with \"full_page_writes=off\" was replayed "
8987 "since last restartpoint"),
8988 errhint("This means that the backup being taken on the standby "
8989 "is corrupt and should not be used. "
8990 "Enable \"full_page_writes\" and run CHECKPOINT on the primary, "
8991 "and then try an online backup again.")));
8992
8993 /*
8994 * During recovery, since we don't use the end-of-backup WAL
8995 * record and don't write the backup history file, the
8996 * starting WAL location doesn't need to be unique. This means
8997 * that two base backups started at the same time might use
8998 * the same checkpoint as starting locations.
8999 */
9000 gotUniqueStartpoint = true;
9001 }
9002
9003 /*
9004 * If two base backups are started at the same time (in WAL sender
9005 * processes), we need to make sure that they use different
9006 * checkpoints as starting locations, because we use the starting
9007 * WAL location as a unique identifier for the base backup in the
9008 * end-of-backup WAL record and when we write the backup history
9009 * file. Perhaps it would be better generate a separate unique ID
9010 * for each backup instead of forcing another checkpoint, but
9011 * taking a checkpoint right after another is not that expensive
9012 * either because only few buffers have been dirtied yet.
9013 */
9014 WALInsertLockAcquireExclusive();
9015 if (XLogCtl->Insert.lastBackupStart < state->startpoint)
9016 {
9017 XLogCtl->Insert.lastBackupStart = state->startpoint;
9018 gotUniqueStartpoint = true;
9019 }
9020 WALInsertLockRelease();
9021 } while (!gotUniqueStartpoint);
9022
9023 /*
9024 * Construct tablespace_map file.
9025 */
9026 datadirpathlen = strlen(DataDir);
9027
9028 /* Collect information about all tablespaces */
9029 tblspcdir = AllocateDir(PG_TBLSPC_DIR);
9030 while ((de = ReadDir(tblspcdir, PG_TBLSPC_DIR)) != NULL)
9031 {
9032 char fullpath[MAXPGPATH + sizeof(PG_TBLSPC_DIR)];
9033 char linkpath[MAXPGPATH];
9034 char *relpath = NULL;
9035 char *s;
9036 PGFileType de_type;
9037 char *badp;
9038 Oid tsoid;
9039
9040 /*
9041 * Try to parse the directory name as an unsigned integer.
9042 *
9043 * Tablespace directories should be positive integers that can be
9044 * represented in 32 bits, with no leading zeroes or trailing
9045 * garbage. If we come across a name that doesn't meet those
9046 * criteria, skip it.
9047 */
9048 if (de->d_name[0] < '1' || de->d_name[1] > '9')
9049 continue;
9050 errno = 0;
9051 tsoid = strtoul(de->d_name, &badp, 10);
9052 if (*badp != '\0' || errno == EINVAL || errno == ERANGE)
9053 continue;
9054
9055 snprintf(fullpath, sizeof(fullpath), "%s/%s", PG_TBLSPC_DIR, de->d_name);
9056
9057 de_type = get_dirent_type(fullpath, de, false, ERROR);
9058
9059 if (de_type == PGFILETYPE_LNK)
9060 {
9061 StringInfoData escapedpath;
9062 int rllen;
9063
9064 rllen = readlink(fullpath, linkpath, sizeof(linkpath));
9065 if (rllen < 0)
9066 {
9067 ereport(WARNING,
9068 (errmsg("could not read symbolic link \"%s\": %m",
9069 fullpath)));
9070 continue;
9071 }
9072 else if (rllen >= sizeof(linkpath))
9073 {
9074 ereport(WARNING,
9075 (errmsg("symbolic link \"%s\" target is too long",
9076 fullpath)));
9077 continue;
9078 }
9079 linkpath[rllen] = '\0';
9080
9081 /*
9082 * Relpath holds the relative path of the tablespace directory
9083 * when it's located within PGDATA, or NULL if it's located
9084 * elsewhere.
9085 */
9086 if (rllen > datadirpathlen &&
9087 strncmp(linkpath, DataDir, datadirpathlen) == 0 &&
9088 IS_DIR_SEP(linkpath[datadirpathlen]))
9089 relpath = pstrdup(linkpath + datadirpathlen + 1);
9090
9091 /*
9092 * Add a backslash-escaped version of the link path to the
9093 * tablespace map file.
9094 */
9095 initStringInfo(&escapedpath);
9096 for (s = linkpath; *s; s++)
9097 {
9098 if (*s == '\n' || *s == '\r' || *s == '\\')
9099 appendStringInfoChar(&escapedpath, '\\');
9100 appendStringInfoChar(&escapedpath, *s);
9101 }
9102 appendStringInfo(tblspcmapfile, "%s %s\n",
9103 de->d_name, escapedpath.data);
9104 pfree(escapedpath.data);
9105 }
9106 else if (de_type == PGFILETYPE_DIR)
9107 {
9108 /*
9109 * It's possible to use allow_in_place_tablespaces to create
9110 * directories directly under pg_tblspc, for testing purposes
9111 * only.
9112 *
9113 * In this case, we store a relative path rather than an
9114 * absolute path into the tablespaceinfo.
9115 */
9116 snprintf(linkpath, sizeof(linkpath), "%s/%s",
9117 PG_TBLSPC_DIR, de->d_name);
9118 relpath = pstrdup(linkpath);
9119 }
9120 else
9121 {
9122 /* Skip any other file type that appears here. */
9123 continue;
9124 }
9125
9126 ti = palloc(sizeof(tablespaceinfo));
9127 ti->oid = tsoid;
9128 ti->path = pstrdup(linkpath);
9129 ti->rpath = relpath;
9130 ti->size = -1;
9131
9132 if (tablespaces)
9133 *tablespaces = lappend(*tablespaces, ti);
9134 }
9135 FreeDir(tblspcdir);
9136
9137 state->starttime = (pg_time_t) time(NULL);
9138 }
9139 PG_END_ENSURE_ERROR_CLEANUP(do_pg_abort_backup, DatumGetBool(true));
9140
9141 state->started_in_recovery = backup_started_in_recovery;
9142
9143 /*
9144 * Mark that the start phase has correctly finished for the backup.
9145 */
9146 sessionBackupState = SESSION_BACKUP_RUNNING;
9147 }
9148
9149 /*
9150 * Utility routine to fetch the session-level status of a backup running.
9151 */
9152 SessionBackupState
9153 get_backup_status(void)
9154 {
9155 return sessionBackupState;
9156 }
9157
9158 /*
9159 * do_pg_backup_stop
9160 *
9161 * Utility function called at the end of an online backup. It creates history
9162 * file (if required), resets sessionBackupState and so on. It can optionally
9163 * wait for WAL segments to be archived.
9164 *
9165 * "state" is filled with the information necessary to restore from this
9166 * backup with its stop LSN (stoppoint), its timeline ID (stoptli), etc.
9167 *
9168 * It is the responsibility of the caller of this function to verify the
9169 * permissions of the calling user!
9170 */
9171 void
9172 do_pg_backup_stop(BackupState *state, bool waitforarchive)
9173 {
9174 bool backup_stopped_in_recovery = false;
9175 char histfilepath[MAXPGPATH];
9176 char lastxlogfilename[MAXFNAMELEN];
9177 char histfilename[MAXFNAMELEN];
9178 XLogSegNo _logSegNo;
9179 FILE *fp;
9180 int seconds_before_warning;
9181 int waits = 0;
9182 bool reported_waiting = false;
9183
9184 Assert(state != NULL);
9185
9186 backup_stopped_in_recovery = RecoveryInProgress();
9187
9188 /*
9189 * During recovery, we don't need to check WAL level. Because, if WAL
9190 * level is not sufficient, it's impossible to get here during recovery.
9191 */
9192 if (!backup_stopped_in_recovery && !XLogIsNeeded())
9193 ereport(ERROR,
9194 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
9195 errmsg("WAL level not sufficient for making an online backup"),
9196 errhint("\"wal_level\" must be set to \"replica\" or \"logical\" at server start.")));
9197
9198 /*
9199 * OK to update backup counter and session-level lock.
9200 *
9201 * Note that CHECK_FOR_INTERRUPTS() must not occur while updating them,
9202 * otherwise they can be updated inconsistently, which might cause
9203 * do_pg_abort_backup() to fail.
9204 */
9205 WALInsertLockAcquireExclusive();
9206
9207 /*
9208 * It is expected that each do_pg_backup_start() call is matched by
9209 * exactly one do_pg_backup_stop() call.
9210 */
9211 Assert(XLogCtl->Insert.runningBackups > 0);
9212 XLogCtl->Insert.runningBackups--;
9213
9214 /*
9215 * Clean up session-level lock.
9216 *
9217 * You might think that WALInsertLockRelease() can be called before
9218 * cleaning up session-level lock because session-level lock doesn't need
9219 * to be protected with WAL insertion lock. But since
9220 * CHECK_FOR_INTERRUPTS() can occur in it, session-level lock must be
9221 * cleaned up before it.
9222 */
9223 sessionBackupState = SESSION_BACKUP_NONE;
9224
9225 WALInsertLockRelease();
9226
9227 /*
9228 * If we are taking an online backup from the standby, we confirm that the
9229 * standby has not been promoted during the backup.
9230 */
9231 if (state->started_in_recovery && !backup_stopped_in_recovery)
9232 ereport(ERROR,
9233 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
9234 errmsg("the standby was promoted during online backup"),
9235 errhint("This means that the backup being taken is corrupt "
9236 "and should not be used. "
9237 "Try taking another online backup.")));
9238
9239 /*
9240 * During recovery, we don't write an end-of-backup record. We assume that
9241 * pg_control was backed up last and its minimum recovery point can be
9242 * available as the backup end location. Since we don't have an
9243 * end-of-backup record, we use the pg_control value to check whether
9244 * we've reached the end of backup when starting recovery from this
9245 * backup. We have no way of checking if pg_control wasn't backed up last
9246 * however.
9247 *
9248 * We don't force a switch to new WAL file but it is still possible to
9249 * wait for all the required files to be archived if waitforarchive is
9250 * true. This is okay if we use the backup to start a standby and fetch
9251 * the missing WAL using streaming replication. But in the case of an
9252 * archive recovery, a user should set waitforarchive to true and wait for
9253 * them to be archived to ensure that all the required files are
9254 * available.
9255 *
9256 * We return the current minimum recovery point as the backup end
9257 * location. Note that it can be greater than the exact backup end
9258 * location if the minimum recovery point is updated after the backup of
9259 * pg_control. This is harmless for current uses.
9260 *
9261 * XXX currently a backup history file is for informational and debug
9262 * purposes only. It's not essential for an online backup. Furthermore,
9263 * even if it's created, it will not be archived during recovery because
9264 * an archiver is not invoked. So it doesn't seem worthwhile to write a
9265 * backup history file during recovery.
9266 */
9267 if (backup_stopped_in_recovery)
9268 {
9269 XLogRecPtr recptr;
9270
9271 /*
9272 * Check to see if all WAL replayed during online backup contain
9273 * full-page writes.
9274 */
9275 SpinLockAcquire(&XLogCtl->info_lck);
9276 recptr = XLogCtl->lastFpwDisableRecPtr;
9277 SpinLockRelease(&XLogCtl->info_lck);
9278
9279 if (state->startpoint <= recptr)
9280 ereport(ERROR,
9281 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
9282 errmsg("WAL generated with \"full_page_writes=off\" was replayed "
9283 "during online backup"),
9284 errhint("This means that the backup being taken on the standby "
9285 "is corrupt and should not be used. "
9286 "Enable \"full_page_writes\" and run CHECKPOINT on the primary, "
9287 "and then try an online backup again.")));
9288
9289
9290 LWLockAcquire(ControlFileLock, LW_SHARED);
9291 state->stoppoint = ControlFile->minRecoveryPoint;
9292 state->stoptli = ControlFile->minRecoveryPointTLI;
9293 LWLockRelease(ControlFileLock);
9294 }
9295 else
9296 {
9297 char *history_file;
9298
9299 /*
9300 * Write the backup-end xlog record
9301 */
9302 XLogBeginInsert();
9303 XLogRegisterData(&state->startpoint,
9304 sizeof(state->startpoint));
9305 state->stoppoint = XLogInsert(RM_XLOG_ID, XLOG_BACKUP_END);
9306
9307 /*
9308 * Given that we're not in recovery, InsertTimeLineID is set and can't
9309 * change, so we can read it without a lock.
9310 */
9311 state->stoptli = XLogCtl->InsertTimeLineID;
9312
9313 /*
9314 * Force a switch to a new xlog segment file, so that the backup is
9315 * valid as soon as archiver moves out the current segment file.
9316 */
9317 RequestXLogSwitch(false);
9318
9319 state->stoptime = (pg_time_t) time(NULL);
9320
9321 /*
9322 * Write the backup history file
9323 */
9324 XLByteToSeg(state->startpoint, _logSegNo, wal_segment_size);
9325 BackupHistoryFilePath(histfilepath, state->stoptli, _logSegNo,
9326 state->startpoint, wal_segment_size);
9327 fp = AllocateFile(histfilepath, "w");
9328 if (!fp)
9329 ereport(ERROR,
9330 (errcode_for_file_access(),
9331 errmsg("could not create file \"%s\": %m",
9332 histfilepath)));
9333
9334 /* Build and save the contents of the backup history file */
9335 history_file = build_backup_content(state, true);
9336 fprintf(fp, "%s", history_file);
9337 pfree(history_file);
9338
9339 if (fflush(fp) || ferror(fp) || FreeFile(fp))
9340 ereport(ERROR,
9341 (errcode_for_file_access(),
9342 errmsg("could not write file \"%s\": %m",
9343 histfilepath)));
9344
9345 /*
9346 * Clean out any no-longer-needed history files. As a side effect,
9347 * this will post a .ready file for the newly created history file,
9348 * notifying the archiver that history file may be archived
9349 * immediately.
9350 */
9351 CleanupBackupHistory();
9352 }
9353
9354 /*
9355 * If archiving is enabled, wait for all the required WAL files to be
9356 * archived before returning. If archiving isn't enabled, the required WAL
9357 * needs to be transported via streaming replication (hopefully with
9358 * wal_keep_size set high enough), or some more exotic mechanism like
9359 * polling and copying files from pg_wal with script. We have no knowledge
9360 * of those mechanisms, so it's up to the user to ensure that he gets all
9361 * the required WAL.
9362 *
9363 * We wait until both the last WAL file filled during backup and the
9364 * history file have been archived, and assume that the alphabetic sorting
9365 * property of the WAL files ensures any earlier WAL files are safely
9366 * archived as well.
9367 *
9368 * We wait forever, since archive_command is supposed to work and we
9369 * assume the admin wanted his backup to work completely. If you don't
9370 * wish to wait, then either waitforarchive should be passed in as false,
9371 * or you can set statement_timeout. Also, some notices are issued to
9372 * clue in anyone who might be doing this interactively.
9373 */
9374
9375 if (waitforarchive &&
9376 ((!backup_stopped_in_recovery && XLogArchivingActive()) ||
9377 (backup_stopped_in_recovery && XLogArchivingAlways())))
9378 {
9379 XLByteToPrevSeg(state->stoppoint, _logSegNo, wal_segment_size);
9380 XLogFileName(lastxlogfilename, state->stoptli, _logSegNo,
9381 wal_segment_size);
9382
9383 XLByteToSeg(state->startpoint, _logSegNo, wal_segment_size);
9384 BackupHistoryFileName(histfilename, state->stoptli, _logSegNo,
9385 state->startpoint, wal_segment_size);
9386
9387 seconds_before_warning = 60;
9388 waits = 0;
9389
9390 while (XLogArchiveIsBusy(lastxlogfilename) ||
9391 XLogArchiveIsBusy(histfilename))
9392 {
9393 CHECK_FOR_INTERRUPTS();
9394
9395 if (!reported_waiting && waits > 5)
9396 {
9397 ereport(NOTICE,
9398 (errmsg("base backup done, waiting for required WAL segments to be archived")));
9399 reported_waiting = true;
9400 }
9401
9402 (void) WaitLatch(MyLatch,
9403 WL_LATCH_SET | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH,
9404 1000L,
9405 WAIT_EVENT_BACKUP_WAIT_WAL_ARCHIVE);
9406 ResetLatch(MyLatch);
9407
9408 if (++waits >= seconds_before_warning)
9409 {
9410 seconds_before_warning *= 2; /* This wraps in >10 years... */
9411 ereport(WARNING,
9412 (errmsg("still waiting for all required WAL segments to be archived (%d seconds elapsed)",
9413 waits),
9414 errhint("Check that your \"archive_command\" is executing properly. "
9415 "You can safely cancel this backup, "
9416 "but the database backup will not be usable without all the WAL segments.")));
9417 }
9418 }
9419
9420 ereport(NOTICE,
9421 (errmsg("all required WAL segments have been archived")));
9422 }
9423 else if (waitforarchive)
9424 ereport(NOTICE,
9425 (errmsg("WAL archiving is not enabled; you must ensure that all required WAL segments are copied through other means to complete the backup")));
9426 }
9427
9428
9429 /*
9430 * do_pg_abort_backup: abort a running backup
9431 *
9432 * This does just the most basic steps of do_pg_backup_stop(), by taking the
9433 * system out of backup mode, thus making it a lot more safe to call from
9434 * an error handler.
9435 *
9436 * 'arg' indicates that it's being called during backup setup; so
9437 * sessionBackupState has not been modified yet, but runningBackups has
9438 * already been incremented. When it's false, then it's invoked as a
9439 * before_shmem_exit handler, and therefore we must not change state
9440 * unless sessionBackupState indicates that a backup is actually running.
9441 *
9442 * NB: This gets used as a PG_ENSURE_ERROR_CLEANUP callback and
9443 * before_shmem_exit handler, hence the odd-looking signature.
9444 */
9445 void
9446 do_pg_abort_backup(int code, Datum arg)
9447 {
9448 bool during_backup_start = DatumGetBool(arg);
9449
9450 /* If called during backup start, there shouldn't be one already running */
9451 Assert(!during_backup_start || sessionBackupState == SESSION_BACKUP_NONE);
9452
9453 if (during_backup_start || sessionBackupState != SESSION_BACKUP_NONE)
9454 {
9455 WALInsertLockAcquireExclusive();
9456 Assert(XLogCtl->Insert.runningBackups > 0);
9457 XLogCtl->Insert.runningBackups--;
9458
9459 sessionBackupState = SESSION_BACKUP_NONE;
9460 WALInsertLockRelease();
9461
9462 if (!during_backup_start)
9463 ereport(WARNING,
9464 errmsg("aborting backup due to backend exiting before pg_backup_stop was called"));
9465 }
9466 }
9467
9468 /*
9469 * Register a handler that will warn about unterminated backups at end of
9470 * session, unless this has already been done.
9471 */
9472 void
9473 register_persistent_abort_backup_handler(void)
9474 {
9475 static bool already_done = false;
9476
9477 if (already_done)
9478 return;
9479 before_shmem_exit(do_pg_abort_backup, DatumGetBool(false));
9480 already_done = true;
9481 }
9482
9483 /*
9484 * Get latest WAL insert pointer
9485 */
9486 XLogRecPtr
9487 GetXLogInsertRecPtr(void)
9488 {
9489 XLogCtlInsert *Insert = &XLogCtl->Insert;
9490 uint64 current_bytepos;
9491
9492 SpinLockAcquire(&Insert->insertpos_lck);
9493 current_bytepos = Insert->CurrBytePos;
9494 SpinLockRelease(&Insert->insertpos_lck);
9495
9496 return XLogBytePosToRecPtr(current_bytepos);
9497 }
9498
9499 /*
9500 * Get latest WAL record end pointer
9501 */
9502 XLogRecPtr
9503 GetXLogInsertEndRecPtr(void)
9504 {
9505 XLogCtlInsert *Insert = &XLogCtl->Insert;
9506 uint64 current_bytepos;
9507
9508 SpinLockAcquire(&Insert->insertpos_lck);
9509 current_bytepos = Insert->CurrBytePos;
9510 SpinLockRelease(&Insert->insertpos_lck);
9511
9512 return XLogBytePosToEndRecPtr(current_bytepos);
9513 }
9514
9515 /*
9516 * Get latest WAL write pointer
9517 */
9518 XLogRecPtr
9519 GetXLogWriteRecPtr(void)
9520 {
9521 RefreshXLogWriteResult(LogwrtResult);
9522
9523 return LogwrtResult.Write;
9524 }
9525
9526 /*
9527 * Returns the redo pointer of the last checkpoint or restartpoint. This is
9528 * the oldest point in WAL that we still need, if we have to restart recovery.
9529 */
9530 void
9531 GetOldestRestartPoint(XLogRecPtr *oldrecptr, TimeLineID *oldtli)
9532 {
9533 LWLockAcquire(ControlFileLock, LW_SHARED);
9534 *oldrecptr = ControlFile->checkPointCopy.redo;
9535 *oldtli = ControlFile->checkPointCopy.ThisTimeLineID;
9536 LWLockRelease(ControlFileLock);
9537 }
9538
9539 /* Thin wrapper around ShutdownWalRcv(). */
9540 void
9541 XLogShutdownWalRcv(void)
9542 {
9543 ShutdownWalRcv();
9544 ResetInstallXLogFileSegmentActive();
9545 }
9546
9547 /* Enable WAL file recycling and preallocation. */
9548 void
9549 SetInstallXLogFileSegmentActive(void)
9550 {
9551 LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
9552 XLogCtl->InstallXLogFileSegmentActive = true;
9553 LWLockRelease(ControlFileLock);
9554 }
9555
9556 /* Disable WAL file recycling and preallocation. */
9557 void
9558 ResetInstallXLogFileSegmentActive(void)
9559 {
9560 LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
9561 XLogCtl->InstallXLogFileSegmentActive = false;
9562 LWLockRelease(ControlFileLock);
9563 }
9564
9565 bool
9566 IsInstallXLogFileSegmentActive(void)
9567 {
9568 bool result;
9569
9570 LWLockAcquire(ControlFileLock, LW_SHARED);
9571 result = XLogCtl->InstallXLogFileSegmentActive;
9572 LWLockRelease(ControlFileLock);
9573
9574 return result;
9575 }
9576
9577 /*
9578 * Update the WalWriterSleeping flag.
9579 */
9580 void
9581 SetWalWriterSleeping(bool sleeping)
9582 {
9583 SpinLockAcquire(&XLogCtl->info_lck);
9584 XLogCtl->WalWriterSleeping = sleeping;
9585 SpinLockRelease(&XLogCtl->info_lck);
9586 }