PostgreSQL Source Code  git master
inval.h File Reference
#include "access/htup.h"
#include "storage/relfilelocator.h"
#include "utils/relcache.h"
Include dependency graph for inval.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Typedefs

typedef void(* SyscacheCallbackFunction) (Datum arg, int cacheid, uint32 hashvalue)
 
typedef void(* RelcacheCallbackFunction) (Datum arg, Oid relid)
 

Functions

void AcceptInvalidationMessages (void)
 
void AtEOXact_Inval (bool isCommit)
 
void AtEOSubXact_Inval (bool isCommit)
 
void PostPrepare_Inval (void)
 
void CommandEndInvalidationMessages (void)
 
void CacheInvalidateHeapTuple (Relation relation, HeapTuple tuple, HeapTuple newtuple)
 
void CacheInvalidateCatalog (Oid catalogId)
 
void CacheInvalidateRelcache (Relation relation)
 
void CacheInvalidateRelcacheAll (void)
 
void CacheInvalidateRelcacheByTuple (HeapTuple classTuple)
 
void CacheInvalidateRelcacheByRelid (Oid relid)
 
void CacheInvalidateSmgr (RelFileLocatorBackend rlocator)
 
void CacheInvalidateRelmap (Oid databaseId)
 
void CacheRegisterSyscacheCallback (int cacheid, SyscacheCallbackFunction func, Datum arg)
 
void CacheRegisterRelcacheCallback (RelcacheCallbackFunction func, Datum arg)
 
void CallSyscacheCallbacks (int cacheid, uint32 hashvalue)
 
void InvalidateSystemCaches (void)
 
void InvalidateSystemCachesExtended (bool debug_discard)
 
void LogLogicalInvalidations (void)
 

Variables

PGDLLIMPORT int debug_discard_caches
 

Typedef Documentation

◆ RelcacheCallbackFunction

typedef void(* RelcacheCallbackFunction) (Datum arg, Oid relid)

Definition at line 24 of file inval.h.

◆ SyscacheCallbackFunction

typedef void(* SyscacheCallbackFunction) (Datum arg, int cacheid, uint32 hashvalue)

Definition at line 23 of file inval.h.

Function Documentation

◆ AcceptInvalidationMessages()

void AcceptInvalidationMessages ( void  )

Definition at line 806 of file inval.c.

807 {
810 
811  /*----------
812  * Test code to force cache flushes anytime a flush could happen.
813  *
814  * This helps detect intermittent faults caused by code that reads a cache
815  * entry and then performs an action that could invalidate the entry, but
816  * rarely actually does so. This can spot issues that would otherwise
817  * only arise with badly timed concurrent DDL, for example.
818  *
819  * The default debug_discard_caches = 0 does no forced cache flushes.
820  *
821  * If used with CLOBBER_FREED_MEMORY,
822  * debug_discard_caches = 1 (formerly known as CLOBBER_CACHE_ALWAYS)
823  * provides a fairly thorough test that the system contains no cache-flush
824  * hazards. However, it also makes the system unbelievably slow --- the
825  * regression tests take about 100 times longer than normal.
826  *
827  * If you're a glutton for punishment, try
828  * debug_discard_caches = 3 (formerly known as CLOBBER_CACHE_RECURSIVELY).
829  * This slows things by at least a factor of 10000, so I wouldn't suggest
830  * trying to run the entire regression tests that way. It's useful to try
831  * a few simple tests, to make sure that cache reload isn't subject to
832  * internal cache-flush hazards, but after you've done a few thousand
833  * recursive reloads it's unlikely you'll learn more.
834  *----------
835  */
836 #ifdef DISCARD_CACHES_ENABLED
837  {
838  static int recursion_depth = 0;
839 
841  {
842  recursion_depth++;
844  recursion_depth--;
845  }
846  }
847 #endif
848 }
static int recursion_depth
Definition: elog.c:153
void InvalidateSystemCachesExtended(bool debug_discard)
Definition: inval.c:674
void LocalExecuteInvalidationMessage(SharedInvalidationMessage *msg)
Definition: inval.c:705
void InvalidateSystemCaches(void)
Definition: inval.c:792
int debug_discard_caches
Definition: inval.c:240
void ReceiveSharedInvalidMessages(void(*invalFunction)(SharedInvalidationMessage *msg), void(*resetFunction)(void))
Definition: sinval.c:69

