1/*
2 * xlog.h
3 *
4 * PostgreSQL write-ahead log manager
5 *
6 * Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
7 * Portions Copyright (c) 1994, Regents of the University of California
8 *
9 * src/include/access/xlog.h
10 */
11#ifndef XLOG_H
12#define XLOG_H
13
14#include "access/rmgr.h"
15#include "access/xlogdefs.h"
16#include "access/xloginsert.h"
17#include "access/xlogreader.h"
18#include "datatype/timestamp.h"
19#include "lib/stringinfo.h"
20#include "nodes/pg_list.h"
21#include "storage/fd.h"
22
23
24/* Sync methods */
25#define SYNC_METHOD_FSYNC 0
26#define SYNC_METHOD_FDATASYNC 1
27#define SYNC_METHOD_OPEN 2 /* for O_SYNC */
28#define SYNC_METHOD_FSYNC_WRITETHROUGH 3
29#define SYNC_METHOD_OPEN_DSYNC 4 /* for O_DSYNC */
30extern int sync_method;
31
32extern PGDLLIMPORT TimeLineID ThisTimeLineID; /* current TLI */
33
34/*
35 * Prior to 8.4, all activity during recovery was carried out by the startup
36 * process. This local variable continues to be used in many parts of the
37 * code to indicate actions taken by RecoveryManagers. Other processes that
38 * potentially perform work during recovery should check RecoveryInProgress().
39 * See XLogCtl notes in xlog.c.
40 */
41extern bool InRecovery;
42
43/*
44 * Like InRecovery, standbyState is only valid in the startup process.
45 * In all other processes it will have the value STANDBY_DISABLED (so
46 * InHotStandby will read as false).
47 *
48 * In DISABLED state, we're performing crash recovery or hot standby was
49 * disabled in postgresql.conf.
50 *
51 * In INITIALIZED state, we've run InitRecoveryTransactionEnvironment, but
52 * we haven't yet processed a RUNNING_XACTS or shutdown-checkpoint WAL record
53 * to initialize our master-transaction tracking system.
54 *
55 * When the transaction tracking is initialized, we enter the SNAPSHOT_PENDING
56 * state. The tracked information might still be incomplete, so we can't allow
57 * connections yet, but redo functions must update the in-memory state when
58 * appropriate.
59 *
60 * In SNAPSHOT_READY mode, we have full knowledge of transactions that are
61 * (or were) running in the master at the current WAL location. Snapshots
62 * can be taken, and read-only queries can be run.
63 */
64typedef enum
65{
66 STANDBY_DISABLED,
67 STANDBY_INITIALIZED,
68 STANDBY_SNAPSHOT_PENDING,
69 STANDBY_SNAPSHOT_READY
70} HotStandbyState;
71
72extern HotStandbyState standbyState;
73
74#define InHotStandby (standbyState >= STANDBY_SNAPSHOT_PENDING)
75
76/*
77 * Recovery target type.
78 * Only set during a Point in Time recovery, not when in standby mode.
79 */
80typedef enum
81{
82 RECOVERY_TARGET_UNSET,
83 RECOVERY_TARGET_XID,
84 RECOVERY_TARGET_TIME,
85 RECOVERY_TARGET_NAME,
86 RECOVERY_TARGET_LSN,
87 RECOVERY_TARGET_IMMEDIATE
88} RecoveryTargetType;
89
90/*
91 * Recovery target TimeLine goal
92 */
93typedef enum
94{
95 RECOVERY_TARGET_TIMELINE_CONTROLFILE,
96 RECOVERY_TARGET_TIMELINE_LATEST,
97 RECOVERY_TARGET_TIMELINE_NUMERIC
98} RecoveryTargetTimeLineGoal;
99
100extern XLogRecPtr ProcLastRecPtr;
101extern XLogRecPtr XactLastRecEnd;
102extern PGDLLIMPORT XLogRecPtr XactLastCommitEnd;
103
104extern bool reachedConsistency;
105
106/* these variables are GUC parameters related to XLOG */
107extern int wal_segment_size;
108extern int min_wal_size_mb;
109extern int max_wal_size_mb;
110extern int wal_keep_segments;
111extern int XLOGbuffers;
112extern int XLogArchiveTimeout;
113extern int wal_retrieve_retry_interval;
114extern char *XLogArchiveCommand;
115extern bool EnableHotStandby;
116extern bool fullPageWrites;
117extern bool wal_log_hints;
118extern bool wal_compression;
119extern bool wal_init_zero;
120extern bool wal_recycle;
121extern bool *wal_consistency_checking;
122extern char *wal_consistency_checking_string;
123extern bool log_checkpoints;
124extern char *recoveryRestoreCommand;
125extern char *recoveryEndCommand;
126extern char *archiveCleanupCommand;
127extern bool recoveryTargetInclusive;
128extern int recoveryTargetAction;
129extern int recovery_min_apply_delay;
130extern char *PrimaryConnInfo;
131extern char *PrimarySlotName;
132
133/* indirectly set via GUC system */
134extern TransactionId recoveryTargetXid;
135extern char *recovery_target_time_string;
136extern const char *recoveryTargetName;
137extern XLogRecPtr recoveryTargetLSN;
138extern RecoveryTargetType recoveryTarget;
139extern char *PromoteTriggerFile;
140extern RecoveryTargetTimeLineGoal recoveryTargetTimeLineGoal;
141extern TimeLineID recoveryTargetTLIRequested;
142extern TimeLineID recoveryTargetTLI;
143
144extern int CheckPointSegments;
145
146/* option set locally in startup process only when signal files exist */
147extern bool StandbyModeRequested;
148extern bool StandbyMode;
149
150/* Archive modes */
151typedef enum ArchiveMode
152{
153 ARCHIVE_MODE_OFF = 0, /* disabled */
154 ARCHIVE_MODE_ON, /* enabled while server is running normally */
155 ARCHIVE_MODE_ALWAYS /* enabled always (even during recovery) */
156} ArchiveMode;
157extern int XLogArchiveMode;
158
159/* WAL levels */
160typedef enum WalLevel
161{
162 WAL_LEVEL_MINIMAL = 0,
163 WAL_LEVEL_REPLICA,
164 WAL_LEVEL_LOGICAL
165} WalLevel;
166
167extern PGDLLIMPORT int wal_level;
168
169/* Is WAL archiving enabled (always or only while server is running normally)? */
170#define XLogArchivingActive() \
171 (AssertMacro(XLogArchiveMode == ARCHIVE_MODE_OFF || wal_level >= WAL_LEVEL_REPLICA), XLogArchiveMode > ARCHIVE_MODE_OFF)
172/* Is WAL archiving enabled always (even during recovery)? */
173#define XLogArchivingAlways() \
174 (AssertMacro(XLogArchiveMode == ARCHIVE_MODE_OFF || wal_level >= WAL_LEVEL_REPLICA), XLogArchiveMode == ARCHIVE_MODE_ALWAYS)
175#define XLogArchiveCommandSet() (XLogArchiveCommand[0] != '\0')
176
177/*
178 * Is WAL-logging necessary for archival or log-shipping, or can we skip
179 * WAL-logging if we fsync() the data before committing instead?
180 */
181#define XLogIsNeeded() (wal_level >= WAL_LEVEL_REPLICA)
182
183/*
184 * Is a full-page image needed for hint bit updates?
185 *
186 * Normally, we don't WAL-log hint bit updates, but if checksums are enabled,
187 * we have to protect them against torn page writes. When you only set
188 * individual bits on a page, it's still consistent no matter what combination
189 * of the bits make it to disk, but the checksum wouldn't match. Also WAL-log
190 * them if forced by wal_log_hints=on.
191 */
192#define XLogHintBitIsNeeded() (DataChecksumsEnabled() || wal_log_hints)
193
194/* Do we need to WAL-log information required only for Hot Standby and logical replication? */
195#define XLogStandbyInfoActive() (wal_level >= WAL_LEVEL_REPLICA)
196
197/* Do we need to WAL-log information required only for logical replication? */
198#define XLogLogicalInfoActive() (wal_level >= WAL_LEVEL_LOGICAL)
199
200#ifdef WAL_DEBUG
201extern bool XLOG_DEBUG;
202#endif
203
204/*
205 * OR-able request flag bits for checkpoints. The "cause" bits are used only
206 * for logging purposes. Note: the flags must be defined so that it's
207 * sensible to OR together request flags arising from different requestors.
208 */
209
210/* These directly affect the behavior of CreateCheckPoint and subsidiaries */
211#define CHECKPOINT_IS_SHUTDOWN 0x0001 /* Checkpoint is for shutdown */
212#define CHECKPOINT_END_OF_RECOVERY 0x0002 /* Like shutdown checkpoint, but
213 * issued at end of WAL recovery */
214#define CHECKPOINT_IMMEDIATE 0x0004 /* Do it without delays */
215#define CHECKPOINT_FORCE 0x0008 /* Force even if no activity */
216#define CHECKPOINT_FLUSH_ALL 0x0010 /* Flush all pages, including those
217 * belonging to unlogged tables */
218/* These are important to RequestCheckpoint */
219#define CHECKPOINT_WAIT 0x0020 /* Wait for completion */
220#define CHECKPOINT_REQUESTED 0x0040 /* Checkpoint request has been made */
221/* These indicate the cause of a checkpoint request */
222#define CHECKPOINT_CAUSE_XLOG 0x0080 /* XLOG consumption */
223#define CHECKPOINT_CAUSE_TIME 0x0100 /* Elapsed time */
224
225/*
226 * Flag bits for the record being inserted, set using XLogSetRecordFlags().
227 */
228#define XLOG_INCLUDE_ORIGIN 0x01 /* include the replication origin */
229#define XLOG_MARK_UNIMPORTANT 0x02 /* record not important for durability */
230
231
232/* Checkpoint statistics */
233typedef struct CheckpointStatsData
234{
235 TimestampTz ckpt_start_t; /* start of checkpoint */
236 TimestampTz ckpt_write_t; /* start of flushing buffers */
237 TimestampTz ckpt_sync_t; /* start of fsyncs */
238 TimestampTz ckpt_sync_end_t; /* end of fsyncs */
239 TimestampTz ckpt_end_t; /* end of checkpoint */
240
241 int ckpt_bufs_written; /* # of buffers written */
242
243 int ckpt_segs_added; /* # of new xlog segments created */
244 int ckpt_segs_removed; /* # of xlog segments deleted */
245 int ckpt_segs_recycled; /* # of xlog segments recycled */
246
247 int ckpt_sync_rels; /* # of relations synced */
248 uint64 ckpt_longest_sync; /* Longest sync for one relation */
249 uint64 ckpt_agg_sync_time; /* The sum of all the individual sync
250 * times, which is not necessarily the
251 * same as the total elapsed time for the
252 * entire sync phase. */
253} CheckpointStatsData;
254
255extern CheckpointStatsData CheckpointStats;
256
257struct XLogRecData;
258
259extern XLogRecPtr XLogInsertRecord(struct XLogRecData *rdata,
260 XLogRecPtr fpw_lsn,
261 uint8 flags);
262extern void XLogFlush(XLogRecPtr RecPtr);
263extern bool XLogBackgroundFlush(void);
264extern bool XLogNeedsFlush(XLogRecPtr RecPtr);
265extern int XLogFileInit(XLogSegNo segno, bool *use_existent, bool use_lock);
266extern int XLogFileOpen(XLogSegNo segno);
267
268extern void CheckXLogRemoved(XLogSegNo segno, TimeLineID tli);
269extern XLogSegNo XLogGetLastRemovedSegno(void);
270extern void XLogSetAsyncXactLSN(XLogRecPtr record);
271extern void XLogSetReplicationSlotMinimumLSN(XLogRecPtr lsn);
272
273extern void xlog_redo(XLogReaderState *record);
274extern void xlog_desc(StringInfo buf, XLogReaderState *record);
275extern const char *xlog_identify(uint8 info);
276
277extern void issue_xlog_fsync(int fd, XLogSegNo segno);
278
279extern bool RecoveryInProgress(void);
280extern bool HotStandbyActive(void);
281extern bool HotStandbyActiveInReplay(void);
282extern bool XLogInsertAllowed(void);
283extern void GetXLogReceiptTime(TimestampTz *rtime, bool *fromStream);
284extern XLogRecPtr GetXLogReplayRecPtr(TimeLineID *replayTLI);
285extern XLogRecPtr GetXLogInsertRecPtr(void);
286extern XLogRecPtr GetXLogWriteRecPtr(void);
287extern bool RecoveryIsPaused(void);
288extern void SetRecoveryPause(bool recoveryPause);
289extern TimestampTz GetLatestXTime(void);
290extern TimestampTz GetCurrentChunkReplayStartTime(void);
291extern char *XLogFileNameP(TimeLineID tli, XLogSegNo segno);
292
293extern void UpdateControlFile(void);
294extern uint64 GetSystemIdentifier(void);
295extern char *GetMockAuthenticationNonce(void);
296extern bool DataChecksumsEnabled(void);
297extern XLogRecPtr GetFakeLSNForUnloggedRel(void);
298extern Size XLOGShmemSize(void);
299extern void XLOGShmemInit(void);
300extern void BootStrapXLOG(void);
301extern void LocalProcessControlFile(bool reset);
302extern void StartupXLOG(void);
303extern void ShutdownXLOG(int code, Datum arg);
304extern void InitXLOGAccess(void);
305extern void CreateCheckPoint(int flags);
306extern bool CreateRestartPoint(int flags);
307extern void XLogPutNextOid(Oid nextOid);
308extern XLogRecPtr XLogRestorePoint(const char *rpName);
309extern void UpdateFullPageWrites(void);
310extern void GetFullPageWriteInfo(XLogRecPtr *RedoRecPtr_p, bool *doPageWrites_p);
311extern XLogRecPtr GetRedoRecPtr(void);
312extern XLogRecPtr GetInsertRecPtr(void);
313extern XLogRecPtr GetFlushRecPtr(void);
314extern XLogRecPtr GetLastImportantRecPtr(void);
315extern void RemovePromoteSignalFiles(void);
316
317extern bool CheckPromoteSignal(void);
318extern void WakeupRecovery(void);
319extern void SetWalWriterSleeping(bool sleeping);
320
321extern void XLogRequestWalReceiverReply(void);
322
323extern void assign_max_wal_size(int newval, void *extra);
324extern void assign_checkpoint_completion_target(double newval, void *extra);
325
326/*
327 * Routines to start, stop, and get status of a base backup.
328 */
329
330/*
331 * Session-level status of base backups
332 *
333 * This is used in parallel with the shared memory status to control parallel
334 * execution of base backup functions for a given session, be it a backend
335 * dedicated to replication or a normal backend connected to a database. The
336 * update of the session-level status happens at the same time as the shared
337 * memory counters to keep a consistent global and local state of the backups
338 * running.
339 */
340typedef enum SessionBackupState
341{
342 SESSION_BACKUP_NONE,
343 SESSION_BACKUP_EXCLUSIVE,
344 SESSION_BACKUP_NON_EXCLUSIVE
345} SessionBackupState;
346
347extern XLogRecPtr do_pg_start_backup(const char *backupidstr, bool fast,
348 TimeLineID *starttli_p, StringInfo labelfile,
349 List **tablespaces, StringInfo tblspcmapfile, bool infotbssize,
350 bool needtblspcmapfile);
351extern XLogRecPtr do_pg_stop_backup(char *labelfile, bool waitforarchive,
352 TimeLineID *stoptli_p);
353extern void do_pg_abort_backup(void);
354extern SessionBackupState get_backup_status(void);
355
356/* File path names (all relative to $PGDATA) */
357#define RECOVERY_SIGNAL_FILE "recovery.signal"
358#define STANDBY_SIGNAL_FILE "standby.signal"
359#define BACKUP_LABEL_FILE "backup_label"
360#define BACKUP_LABEL_OLD "backup_label.old"
361
362#define TABLESPACE_MAP "tablespace_map"
363#define TABLESPACE_MAP_OLD "tablespace_map.old"
364
365/* files to signal promotion to primary */
366#define PROMOTE_SIGNAL_FILE "promote"
367#define FALLBACK_PROMOTE_SIGNAL_FILE "fallback_promote"
368
369#endif /* XLOG_H */
370