granicus.if.org Git - postgresql/blob - src/include/access/xlog_internal.h

   1 /*
   2  * xlog_internal.h
   3  *
   4  * PostgreSQL transaction log internal declarations
   5  *
   6  * NOTE: this file is intended to contain declarations useful for
   7  * manipulating the XLOG files directly, but it is not supposed to be
   8  * needed by rmgr routines (redo support for individual record types).
   9  * So the XLogRecord typedef and associated stuff appear in xlog.h.
  10  *
  11  * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
  12  * Portions Copyright (c) 1994, Regents of the University of California
  13  *
  14  * src/include/access/xlog_internal.h
  15  */
  16 #ifndef XLOG_INTERNAL_H
  17 #define XLOG_INTERNAL_H
  18
  19 #include "access/xlog.h"
  20 #include "fmgr.h"
  21 #include "pgtime.h"
  22 #include "storage/block.h"
  23 #include "storage/relfilenode.h"
  24
  25
  26 /*
  27  * Header info for a backup block appended to an XLOG record.
  28  *
  29  * As a trivial form of data compression, the XLOG code is aware that
  30  * PG data pages usually contain an unused "hole" in the middle, which
  31  * contains only zero bytes.  If hole_length > 0 then we have removed
  32  * such a "hole" from the stored data (and it's not counted in the
  33  * XLOG record's CRC, either).  Hence, the amount of block data actually
  34  * present following the BkpBlock struct is BLCKSZ - hole_length bytes.
  35  *
  36  * Note that we don't attempt to align either the BkpBlock struct or the
  37  * block's data.  So, the struct must be copied to aligned local storage
  38  * before use.
  39  */
  40 typedef struct BkpBlock
  41 {
  42         RelFileNode node;                       /* relation containing block */
  43         ForkNumber      fork;                   /* fork within the relation */
  44         BlockNumber block;                      /* block number */
  45         uint16          hole_offset;    /* number of bytes before "hole" */
  46         uint16          hole_length;    /* number of bytes in "hole" */
  47
  48         /* ACTUAL BLOCK DATA FOLLOWS AT END OF STRUCT */
  49 } BkpBlock;
  50
  51 /*
  52  * When there is not enough space on current page for whole record, we
  53  * continue on the next page with continuation record.  (However, the
  54  * XLogRecord header will never be split across pages; if there's less than
  55  * SizeOfXLogRecord space left at the end of a page, we just waste it.)
  56  *
  57  * Note that xl_rem_len includes backup-block data; that is, it tracks
  58  * xl_tot_len not xl_len in the initial header.  Also note that the
  59  * continuation data isn't necessarily aligned.
  60  */
  61 typedef struct XLogContRecord
  62 {
  63         uint32          xl_rem_len;             /* total len of remaining data for record */
  64
  65         /* ACTUAL LOG DATA FOLLOWS AT END OF STRUCT */
  66
  67 } XLogContRecord;
  68
  69 #define SizeOfXLogContRecord    sizeof(XLogContRecord)
  70
  71 /*
  72  * Each page of XLOG file has a header like this:
  73  */
  74 #define XLOG_PAGE_MAGIC 0xD070  /* can be used as WAL version indicator */
  75
  76 typedef struct XLogPageHeaderData
  77 {
  78         uint16          xlp_magic;              /* magic value for correctness checks */
  79         uint16          xlp_info;               /* flag bits, see below */
  80         TimeLineID      xlp_tli;                /* TimeLineID of first record on page */
  81         XLogRecPtr      xlp_pageaddr;   /* XLOG address of this page */
  82 } XLogPageHeaderData;
  83
  84 #define SizeOfXLogShortPHD      MAXALIGN(sizeof(XLogPageHeaderData))
  85
  86 typedef XLogPageHeaderData *XLogPageHeader;
  87
  88 /*
  89  * When the XLP_LONG_HEADER flag is set, we store additional fields in the
  90  * page header.  (This is ordinarily done just in the first page of an
  91  * XLOG file.)  The additional fields serve to identify the file accurately.
  92  */
  93 typedef struct XLogLongPageHeaderData
  94 {
  95         XLogPageHeaderData std;         /* standard header fields */
  96         uint64          xlp_sysid;              /* system identifier from pg_control */
  97         uint32          xlp_seg_size;   /* just as a cross-check */
  98         uint32          xlp_xlog_blcksz;        /* just as a cross-check */
  99 } XLogLongPageHeaderData;
 100
 101 #define SizeOfXLogLongPHD       MAXALIGN(sizeof(XLogLongPageHeaderData))
 102
 103 typedef XLogLongPageHeaderData *XLogLongPageHeader;
 104
 105 /* When record crosses page boundary, set this flag in new page's header */
 106 #define XLP_FIRST_IS_CONTRECORD         0x0001
 107 /* This flag indicates a "long" page header */
 108 #define XLP_LONG_HEADER                         0x0002
 109 /* This flag indicates backup blocks starting in this page are optional */
 110 #define XLP_BKP_REMOVABLE                       0x0004
 111 /* All defined flag bits in xlp_info (used for validity checking of header) */
 112 #define XLP_ALL_FLAGS                           0x0007
 113
 114 #define XLogPageHeaderSize(hdr)         \
 115         (((hdr)->xlp_info & XLP_LONG_HEADER) ? SizeOfXLogLongPHD : SizeOfXLogShortPHD)
 116
 117 /*
 118  * We break each logical log file (xlogid value) into segment files of the
 119  * size indicated by XLOG_SEG_SIZE.  One possible segment at the end of each
 120  * log file is wasted, to ensure that we don't have problems representing
 121  * last-byte-position-plus-1.
 122  */
 123 #define XLogSegSize             ((uint32) XLOG_SEG_SIZE)
 124 #define XLogSegsPerFile (((uint32) 0xffffffff) / XLogSegSize)
 125 #define XLogFileSize    (XLogSegsPerFile * XLogSegSize)
 126
 127
 128 /*
 129  * Macros for manipulating XLOG pointers
 130  */
 131
 132 /* Increment an xlogid/segment pair */
 133 #define NextLogSeg(logId, logSeg)       \
 134         do { \
 135                 if ((logSeg) >= XLogSegsPerFile-1) \
 136                 { \
 137                         (logId)++; \
 138                         (logSeg) = 0; \
 139                 } \
 140                 else \
 141                         (logSeg)++; \
 142         } while (0)
 143
 144 /* Decrement an xlogid/segment pair (assume it's not 0,0) */
 145 #define PrevLogSeg(logId, logSeg)       \
 146         do { \
 147                 if (logSeg) \
 148                         (logSeg)--; \
 149                 else \
 150                 { \
 151                         (logId)--; \
 152                         (logSeg) = XLogSegsPerFile-1; \
 153                 } \
 154         } while (0)
 155
 156 /* Align a record pointer to next page */
 157 #define NextLogPage(recptr) \
 158         do {    \
 159                 if ((recptr).xrecoff % XLOG_BLCKSZ != 0)        \
 160                         (recptr).xrecoff +=     \
 161                                 (XLOG_BLCKSZ - (recptr).xrecoff % XLOG_BLCKSZ); \
 162                 if ((recptr).xrecoff >= XLogFileSize) \
 163                 {       \
 164                         ((recptr).xlogid)++;    \
 165                         (recptr).xrecoff = 0; \
 166                 }       \
 167         } while (0)
 168
 169 /*
 170  * Compute ID and segment from an XLogRecPtr.
 171  *
 172  * For XLByteToSeg, do the computation at face value.  For XLByteToPrevSeg,
 173  * a boundary byte is taken to be in the previous segment.      This is suitable
 174  * for deciding which segment to write given a pointer to a record end,
 175  * for example.  (We can assume xrecoff is not zero, since no valid recptr
 176  * can have that.)
 177  */
 178 #define XLByteToSeg(xlrp, logId, logSeg)        \
 179         ( logId = (xlrp).xlogid, \
 180           logSeg = (xlrp).xrecoff / XLogSegSize \
 181         )
 182 #define XLByteToPrevSeg(xlrp, logId, logSeg)    \
 183         ( logId = (xlrp).xlogid, \
 184           logSeg = ((xlrp).xrecoff - 1) / XLogSegSize \
 185         )
 186
 187 /*
 188  * Is an XLogRecPtr within a particular XLOG segment?
 189  *
 190  * For XLByteInSeg, do the computation at face value.  For XLByteInPrevSeg,
 191  * a boundary byte is taken to be in the previous segment.
 192  */
 193 #define XLByteInSeg(xlrp, logId, logSeg)        \
 194         ((xlrp).xlogid == (logId) && \
 195          (xlrp).xrecoff / XLogSegSize == (logSeg))
 196
 197 #define XLByteInPrevSeg(xlrp, logId, logSeg)    \
 198         ((xlrp).xlogid == (logId) && \
 199          ((xlrp).xrecoff - 1) / XLogSegSize == (logSeg))
 200
 201 /* Check if an xrecoff value is in a plausible range */
 202 #define XRecOffIsValid(xrecoff) \
 203                 ((xrecoff) % XLOG_BLCKSZ >= SizeOfXLogShortPHD && \
 204                 (XLOG_BLCKSZ - (xrecoff) % XLOG_BLCKSZ) >= SizeOfXLogRecord)
 205
 206 /*
 207  * The XLog directory and control file (relative to $PGDATA)
 208  */
 209 #define XLOGDIR                         "pg_xlog"
 210 #define XLOG_CONTROL_FILE       "global/pg_control"
 211
 212 /*
 213  * These macros encapsulate knowledge about the exact layout of XLog file
 214  * names, timeline history file names, and archive-status file names.
 215  */
 216 #define MAXFNAMELEN             64
 217
 218 #define XLogFileName(fname, tli, log, seg)      \
 219         snprintf(fname, MAXFNAMELEN, "%08X%08X%08X", tli, log, seg)
 220
 221 #define XLogFromFileName(fname, tli, log, seg)  \
 222         sscanf(fname, "%08X%08X%08X", tli, log, seg)
 223
 224 #define XLogFilePath(path, tli, log, seg)       \
 225         snprintf(path, MAXPGPATH, XLOGDIR "/%08X%08X%08X", tli, log, seg)
 226
 227 #define TLHistoryFileName(fname, tli)   \
 228         snprintf(fname, MAXFNAMELEN, "%08X.history", tli)
 229
 230 #define TLHistoryFilePath(path, tli)    \
 231         snprintf(path, MAXPGPATH, XLOGDIR "/%08X.history", tli)
 232
 233 #define StatusFilePath(path, xlog, suffix)      \
 234         snprintf(path, MAXPGPATH, XLOGDIR "/archive_status/%s%s", xlog, suffix)
 235
 236 #define BackupHistoryFileName(fname, tli, log, seg, offset) \
 237         snprintf(fname, MAXFNAMELEN, "%08X%08X%08X.%08X.backup", tli, log, seg, offset)
 238
 239 #define BackupHistoryFilePath(path, tli, log, seg, offset)      \
 240         snprintf(path, MAXPGPATH, XLOGDIR "/%08X%08X%08X.%08X.backup", tli, log, seg, offset)
 241
 242
 243 /*
 244  * Method table for resource managers.
 245  *
 246  * RmgrTable[] is indexed by RmgrId values (see rmgr.h).
 247  */
 248 typedef struct RmgrData
 249 {
 250         const char *rm_name;
 251         void            (*rm_redo) (XLogRecPtr lsn, XLogRecord *rptr);
 252         void            (*rm_desc) (StringInfo buf, uint8 xl_info, char *rec);
 253         void            (*rm_startup) (void);
 254         void            (*rm_cleanup) (void);
 255         bool            (*rm_safe_restartpoint) (void);
 256 } RmgrData;
 257
 258 extern const RmgrData RmgrTable[];
 259
 260 /*
 261  * Exported to support xlog switching from checkpointer
 262  */
 263 extern pg_time_t GetLastSegSwitchTime(void);
 264 extern XLogRecPtr RequestXLogSwitch(void);
 265
 266 /*
 267  * These aren't in xlog.h because I'd rather not include fmgr.h there.
 268  */
 269 extern Datum pg_start_backup(PG_FUNCTION_ARGS);
 270 extern Datum pg_stop_backup(PG_FUNCTION_ARGS);
 271 extern Datum pg_switch_xlog(PG_FUNCTION_ARGS);
 272 extern Datum pg_create_restore_point(PG_FUNCTION_ARGS);
 273 extern Datum pg_current_xlog_location(PG_FUNCTION_ARGS);
 274 extern Datum pg_current_xlog_insert_location(PG_FUNCTION_ARGS);
 275 extern Datum pg_last_xlog_receive_location(PG_FUNCTION_ARGS);
 276 extern Datum pg_last_xlog_replay_location(PG_FUNCTION_ARGS);
 277 extern Datum pg_last_xact_replay_timestamp(PG_FUNCTION_ARGS);
 278 extern Datum pg_xlogfile_name_offset(PG_FUNCTION_ARGS);
 279 extern Datum pg_xlogfile_name(PG_FUNCTION_ARGS);
 280 extern Datum pg_is_in_recovery(PG_FUNCTION_ARGS);
 281 extern Datum pg_xlog_replay_pause(PG_FUNCTION_ARGS);
 282 extern Datum pg_xlog_replay_resume(PG_FUNCTION_ARGS);
 283 extern Datum pg_is_xlog_replay_paused(PG_FUNCTION_ARGS);
 284 extern Datum pg_xlog_location_diff(PG_FUNCTION_ARGS);
 285
 286 #endif   /* XLOG_INTERNAL_H */