#include "postgres.h"
#include <unistd.h>
#include "access/transam.h"
#include "access/xlog_internal.h"
#include "access/xlogreader.h"
#include "access/xlogrecord.h"
#include "catalog/pg_control.h"
#include "common/pg_lzcompress.h"
#include "replication/origin.h"
#include "miscadmin.h"
#include "pgstat.h"
#include "utils/memutils.h"

Include dependency graph for xlogreader.c:

Macros
#define	MAX_ERRORMSG_LEN 1000

#define	COPY_HEADER_FIELD(_dst, _size)

Functions
static void	report_invalid_record (XLogReaderState state, const char fmt,...) pg_attribute_printf(2

static void static bool	allocate_recordbuf (XLogReaderState *state, uint32 reclength)

static int	ReadPageInternal (XLogReaderState *state, XLogRecPtr pageptr, int reqLen)

static void	XLogReaderInvalReadState (XLogReaderState *state)

static bool	ValidXLogRecordHeader (XLogReaderState state, XLogRecPtr RecPtr, XLogRecPtr PrevRecPtr, XLogRecord record, bool randAccess)

static bool	ValidXLogRecord (XLogReaderState state, XLogRecord record, XLogRecPtr recptr)

static void	ResetDecoder (XLogReaderState *state)

XLogReaderState *	XLogReaderAllocate (int wal_segment_size, const char waldir, XLogPageReadCB pagereadfunc, void private_data)

void	XLogReaderFree (XLogReaderState *state)

void	WALOpenSegmentInit (WALOpenSegment seg, WALSegmentContext segcxt, int segsize, const char *waldir)

XLogRecord *	XLogReadRecord (XLogReaderState state, XLogRecPtr RecPtr, char *errormsg)

bool	XLogReaderValidatePageHeader (XLogReaderState state, XLogRecPtr recptr, char phdr)

bool	WALRead (char buf, XLogRecPtr startptr, Size count, TimeLineID tli, WALOpenSegment seg, WALSegmentContext segcxt, WALSegmentOpen openSegment, WALReadError errinfo)

bool	DecodeXLogRecord (XLogReaderState state, XLogRecord record, char **errormsg)

bool	XLogRecGetBlockTag (XLogReaderState record, uint8 block_id, RelFileNode rnode, ForkNumber forknum, BlockNumber blknum)

char *	XLogRecGetBlockData (XLogReaderState record, uint8 block_id, Size len)

bool	RestoreBlockImage (XLogReaderState record, uint8 block_id, char page)

FullTransactionId	XLogRecGetFullXid (XLogReaderState *record)

Macro Definition Documentation

◆ COPY_HEADER_FIELD

#define COPY_HEADER_FIELD	(	_dst,
		_size
	)

Value:

do {                                        \
        if (remaining < _size)                  \
            goto shortdata_err;                 \
        memcpy(_dst, ptr, _size);               \
        ptr += _size;                           \
        remaining -= _size;                     \
    } while(0)

Referenced by DecodeXLogRecord().

◆ MAX_ERRORMSG_LEN

#define MAX_ERRORMSG_LEN 1000

Definition at line 49 of file xlogreader.c.

Referenced by report_invalid_record(), and XLogReaderAllocate().

Function Documentation

◆ allocate_recordbuf()

static bool allocate_recordbuf	(	XLogReaderState *	state,
		uint32	reclength
	)

static

Definition at line 166 of file xlogreader.c.

References AllocSizeIsValid, Max, MCXT_ALLOC_NO_OOM, palloc_extended(), pfree(), XLogReaderState::readRecordBuf, and XLogReaderState::readRecordBufSize.

Referenced by XLogReaderAllocate(), and XLogReadRecord().

 {
     uint32      newSize = reclength;
 
     newSize += XLOG_BLCKSZ - (newSize % XLOG_BLCKSZ);
     newSize = Max(newSize, 5 * Max(BLCKSZ, XLOG_BLCKSZ));
 
 #ifndef FRONTEND
 
     /*
      * Note that in much unlucky circumstances, the random data read from a
      * recycled segment can cause this routine to be called with a size
      * causing a hard failure at allocation.  For a standby, this would cause
      * the instance to stop suddenly with a hard failure, preventing it to
      * retry fetching WAL from one of its sources which could allow it to move
      * on with replay without a manual restart. If the data comes from a past
      * recycled segment and is still valid, then the allocation may succeed
      * but record checks are going to fail so this would be short-lived.  If
      * the allocation fails because of a memory shortage, then this is not a
      * hard failure either per the guarantee given by MCXT_ALLOC_NO_OOM.
      */
     if (!AllocSizeIsValid(newSize))
         return false;
 
 #endif
 
     if (state->readRecordBuf)
         pfree(state->readRecordBuf);
     state->readRecordBuf =
         (char *) palloc_extended(newSize, MCXT_ALLOC_NO_OOM);
     if (state->readRecordBuf == NULL)
     {
         state->readRecordBufSize = 0;
         return false;
     }
     state->readRecordBufSize = newSize;
     return true;
 }

◆ DecodeXLogRecord()

bool DecodeXLogRecord	(	XLogReaderState *	state,
		XLogRecord *	record,
		char **	errormsg
	)

Definition at line 1144 of file xlogreader.c.

References DecodedBkpBlock::apply_image, Assert, DecodedBkpBlock::bimg_info, DecodedBkpBlock::bimg_len, DecodedBkpBlock::bkp_image, BKPBLOCK_FORK_MASK, BKPBLOCK_HAS_DATA, BKPBLOCK_HAS_IMAGE, BKPBLOCK_SAME_REL, BKPIMAGE_APPLY, BKPIMAGE_HAS_HOLE, BKPIMAGE_IS_COMPRESSED, DecodedBkpBlock::blkno, XLogReaderState::blocks, COPY_HEADER_FIELD, DecodedBkpBlock::data, DecodedBkpBlock::data_bufsz, DecodedBkpBlock::data_len, XLogReaderState::decoded_record, XLogReaderState::errormsg_buf, DecodedBkpBlock::flags, DecodedBkpBlock::forknum, DecodedBkpBlock::has_data, DecodedBkpBlock::has_image, DecodedBkpBlock::hole_length, DecodedBkpBlock::hole_offset, DecodedBkpBlock::in_use, InvalidRepOriginId, XLogReaderState::main_data, XLogReaderState::main_data_bufsz, XLogReaderState::main_data_len, Max, XLogReaderState::max_block_id, MAXALIGN, palloc(), pfree(), XLogReaderState::ReadRecPtr, XLogReaderState::record_origin, remaining, report_invalid_record(), ResetDecoder(), DecodedBkpBlock::rnode, SizeOfXLogRecord, XLogRecord::xl_tot_len, XLR_BLOCK_ID_DATA_LONG, XLR_BLOCK_ID_DATA_SHORT, XLR_BLOCK_ID_ORIGIN, and XLR_MAX_BLOCK_ID.

