1 /* 2 * xlog.h 3 * 4 * PostgreSQL write-ahead log manager 5 * 6 * Portions Copyright (c) 1996-2018, 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 */ 30 extern int sync_method; 31 32 extern 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 */ 41 extern 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 */ 64 typedef enum 65 { 66 STANDBY_DISABLED, 67 STANDBY_INITIALIZED, 68 STANDBY_SNAPSHOT_PENDING, 69 STANDBY_SNAPSHOT_READY 70 } HotStandbyState; 71 72 extern 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 standby_mode = on 79 */ 80 typedef 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 extern XLogRecPtr ProcLastRecPtr; 91 extern XLogRecPtr XactLastRecEnd; 92 extern PGDLLIMPORT XLogRecPtr XactLastCommitEnd; 93 94 extern bool reachedConsistency; 95 96 /* these variables are GUC parameters related to XLOG */ 97 extern int wal_segment_size; 98 extern int min_wal_size_mb; 99 extern int max_wal_size_mb; 100 extern int wal_keep_segments; 101 extern int XLOGbuffers; 102 extern int XLogArchiveTimeout; 103 extern int wal_retrieve_retry_interval; 104 extern char *XLogArchiveCommand; 105 extern bool EnableHotStandby; 106 extern bool fullPageWrites; 107 extern bool wal_log_hints; 108 extern bool wal_compression; 109 extern bool *wal_consistency_checking; 110 extern char *wal_consistency_checking_string; 111 extern bool log_checkpoints; 112 113 extern int CheckPointSegments; 114 115 /* Archive modes */ 116 typedef enum ArchiveMode 117 { 118 ARCHIVE_MODE_OFF = 0, /* disabled */ 119 ARCHIVE_MODE_ON, /* enabled while server is running normally */ 120 ARCHIVE_MODE_ALWAYS /* enabled always (even during recovery) */ 121 } ArchiveMode; 122 extern int XLogArchiveMode; 123 124 /* WAL levels */ 125 typedef enum WalLevel 126 { 127 WAL_LEVEL_MINIMAL = 0, 128 WAL_LEVEL_REPLICA, 129 WAL_LEVEL_LOGICAL 130 } WalLevel; 131 132 /* Recovery states */ 133 typedef enum RecoveryState 134 { 135 RECOVERY_STATE_CRASH = 0, /* crash recovery */ 136 RECOVERY_STATE_ARCHIVE, /* archive recovery */ 137 RECOVERY_STATE_DONE /* currently in production */ 138 } RecoveryState; 139 140 extern PGDLLIMPORT int wal_level; 141 142 /* Is WAL archiving enabled (always or only while server is running normally)? */ 143 #define XLogArchivingActive() \ 144 (AssertMacro(XLogArchiveMode == ARCHIVE_MODE_OFF || wal_level >= WAL_LEVEL_REPLICA), XLogArchiveMode > ARCHIVE_MODE_OFF) 145 /* Is WAL archiving enabled always (even during recovery)? */ 146 #define XLogArchivingAlways() \ 147 (AssertMacro(XLogArchiveMode == ARCHIVE_MODE_OFF || wal_level >= WAL_LEVEL_REPLICA), XLogArchiveMode == ARCHIVE_MODE_ALWAYS) 148 #define XLogArchiveCommandSet() (XLogArchiveCommand[0] != '\0') 149 150 /* 151 * Is WAL-logging necessary for archival or log-shipping, or can we skip 152 * WAL-logging if we fsync() the data before committing instead? 153 */ 154 #define XLogIsNeeded() (wal_level >= WAL_LEVEL_REPLICA) 155 156 /* 157 * Is a full-page image needed for hint bit updates? 158 * 159 * Normally, we don't WAL-log hint bit updates, but if checksums are enabled, 160 * we have to protect them against torn page writes. When you only set 161 * individual bits on a page, it's still consistent no matter what combination 162 * of the bits make it to disk, but the checksum wouldn't match. Also WAL-log 163 * them if forced by wal_log_hints=on. 164 */ 165 #define XLogHintBitIsNeeded() (DataChecksumsEnabled() || wal_log_hints) 166 167 /* Do we need to WAL-log information required only for Hot Standby and logical replication? */ 168 #define XLogStandbyInfoActive() (wal_level >= WAL_LEVEL_REPLICA) 169 170 /* Do we need to WAL-log information required only for logical replication? */ 171 #define XLogLogicalInfoActive() (wal_level >= WAL_LEVEL_LOGICAL) 172 173 #ifdef WAL_DEBUG 174 extern bool XLOG_DEBUG; 175 #endif 176 177 /* 178 * OR-able request flag bits for checkpoints. The "cause" bits are used only 179 * for logging purposes. Note: the flags must be defined so that it's 180 * sensible to OR together request flags arising from different requestors. 181 */ 182 183 /* These directly affect the behavior of CreateCheckPoint and subsidiaries */ 184 #define CHECKPOINT_IS_SHUTDOWN 0x0001 /* Checkpoint is for shutdown */ 185 #define CHECKPOINT_END_OF_RECOVERY 0x0002 /* Like shutdown checkpoint, but 186 * issued at end of WAL recovery */ 187 #define CHECKPOINT_IMMEDIATE 0x0004 /* Do it without delays */ 188 #define CHECKPOINT_FORCE 0x0008 /* Force even if no activity */ 189 #define CHECKPOINT_FLUSH_ALL 0x0010 /* Flush all pages, including those 190 * belonging to unlogged tables */ 191 /* These are important to RequestCheckpoint */ 192 #define CHECKPOINT_WAIT 0x0020 /* Wait for completion */ 193 /* These indicate the cause of a checkpoint request */ 194 #define CHECKPOINT_CAUSE_XLOG 0x0040 /* XLOG consumption */ 195 #define CHECKPOINT_CAUSE_TIME 0x0080 /* Elapsed time */ 196 /* We set this to ensure that ckpt_flags is not 0 if a request has been made */ 197 #define CHECKPOINT_REQUESTED 0x0100 /* Checkpoint request has been made */ 198 199 /* 200 * Flag bits for the record being inserted, set using XLogSetRecordFlags(). 201 */ 202 #define XLOG_INCLUDE_ORIGIN 0x01 /* include the replication origin */ 203 #define XLOG_MARK_UNIMPORTANT 0x02 /* record not important for durability */ 204 205 206 /* Checkpoint statistics */ 207 typedef struct CheckpointStatsData 208 { 209 TimestampTz ckpt_start_t; /* start of checkpoint */ 210 TimestampTz ckpt_write_t; /* start of flushing buffers */ 211 TimestampTz ckpt_sync_t; /* start of fsyncs */ 212 TimestampTz ckpt_sync_end_t; /* end of fsyncs */ 213 TimestampTz ckpt_end_t; /* end of checkpoint */ 214 215 int ckpt_bufs_written; /* # of buffers written */ 216 217 int ckpt_segs_added; /* # of new xlog segments created */ 218 int ckpt_segs_removed; /* # of xlog segments deleted */ 219 int ckpt_segs_recycled; /* # of xlog segments recycled */ 220 221 int ckpt_sync_rels; /* # of relations synced */ 222 uint64 ckpt_longest_sync; /* Longest sync for one relation */ 223 uint64 ckpt_agg_sync_time; /* The sum of all the individual sync 224 * times, which is not necessarily the 225 * same as the total elapsed time for the 226 * entire sync phase. */ 227 } CheckpointStatsData; 228 229 extern CheckpointStatsData CheckpointStats; 230 231 struct XLogRecData; 232 233 extern XLogRecPtr XLogInsertRecord(struct XLogRecData *rdata, 234 XLogRecPtr fpw_lsn, 235 uint8 flags); 236 extern void XLogFlush(XLogRecPtr RecPtr); 237 extern bool XLogBackgroundFlush(void); 238 extern bool XLogNeedsFlush(XLogRecPtr RecPtr); 239 extern int XLogFileInit(XLogSegNo segno, bool *use_existent, bool use_lock); 240 extern int XLogFileOpen(XLogSegNo segno); 241 242 extern void CheckXLogRemoved(XLogSegNo segno, TimeLineID tli); 243 extern XLogSegNo XLogGetLastRemovedSegno(void); 244 extern void XLogSetAsyncXactLSN(XLogRecPtr record); 245 extern void XLogSetReplicationSlotMinimumLSN(XLogRecPtr lsn); 246 247 extern void xlog_redo(XLogReaderState *record); 248 extern void xlog_desc(StringInfo buf, XLogReaderState *record); 249 extern const char *xlog_identify(uint8 info); 250 251 extern void issue_xlog_fsync(int fd, XLogSegNo segno); 252 253 extern bool RecoveryInProgress(void); 254 extern RecoveryState GetRecoveryState(void); 255 extern bool HotStandbyActive(void); 256 extern bool HotStandbyActiveInReplay(void); 257 extern bool XLogInsertAllowed(void); 258 extern void GetXLogReceiptTime(TimestampTz *rtime, bool *fromStream); 259 extern XLogRecPtr GetXLogReplayRecPtr(TimeLineID *replayTLI); 260 extern XLogRecPtr GetXLogInsertRecPtr(void); 261 extern XLogRecPtr GetXLogWriteRecPtr(void); 262 extern bool RecoveryIsPaused(void); 263 extern void SetRecoveryPause(bool recoveryPause); 264 extern TimestampTz GetLatestXTime(void); 265 extern TimestampTz GetCurrentChunkReplayStartTime(void); 266 extern char *XLogFileNameP(TimeLineID tli, XLogSegNo segno); 267 268 extern void UpdateControlFile(void); 269 extern uint64 GetSystemIdentifier(void); 270 extern char *GetMockAuthenticationNonce(void); 271 extern bool DataChecksumsEnabled(void); 272 extern XLogRecPtr GetFakeLSNForUnloggedRel(void); 273 extern Size XLOGShmemSize(void); 274 extern void XLOGShmemInit(void); 275 extern void BootStrapXLOG(void); 276 extern void LocalProcessControlFile(bool reset); 277 extern void StartupXLOG(void); 278 extern void ShutdownXLOG(int code, Datum arg); 279 extern void InitXLOGAccess(void); 280 extern void CreateCheckPoint(int flags); 281 extern bool CreateRestartPoint(int flags); 282 extern void XLogPutNextOid(Oid nextOid); 283 extern XLogRecPtr XLogRestorePoint(const char *rpName); 284 extern void UpdateFullPageWrites(void); 285 extern void GetFullPageWriteInfo(XLogRecPtr *RedoRecPtr_p, bool *doPageWrites_p); 286 extern XLogRecPtr GetRedoRecPtr(void); 287 extern XLogRecPtr GetInsertRecPtr(void); 288 extern XLogRecPtr GetFlushRecPtr(void); 289 extern XLogRecPtr GetLastImportantRecPtr(void); 290 extern void GetNextXidAndEpoch(TransactionId *xid, uint32 *epoch); 291 extern void RemovePromoteSignalFiles(void); 292 293 extern bool CheckPromoteSignal(void); 294 extern void WakeupRecovery(void); 295 extern void SetWalWriterSleeping(bool sleeping); 296 297 extern void XLogRequestWalReceiverReply(void); 298 299 extern void assign_max_wal_size(int newval, void *extra); 300 extern void assign_checkpoint_completion_target(double newval, void *extra); 301 302 /* 303 * Routines to start, stop, and get status of a base backup. 304 */ 305 306 /* 307 * Session-level status of base backups 308 * 309 * This is used in parallel with the shared memory status to control parallel 310 * execution of base backup functions for a given session, be it a backend 311 * dedicated to replication or a normal backend connected to a database. The 312 * update of the session-level status happens at the same time as the shared 313 * memory counters to keep a consistent global and local state of the backups 314 * running. 315 */ 316 typedef enum SessionBackupState 317 { 318 SESSION_BACKUP_NONE, 319 SESSION_BACKUP_EXCLUSIVE, 320 SESSION_BACKUP_NON_EXCLUSIVE 321 } SessionBackupState; 322 323 extern XLogRecPtr do_pg_start_backup(const char *backupidstr, bool fast, 324 TimeLineID *starttli_p, StringInfo labelfile, 325 List **tablespaces, StringInfo tblspcmapfile, bool infotbssize, 326 bool needtblspcmapfile); 327 extern XLogRecPtr do_pg_stop_backup(char *labelfile, bool waitforarchive, 328 TimeLineID *stoptli_p); 329 extern void do_pg_abort_backup(int code, Datum arg); 330 extern void register_persistent_abort_backup_handler(void); 331 extern SessionBackupState get_backup_status(void); 332 333 /* File path names (all relative to $PGDATA) */ 334 #define BACKUP_LABEL_FILE "backup_label" 335 #define BACKUP_LABEL_OLD "backup_label.old" 336 337 #define TABLESPACE_MAP "tablespace_map" 338 #define TABLESPACE_MAP_OLD "tablespace_map.old" 339 340 #endif /* XLOG_H */ 341