xlogreader.c File Reference

#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:

Go to the source code of this file.

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)
void	XLogBeginRead (XLogReaderState *state, XLogRecPtr RecPtr)
XLogRecord *	XLogReadRecord (XLogReaderState *state, 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 1165 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 568 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 1140 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(), XLogBeginRead(), 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 1534 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 750 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 681 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 1054 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;
}

XLogBeginRead()

void XLogBeginRead	(	XLogReaderState *	state,
		XLogRecPtr	RecPtr
	)

Definition at line 233 of file xlogreader.c.

References Assert, XLogReaderState::EndRecPtr, InvalidXLogRecPtr, XLogReaderState::ReadRecPtr, ResetDecoder(), and XLogRecPtrIsInvalid.

Referenced by DecodingContextFindStartpoint(), extractPageMap(), findLastCheckpoint(), pg_logical_replication_slot_advance(), pg_logical_slot_get_changes_guts(), ReadCheckpointRecord(), readOneRecord(), StartLogicalReplication(), StartupXLOG(), XLogReaderValidatePageHeader(), and XlogReadTwoPhaseData().

{
    Assert(!XLogRecPtrIsInvalid(RecPtr));

    ResetDecoder(state);

    /* Begin at the passed-in record pointer. */
    state->EndRecPtr = RecPtr;
    state->ReadRecPtr = InvalidXLogRecPtr;
}

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 667 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 779 of file xlogreader.c.

References Assert, 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, XLogBeginRead(), 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,
		char **	errormsg
	)

Definition at line 261 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().

{
    XLogRecPtr  RecPtr;
    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);

    RecPtr = state->EndRecPtr;

    if (state->ReadRecPtr != InvalidXLogRecPtr)
    {
        /* read the record after the one we just read */

        /*
         * EndRecPtr 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, EndRecPtr 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 1505 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_dedup(), btree_xlog_delete(), 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 1481 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(), 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 1587 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);
}