Referenced by XLogInsertRecord(), and XLogReadRecord().

 {
     /*
      * read next _size bytes from record buffer, but check for overrun first.
      */
 #define COPY_HEADER_FIELD(_dst, _size)          \
     do {                                        \
         if (remaining < _size)                  \
             goto shortdata_err;                 \
         memcpy(_dst, ptr, _size);               \
         ptr += _size;                           \
         remaining -= _size;                     \
     } while(0)
 
     char       *ptr;
     uint32      remaining;
     uint32      datatotal;
     RelFileNode *rnode = NULL;
     uint8       block_id;
 
     ResetDecoder(state);
 
     state->decoded_record = record;
     state->record_origin = InvalidRepOriginId;
 
     ptr = (char *) record;
     ptr += SizeOfXLogRecord;
     remaining = record->xl_tot_len - SizeOfXLogRecord;
 
     /* Decode the headers */
     datatotal = 0;
     while (remaining > datatotal)
     {
         COPY_HEADER_FIELD(&block_id, sizeof(uint8));
 
         if (block_id == XLR_BLOCK_ID_DATA_SHORT)
         {
             /* XLogRecordDataHeaderShort */
             uint8       main_data_len;
 
             COPY_HEADER_FIELD(&main_data_len, sizeof(uint8));
 
             state->main_data_len = main_data_len;
             datatotal += main_data_len;
             break;              /* by convention, the main data fragment is
                                  * always last */
         }
         else if (block_id == XLR_BLOCK_ID_DATA_LONG)
         {
             /* XLogRecordDataHeaderLong */
             uint32      main_data_len;
 
             COPY_HEADER_FIELD(&main_data_len, sizeof(uint32));
             state->main_data_len = main_data_len;
             datatotal += main_data_len;
             break;              /* by convention, the main data fragment is
                                  * always last */
         }
         else if (block_id == XLR_BLOCK_ID_ORIGIN)
         {
             COPY_HEADER_FIELD(&state->record_origin, sizeof(RepOriginId));
         }
         else if (block_id <= XLR_MAX_BLOCK_ID)
         {
             /* XLogRecordBlockHeader */
             DecodedBkpBlock *blk;
             uint8       fork_flags;
 
             if (block_id <= state->max_block_id)
             {
                 report_invalid_record(state,
                                       "out-of-order block_id %u at %X/%X",
                                       block_id,
                                       (uint32) (state->ReadRecPtr >> 32),
                                       (uint32) state->ReadRecPtr);
                 goto err;
             }
             state->max_block_id = block_id;
 
             blk = &state->blocks[block_id];
             blk->in_use = true;
             blk->apply_image = false;
 
             COPY_HEADER_FIELD(&fork_flags, sizeof(uint8));
             blk->forknum = fork_flags & BKPBLOCK_FORK_MASK;
             blk->flags = fork_flags;
             blk->has_image = ((fork_flags & BKPBLOCK_HAS_IMAGE) != 0);
             blk->has_data = ((fork_flags & BKPBLOCK_HAS_DATA) != 0);
 
             COPY_HEADER_FIELD(&blk->data_len, sizeof(uint16));
             /* cross-check that the HAS_DATA flag is set iff data_length > 0 */
             if (blk->has_data && blk->data_len == 0)
             {
                 report_invalid_record(state,
                                       "BKPBLOCK_HAS_DATA set, but no data included at %X/%X",
                                       (uint32) (state->ReadRecPtr >> 32), (uint32) state->ReadRecPtr);
                 goto err;
             }
             if (!blk->has_data && blk->data_len != 0)
             {
                 report_invalid_record(state,
                                       "BKPBLOCK_HAS_DATA not set, but data length is %u at %X/%X",
                                       (unsigned int) blk->data_len,
                                       (uint32) (state->ReadRecPtr >> 32), (uint32) state->ReadRecPtr);
                 goto err;
             }
             datatotal += blk->data_len;
 
             if (blk->has_image)
             {
                 COPY_HEADER_FIELD(&blk->bimg_len, sizeof(uint16));
                 COPY_HEADER_FIELD(&blk->hole_offset, sizeof(uint16));
                 COPY_HEADER_FIELD(&blk->bimg_info, sizeof(uint8));
 
                 blk->apply_image = ((blk->bimg_info & BKPIMAGE_APPLY) != 0);
 
                 if (blk->bimg_info & BKPIMAGE_IS_COMPRESSED)
                 {
                     if (blk->bimg_info & BKPIMAGE_HAS_HOLE)
                         COPY_HEADER_FIELD(&blk->hole_length, sizeof(uint16));
                     else
                         blk->hole_length = 0;
                 }
                 else
                     blk->hole_length = BLCKSZ - blk->bimg_len;
                 datatotal += blk->bimg_len;
 
                 /*
                  * cross-check that hole_offset > 0, hole_length > 0 and
                  * bimg_len < BLCKSZ if the HAS_HOLE flag is set.
                  */
                 if ((blk->bimg_info & BKPIMAGE_HAS_HOLE) &&
                     (blk->hole_offset == 0 ||
                      blk->hole_length == 0 ||
                      blk->bimg_len == BLCKSZ))
                 {
                     report_invalid_record(state,
                                           "BKPIMAGE_HAS_HOLE set, but hole offset %u length %u block image length %u at %X/%X",
                                           (unsigned int) blk->hole_offset,
                                           (unsigned int) blk->hole_length,
                                           (unsigned int) blk->bimg_len,
                                           (uint32) (state->ReadRecPtr >> 32), (uint32) state->ReadRecPtr);
                     goto err;
                 }
 
                 /*
                  * cross-check that hole_offset == 0 and hole_length == 0 if
                  * the HAS_HOLE flag is not set.
                  */
                 if (!(blk->bimg_info & BKPIMAGE_HAS_HOLE) &&
                     (blk->hole_offset != 0 || blk->hole_length != 0))
                 {
                     report_invalid_record(state,
                                           "BKPIMAGE_HAS_HOLE not set, but hole offset %u length %u at %X/%X",
                                           (unsigned int) blk->hole_offset,
                                           (unsigned int) blk->hole_length,
                                           (uint32) (state->ReadRecPtr >> 32), (uint32) state->ReadRecPtr);
                     goto err;
                 }
 
                 /*
                  * cross-check that bimg_len < BLCKSZ if the IS_COMPRESSED
                  * flag is set.
                  */
                 if ((blk->bimg_info & BKPIMAGE_IS_COMPRESSED) &&
                     blk->bimg_len == BLCKSZ)
                 {
                     report_invalid_record(state,
                                           "BKPIMAGE_IS_COMPRESSED set, but block image length %u at %X/%X",
                                           (unsigned int) blk->bimg_len,
                                           (uint32) (state->ReadRecPtr >> 32), (uint32) state->ReadRecPtr);
                     goto err;
                 }
 
                 /*
                  * cross-check that bimg_len = BLCKSZ if neither HAS_HOLE nor
                  * IS_COMPRESSED flag is set.
                  */
                 if (!(blk->bimg_info & BKPIMAGE_HAS_HOLE) &&
                     !(blk->bimg_info & BKPIMAGE_IS_COMPRESSED) &&
                     blk->bimg_len != BLCKSZ)
                 {
                     report_invalid_record(state,
                                           "neither BKPIMAGE_HAS_HOLE nor BKPIMAGE_IS_COMPRESSED set, but block image length is %u at %X/%X",
                                           (unsigned int) blk->data_len,
                                           (uint32) (state->ReadRecPtr >> 32), (uint32) state->ReadRecPtr);
                     goto err;
                 }
             }
             if (!(fork_flags & BKPBLOCK_SAME_REL))
             {
                 COPY_HEADER_FIELD(&blk->rnode, sizeof(RelFileNode));
                 rnode = &blk->rnode;
             }
             else
             {
                 if (rnode == NULL)
                 {
                     report_invalid_record(state,
                                           "BKPBLOCK_SAME_REL set but no previous rel at %X/%X",
                                           (uint32) (state->ReadRecPtr >> 32), (uint32) state->ReadRecPtr);
                     goto err;
                 }
 
                 blk->rnode = *rnode;
             }
             COPY_HEADER_FIELD(&blk->blkno, sizeof(BlockNumber));
         }
         else
         {
             report_invalid_record(state,
                                   "invalid block_id %u at %X/%X",
                                   block_id,
                                   (uint32) (state->ReadRecPtr >> 32),
                                   (uint32) state->ReadRecPtr);
             goto err;
         }
     }
 
     if (remaining != datatotal)
         goto shortdata_err;
 
     /*
      * Ok, we've parsed the fragment headers, and verified that the total
      * length of the payload in the fragments is equal to the amount of data
      * left. Copy the data of each fragment to a separate buffer.
      *
      * We could just set up pointers into readRecordBuf, but we want to align
      * the data for the convenience of the callers. Backup images are not
      * copied, however; they don't need alignment.
      */
 
     /* block data first */
     for (block_id = 0; block_id <= state->max_block_id; block_id++)
     {
         DecodedBkpBlock *blk = &state->blocks[block_id];
 
         if (!blk->in_use)
             continue;
 
         Assert(blk->has_image || !blk->apply_image);
 
         if (blk->has_image)
         {
             blk->bkp_image = ptr;
             ptr += blk->bimg_len;
         }
         if (blk->has_data)
         {
             if (!blk->data || blk->data_len > blk->data_bufsz)
             {
                 if (blk->data)
                     pfree(blk->data);
 
                 /*
                  * Force the initial request to be BLCKSZ so that we don't
                  * waste time with lots of trips through this stanza as a
                  * result of WAL compression.
                  */
                 blk->data_bufsz = MAXALIGN(Max(blk->data_len, BLCKSZ));
                 blk->data = palloc(blk->data_bufsz);
             }
             memcpy(blk->data, ptr, blk->data_len);
             ptr += blk->data_len;
         }
     }
 
     /* and finally, the main data */
     if (state->main_data_len > 0)
     {
         if (!state->main_data || state->main_data_len > state->main_data_bufsz)
         {
             if (state->main_data)
                 pfree(state->main_data);
 
             /*
              * main_data_bufsz must be MAXALIGN'ed.  In many xlog record
              * types, we omit trailing struct padding on-disk to save a few
              * bytes; but compilers may generate accesses to the xlog struct
              * that assume that padding bytes are present.  If the palloc
              * request is not large enough to include such padding bytes then
              * we'll get valgrind complaints due to otherwise-harmless fetches
              * of the padding bytes.
              *
              * In addition, force the initial request to be reasonably large
              * so that we don't waste time with lots of trips through this
              * stanza.  BLCKSZ / 2 seems like a good compromise choice.
              */
             state->main_data_bufsz = MAXALIGN(Max(state->main_data_len,
                                                   BLCKSZ / 2));
             state->main_data = palloc(state->main_data_bufsz);
         }
         memcpy(state->main_data, ptr, state->main_data_len);
         ptr += state->main_data_len;
     }
 
     return true;
 
 shortdata_err:
     report_invalid_record(state,
                           "record with invalid length at %X/%X",
                           (uint32) (state->ReadRecPtr >> 32), (uint32) state->ReadRecPtr);
 err:
     *errormsg = state->errormsg_buf;
 
     return false;
 }

