#include "access/xlogreader.h"
#include "lib/stringinfo.h"
#include "storage/lockdefs.h"
#include "storage/sinval.h"

Include dependency graph for standbydefs.h:

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

Go to the source code of this file.

Data Structures
struct	xl_standby_locks

struct	xl_running_xacts

struct	xl_invalidations

Macros
#define	XLOG_STANDBY_LOCK 0x00

#define	XLOG_RUNNING_XACTS 0x10

#define	XLOG_INVALIDATIONS 0x20

#define	MinSizeOfInvalidations offsetof(xl_invalidations, msgs)

Typedefs
typedef struct xl_standby_locks	xl_standby_locks

typedef struct xl_running_xacts	xl_running_xacts

typedef struct xl_invalidations	xl_invalidations

Functions
void	standby_redo (XLogReaderState *record)

void	standby_desc (StringInfo buf, XLogReaderState *record)

const char *	standby_identify (uint8 info)

void	standby_desc_invalidations (StringInfo buf, int nmsgs, SharedInvalidationMessage *msgs, Oid dbId, Oid tsId, bool relcacheInitFileInval)

Macro Definition Documentation

◆ MinSizeOfInvalidations

#define MinSizeOfInvalidations offsetof(xl_invalidations, msgs)

Definition at line 72 of file standbydefs.h.

◆ XLOG_INVALIDATIONS

#define XLOG_INVALIDATIONS 0x20

Definition at line 36 of file standbydefs.h.

◆ XLOG_RUNNING_XACTS

#define XLOG_RUNNING_XACTS 0x10

Definition at line 35 of file standbydefs.h.

◆ XLOG_STANDBY_LOCK

#define XLOG_STANDBY_LOCK 0x00

Definition at line 34 of file standbydefs.h.

Typedef Documentation

◆ xl_invalidations

typedef struct xl_invalidations xl_invalidations

◆ xl_running_xacts

typedef struct xl_running_xacts xl_running_xacts

◆ xl_standby_locks

typedef struct xl_standby_locks xl_standby_locks

Function Documentation

◆ standby_desc()

void standby_desc	(	StringInfo	buf,
		XLogReaderState *	record
	)

Definition at line 47 of file standbydesc.c.

{
    char       *rec = XLogRecGetData(record);
    uint8       info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
 
    if (info == XLOG_STANDBY_LOCK)
    {
        xl_standby_locks *xlrec = (xl_standby_locks *) rec;
        int         i;
 
        for (i = 0; i < xlrec->nlocks; i++)
            appendStringInfo(buf, "xid %u db %u rel %u ",
                             xlrec->locks[i].xid, xlrec->locks[i].dbOid,
                             xlrec->locks[i].relOid);
    }
    else if (info == XLOG_RUNNING_XACTS)
    {
        xl_running_xacts *xlrec = (xl_running_xacts *) rec;
 
        standby_desc_running_xacts(buf, xlrec);
    }
    else if (info == XLOG_INVALIDATIONS)
    {
        xl_invalidations *xlrec = (xl_invalidations *) rec;
 
        standby_desc_invalidations(buf, xlrec->nmsgs, xlrec->msgs,
                                   xlrec->dbId, xlrec->tsId,
                                   xlrec->relcacheInitFileInval);
    }
}

References appendStringInfo(), buf, xl_invalidations::dbId, xl_standby_lock::dbOid, i, xl_standby_locks::locks, xl_invalidations::msgs, xl_standby_locks::nlocks, xl_invalidations::nmsgs, xl_invalidations::relcacheInitFileInval, xl_standby_lock::relOid, standby_desc_invalidations(), standby_desc_running_xacts(), xl_invalidations::tsId, xl_standby_lock::xid, XLOG_INVALIDATIONS, XLOG_RUNNING_XACTS, XLOG_STANDBY_LOCK, XLogRecGetData, and XLogRecGetInfo.

◆ standby_desc_invalidations()

void standby_desc_invalidations	(	StringInfo	buf,
		int	nmsgs,
		SharedInvalidationMessage *	msgs,
		Oid	dbId,
		Oid	tsId,
		bool	relcacheInitFileInval
	)

Definition at line 101 of file standbydesc.c.

{
    int         i;
 
    /* Do nothing if there are no invalidation messages */
    if (nmsgs <= 0)
        return;
 
    if (relcacheInitFileInval)
        appendStringInfo(buf, "; relcache init file inval dbid %u tsid %u",
                         dbId, tsId);
 
    appendStringInfoString(buf, "; inval msgs:");
    for (i = 0; i < nmsgs; i++)
    {
        SharedInvalidationMessage *msg = &msgs[i];
 
        if (msg->id >= 0)
            appendStringInfo(buf, " catcache %d", msg->id);
        else if (msg->id == SHAREDINVALCATALOG_ID)
            appendStringInfo(buf, " catalog %u", msg->cat.catId);
        else if (msg->id == SHAREDINVALRELCACHE_ID)
            appendStringInfo(buf, " relcache %u", msg->rc.relId);
        /* not expected, but print something anyway */
        else if (msg->id == SHAREDINVALSMGR_ID)
            appendStringInfoString(buf, " smgr");
        /* not expected, but print something anyway */
        else if (msg->id == SHAREDINVALRELMAP_ID)
            appendStringInfo(buf, " relmap db %u", msg->rm.dbId);
        else if (msg->id == SHAREDINVALSNAPSHOT_ID)
            appendStringInfo(buf, " snapshot %u", msg->sn.relId);
        else
            appendStringInfo(buf, " unrecognized id %d", msg->id);
    }
}

