pg_walinspect.c File Reference

#include "postgres.h"
#include "access/xlog.h"
#include "access/xlog_internal.h"
#include "access/xlogreader.h"
#include "access/xlogrecovery.h"
#include "access/xlogstats.h"
#include "access/xlogutils.h"
#include "funcapi.h"
#include "miscadmin.h"
#include "utils/array.h"
#include "utils/builtins.h"
#include "utils/pg_lsn.h"

Include dependency graph for pg_walinspect.c:

Go to the source code of this file.

Macros
#define	PG_GET_WAL_BLOCK_INFO_COLS   20
#define	PG_GET_WAL_RECORD_INFO_COLS   11
#define	PG_GET_WAL_RECORDS_INFO_COLS   11
#define	PG_GET_WAL_STATS_COLS   9

Functions
	PG_FUNCTION_INFO_V1 (pg_get_wal_block_info)
	PG_FUNCTION_INFO_V1 (pg_get_wal_record_info)
	PG_FUNCTION_INFO_V1 (pg_get_wal_records_info)
	PG_FUNCTION_INFO_V1 (pg_get_wal_records_info_till_end_of_wal)
	PG_FUNCTION_INFO_V1 (pg_get_wal_stats)
	PG_FUNCTION_INFO_V1 (pg_get_wal_stats_till_end_of_wal)
static void	ValidateInputLSNs (XLogRecPtr start_lsn, XLogRecPtr *end_lsn)
static XLogRecPtr	GetCurrentLSN (void)
static XLogReaderState *	InitXLogReaderState (XLogRecPtr lsn)
static XLogRecord *	ReadNextXLogRecord (XLogReaderState *xlogreader)
static void	GetWALRecordInfo (XLogReaderState *record, Datum *values, bool *nulls, uint32 ncols)
static void	GetWALRecordsInfo (FunctionCallInfo fcinfo, XLogRecPtr start_lsn, XLogRecPtr end_lsn)
static void	GetXLogSummaryStats (XLogStats *stats, ReturnSetInfo *rsinfo, Datum *values, bool *nulls, uint32 ncols, bool stats_per_record)
static void	FillXLogStatsRow (const char *name, uint64 n, uint64 total_count, uint64 rec_len, uint64 total_rec_len, uint64 fpi_len, uint64 total_fpi_len, uint64 tot_len, uint64 total_len, Datum *values, bool *nulls, uint32 ncols)
static void	GetWalStats (FunctionCallInfo fcinfo, XLogRecPtr start_lsn, XLogRecPtr end_lsn, bool stats_per_record)
static void	GetWALBlockInfo (FunctionCallInfo fcinfo, XLogReaderState *record, bool show_data)
Datum	pg_get_wal_block_info (PG_FUNCTION_ARGS)
Datum	pg_get_wal_record_info (PG_FUNCTION_ARGS)
Datum	pg_get_wal_records_info (PG_FUNCTION_ARGS)
Datum	pg_get_wal_stats (PG_FUNCTION_ARGS)
Datum	pg_get_wal_records_info_till_end_of_wal (PG_FUNCTION_ARGS)
Datum	pg_get_wal_stats_till_end_of_wal (PG_FUNCTION_ARGS)

Variables
	PG_MODULE_MAGIC

Macro Definition Documentation

PG_GET_WAL_BLOCK_INFO_COLS

#define PG_GET_WAL_BLOCK_INFO_COLS   20

PG_GET_WAL_RECORD_INFO_COLS

#define PG_GET_WAL_RECORD_INFO_COLS   11

PG_GET_WAL_RECORDS_INFO_COLS

#define PG_GET_WAL_RECORDS_INFO_COLS   11

PG_GET_WAL_STATS_COLS

#define PG_GET_WAL_STATS_COLS   9

Function Documentation

FillXLogStatsRow()

static void FillXLogStatsRow ( const char *  name, uint64  n, uint64  total_count, uint64  rec_len, uint64  total_rec_len, uint64  fpi_len, uint64  total_fpi_len, uint64  tot_len, uint64  total_len, Datum *  values, bool *  nulls, uint32  ncols  )

static

Definition at line 603 of file pg_walinspect.c.

{
    double      n_pct,
                rec_len_pct,
                fpi_len_pct,
                tot_len_pct;
    int         i = 0;
 
    n_pct = 0;
    if (total_count != 0)
        n_pct = 100 * (double) n / total_count;
 
    rec_len_pct = 0;
    if (total_rec_len != 0)
        rec_len_pct = 100 * (double) rec_len / total_rec_len;
 
    fpi_len_pct = 0;
    if (total_fpi_len != 0)
        fpi_len_pct = 100 * (double) fpi_len / total_fpi_len;
 
    tot_len_pct = 0;
    if (total_len != 0)
        tot_len_pct = 100 * (double) tot_len / total_len;
 
    values[i++] = CStringGetTextDatum(name);
    values[i++] = Int64GetDatum(n);
    values[i++] = Float8GetDatum(n_pct);
    values[i++] = Int64GetDatum(rec_len);
    values[i++] = Float8GetDatum(rec_len_pct);
    values[i++] = Int64GetDatum(fpi_len);
    values[i++] = Float8GetDatum(fpi_len_pct);
    values[i++] = Int64GetDatum(tot_len);
    values[i++] = Float8GetDatum(tot_len_pct);
 
    Assert(i == ncols);
}