◆ ReadPageInternal()

static int ReadPageInternal	(	XLogReaderState *	state,
		XLogRecPtr	pageptr,
		int	reqLen
	)

static

Definition at line 546 of file xlogreader.c.

References Assert, XLogReaderState::currRecPtr, Max, XLogReaderState::read_page, XLogReaderState::readBuf, XLogReaderState::readLen, readLen, XLogReaderState::seg, XLogReaderState::segcxt, XLogReaderState::segoff, SizeOfXLogShortPHD, WALOpenSegment::ws_segno, WALSegmentContext::ws_segsize, XLByteToSeg, XLogPageHeaderSize, XLogReaderInvalReadState(), XLogReaderValidatePageHeader(), and XLogSegmentOffset.

Referenced by XLogReaderValidatePageHeader(), and XLogReadRecord().

 {
     int         readLen;
     uint32      targetPageOff;
     XLogSegNo   targetSegNo;
     XLogPageHeader hdr;
 
     Assert((pageptr % XLOG_BLCKSZ) == 0);
 
     XLByteToSeg(pageptr, targetSegNo, state->segcxt.ws_segsize);
     targetPageOff = XLogSegmentOffset(pageptr, state->segcxt.ws_segsize);
 
     /* check whether we have all the requested data already */
     if (targetSegNo == state->seg.ws_segno &&
         targetPageOff == state->segoff && reqLen <= state->readLen)
         return state->readLen;
 
     /*
      * Data is not in our buffer.
      *
      * Every time we actually read the page, even if we looked at parts of it
      * before, we need to do verification as the read_page callback might now
      * be rereading data from a different source.
      *
      * Whenever switching to a new WAL segment, we read the first page of the
      * file and validate its header, even if that's not where the target
      * record is.  This is so that we can check the additional identification
      * info that is present in the first page's "long" header.
      */
     if (targetSegNo != state->seg.ws_segno && targetPageOff != 0)
     {
         XLogRecPtr  targetSegmentPtr = pageptr - targetPageOff;
 
         readLen = state->read_page(state, targetSegmentPtr, XLOG_BLCKSZ,
                                    state->currRecPtr,
                                    state->readBuf);
         if (readLen < 0)
             goto err;
 
         /* we can be sure to have enough WAL available, we scrolled back */
         Assert(readLen == XLOG_BLCKSZ);
 
         if (!XLogReaderValidatePageHeader(state, targetSegmentPtr,
                                           state->readBuf))
             goto err;
     }
 
     /*
      * First, read the requested data length, but at least a short page header
      * so that we can validate it.
      */
     readLen = state->read_page(state, pageptr, Max(reqLen, SizeOfXLogShortPHD),
                                state->currRecPtr,
                                state->readBuf);
     if (readLen < 0)
         goto err;
 
     Assert(readLen <= XLOG_BLCKSZ);
 
     /* Do we have enough data to check the header length? */
     if (readLen <= SizeOfXLogShortPHD)
         goto err;
 
     Assert(readLen >= reqLen);
 
     hdr = (XLogPageHeader) state->readBuf;
 
     /* still not enough */
     if (readLen < XLogPageHeaderSize(hdr))
     {
         readLen = state->read_page(state, pageptr, XLogPageHeaderSize(hdr),
                                    state->currRecPtr,
                                    state->readBuf);
         if (readLen < 0)
             goto err;
     }
 
     /*
      * Now that we know we have the full header, validate it.
      */
     if (!XLogReaderValidatePageHeader(state, pageptr, (char *) hdr))
         goto err;
 
     /* update read state information */
     state->seg.ws_segno = targetSegNo;
     state->segoff = targetPageOff;
     state->readLen = readLen;
 
     return readLen;
 
 err:
     XLogReaderInvalReadState(state);
     return -1;
 }

◆ report_invalid_record()

static void report_invalid_record	(	XLogReaderState *	state,
		const char *	fmt,
			...
	)

static

Definition at line 56 of file xlogreader.c.

References _, generate_unaccent_rules::args, XLogReaderState::errormsg_buf, MAX_ERRORMSG_LEN, and vsnprintf.

Referenced by DecodeXLogRecord(), RestoreBlockImage(), ValidXLogRecord(), ValidXLogRecordHeader(), XLogReaderValidatePageHeader(), and XLogReadRecord().

 {
     va_list     args;
 
     fmt = _(fmt);
 
     va_start(args, fmt);
     vsnprintf(state->errormsg_buf, MAX_ERRORMSG_LEN, fmt, args);
     va_end(args);
 }

