xlogreader.h File Reference

#include "access/transam.h"
#include "access/xlogrecord.h"
#include "storage/buf.h"

Include dependency graph for xlogreader.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	WALOpenSegment
struct	WALSegmentContext
struct	XLogReaderRoutine
struct	DecodedBkpBlock
struct	DecodedXLogRecord
struct	XLogReaderState
struct	WALReadError

Macros
#define	XL_ROUTINE(...)   &(XLogReaderRoutine){__VA_ARGS__}
#define	XLogRecGetTotalLen(decoder)   ((decoder)->record->header.xl_tot_len)
#define	XLogRecGetPrev(decoder)   ((decoder)->record->header.xl_prev)
#define	XLogRecGetInfo(decoder)   ((decoder)->record->header.xl_info)
#define	XLogRecGetRmid(decoder)   ((decoder)->record->header.xl_rmid)
#define	XLogRecGetXid(decoder)   ((decoder)->record->header.xl_xid)
#define	XLogRecGetOrigin(decoder)   ((decoder)->record->record_origin)
#define	XLogRecGetTopXid(decoder)   ((decoder)->record->toplevel_xid)
#define	XLogRecGetData(decoder)   ((decoder)->record->main_data)
#define	XLogRecGetDataLen(decoder)   ((decoder)->record->main_data_len)
#define	XLogRecHasAnyBlockRefs(decoder)   ((decoder)->record->max_block_id >= 0)
#define	XLogRecMaxBlockId(decoder)   ((decoder)->record->max_block_id)
#define	XLogRecGetBlock(decoder, i)   (&(decoder)->record->blocks[(i)])
#define	XLogRecHasBlockRef(decoder, block_id)
#define	XLogRecHasBlockImage(decoder, block_id)    ((decoder)->record->blocks[block_id].has_image)
#define	XLogRecBlockImageApply(decoder, block_id)    ((decoder)->record->blocks[block_id].apply_image)
#define	XLogRecHasBlockData(decoder, block_id)    ((decoder)->record->blocks[block_id].has_data)

Typedefs
typedef struct WALOpenSegment	WALOpenSegment
typedef struct WALSegmentContext	WALSegmentContext
typedef struct XLogReaderState	XLogReaderState
typedef int(*	XLogPageReadCB) (XLogReaderState *xlogreader, XLogRecPtr targetPagePtr, int reqLen, XLogRecPtr targetRecPtr, char *readBuf)
typedef void(*	WALSegmentOpenCB) (XLogReaderState *xlogreader, XLogSegNo nextSegNo, TimeLineID *tli_p)
typedef void(*	WALSegmentCloseCB) (XLogReaderState *xlogreader)
typedef struct XLogReaderRoutine	XLogReaderRoutine
typedef struct DecodedXLogRecord	DecodedXLogRecord
typedef enum XLogPageReadResult	XLogPageReadResult
typedef struct WALReadError	WALReadError

Enumerations
enum	XLogPageReadResult { XLREAD_SUCCESS = 0 , XLREAD_FAIL = -1 , XLREAD_WOULDBLOCK = -2 }

Functions
static bool	XLogReaderHasQueuedRecordOrError (XLogReaderState *state)
XLogReaderState *	XLogReaderAllocate (int wal_segment_size, const char *waldir, XLogReaderRoutine *routine, void *private_data)
void	XLogReaderFree (XLogReaderState *state)
void	XLogReaderSetDecodeBuffer (XLogReaderState *state, void *buffer, size_t size)
void	XLogBeginRead (XLogReaderState *state, XLogRecPtr RecPtr)
XLogRecPtr	XLogFindNextRecord (XLogReaderState *state, XLogRecPtr RecPtr)
struct XLogRecord *	XLogReadRecord (XLogReaderState *state, char **errormsg)
DecodedXLogRecord *	XLogNextRecord (XLogReaderState *state, char **errormsg)
XLogRecPtr	XLogReleasePreviousRecord (XLogReaderState *state)
DecodedXLogRecord *	XLogReadAhead (XLogReaderState *state, bool nonblocking)
bool	XLogReaderValidatePageHeader (XLogReaderState *state, XLogRecPtr recptr, char *phdr)
void	XLogReaderResetError (XLogReaderState *state)
bool	WALRead (XLogReaderState *state, char *buf, XLogRecPtr startptr, Size count, TimeLineID tli, WALReadError *errinfo)
size_t	DecodeXLogRecordRequiredSpace (size_t xl_tot_len)
bool	DecodeXLogRecord (XLogReaderState *state, DecodedXLogRecord *decoded, XLogRecord *record, XLogRecPtr lsn, char **errormsg)
FullTransactionId	XLogRecGetFullXid (XLogReaderState *record)
bool	RestoreBlockImage (XLogReaderState *record, uint8 block_id, char *page)
char *	XLogRecGetBlockData (XLogReaderState *record, uint8 block_id, Size *len)
void	XLogRecGetBlockTag (XLogReaderState *record, uint8 block_id, RelFileLocator *rlocator, ForkNumber *forknum, BlockNumber *blknum)
bool	XLogRecGetBlockTagExtended (XLogReaderState *record, uint8 block_id, RelFileLocator *rlocator, ForkNumber *forknum, BlockNumber *blknum, Buffer *prefetch_buffer)

Macro Definition Documentation

XL_ROUTINE

#define XL_ROUTINE

(

...

)

&(XLogReaderRoutine){__VA_ARGS__}

Definition at line 117 of file xlogreader.h.

XLogRecBlockImageApply

#define XLogRecBlockImageApply	(		decoder,
			block_id
	)		((decoder)->record->blocks[block_id].apply_image)

Definition at line 424 of file xlogreader.h.

XLogRecGetBlock

#define XLogRecGetBlock	(		decoder,
			i
	)		(&(decoder)->record->blocks[(i)])

Definition at line 418 of file xlogreader.h.