References Assert(), CStringGetTextDatum, Float8GetDatum(), i, Int64GetDatum(), name, and values.

Referenced by GetXLogSummaryStats().

GetCurrentLSN()

static XLogRecPtr GetCurrentLSN ( void  )

static

Definition at line 69 of file pg_walinspect.c.

{
    XLogRecPtr  curr_lsn;
 
    /*
     * We determine the current LSN of the server similar to how page_read
     * callback read_local_xlog_page_no_wait does.
     */
    if (!RecoveryInProgress())
        curr_lsn = GetFlushRecPtr(NULL);
    else
        curr_lsn = GetXLogReplayRecPtr(NULL);
 
    Assert(!XLogRecPtrIsInvalid(curr_lsn));
 
    return curr_lsn;
}

References Assert(), GetFlushRecPtr(), GetXLogReplayRecPtr(), RecoveryInProgress(), and XLogRecPtrIsInvalid.

Referenced by pg_get_wal_record_info(), pg_get_wal_records_info_till_end_of_wal(), pg_get_wal_stats_till_end_of_wal(), and ValidateInputLSNs().

GetWALBlockInfo()

static void GetWALBlockInfo ( FunctionCallInfo  fcinfo, XLogReaderState *  record, bool  show_data  )

static

Definition at line 248 of file pg_walinspect.c.

{
#define PG_GET_WAL_BLOCK_INFO_COLS 20
    int         block_id;
    ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
    RmgrData    desc;
    const char *record_type;
    StringInfoData rec_desc;
 
    Assert(XLogRecHasAnyBlockRefs(record));
 
    desc = GetRmgr(XLogRecGetRmid(record));
    record_type = desc.rm_identify(XLogRecGetInfo(record));
 
    if (record_type == NULL)
        record_type = psprintf("UNKNOWN (%x)",
                               XLogRecGetInfo(record) & ~XLR_INFO_MASK);
 
    initStringInfo(&rec_desc);
    desc.rm_desc(&rec_desc, record);
 
    for (block_id = 0; block_id <= XLogRecMaxBlockId(record); block_id++)
    {
        DecodedBkpBlock *blk;
        BlockNumber blkno;
        RelFileLocator rnode;
        ForkNumber  forknum;
        Datum       values[PG_GET_WAL_BLOCK_INFO_COLS] = {0};
        bool        nulls[PG_GET_WAL_BLOCK_INFO_COLS] = {0};
        uint32      block_data_len = 0,
                    block_fpi_len = 0;
        ArrayType  *block_fpi_info = NULL;
        int         i = 0;
 
        if (!XLogRecHasBlockRef(record, block_id))
            continue;
 
        blk = XLogRecGetBlock(record, block_id);
 
        (void) XLogRecGetBlockTagExtended(record, block_id,
                                          &rnode, &forknum, &blkno, NULL);
 
        /* Save block_data_len */
        if (blk->has_data)
            block_data_len = blk->data_len;
 
        if (blk->has_image)
        {
            /* Block reference has an FPI, so prepare relevant output */
            int         bitcnt;
            int         cnt = 0;
            Datum      *flags;
 
            /* Save block_fpi_len */
            block_fpi_len = blk->bimg_len;
 
            /* Construct and save block_fpi_info */
            bitcnt = pg_popcount((const char *) &blk->bimg_info,
                                 sizeof(uint8));
            flags = (Datum *) palloc0(sizeof(Datum) * bitcnt);
            if ((blk->bimg_info & BKPIMAGE_HAS_HOLE) != 0)
                flags[cnt++] = CStringGetTextDatum("HAS_HOLE");
            if (blk->apply_image)
                flags[cnt++] = CStringGetTextDatum("APPLY");
            if ((blk->bimg_info & BKPIMAGE_COMPRESS_PGLZ) != 0)
                flags[cnt++] = CStringGetTextDatum("COMPRESS_PGLZ");
            if ((blk->bimg_info & BKPIMAGE_COMPRESS_LZ4) != 0)
                flags[cnt++] = CStringGetTextDatum("COMPRESS_LZ4");
            if ((blk->bimg_info & BKPIMAGE_COMPRESS_ZSTD) != 0)
                flags[cnt++] = CStringGetTextDatum("COMPRESS_ZSTD");
 
            Assert(cnt <= bitcnt);
            block_fpi_info = construct_array_builtin(flags, cnt, TEXTOID);
        }
 
        /* start_lsn, end_lsn, prev_lsn, and blockid outputs */
        values[i++] = LSNGetDatum(record->ReadRecPtr);
        values[i++] = LSNGetDatum(record->EndRecPtr);
        values[i++] = LSNGetDatum(XLogRecGetPrev(record));
        values[i++] = Int16GetDatum(block_id);
 
        /* relfile and block related outputs */
        values[i++] = ObjectIdGetDatum(blk->rlocator.spcOid);
        values[i++] = ObjectIdGetDatum(blk->rlocator.dbOid);
        values[i++] = ObjectIdGetDatum(blk->rlocator.relNumber);
        values[i++] = Int16GetDatum(forknum);
        values[i++] = Int64GetDatum((int64) blkno);
 
        /* xid, resource_manager, and record_type outputs */
        values[i++] = TransactionIdGetDatum(XLogRecGetXid(record));
        values[i++] = CStringGetTextDatum(desc.rm_name);
        values[i++] = CStringGetTextDatum(record_type);
 
        /*
         * record_length, main_data_length, block_data_len, and
         * block_fpi_length outputs
         */
        values[i++] = UInt32GetDatum(XLogRecGetTotalLen(record));
        values[i++] = UInt32GetDatum(XLogRecGetDataLen(record));
        values[i++] = UInt32GetDatum(block_data_len);
        values[i++] = UInt32GetDatum(block_fpi_len);
 
        /* block_fpi_info (text array) output */
        if (block_fpi_info)
            values[i++] = PointerGetDatum(block_fpi_info);
        else
            nulls[i++] = true;
 
        /* description output (describes WAL record) */
        if (rec_desc.len > 0)
            values[i++] = CStringGetTextDatum(rec_desc.data);
        else
            nulls[i++] = true;
 
        /* block_data output */
        if (blk->has_data && show_data)
        {
            bytea      *block_data;
 
            block_data = (bytea *) palloc(block_data_len + VARHDRSZ);
            SET_VARSIZE(block_data, block_data_len + VARHDRSZ);
            memcpy(VARDATA(block_data), blk->data, block_data_len);
            values[i++] = PointerGetDatum(block_data);
        }
        else
            nulls[i++] = true;
 
        /* block_fpi_data output */
        if (blk->has_image && show_data)
        {
            PGAlignedBlock buf;
            Page        page;
            bytea      *block_fpi_data;
 
            page = (Page) buf.data;
            if (!RestoreBlockImage(record, block_id, page))
                ereport(ERROR,
                        (errcode(ERRCODE_INTERNAL_ERROR),
                         errmsg_internal("%s", record->errormsg_buf)));
 
            block_fpi_data = (bytea *) palloc(BLCKSZ + VARHDRSZ);
            SET_VARSIZE(block_fpi_data, BLCKSZ + VARHDRSZ);
            memcpy(VARDATA(block_fpi_data), page, BLCKSZ);
            values[i++] = PointerGetDatum(block_fpi_data);
        }
        else
            nulls[i++] = true;
 
        Assert(i == PG_GET_WAL_BLOCK_INFO_COLS);
 
        /* Store a tuple for this block reference */
        tuplestore_putvalues(rsinfo->setResult, rsinfo->setDesc,
                             values, nulls);
    }
 
#undef PG_GET_WAL_BLOCK_INFO_COLS
}