◆ ResetDecoder()

static void ResetDecoder ( XLogReaderState * state )

static

Definition at line 1119 of file xlogreader.c.

References DecodedBkpBlock::apply_image, XLogReaderState::blocks, XLogReaderState::decoded_record, DecodedBkpBlock::has_data, DecodedBkpBlock::has_image, DecodedBkpBlock::in_use, XLogReaderState::main_data_len, and XLogReaderState::max_block_id.

Referenced by DecodeXLogRecord(), and XLogReadRecord().

 {
     int         block_id;
 
     state->decoded_record = NULL;
 
     state->main_data_len = 0;
 
     for (block_id = 0; block_id <= state->max_block_id; block_id++)
     {
         state->blocks[block_id].in_use = false;
         state->blocks[block_id].has_image = false;
         state->blocks[block_id].has_data = false;
         state->blocks[block_id].apply_image = false;
     }
     state->max_block_id = -1;
 }

◆ RestoreBlockImage()

bool RestoreBlockImage	(	XLogReaderState *	record,
		uint8	block_id,
		char *	page
	)

Definition at line 1513 of file xlogreader.c.

References DecodedBkpBlock::bimg_info, DecodedBkpBlock::bimg_len, DecodedBkpBlock::bkp_image, BKPIMAGE_IS_COMPRESSED, XLogReaderState::blocks, PGAlignedBlock::data, DecodedBkpBlock::has_image, DecodedBkpBlock::hole_length, DecodedBkpBlock::hole_offset, DecodedBkpBlock::in_use, MemSet, pglz_decompress(), XLogReaderState::ReadRecPtr, and report_invalid_record().

Referenced by checkXLogConsistency(), and XLogReadBufferForRedoExtended().

 {
     DecodedBkpBlock *bkpb;
     char       *ptr;
     PGAlignedBlock tmp;
 
     if (!record->blocks[block_id].in_use)
         return false;
     if (!record->blocks[block_id].has_image)
         return false;
 
     bkpb = &record->blocks[block_id];
     ptr = bkpb->bkp_image;
 
     if (bkpb->bimg_info & BKPIMAGE_IS_COMPRESSED)
     {
         /* If a backup block image is compressed, decompress it */
         if (pglz_decompress(ptr, bkpb->bimg_len, tmp.data,
                             BLCKSZ - bkpb->hole_length, true) < 0)
         {
             report_invalid_record(record, "invalid compressed image at %X/%X, block %d",
                                   (uint32) (record->ReadRecPtr >> 32),
                                   (uint32) record->ReadRecPtr,
                                   block_id);
             return false;
         }
         ptr = tmp.data;
     }
 
     /* generate page, taking into account hole if necessary */
     if (bkpb->hole_length == 0)
     {
         memcpy(page, ptr, BLCKSZ);
     }
     else
     {
         memcpy(page, ptr, bkpb->hole_offset);
         /* must zero-fill the hole */
         MemSet(page + bkpb->hole_offset, 0, bkpb->hole_length);
         memcpy(page + (bkpb->hole_offset + bkpb->hole_length),
                ptr + bkpb->hole_offset,
                BLCKSZ - (bkpb->hole_offset + bkpb->hole_length));
     }
 
     return true;
 }

◆ ValidXLogRecord()

static bool ValidXLogRecord	(	XLogReaderState *	state,
		XLogRecord *	record,
		XLogRecPtr	recptr
	)

static

Definition at line 728 of file xlogreader.c.

References COMP_CRC32C, EQ_CRC32C, FIN_CRC32C, INIT_CRC32C, offsetof, report_invalid_record(), and SizeOfXLogRecord.

Referenced by XLogReadRecord().

 {
     pg_crc32c   crc;
 
     /* Calculate the CRC */
     INIT_CRC32C(crc);
     COMP_CRC32C(crc, ((char *) record) + SizeOfXLogRecord, record->xl_tot_len - SizeOfXLogRecord);
     /* include the record header last */
     COMP_CRC32C(crc, (char *) record, offsetof(XLogRecord, xl_crc));
     FIN_CRC32C(crc);
 
     if (!EQ_CRC32C(record->xl_crc, crc))
     {
         report_invalid_record(state,
                               "incorrect resource manager data checksum in record at %X/%X",
                               (uint32) (recptr >> 32), (uint32) recptr);
         return false;
     }
 
     return true;
 }

◆ ValidXLogRecordHeader()

static bool ValidXLogRecordHeader	(	XLogReaderState *	state,
		XLogRecPtr	RecPtr,
		XLogRecPtr	PrevRecPtr,
		XLogRecord *	record,
		bool	randAccess
	)

static

Definition at line 659 of file xlogreader.c.

References report_invalid_record(), RM_MAX_ID, SizeOfXLogRecord, XLogRecord::xl_prev, XLogRecord::xl_rmid, and XLogRecord::xl_tot_len.

Referenced by XLogReadRecord().

 {
     if (record->xl_tot_len < SizeOfXLogRecord)
     {
         report_invalid_record(state,
                               "invalid record length at %X/%X: wanted %u, got %u",
                               (uint32) (RecPtr >> 32), (uint32) RecPtr,
                               (uint32) SizeOfXLogRecord, record->xl_tot_len);
         return false;
     }
     if (record->xl_rmid > RM_MAX_ID)
     {
         report_invalid_record(state,
                               "invalid resource manager ID %u at %X/%X",
                               record->xl_rmid, (uint32) (RecPtr >> 32),
                               (uint32) RecPtr);
         return false;
     }
     if (randAccess)
     {
         /*
          * We can't exactly verify the prev-link, but surely it should be less
          * than the record's own address.
          */
         if (!(record->xl_prev < RecPtr))
         {
             report_invalid_record(state,
                                   "record with incorrect prev-link %X/%X at %X/%X",
                                   (uint32) (record->xl_prev >> 32),
                                   (uint32) record->xl_prev,
                                   (uint32) (RecPtr >> 32), (uint32) RecPtr);
             return false;
         }
     }
     else
     {
         /*
          * Record's prev-link should exactly match our previous location. This
          * check guards against torn WAL pages where a stale but valid-looking
          * WAL record starts on a sector boundary.
          */
         if (record->xl_prev != PrevRecPtr)
         {
             report_invalid_record(state,
                                   "record with incorrect prev-link %X/%X at %X/%X",
                                   (uint32) (record->xl_prev >> 32),
                                   (uint32) record->xl_prev,
                                   (uint32) (RecPtr >> 32), (uint32) RecPtr);
             return false;
         }
     }
 
     return true;
 }

◆ WALOpenSegmentInit()

void WALOpenSegmentInit	(	WALOpenSegment *	seg,
		WALSegmentContext *	segcxt,
		int	segsize,
		const char *	waldir
	)

Definition at line 209 of file xlogreader.c.

References MAXPGPATH, snprintf, WALSegmentContext::ws_dir, WALOpenSegment::ws_file, WALOpenSegment::ws_segno, WALSegmentContext::ws_segsize, and WALOpenSegment::ws_tli.

Referenced by XLogReaderAllocate().

 {
     seg->ws_file = -1;
     seg->ws_segno = 0;
     seg->ws_tli = 0;
 
     segcxt->ws_segsize = segsize;
     if (waldir)
         snprintf(segcxt->ws_dir, MAXPGPATH, "%s", waldir);
 }

◆ WALRead()

bool WALRead	(	char *	buf,
		XLogRecPtr	startptr,
		Size	count,
		TimeLineID	tli,
		WALOpenSegment *	seg,
		WALSegmentContext *	segcxt,
		WALSegmentOpen	openSegment,
		WALReadError *	errinfo
	)