XLogRecGetData

#define XLogRecGetData

(

decoder

)

((decoder)->record->main_data)

Definition at line 414 of file xlogreader.h.

XLogRecGetDataLen

#define XLogRecGetDataLen

(

decoder

)

((decoder)->record->main_data_len)

Definition at line 415 of file xlogreader.h.

XLogRecGetInfo

#define XLogRecGetInfo

(

decoder

)

((decoder)->record->header.xl_info)

Definition at line 409 of file xlogreader.h.

XLogRecGetOrigin

#define XLogRecGetOrigin

(

decoder

)

((decoder)->record->record_origin)

Definition at line 412 of file xlogreader.h.

XLogRecGetPrev

#define XLogRecGetPrev

(

decoder

)

((decoder)->record->header.xl_prev)

Definition at line 408 of file xlogreader.h.

XLogRecGetRmid

#define XLogRecGetRmid

(

decoder

)

((decoder)->record->header.xl_rmid)

Definition at line 410 of file xlogreader.h.

XLogRecGetTopXid

#define XLogRecGetTopXid

(

decoder

)

((decoder)->record->toplevel_xid)

Definition at line 413 of file xlogreader.h.

XLogRecGetTotalLen

#define XLogRecGetTotalLen

(

decoder

)

((decoder)->record->header.xl_tot_len)

Definition at line 407 of file xlogreader.h.

XLogRecGetXid

#define XLogRecGetXid

(

decoder

)

((decoder)->record->header.xl_xid)

Definition at line 411 of file xlogreader.h.

XLogRecHasAnyBlockRefs

#define XLogRecHasAnyBlockRefs

(

decoder

)

((decoder)->record->max_block_id >= 0)

Definition at line 416 of file xlogreader.h.

XLogRecHasBlockData

#define XLogRecHasBlockData	(		decoder,
			block_id
	)		((decoder)->record->blocks[block_id].has_data)

Definition at line 426 of file xlogreader.h.

XLogRecHasBlockImage

#define XLogRecHasBlockImage	(		decoder,
			block_id
	)		((decoder)->record->blocks[block_id].has_image)

Definition at line 422 of file xlogreader.h.

XLogRecHasBlockRef

#define XLogRecHasBlockRef	(		decoder,
			block_id
	)

Value:

    (((decoder)->record->max_block_id >= (block_id)) && \
     ((decoder)->record->blocks[block_id].in_use))

Definition at line 419 of file xlogreader.h.

XLogRecMaxBlockId

#define XLogRecMaxBlockId

(

decoder

)

((decoder)->record->max_block_id)

Definition at line 417 of file xlogreader.h.

Typedef Documentation

DecodedXLogRecord

typedef struct DecodedXLogRecord DecodedXLogRecord

WALOpenSegment

typedef struct WALOpenSegment WALOpenSegment

WALReadError

typedef struct WALReadError WALReadError

WALSegmentCloseCB

typedef void(* WALSegmentCloseCB) (XLogReaderState *xlogreader)

Definition at line 70 of file xlogreader.h.

WALSegmentContext

typedef struct WALSegmentContext WALSegmentContext

WALSegmentOpenCB

typedef void(* WALSegmentOpenCB) (XLogReaderState *xlogreader, XLogSegNo nextSegNo, TimeLineID *tli_p)

Definition at line 67 of file xlogreader.h.

XLogPageReadCB

typedef int(* XLogPageReadCB) (XLogReaderState *xlogreader, XLogRecPtr targetPagePtr, int reqLen, XLogRecPtr targetRecPtr, char *readBuf)

Definition at line 62 of file xlogreader.h.

XLogPageReadResult

typedef enum XLogPageReadResult XLogPageReadResult

XLogReaderRoutine

typedef struct XLogReaderRoutine XLogReaderRoutine

XLogReaderState

typedef struct XLogReaderState XLogReaderState

Definition at line 59 of file xlogreader.h.

Enumeration Type Documentation

XLogPageReadResult

enum XLogPageReadResult

Enumerator
XLREAD_SUCCESS
XLREAD_FAIL
XLREAD_WOULDBLOCK

Definition at line 348 of file xlogreader.h.

{
    XLREAD_SUCCESS = 0,         /* record is successfully read */
    XLREAD_FAIL = -1,           /* failed during reading a record */
    XLREAD_WOULDBLOCK = -2,     /* nonblocking mode only, no data */
} XLogPageReadResult;

Function Documentation

DecodeXLogRecord()

bool DecodeXLogRecord ( XLogReaderState *  state, DecodedXLogRecord *  decoded, XLogRecord *  record, XLogRecPtr  lsn, char **  errormsg  )

extern

Definition at line 1683 of file xlogreader.c.