References DecodedBkpBlock::apply_image, Assert(), DecodedBkpBlock::bimg_info, DecodedBkpBlock::bimg_len, BKPIMAGE_COMPRESS_LZ4, BKPIMAGE_COMPRESS_PGLZ, BKPIMAGE_COMPRESS_ZSTD, BKPIMAGE_HAS_HOLE, buf, construct_array_builtin(), CStringGetTextDatum, DecodedBkpBlock::data, DecodedBkpBlock::data_len, RelFileLocator::dbOid, XLogReaderState::EndRecPtr, ereport, errcode(), errmsg_internal(), ERROR, XLogReaderState::errormsg_buf, GetRmgr(), DecodedBkpBlock::has_data, DecodedBkpBlock::has_image, i, if(), initStringInfo(), Int16GetDatum(), Int64GetDatum(), LSNGetDatum(), ObjectIdGetDatum(), palloc(), palloc0(), PG_GET_WAL_BLOCK_INFO_COLS, pg_popcount(), PointerGetDatum(), psprintf(), XLogReaderState::ReadRecPtr, RelFileLocator::relNumber, RestoreBlockImage(), FunctionCallInfoBaseData::resultinfo, DecodedBkpBlock::rlocator, SET_VARSIZE, ReturnSetInfo::setDesc, ReturnSetInfo::setResult, RelFileLocator::spcOid, TransactionIdGetDatum(), tuplestore_putvalues(), UInt32GetDatum(), values, VARDATA, VARHDRSZ, XLogRecGetBlock, XLogRecGetBlockTagExtended(), XLogRecGetDataLen, XLogRecGetInfo, XLogRecGetPrev, XLogRecGetRmid, XLogRecGetTotalLen, XLogRecGetXid, XLogRecHasAnyBlockRefs, XLogRecHasBlockRef, XLogRecMaxBlockId, and XLR_INFO_MASK.

Referenced by pg_get_wal_block_info().

GetWALRecordInfo()