Definition at line 1033 of file xlogreader.c.

References buf, close, pg_pread(), pgstat_report_wait_end(), pgstat_report_wait_start(), startptr, WAIT_EVENT_WAL_READ, WALReadError::wre_errno, WALReadError::wre_off, WALReadError::wre_read, WALReadError::wre_req, WALReadError::wre_seg, WALOpenSegment::ws_file, WALOpenSegment::ws_segno, WALSegmentContext::ws_segsize, WALOpenSegment::ws_tli, XLByteInSeg, XLByteToSeg, and XLogSegmentOffset.

Referenced by logical_read_xlog_page(), read_local_xlog_page(), WALDumpReadPage(), and XLogSendPhysical().

 {
     char       *p;
     XLogRecPtr  recptr;
     Size        nbytes;
 
     p = buf;
     recptr = startptr;
     nbytes = count;
 
     while (nbytes > 0)
     {
         uint32      startoff;
         int         segbytes;
         int         readbytes;
 
         startoff = XLogSegmentOffset(recptr, segcxt->ws_segsize);
 
         /*
          * If the data we want is not in a segment we have open, close what we
          * have (if anything) and open the next one, using the caller's
          * provided openSegment callback.
          */
         if (seg->ws_file < 0 ||
             !XLByteInSeg(recptr, seg->ws_segno, segcxt->ws_segsize) ||
             tli != seg->ws_tli)
         {
             XLogSegNo   nextSegNo;
 
             if (seg->ws_file >= 0)
                 close(seg->ws_file);
 
             XLByteToSeg(recptr, nextSegNo, segcxt->ws_segsize);
             seg->ws_file = openSegment(nextSegNo, segcxt, &tli);
 
             /* Update the current segment info. */
             seg->ws_tli = tli;
             seg->ws_segno = nextSegNo;
         }
 
         /* How many bytes are within this segment? */
         if (nbytes > (segcxt->ws_segsize - startoff))
             segbytes = segcxt->ws_segsize - startoff;
         else
             segbytes = nbytes;
 
 #ifndef FRONTEND
         pgstat_report_wait_start(WAIT_EVENT_WAL_READ);
 #endif
 
         /* Reset errno first; eases reporting non-errno-affecting errors */
         errno = 0;
         readbytes = pg_pread(seg->ws_file, p, segbytes, (off_t) startoff);
 
 #ifndef FRONTEND
         pgstat_report_wait_end();
 #endif
 
         if (readbytes <= 0)
         {
             errinfo->wre_errno = errno;
             errinfo->wre_req = segbytes;
             errinfo->wre_read = readbytes;
             errinfo->wre_off = startoff;
             errinfo->wre_seg = *seg;
             return false;
         }
 
         /* Update state for read */
         recptr += readbytes;
         nbytes -= readbytes;
         p += readbytes;
     }
 
     return true;
 }

◆ XLogReaderAllocate()

XLogReaderState* XLogReaderAllocate	(	int	wal_segment_size,
		const char *	waldir,
		XLogPageReadCB	pagereadfunc,
		void *	private_data
	)

Definition at line 73 of file xlogreader.c.

References allocate_recordbuf(), XLogReaderState::errormsg_buf, XLogReaderState::max_block_id, MAX_ERRORMSG_LEN, MCXT_ALLOC_NO_OOM, MCXT_ALLOC_ZERO, palloc_extended(), pfree(), XLogReaderState::private_data, XLogReaderState::read_page, XLogReaderState::readBuf, XLogReaderState::seg, XLogReaderState::segcxt, and WALOpenSegmentInit().

Referenced by extractPageMap(), findLastCheckpoint(), main(), readOneRecord(), StartupDecodingContext(), StartupXLOG(), XLogInsertRecord(), and XlogReadTwoPhaseData().

 {
     XLogReaderState *state;
 
     state = (XLogReaderState *)
         palloc_extended(sizeof(XLogReaderState),
                         MCXT_ALLOC_NO_OOM | MCXT_ALLOC_ZERO);
     if (!state)
         return NULL;
 
     state->max_block_id = -1;
 
     /*
      * Permanently allocate readBuf.  We do it this way, rather than just
      * making a static array, for two reasons: (1) no need to waste the
      * storage in most instantiations of the backend; (2) a static char array
      * isn't guaranteed to have any particular alignment, whereas
      * palloc_extended() will provide MAXALIGN'd storage.
      */
     state->readBuf = (char *) palloc_extended(XLOG_BLCKSZ,
                                               MCXT_ALLOC_NO_OOM);
     if (!state->readBuf)
     {
         pfree(state);
         return NULL;
     }
 
     /* Initialize segment info. */
     WALOpenSegmentInit(&state->seg, &state->segcxt, wal_segment_size,
                        waldir);
 
     state->read_page = pagereadfunc;
     /* system_identifier initialized to zeroes above */
     state->private_data = private_data;
     /* ReadRecPtr, EndRecPtr and readLen initialized to zeroes above */
     state->errormsg_buf = palloc_extended(MAX_ERRORMSG_LEN + 1,
                                           MCXT_ALLOC_NO_OOM);
     if (!state->errormsg_buf)
     {
         pfree(state->readBuf);
         pfree(state);
         return NULL;
     }
     state->errormsg_buf[0] = '\0';
 
     /*
      * Allocate an initial readRecordBuf of minimal size, which can later be
      * enlarged if necessary.
      */
     if (!allocate_recordbuf(state, 0))
     {
         pfree(state->errormsg_buf);
         pfree(state->readBuf);
         pfree(state);
         return NULL;
     }
 
     return state;
 }

◆ XLogReaderFree()

void XLogReaderFree ( XLogReaderState * state )

Definition at line 135 of file xlogreader.c.

References XLogReaderState::blocks, DecodedBkpBlock::data, XLogReaderState::errormsg_buf, XLogReaderState::main_data, pfree(), XLogReaderState::readBuf, XLogReaderState::readRecordBuf, and XLR_MAX_BLOCK_ID.

Referenced by extractPageMap(), findLastCheckpoint(), FreeDecodingContext(), main(), readOneRecord(), StartupXLOG(), and XlogReadTwoPhaseData().

 {
     int         block_id;
 
     for (block_id = 0; block_id <= XLR_MAX_BLOCK_ID; block_id++)
     {
         if (state->blocks[block_id].data)
             pfree(state->blocks[block_id].data);
     }
     if (state->main_data)
         pfree(state->main_data);
 
     pfree(state->errormsg_buf);
     if (state->readRecordBuf)
         pfree(state->readRecordBuf);
     pfree(state->readBuf);
     pfree(state);
 }

◆ XLogReaderInvalReadState()

static void XLogReaderInvalReadState ( XLogReaderState * state )

static

Definition at line 645 of file xlogreader.c.

References XLogReaderState::readLen, XLogReaderState::seg, XLogReaderState::segoff, and WALOpenSegment::ws_segno.

Referenced by ReadPageInternal(), XLogReaderValidatePageHeader(), and XLogReadRecord().

 {
     state->seg.ws_segno = 0;
     state->segoff = 0;
     state->readLen = 0;
 }

◆ XLogReaderValidatePageHeader()

bool XLogReaderValidatePageHeader	(	XLogReaderState *	state,
		XLogRecPtr	recptr,
		char *	phdr
	)

Definition at line 757 of file xlogreader.c.