References debug_discard_caches, InvalidateSystemCaches(), InvalidateSystemCachesExtended(), LocalExecuteInvalidationMessage(), ReceiveSharedInvalidMessages(), and recursion_depth.

Referenced by apply_handle_commit_internal(), AtStart_Cache(), ConditionalLockDatabaseObject(), ConditionalLockRelation(), ConditionalLockRelationOid(), ConditionalLockSharedObject(), delay_execution_planner(), InitializeSessionUserId(), LockDatabaseObject(), LockRelation(), LockRelationId(), LockRelationOid(), LockSharedObject(), LogicalRepApplyLoop(), pgstat_init_function_usage(), ProcessCatchupInterrupt(), RangeVarGetRelidExtended(), relation_openrv(), relation_openrv_extended(), RemoveRelations(), and write_relcache_init_file().

◆ AtEOSubXact_Inval()

void AtEOSubXact_Inval ( bool  isCommit)

Definition at line 1082 of file inval.c.

1083 {
1084  int my_level;
1086 
1087  /* Quick exit if no messages. */
1088  if (myInfo == NULL)
1089  return;
1090 
1091  /* Also bail out quickly if messages are not for this level. */
1092  my_level = GetCurrentTransactionNestLevel();
1093  if (myInfo->my_level != my_level)
1094  {
1095  Assert(myInfo->my_level < my_level);
1096  return;
1097  }
1098 
1099  if (isCommit)
1100  {
1101  /* If CurrentCmdInvalidMsgs still has anything, fix it */
1103 
1104  /*
1105  * We create invalidation stack entries lazily, so the parent might
1106  * not have one. Instead of creating one, moving all the data over,
1107  * and then freeing our own, we can just adjust the level of our own
1108  * entry.
1109  */
1110  if (myInfo->parent == NULL || myInfo->parent->my_level < my_level - 1)
1111  {
1112  myInfo->my_level--;
1113  return;
1114  }
1115 
1116  /*
1117  * Pass up my inval messages to parent. Notice that we stick them in
1118  * PriorCmdInvalidMsgs, not CurrentCmdInvalidMsgs, since they've
1119  * already been locally processed. (This would trigger the Assert in
1120  * AppendInvalidationMessageSubGroup if the parent's
1121  * CurrentCmdInvalidMsgs isn't empty; but we already checked that in
1122  * PrepareInvalidationState.)
1123  */
1125  &myInfo->PriorCmdInvalidMsgs);
1126 
1127  /* Must readjust parent's CurrentCmdInvalidMsgs indexes now */
1129  &myInfo->parent->PriorCmdInvalidMsgs);
1130 
1131  /* Pending relcache inval becomes parent's problem too */
1132  if (myInfo->RelcacheInitFileInval)
1133  myInfo->parent->RelcacheInitFileInval = true;
1134 
1135  /* Pop the transaction state stack */
1136  transInvalInfo = myInfo->parent;
1137 
1138  /* Need not free anything else explicitly */
1139  pfree(myInfo);
1140  }
1141  else
1142  {
1145 
1146  /* Pop the transaction state stack */
1147  transInvalInfo = myInfo->parent;
1148 
1149  /* Need not free anything else explicitly */
1150  pfree(myInfo);
1151  }
1152 }
#define Assert(condition)
Definition: c.h:858
static void ProcessInvalidationMessages(InvalidationMsgsGroup *group, void(*func)(SharedInvalidationMessage *msg))
Definition: inval.c:514
static TransInvalidationInfo * transInvalInfo
Definition: inval.c:237
static void AppendInvalidationMessages(InvalidationMsgsGroup *dest, InvalidationMsgsGroup *src)
Definition: inval.c:500
#define SetGroupToFollow(targetgroup, priorgroup)
Definition: inval.c:188
void CommandEndInvalidationMessages(void)
Definition: inval.c:1170
void pfree(void *pointer)
Definition: mcxt.c:1520
struct TransInvalidationInfo * parent
Definition: inval.c:222
InvalidationMsgsGroup CurrentCmdInvalidMsgs
Definition: inval.c:228
InvalidationMsgsGroup PriorCmdInvalidMsgs
Definition: inval.c:231
bool RelcacheInitFileInval
Definition: inval.c:234
int GetCurrentTransactionNestLevel(void)
Definition: xact.c:926