static void GetWALRecordInfo ( XLogReaderState *  record, Datum *  values, bool *  nulls, uint32  ncols  )

static

Definition at line 188 of file pg_walinspect.c.

{
    const char *record_type;
    RmgrData    desc;
    uint32      fpi_len = 0;
    StringInfoData rec_desc;
    StringInfoData rec_blk_ref;
    int         i = 0;
 
    desc = GetRmgr(XLogRecGetRmid(record));
    record_type = desc.rm_identify(XLogRecGetInfo(record));
 
    if (record_type == NULL)
        record_type = psprintf("UNKNOWN (%x)", XLogRecGetInfo(record) & ~XLR_INFO_MASK);
 
    initStringInfo(&rec_desc);
    desc.rm_desc(&rec_desc, record);
 
    if (XLogRecHasAnyBlockRefs(record))
    {
        initStringInfo(&rec_blk_ref);
        XLogRecGetBlockRefInfo(record, false, true, &rec_blk_ref, &fpi_len);
    }
 
    values[i++] = LSNGetDatum(record->ReadRecPtr);
    values[i++] = LSNGetDatum(record->EndRecPtr);
    values[i++] = LSNGetDatum(XLogRecGetPrev(record));
    values[i++] = TransactionIdGetDatum(XLogRecGetXid(record));
    values[i++] = CStringGetTextDatum(desc.rm_name);
    values[i++] = CStringGetTextDatum(record_type);
    values[i++] = UInt32GetDatum(XLogRecGetTotalLen(record));
    values[i++] = UInt32GetDatum(XLogRecGetDataLen(record));
    values[i++] = UInt32GetDatum(fpi_len);
 
    if (rec_desc.len > 0)
        values[i++] = CStringGetTextDatum(rec_desc.data);
    else
        nulls[i++] = true;
 
    if (XLogRecHasAnyBlockRefs(record))
        values[i++] = CStringGetTextDatum(rec_blk_ref.data);
    else
        nulls[i++] = true;
 
    Assert(i == ncols);
}

References Assert(), CStringGetTextDatum, StringInfoData::data, XLogReaderState::EndRecPtr, GetRmgr(), i, initStringInfo(), StringInfoData::len, LSNGetDatum(), psprintf(), XLogReaderState::ReadRecPtr, RmgrData::rm_desc, RmgrData::rm_identify, RmgrData::rm_name, TransactionIdGetDatum(), UInt32GetDatum(), values, XLogRecGetBlockRefInfo(), XLogRecGetDataLen, XLogRecGetInfo, XLogRecGetPrev, XLogRecGetRmid, XLogRecGetTotalLen, XLogRecGetXid, XLogRecHasAnyBlockRefs, and XLR_INFO_MASK.

Referenced by GetWALRecordsInfo(), and pg_get_wal_record_info().

GetWALRecordsInfo()

static void GetWALRecordsInfo ( FunctionCallInfo  fcinfo, XLogRecPtr  start_lsn, XLogRecPtr  end_lsn  )

static

Definition at line 536 of file pg_walinspect.c.