References Assert, XLogReaderState::EndRecPtr, header(), InvalidXLogRecPtr, XLogReaderState::latestPagePtr, XLogReaderState::latestPageTLI, MAXALIGN, MAXFNAMELEN, XLogReaderState::readBuf, readLen, ReadPageInternal(), XLogReaderState::ReadRecPtr, ReadRecPtr, report_invalid_record(), XLogReaderState::seg, XLogReaderState::segcxt, XLogReaderState::system_identifier, WALSegmentContext::ws_segsize, WALOpenSegment::ws_tli, XLByteToSeg, XLOG_PAGE_MAGIC, XLogFileName, XLogPageHeaderSize, XLogReaderInvalReadState(), XLogReadRecord(), XLogRecPtrIsInvalid, XLogSegmentOffset, XLogSegNoOffsetToRecPtr, XLP_ALL_FLAGS, XLP_FIRST_IS_CONTRECORD, XLogPageHeaderData::xlp_info, XLP_LONG_HEADER, XLogPageHeaderData::xlp_magic, XLogPageHeaderData::xlp_pageaddr, XLogPageHeaderData::xlp_rem_len, XLogLongPageHeaderData::xlp_seg_size, XLogLongPageHeaderData::xlp_sysid, XLogPageHeaderData::xlp_tli, and XLogLongPageHeaderData::xlp_xlog_blcksz.

Referenced by ReadPageInternal(), and XLogPageRead().

 {
     XLogRecPtr  recaddr;
     XLogSegNo   segno;
     int32       offset;
     XLogPageHeader hdr = (XLogPageHeader) phdr;
 
     Assert((recptr % XLOG_BLCKSZ) == 0);
 
     XLByteToSeg(recptr, segno, state->segcxt.ws_segsize);
     offset = XLogSegmentOffset(recptr, state->segcxt.ws_segsize);
 
     XLogSegNoOffsetToRecPtr(segno, offset, state->segcxt.ws_segsize, recaddr);
 
     if (hdr->xlp_magic != XLOG_PAGE_MAGIC)
     {
         char        fname[MAXFNAMELEN];
 
         XLogFileName(fname, state->seg.ws_tli, segno, state->segcxt.ws_segsize);
 
         report_invalid_record(state,
                               "invalid magic number %04X in log segment %s, offset %u",
                               hdr->xlp_magic,
                               fname,
                               offset);
         return false;
     }
 
     if ((hdr->xlp_info & ~XLP_ALL_FLAGS) != 0)
     {
         char        fname[MAXFNAMELEN];
 
         XLogFileName(fname, state->seg.ws_tli, segno, state->segcxt.ws_segsize);
 
         report_invalid_record(state,
                               "invalid info bits %04X in log segment %s, offset %u",
                               hdr->xlp_info,
                               fname,
                               offset);
         return false;
     }
 
     if (hdr->xlp_info & XLP_LONG_HEADER)
     {
         XLogLongPageHeader longhdr = (XLogLongPageHeader) hdr;
 
         if (state->system_identifier &&
             longhdr->xlp_sysid != state->system_identifier)
         {
             report_invalid_record(state,
                                   "WAL file is from different database system: WAL file database system identifier is %llu, pg_control database system identifier is %llu",
                                   (unsigned long long) longhdr->xlp_sysid,
                                   (unsigned long long) state->system_identifier);
             return false;
         }
         else if (longhdr->xlp_seg_size != state->segcxt.ws_segsize)
         {
             report_invalid_record(state,
                                   "WAL file is from different database system: incorrect segment size in page header");
             return false;
         }
         else if (longhdr->xlp_xlog_blcksz != XLOG_BLCKSZ)
         {
             report_invalid_record(state,
                                   "WAL file is from different database system: incorrect XLOG_BLCKSZ in page header");
             return false;
         }
     }
     else if (offset == 0)
     {
         char        fname[MAXFNAMELEN];
 
         XLogFileName(fname, state->seg.ws_tli, segno, state->segcxt.ws_segsize);
 
         /* hmm, first page of file doesn't have a long header? */
         report_invalid_record(state,
                               "invalid info bits %04X in log segment %s, offset %u",
                               hdr->xlp_info,
                               fname,
                               offset);
         return false;
     }
 
     /*
      * Check that the address on the page agrees with what we expected. This
      * check typically fails when an old WAL segment is recycled, and hasn't
      * yet been overwritten with new data yet.
      */
     if (hdr->xlp_pageaddr != recaddr)
     {
         char        fname[MAXFNAMELEN];
 
         XLogFileName(fname, state->seg.ws_tli, segno, state->segcxt.ws_segsize);
 
         report_invalid_record(state,
                               "unexpected pageaddr %X/%X in log segment %s, offset %u",
                               (uint32) (hdr->xlp_pageaddr >> 32), (uint32) hdr->xlp_pageaddr,
                               fname,
                               offset);
         return false;
     }
 
     /*
      * Since child timelines are always assigned a TLI greater than their
      * immediate parent's TLI, we should never see TLI go backwards across
      * successive pages of a consistent WAL sequence.
      *
      * Sometimes we re-read a segment that's already been (partially) read. So
      * we only verify TLIs for pages that are later than the last remembered
      * LSN.
      */
     if (recptr > state->latestPagePtr)
     {
         if (hdr->xlp_tli < state->latestPageTLI)
         {
             char        fname[MAXFNAMELEN];
 
             XLogFileName(fname, state->seg.ws_tli, segno, state->segcxt.ws_segsize);
 
             report_invalid_record(state,
                                   "out-of-sequence timeline ID %u (after %u) in log segment %s, offset %u",
                                   hdr->xlp_tli,
                                   state->latestPageTLI,
                                   fname,
                                   offset);
             return false;
         }
     }
     state->latestPagePtr = recptr;
     state->latestPageTLI = hdr->xlp_tli;
 
     return true;
 }

◆ XLogReadRecord()

XLogRecord* XLogReadRecord	(	XLogReaderState *	state,
		XLogRecPtr	RecPtr,
		char **	errormsg
	)

Definition at line 238 of file xlogreader.c.

References allocate_recordbuf(), Assert, XLogReaderState::currRecPtr, DecodeXLogRecord(), XLogReaderState::EndRecPtr, XLogReaderState::errormsg_buf, InvalidXLogRecPtr, MAXALIGN, Min, XLogReaderState::readBuf, readOff, ReadPageInternal(), XLogReaderState::readRecordBuf, XLogReaderState::readRecordBufSize, XLogReaderState::ReadRecPtr, report_invalid_record(), ResetDecoder(), XLogReaderState::segcxt, SizeOfXLogRecord, SizeOfXLogShortPHD, ValidXLogRecord(), ValidXLogRecordHeader(), WALSegmentContext::ws_segsize, XLogRecord::xl_info, XLogRecord::xl_rmid, XLogRecord::xl_tot_len, XLOG_SWITCH, XLogPageHeaderSize, XLogReaderInvalReadState(), XLogSegmentOffset, XLP_FIRST_IS_CONTRECORD, XLogPageHeaderData::xlp_info, XLogPageHeaderData::xlp_rem_len, XLR_INFO_MASK, and XRecOffIsValid.

