standbydefs.h File Reference

#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 73 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  )

extern

Definition at line 49 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, fb(), i, standby_desc_invalidations(), standby_desc_running_xacts(), 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  )

extern

Definition at line 103 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 if (msg->id == SHAREDINVALRELSYNC_ID)
            appendStringInfo(buf, " relsync %u", msg->rs.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, SharedInvalRelSyncMsg::relid, SharedInvalidationMessage::rm, SharedInvalidationMessage::rs, SHAREDINVALCATALOG_ID, SHAREDINVALRELCACHE_ID, SHAREDINVALRELMAP_ID, SHAREDINVALRELSYNC_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 )

extern

Definition at line 81 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 fb(), XLOG_INVALIDATIONS, XLOG_RUNNING_XACTS, XLOG_STANDBY_LOCK, and XLR_INFO_MASK.

standby_redo()

void standby_redo ( XLogReaderState *  record )

extern

Definition at line 1165 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;
 
        /*
         * Records issued for specific database are not suitable for physical
         * replication because that affects the whole cluster. In particular,
         * the list of XID is probably incomplete here.
         */
        if (OidIsValid(xlrec->dbid))
            return;
 
        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, elog, fb(), i, RunningTransactionsData::latestCompletedXid, RunningTransactionsData::nextXid, OidIsValid, RunningTransactionsData::oldestRunningXid, PANIC, pgstat_report_stat(), ProcArrayApplyRecoveryInfo(), ProcessCommittedInvalidationMessages(), STANDBY_DISABLED, StandbyAcquireAccessExclusiveLock(), standbyState, RunningTransactionsData::subxcnt, RunningTransactionsData::subxid_status, SUBXIDS_IN_ARRAY, SUBXIDS_MISSING, RunningTransactionsData::xcnt, RunningTransactionsData::xids, XLOG_INVALIDATIONS, XLOG_RUNNING_XACTS, XLOG_STANDBY_LOCK, XLogRecGetData, XLogRecGetInfo, and XLogRecHasAnyBlockRefs.