{
#define PG_GET_WAL_RECORDS_INFO_COLS 11
    XLogReaderState *xlogreader;
    ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
    MemoryContext old_cxt;
    MemoryContext tmp_cxt;
 
    Assert(start_lsn <= end_lsn);
 
    InitMaterializedSRF(fcinfo, 0);
 
    xlogreader = InitXLogReaderState(start_lsn);
 
    tmp_cxt = AllocSetContextCreate(CurrentMemoryContext,
                                    "GetWALRecordsInfo temporary cxt",
                                    ALLOCSET_DEFAULT_SIZES);
 
    while (ReadNextXLogRecord(xlogreader) &&
           xlogreader->EndRecPtr <= end_lsn)
    {
        Datum       values[PG_GET_WAL_RECORDS_INFO_COLS] = {0};
        bool        nulls[PG_GET_WAL_RECORDS_INFO_COLS] = {0};
 
        /* Use the tmp context so we can clean up after each tuple is done */
        old_cxt = MemoryContextSwitchTo(tmp_cxt);
 
        GetWALRecordInfo(xlogreader, values, nulls,
                         PG_GET_WAL_RECORDS_INFO_COLS);
 
        tuplestore_putvalues(rsinfo->setResult, rsinfo->setDesc,
                             values, nulls);
 
        /* clean up and switch back */
        MemoryContextSwitchTo(old_cxt);
        MemoryContextReset(tmp_cxt);
 
        CHECK_FOR_INTERRUPTS();
    }
 
    MemoryContextDelete(tmp_cxt);
    pfree(xlogreader->private_data);
    XLogReaderFree(xlogreader);
 
#undef PG_GET_WAL_RECORDS_INFO_COLS
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, Assert(), CHECK_FOR_INTERRUPTS, CurrentMemoryContext, XLogReaderState::EndRecPtr, GetWALRecordInfo(), InitMaterializedSRF(), InitXLogReaderState(), MemoryContextDelete(), MemoryContextReset(), MemoryContextSwitchTo(), pfree(), PG_GET_WAL_RECORDS_INFO_COLS, XLogReaderState::private_data, ReadNextXLogRecord(), FunctionCallInfoBaseData::resultinfo, ReturnSetInfo::setDesc, ReturnSetInfo::setResult, tuplestore_putvalues(), values, xlogreader, and XLogReaderFree().

Referenced by pg_get_wal_records_info(), and pg_get_wal_records_info_till_end_of_wal().

GetWalStats()

static void GetWalStats ( FunctionCallInfo  fcinfo, XLogRecPtr  start_lsn, XLogRecPtr  end_lsn, bool  stats_per_record  )

static

Definition at line 762 of file pg_walinspect.c.

{
#define PG_GET_WAL_STATS_COLS 9
    XLogReaderState *xlogreader;
    XLogStats   stats = {0};
    ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
    Datum       values[PG_GET_WAL_STATS_COLS] = {0};
    bool        nulls[PG_GET_WAL_STATS_COLS] = {0};
 
    Assert(start_lsn <= end_lsn);
 
    InitMaterializedSRF(fcinfo, 0);
 
    xlogreader = InitXLogReaderState(start_lsn);
 
    while (ReadNextXLogRecord(xlogreader) &&
           xlogreader->EndRecPtr <= end_lsn)
    {
        XLogRecStoreStats(&stats, xlogreader);
 
        CHECK_FOR_INTERRUPTS();
    }
 
    pfree(xlogreader->private_data);
    XLogReaderFree(xlogreader);
 
    GetXLogSummaryStats(&stats, rsinfo, values, nulls,
                        PG_GET_WAL_STATS_COLS,
                        stats_per_record);
 
#undef PG_GET_WAL_STATS_COLS
}

References PG_GET_WAL_STATS_COLS, FunctionCallInfoBaseData::resultinfo, values, and xlogreader.

Referenced by pg_get_wal_stats(), and pg_get_wal_stats_till_end_of_wal().

GetXLogSummaryStats()

static void GetXLogSummaryStats ( XLogStats *  stats, ReturnSetInfo *  rsinfo, Datum *  values, bool *  nulls, uint32  ncols, bool  stats_per_record  )

static

Definition at line 649 of file pg_walinspect.c.

{
    MemoryContext old_cxt;
    MemoryContext tmp_cxt;
    uint64      total_count = 0;
    uint64      total_rec_len = 0;
    uint64      total_fpi_len = 0;
    uint64      total_len = 0;
    int         ri;
 
    /*
     * Each row shows its percentages of the total, so make a first pass to
     * calculate column totals.
     */
    for (ri = 0; ri <= RM_MAX_ID; ri++)
    {
        if (!RmgrIdIsValid(ri))
            continue;
 
        total_count += stats->rmgr_stats[ri].count;
        total_rec_len += stats->rmgr_stats[ri].rec_len;
        total_fpi_len += stats->rmgr_stats[ri].fpi_len;
    }
    total_len = total_rec_len + total_fpi_len;
 
    tmp_cxt = AllocSetContextCreate(CurrentMemoryContext,
                                    "GetXLogSummaryStats temporary cxt",
                                    ALLOCSET_DEFAULT_SIZES);
 
    for (ri = 0; ri <= RM_MAX_ID; ri++)
    {
        uint64      count;
        uint64      rec_len;
        uint64      fpi_len;
        uint64      tot_len;
        RmgrData    desc;
 
        if (!RmgrIdIsValid(ri))
            continue;
 
        if (!RmgrIdExists(ri))
            continue;
 
        desc = GetRmgr(ri);
 
        if (stats_per_record)
        {
            int         rj;
 
            for (rj = 0; rj < MAX_XLINFO_TYPES; rj++)
            {
                const char *id;
 
                count = stats->record_stats[ri][rj].count;
                rec_len = stats->record_stats[ri][rj].rec_len;
                fpi_len = stats->record_stats[ri][rj].fpi_len;
                tot_len = rec_len + fpi_len;
 
                /* Skip undefined combinations and ones that didn't occur */
                if (count == 0)
                    continue;
 
                old_cxt = MemoryContextSwitchTo(tmp_cxt);
 
                /* the upper four bits in xl_info are the rmgr's */
                id = desc.rm_identify(rj << 4);
                if (id == NULL)
                    id = psprintf("UNKNOWN (%x)", rj << 4);
 
                FillXLogStatsRow(psprintf("%s/%s", desc.rm_name, id), count,
                                 total_count, rec_len, total_rec_len, fpi_len,
                                 total_fpi_len, tot_len, total_len,
                                 values, nulls, ncols);
 
                tuplestore_putvalues(rsinfo->setResult, rsinfo->setDesc,
                                     values, nulls);
 
                /* clean up and switch back */
                MemoryContextSwitchTo(old_cxt);
                MemoryContextReset(tmp_cxt);
            }
        }
        else
        {
            count = stats->rmgr_stats[ri].count;
            rec_len = stats->rmgr_stats[ri].rec_len;
            fpi_len = stats->rmgr_stats[ri].fpi_len;
            tot_len = rec_len + fpi_len;
 
            old_cxt = MemoryContextSwitchTo(tmp_cxt);
 
            FillXLogStatsRow(desc.rm_name, count, total_count, rec_len,
                             total_rec_len, fpi_len, total_fpi_len, tot_len,
                             total_len, values, nulls, ncols);
 
            tuplestore_putvalues(rsinfo->setResult, rsinfo->setDesc,
                                 values, nulls);
 
            /* clean up and switch back */
            MemoryContextSwitchTo(old_cxt);
            MemoryContextReset(tmp_cxt);
        }
    }
 
    MemoryContextDelete(tmp_cxt);
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, XLogRecStats::count, CurrentMemoryContext, FillXLogStatsRow(), XLogRecStats::fpi_len, GetRmgr(), MAX_XLINFO_TYPES, MemoryContextDelete(), MemoryContextReset(), MemoryContextSwitchTo(), psprintf(), XLogRecStats::rec_len, XLogStats::record_stats, RmgrData::rm_identify, RM_MAX_ID, RmgrData::rm_name, XLogStats::rmgr_stats, RmgrIdExists(), RmgrIdIsValid, ReturnSetInfo::setDesc, ReturnSetInfo::setResult, tuplestore_putvalues(), and values.

InitXLogReaderState()

static XLogReaderState * InitXLogReaderState ( XLogRecPtr  lsn )

static

Definition at line 91 of file pg_walinspect.c.

{
    XLogReaderState *xlogreader;
    ReadLocalXLogPageNoWaitPrivate *private_data;
    XLogRecPtr  first_valid_record;
 
    /*
     * Reading WAL below the first page of the first segments isn't allowed.
     * This is a bootstrap WAL page and the page_read callback fails to read
     * it.
     */
    if (lsn < XLOG_BLCKSZ)
        ereport(ERROR,
                (errmsg("could not read WAL at LSN %X/%X",
                        LSN_FORMAT_ARGS(lsn))));
 
    private_data = (ReadLocalXLogPageNoWaitPrivate *)
        palloc0(sizeof(ReadLocalXLogPageNoWaitPrivate));
 
    xlogreader = XLogReaderAllocate(wal_segment_size, NULL,
                                    XL_ROUTINE(.page_read = &read_local_xlog_page_no_wait,
                                               .segment_open = &wal_segment_open,
                                               .segment_close = &wal_segment_close),
                                    private_data);
 
    if (xlogreader == NULL)
        ereport(ERROR,
                (errcode(ERRCODE_OUT_OF_MEMORY),
                 errmsg("out of memory"),
                 errdetail("Failed while allocating a WAL reading processor.")));
 
    /* first find a valid recptr to start from */
    first_valid_record = XLogFindNextRecord(xlogreader, lsn);
 
    if (XLogRecPtrIsInvalid(first_valid_record))
        ereport(ERROR,
                (errmsg("could not find a valid record after %X/%X",
                        LSN_FORMAT_ARGS(lsn))));
 
    return xlogreader;
}

References ereport, errcode(), errdetail(), errmsg(), ERROR, LSN_FORMAT_ARGS, palloc0(), read_local_xlog_page_no_wait(), wal_segment_close(), wal_segment_open(), wal_segment_size, XL_ROUTINE, XLogFindNextRecord(), xlogreader, XLogReaderAllocate(), and XLogRecPtrIsInvalid.

Referenced by GetWALRecordsInfo(), pg_get_wal_block_info(), and pg_get_wal_record_info().

PG_FUNCTION_INFO_V1() [1/6]

PG_FUNCTION_INFO_V1

(

pg_get_wal_block_info

)

PG_FUNCTION_INFO_V1() [2/6]

PG_FUNCTION_INFO_V1

(

pg_get_wal_record_info

)

PG_FUNCTION_INFO_V1() [3/6]

PG_FUNCTION_INFO_V1

(

pg_get_wal_records_info

)

PG_FUNCTION_INFO_V1() [4/6]

PG_FUNCTION_INFO_V1

(

pg_get_wal_records_info_till_end_of_wal

)

PG_FUNCTION_INFO_V1() [5/6]

PG_FUNCTION_INFO_V1

(

pg_get_wal_stats

)

PG_FUNCTION_INFO_V1() [6/6]

PG_FUNCTION_INFO_V1

(

pg_get_wal_stats_till_end_of_wal

)

pg_get_wal_block_info()

Datum pg_get_wal_block_info

(

PG_FUNCTION_ARGS

)

Definition at line 411 of file pg_walinspect.c.

{
    XLogRecPtr  start_lsn = PG_GETARG_LSN(0);
    XLogRecPtr  end_lsn = PG_GETARG_LSN(1);
    bool        show_data = PG_GETARG_BOOL(2);
    XLogReaderState *xlogreader;
    MemoryContext old_cxt;
    MemoryContext tmp_cxt;
 
    ValidateInputLSNs(start_lsn, &end_lsn);
 
    InitMaterializedSRF(fcinfo, 0);
 
    xlogreader = InitXLogReaderState(start_lsn);
 
    tmp_cxt = AllocSetContextCreate(CurrentMemoryContext,
                                    "pg_get_wal_block_info temporary cxt",
                                    ALLOCSET_DEFAULT_SIZES);
 
    while (ReadNextXLogRecord(xlogreader) &&
           xlogreader->EndRecPtr <= end_lsn)
    {
        CHECK_FOR_INTERRUPTS();
 
        if (!XLogRecHasAnyBlockRefs(xlogreader))
            continue;
 
        /* Use the tmp context so we can clean up after each tuple is done */
        old_cxt = MemoryContextSwitchTo(tmp_cxt);
 
        GetWALBlockInfo(fcinfo, xlogreader, show_data);
 
        /* clean up and switch back */
        MemoryContextSwitchTo(old_cxt);
        MemoryContextReset(tmp_cxt);
    }
 
    MemoryContextDelete(tmp_cxt);
    pfree(xlogreader->private_data);
    XLogReaderFree(xlogreader);
 
    PG_RETURN_VOID();
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, CHECK_FOR_INTERRUPTS, CurrentMemoryContext, XLogReaderState::EndRecPtr, GetWALBlockInfo(), InitMaterializedSRF(), InitXLogReaderState(), MemoryContextDelete(), MemoryContextReset(), MemoryContextSwitchTo(), pfree(), PG_GETARG_BOOL, PG_GETARG_LSN, PG_RETURN_VOID, XLogReaderState::private_data, ReadNextXLogRecord(), ValidateInputLSNs(), xlogreader, XLogReaderFree(), and XLogRecHasAnyBlockRefs.

pg_get_wal_record_info()

Datum pg_get_wal_record_info

(

PG_FUNCTION_ARGS

)

Definition at line 459 of file pg_walinspect.c.

{
#define PG_GET_WAL_RECORD_INFO_COLS 11
    Datum       result;
    Datum       values[PG_GET_WAL_RECORD_INFO_COLS] = {0};
    bool        nulls[PG_GET_WAL_RECORD_INFO_COLS] = {0};
    XLogRecPtr  lsn;
    XLogRecPtr  curr_lsn;
    XLogReaderState *xlogreader;
    TupleDesc   tupdesc;
    HeapTuple   tuple;
 
    lsn = PG_GETARG_LSN(0);
    curr_lsn = GetCurrentLSN();
 
    if (lsn > curr_lsn)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("WAL input LSN must be less than current LSN"),
                 errdetail("Current WAL LSN on the database system is at %X/%X.",
                           LSN_FORMAT_ARGS(curr_lsn))));
 
    /* Build a tuple descriptor for our result type. */
    if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
        elog(ERROR, "return type must be a row type");
 
    xlogreader = InitXLogReaderState(lsn);
 
    if (!ReadNextXLogRecord(xlogreader))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("could not read WAL at %X/%X",
                        LSN_FORMAT_ARGS(xlogreader->EndRecPtr))));
 
    GetWALRecordInfo(xlogreader, values, nulls, PG_GET_WAL_RECORD_INFO_COLS);
 
    pfree(xlogreader->private_data);
    XLogReaderFree(xlogreader);
 
    tuple = heap_form_tuple(tupdesc, values, nulls);
    result = HeapTupleGetDatum(tuple);
 
    PG_RETURN_DATUM(result);
