PostgreSQL Source Code  git master
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 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

◆ xl_running_xacts

◆ xl_standby_locks

Function Documentation

◆ standby_desc()

void standby_desc ( StringInfo  buf,
XLogReaderState record 
)

Definition at line 40 of file standbydesc.c.

41 {
42  char *rec = XLogRecGetData(record);
43  uint8 info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
44 
45  if (info == XLOG_STANDBY_LOCK)
46  {
47  xl_standby_locks *xlrec = (xl_standby_locks *) rec;
48  int i;
49 
50  for (i = 0; i < xlrec->nlocks; i++)
51  appendStringInfo(buf, "xid %u db %u rel %u ",
52  xlrec->locks[i].xid, xlrec->locks[i].dbOid,
53  xlrec->locks[i].relOid);
54  }
55  else if (info == XLOG_RUNNING_XACTS)
56  {
57  xl_running_xacts *xlrec = (xl_running_xacts *) rec;
58 
60  }
61  else if (info == XLOG_INVALIDATIONS)
62  {
63  xl_invalidations *xlrec = (xl_invalidations *) rec;
64 
65  standby_desc_invalidations(buf, xlrec->nmsgs, xlrec->msgs,
66  xlrec->dbId, xlrec->tsId,
67  xlrec->relcacheInitFileInval);
68  }
69 }
unsigned char uint8
Definition: c.h:439
int i
Definition: isn.c:73
static char * buf
Definition: pg_test_fsync.c:67
#define XLOG_INVALIDATIONS
Definition: standbydefs.h:36
#define XLOG_STANDBY_LOCK
Definition: standbydefs.h:34
#define XLOG_RUNNING_XACTS
Definition: standbydefs.h:35
void standby_desc_invalidations(StringInfo buf, int nmsgs, SharedInvalidationMessage *msgs, Oid dbId, Oid tsId, bool relcacheInitFileInval)
Definition: standbydesc.c:98
static void standby_desc_running_xacts(StringInfo buf, xl_running_xacts *xlrec)
Definition: standbydesc.c:20
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition: stringinfo.c:91
SharedInvalidationMessage msgs[FLEXIBLE_ARRAY_MEMBER]
Definition: standbydefs.h:69
bool relcacheInitFileInval
Definition: standbydefs.h:67
TransactionId xid
Definition: lockdefs.h:51
xl_standby_lock locks[FLEXIBLE_ARRAY_MEMBER]
Definition: standbydefs.h:41
#define XLogRecGetInfo(decoder)
Definition: xlogreader.h:408
#define XLogRecGetData(decoder)
Definition: xlogreader.h:413
#define XLR_INFO_MASK
Definition: xlogrecord.h:62

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, XLogRecGetInfo, and XLR_INFO_MASK.

◆ standby_desc_invalidations()

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

Definition at line 98 of file standbydesc.c.

102 {
103  int i;
104 
105  /* Do nothing if there are no invalidation messages */
106  if (nmsgs <= 0)
107  return;
108 
109  if (relcacheInitFileInval)
110  appendStringInfo(buf, "; relcache init file inval dbid %u tsid %u",
111  dbId, tsId);
112 
113  appendStringInfoString(buf, "; inval msgs:");
114  for (i = 0; i < nmsgs; i++)
115  {
116  SharedInvalidationMessage *msg = &msgs[i];
117 
118  if (msg->id >= 0)
119  appendStringInfo(buf, " catcache %d", msg->id);
120  else if (msg->id == SHAREDINVALCATALOG_ID)
121  appendStringInfo(buf, " catalog %u", msg->cat.catId);
122  else if (msg->id == SHAREDINVALRELCACHE_ID)
123  appendStringInfo(buf, " relcache %u", msg->rc.relId);
124  /* not expected, but print something anyway */
125  else if (msg->id == SHAREDINVALSMGR_ID)
126  appendStringInfoString(buf, " smgr");
127  /* not expected, but print something anyway */
128  else if (msg->id == SHAREDINVALRELMAP_ID)
129  appendStringInfo(buf, " relmap db %u", msg->rm.dbId);
130  else if (msg->id == SHAREDINVALSNAPSHOT_ID)
131  appendStringInfo(buf, " snapshot %u", msg->sn.relId);
132  else
133  appendStringInfo(buf, " unrecognized id %d", msg->id);
134  }
135 }
#define SHAREDINVALCATALOG_ID
Definition: sinval.h:67
#define SHAREDINVALSMGR_ID
Definition: sinval.h:85
#define SHAREDINVALSNAPSHOT_ID
Definition: sinval.h:104
#define SHAREDINVALRELCACHE_ID
Definition: sinval.h:76
#define SHAREDINVALRELMAP_ID
Definition: sinval.h:96
void appendStringInfoString(StringInfo str, const char *s)
Definition: stringinfo.c:176
SharedInvalRelcacheMsg rc
Definition: sinval.h:118
SharedInvalCatalogMsg cat
Definition: sinval.h:117
SharedInvalSnapshotMsg sn
Definition: sinval.h:121
SharedInvalRelmapMsg rm
Definition: sinval.h:120

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 standby_desc(), xact_desc(), xact_desc_commit(), and xact_desc_prepare().