References AppendInvalidationMessages(), Assert, CommandEndInvalidationMessages(), TransInvalidationInfo::CurrentCmdInvalidMsgs, GetCurrentTransactionNestLevel(), LocalExecuteInvalidationMessage(), TransInvalidationInfo::my_level, TransInvalidationInfo::parent, pfree(), TransInvalidationInfo::PriorCmdInvalidMsgs, ProcessInvalidationMessages(), TransInvalidationInfo::RelcacheInitFileInval, SetGroupToFollow, and transInvalInfo.

Referenced by AbortSubTransaction(), and CommitSubTransaction().

◆ AtEOXact_Inval()

void AtEOXact_Inval ( bool  isCommit)

Definition at line 1025 of file inval.c.

1026 {
1027  /* Quick exit if no messages */
1028  if (transInvalInfo == NULL)
1029  return;
1030 
1031  /* Must be at top of stack */
1032  Assert(transInvalInfo->my_level == 1 && transInvalInfo->parent == NULL);
1033 
1034  if (isCommit)
1035  {
1036  /*
1037  * Relcache init file invalidation requires processing both before and
1038  * after we send the SI messages. However, we need not do anything
1039  * unless we committed.
1040  */
1043 
1046 
1049 
1052  }
1053  else
1054  {
1057  }
1058 
1059  /* Need not free anything explicitly */
1060  transInvalInfo = NULL;
1061 }
static void ProcessInvalidationMessagesMulti(InvalidationMsgsGroup *group, void(*func)(const SharedInvalidationMessage *msgs, int n))
Definition: inval.c:526
void RelationCacheInitFilePostInvalidate(void)
Definition: relcache.c:6745
void RelationCacheInitFilePreInvalidate(void)
Definition: relcache.c:6720
void SendSharedInvalidMessages(const SharedInvalidationMessage *msgs, int n)
Definition: sinval.c:47

References AppendInvalidationMessages(), Assert, TransInvalidationInfo::CurrentCmdInvalidMsgs, LocalExecuteInvalidationMessage(), TransInvalidationInfo::my_level, TransInvalidationInfo::parent, TransInvalidationInfo::PriorCmdInvalidMsgs, ProcessInvalidationMessages(), ProcessInvalidationMessagesMulti(), RelationCacheInitFilePostInvalidate(), RelationCacheInitFilePreInvalidate(), TransInvalidationInfo::RelcacheInitFileInval, SendSharedInvalidMessages(), and transInvalInfo.

Referenced by AbortTransaction(), CommitTransaction(), and PostPrepare_Inval().

◆ CacheInvalidateCatalog()

void CacheInvalidateCatalog ( Oid  catalogId)

Definition at line 1336 of file inval.c.

1337 {
1338  Oid databaseId;
1339 
1341 
1342  if (IsSharedRelation(catalogId))
1343  databaseId = InvalidOid;
1344  else
1345  databaseId = MyDatabaseId;
1346 
1347  RegisterCatalogInvalidation(databaseId, catalogId);
1348 }
bool IsSharedRelation(Oid relationId)
Definition: catalog.c:243
Oid MyDatabaseId
Definition: globals.c:91
static void PrepareInvalidationState(void)
Definition: inval.c:611
static void RegisterCatalogInvalidation(Oid dbId, Oid catId)
Definition: inval.c:558
#define InvalidOid
Definition: postgres_ext.h:36
unsigned int Oid
Definition: postgres_ext.h:31

References InvalidOid, IsSharedRelation(), MyDatabaseId, PrepareInvalidationState(), and RegisterCatalogInvalidation().

Referenced by finish_heap_swap().

◆ CacheInvalidateHeapTuple()

void CacheInvalidateHeapTuple ( Relation  relation,
HeapTuple  tuple,
HeapTuple  newtuple 
)

Definition at line 1204 of file inval.c.