#undef PG_GET_WAL_RECORD_INFO_COLS
}

References elog(), XLogReaderState::EndRecPtr, ereport, errcode(), errdetail(), errmsg(), ERROR, get_call_result_type(), GetCurrentLSN(), GetWALRecordInfo(), heap_form_tuple(), HeapTupleGetDatum(), InitXLogReaderState(), LSN_FORMAT_ARGS, pfree(), PG_GET_WAL_RECORD_INFO_COLS, PG_GETARG_LSN, PG_RETURN_DATUM, XLogReaderState::private_data, ReadNextXLogRecord(), TYPEFUNC_COMPOSITE, values, xlogreader, and XLogReaderFree().

pg_get_wal_records_info()

Datum pg_get_wal_records_info

(

PG_FUNCTION_ARGS

)

Definition at line 588 of file pg_walinspect.c.

{
    XLogRecPtr  start_lsn = PG_GETARG_LSN(0);
    XLogRecPtr  end_lsn = PG_GETARG_LSN(1);
 
    ValidateInputLSNs(start_lsn, &end_lsn);
    GetWALRecordsInfo(fcinfo, start_lsn, end_lsn);
 
    PG_RETURN_VOID();
}

References GetWALRecordsInfo(), PG_GETARG_LSN, PG_RETURN_VOID, and ValidateInputLSNs().

