xlogdesc.c File Reference

#include "postgres.h"
#include "access/transam.h"
#include "access/xlog.h"
#include "access/xlog_internal.h"
#include "catalog/pg_control.h"
#include "utils/guc.h"
#include "utils/timestamp.h"

Include dependency graph for xlogdesc.c:

Go to the source code of this file.

Functions
static const char *	get_wal_level_string (int wal_level)
void	xlog_desc (StringInfo buf, XLogReaderState *record)
const char *	xlog_identify (uint8 info)
void	XLogRecGetBlockRefInfo (XLogReaderState *record, bool pretty, bool detailed_format, StringInfo buf, uint32 *fpi_len)

Variables
const struct config_enum_entry	wal_level_options []

Function Documentation

get_wal_level_string()

static const char * get_wal_level_string ( int  wal_level )

static

Definition at line 40 of file xlogdesc.c.

{
    const struct config_enum_entry *entry;
    const char *wal_level_str = "?";
 
    for (entry = wal_level_options; entry->name; entry++)
    {
        if (entry->val == wal_level)
        {
            wal_level_str = entry->name;
            break;
        }
    }
 
    return wal_level_str;
}

References config_enum_entry::name, config_enum_entry::val, wal_level, wal_level_options, and wal_level_str().

Referenced by xlog_desc().

xlog_desc()

void xlog_desc	(	StringInfo	buf,
		XLogReaderState *	record
	)

Definition at line 58 of file xlogdesc.c.

{
    char       *rec = XLogRecGetData(record);
    uint8       info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
 
    if (info == XLOG_CHECKPOINT_SHUTDOWN ||
        info == XLOG_CHECKPOINT_ONLINE)
    {
        CheckPoint *checkpoint = (CheckPoint *) rec;
 
        appendStringInfo(buf, "redo %X/%08X; "
                         "tli %u; prev tli %u; fpw %s; wal_level %s; logical decoding %s; xid %u:%u; oid %u; multi %u; offset %" PRIu64 "; "
                         "oldest xid %u in DB %u; oldest multi %u in DB %u; "
                         "oldest/newest commit timestamp xid: %u/%u; "
                         "oldest running xid %u; %s",
                         LSN_FORMAT_ARGS(checkpoint->redo),
                         checkpoint->ThisTimeLineID,
                         checkpoint->PrevTimeLineID,
                         checkpoint->fullPageWrites ? "true" : "false",
                         get_wal_level_string(checkpoint->wal_level),
                         checkpoint->logicalDecodingEnabled ? "true" : "false",
                         EpochFromFullTransactionId(checkpoint->nextXid),
                         XidFromFullTransactionId(checkpoint->nextXid),
                         checkpoint->nextOid,
                         checkpoint->nextMulti,
                         checkpoint->nextMultiOffset,
                         checkpoint->oldestXid,
                         checkpoint->oldestXidDB,
                         checkpoint->oldestMulti,
                         checkpoint->oldestMultiDB,
                         checkpoint->oldestCommitTsXid,
                         checkpoint->newestCommitTsXid,
                         checkpoint->oldestActiveXid,
                         (info == XLOG_CHECKPOINT_SHUTDOWN) ? "shutdown" : "online");
    }
    else if (info == XLOG_NEXTOID)
    {
        Oid         nextOid;
 
        memcpy(&nextOid, rec, sizeof(Oid));
        appendStringInfo(buf, "%u", nextOid);
    }
    else if (info == XLOG_RESTORE_POINT)
    {
        xl_restore_point *xlrec = (xl_restore_point *) rec;
 
        appendStringInfoString(buf, xlrec->rp_name);
    }
    else if (info == XLOG_FPI || info == XLOG_FPI_FOR_HINT)
    {
        /* no further information to print */
    }
    else if (info == XLOG_BACKUP_END)
    {
        XLogRecPtr  startpoint;
 
        memcpy(&startpoint, rec, sizeof(XLogRecPtr));
        appendStringInfo(buf, "%X/%08X", LSN_FORMAT_ARGS(startpoint));
    }
    else if (info == XLOG_PARAMETER_CHANGE)
    {
        xl_parameter_change xlrec;
        const char *wal_level_str;
 
        memcpy(&xlrec, rec, sizeof(xl_parameter_change));
        wal_level_str = get_wal_level_string(xlrec.wal_level);
 
        appendStringInfo(buf, "max_connections=%d max_worker_processes=%d "
                         "max_wal_senders=%d max_prepared_xacts=%d "
                         "max_locks_per_xact=%d wal_level=%s "
                         "wal_log_hints=%s track_commit_timestamp=%s",
                         xlrec.MaxConnections,
                         xlrec.max_worker_processes,
                         xlrec.max_wal_senders,
                         xlrec.max_prepared_xacts,
                         xlrec.max_locks_per_xact,
                         wal_level_str,
                         xlrec.wal_log_hints ? "on" : "off",
                         xlrec.track_commit_timestamp ? "on" : "off");
    }
    else if (info == XLOG_FPW_CHANGE)
    {
        bool        fpw;
 
        memcpy(&fpw, rec, sizeof(bool));
        appendStringInfoString(buf, fpw ? "true" : "false");
    }
    else if (info == XLOG_END_OF_RECOVERY)
    {
        xl_end_of_recovery xlrec;
 
        memcpy(&xlrec, rec, sizeof(xl_end_of_recovery));
        appendStringInfo(buf, "tli %u; prev tli %u; time %s; wal_level %s",
                         xlrec.ThisTimeLineID, xlrec.PrevTimeLineID,
                         timestamptz_to_str(xlrec.end_time),
                         get_wal_level_string(xlrec.wal_level));
    }
    else if (info == XLOG_OVERWRITE_CONTRECORD)
    {
        xl_overwrite_contrecord xlrec;
 
        memcpy(&xlrec, rec, sizeof(xl_overwrite_contrecord));
        appendStringInfo(buf, "lsn %X/%08X; time %s",
                         LSN_FORMAT_ARGS(xlrec.overwritten_lsn),
                         timestamptz_to_str(xlrec.overwrite_time));
    }
    else if (info == XLOG_CHECKPOINT_REDO)
    {
        int         wal_level;
 
        memcpy(&wal_level, rec, sizeof(int));
        appendStringInfo(buf, "wal_level %s", get_wal_level_string(wal_level));
    }
    else if (info == XLOG_LOGICAL_DECODING_STATUS_CHANGE)
    {
        bool        enabled;
 
        memcpy(&enabled, rec, sizeof(bool));
        appendStringInfoString(buf, enabled ? "true" : "false");
    }
}