Referenced by DecodingContextFindStartpoint(), extractPageMap(), findLastCheckpoint(), main(), pg_logical_replication_slot_advance(), pg_logical_slot_get_changes_guts(), readOneRecord(), ReadRecord(), XLogReaderValidatePageHeader(), XlogReadTwoPhaseData(), and XLogSendLogical().

 {
     XLogRecord *record;
     XLogRecPtr  targetPagePtr;
     bool        randAccess;
     uint32      len,
                 total_len;
     uint32      targetRecOff;
     uint32      pageHeaderSize;
     bool        gotheader;
     int         readOff;
 
     /*
      * randAccess indicates whether to verify the previous-record pointer of
      * the record we're reading.  We only do this if we're reading
      * sequentially, which is what we initially assume.
      */
     randAccess = false;
 
     /* reset error state */
     *errormsg = NULL;
     state->errormsg_buf[0] = '\0';
 
     ResetDecoder(state);
 
     if (RecPtr == InvalidXLogRecPtr)
     {
         /* No explicit start point; read the record after the one we just read */
         RecPtr = state->EndRecPtr;
 
         if (state->ReadRecPtr == InvalidXLogRecPtr)
             randAccess = true;
 
         /*
          * RecPtr is pointing to end+1 of the previous WAL record.  If we're
          * at a page boundary, no more records can fit on the current page. We
          * must skip over the page header, but we can't do that until we've
          * read in the page, since the header size is variable.
          */
     }
     else
     {
         /*
          * Caller supplied a position to start at.
          *
          * In this case, the passed-in record pointer should already be
          * pointing to a valid record starting position.
          */
         Assert(XRecOffIsValid(RecPtr));
         randAccess = true;
     }
 
     state->currRecPtr = RecPtr;
 
     targetPagePtr = RecPtr - (RecPtr % XLOG_BLCKSZ);
     targetRecOff = RecPtr % XLOG_BLCKSZ;
 
     /*
      * Read the page containing the record into state->readBuf. Request enough
      * byte to cover the whole record header, or at least the part of it that
      * fits on the same page.
      */
     readOff = ReadPageInternal(state, targetPagePtr,
                                Min(targetRecOff + SizeOfXLogRecord, XLOG_BLCKSZ));
     if (readOff < 0)
         goto err;
 
     /*
      * ReadPageInternal always returns at least the page header, so we can
      * examine it now.
      */
     pageHeaderSize = XLogPageHeaderSize((XLogPageHeader) state->readBuf);
     if (targetRecOff == 0)
     {
         /*
          * At page start, so skip over page header.
          */
         RecPtr += pageHeaderSize;
         targetRecOff = pageHeaderSize;
     }
     else if (targetRecOff < pageHeaderSize)
     {
         report_invalid_record(state, "invalid record offset at %X/%X",
                               (uint32) (RecPtr >> 32), (uint32) RecPtr);
         goto err;
     }
 
     if ((((XLogPageHeader) state->readBuf)->xlp_info & XLP_FIRST_IS_CONTRECORD) &&
         targetRecOff == pageHeaderSize)
     {
         report_invalid_record(state, "contrecord is requested by %X/%X",
                               (uint32) (RecPtr >> 32), (uint32) RecPtr);
         goto err;
     }
 
     /* ReadPageInternal has verified the page header */
     Assert(pageHeaderSize <= readOff);
 
     /*
      * Read the record length.
      *
      * NB: Even though we use an XLogRecord pointer here, the whole record
      * header might not fit on this page. xl_tot_len is the first field of the
      * struct, so it must be on this page (the records are MAXALIGNed), but we
      * cannot access any other fields until we've verified that we got the
      * whole header.
      */
     record = (XLogRecord *) (state->readBuf + RecPtr % XLOG_BLCKSZ);
     total_len = record->xl_tot_len;
 
     /*
      * If the whole record header is on this page, validate it immediately.
      * Otherwise do just a basic sanity check on xl_tot_len, and validate the
      * rest of the header after reading it from the next page.  The xl_tot_len
      * check is necessary here to ensure that we enter the "Need to reassemble
      * record" code path below; otherwise we might fail to apply
      * ValidXLogRecordHeader at all.
      */
     if (targetRecOff <= XLOG_BLCKSZ - SizeOfXLogRecord)
     {
         if (!ValidXLogRecordHeader(state, RecPtr, state->ReadRecPtr, record,
                                    randAccess))
             goto err;
         gotheader = true;
     }
     else
     {
         /* XXX: more validation should be done here */
         if (total_len < SizeOfXLogRecord)
         {
             report_invalid_record(state,
                                   "invalid record length at %X/%X: wanted %u, got %u",
                                   (uint32) (RecPtr >> 32), (uint32) RecPtr,
                                   (uint32) SizeOfXLogRecord, total_len);
             goto err;
         }
         gotheader = false;
     }
 
     len = XLOG_BLCKSZ - RecPtr % XLOG_BLCKSZ;
     if (total_len > len)
     {
         /* Need to reassemble record */
         char       *contdata;
         XLogPageHeader pageHeader;
         char       *buffer;
         uint32      gotlen;
 
         /*
          * Enlarge readRecordBuf as needed.
          */
         if (total_len > state->readRecordBufSize &&
             !allocate_recordbuf(state, total_len))
         {
             /* We treat this as a "bogus data" condition */
             report_invalid_record(state, "record length %u at %X/%X too long",
                                   total_len,
                                   (uint32) (RecPtr >> 32), (uint32) RecPtr);
             goto err;
         }
 
         /* Copy the first fragment of the record from the first page. */
         memcpy(state->readRecordBuf,
                state->readBuf + RecPtr % XLOG_BLCKSZ, len);
         buffer = state->readRecordBuf + len;
         gotlen = len;
 
         do
         {
             /* Calculate pointer to beginning of next page */
             targetPagePtr += XLOG_BLCKSZ;
 
             /* Wait for the next page to become available */
             readOff = ReadPageInternal(state, targetPagePtr,
                                        Min(total_len - gotlen + SizeOfXLogShortPHD,
                                            XLOG_BLCKSZ));
 
             if (readOff < 0)
                 goto err;
 
             Assert(SizeOfXLogShortPHD <= readOff);
 
             /* Check that the continuation on next page looks valid */
             pageHeader = (XLogPageHeader) state->readBuf;
             if (!(pageHeader->xlp_info & XLP_FIRST_IS_CONTRECORD))
             {
                 report_invalid_record(state,
                                       "there is no contrecord flag at %X/%X",
                                       (uint32) (RecPtr >> 32), (uint32) RecPtr);
                 goto err;
             }
 
             /*
              * Cross-check that xlp_rem_len agrees with how much of the record
              * we expect there to be left.
              */
             if (pageHeader->xlp_rem_len == 0 ||
                 total_len != (pageHeader->xlp_rem_len + gotlen))
             {
                 report_invalid_record(state,
                                       "invalid contrecord length %u at %X/%X",
                                       pageHeader->xlp_rem_len,
                                       (uint32) (RecPtr >> 32), (uint32) RecPtr);
                 goto err;
             }
 
             /* Append the continuation from this page to the buffer */
             pageHeaderSize = XLogPageHeaderSize(pageHeader);
 
             if (readOff < pageHeaderSize)
                 readOff = ReadPageInternal(state, targetPagePtr,
                                            pageHeaderSize);
 
             Assert(pageHeaderSize <= readOff);
 
             contdata = (char *) state->readBuf + pageHeaderSize;
             len = XLOG_BLCKSZ - pageHeaderSize;
             if (pageHeader->xlp_rem_len < len)
                 len = pageHeader->xlp_rem_len;
 
             if (readOff < pageHeaderSize + len)
                 readOff = ReadPageInternal(state, targetPagePtr,
                                            pageHeaderSize + len);
 
             memcpy(buffer, (char *) contdata, len);
             buffer += len;
             gotlen += len;
 
             /* If we just reassembled the record header, validate it. */
             if (!gotheader)
             {
                 record = (XLogRecord *) state->readRecordBuf;
                 if (!ValidXLogRecordHeader(state, RecPtr, state->ReadRecPtr,
                                            record, randAccess))
                     goto err;
                 gotheader = true;
             }
         } while (gotlen < total_len);
 
         Assert(gotheader);
 
         record = (XLogRecord *) state->readRecordBuf;
         if (!ValidXLogRecord(state, record, RecPtr))
             goto err;
 
         pageHeaderSize = XLogPageHeaderSize((XLogPageHeader) state->readBuf);
         state->ReadRecPtr = RecPtr;
         state->EndRecPtr = targetPagePtr + pageHeaderSize
             + MAXALIGN(pageHeader->xlp_rem_len);
     }
     else
     {
         /* Wait for the record data to become available */
         readOff = ReadPageInternal(state, targetPagePtr,
                                    Min(targetRecOff + total_len, XLOG_BLCKSZ));
         if (readOff < 0)
             goto err;
 
         /* Record does not cross a page boundary */
         if (!ValidXLogRecord(state, record, RecPtr))
             goto err;
 
         state->EndRecPtr = RecPtr + MAXALIGN(total_len);
 
         state->ReadRecPtr = RecPtr;
     }
 
     /*
      * Special processing if it's an XLOG SWITCH record
      */
     if (record->xl_rmid == RM_XLOG_ID &&
         (record->xl_info & ~XLR_INFO_MASK) == XLOG_SWITCH)
     {
         /* Pretend it extends to end of segment */
         state->EndRecPtr += state->segcxt.ws_segsize - 1;
         state->EndRecPtr -= XLogSegmentOffset(state->EndRecPtr, state->segcxt.ws_segsize);
     }
 
     if (DecodeXLogRecord(state, record, errormsg))
         return record;
     else
         return NULL;
 
 err:
 
     /*
      * Invalidate the read state. We might read from a different source after
      * failure.
      */
     XLogReaderInvalReadState(state);
 
     if (state->errormsg_buf[0] != '\0')
         *errormsg = state->errormsg_buf;
 
     return NULL;
 }

