4 * PostgreSQL transaction log manager
6 * Portions Copyright (c) 1996-2010, PostgreSQL Global Development Group
7 * Portions Copyright (c) 1994, Regents of the University of California
9 * $PostgreSQL: pgsql/src/include/access/xlog.h,v 1.117 2010/09/15 10:35:05 heikki Exp $
14 #include "access/rmgr.h"
15 #include "access/xlogdefs.h"
16 #include "lib/stringinfo.h"
17 #include "storage/buf.h"
18 #include "utils/guc.h"
19 #include "utils/pg_crc.h"
20 #include "utils/timestamp.h"
24 * The overall layout of an XLOG record is:
25 * Fixed-size header (XLogRecord struct)
33 * where there can be zero to three backup blocks (as signaled by xl_info flag
34 * bits). XLogRecord structs always start on MAXALIGN boundaries in the WAL
35 * files, and we round up SizeOfXLogRecord so that the rmgr data is also
36 * guaranteed to begin on a MAXALIGN boundary. However, no padding is added
37 * to align BkpBlock structs or backup block data.
39 * NOTE: xl_len counts only the rmgr data, not the XLogRecord header,
40 * and also not any backup blocks. xl_tot_len counts everything. Neither
41 * length field is rounded up to an alignment boundary.
43 typedef struct XLogRecord
45 pg_crc32 xl_crc; /* CRC for this record */
46 XLogRecPtr xl_prev; /* ptr to previous record in log */
47 TransactionId xl_xid; /* xact id */
48 uint32 xl_tot_len; /* total len of entire record */
49 uint32 xl_len; /* total len of rmgr data */
50 uint8 xl_info; /* flag bits, see below */
51 RmgrId xl_rmid; /* resource manager for this record */
53 /* Depending on MAXALIGN, there are either 2 or 6 wasted bytes here */
55 /* ACTUAL LOG DATA FOLLOWS AT END OF STRUCT */
59 #define SizeOfXLogRecord MAXALIGN(sizeof(XLogRecord))
61 #define XLogRecGetData(record) ((char*) (record) + SizeOfXLogRecord)
64 * XLOG uses only low 4 bits of xl_info. High 4 bits may be used by rmgr.
66 #define XLR_INFO_MASK 0x0F
69 * If we backed up any disk blocks with the XLOG record, we use flag bits in
70 * xl_info to signal it. We support backup of up to 3 disk blocks per XLOG
73 #define XLR_BKP_BLOCK_MASK 0x0E /* all info bits used for bkp blocks */
74 #define XLR_MAX_BKP_BLOCKS 3
75 #define XLR_SET_BKP_BLOCK(iblk) (0x08 >> (iblk))
76 #define XLR_BKP_BLOCK_1 XLR_SET_BKP_BLOCK(0) /* 0x08 */
77 #define XLR_BKP_BLOCK_2 XLR_SET_BKP_BLOCK(1) /* 0x04 */
78 #define XLR_BKP_BLOCK_3 XLR_SET_BKP_BLOCK(2) /* 0x02 */
81 * Bit 0 of xl_info is set if the backed-up blocks could safely be removed
82 * from a compressed version of XLOG (that is, they are backed up only to
83 * prevent partial-page-write problems, and not to ensure consistency of PITR
84 * recovery). The compression algorithm would need to extract data from the
85 * blocks to create an equivalent non-full-page XLOG record.
87 #define XLR_BKP_REMOVABLE 0x01
90 #define SYNC_METHOD_FSYNC 0
91 #define SYNC_METHOD_FDATASYNC 1
92 #define SYNC_METHOD_OPEN 2 /* for O_SYNC */
93 #define SYNC_METHOD_FSYNC_WRITETHROUGH 3
94 #define SYNC_METHOD_OPEN_DSYNC 4 /* for O_DSYNC */
95 extern int sync_method;
98 * The rmgr data to be written by XLogInsert() is defined by a chain of
99 * one or more XLogRecData structs. (Multiple structs would be used when
100 * parts of the source data aren't physically adjacent in memory, or when
101 * multiple associated buffers need to be specified.)
103 * If buffer is valid then XLOG will check if buffer must be backed up
104 * (ie, whether this is first change of that page since last checkpoint).
105 * If so, the whole page contents are attached to the XLOG record, and XLOG
106 * sets XLR_BKP_BLOCK_X bit in xl_info. Note that the buffer must be pinned
107 * and exclusive-locked by the caller, so that it won't change under us.
108 * NB: when the buffer is backed up, we DO NOT insert the data pointed to by
109 * this XLogRecData struct into the XLOG record, since we assume it's present
110 * in the buffer. Therefore, rmgr redo routines MUST pay attention to
111 * XLR_BKP_BLOCK_X to know what is actually stored in the XLOG record.
112 * The i'th XLR_BKP_BLOCK bit corresponds to the i'th distinct buffer
113 * value (ignoring InvalidBuffer) appearing in the rdata chain.
115 * When buffer is valid, caller must set buffer_std to indicate whether the
116 * page uses standard pd_lower/pd_upper header fields. If this is true, then
117 * XLOG is allowed to omit the free space between pd_lower and pd_upper from
118 * the backed-up page image. Note that even when buffer_std is false, the
119 * page MUST have an LSN field as its first eight bytes!
121 * Note: data can be NULL to indicate no rmgr data associated with this chain
122 * entry. This can be sensible (ie, not a wasted entry) if buffer is valid.
123 * The implication is that the buffer has been changed by the operation being
124 * logged, and so may need to be backed up, but the change can be redone using
125 * only information already present elsewhere in the XLOG entry.
127 typedef struct XLogRecData
129 char *data; /* start of rmgr data to include */
130 uint32 len; /* length of rmgr data to include */
131 Buffer buffer; /* buffer associated with data, if any */
132 bool buffer_std; /* buffer has standard pd_lower/pd_upper */
133 struct XLogRecData *next; /* next struct in chain, or NULL */
136 extern PGDLLIMPORT TimeLineID ThisTimeLineID; /* current TLI */
139 * Prior to 8.4, all activity during recovery was carried out by the startup
140 * process. This local variable continues to be used in many parts of the
141 * code to indicate actions taken by RecoveryManagers. Other processes that
142 * potentially perform work during recovery should check RecoveryInProgress().
143 * See XLogCtl notes in xlog.c.
145 extern bool InRecovery;
148 * Like InRecovery, standbyState is only valid in the startup process.
149 * In all other processes it will have the value STANDBY_DISABLED (so
150 * InHotStandby will read as FALSE).
152 * In DISABLED state, we're performing crash recovery or hot standby was
153 * disabled in postgresql.conf.
155 * In INITIALIZED state, we've run InitRecoveryTransactionEnvironment, but
156 * we haven't yet processed a RUNNING_XACTS or shutdown-checkpoint WAL record
157 * to initialize our master-transaction tracking system.
159 * When the transaction tracking is initialized, we enter the SNAPSHOT_PENDING
160 * state. The tracked information might still be incomplete, so we can't allow
161 * connections yet, but redo functions must update the in-memory state when
164 * In SNAPSHOT_READY mode, we have full knowledge of transactions that are
165 * (or were) running in the master at the current WAL location. Snapshots
166 * can be taken, and read-only queries can be run.
172 STANDBY_SNAPSHOT_PENDING,
173 STANDBY_SNAPSHOT_READY
176 extern HotStandbyState standbyState;
178 #define InHotStandby (standbyState >= STANDBY_SNAPSHOT_PENDING)
181 * Recovery target type.
182 * Only set during a Point in Time recovery, not when standby_mode = on
186 RECOVERY_TARGET_UNSET,
189 } RecoveryTargetType;
191 extern XLogRecPtr XactLastRecEnd;
193 /* these variables are GUC parameters related to XLOG */
194 extern int CheckPointSegments;
195 extern int wal_keep_segments;
196 extern int XLOGbuffers;
197 extern int XLogArchiveTimeout;
198 extern bool XLogArchiveMode;
199 extern char *XLogArchiveCommand;
200 extern bool EnableHotStandby;
201 extern bool log_checkpoints;
204 typedef enum WalLevel
206 WAL_LEVEL_MINIMAL = 0,
208 WAL_LEVEL_HOT_STANDBY
210 extern int wal_level;
212 #define XLogArchivingActive() (XLogArchiveMode && wal_level >= WAL_LEVEL_ARCHIVE)
213 #define XLogArchiveCommandSet() (XLogArchiveCommand[0] != '\0')
216 * Is WAL-logging necessary for archival or log-shipping, or can we skip
217 * WAL-logging if we fsync() the data before committing instead?
219 #define XLogIsNeeded() (wal_level >= WAL_LEVEL_ARCHIVE)
221 /* Do we need to WAL-log information required only for Hot Standby? */
222 #define XLogStandbyInfoActive() (wal_level >= WAL_LEVEL_HOT_STANDBY)
225 * Replication mode. This is used to identify how long transaction
226 * commit should wait for replication.
228 * REPLICATION_MODE_ASYNC doesn't make transaction commit wait for
229 * replication, i.e., asynchronous replication.
231 * REPLICATION_MODE_RECV makes transaction commit wait for XLOG
232 * records to be received on the standby.
234 * REPLICATION_MODE_FSYNC makes transaction commit wait for XLOG
235 * records to be received and fsync'd on the standby.
237 * REPLICATION_MODE_APPLY makes transaction commit wait for XLOG
238 * records to be received, fsync'd and applied on the standby.
240 typedef enum ReplicationMode
242 REPLICATION_MODE_ASYNC = 0,
243 REPLICATION_MODE_RECV,
244 REPLICATION_MODE_FSYNC,
245 REPLICATION_MODE_APPLY
247 extern int replication_mode;
248 extern const struct config_enum_entry replication_mode_options[];
251 extern bool XLOG_DEBUG;
255 * OR-able request flag bits for checkpoints. The "cause" bits are used only
256 * for logging purposes. Note: the flags must be defined so that it's
257 * sensible to OR together request flags arising from different requestors.
260 /* These directly affect the behavior of CreateCheckPoint and subsidiaries */
261 #define CHECKPOINT_IS_SHUTDOWN 0x0001 /* Checkpoint is for shutdown */
262 #define CHECKPOINT_END_OF_RECOVERY 0x0002 /* Like shutdown checkpoint,
263 * but issued at end of WAL
265 #define CHECKPOINT_IMMEDIATE 0x0004 /* Do it without delays */
266 #define CHECKPOINT_FORCE 0x0008 /* Force even if no activity */
267 /* These are important to RequestCheckpoint */
268 #define CHECKPOINT_WAIT 0x0010 /* Wait for completion */
269 /* These indicate the cause of a checkpoint request */
270 #define CHECKPOINT_CAUSE_XLOG 0x0020 /* XLOG consumption */
271 #define CHECKPOINT_CAUSE_TIME 0x0040 /* Elapsed time */
273 /* Checkpoint statistics */
274 typedef struct CheckpointStatsData
276 TimestampTz ckpt_start_t; /* start of checkpoint */
277 TimestampTz ckpt_write_t; /* start of flushing buffers */
278 TimestampTz ckpt_sync_t; /* start of fsyncs */
279 TimestampTz ckpt_sync_end_t; /* end of fsyncs */
280 TimestampTz ckpt_end_t; /* end of checkpoint */
282 int ckpt_bufs_written; /* # of buffers written */
284 int ckpt_segs_added; /* # of new xlog segments created */
285 int ckpt_segs_removed; /* # of xlog segments deleted */
286 int ckpt_segs_recycled; /* # of xlog segments recycled */
287 } CheckpointStatsData;
289 extern CheckpointStatsData CheckpointStats;
291 extern XLogRecPtr XLogInsert(RmgrId rmid, uint8 info, XLogRecData *rdata);
292 extern void XLogFlush(XLogRecPtr RecPtr);
293 extern void XLogBackgroundFlush(void);
294 extern bool XLogNeedsFlush(XLogRecPtr RecPtr);
295 extern int XLogFileInit(uint32 log, uint32 seg,
296 bool *use_existent, bool use_lock);
297 extern int XLogFileOpen(uint32 log, uint32 seg);
300 extern void XLogGetLastRemoved(uint32 *log, uint32 *seg);
301 extern void XLogSetAsyncXactLSN(XLogRecPtr record);
303 extern void RestoreBkpBlocks(XLogRecPtr lsn, XLogRecord *record, bool cleanup);
305 extern void xlog_redo(XLogRecPtr lsn, XLogRecord *record);
306 extern void xlog_desc(StringInfo buf, uint8 xl_info, char *rec);
308 extern void issue_xlog_fsync(int fd, uint32 log, uint32 seg);
310 extern bool RecoveryInProgress(void);
311 extern bool XLogInsertAllowed(void);
312 extern void GetXLogReceiptTime(TimestampTz *rtime, bool *fromStream);
314 extern void UpdateControlFile(void);
315 extern uint64 GetSystemIdentifier(void);
316 extern Size XLOGShmemSize(void);
317 extern void XLOGShmemInit(void);
318 extern void BootStrapXLOG(void);
319 extern void StartupXLOG(void);
320 extern void ShutdownXLOG(int code, Datum arg);
321 extern void InitXLOGAccess(void);
322 extern void CreateCheckPoint(int flags);
323 extern bool CreateRestartPoint(int flags);
324 extern void XLogPutNextOid(Oid nextOid);
325 extern XLogRecPtr GetRedoRecPtr(void);
326 extern XLogRecPtr GetInsertRecPtr(void);
327 extern XLogRecPtr GetFlushRecPtr(void);
328 extern XLogRecPtr GetReplayRecPtr(void);
329 extern void GetNextXidAndEpoch(TransactionId *xid, uint32 *epoch);
330 extern TimeLineID GetRecoveryTargetTLI(void);
332 extern void HandleStartupProcInterrupts(void);
333 extern void StartupProcessMain(void);
334 extern bool StandbyIsTriggered(void);
335 extern void WakeupRecovery(void);