References appendStringInfo(), appendStringInfoString(), buf, xl_end_of_recovery::end_time, EpochFromFullTransactionId, CheckPoint::fullPageWrites, get_wal_level_string(), CheckPoint::logicalDecodingEnabled, LSN_FORMAT_ARGS, xl_parameter_change::max_locks_per_xact, xl_parameter_change::max_prepared_xacts, xl_parameter_change::max_wal_senders, xl_parameter_change::max_worker_processes, xl_parameter_change::MaxConnections, CheckPoint::newestCommitTsXid, CheckPoint::nextMulti, CheckPoint::nextMultiOffset, CheckPoint::nextOid, CheckPoint::nextXid, CheckPoint::oldestActiveXid, CheckPoint::oldestCommitTsXid, CheckPoint::oldestMulti, CheckPoint::oldestMultiDB, CheckPoint::oldestXid, CheckPoint::oldestXidDB, xl_overwrite_contrecord::overwrite_time, xl_overwrite_contrecord::overwritten_lsn, xl_end_of_recovery::PrevTimeLineID, CheckPoint::PrevTimeLineID, CheckPoint::redo, xl_restore_point::rp_name, xl_end_of_recovery::ThisTimeLineID, CheckPoint::ThisTimeLineID, timestamptz_to_str(), xl_parameter_change::track_commit_timestamp, wal_level, xl_parameter_change::wal_level, xl_end_of_recovery::wal_level, CheckPoint::wal_level, wal_level_str(), xl_parameter_change::wal_log_hints, XidFromFullTransactionId, XLOG_BACKUP_END, XLOG_CHECKPOINT_ONLINE, XLOG_CHECKPOINT_REDO, XLOG_CHECKPOINT_SHUTDOWN, XLOG_END_OF_RECOVERY, XLOG_FPI, XLOG_FPI_FOR_HINT, XLOG_FPW_CHANGE, XLOG_LOGICAL_DECODING_STATUS_CHANGE, XLOG_NEXTOID, XLOG_OVERWRITE_CONTRECORD, XLOG_PARAMETER_CHANGE, XLOG_RESTORE_POINT, XLogRecGetData, and XLogRecGetInfo.

