src/include/access/xlog.h

   1 /*
   2  * xlog.h
   3  *
   4  * PostgreSQL transaction log manager
   5  *
   6  * Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
   7  * Portions Copyright (c) 1994, Regents of the University of California
   8  *
   9  * $PostgreSQL$
  10  */
  11 #ifndef XLOG_H
  12 #define XLOG_H
  13
  14 #include "access/rmgr.h"
  15 #include "access/xlogdefs.h"
  16 #include "lib/stringinfo.h"
  17 #include "storage/buf.h"
  18 #include "utils/pg_crc.h"
  19 #include "utils/timestamp.h"
  20
  21
  22 /*
  23  * The overall layout of an XLOG record is:
  24  *              Fixed-size header (XLogRecord struct)
  25  *              rmgr-specific data
  26  *              BkpBlock
  27  *              backup block data
  28  *              BkpBlock
  29  *              backup block data
  30  *              ...
  31  *
  32  * where there can be zero to three backup blocks (as signaled by xl_info flag
  33  * bits).  XLogRecord structs always start on MAXALIGN boundaries in the WAL
  34  * files, and we round up SizeOfXLogRecord so that the rmgr data is also
  35  * guaranteed to begin on a MAXALIGN boundary.  However, no padding is added
  36  * to align BkpBlock structs or backup block data.
  37  *
  38  * NOTE: xl_len counts only the rmgr data, not the XLogRecord header,
  39  * and also not any backup blocks.      xl_tot_len counts everything.  Neither
  40  * length field is rounded up to an alignment boundary.
  41  */
  42 typedef struct XLogRecord
  43 {
  44         pg_crc32        xl_crc;                 /* CRC for this record */
  45         XLogRecPtr      xl_prev;                /* ptr to previous record in log */
  46         TransactionId xl_xid;           /* xact id */
  47         uint32          xl_tot_len;             /* total len of entire record */
  48         uint32          xl_len;                 /* total len of rmgr data */
  49         uint8           xl_info;                /* flag bits, see below */
  50         RmgrId          xl_rmid;                /* resource manager for this record */
  51
  52         /* Depending on MAXALIGN, there are either 2 or 6 wasted bytes here */
  53
  54         /* ACTUAL LOG DATA FOLLOWS AT END OF STRUCT */
  55
  56 } XLogRecord;
  57
  58 #define SizeOfXLogRecord        MAXALIGN(sizeof(XLogRecord))
  59
  60 #define XLogRecGetData(record)  ((char*) (record) + SizeOfXLogRecord)
  61
  62 /*
  63  * XLOG uses only low 4 bits of xl_info.  High 4 bits may be used by rmgr.
  64  */
  65 #define XLR_INFO_MASK                   0x0F
  66
  67 /*
  68  * If we backed up any disk blocks with the XLOG record, we use flag bits in
  69  * xl_info to signal it.  We support backup of up to 3 disk blocks per XLOG
  70  * record.
  71  */
  72 #define XLR_BKP_BLOCK_MASK              0x0E    /* all info bits used for bkp blocks */
  73 #define XLR_MAX_BKP_BLOCKS              3
  74 #define XLR_SET_BKP_BLOCK(iblk) (0x08 >> (iblk))
  75 #define XLR_BKP_BLOCK_1                 XLR_SET_BKP_BLOCK(0)    /* 0x08 */
  76 #define XLR_BKP_BLOCK_2                 XLR_SET_BKP_BLOCK(1)    /* 0x04 */
  77 #define XLR_BKP_BLOCK_3                 XLR_SET_BKP_BLOCK(2)    /* 0x02 */
  78
  79 /*
  80  * Bit 0 of xl_info is set if the backed-up blocks could safely be removed
  81  * from a compressed version of XLOG (that is, they are backed up only to
  82  * prevent partial-page-write problems, and not to ensure consistency of PITR
  83  * recovery).  The compression algorithm would need to extract data from the
  84  * blocks to create an equivalent non-full-page XLOG record.
  85  */
  86 #define XLR_BKP_REMOVABLE               0x01
  87
  88 /* Sync methods */
  89 #define SYNC_METHOD_FSYNC               0
  90 #define SYNC_METHOD_FDATASYNC   1
  91 #define SYNC_METHOD_OPEN                2               /* for O_SYNC */
  92 #define SYNC_METHOD_FSYNC_WRITETHROUGH  3
  93 #define SYNC_METHOD_OPEN_DSYNC  4               /* for O_DSYNC */
  94 extern int      sync_method;
  95
  96 /*
  97  * The rmgr data to be written by XLogInsert() is defined by a chain of
  98  * one or more XLogRecData structs.  (Multiple structs would be used when
  99  * parts of the source data aren't physically adjacent in memory, or when
 100  * multiple associated buffers need to be specified.)
 101  *
 102  * If buffer is valid then XLOG will check if buffer must be backed up
 103  * (ie, whether this is first change of that page since last checkpoint).
 104  * If so, the whole page contents are attached to the XLOG record, and XLOG
 105  * sets XLR_BKP_BLOCK_X bit in xl_info.  Note that the buffer must be pinned
 106  * and exclusive-locked by the caller, so that it won't change under us.
 107  * NB: when the buffer is backed up, we DO NOT insert the data pointed to by
 108  * this XLogRecData struct into the XLOG record, since we assume it's present
 109  * in the buffer.  Therefore, rmgr redo routines MUST pay attention to
 110  * XLR_BKP_BLOCK_X to know what is actually stored in the XLOG record.
 111  * The i'th XLR_BKP_BLOCK bit corresponds to the i'th distinct buffer
 112  * value (ignoring InvalidBuffer) appearing in the rdata chain.
 113  *
 114  * When buffer is valid, caller must set buffer_std to indicate whether the
 115  * page uses standard pd_lower/pd_upper header fields.  If this is true, then
 116  * XLOG is allowed to omit the free space between pd_lower and pd_upper from
 117  * the backed-up page image.  Note that even when buffer_std is false, the
 118  * page MUST have an LSN field as its first eight bytes!
 119  *
 120  * Note: data can be NULL to indicate no rmgr data associated with this chain
 121  * entry.  This can be sensible (ie, not a wasted entry) if buffer is valid.
 122  * The implication is that the buffer has been changed by the operation being
 123  * logged, and so may need to be backed up, but the change can be redone using
 124  * only information already present elsewhere in the XLOG entry.
 125  */
 126 typedef struct XLogRecData
 127 {
 128         char       *data;                       /* start of rmgr data to include */
 129         uint32          len;                    /* length of rmgr data to include */
 130         Buffer          buffer;                 /* buffer associated with data, if any */
 131         bool            buffer_std;             /* buffer has standard pd_lower/pd_upper */
 132         struct XLogRecData *next;       /* next struct in chain, or NULL */
 133 } XLogRecData;
 134
 135 extern TimeLineID ThisTimeLineID;               /* current TLI */
 136 extern bool InRecovery;
 137 extern XLogRecPtr XactLastRecEnd;
 138
 139 /* these variables are GUC parameters related to XLOG */
 140 extern int      CheckPointSegments;
 141 extern int      XLOGbuffers;
 142 extern bool XLogArchiveMode;
 143 extern char *XLogArchiveCommand;
 144 extern int      XLogArchiveTimeout;
 145 extern bool log_checkpoints;
 146
 147 #define XLogArchivingActive()   (XLogArchiveMode)
 148 #define XLogArchiveCommandSet() (XLogArchiveCommand[0] != '\0')
 149
 150 #ifdef WAL_DEBUG
 151 extern bool XLOG_DEBUG;
 152 #endif
 153
 154 /*
 155  * OR-able request flag bits for checkpoints.  The "cause" bits are used only
 156  * for logging purposes.  Note: the flags must be defined so that it's
 157  * sensible to OR together request flags arising from different requestors.
 158  */
 159
 160 /* These directly affect the behavior of CreateCheckPoint and subsidiaries */
 161 #define CHECKPOINT_IS_SHUTDOWN  0x0001  /* Checkpoint is for shutdown */
 162 #define CHECKPOINT_IMMEDIATE    0x0002  /* Do it without delays */
 163 #define CHECKPOINT_FORCE                0x0004  /* Force even if no activity */
 164 /* These are important to RequestCheckpoint */
 165 #define CHECKPOINT_WAIT                 0x0008  /* Wait for completion */
 166 /* These indicate the cause of a checkpoint request */
 167 #define CHECKPOINT_CAUSE_XLOG   0x0010  /* XLOG consumption */
 168 #define CHECKPOINT_CAUSE_TIME   0x0020  /* Elapsed time */
 169 #define CHECKPOINT_END_OF_RECOVERY      0x0040  /* Like shutdown checkpoint, but
 170                                                                                          * issued at end of WAL recovery */
 171
 172 /* Checkpoint statistics */
 173 typedef struct CheckpointStatsData
 174 {
 175         TimestampTz ckpt_start_t;       /* start of checkpoint */
 176         TimestampTz ckpt_write_t;       /* start of flushing buffers */
 177         TimestampTz ckpt_sync_t;        /* start of fsyncs */
 178         TimestampTz ckpt_sync_end_t;    /* end of fsyncs */
 179         TimestampTz ckpt_end_t;         /* end of checkpoint */
 180
 181         int                     ckpt_bufs_written;              /* # of buffers written */
 182
 183         int                     ckpt_segs_added;        /* # of new xlog segments created */
 184         int                     ckpt_segs_removed;              /* # of xlog segments deleted */
 185         int                     ckpt_segs_recycled;             /* # of xlog segments recycled */
 186 } CheckpointStatsData;
 187
 188 extern CheckpointStatsData CheckpointStats;
 189
 190
 191 extern XLogRecPtr XLogInsert(RmgrId rmid, uint8 info, XLogRecData *rdata);
 192 extern void XLogFlush(XLogRecPtr RecPtr);
 193 extern void XLogBackgroundFlush(void);
 194 extern void XLogAsyncCommitFlush(void);
 195 extern bool XLogNeedsFlush(XLogRecPtr RecPtr);
 196
 197 extern void XLogSetAsyncCommitLSN(XLogRecPtr record);
 198
 199 extern void RestoreBkpBlocks(XLogRecPtr lsn, XLogRecord *record, bool cleanup);
 200
 201 extern void xlog_redo(XLogRecPtr lsn, XLogRecord *record);
 202 extern void xlog_desc(StringInfo buf, uint8 xl_info, char *rec);
 203
 204 extern bool RecoveryInProgress(void);
 205
 206 extern void UpdateControlFile(void);
 207 extern Size XLOGShmemSize(void);
 208 extern void XLOGShmemInit(void);
 209 extern void BootStrapXLOG(void);
 210 extern void StartupXLOG(void);
 211 extern void ShutdownXLOG(int code, Datum arg);
 212 extern void InitXLOGAccess(void);
 213 extern void CreateCheckPoint(int flags);
 214 extern bool CreateRestartPoint(int flags);
 215 extern void XLogPutNextOid(Oid nextOid);
 216 extern XLogRecPtr GetRedoRecPtr(void);
 217 extern XLogRecPtr GetInsertRecPtr(void);
 218 extern void GetNextXidAndEpoch(TransactionId *xid, uint32 *epoch);
 219
 220 extern void StartupProcessMain(void);
 221
 222 #endif   /* XLOG_H */