◆ standby_identify()

const char* standby_identify ( uint8  info)

Definition at line 72 of file standbydesc.c.

73 {
74  const char *id = NULL;
75 
76  switch (info & ~XLR_INFO_MASK)
77  {
78  case XLOG_STANDBY_LOCK:
79  id = "LOCK";
80  break;
81  case XLOG_RUNNING_XACTS:
82  id = "RUNNING_XACTS";
83  break;
84  case XLOG_INVALIDATIONS:
85  id = "INVALIDATIONS";
86  break;
87  }
88 
89  return id;
90 }

References XLOG_INVALIDATIONS, XLOG_RUNNING_XACTS, XLOG_STANDBY_LOCK, and XLR_INFO_MASK.

◆ standby_redo()

void standby_redo ( XLogReaderState record)

Definition at line 1105 of file standby.c.

1106 {
1107  uint8 info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
1108 
1109  /* Backup blocks are not used in standby records */
1110  Assert(!XLogRecHasAnyBlockRefs(record));
1111 
1112  /* Do nothing if we're not in hot standby mode */
1114  return;
1115 
1116  if (info == XLOG_STANDBY_LOCK)
1117  {
1118  xl_standby_locks *xlrec = (xl_standby_locks *) XLogRecGetData(record);
1119  int i;
1120 
1121  for (i = 0; i < xlrec->nlocks; i++)
1123  xlrec->locks[i].dbOid,
1124  xlrec->locks[i].relOid);
1125  }
1126  else if (info == XLOG_RUNNING_XACTS)
1127  {
1128  xl_running_xacts *xlrec = (xl_running_xacts *) XLogRecGetData(record);
1129  RunningTransactionsData running;
1130 
1131  running.xcnt = xlrec->xcnt;
1132  running.subxcnt = xlrec->subxcnt;
1133  running.subxid_overflow = xlrec->subxid_overflow;
1134  running.nextXid = xlrec->nextXid;
1135  running.latestCompletedXid = xlrec->latestCompletedXid;
1136  running.oldestRunningXid = xlrec->oldestRunningXid;
1137  running.xids = xlrec->xids;
1138 
1139  ProcArrayApplyRecoveryInfo(&running);
1140  }
1141  else if (info == XLOG_INVALIDATIONS)
1142  {
1143  xl_invalidations *xlrec = (xl_invalidations *) XLogRecGetData(record);
1144 
1146  xlrec->nmsgs,
1147  xlrec->relcacheInitFileInval,
1148  xlrec->dbId,
1149  xlrec->tsId);
1150  }
1151  else
1152  elog(PANIC, "standby_redo: unknown op code %u", info);
1153 }
#define PANIC
Definition: elog.h:36
#define elog(elevel,...)
Definition: elog.h:218
void ProcessCommittedInvalidationMessages(SharedInvalidationMessage *msgs, int nmsgs, bool RelcacheInitFileInval, Oid dbid, Oid tsid)
Definition: inval.c:963
Assert(fmt[strlen(fmt) - 1] !='\n')
void ProcArrayApplyRecoveryInfo(RunningTransactions running)
Definition: procarray.c:1039
void StandbyAcquireAccessExclusiveLock(TransactionId xid, Oid dbOid, Oid relOid)
Definition: standby.c:948
TransactionId oldestRunningXid
Definition: standby.h:83
TransactionId nextXid
Definition: standby.h:82
TransactionId latestCompletedXid
Definition: standby.h:84
TransactionId * xids
Definition: standby.h:86
TransactionId latestCompletedXid
Definition: standbydefs.h:54
TransactionId oldestRunningXid
Definition: standbydefs.h:53
TransactionId xids[FLEXIBLE_ARRAY_MEMBER]
Definition: standbydefs.h:56
TransactionId nextXid
Definition: standbydefs.h:52
#define XLogRecHasAnyBlockRefs(decoder)
Definition: xlogreader.h:415
HotStandbyState standbyState
Definition: xlogutils.c:56
@ STANDBY_DISABLED
Definition: xlogutils.h:49

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, ProcArrayApplyRecoveryInfo(), ProcessCommittedInvalidationMessages(), xl_invalidations::relcacheInitFileInval, xl_standby_lock::relOid, STANDBY_DISABLED, StandbyAcquireAccessExclusiveLock(), standbyState, RunningTransactionsData::subxcnt, xl_running_xacts::subxcnt, RunningTransactionsData::subxid_overflow, xl_running_xacts::subxid_overflow, 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, XLogRecHasAnyBlockRefs, and XLR_INFO_MASK.