xlog_identify()

const char * xlog_identify

(

uint8

info

)

Definition at line 181 of file xlogdesc.c.

{
    const char *id = NULL;
 
    switch (info & ~XLR_INFO_MASK)
    {
        case XLOG_CHECKPOINT_SHUTDOWN:
            id = "CHECKPOINT_SHUTDOWN";
            break;
        case XLOG_CHECKPOINT_ONLINE:
            id = "CHECKPOINT_ONLINE";
            break;
        case XLOG_NOOP:
            id = "NOOP";
            break;
        case XLOG_NEXTOID:
            id = "NEXTOID";
            break;
        case XLOG_SWITCH:
            id = "SWITCH";
            break;
        case XLOG_BACKUP_END:
            id = "BACKUP_END";
            break;
        case XLOG_PARAMETER_CHANGE:
            id = "PARAMETER_CHANGE";
            break;
        case XLOG_RESTORE_POINT:
            id = "RESTORE_POINT";
            break;
        case XLOG_FPW_CHANGE:
            id = "FPW_CHANGE";
            break;
        case XLOG_END_OF_RECOVERY:
            id = "END_OF_RECOVERY";
            break;
        case XLOG_OVERWRITE_CONTRECORD:
            id = "OVERWRITE_CONTRECORD";
            break;
        case XLOG_FPI:
            id = "FPI";
            break;
        case XLOG_FPI_FOR_HINT:
            id = "FPI_FOR_HINT";
            break;
        case XLOG_CHECKPOINT_REDO:
            id = "CHECKPOINT_REDO";
            break;
        case XLOG_LOGICAL_DECODING_STATUS_CHANGE:
            id = "LOGICAL_DECODING_STATUS_CHANGE";
            break;
    }
 
    return id;
}

References XLOG_BACKUP_END, XLOG_CHECKPOINT_ONLINE, XLOG_CHECKPOINT_REDO, XLOG_CHECKPOINT_SHUTDOWN, XLOG_END_OF_RECOVERY, XLOG_FPI, XLOG_FPI_FOR_HINT, XLOG_FPW_CHANGE, XLOG_LOGICAL_DECODING_STATUS_CHANGE, XLOG_NEXTOID, XLOG_NOOP, XLOG_OVERWRITE_CONTRECORD, XLOG_PARAMETER_CHANGE, XLOG_RESTORE_POINT, XLOG_SWITCH, and XLR_INFO_MASK.

XLogRecGetBlockRefInfo()

void XLogRecGetBlockRefInfo	(	XLogReaderState *	record,
		bool	pretty,
		bool	detailed_format,
		StringInfo	buf,
		uint32 *	fpi_len
	)

Definition at line 242 of file xlogdesc.c.