◆ XLogRecGetBlockData()

char* XLogRecGetBlockData	(	XLogReaderState *	record,
		uint8	block_id,
		Size *	len
	)

Definition at line 1484 of file xlogreader.c.

References XLogReaderState::blocks, DecodedBkpBlock::data, DecodedBkpBlock::data_len, DecodedBkpBlock::has_data, and DecodedBkpBlock::in_use.

Referenced by _bt_restore_meta(), brin_xlog_insert_update(), brin_xlog_samepage_update(), btree_desc(), btree_xlog_insert(), btree_xlog_newroot(), btree_xlog_split(), btree_xlog_vacuum(), DecodeInsert(), DecodeMultiInsert(), DecodeUpdate(), generic_redo(), gin_desc(), ginRedoInsert(), ginRedoInsertListPage(), ginRedoUpdateMetapage(), ginRedoVacuumDataLeafPage(), gistRedoPageSplitRecord(), gistRedoPageUpdateRecord(), hash_xlog_add_ovfl_page(), hash_xlog_delete(), hash_xlog_insert(), hash_xlog_move_page_contents(), hash_xlog_split_allocate_page(), hash_xlog_squeeze_page(), heap_xlog_clean(), heap_xlog_freeze_page(), heap_xlog_inplace(), heap_xlog_insert(), heap_xlog_multi_insert(), and heap_xlog_update().

 {
     DecodedBkpBlock *bkpb;
 
     if (!record->blocks[block_id].in_use)
         return NULL;
 
     bkpb = &record->blocks[block_id];
 
     if (!bkpb->has_data)
     {
         if (len)
             *len = 0;
         return NULL;
     }
     else
     {
         if (len)
             *len = bkpb->data_len;
         return bkpb->data;
     }
 }

◆ XLogRecGetBlockTag()

bool XLogRecGetBlockTag	(	XLogReaderState *	record,
		uint8	block_id,
		RelFileNode *	rnode,
		ForkNumber *	forknum,
		BlockNumber *	blknum
	)

Definition at line 1460 of file xlogreader.c.

References DecodedBkpBlock::blkno, XLogReaderState::blocks, DecodedBkpBlock::forknum, DecodedBkpBlock::in_use, and DecodedBkpBlock::rnode.

Referenced by brin_xlog_revmap_extend(), btree_xlog_delete(), btree_xlog_split(), btree_xlog_vacuum(), checkXLogConsistency(), DecodeDelete(), DecodeInsert(), DecodeMultiInsert(), DecodeSpecConfirm(), DecodeUpdate(), extractPageInfo(), gistRedoDeleteRecord(), gistRedoPageSplitRecord(), hash_xlog_add_ovfl_page(), hash_xlog_init_bitmap_page(), hash_xlog_init_meta_page(), hash_xlog_vacuum_one_page(), heap_xlog_clean(), heap_xlog_delete(), heap_xlog_freeze_page(), heap_xlog_insert(), heap_xlog_lock(), heap_xlog_lock_updated(), heap_xlog_multi_insert(), heap_xlog_update(), heap_xlog_visible(), spgRedoAddLeaf(), spgRedoAddNode(), spgRedoMoveLeafs(), spgRedoPickSplit(), spgRedoVacuumRedirect(), xlog_redo(), XLogDumpDisplayRecord(), and XLogReadBufferForRedoExtended().

 {
     DecodedBkpBlock *bkpb;
 
     if (!record->blocks[block_id].in_use)
         return false;
 
     bkpb = &record->blocks[block_id];
     if (rnode)
         *rnode = bkpb->rnode;
     if (forknum)
         *forknum = bkpb->forknum;
     if (blknum)
         *blknum = bkpb->blkno;
     return true;
 }

◆ XLogRecGetFullXid()

FullTransactionId XLogRecGetFullXid ( XLogReaderState * record )

Definition at line 1566 of file xlogreader.c.

References AmStartupProcess, Assert, epoch, EpochFromFullTransactionId, FullTransactionIdFromEpochAndXid(), IsUnderPostmaster, VariableCacheData::nextFullXid, ShmemVariableCache, unlikely, XidFromFullTransactionId, and XLogRecGetXid.

 {
     TransactionId   xid,
                     next_xid;
     uint32          epoch;
 
     /*
      * This function is only safe during replay, because it depends on the
      * replay state.  See AdvanceNextFullTransactionIdPastXid() for more.
      */
     Assert(AmStartupProcess() || !IsUnderPostmaster);
 
     xid = XLogRecGetXid(record);
     next_xid = XidFromFullTransactionId(ShmemVariableCache->nextFullXid);
     epoch = EpochFromFullTransactionId(ShmemVariableCache->nextFullXid);
 
     /*
      * If xid is numerically greater than next_xid, it has to be from the
      * last epoch.
      */
     if (unlikely(xid > next_xid))
         --epoch;
 
     return FullTransactionIdFromEpochAndXid(epoch, xid);
 }

Macros

Functions

Macro Definition Documentation

◆ COPY_HEADER_FIELD

◆ MAX_ERRORMSG_LEN

Function Documentation

◆ allocate_recordbuf()

◆ DecodeXLogRecord()

◆ ReadPageInternal()

◆ report_invalid_record()

◆ ResetDecoder()

◆ RestoreBlockImage()

◆ ValidXLogRecord()

◆ ValidXLogRecordHeader()

◆ WALOpenSegmentInit()

◆ WALRead()

◆ XLogReaderAllocate()

◆ XLogReaderFree()

◆ XLogReaderInvalReadState()

◆ XLogReaderValidatePageHeader()

◆ XLogReadRecord()

◆ XLogRecGetBlockData()

◆ XLogRecGetBlockTag()

◆ XLogRecGetFullXid()