1207 {
1208  Oid tupleRelId;
1209  Oid databaseId;
1210  Oid relationId;
1211 
1212  /* Do nothing during bootstrap */
1214  return;
1215 
1216  /*
1217  * We only need to worry about invalidation for tuples that are in system
1218  * catalogs; user-relation tuples are never in catcaches and can't affect
1219  * the relcache either.
1220  */
1221  if (!IsCatalogRelation(relation))
1222  return;
1223 
1224  /*
1225  * IsCatalogRelation() will return true for TOAST tables of system
1226  * catalogs, but we don't care about those, either.
1227  */
1228  if (IsToastRelation(relation))
1229  return;
1230 
1231  /*
1232  * If we're not prepared to queue invalidation messages for this
1233  * subtransaction level, get ready now.
1234  */
1236 
1237  /*
1238  * First let the catcache do its thing
1239  */
1240  tupleRelId = RelationGetRelid(relation);
1241  if (RelationInvalidatesSnapshotsOnly(tupleRelId))
1242  {
1243  databaseId = IsSharedRelation(tupleRelId) ? InvalidOid : MyDatabaseId;
1244  RegisterSnapshotInvalidation(databaseId, tupleRelId);
1245  }
1246  else
1247  PrepareToInvalidateCacheTuple(relation, tuple, newtuple,
1249 
1250  /*
1251  * Now, is this tuple one of the primary definers of a relcache entry? See
1252  * comments in file header for deeper explanation.
1253  *
1254  * Note we ignore newtuple here; we assume an update cannot move a tuple
1255  * from being part of one relcache entry to being part of another.
1256  */
1257  if (tupleRelId == RelationRelationId)
1258  {
1259  Form_pg_class classtup = (Form_pg_class) GETSTRUCT(tuple);
1260 
1261  relationId = classtup->oid;
1262  if (classtup->relisshared)
1263  databaseId = InvalidOid;
1264  else
1265  databaseId = MyDatabaseId;
1266  }
1267  else if (tupleRelId == AttributeRelationId)
1268  {
1269  Form_pg_attribute atttup = (Form_pg_attribute) GETSTRUCT(tuple);
1270 
1271  relationId = atttup->attrelid;
1272 
1273  /*
1274  * KLUGE ALERT: we always send the relcache event with MyDatabaseId,
1275  * even if the rel in question is shared (which we can't easily tell).
1276  * This essentially means that only backends in this same database
1277  * will react to the relcache flush request. This is in fact
1278  * appropriate, since only those backends could see our pg_attribute
1279  * change anyway. It looks a bit ugly though. (In practice, shared
1280  * relations can't have schema changes after bootstrap, so we should
1281  * never come here for a shared rel anyway.)
1282  */
1283  databaseId = MyDatabaseId;
1284  }
1285  else if (tupleRelId == IndexRelationId)
1286  {
1287  Form_pg_index indextup = (Form_pg_index) GETSTRUCT(tuple);
1288 
1289  /*
1290  * When a pg_index row is updated, we should send out a relcache inval
1291  * for the index relation. As above, we don't know the shared status
1292  * of the index, but in practice it doesn't matter since indexes of
1293  * shared catalogs can't have such updates.
1294  */
1295  relationId = indextup->indexrelid;
1296  databaseId = MyDatabaseId;
1297  }
1298  else if (tupleRelId == ConstraintRelationId)
1299  {
1300  Form_pg_constraint constrtup = (Form_pg_constraint) GETSTRUCT(tuple);
1301 
1302  /*
1303  * Foreign keys are part of relcache entries, too, so send out an
1304  * inval for the table that the FK applies to.
1305  */
1306  if (constrtup->contype == CONSTRAINT_FOREIGN &&
1307  OidIsValid(constrtup->conrelid))
1308  {
1309  relationId = constrtup->conrelid;
1310  databaseId = MyDatabaseId;
1311  }
1312  else
1313  return;
1314  }
1315  else
1316  return;
1317 
1318  /*
1319  * Yes. We need to register a relcache invalidation event.
1320  */
1321  RegisterRelcacheInvalidation(databaseId, relationId);
1322 }
#define OidIsValid(objectId)
Definition: c.h:775
bool IsToastRelation(Relation relation)
Definition: catalog.c:145
bool IsCatalogRelation(Relation relation)
Definition: catalog.c:103
void PrepareToInvalidateCacheTuple(Relation relation, HeapTuple tuple, HeapTuple newtuple, void(*function)(int, uint32, Oid))
Definition: catcache.c:2250
#define GETSTRUCT(TUP)
Definition: htup_details.h:653
static void RegisterSnapshotInvalidation(Oid dbId, Oid relId)
Definition: inval.c:600
static void RegisterCatcacheInvalidation(int cacheId, uint32 hashValue, Oid dbId)
Definition: inval.c:544
static void RegisterRelcacheInvalidation(Oid dbId, Oid relId)
Definition: inval.c:570
#define IsBootstrapProcessingMode()
Definition: miscadmin.h:454
FormData_pg_attribute * Form_pg_attribute
Definition: pg_attribute.h:209
FormData_pg_class * Form_pg_class
Definition: pg_class.h:153
FormData_pg_constraint * Form_pg_constraint
FormData_pg_index * Form_pg_index
Definition: pg_index.h:70
#define RelationGetRelid(relation)
Definition: rel.h:505
bool RelationInvalidatesSnapshotsOnly(Oid relid)
Definition: syscache.c:601

References GETSTRUCT, InvalidOid, IsBootstrapProcessingMode, IsCatalogRelation(), IsSharedRelation(), IsToastRelation(), MyDatabaseId, OidIsValid, PrepareInvalidationState(), PrepareToInvalidateCacheTuple(), RegisterCatcacheInvalidation(), RegisterRelcacheInvalidation(), RegisterSnapshotInvalidation(), RelationGetRelid, and RelationInvalidatesSnapshotsOnly().

Referenced by AlterDomainAddConstraint(), AlterDomainDropConstraint(), heap_delete(), heap_inplace_update(), heap_insert(), heap_multi_insert(), and heap_update().

◆ CacheInvalidateRelcache()

◆ CacheInvalidateRelcacheAll()

void CacheInvalidateRelcacheAll ( void  )

◆ CacheInvalidateRelcacheByRelid()

void CacheInvalidateRelcacheByRelid ( Oid  relid)

Definition at line 1419 of file inval.c.

1420 {
1421  HeapTuple tup;
1422 
1424 
1425  tup = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
1426  if (!HeapTupleIsValid(tup))
1427  elog(ERROR, "cache lookup failed for relation %u", relid);
1429  ReleaseSysCache(tup);
1430 }
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:224
#define HeapTupleIsValid(tuple)
Definition: htup.h:78
void CacheInvalidateRelcacheByTuple(HeapTuple classTuple)
Definition: inval.c:1396
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:252
void ReleaseSysCache(HeapTuple tuple)
Definition: syscache.c:266
HeapTuple SearchSysCache1(int cacheId, Datum key1)
Definition: syscache.c:218

References CacheInvalidateRelcacheByTuple(), elog, ERROR, HeapTupleIsValid, ObjectIdGetDatum(), PrepareInvalidationState(), ReleaseSysCache(), and SearchSysCache1().

Referenced by ATExecAlterConstraint(), ATExecAttachPartition(), DefineIndex(), DetachPartitionFinalize(), heap_drop_with_catalog(), InvalidatePublicationRels(), ReindexRelationConcurrently(), RemoveStatisticsById(), and StorePartitionBound().

◆ CacheInvalidateRelcacheByTuple()

void CacheInvalidateRelcacheByTuple ( HeapTuple  classTuple)

Definition at line 1396 of file inval.c.

1397 {
1398  Form_pg_class classtup = (Form_pg_class) GETSTRUCT(classTuple);
1399  Oid databaseId;
1400  Oid relationId;
1401 
1403 
1404  relationId = classtup->oid;
1405  if (classtup->relisshared)
1406  databaseId = InvalidOid;
1407  else
1408  databaseId = MyDatabaseId;
1409  RegisterRelcacheInvalidation(databaseId, relationId);
1410 }

References GETSTRUCT, InvalidOid, MyDatabaseId, PrepareInvalidationState(), and RegisterRelcacheInvalidation().

Referenced by CacheInvalidateRelcacheByRelid(), copy_table_data(), CreateTriggerFiringOn(), index_update_stats(), RemoveRoleFromObjectPolicy(), SetRelationHasSubclass(), SetRelationRuleStatus(), and swap_relation_files().

◆ CacheInvalidateRelmap()

void CacheInvalidateRelmap ( Oid  databaseId)

Definition at line 1489 of file inval.c.

1490 {
1492 
1493  msg.rm.id = SHAREDINVALRELMAP_ID;
1494  msg.rm.dbId = databaseId;
1495  /* check AddCatcacheInvalidationMessage() for an explanation */
1496  VALGRIND_MAKE_MEM_DEFINED(&msg, sizeof(msg));
1497 
1498  SendSharedInvalidMessages(&msg, 1);
1499 }
#define VALGRIND_MAKE_MEM_DEFINED(addr, size)
Definition: memdebug.h:26
#define SHAREDINVALRELMAP_ID
Definition: sinval.h:96
SharedInvalRelmapMsg rm
Definition: sinval.h:120

References SharedInvalRelmapMsg::dbId, SharedInvalRelmapMsg::id, SharedInvalidationMessage::rm, SendSharedInvalidMessages(), SHAREDINVALRELMAP_ID, and VALGRIND_MAKE_MEM_DEFINED.

Referenced by write_relmap_file().

◆ CacheInvalidateSmgr()

void CacheInvalidateSmgr ( RelFileLocatorBackend  rlocator)

Definition at line 1459 of file inval.c.

1460 {
1462 
1463  msg.sm.id = SHAREDINVALSMGR_ID;
1464  msg.sm.backend_hi = rlocator.backend >> 16;
1465  msg.sm.backend_lo = rlocator.backend & 0xffff;
1466  msg.sm.rlocator = rlocator.locator;
1467  /* check AddCatcacheInvalidationMessage() for an explanation */
1468  VALGRIND_MAKE_MEM_DEFINED(&msg, sizeof(msg));
1469 
1470  SendSharedInvalidMessages(&msg, 1);
1471 }
#define SHAREDINVALSMGR_ID
Definition: sinval.h:85
RelFileLocator locator
uint16 backend_lo
Definition: sinval.h:92
RelFileLocator rlocator
Definition: sinval.h:93
SharedInvalSmgrMsg sm
Definition: sinval.h:119

References RelFileLocatorBackend::backend, SharedInvalSmgrMsg::backend_hi, SharedInvalSmgrMsg::backend_lo, SharedInvalSmgrMsg::id, RelFileLocatorBackend::locator, SharedInvalSmgrMsg::rlocator, SendSharedInvalidMessages(), SHAREDINVALSMGR_ID, SharedInvalidationMessage::sm, and VALGRIND_MAKE_MEM_DEFINED.

Referenced by smgrdounlinkall(), smgrtruncate(), and vm_extend().

◆ CacheRegisterRelcacheCallback()

void CacheRegisterRelcacheCallback ( RelcacheCallbackFunction  func,
Datum  arg 
)

Definition at line 1558 of file inval.c.

1560 {
1562  elog(FATAL, "out of relcache_callback_list slots");
1563 
1566 
1568 }
#define FATAL
Definition: elog.h:41
static int relcache_callback_count
Definition: inval.c:273
static struct RELCACHECALLBACK relcache_callback_list[MAX_RELCACHE_CALLBACKS]
#define MAX_RELCACHE_CALLBACKS
Definition: inval.c:253
void * arg
RelcacheCallbackFunction function
Definition: inval.c:269

References RELCACHECALLBACK::arg, arg, elog, FATAL, RELCACHECALLBACK::function, MAX_RELCACHE_CALLBACKS, relcache_callback_count, and relcache_callback_list.

Referenced by init_rel_sync_cache(), InitializeRelfilenumberMap(), InitPlanCache(), logicalrep_partmap_init(), logicalrep_relmap_init(), and lookup_type_cache().

◆ CacheRegisterSyscacheCallback()

void CacheRegisterSyscacheCallback ( int  cacheid,
SyscacheCallbackFunction  func,
Datum  arg 
)

Definition at line 1516 of file inval.c.

1519 {
1520  if (cacheid < 0 || cacheid >= SysCacheSize)
1521  elog(FATAL, "invalid cache ID: %d", cacheid);
1523  elog(FATAL, "out of syscache_callback_list slots");
1524 
1525  if (syscache_callback_links[cacheid] == 0)
1526  {
1527  /* first callback for this cache */
1529  }
1530  else
1531  {
1532  /* add to end of chain, so that older callbacks are called first */
1533  int i = syscache_callback_links[cacheid] - 1;
1534 
1535  while (syscache_callback_list[i].link > 0)
1536  i = syscache_callback_list[i].link - 1;
1538  }
1539 
1544 
1546 }
static struct SYSCACHECALLBACK syscache_callback_list[MAX_SYSCACHE_CALLBACKS]
#define MAX_SYSCACHE_CALLBACKS
Definition: inval.c:252
static int16 syscache_callback_links[SysCacheSize]
Definition: inval.c:263
static int syscache_callback_count
Definition: inval.c:265
int i
Definition: isn.c:73
SyscacheCallbackFunction function
Definition: inval.c:259
int16 link
Definition: inval.c:258

References SYSCACHECALLBACK::arg, arg, elog, FATAL, SYSCACHECALLBACK::function, i, SYSCACHECALLBACK::id, SYSCACHECALLBACK::link, MAX_SYSCACHE_CALLBACKS, syscache_callback_count, syscache_callback_links, and syscache_callback_list.

Referenced by BuildEventTriggerCache(), find_oper_cache_entry(), GetConnection(), init_rel_sync_cache(), init_ts_config_cache(), initialize_acl(), InitializeAttoptCache(), InitializeLogRepWorker(), InitializeSearchPath(), InitializeShippableCache(), InitializeTableSpaceCache(), InitPlanCache(), lookup_proof_cache(), lookup_ts_dictionary_cache(), lookup_ts_parser_cache(), lookup_type_cache(), ParallelApplyWorkerMain(), pgoutput_startup(), ri_InitHashTables(), SetupApplyOrSyncWorker(), and superuser_arg().

◆ CallSyscacheCallbacks()

void CallSyscacheCallbacks ( int  cacheid,
uint32  hashvalue 
)

Definition at line 1577 of file inval.c.

1578 {
1579  int i;
1580 
1581  if (cacheid < 0 || cacheid >= SysCacheSize)
1582  elog(ERROR, "invalid cache ID: %d", cacheid);
1583 
1584  i = syscache_callback_links[cacheid] - 1;
1585  while (i >= 0)
1586  {
1587  struct SYSCACHECALLBACK *ccitem = syscache_callback_list + i;
1588 
1589  Assert(ccitem->id == cacheid);
1590  ccitem->function(ccitem->arg, cacheid, hashvalue);
1591  i = ccitem->link - 1;
1592  }
1593 }

References SYSCACHECALLBACK::arg, Assert, elog, ERROR, SYSCACHECALLBACK::function, i, SYSCACHECALLBACK::id, SYSCACHECALLBACK::link, syscache_callback_links, and syscache_callback_list.

Referenced by CatalogCacheFlushCatalog(), and LocalExecuteInvalidationMessage().

◆ CommandEndInvalidationMessages()

void CommandEndInvalidationMessages ( void  )

Definition at line 1170 of file inval.c.

1171 {
1172  /*
1173  * You might think this shouldn't be called outside any transaction, but
1174  * bootstrap does it, and also ABORT issued when not in a transaction. So
1175  * just quietly return if no state to work on.
1176  */
1177  if (transInvalInfo == NULL)
1178  return;
1179 
1182 
1183  /* WAL Log per-command invalidation messages for wal_level=logical */
1184  if (XLogLogicalInfoActive())
1186 
1189 }
void LogLogicalInvalidations(void)
Definition: inval.c:1604
#define XLogLogicalInfoActive()
Definition: xlog.h:124

References AppendInvalidationMessages(), TransInvalidationInfo::CurrentCmdInvalidMsgs, LocalExecuteInvalidationMessage(), LogLogicalInvalidations(), TransInvalidationInfo::PriorCmdInvalidMsgs, ProcessInvalidationMessages(), transInvalInfo, and XLogLogicalInfoActive.

Referenced by AtCCI_LocalCache(), and AtEOSubXact_Inval().

◆ InvalidateSystemCaches()

◆ InvalidateSystemCachesExtended()

void InvalidateSystemCachesExtended ( bool  debug_discard)

Definition at line 674 of file inval.c.

675 {
676  int i;
677 
680  RelationCacheInvalidate(debug_discard); /* gets smgr and relmap too */
681 
682  for (i = 0; i < syscache_callback_count; i++)
683  {
684  struct SYSCACHECALLBACK *ccitem = syscache_callback_list + i;
685 
686  ccitem->function(ccitem->arg, ccitem->id, 0);
687  }
688 
689  for (i = 0; i < relcache_callback_count; i++)
690  {
691  struct RELCACHECALLBACK *ccitem = relcache_callback_list + i;
692 
693  ccitem->function(ccitem->arg, InvalidOid);
694  }
695 }
void ResetCatalogCaches(void)
Definition: catcache.c:753
void RelationCacheInvalidate(bool debug_discard)
Definition: relcache.c:2973
void InvalidateCatalogSnapshot(void)
Definition: snapmgr.c:422

References SYSCACHECALLBACK::arg, RELCACHECALLBACK::arg, SYSCACHECALLBACK::function, RELCACHECALLBACK::function, i, SYSCACHECALLBACK::id, InvalidateCatalogSnapshot(), InvalidOid, RelationCacheInvalidate(), relcache_callback_count, relcache_callback_list, ResetCatalogCaches(), syscache_callback_count, and syscache_callback_list.

Referenced by AcceptInvalidationMessages(), and InvalidateSystemCaches().

◆ LogLogicalInvalidations()

void LogLogicalInvalidations ( void  )

Definition at line 1604 of file inval.c.

1605 {
1606  xl_xact_invals xlrec;
1607  InvalidationMsgsGroup *group;
1608  int nmsgs;
1609 
1610  /* Quick exit if we haven't done anything with invalidation messages. */
1611  if (transInvalInfo == NULL)
1612  return;
1613 
1615  nmsgs = NumMessagesInGroup(group);
1616 
1617  if (nmsgs > 0)
1618  {
1619  /* prepare record */
1620  memset(&xlrec, 0, MinSizeOfXactInvals);
1621  xlrec.nmsgs = nmsgs;
1622 
1623  /* perform insertion */
1624  XLogBeginInsert();
1625  XLogRegisterData((char *) (&xlrec), MinSizeOfXactInvals);
1627  XLogRegisterData((char *) msgs,
1628  n * sizeof(SharedInvalidationMessage)));
1630  XLogRegisterData((char *) msgs,
1631  n * sizeof(SharedInvalidationMessage)));
1632  XLogInsert(RM_XACT_ID, XLOG_XACT_INVALIDATIONS);
1633  }
1634 }
#define NumMessagesInGroup(group)
Definition: inval.c:197
#define CatCacheMsgs
Definition: inval.c:161
#define ProcessMessageSubGroupMulti(group, subgroup, codeFragment)
Definition: inval.c:372
#define RelCacheMsgs
Definition: inval.c:162
int nmsgs
Definition: xact.h:298
#define MinSizeOfXactInvals
Definition: xact.h:301
#define XLOG_XACT_INVALIDATIONS
Definition: xact.h:175
void XLogRegisterData(char *data, uint32 len)
Definition: xloginsert.c:364
XLogRecPtr XLogInsert(RmgrId rmid, uint8 info)
Definition: xloginsert.c:474
void XLogBeginInsert(void)
Definition: xloginsert.c:149

References CatCacheMsgs, TransInvalidationInfo::CurrentCmdInvalidMsgs, MinSizeOfXactInvals, xl_xact_invals::nmsgs, NumMessagesInGroup, ProcessMessageSubGroupMulti, RelCacheMsgs, transInvalInfo, XLOG_XACT_INVALIDATIONS, XLogBeginInsert(), XLogInsert(), and XLogRegisterData().

Referenced by CommandEndInvalidationMessages(), and RecordTransactionCommit().

◆ PostPrepare_Inval()

void PostPrepare_Inval ( void  )

Definition at line 863 of file inval.c.

864 {
865  AtEOXact_Inval(false);
866 }
void AtEOXact_Inval(bool isCommit)
Definition: inval.c:1025

References AtEOXact_Inval().

Referenced by PrepareTransaction().

Variable Documentation

◆ debug_discard_caches

PGDLLIMPORT int debug_discard_caches
extern

Definition at line 240 of file inval.c.

Referenced by AcceptInvalidationMessages(), LookupOpclassInfo(), and RelationBuildDesc().