{
    /*
     * 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;
    char       *out;
    uint32      remaining;
    uint32      datatotal;
    RelFileLocator *rlocator = NULL;
    uint8       block_id;
 
    decoded->header = *record;
    decoded->lsn = lsn;
    decoded->next = NULL;
    decoded->record_origin = InvalidReplOriginId;
    decoded->toplevel_xid = InvalidTransactionId;
    decoded->main_data = NULL;
    decoded->main_data_len = 0;
    decoded->max_block_id = -1;
    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));
 
            decoded->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));
            decoded->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(&decoded->record_origin, sizeof(ReplOriginId));
        }
        else if (block_id == XLR_BLOCK_ID_TOPLEVEL_XID)
        {
            COPY_HEADER_FIELD(&decoded->toplevel_xid, sizeof(TransactionId));
        }
        else if (block_id <= XLR_MAX_BLOCK_ID)
        {
            /* XLogRecordBlockHeader */
            DecodedBkpBlock *blk;
            uint8       fork_flags;
 
            /* mark any intervening block IDs as not in use */
            for (int i = decoded->max_block_id + 1; i < block_id; ++i)
                decoded->blocks[i].in_use = false;
 
            if (block_id <= decoded->max_block_id)
            {
                report_invalid_record(state,
                                      "out-of-order block_id %u at %X/%08X",
                                      block_id,
                                      LSN_FORMAT_ARGS(state->ReadRecPtr));
                goto err;
            }
            decoded->max_block_id = block_id;
 
            blk = &decoded->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);
 
            blk->prefetch_buffer = InvalidBuffer;
 
            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/%08X",
                                      LSN_FORMAT_ARGS(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 %d at %X/%08X",
                                      blk->data_len,
                                      LSN_FORMAT_ARGS(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 (BKPIMAGE_COMPRESSED(blk->bimg_info))
                {
                    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 %d length %d block image length %d at %X/%08X",
                                          blk->hole_offset,
                                          blk->hole_length,
                                          blk->bimg_len,
                                          LSN_FORMAT_ARGS(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 %d length %d at %X/%08X",
                                          blk->hole_offset,
                                          blk->hole_length,
                                          LSN_FORMAT_ARGS(state->ReadRecPtr));
                    goto err;
                }
 
                /*
                 * Cross-check that bimg_len < BLCKSZ if it is compressed.
                 */
                if (BKPIMAGE_COMPRESSED(blk->bimg_info) &&
                    blk->bimg_len == BLCKSZ)
                {
                    report_invalid_record(state,
                                          "BKPIMAGE_COMPRESSED set, but block image length %d at %X/%08X",
                                          blk->bimg_len,
                                          LSN_FORMAT_ARGS(state->ReadRecPtr));
                    goto err;
                }
 
                /*
                 * cross-check that bimg_len = BLCKSZ if neither HAS_HOLE is
                 * set nor COMPRESSED().
                 */
                if (!(blk->bimg_info & BKPIMAGE_HAS_HOLE) &&
                    !BKPIMAGE_COMPRESSED(blk->bimg_info) &&
                    blk->bimg_len != BLCKSZ)
                {
                    report_invalid_record(state,
                                          "neither BKPIMAGE_HAS_HOLE nor BKPIMAGE_COMPRESSED set, but block image length is %d at %X/%08X",
                                          blk->data_len,
                                          LSN_FORMAT_ARGS(state->ReadRecPtr));
                    goto err;
                }
            }
            if (!(fork_flags & BKPBLOCK_SAME_REL))
            {
                COPY_HEADER_FIELD(&blk->rlocator, sizeof(RelFileLocator));
                rlocator = &blk->rlocator;
            }
            else
            {
                if (rlocator == NULL)
                {
                    report_invalid_record(state,
                                          "BKPBLOCK_SAME_REL set but no previous rel at %X/%08X",
                                          LSN_FORMAT_ARGS(state->ReadRecPtr));
                    goto err;
                }
 
                blk->rlocator = *rlocator;
            }
            COPY_HEADER_FIELD(&blk->blkno, sizeof(BlockNumber));
        }
        else
        {
            report_invalid_record(state,
                                  "invalid block_id %u at %X/%08X",
                                  block_id, LSN_FORMAT_ARGS(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 contiguous space after the
     * blocks array, inserting alignment padding before the data fragments so
     * they can be cast to struct pointers by REDO routines.
     */
    out = ((char *) decoded) +
        offsetof(DecodedXLogRecord, blocks) +
        sizeof(decoded->blocks[0]) * (decoded->max_block_id + 1);
 
    /* block data first */
    for (block_id = 0; block_id <= decoded->max_block_id; block_id++)
    {
        DecodedBkpBlock *blk = &decoded->blocks[block_id];
 
        if (!blk->in_use)
            continue;
 
        Assert(blk->has_image || !blk->apply_image);
 
        if (blk->has_image)
        {
            /* no need to align image */
            blk->bkp_image = out;
            memcpy(out, ptr, blk->bimg_len);
            ptr += blk->bimg_len;
            out += blk->bimg_len;
        }
        if (blk->has_data)
        {
            out = (char *) MAXALIGN(out);
            blk->data = out;
            memcpy(blk->data, ptr, blk->data_len);
            ptr += blk->data_len;
            out += blk->data_len;
        }
    }
 
    /* and finally, the main data */
    if (decoded->main_data_len > 0)
    {
        out = (char *) MAXALIGN(out);
        decoded->main_data = out;
        memcpy(decoded->main_data, ptr, decoded->main_data_len);
        ptr += decoded->main_data_len;
        out += decoded->main_data_len;
    }
 
    /* Report the actual size we used. */
    decoded->size = MAXALIGN(out - (char *) decoded);
    Assert(DecodeXLogRecordRequiredSpace(record->xl_tot_len) >=
           decoded->size);
 
    return true;
 
shortdata_err:
    report_invalid_record(state,
                          "record with invalid length at %X/%08X",
                          LSN_FORMAT_ARGS(state->ReadRecPtr));
err:
    *errormsg = state->errormsg_buf;
 
    return false;
}

References Assert, BKPBLOCK_FORK_MASK, BKPBLOCK_HAS_DATA, BKPBLOCK_HAS_IMAGE, BKPBLOCK_SAME_REL, BKPIMAGE_APPLY, BKPIMAGE_COMPRESSED, BKPIMAGE_HAS_HOLE, COPY_HEADER_FIELD, DecodeXLogRecordRequiredSpace(), err(), fb(), i, DecodedBkpBlock::in_use, InvalidBuffer, InvalidReplOriginId, InvalidTransactionId, LSN_FORMAT_ARGS, MAXALIGN, remaining, report_invalid_record(), SizeOfXLogRecord, XLogRecord::xl_tot_len, XLR_BLOCK_ID_DATA_LONG, XLR_BLOCK_ID_DATA_SHORT, XLR_BLOCK_ID_ORIGIN, XLR_BLOCK_ID_TOPLEVEL_XID, and XLR_MAX_BLOCK_ID.

Referenced by XLogDecodeNextRecord(), and XLogInsertRecord().

DecodeXLogRecordRequiredSpace()

size_t DecodeXLogRecordRequiredSpace ( size_t  xl_tot_len )

extern

Definition at line 1650 of file xlogreader.c.

{
    size_t      size = 0;
 
    /* Account for the fixed size part of the decoded record struct. */
    size += offsetof(DecodedXLogRecord, blocks[0]);
    /* Account for the flexible blocks array of maximum possible size. */
    size += sizeof(DecodedBkpBlock) * (XLR_MAX_BLOCK_ID + 1);
    /* Account for all the raw main and block data. */
    size += xl_tot_len;
    /* We might insert padding before main_data. */
    size += (MAXIMUM_ALIGNOF - 1);
    /* We might insert padding before each block's data. */
    size += (MAXIMUM_ALIGNOF - 1) * (XLR_MAX_BLOCK_ID + 1);
    /* We might insert padding at the end. */
    size += (MAXIMUM_ALIGNOF - 1);
 
    return size;
}

References fb(), and XLR_MAX_BLOCK_ID.

Referenced by DecodeXLogRecord(), InitXLogInsert(), XLogInsertRecord(), and XLogReadRecordAlloc().

RestoreBlockImage()

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

extern

Definition at line 2077 of file xlogreader.c.

{
    DecodedBkpBlock *bkpb;
    char       *ptr;
    PGAlignedBlock tmp;
 
    if (block_id > record->record->max_block_id ||
        !record->record->blocks[block_id].in_use)
    {
        report_invalid_record(record,
                              "could not restore image at %X/%08X with invalid block %d specified",
                              LSN_FORMAT_ARGS(record->ReadRecPtr),
                              block_id);
        return false;
    }
    if (!record->record->blocks[block_id].has_image)
    {
        report_invalid_record(record, "could not restore image at %X/%08X with invalid state, block %d",
                              LSN_FORMAT_ARGS(record->ReadRecPtr),
                              block_id);
        return false;
    }
 
    bkpb = &record->record->blocks[block_id];
    ptr = bkpb->bkp_image;
 
    if (BKPIMAGE_COMPRESSED(bkpb->bimg_info))
    {
        /* If a backup block image is compressed, decompress it */
        bool        decomp_success = true;
 
        if ((bkpb->bimg_info & BKPIMAGE_COMPRESS_PGLZ) != 0)
        {
            if (pglz_decompress(ptr, bkpb->bimg_len, tmp.data,
                                BLCKSZ - bkpb->hole_length, true) < 0)
                decomp_success = false;
        }
        else if ((bkpb->bimg_info & BKPIMAGE_COMPRESS_LZ4) != 0)
        {
#ifdef USE_LZ4
            if (LZ4_decompress_safe(ptr, tmp.data,
                                    bkpb->bimg_len, BLCKSZ - bkpb->hole_length) <= 0)
                decomp_success = false;
#else
            report_invalid_record(record, "could not restore image at %X/%08X compressed with %s not supported by build, block %d",
                                  LSN_FORMAT_ARGS(record->ReadRecPtr),
                                  "LZ4",
                                  block_id);
            return false;
#endif
        }
        else if ((bkpb->bimg_info & BKPIMAGE_COMPRESS_ZSTD) != 0)
        {
#ifdef USE_ZSTD
            size_t      decomp_result = ZSTD_decompress(tmp.data,
                                                        BLCKSZ - bkpb->hole_length,
                                                        ptr, bkpb->bimg_len);
 
            if (ZSTD_isError(decomp_result))
                decomp_success = false;
#else
            report_invalid_record(record, "could not restore image at %X/%08X compressed with %s not supported by build, block %d",
                                  LSN_FORMAT_ARGS(record->ReadRecPtr),
                                  "zstd",
                                  block_id);
            return false;
#endif
        }
        else
        {
            report_invalid_record(record, "could not restore image at %X/%08X compressed with unknown method, block %d",
                                  LSN_FORMAT_ARGS(record->ReadRecPtr),
                                  block_id);
            return false;
        }
 
        if (!decomp_success)
        {
            report_invalid_record(record, "could not decompress image at %X/%08X, block %d",
                                  LSN_FORMAT_ARGS(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;
}

References DecodedBkpBlock::bkp_image, BKPIMAGE_COMPRESS_LZ4, BKPIMAGE_COMPRESS_PGLZ, BKPIMAGE_COMPRESS_ZSTD, BKPIMAGE_COMPRESSED, DecodedXLogRecord::blocks, PGAlignedBlock::data, fb(), DecodedBkpBlock::has_image, DecodedBkpBlock::in_use, LSN_FORMAT_ARGS, DecodedXLogRecord::max_block_id, MemSet, pglz_decompress(), XLogReaderState::ReadRecPtr, XLogReaderState::record, and report_invalid_record().

Referenced by GetWALBlockInfo(), verifyBackupPageConsistency(), XLogReadBufferForRedoExtended(), and XLogRecordSaveFPWs().

WALRead()

bool WALRead ( XLogReaderState *  state, char *  buf, XLogRecPtr  startptr, Size  count, TimeLineID  tli, WALReadError *  errinfo  )

extern

Definition at line 1515 of file xlogreader.c.

{
    char       *p;
    XLogRecPtr  recptr;
    Size        nbytes;
#ifndef FRONTEND
    instr_time  io_start;
#endif
 
    p = buf;
    recptr = startptr;
    nbytes = count;
 
    while (nbytes > 0)
    {
        uint32      startoff;
        int         segbytes;
        int         readbytes;
 
        startoff = XLogSegmentOffset(recptr, state->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 segment_open callback.
         */
        if (state->seg.ws_file < 0 ||
            !XLByteInSeg(recptr, state->seg.ws_segno, state->segcxt.ws_segsize) ||
            tli != state->seg.ws_tli)
        {
            XLogSegNo   nextSegNo;
 
            if (state->seg.ws_file >= 0)
                state->routine.segment_close(state);
 
            XLByteToSeg(recptr, nextSegNo, state->segcxt.ws_segsize);
            state->routine.segment_open(state, nextSegNo, &tli);
 
            /* This shouldn't happen -- indicates a bug in segment_open */
            Assert(state->seg.ws_file >= 0);
 
            /* Update the current segment info. */
            state->seg.ws_tli = tli;
            state->seg.ws_segno = nextSegNo;
        }
 
        /* How many bytes are within this segment? */
        if (nbytes > (state->segcxt.ws_segsize - startoff))
            segbytes = state->segcxt.ws_segsize - startoff;
        else
            segbytes = nbytes;
 
#ifndef FRONTEND
        /* Measure I/O timing when reading segment */
        io_start = pgstat_prepare_io_time(track_wal_io_timing);
 
        pgstat_report_wait_start(WAIT_EVENT_WAL_READ);
#endif
 
        /* Reset errno first; eases reporting non-errno-affecting errors */
        errno = 0;
        readbytes = pg_pread(state->seg.ws_file, p, segbytes, (pgoff_t) startoff);
 
#ifndef FRONTEND
        pgstat_report_wait_end();
 
        pgstat_count_io_op_time(IOOBJECT_WAL, IOCONTEXT_NORMAL, IOOP_READ,
                                io_start, 1, readbytes);
#endif
 
        if (readbytes <= 0)
        {
            errinfo->wre_errno = errno;
            errinfo->wre_req = segbytes;
            errinfo->wre_read = readbytes;
            errinfo->wre_off = startoff;
            errinfo->wre_seg = state->seg;
            return false;
        }
 
        /* Update state for read */
        recptr += readbytes;
        nbytes -= readbytes;
        p += readbytes;
    }
 
    return true;
}

References Assert, buf, fb(), IOCONTEXT_NORMAL, IOOBJECT_WAL, IOOP_READ, pg_pread, pgstat_count_io_op_time(), pgstat_prepare_io_time(), pgstat_report_wait_end(), pgstat_report_wait_start(), track_wal_io_timing, XLByteInSeg, XLByteToSeg, and XLogSegmentOffset.

Referenced by logical_read_xlog_page(), read_local_xlog_page_guts(), summarizer_read_local_xlog_page(), WALDumpReadPage(), and XLogSendPhysical().

XLogBeginRead()

void XLogBeginRead ( XLogReaderState *  state, XLogRecPtr  RecPtr  )

extern

Definition at line 233 of file xlogreader.c.

{
    Assert(XLogRecPtrIsValid(RecPtr));
 
    ResetDecoder(state);
 
    /* Begin at the passed-in record pointer. */
    state->EndRecPtr = RecPtr;
    state->NextRecPtr = RecPtr;
    state->ReadRecPtr = InvalidXLogRecPtr;
    state->DecodeRecPtr = InvalidXLogRecPtr;
}

References Assert, fb(), InvalidXLogRecPtr, ResetDecoder(), and XLogRecPtrIsValid.

Referenced by DecodingContextFindStartpoint(), extractPageMap(), findLastCheckpoint(), LogicalReplicationSlotCheckPendingWal(), LogicalSlotAdvanceAndCheckSnapState(), pg_logical_slot_get_changes_guts(), readOneRecord(), StartLogicalReplication(), SummarizeWAL(), XLogFindNextRecord(), XLogPrefetcherBeginRead(), and XlogReadTwoPhaseData().

XLogFindNextRecord()

XLogRecPtr XLogFindNextRecord ( XLogReaderState *  state, XLogRecPtr  RecPtr  )

extern

Definition at line 1395 of file xlogreader.c.

{
    XLogRecPtr  tmpRecPtr;
    XLogRecPtr  found = InvalidXLogRecPtr;
    XLogPageHeader header;
    char       *errormsg;
 
    Assert(XLogRecPtrIsValid(RecPtr));
 
    /* Make sure ReadPageInternal() can't return XLREAD_WOULDBLOCK. */
    state->nonblocking = false;
 
    /*
     * skip over potential continuation data, keeping in mind that it may span
     * multiple pages
     */
    tmpRecPtr = RecPtr;
    while (true)
    {
        XLogRecPtr  targetPagePtr;
        int         targetRecOff;
        uint32      pageHeaderSize;
        int         readLen;
 
        /*
         * Compute targetRecOff. It should typically be equal or greater than
         * short page-header since a valid record can't start anywhere before
         * that, except when caller has explicitly specified the offset that
         * falls somewhere there or when we are skipping multi-page
         * continuation record. It doesn't matter though because
         * ReadPageInternal() is prepared to handle that and will read at
         * least short page-header worth of data
         */
        targetRecOff = tmpRecPtr % XLOG_BLCKSZ;
 
        /* scroll back to page boundary */
        targetPagePtr = tmpRecPtr - targetRecOff;
 
        /* Read the page containing the record */
        readLen = ReadPageInternal(state, targetPagePtr, targetRecOff);
        if (readLen < 0)
            goto err;
 
        header = (XLogPageHeader) state->readBuf;
 
        pageHeaderSize = XLogPageHeaderSize(header);
 
        /* make sure we have enough data for the page header */
        readLen = ReadPageInternal(state, targetPagePtr, pageHeaderSize);
        if (readLen < 0)
            goto err;
 
        /* skip over potential continuation data */
        if (header->xlp_info & XLP_FIRST_IS_CONTRECORD)
        {
            /*
             * If the length of the remaining continuation data is more than
             * what can fit in this page, the continuation record crosses over
             * this page. Read the next page and try again. xlp_rem_len in the
             * next page header will contain the remaining length of the
             * continuation data
             *
             * Note that record headers are MAXALIGN'ed
             */
            if (MAXALIGN(header->xlp_rem_len) >= (XLOG_BLCKSZ - pageHeaderSize))
                tmpRecPtr = targetPagePtr + XLOG_BLCKSZ;
            else
            {
                /*
                 * The previous continuation record ends in this page. Set
                 * tmpRecPtr to point to the first valid record
                 */
                tmpRecPtr = targetPagePtr + pageHeaderSize
                    + MAXALIGN(header->xlp_rem_len);
                break;
            }
        }
        else
        {
            tmpRecPtr = targetPagePtr + pageHeaderSize;
            break;
        }
    }
 
    /*
     * we know now that tmpRecPtr is an address pointing to a valid XLogRecord
     * because either we're at the first record after the beginning of a page
     * or we just jumped over the remaining data of a continuation.
     */
    XLogBeginRead(state, tmpRecPtr);
    while (XLogReadRecord(state, &errormsg) != NULL)
    {
        /* past the record we've found, break out */
        if (RecPtr <= state->ReadRecPtr)
        {
            /* Rewind the reader to the beginning of the last record. */
            found = state->ReadRecPtr;
            XLogBeginRead(state, found);
            return found;
        }
    }
 
err:
    XLogReaderInvalReadState(state);
 
    return InvalidXLogRecPtr;
}

References Assert, err(), fb(), InvalidXLogRecPtr, MAXALIGN, readLen, ReadPageInternal(), XLogBeginRead(), XLogPageHeaderSize, XLogReaderInvalReadState(), XLogReadRecord(), XLogRecPtrIsValid, XLP_FIRST_IS_CONTRECORD, XLogPageHeaderData::xlp_info, and XLogPageHeaderData::xlp_rem_len.

Referenced by InitXLogReaderState(), main(), and SummarizeWAL().

XLogNextRecord()

DecodedXLogRecord * XLogNextRecord ( XLogReaderState *  state, char **  errormsg  )

extern

Definition at line 327 of file xlogreader.c.

{
    /* Release the last record returned by XLogNextRecord(). */
    XLogReleasePreviousRecord(state);
 
    if (state->decode_queue_head == NULL)
    {
        *errormsg = NULL;
        if (state->errormsg_deferred)
        {
            if (state->errormsg_buf[0] != '\0')
                *errormsg = state->errormsg_buf;
            state->errormsg_deferred = false;
        }
 
        /*
         * state->EndRecPtr is expected to have been set by the last call to
         * XLogBeginRead() or XLogNextRecord(), and is the location of the
         * error.
         */
        Assert(XLogRecPtrIsValid(state->EndRecPtr));
 
        return NULL;
    }
 
    /*
     * Record this as the most recent record returned, so that we'll release
     * it next time.  This also exposes it to the traditional
     * XLogRecXXX(xlogreader) macros, which work with the decoder rather than
     * the record for historical reasons.
     */
    state->record = state->decode_queue_head;
 
    /*
     * Update the pointers to the beginning and one-past-the-end of this
     * record, again for the benefit of historical code that expected the
     * decoder to track this rather than accessing these fields of the record
     * itself.
     */
    state->ReadRecPtr = state->record->lsn;
    state->EndRecPtr = state->record->next_lsn;
 
    *errormsg = NULL;
 
    return state->record;
}

References Assert, fb(), XLogRecPtrIsValid, and XLogReleasePreviousRecord().

Referenced by XLogPrefetcherReadRecord(), and XLogReadRecord().

XLogReadAhead()

DecodedXLogRecord * XLogReadAhead ( XLogReaderState *  state, bool  nonblocking  )

extern

Definition at line 978 of file xlogreader.c.

{
    XLogPageReadResult result;
 
    if (state->errormsg_deferred)
        return NULL;
 
    result = XLogDecodeNextRecord(state, nonblocking);
    if (result == XLREAD_SUCCESS)
    {
        Assert(state->decode_queue_tail != NULL);
        return state->decode_queue_tail;
    }
 
    return NULL;
}

References Assert, fb(), XLogDecodeNextRecord(), and XLREAD_SUCCESS.

Referenced by XLogPrefetcherNextBlock(), and XLogReadRecord().

XLogReaderAllocate()

XLogReaderState * XLogReaderAllocate ( int  wal_segment_size, const char *  waldir, XLogReaderRoutine *  routine, void *  private_data  )

extern

Definition at line 108 of file xlogreader.c.

{
    XLogReaderState *state;
 
    state = (XLogReaderState *)
        palloc_extended(sizeof(XLogReaderState),
                        MCXT_ALLOC_NO_OOM | MCXT_ALLOC_ZERO);
    if (!state)
        return NULL;
 
    /* initialize caller-provided support functions */
    state->routine = *routine;
 
    /*
     * 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);
 
    /* 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.
     */
    allocate_recordbuf(state, 0);
    return state;
}

References allocate_recordbuf(), fb(), MAX_ERRORMSG_LEN, MCXT_ALLOC_NO_OOM, MCXT_ALLOC_ZERO, palloc_extended(), pfree(), wal_segment_size, and WALOpenSegmentInit().

Referenced by extractPageMap(), findLastCheckpoint(), InitWalRecovery(), InitXLogReaderState(), main(), readOneRecord(), StartReplication(), StartupDecodingContext(), SummarizeWAL(), XLogInsertRecord(), and XlogReadTwoPhaseData().

XLogReaderFree()

void XLogReaderFree ( XLogReaderState *  state )

extern

Definition at line 163 of file xlogreader.c.

{
    if (state->seg.ws_file != -1)
        state->routine.segment_close(state);
 
    if (state->decode_buffer && state->free_decode_buffer)
        pfree(state->decode_buffer);
 
    pfree(state->errormsg_buf);
    if (state->readRecordBuf)
        pfree(state->readRecordBuf);
    pfree(state->readBuf);
    pfree(state);
}

References pfree().

Referenced by extractPageMap(), findLastCheckpoint(), FreeDecodingContext(), GetWALRecordsInfo(), GetWalStats(), main(), pg_get_wal_block_info(), pg_get_wal_record_info(), readOneRecord(), ShutdownWalRecovery(), SummarizeWAL(), and XlogReadTwoPhaseData().

XLogReaderHasQueuedRecordOrError()

static bool XLogReaderHasQueuedRecordOrError ( XLogReaderState *  state )

inlinestatic

Definition at line 324 of file xlogreader.h.

{
    return (state->decode_queue_head != NULL) || state->errormsg_deferred;
}

References fb().

Referenced by XLogPrefetcherNextBlock(), XLogPrefetcherReadRecord(), and XLogReadRecord().

XLogReaderResetError()

void XLogReaderResetError ( XLogReaderState *  state )

extern

Definition at line 1377 of file xlogreader.c.

{
    state->errormsg_buf[0] = '\0';
    state->errormsg_deferred = false;
}

Referenced by XLogPageRead().

XLogReaderSetDecodeBuffer()

void XLogReaderSetDecodeBuffer ( XLogReaderState *  state, void *  buffer, size_t  size  )

extern

Definition at line 92 of file xlogreader.c.

{
    Assert(state->decode_buffer == NULL);
 
    state->decode_buffer = buffer;
    state->decode_buffer_size = size;
    state->decode_buffer_tail = buffer;
    state->decode_buffer_head = buffer;
}

References Assert, and fb().

Referenced by InitWalRecovery().

XLogReaderValidatePageHeader()

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

extern

Definition at line 1236 of file xlogreader.c.

{
    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);
 
    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 WAL segment %s, LSN %X/%08X, offset %u",
                              hdr->xlp_magic,
                              fname,
                              LSN_FORMAT_ARGS(recptr),
                              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 WAL segment %s, LSN %X/%08X, offset %u",
                              hdr->xlp_info,
                              fname,
                              LSN_FORMAT_ARGS(recptr),
                              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 %" PRIu64 ", pg_control database system identifier is %" PRIu64,
                                  longhdr->xlp_sysid,
                                  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 WAL segment %s, LSN %X/%08X, offset %u",
                              hdr->xlp_info,
                              fname,
                              LSN_FORMAT_ARGS(recptr),
                              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 != recptr)
    {
        char        fname[MAXFNAMELEN];
 
        XLogFileName(fname, state->seg.ws_tli, segno, state->segcxt.ws_segsize);
 
        report_invalid_record(state,
                              "unexpected pageaddr %X/%08X in WAL segment %s, LSN %X/%08X, offset %u",
                              LSN_FORMAT_ARGS(hdr->xlp_pageaddr),
                              fname,
                              LSN_FORMAT_ARGS(recptr),
                              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 WAL segment %s, LSN %X/%08X, offset %u",
                                  hdr->xlp_tli,
                                  state->latestPageTLI,
                                  fname,
                                  LSN_FORMAT_ARGS(recptr),
                                  offset);
            return false;
        }
    }
    state->latestPagePtr = recptr;
    state->latestPageTLI = hdr->xlp_tli;
 
    return true;
}

References Assert, fb(), LSN_FORMAT_ARGS, MAXFNAMELEN, report_invalid_record(), XLByteToSeg, XLOG_PAGE_MAGIC, XLogFileName(), XLogSegmentOffset, XLP_ALL_FLAGS, XLogPageHeaderData::xlp_info, XLP_LONG_HEADER, XLogPageHeaderData::xlp_magic, XLogPageHeaderData::xlp_pageaddr, and XLogPageHeaderData::xlp_tli.

Referenced by ReadPageInternal(), and XLogPageRead().

XLogReadRecord()

struct XLogRecord * XLogReadRecord ( XLogReaderState *  state, char **  errormsg  )

extern

Definition at line 391 of file xlogreader.c.

{
    DecodedXLogRecord *decoded;
 
    /*
     * Release last returned record, if there is one.  We need to do this so
     * that we can check for empty decode queue accurately.
     */
    XLogReleasePreviousRecord(state);
 
    /*
     * Call XLogReadAhead() in blocking mode to make sure there is something
     * in the queue, though we don't use the result.
     */
    if (!XLogReaderHasQueuedRecordOrError(state))
        XLogReadAhead(state, false /* nonblocking */ );
 
    /* Consume the head record or error. */
    decoded = XLogNextRecord(state, errormsg);
    if (decoded)
    {
        /*
         * This function returns a pointer to the record's header, not the
         * actual decoded record.  The caller will access the decoded record
         * through the XLogRecGetXXX() macros, which reach the decoded
         * recorded as xlogreader->record.
         */
        Assert(state->record == decoded);
        return &decoded->header;
    }
 
    return NULL;
}

References Assert, fb(), XLogNextRecord(), XLogReadAhead(), XLogReaderHasQueuedRecordOrError(), and XLogReleasePreviousRecord().

Referenced by DecodingContextFindStartpoint(), extractPageMap(), findLastCheckpoint(), LogicalReplicationSlotCheckPendingWal(), LogicalSlotAdvanceAndCheckSnapState(), main(), pg_logical_slot_get_changes_guts(), ReadNextXLogRecord(), readOneRecord(), SummarizeWAL(), XLogFindNextRecord(), XlogReadTwoPhaseData(), and XLogSendLogical().

XLogRecGetBlockData()

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

extern

Definition at line 2046 of file xlogreader.c.

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

References DecodedXLogRecord::blocks, DecodedBkpBlock::data_len, fb(), DecodedBkpBlock::in_use, len, DecodedXLogRecord::max_block_id, and XLogReaderState::record.

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(), heap2_desc(), heap_xlog_inplace(), heap_xlog_insert(), heap_xlog_multi_insert(), heap_xlog_prune_freeze(), and heap_xlog_update().

XLogRecGetBlockTag()

void XLogRecGetBlockTag ( XLogReaderState *  record, uint8  block_id, RelFileLocator *  rlocator, ForkNumber *  forknum, BlockNumber *  blknum  )

extern

Definition at line 1992 of file xlogreader.c.

{
    if (!XLogRecGetBlockTagExtended(record, block_id, rlocator, forknum,
                                    blknum, NULL))
    {
#ifndef FRONTEND
        elog(ERROR, "could not locate backup block with ID %d in WAL record",
             block_id);
#else
        pg_fatal("could not locate backup block with ID %d in WAL record",
                 block_id);
#endif
    }
}

References elog, ERROR, fb(), pg_fatal, and XLogRecGetBlockTagExtended().

Referenced by brin_xlog_revmap_extend(), btree_xlog_delete(), btree_xlog_split(), DecodeDelete(), DecodeInsert(), DecodeMultiInsert(), DecodeSpecConfirm(), DecodeUpdate(), gistRedoDeleteRecord(), gistRedoPageSplitRecord(), hash_xlog_add_ovfl_page(), hash_xlog_init_bitmap_page(), hash_xlog_init_meta_page(), hash_xlog_vacuum_one_page(), heap_xlog_delete(), heap_xlog_insert(), heap_xlog_lock(), heap_xlog_lock_updated(), heap_xlog_multi_insert(), heap_xlog_prune_freeze(), heap_xlog_update(), heap_xlog_visible(), spgRedoAddLeaf(), spgRedoAddNode(), spgRedoMoveLeafs(), spgRedoPickSplit(), and spgRedoVacuumRedirect().

XLogRecGetBlockTagExtended()

bool XLogRecGetBlockTagExtended ( XLogReaderState *  record, uint8  block_id, RelFileLocator *  rlocator, ForkNumber *  forknum, BlockNumber *  blknum, Buffer *  prefetch_buffer  )

extern

Definition at line 2018 of file xlogreader.c.

{
    DecodedBkpBlock *bkpb;
 
    if (!XLogRecHasBlockRef(record, block_id))
        return false;
 
    bkpb = &record->record->blocks[block_id];
    if (rlocator)
        *rlocator = bkpb->rlocator;
    if (forknum)
        *forknum = bkpb->forknum;
    if (blknum)
        *blknum = bkpb->blkno;
    if (prefetch_buffer)
        *prefetch_buffer = bkpb->prefetch_buffer;
    return true;
}

References DecodedXLogRecord::blocks, fb(), XLogReaderState::record, and XLogRecHasBlockRef.

Referenced by btree_xlog_split(), extractPageInfo(), GetWALBlockInfo(), heap_xlog_update(), SummarizeWAL(), verifyBackupPageConsistency(), xlog_block_info(), XLogReadBufferForRedoExtended(), XLogRecGetBlockRefInfo(), XLogRecGetBlockTag(), XLogRecordMatchesRelationBlock(), and XLogRecordSaveFPWs().

XLogRecGetFullXid()

FullTransactionId XLogRecGetFullXid ( XLogReaderState *  record )

extern

Definition at line 2188 of file xlogreader.c.

{
    /*
     * This function is only safe during replay, because it depends on the
     * replay state.  See AdvanceNextFullTransactionIdPastXid() for more.
     */
    Assert(AmStartupProcess() || !IsUnderPostmaster);
 
    return FullTransactionIdFromAllowableAt(TransamVariables->nextXid,
                                            XLogRecGetXid(record));
}

References AmStartupProcess, Assert, FullTransactionIdFromAllowableAt(), IsUnderPostmaster, TransamVariablesData::nextXid, TransamVariables, and XLogRecGetXid.

XLogReleasePreviousRecord()

XLogRecPtr XLogReleasePreviousRecord ( XLogReaderState *  state )

extern

Definition at line 251 of file xlogreader.c.

{
    DecodedXLogRecord *record;
    XLogRecPtr  next_lsn;
 
    if (!state->record)
        return InvalidXLogRecPtr;
 
    /*
     * Remove it from the decoded record queue.  It must be the oldest item
     * decoded, decode_queue_head.
     */
    record = state->record;
    next_lsn = record->next_lsn;
    Assert(record == state->decode_queue_head);
    state->record = NULL;
    state->decode_queue_head = record->next;
 
    /* It might also be the newest item decoded, decode_queue_tail. */
    if (state->decode_queue_tail == record)
        state->decode_queue_tail = NULL;
 
    /* Release the space. */
    if (unlikely(record->oversized))
    {
        /* It's not in the decode buffer, so free it to release space. */
        pfree(record);
    }
    else
    {
        /* It must be the head (oldest) record in the decode buffer. */
        Assert(state->decode_buffer_head == (char *) record);
 
        /*
         * We need to update head to point to the next record that is in the
         * decode buffer, if any, being careful to skip oversized ones
         * (they're not in the decode buffer).
         */
        record = record->next;
        while (unlikely(record && record->oversized))
            record = record->next;
 
        if (record)
        {
            /* Adjust head to release space up to the next record. */
            state->decode_buffer_head = (char *) record;
        }
        else
        {
            /*
             * Otherwise we might as well just reset head and tail to the
             * start of the buffer space, because we're empty.  This means
             * we'll keep overwriting the same piece of memory if we're not
             * doing any prefetching.
             */
            state->decode_buffer_head = state->decode_buffer;
            state->decode_buffer_tail = state->decode_buffer;
        }
    }
 
    return next_lsn;
}

References Assert, fb(), InvalidXLogRecPtr, DecodedXLogRecord::next, DecodedXLogRecord::next_lsn, DecodedXLogRecord::oversized, pfree(), and unlikely.

Referenced by XLogNextRecord(), XLogPrefetcherReadRecord(), and XLogReadRecord().