{
    int         block_id;
 
    Assert(record != NULL);
 
    if (detailed_format && pretty)
        appendStringInfoChar(buf, '\n');
 
    for (block_id = 0; block_id <= XLogRecMaxBlockId(record); block_id++)
    {
        RelFileLocator rlocator;
        ForkNumber  forknum;
        BlockNumber blk;
 
        if (!XLogRecGetBlockTagExtended(record, block_id,
                                        &rlocator, &forknum, &blk, NULL))
            continue;
 
        if (detailed_format)
        {
            /* Get block references in detailed format. */
 
            if (pretty)
                appendStringInfoChar(buf, '\t');
            else if (block_id > 0)
                appendStringInfoChar(buf, ' ');
 
            appendStringInfo(buf,
                             "blkref #%d: rel %u/%u/%u fork %s blk %u",
                             block_id,
                             rlocator.spcOid, rlocator.dbOid, rlocator.relNumber,
                             forkNames[forknum],
                             blk);
 
            if (XLogRecHasBlockImage(record, block_id))
            {
                uint8       bimg_info = XLogRecGetBlock(record, block_id)->bimg_info;
 
                /* Calculate the amount of FPI data in the record. */
                if (fpi_len)
                    *fpi_len += XLogRecGetBlock(record, block_id)->bimg_len;
 
                if (BKPIMAGE_COMPRESSED(bimg_info))
                {
                    const char *method;
 
                    if ((bimg_info & BKPIMAGE_COMPRESS_PGLZ) != 0)
                        method = "pglz";
                    else if ((bimg_info & BKPIMAGE_COMPRESS_LZ4) != 0)
                        method = "lz4";
                    else if ((bimg_info & BKPIMAGE_COMPRESS_ZSTD) != 0)
                        method = "zstd";
                    else
                        method = "unknown";
 
                    appendStringInfo(buf,
                                     " (FPW%s); hole: offset: %u, length: %u, "
                                     "compression saved: %u, method: %s",
                                     XLogRecBlockImageApply(record, block_id) ?
                                     "" : " for WAL verification",
                                     XLogRecGetBlock(record, block_id)->hole_offset,
                                     XLogRecGetBlock(record, block_id)->hole_length,
                                     BLCKSZ -
                                     XLogRecGetBlock(record, block_id)->hole_length -
                                     XLogRecGetBlock(record, block_id)->bimg_len,
                                     method);
                }
                else
                {
                    appendStringInfo(buf,
                                     " (FPW%s); hole: offset: %u, length: %u",
                                     XLogRecBlockImageApply(record, block_id) ?
                                     "" : " for WAL verification",
                                     XLogRecGetBlock(record, block_id)->hole_offset,
                                     XLogRecGetBlock(record, block_id)->hole_length);
                }
            }
 
            if (pretty)
                appendStringInfoChar(buf, '\n');
        }
        else
        {
            /* Get block references in short format. */
 
            if (forknum != MAIN_FORKNUM)
            {
                appendStringInfo(buf,
                                 ", blkref #%d: rel %u/%u/%u fork %s blk %u",
                                 block_id,
                                 rlocator.spcOid, rlocator.dbOid, rlocator.relNumber,
                                 forkNames[forknum],
                                 blk);
            }
            else
            {
                appendStringInfo(buf,
                                 ", blkref #%d: rel %u/%u/%u blk %u",
                                 block_id,
                                 rlocator.spcOid, rlocator.dbOid, rlocator.relNumber,
                                 blk);
            }
 
            if (XLogRecHasBlockImage(record, block_id))
            {
                /* Calculate the amount of FPI data in the record. */
                if (fpi_len)
                    *fpi_len += XLogRecGetBlock(record, block_id)->bimg_len;
 
                if (XLogRecBlockImageApply(record, block_id))
                    appendStringInfoString(buf, " FPW");
                else
                    appendStringInfoString(buf, " FPW for WAL verification");
            }
        }
    }
 
    if (!detailed_format && pretty)
        appendStringInfoChar(buf, '\n');
}

References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), Assert(), BKPIMAGE_COMPRESS_LZ4, BKPIMAGE_COMPRESS_PGLZ, BKPIMAGE_COMPRESS_ZSTD, BKPIMAGE_COMPRESSED, buf, RelFileLocator::dbOid, forkNames, MAIN_FORKNUM, RelFileLocator::relNumber, RelFileLocator::spcOid, XLogRecBlockImageApply, XLogRecGetBlock, XLogRecGetBlockTagExtended(), XLogRecHasBlockImage, and XLogRecMaxBlockId.

Referenced by GetWALRecordInfo(), and XLogDumpDisplayRecord().

Variable Documentation

wal_level_options

const struct config_enum_entry wal_level_options[]

Initial value:

= {
    {"minimal", WAL_LEVEL_MINIMAL, false},
    {"replica", WAL_LEVEL_REPLICA, false},
    {"archive", WAL_LEVEL_REPLICA, true},   
    {"hot_standby", WAL_LEVEL_REPLICA, true},   
    {"logical", WAL_LEVEL_LOGICAL, false},
    {NULL, 0, false}
}

Definition at line 27 of file xlogdesc.c.

Referenced by get_wal_level_string().