pg_get_wal_records_info_till_end_of_wal()

Datum pg_get_wal_records_info_till_end_of_wal

(

PG_FUNCTION_ARGS

)

Definition at line 817 of file pg_walinspect.c.

{
    XLogRecPtr  start_lsn = PG_GETARG_LSN(0);
    XLogRecPtr  end_lsn = GetCurrentLSN();
 
    if (start_lsn > end_lsn)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("WAL start LSN must be less than current LSN"),
                 errdetail("Current WAL LSN on the database system is at %X/%X.",
                           LSN_FORMAT_ARGS(end_lsn))));
 
    GetWALRecordsInfo(fcinfo, start_lsn, end_lsn);
 
    PG_RETURN_VOID();
}

References ereport, errcode(), errdetail(), errmsg(), ERROR, GetCurrentLSN(), GetWALRecordsInfo(), LSN_FORMAT_ARGS, PG_GETARG_LSN, and PG_RETURN_VOID.

pg_get_wal_stats()

Datum pg_get_wal_stats

(

PG_FUNCTION_ARGS

)

Definition at line 800 of file pg_walinspect.c.

{
    XLogRecPtr  start_lsn = PG_GETARG_LSN(0);
    XLogRecPtr  end_lsn = PG_GETARG_LSN(1);
    bool        stats_per_record = PG_GETARG_BOOL(2);
 
    ValidateInputLSNs(start_lsn, &end_lsn);
    GetWalStats(fcinfo, start_lsn, end_lsn, stats_per_record);
 
    PG_RETURN_VOID();
}