References appendStringInfo(), appendStringInfoString(), buf, SharedInvalidationMessage::cat, SharedInvalCatalogMsg::catId, SharedInvalRelmapMsg::dbId, i, SharedInvalidationMessage::id, SharedInvalidationMessage::rc, SharedInvalRelcacheMsg::relId, SharedInvalSnapshotMsg::relId, SharedInvalidationMessage::rm, SHAREDINVALCATALOG_ID, SHAREDINVALRELCACHE_ID, SHAREDINVALRELMAP_ID, SHAREDINVALSMGR_ID, SHAREDINVALSNAPSHOT_ID, and SharedInvalidationMessage::sn.

Referenced by heap_desc(), standby_desc(), xact_desc(), xact_desc_commit(), and xact_desc_prepare().

◆ standby_identify()

const char * standby_identify ( uint8 info )

Definition at line 79 of file standbydesc.c.

{
    const char *id = NULL;
 
    switch (info & ~XLR_INFO_MASK)
    {
        case XLOG_STANDBY_LOCK:
            id = "LOCK";
            break;
        case XLOG_RUNNING_XACTS:
            id = "RUNNING_XACTS";
            break;
        case XLOG_INVALIDATIONS:
            id = "INVALIDATIONS";
            break;
    }
 
    return id;
}

References XLOG_INVALIDATIONS, XLOG_RUNNING_XACTS, XLOG_STANDBY_LOCK, and XLR_INFO_MASK.

◆ standby_redo()

void standby_redo ( XLogReaderState * record )

Definition at line 1162 of file standby.c.

{
    uint8       info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
 
    /* Backup blocks are not used in standby records */
    Assert(!XLogRecHasAnyBlockRefs(record));
 
    /* Do nothing if we're not in hot standby mode */
    if (standbyState == STANDBY_DISABLED)
        return;
 
    if (info == XLOG_STANDBY_LOCK)
    {
        xl_standby_locks *xlrec = (xl_standby_locks *) XLogRecGetData(record);
        int         i;
 
        for (i = 0; i < xlrec->nlocks; i++)
            StandbyAcquireAccessExclusiveLock(xlrec->locks[i].xid,
                                              xlrec->locks[i].dbOid,
                                              xlrec->locks[i].relOid);
    }
    else if (info == XLOG_RUNNING_XACTS)
    {
        xl_running_xacts *xlrec = (xl_running_xacts *) XLogRecGetData(record);
        RunningTransactionsData running;
 
        running.xcnt = xlrec->xcnt;
        running.subxcnt = xlrec->subxcnt;
        running.subxid_status = xlrec->subxid_overflow ? SUBXIDS_MISSING : SUBXIDS_IN_ARRAY;
        running.nextXid = xlrec->nextXid;
        running.latestCompletedXid = xlrec->latestCompletedXid;
        running.oldestRunningXid = xlrec->oldestRunningXid;
        running.xids = xlrec->xids;
 
        ProcArrayApplyRecoveryInfo(&running);
 
        /*
         * The startup process currently has no convenient way to schedule
         * stats to be reported. XLOG_RUNNING_XACTS records issued at a
         * regular cadence, making this a convenient location to report stats.
         * While these records aren't generated with wal_level=minimal, stats
         * also cannot be accessed during WAL replay.
         */
        pgstat_report_stat(true);
    }
    else if (info == XLOG_INVALIDATIONS)
    {
        xl_invalidations *xlrec = (xl_invalidations *) XLogRecGetData(record);
 
        ProcessCommittedInvalidationMessages(xlrec->msgs,
                                             xlrec->nmsgs,
                                             xlrec->relcacheInitFileInval,
                                             xlrec->dbId,
                                             xlrec->tsId);
    }
    else
        elog(PANIC, "standby_redo: unknown op code %u", info);
}

References Assert, xl_invalidations::dbId, xl_standby_lock::dbOid, elog, i, RunningTransactionsData::latestCompletedXid, xl_running_xacts::latestCompletedXid, xl_standby_locks::locks, xl_invalidations::msgs, RunningTransactionsData::nextXid, xl_running_xacts::nextXid, xl_standby_locks::nlocks, xl_invalidations::nmsgs, RunningTransactionsData::oldestRunningXid, xl_running_xacts::oldestRunningXid, PANIC, pgstat_report_stat(), ProcArrayApplyRecoveryInfo(), ProcessCommittedInvalidationMessages(), xl_invalidations::relcacheInitFileInval, xl_standby_lock::relOid, STANDBY_DISABLED, StandbyAcquireAccessExclusiveLock(), standbyState, RunningTransactionsData::subxcnt, xl_running_xacts::subxcnt, xl_running_xacts::subxid_overflow, RunningTransactionsData::subxid_status, SUBXIDS_IN_ARRAY, SUBXIDS_MISSING, xl_invalidations::tsId, RunningTransactionsData::xcnt, xl_running_xacts::xcnt, xl_standby_lock::xid, RunningTransactionsData::xids, xl_running_xacts::xids, XLOG_INVALIDATIONS, XLOG_RUNNING_XACTS, XLOG_STANDBY_LOCK, XLogRecGetData, XLogRecGetInfo, and XLogRecHasAnyBlockRefs.

Data Structures

Macros

Typedefs

Functions