References GetWalStats(), PG_GETARG_BOOL, PG_GETARG_LSN, PG_RETURN_VOID, and ValidateInputLSNs().

pg_get_wal_stats_till_end_of_wal()

Datum pg_get_wal_stats_till_end_of_wal

(

PG_FUNCTION_ARGS

)

Definition at line 835 of file pg_walinspect.c.

{
    XLogRecPtr  start_lsn = PG_GETARG_LSN(0);
    XLogRecPtr  end_lsn = GetCurrentLSN();
    bool        stats_per_record = PG_GETARG_BOOL(1);
 
    if (start_lsn > end_lsn)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("WAL start LSN must be less than current LSN"),
                 errdetail("Current WAL LSN on the database system is at %X/%X.",
                           LSN_FORMAT_ARGS(end_lsn))));
 
    GetWalStats(fcinfo, start_lsn, end_lsn, stats_per_record);
 
    PG_RETURN_VOID();
}

References ereport, errcode(), errdetail(), errmsg(), ERROR, GetCurrentLSN(), GetWalStats(), LSN_FORMAT_ARGS, PG_GETARG_BOOL, PG_GETARG_LSN, and PG_RETURN_VOID.

ReadNextXLogRecord()

static XLogRecord * ReadNextXLogRecord ( XLogReaderState *  xlogreader )

static

Definition at line 146 of file pg_walinspect.c.

{
    XLogRecord *record;
    char       *errormsg;
 
    record = XLogReadRecord(xlogreader, &errormsg);
 
    if (record == NULL)
    {
        ReadLocalXLogPageNoWaitPrivate *private_data;
 
        /* return NULL, if end of WAL is reached */
        private_data = (ReadLocalXLogPageNoWaitPrivate *)
            xlogreader->private_data;
 
        if (private_data->end_of_wal)
            return NULL;
 
        if (errormsg)
            ereport(ERROR,
                    (errcode_for_file_access(),
                     errmsg("could not read WAL at %X/%X: %s",
                            LSN_FORMAT_ARGS(xlogreader->EndRecPtr), errormsg)));
        else
            ereport(ERROR,
                    (errcode_for_file_access(),
                     errmsg("could not read WAL at %X/%X",
                            LSN_FORMAT_ARGS(xlogreader->EndRecPtr))));
    }
 
    return record;
}

References ReadLocalXLogPageNoWaitPrivate::end_of_wal, XLogReaderState::EndRecPtr, ereport, errcode_for_file_access(), errmsg(), ERROR, if(), LSN_FORMAT_ARGS, XLogReaderState::private_data, xlogreader, and XLogReadRecord().

Referenced by GetWALRecordsInfo(), pg_get_wal_block_info(), and pg_get_wal_record_info().

ValidateInputLSNs()

static void ValidateInputLSNs ( XLogRecPtr  start_lsn, XLogRecPtr *  end_lsn  )

static

Definition at line 512 of file pg_walinspect.c.

{
    XLogRecPtr  curr_lsn = GetCurrentLSN();
 
    if (start_lsn > curr_lsn)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("WAL start LSN must be less than current LSN"),
                 errdetail("Current WAL LSN on the database system is at %X/%X.",
                           LSN_FORMAT_ARGS(curr_lsn))));
 
    if (start_lsn > *end_lsn)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("WAL start LSN must be less than end LSN")));
 
    if (*end_lsn > curr_lsn)
        *end_lsn = curr_lsn;
}

References ereport, errcode(), errdetail(), errmsg(), ERROR, GetCurrentLSN(), and LSN_FORMAT_ARGS.

Referenced by pg_get_wal_block_info(), pg_get_wal_records_info(), and pg_get_wal_stats().

Variable Documentation

PG_MODULE_MAGIC

PG_MODULE_MAGIC

Definition at line 32 of file pg_walinspect.c.