#include "postgres.h"
#include <limits.h>
#include "access/htup_details.h"
#include "access/xact.h"
#include "catalog/catalog.h"
#include "catalog/pg_constraint.h"
#include "miscadmin.h"
#include "storage/sinval.h"
#include "storage/smgr.h"
#include "utils/catcache.h"
#include "utils/inval.h"
#include "utils/memdebug.h"
#include "utils/memutils.h"
#include "utils/rel.h"
#include "utils/relmapper.h"
#include "utils/snapmgr.h"
#include "utils/syscache.h"

Include dependency graph for inval.c:

Data Structures
struct	InvalidationChunk

struct	InvalidationListHeader

struct	TransInvalidationInfo

struct	SYSCACHECALLBACK

struct	RELCACHECALLBACK

Macros
#define	MAX_SYSCACHE_CALLBACKS 64

#define	MAX_RELCACHE_CALLBACKS 10

#define	FIRSTCHUNKSIZE 32

#define	ProcessMessageList(listHdr, codeFragment)

#define	ProcessMessageListMulti(listHdr, codeFragment)

Typedefs
typedef struct InvalidationChunk	InvalidationChunk

typedef struct InvalidationListHeader	InvalidationListHeader

typedef struct TransInvalidationInfo	TransInvalidationInfo

Functions
static void	AddInvalidationMessage (InvalidationChunk *listHdr, SharedInvalidationMessage msg)

static void	AppendInvalidationMessageList (InvalidationChunk destHdr, InvalidationChunk srcHdr)

static void	AddCatcacheInvalidationMessage (InvalidationListHeader *hdr, int id, uint32 hashValue, Oid dbId)

static void	AddCatalogInvalidationMessage (InvalidationListHeader *hdr, Oid dbId, Oid catId)

static void	AddRelcacheInvalidationMessage (InvalidationListHeader *hdr, Oid dbId, Oid relId)

static void	AddSnapshotInvalidationMessage (InvalidationListHeader *hdr, Oid dbId, Oid relId)

static void	AppendInvalidationMessages (InvalidationListHeader dest, InvalidationListHeader src)

static void	ProcessInvalidationMessages (InvalidationListHeader hdr, void(func)(SharedInvalidationMessage *msg))

static void	ProcessInvalidationMessagesMulti (InvalidationListHeader hdr, void(func)(const SharedInvalidationMessage *msgs, int n))

static void	RegisterCatcacheInvalidation (int cacheId, uint32 hashValue, Oid dbId)

static void	RegisterCatalogInvalidation (Oid dbId, Oid catId)

static void	RegisterRelcacheInvalidation (Oid dbId, Oid relId)

static void	RegisterSnapshotInvalidation (Oid dbId, Oid relId)

void	LocalExecuteInvalidationMessage (SharedInvalidationMessage *msg)

void	InvalidateSystemCaches (void)

void	AcceptInvalidationMessages (void)

static void	PrepareInvalidationState (void)

void	PostPrepare_Inval (void)

static void	MakeSharedInvalidMessagesArray (const SharedInvalidationMessage *msgs, int n)

int	xactGetCommittedInvalidationMessages (SharedInvalidationMessage *msgs, bool RelcacheInitFileInval)

void	ProcessCommittedInvalidationMessages (SharedInvalidationMessage *msgs, int nmsgs, bool RelcacheInitFileInval, Oid dbid, Oid tsid)

void	AtEOXact_Inval (bool isCommit)

void	AtEOSubXact_Inval (bool isCommit)

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 (RelFileNodeBackend rnode)

void	CacheInvalidateRelmap (Oid databaseId)

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

void	CacheRegisterRelcacheCallback (RelcacheCallbackFunction func, Datum arg)

void	CallSyscacheCallbacks (int cacheid, uint32 hashvalue)

Variables
static TransInvalidationInfo *	transInvalInfo = NULL

static SharedInvalidationMessage *	SharedInvalidMessagesArray

static int	numSharedInvalidMessagesArray

static int	maxSharedInvalidMessagesArray

static struct SYSCACHECALLBACK	syscache_callback_list [MAX_SYSCACHE_CALLBACKS]

static int16	syscache_callback_links [SysCacheSize]

static int	syscache_callback_count = 0

static struct RELCACHECALLBACK	relcache_callback_list [MAX_RELCACHE_CALLBACKS]

static int	relcache_callback_count = 0

Macro Definition Documentation

◆ FIRSTCHUNKSIZE

#define FIRSTCHUNKSIZE 32

Referenced by AddInvalidationMessage(), and MakeSharedInvalidMessagesArray().

◆ MAX_RELCACHE_CALLBACKS

#define MAX_RELCACHE_CALLBACKS 10

Definition at line 191 of file inval.c.

Referenced by CacheRegisterRelcacheCallback().

◆ MAX_SYSCACHE_CALLBACKS

#define MAX_SYSCACHE_CALLBACKS 64

Definition at line 190 of file inval.c.

Referenced by CacheRegisterSyscacheCallback().

◆ ProcessMessageList

#define ProcessMessageList	(	listHdr,
		codeFragment
	)

Value:

do { \
        InvalidationChunk *_chunk; \
        for (_chunk = (listHdr); _chunk != NULL; _chunk = _chunk->next) \
        { \
            int     _cindex; \
            for (_cindex = 0; _cindex < _chunk->nitems; _cindex++) \
            { \
                SharedInvalidationMessage *msg = &_chunk->msgs[_cindex]; \
                codeFragment; \
            } \
        } \
    } while (0)

Definition at line 295 of file inval.c.

Referenced by AddRelcacheInvalidationMessage(), AddSnapshotInvalidationMessage(), and ProcessInvalidationMessages().

◆ ProcessMessageListMulti

#define ProcessMessageListMulti	(	listHdr,
		codeFragment
	)

Value:

do { \
        InvalidationChunk *_chunk; \
        for (_chunk = (listHdr); _chunk != NULL; _chunk = _chunk->next) \
        { \
            SharedInvalidationMessage *msgs = _chunk->msgs; \
            int     n = _chunk->nitems; \
            codeFragment; \
        } \
    } while (0)

Definition at line 315 of file inval.c.

Referenced by ProcessInvalidationMessagesMulti().

Typedef Documentation

◆ InvalidationChunk

typedef struct InvalidationChunk InvalidationChunk

◆ InvalidationListHeader

typedef struct InvalidationListHeader InvalidationListHeader

◆ TransInvalidationInfo

typedef struct TransInvalidationInfo TransInvalidationInfo

Function Documentation

◆ AcceptInvalidationMessages()

void AcceptInvalidationMessages ( void )

Definition at line 681 of file inval.c.

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

Referenced by apply_handle_commit(), AtStart_Cache(), ConditionalLockRelation(), ConditionalLockRelationOid(), InitializeSessionUserId(), LockDatabaseObject(), LockRelation(), LockRelationOid(), LockSharedObject(), LogicalRepApplyLoop(), ProcessCatchupInterrupt(), RangeVarGetRelidExtended(), relation_openrv(), relation_openrv_extended(), RemoveRelations(), and write_relcache_init_file().

 {
     ReceiveSharedInvalidMessages(LocalExecuteInvalidationMessage,
                                  InvalidateSystemCaches);
 
     /*
      * Test code to force cache flushes anytime a flush could happen.
      *
      * If used with CLOBBER_FREED_MEMORY, CLOBBER_CACHE_ALWAYS provides a
      * fairly thorough test that the system contains no cache-flush hazards.
      * However, it also makes the system unbelievably slow --- the regression
      * tests take about 100 times longer than normal.
      *
      * If you're a glutton for punishment, try CLOBBER_CACHE_RECURSIVELY. This
      * slows things by at least a factor of 10000, so I wouldn't suggest
      * trying to run the entire regression tests that way.  It's useful to try
      * a few simple tests, to make sure that cache reload isn't subject to
      * internal cache-flush hazards, but after you've done a few thousand
      * recursive reloads it's unlikely you'll learn more.
      */
 #if defined(CLOBBER_CACHE_ALWAYS)
     {
         static bool in_recursion = false;
 
         if (!in_recursion)
         {
             in_recursion = true;
             InvalidateSystemCaches();
             in_recursion = false;
         }
     }
 #elif defined(CLOBBER_CACHE_RECURSIVELY)
     {
         static int  recursion_depth = 0;
 
         /* Maximum depth is arbitrary depending on your threshold of pain */
         if (recursion_depth < 3)
         {
             recursion_depth++;
             InvalidateSystemCaches();
             recursion_depth--;
         }
     }
 #endif
 }

◆ AddCatalogInvalidationMessage()

static void AddCatalogInvalidationMessage	(	InvalidationListHeader *	hdr,
		Oid	dbId,
		Oid	catId
	)

static

Definition at line 367 of file inval.c.

References AddInvalidationMessage(), SharedInvalidationMessage::cat, SharedInvalCatalogMsg::catId, InvalidationListHeader::cclist, SharedInvalCatalogMsg::dbId, SharedInvalCatalogMsg::id, SHAREDINVALCATALOG_ID, and VALGRIND_MAKE_MEM_DEFINED.

Referenced by RegisterCatalogInvalidation().

 {
     SharedInvalidationMessage msg;
 
     msg.cat.id = SHAREDINVALCATALOG_ID;
     msg.cat.dbId = dbId;
     msg.cat.catId = catId;
     /* check AddCatcacheInvalidationMessage() for an explanation */
     VALGRIND_MAKE_MEM_DEFINED(&msg, sizeof(msg));
 
     AddInvalidationMessage(&hdr->cclist, &msg);
 }

◆ AddCatcacheInvalidationMessage()

static void AddCatcacheInvalidationMessage	(	InvalidationListHeader *	hdr,
		int	id,
		uint32	hashValue,
		Oid	dbId
	)

static

Definition at line 339 of file inval.c.

References AddInvalidationMessage(), Assert, SharedInvalidationMessage::cc, InvalidationListHeader::cclist, SharedInvalCatcacheMsg::dbId, SharedInvalCatcacheMsg::hashValue, SharedInvalCatcacheMsg::id, and VALGRIND_MAKE_MEM_DEFINED.

Referenced by RegisterCatcacheInvalidation().

 {
     SharedInvalidationMessage msg;
 
     Assert(id < CHAR_MAX);
     msg.cc.id = (int8) id;
     msg.cc.dbId = dbId;
     msg.cc.hashValue = hashValue;
 
     /*
      * Define padding bytes in SharedInvalidationMessage structs to be
      * defined. Otherwise the sinvaladt.c ringbuffer, which is accessed by
      * multiple processes, will cause spurious valgrind warnings about
      * undefined memory being used. That's because valgrind remembers the
      * undefined bytes from the last local process's store, not realizing that
      * another process has written since, filling the previously uninitialized
      * bytes
      */
     VALGRIND_MAKE_MEM_DEFINED(&msg, sizeof(msg));
 
     AddInvalidationMessage(&hdr->cclist, &msg);
 }

◆ AddInvalidationMessage()

static void AddInvalidationMessage	(	InvalidationChunk **	listHdr,
		SharedInvalidationMessage *	msg
	)

static

Definition at line 229 of file inval.c.

References CurTransactionContext, FIRSTCHUNKSIZE, InvalidationChunk::maxitems, MemoryContextAlloc(), InvalidationChunk::msgs, InvalidationChunk::next, InvalidationChunk::nitems, and offsetof.

Referenced by AddCatalogInvalidationMessage(), AddCatcacheInvalidationMessage(), AddRelcacheInvalidationMessage(), and AddSnapshotInvalidationMessage().

 {
     InvalidationChunk *chunk = *listHdr;
 
     if (chunk == NULL)
     {
         /* First time through; create initial chunk */
 #define FIRSTCHUNKSIZE 32
         chunk = (InvalidationChunk *)
             MemoryContextAlloc(CurTransactionContext,
                                offsetof(InvalidationChunk, msgs) +
                                FIRSTCHUNKSIZE * sizeof(SharedInvalidationMessage));
         chunk->nitems = 0;
         chunk->maxitems = FIRSTCHUNKSIZE;
         chunk->next = *listHdr;
         *listHdr = chunk;
     }
     else if (chunk->nitems >= chunk->maxitems)
     {
         /* Need another chunk; double size of last chunk */
         int         chunksize = 2 * chunk->maxitems;
 
         chunk = (InvalidationChunk *)
             MemoryContextAlloc(CurTransactionContext,
                                offsetof(InvalidationChunk, msgs) +
                                chunksize * sizeof(SharedInvalidationMessage));
         chunk->nitems = 0;
         chunk->maxitems = chunksize;
         chunk->next = *listHdr;
         *listHdr = chunk;
     }
     /* Okay, add message to current chunk */
     chunk->msgs[chunk->nitems] = *msg;
     chunk->nitems++;
 }

◆ AddRelcacheInvalidationMessage()

static void AddRelcacheInvalidationMessage	(	InvalidationListHeader *	hdr,
		Oid	dbId,
		Oid	relId
	)

static

Definition at line 385 of file inval.c.

References AddInvalidationMessage(), SharedInvalRelcacheMsg::dbId, SharedInvalRelcacheMsg::id, InvalidOid, ProcessMessageList, SharedInvalidationMessage::rc, InvalidationListHeader::rclist, SharedInvalRelcacheMsg::relId, SHAREDINVALRELCACHE_ID, and VALGRIND_MAKE_MEM_DEFINED.

Referenced by RegisterRelcacheInvalidation().

 {
     SharedInvalidationMessage msg;
 
     /*
      * Don't add a duplicate item. We assume dbId need not be checked because
      * it will never change. InvalidOid for relId means all relations so we
      * don't need to add individual ones when it is present.
      */
     ProcessMessageList(hdr->rclist,
                        if (msg->rc.id == SHAREDINVALRELCACHE_ID &&
                            (msg->rc.relId == relId ||
                             msg->rc.relId == InvalidOid))
                        return);
 
     /* OK, add the item */
     msg.rc.id = SHAREDINVALRELCACHE_ID;
     msg.rc.dbId = dbId;
     msg.rc.relId = relId;
     /* check AddCatcacheInvalidationMessage() for an explanation */
     VALGRIND_MAKE_MEM_DEFINED(&msg, sizeof(msg));
 
     AddInvalidationMessage(&hdr->rclist, &msg);
 }

◆ AddSnapshotInvalidationMessage()

static void AddSnapshotInvalidationMessage	(	InvalidationListHeader *	hdr,
		Oid	dbId,
		Oid	relId
	)

static

Definition at line 415 of file inval.c.

References AddInvalidationMessage(), SharedInvalSnapshotMsg::dbId, SharedInvalSnapshotMsg::id, ProcessMessageList, InvalidationListHeader::rclist, SharedInvalSnapshotMsg::relId, SHAREDINVALSNAPSHOT_ID, SharedInvalidationMessage::sn, and VALGRIND_MAKE_MEM_DEFINED.

Referenced by RegisterSnapshotInvalidation().

 {
     SharedInvalidationMessage msg;
 
     /* Don't add a duplicate item */
     /* We assume dbId need not be checked because it will never change */
     ProcessMessageList(hdr->rclist,
                        if (msg->sn.id == SHAREDINVALSNAPSHOT_ID &&
                            msg->sn.relId == relId)
                        return);
 
     /* OK, add the item */
     msg.sn.id = SHAREDINVALSNAPSHOT_ID;
     msg.sn.dbId = dbId;
     msg.sn.relId = relId;
     /* check AddCatcacheInvalidationMessage() for an explanation */
     VALGRIND_MAKE_MEM_DEFINED(&msg, sizeof(msg));
 
     AddInvalidationMessage(&hdr->rclist, &msg);
 }

◆ AppendInvalidationMessageList()

static void AppendInvalidationMessageList	(	InvalidationChunk **	destHdr,
		InvalidationChunk **	srcHdr
	)

static

Definition at line 271 of file inval.c.

References InvalidationChunk::next.

Referenced by AppendInvalidationMessages().

 {
     InvalidationChunk *chunk = *srcHdr;
 
     if (chunk == NULL)
         return;                 /* nothing to do */
 
     while (chunk->next != NULL)
         chunk = chunk->next;
 
     chunk->next = *destHdr;
 
     *destHdr = *srcHdr;
 
     *srcHdr = NULL;
 }

◆ AppendInvalidationMessages()

static void AppendInvalidationMessages	(	InvalidationListHeader *	dest,
		InvalidationListHeader *	src
	)

static

Definition at line 442 of file inval.c.

References AppendInvalidationMessageList(), InvalidationListHeader::cclist, and InvalidationListHeader::rclist.

Referenced by AtEOSubXact_Inval(), AtEOXact_Inval(), and CommandEndInvalidationMessages().

 {
     AppendInvalidationMessageList(&dest->cclist, &src->cclist);
     AppendInvalidationMessageList(&dest->rclist, &src->rclist);
 }

◆ AtEOSubXact_Inval()

void AtEOSubXact_Inval ( bool isCommit )

Definition at line 1008 of file inval.c.

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

Referenced by AbortSubTransaction(), and CommitSubTransaction().

 {
     int         my_level;
     TransInvalidationInfo *myInfo = transInvalInfo;
 
     /* Quick exit if no messages. */
     if (myInfo == NULL)
         return;
 
     /* Also bail out quickly if messages are not for this level. */
     my_level = GetCurrentTransactionNestLevel();
     if (myInfo->my_level != my_level)
     {
         Assert(myInfo->my_level < my_level);
         return;
     }
 
     if (isCommit)
     {
         /* If CurrentCmdInvalidMsgs still has anything, fix it */
         CommandEndInvalidationMessages();
 
         /*
          * We create invalidation stack entries lazily, so the parent might
          * not have one.  Instead of creating one, moving all the data over,
          * and then freeing our own, we can just adjust the level of our own
          * entry.
          */
         if (myInfo->parent == NULL || myInfo->parent->my_level < my_level - 1)
         {
             myInfo->my_level--;
             return;
         }
 
         /* Pass up my inval messages to parent */
         AppendInvalidationMessages(&myInfo->parent->PriorCmdInvalidMsgs,
                                    &myInfo->PriorCmdInvalidMsgs);
 
         /* Pending relcache inval becomes parent's problem too */
         if (myInfo->RelcacheInitFileInval)
             myInfo->parent->RelcacheInitFileInval = true;
 
         /* Pop the transaction state stack */
         transInvalInfo = myInfo->parent;
 
         /* Need not free anything else explicitly */
         pfree(myInfo);
     }
     else
     {
         ProcessInvalidationMessages(&myInfo->PriorCmdInvalidMsgs,
                                     LocalExecuteInvalidationMessage);
 
         /* Pop the transaction state stack */
         transInvalInfo = myInfo->parent;
 
         /* Need not free anything else explicitly */
         pfree(myInfo);
     }
 }

◆ AtEOXact_Inval()

void AtEOXact_Inval ( bool isCommit )

Definition at line 949 of file inval.c.

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

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

 {
     /* Quick exit if no messages */
     if (transInvalInfo == NULL)
         return;
 
     /* Must be at top of stack */
     Assert(transInvalInfo->my_level == 1 && transInvalInfo->parent == NULL);
 
     if (isCommit)
     {
         /*
          * Relcache init file invalidation requires processing both before and
          * after we send the SI messages.  However, we need not do anything
          * unless we committed.
          */
         if (transInvalInfo->RelcacheInitFileInval)
             RelationCacheInitFilePreInvalidate();
 
         AppendInvalidationMessages(&transInvalInfo->PriorCmdInvalidMsgs,
                                    &transInvalInfo->CurrentCmdInvalidMsgs);
 
         ProcessInvalidationMessagesMulti(&transInvalInfo->PriorCmdInvalidMsgs,
                                          SendSharedInvalidMessages);
 
         if (transInvalInfo->RelcacheInitFileInval)
             RelationCacheInitFilePostInvalidate();
     }
     else
     {
         ProcessInvalidationMessages(&transInvalInfo->PriorCmdInvalidMsgs,
                                     LocalExecuteInvalidationMessage);
     }
 
     /* Need not free anything explicitly */
     transInvalInfo = NULL;
     SharedInvalidMessagesArray = NULL;
     numSharedInvalidMessagesArray = 0;
 }

◆ CacheInvalidateCatalog()

void CacheInvalidateCatalog ( Oid catalogId )

Definition at line 1246 of file inval.c.

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

Referenced by finish_heap_swap().

 {
     Oid         databaseId;
 
     PrepareInvalidationState();
 
     if (IsSharedRelation(catalogId))
         databaseId = InvalidOid;
     else
         databaseId = MyDatabaseId;
 
     RegisterCatalogInvalidation(databaseId, catalogId);
 }

◆ CacheInvalidateHeapTuple()

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

Definition at line 1114 of file inval.c.

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().

 {
     Oid         tupleRelId;
     Oid         databaseId;
     Oid         relationId;
 
     /* Do nothing during bootstrap */
     if (IsBootstrapProcessingMode())
         return;
 
     /*
      * We only need to worry about invalidation for tuples that are in system
      * catalogs; user-relation tuples are never in catcaches and can't affect
      * the relcache either.
      */
     if (!IsCatalogRelation(relation))
         return;
 
     /*
      * IsCatalogRelation() will return true for TOAST tables of system
      * catalogs, but we don't care about those, either.
      */
     if (IsToastRelation(relation))
         return;
 
     /*
      * If we're not prepared to queue invalidation messages for this
      * subtransaction level, get ready now.
      */
     PrepareInvalidationState();
 
     /*
      * First let the catcache do its thing
      */
     tupleRelId = RelationGetRelid(relation);
     if (RelationInvalidatesSnapshotsOnly(tupleRelId))
     {
         databaseId = IsSharedRelation(tupleRelId) ? InvalidOid : MyDatabaseId;
         RegisterSnapshotInvalidation(databaseId, tupleRelId);
     }
     else
         PrepareToInvalidateCacheTuple(relation, tuple, newtuple,
                                       RegisterCatcacheInvalidation);
 
     /*
      * Now, is this tuple one of the primary definers of a relcache entry? See
      * comments in file header for deeper explanation.
      *
      * Note we ignore newtuple here; we assume an update cannot move a tuple
      * from being part of one relcache entry to being part of another.
      */
     if (tupleRelId == RelationRelationId)
     {
         Form_pg_class classtup = (Form_pg_class) GETSTRUCT(tuple);
 
         relationId = classtup->oid;
         if (classtup->relisshared)
             databaseId = InvalidOid;
         else
             databaseId = MyDatabaseId;
     }
     else if (tupleRelId == AttributeRelationId)
     {
         Form_pg_attribute atttup = (Form_pg_attribute) GETSTRUCT(tuple);
 
         relationId = atttup->attrelid;
 
         /*
          * KLUGE ALERT: we always send the relcache event with MyDatabaseId,
          * even if the rel in question is shared (which we can't easily tell).
          * This essentially means that only backends in this same database
          * will react to the relcache flush request.  This is in fact
          * appropriate, since only those backends could see our pg_attribute
          * change anyway.  It looks a bit ugly though.  (In practice, shared
          * relations can't have schema changes after bootstrap, so we should
          * never come here for a shared rel anyway.)
          */
         databaseId = MyDatabaseId;
     }
     else if (tupleRelId == IndexRelationId)
     {
         Form_pg_index indextup = (Form_pg_index) GETSTRUCT(tuple);
 
         /*
          * When a pg_index row is updated, we should send out a relcache inval
          * for the index relation.  As above, we don't know the shared status
          * of the index, but in practice it doesn't matter since indexes of
          * shared catalogs can't have such updates.
          */
         relationId = indextup->indexrelid;
         databaseId = MyDatabaseId;
     }
     else if (tupleRelId == ConstraintRelationId)
     {
         Form_pg_constraint constrtup = (Form_pg_constraint) GETSTRUCT(tuple);
 
         /*
          * Foreign keys are part of relcache entries, too, so send out an
          * inval for the table that the FK applies to.
          */
         if (constrtup->contype == CONSTRAINT_FOREIGN &&
             OidIsValid(constrtup->conrelid))
         {
             relationId = constrtup->conrelid;
             databaseId = MyDatabaseId;
         }
         else
             return;
     }
     else
         return;
 
     /*
      * Yes.  We need to register a relcache invalidation event.
      */
     RegisterRelcacheInvalidation(databaseId, relationId);
 }

◆ CacheInvalidateRelcache()

void CacheInvalidateRelcache ( Relation relation )

Definition at line 1270 of file inval.c.

References InvalidOid, MyDatabaseId, PrepareInvalidationState(), RelationData::rd_rel, RegisterRelcacheInvalidation(), and RelationGetRelid.

Referenced by AlterPolicy(), ATExecAlterConstraint(), ATExecDetachPartition(), ATExecGenericOptions(), ATExecValidateConstraint(), CreatePolicy(), CreateStatistics(), EnableDisableRule(), EnableDisableTrigger(), index_concurrently_set_dead(), index_create(), index_drop(), publication_add_relation(), reindex_index(), RelationSetNewRelfilenode(), RemovePolicyById(), RemoveRewriteRuleById(), RemoveRoleFromObjectPolicy(), RemoveTriggerById(), rename_constraint_internal(), rename_policy(), RenameRewriteRule(), renametrig(), SetRelationNumChecks(), StorePartitionBound(), and StorePartitionKey().

 {
     Oid         databaseId;
     Oid         relationId;
 
     PrepareInvalidationState();
 
     relationId = RelationGetRelid(relation);
     if (relation->rd_rel->relisshared)
         databaseId = InvalidOid;
     else
         databaseId = MyDatabaseId;
 
     RegisterRelcacheInvalidation(databaseId, relationId);
 }

◆ CacheInvalidateRelcacheAll()

void CacheInvalidateRelcacheAll ( void )

Definition at line 1294 of file inval.c.

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

Referenced by AlterPublicationOptions().

 {
     PrepareInvalidationState();
 
     RegisterRelcacheInvalidation(InvalidOid, InvalidOid);
 }

◆ CacheInvalidateRelcacheByRelid()

void CacheInvalidateRelcacheByRelid ( Oid relid )

Definition at line 1329 of file inval.c.

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

Referenced by AlterPublicationOptions(), ATExecAlterConstraint(), ATExecDetachPartition(), DefineIndex(), heap_drop_with_catalog(), ReindexRelationConcurrently(), RemovePublicationRelById(), RemoveStatisticsById(), and StorePartitionBound().

 {
     HeapTuple   tup;
 
     PrepareInvalidationState();
 
     tup = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
     if (!HeapTupleIsValid(tup))
         elog(ERROR, "cache lookup failed for relation %u", relid);
     CacheInvalidateRelcacheByTuple(tup);
     ReleaseSysCache(tup);
 }

◆ CacheInvalidateRelcacheByTuple()

void CacheInvalidateRelcacheByTuple ( HeapTuple classTuple )

Definition at line 1306 of file inval.c.

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

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

 {
     Form_pg_class classtup = (Form_pg_class) GETSTRUCT(classTuple);
     Oid         databaseId;
     Oid         relationId;
 
     PrepareInvalidationState();
 
     relationId = classtup->oid;
     if (classtup->relisshared)
         databaseId = InvalidOid;
     else
         databaseId = MyDatabaseId;
     RegisterRelcacheInvalidation(databaseId, relationId);
 }

◆ CacheInvalidateRelmap()

void CacheInvalidateRelmap ( Oid databaseId )

Definition at line 1399 of file inval.c.

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

Referenced by write_relmap_file().

 {
     SharedInvalidationMessage msg;
 
     msg.rm.id = SHAREDINVALRELMAP_ID;
     msg.rm.dbId = databaseId;
     /* check AddCatcacheInvalidationMessage() for an explanation */
     VALGRIND_MAKE_MEM_DEFINED(&msg, sizeof(msg));
 
     SendSharedInvalidMessages(&msg, 1);
 }

◆ CacheInvalidateSmgr()

void CacheInvalidateSmgr ( RelFileNodeBackend rnode )

Definition at line 1369 of file inval.c.

References RelFileNodeBackend::backend, SharedInvalSmgrMsg::backend_hi, SharedInvalSmgrMsg::backend_lo, SharedInvalSmgrMsg::id, RelFileNodeBackend::node, SharedInvalSmgrMsg::rnode, SendSharedInvalidMessages(), SHAREDINVALSMGR_ID, SharedInvalidationMessage::sm, and VALGRIND_MAKE_MEM_DEFINED.

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

 {
     SharedInvalidationMessage msg;
 
     msg.sm.id = SHAREDINVALSMGR_ID;
     msg.sm.backend_hi = rnode.backend >> 16;
     msg.sm.backend_lo = rnode.backend & 0xffff;
     msg.sm.rnode = rnode.node;
     /* check AddCatcacheInvalidationMessage() for an explanation */
     VALGRIND_MAKE_MEM_DEFINED(&msg, sizeof(msg));
 
     SendSharedInvalidMessages(&msg, 1);
 }

◆ CacheRegisterRelcacheCallback()

void CacheRegisterRelcacheCallback	(	RelcacheCallbackFunction	func,
		Datum	arg
	)

Definition at line 1468 of file inval.c.

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

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

 {
     if (relcache_callback_count >= MAX_RELCACHE_CALLBACKS)
         elog(FATAL, "out of relcache_callback_list slots");
 
     relcache_callback_list[relcache_callback_count].function = func;
     relcache_callback_list[relcache_callback_count].arg = arg;
 
     ++relcache_callback_count;
 }

◆ CacheRegisterSyscacheCallback()

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

Definition at line 1426 of file inval.c.

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

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

 {
     if (cacheid < 0 || cacheid >= SysCacheSize)
         elog(FATAL, "invalid cache ID: %d", cacheid);
     if (syscache_callback_count >= MAX_SYSCACHE_CALLBACKS)
         elog(FATAL, "out of syscache_callback_list slots");
 
     if (syscache_callback_links[cacheid] == 0)
     {
         /* first callback for this cache */
         syscache_callback_links[cacheid] = syscache_callback_count + 1;
     }
     else
     {
         /* add to end of chain, so that older callbacks are called first */
         int         i = syscache_callback_links[cacheid] - 1;
 
         while (syscache_callback_list[i].link > 0)
             i = syscache_callback_list[i].link - 1;
         syscache_callback_list[i].link = syscache_callback_count + 1;
     }
 
     syscache_callback_list[syscache_callback_count].id = cacheid;
     syscache_callback_list[syscache_callback_count].link = 0;
     syscache_callback_list[syscache_callback_count].function = func;
     syscache_callback_list[syscache_callback_count].arg = arg;
 
     ++syscache_callback_count;
 }

◆ CallSyscacheCallbacks()

void CallSyscacheCallbacks	(	int	cacheid,
		uint32	hashvalue
	)

Definition at line 1487 of file inval.c.

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

Referenced by CatalogCacheFlushCatalog(), and LocalExecuteInvalidationMessage().

 {
     int         i;
 
     if (cacheid < 0 || cacheid >= SysCacheSize)
         elog(ERROR, "invalid cache ID: %d", cacheid);
 
     i = syscache_callback_links[cacheid] - 1;
     while (i >= 0)
     {
         struct SYSCACHECALLBACK *ccitem = syscache_callback_list + i;
 
         Assert(ccitem->id == cacheid);
         ccitem->function(ccitem->arg, cacheid, hashvalue);
         i = ccitem->link - 1;
     }
 }

◆ CommandEndInvalidationMessages()

void CommandEndInvalidationMessages ( void )

Definition at line 1085 of file inval.c.

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

Referenced by AtCCI_LocalCache(), and AtEOSubXact_Inval().

 {
     /*
      * You might think this shouldn't be called outside any transaction, but
      * bootstrap does it, and also ABORT issued when not in a transaction. So
      * just quietly return if no state to work on.
      */
     if (transInvalInfo == NULL)
         return;
 
     ProcessInvalidationMessages(&transInvalInfo->CurrentCmdInvalidMsgs,
                                 LocalExecuteInvalidationMessage);
     AppendInvalidationMessages(&transInvalInfo->PriorCmdInvalidMsgs,
                                &transInvalInfo->CurrentCmdInvalidMsgs);
 }

◆ InvalidateSystemCaches()

void InvalidateSystemCaches ( void )

Definition at line 643 of file inval.c.

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(), ParallelWorkerMain(), pg_logical_replication_slot_advance(), and pg_logical_slot_get_changes_guts().

 {
     int         i;
 
     InvalidateCatalogSnapshot();
     ResetCatalogCaches();
     RelationCacheInvalidate();  /* gets smgr and relmap too */
 
     for (i = 0; i < syscache_callback_count; i++)
     {
         struct SYSCACHECALLBACK *ccitem = syscache_callback_list + i;
 
         ccitem->function(ccitem->arg, ccitem->id, 0);
     }
 
     for (i = 0; i < relcache_callback_count; i++)
     {
         struct RELCACHECALLBACK *ccitem = relcache_callback_list + i;
 
         ccitem->function(ccitem->arg, InvalidOid);
     }
 }

◆ LocalExecuteInvalidationMessage()

void LocalExecuteInvalidationMessage ( SharedInvalidationMessage * msg )

Definition at line 556 of file inval.c.

References RELCACHECALLBACK::arg, RelFileNodeBackend::backend, SharedInvalSmgrMsg::backend_hi, SharedInvalSmgrMsg::backend_lo, CallSyscacheCallbacks(), SharedInvalidationMessage::cat, CatalogCacheFlushCatalog(), SharedInvalCatalogMsg::catId, SharedInvalidationMessage::cc, SharedInvalCatcacheMsg::dbId, SharedInvalCatalogMsg::dbId, SharedInvalRelcacheMsg::dbId, SharedInvalRelmapMsg::dbId, elog, FATAL, RELCACHECALLBACK::function, SharedInvalCatcacheMsg::hashValue, i, SharedInvalCatcacheMsg::id, SharedInvalidationMessage::id, InvalidateCatalogSnapshot(), InvalidOid, MyDatabaseId, RelFileNodeBackend::node, SharedInvalidationMessage::rc, RelationCacheInvalidate(), RelationCacheInvalidateEntry(), RelationMapInvalidate(), relcache_callback_count, relcache_callback_list, SharedInvalRelcacheMsg::relId, SharedInvalidationMessage::rm, SharedInvalSmgrMsg::rnode, SHAREDINVALCATALOG_ID, SHAREDINVALRELCACHE_ID, SHAREDINVALRELMAP_ID, SHAREDINVALSMGR_ID, SHAREDINVALSNAPSHOT_ID, SharedInvalidationMessage::sm, smgrclosenode(), and SysCacheInvalidate().

Referenced by AcceptInvalidationMessages(), AtEOSubXact_Inval(), AtEOXact_Inval(), CommandEndInvalidationMessages(), ReorderBufferExecuteInvalidations(), and ReorderBufferImmediateInvalidation().

 {
     if (msg->id >= 0)
     {
         if (msg->cc.dbId == MyDatabaseId || msg->cc.dbId == InvalidOid)
         {
             InvalidateCatalogSnapshot();
 
             SysCacheInvalidate(msg->cc.id, msg->cc.hashValue);
 
             CallSyscacheCallbacks(msg->cc.id, msg->cc.hashValue);
         }
     }
     else if (msg->id == SHAREDINVALCATALOG_ID)
     {
         if (msg->cat.dbId == MyDatabaseId || msg->cat.dbId == InvalidOid)
         {
             InvalidateCatalogSnapshot();
 
             CatalogCacheFlushCatalog(msg->cat.catId);
 
             /* CatalogCacheFlushCatalog calls CallSyscacheCallbacks as needed */
         }
     }
     else if (msg->id == SHAREDINVALRELCACHE_ID)
     {
         if (msg->rc.dbId == MyDatabaseId || msg->rc.dbId == InvalidOid)
         {
             int         i;
 
             if (msg->rc.relId == InvalidOid)
                 RelationCacheInvalidate();
             else
                 RelationCacheInvalidateEntry(msg->rc.relId);
 
             for (i = 0; i < relcache_callback_count; i++)
             {
                 struct RELCACHECALLBACK *ccitem = relcache_callback_list + i;
 
                 ccitem->function(ccitem->arg, msg->rc.relId);
             }
         }
     }
     else if (msg->id == SHAREDINVALSMGR_ID)
     {
         /*
          * We could have smgr entries for relations of other databases, so no
          * short-circuit test is possible here.
          */
         RelFileNodeBackend rnode;
 
         rnode.node = msg->sm.rnode;
         rnode.backend = (msg->sm.backend_hi << 16) | (int) msg->sm.backend_lo;
         smgrclosenode(rnode);
     }
     else if (msg->id == SHAREDINVALRELMAP_ID)
     {
         /* We only care about our own database and shared catalogs */
         if (msg->rm.dbId == InvalidOid)
             RelationMapInvalidate(true);
         else if (msg->rm.dbId == MyDatabaseId)
             RelationMapInvalidate(false);
     }
     else if (msg->id == SHAREDINVALSNAPSHOT_ID)
     {
         /* We only care about our own database and shared catalogs */
         if (msg->rm.dbId == InvalidOid)
             InvalidateCatalogSnapshot();
         else if (msg->rm.dbId == MyDatabaseId)
             InvalidateCatalogSnapshot();
     }
     else
         elog(FATAL, "unrecognized SI message ID: %d", msg->id);
 }

◆ MakeSharedInvalidMessagesArray()

static void MakeSharedInvalidMessagesArray	(	const SharedInvalidationMessage *	msgs,
		int	n
	)

static

Definition at line 778 of file inval.c.

References FIRSTCHUNKSIZE, maxSharedInvalidMessagesArray, numSharedInvalidMessagesArray, palloc(), and repalloc().

Referenced by xactGetCommittedInvalidationMessages().

 {
     /*
      * Initialise array first time through in each commit
      */
     if (SharedInvalidMessagesArray == NULL)
     {
         maxSharedInvalidMessagesArray = FIRSTCHUNKSIZE;
         numSharedInvalidMessagesArray = 0;
 
         /*
          * Although this is being palloc'd we don't actually free it directly.
          * We're so close to EOXact that we now we're going to lose it anyhow.
          */
         SharedInvalidMessagesArray = palloc(maxSharedInvalidMessagesArray
                                             * sizeof(SharedInvalidationMessage));
     }
 
     if ((numSharedInvalidMessagesArray + n) > maxSharedInvalidMessagesArray)
     {
         while ((numSharedInvalidMessagesArray + n) > maxSharedInvalidMessagesArray)
             maxSharedInvalidMessagesArray *= 2;
 
         SharedInvalidMessagesArray = repalloc(SharedInvalidMessagesArray,
                                               maxSharedInvalidMessagesArray
                                               * sizeof(SharedInvalidationMessage));
     }
 
     /*
      * Append the next chunk onto the array
      */
     memcpy(SharedInvalidMessagesArray + numSharedInvalidMessagesArray,
            msgs, n * sizeof(SharedInvalidationMessage));
     numSharedInvalidMessagesArray += n;
 }

◆ PostPrepare_Inval()

void PostPrepare_Inval ( void )

Definition at line 769 of file inval.c.

References AtEOXact_Inval().

Referenced by PrepareTransaction().

 {
     AtEOXact_Inval(false);
 }

◆ PrepareInvalidationState()

static void PrepareInvalidationState ( void )

static

Definition at line 732 of file inval.c.

References Assert, GetCurrentTransactionNestLevel(), MemoryContextAllocZero(), TransInvalidationInfo::my_level, TransInvalidationInfo::parent, TopTransactionContext, and transInvalInfo.

Referenced by CacheInvalidateCatalog(), CacheInvalidateHeapTuple(), CacheInvalidateRelcache(), CacheInvalidateRelcacheAll(), CacheInvalidateRelcacheByRelid(), and CacheInvalidateRelcacheByTuple().

 {
     TransInvalidationInfo *myInfo;
 
     if (transInvalInfo != NULL &&
         transInvalInfo->my_level == GetCurrentTransactionNestLevel())
         return;
 
     myInfo = (TransInvalidationInfo *)
         MemoryContextAllocZero(TopTransactionContext,
                                sizeof(TransInvalidationInfo));
     myInfo->parent = transInvalInfo;
     myInfo->my_level = GetCurrentTransactionNestLevel();
 
     /*
      * If there's any previous entry, this one should be for a deeper nesting
      * level.
      */
     Assert(transInvalInfo == NULL ||
            myInfo->my_level > transInvalInfo->my_level);
 
     transInvalInfo = myInfo;
 }

◆ ProcessCommittedInvalidationMessages()

void ProcessCommittedInvalidationMessages	(	SharedInvalidationMessage *	msgs,
		int	nmsgs,
		bool	RelcacheInitFileInval,
		Oid	dbid,
		Oid	tsid
	)

Definition at line 884 of file inval.c.

References DatabasePath, DEBUG4, elog, GetDatabasePath(), OidIsValid, pfree(), RelationCacheInitFilePostInvalidate(), RelationCacheInitFilePreInvalidate(), SendSharedInvalidMessages(), and trace_recovery().

Referenced by standby_redo(), and xact_redo_commit().

 {
     if (nmsgs <= 0)
         return;
 
     elog(trace_recovery(DEBUG4), "replaying commit with %d messages%s", nmsgs,
          (RelcacheInitFileInval ? " and relcache file invalidation" : ""));
 
     if (RelcacheInitFileInval)
     {
         elog(trace_recovery(DEBUG4), "removing relcache init files for database %u",
              dbid);
 
         /*
          * RelationCacheInitFilePreInvalidate, when the invalidation message
          * is for a specific database, requires DatabasePath to be set, but we
          * should not use SetDatabasePath during recovery, since it is
          * intended to be used only once by normal backends.  Hence, a quick
          * hack: set DatabasePath directly then unset after use.
          */
         if (OidIsValid(dbid))
             DatabasePath = GetDatabasePath(dbid, tsid);
 
         RelationCacheInitFilePreInvalidate();
 
         if (OidIsValid(dbid))
         {
             pfree(DatabasePath);
             DatabasePath = NULL;
         }
     }
 
     SendSharedInvalidMessages(msgs, nmsgs);
 
     if (RelcacheInitFileInval)
         RelationCacheInitFilePostInvalidate();
 }

◆ ProcessInvalidationMessages()

static void ProcessInvalidationMessages	(	InvalidationListHeader *	hdr,
		void()(SharedInvalidationMessage msg)	func
	)

static

Definition at line 456 of file inval.c.

References InvalidationListHeader::cclist, ProcessMessageList, and InvalidationListHeader::rclist.

Referenced by AtEOSubXact_Inval(), AtEOXact_Inval(), and CommandEndInvalidationMessages().

 {
     ProcessMessageList(hdr->cclist, func(msg));
     ProcessMessageList(hdr->rclist, func(msg));
 }

◆ ProcessInvalidationMessagesMulti()

static void ProcessInvalidationMessagesMulti	(	InvalidationListHeader *	hdr,
		void()(const SharedInvalidationMessage msgs, int n)	func
	)

static

Definition at line 468 of file inval.c.

References InvalidationListHeader::cclist, ProcessMessageListMulti, and InvalidationListHeader::rclist.

Referenced by AtEOXact_Inval(), and xactGetCommittedInvalidationMessages().

 {
     ProcessMessageListMulti(hdr->cclist, func(msgs, n));
     ProcessMessageListMulti(hdr->rclist, func(msgs, n));
 }

◆ RegisterCatalogInvalidation()

static void RegisterCatalogInvalidation	(	Oid	dbId,
		Oid	catId
	)

static

Definition at line 500 of file inval.c.

References AddCatalogInvalidationMessage(), and TransInvalidationInfo::CurrentCmdInvalidMsgs.

Referenced by CacheInvalidateCatalog().

 {
     AddCatalogInvalidationMessage(&transInvalInfo->CurrentCmdInvalidMsgs,
                                   dbId, catId);
 }

◆ RegisterCatcacheInvalidation()

static void RegisterCatcacheInvalidation	(	int	cacheId,
		uint32	hashValue,
		Oid	dbId
	)

static

Definition at line 486 of file inval.c.

References AddCatcacheInvalidationMessage(), and TransInvalidationInfo::CurrentCmdInvalidMsgs.

Referenced by CacheInvalidateHeapTuple().

 {
     AddCatcacheInvalidationMessage(&transInvalInfo->CurrentCmdInvalidMsgs,
                                    cacheId, hashValue, dbId);
 }

◆ RegisterRelcacheInvalidation()

static void RegisterRelcacheInvalidation	(	Oid	dbId,
		Oid	relId
	)

static

Definition at line 512 of file inval.c.

References AddRelcacheInvalidationMessage(), TransInvalidationInfo::CurrentCmdInvalidMsgs, GetCurrentCommandId(), InvalidOid, RelationIdIsInInitFile(), and TransInvalidationInfo::RelcacheInitFileInval.

Referenced by CacheInvalidateHeapTuple(), CacheInvalidateRelcache(), CacheInvalidateRelcacheAll(), and CacheInvalidateRelcacheByTuple().

 {
     AddRelcacheInvalidationMessage(&transInvalInfo->CurrentCmdInvalidMsgs,
                                    dbId, relId);
 
     /*
      * Most of the time, relcache invalidation is associated with system
      * catalog updates, but there are a few cases where it isn't.  Quick hack
      * to ensure that the next CommandCounterIncrement() will think that we
      * need to do CommandEndInvalidationMessages().
      */
     (void) GetCurrentCommandId(true);
 
     /*
      * If the relation being invalidated is one of those cached in a relcache
      * init file, mark that we need to zap that file at commit. For simplicity
      * invalidations for a specific database always invalidate the shared file
      * as well.  Also zap when we are invalidating whole relcache.
      */
     if (relId == InvalidOid || RelationIdIsInInitFile(relId))
         transInvalInfo->RelcacheInitFileInval = true;
 }

◆ RegisterSnapshotInvalidation()

static void RegisterSnapshotInvalidation	(	Oid	dbId,
		Oid	relId
	)

static

Definition at line 542 of file inval.c.

References AddSnapshotInvalidationMessage(), and TransInvalidationInfo::CurrentCmdInvalidMsgs.

Referenced by CacheInvalidateHeapTuple().

 {
     AddSnapshotInvalidationMessage(&transInvalInfo->CurrentCmdInvalidMsgs,
                                    dbId, relId);
 }

◆ xactGetCommittedInvalidationMessages()

int xactGetCommittedInvalidationMessages	(	SharedInvalidationMessage **	msgs,
		bool *	RelcacheInitFileInval
	)

Definition at line 828 of file inval.c.

References Assert, TransInvalidationInfo::CurrentCmdInvalidMsgs, CurTransactionContext, MakeSharedInvalidMessagesArray(), MemoryContextSwitchTo(), TransInvalidationInfo::my_level, numSharedInvalidMessagesArray, TransInvalidationInfo::parent, TransInvalidationInfo::PriorCmdInvalidMsgs, ProcessInvalidationMessagesMulti(), TransInvalidationInfo::RelcacheInitFileInval, and SharedInvalidMessagesArray.

Referenced by RecordTransactionCommit(), and StartPrepare().

 {
     MemoryContext oldcontext;
 
     /* Quick exit if we haven't done anything with invalidation messages. */
     if (transInvalInfo == NULL)
     {
         *RelcacheInitFileInval = false;
         *msgs = NULL;
         return 0;
     }
 
     /* Must be at top of stack */
     Assert(transInvalInfo->my_level == 1 && transInvalInfo->parent == NULL);
 
     /*
      * Relcache init file invalidation requires processing both before and
      * after we send the SI messages.  However, we need not do anything unless
      * we committed.
      */
     *RelcacheInitFileInval = transInvalInfo->RelcacheInitFileInval;
 
     /*
      * Walk through TransInvalidationInfo to collect all the messages into a
      * single contiguous array of invalidation messages. It must be contiguous
      * so we can copy directly into WAL message. Maintain the order that they
      * would be processed in by AtEOXact_Inval(), to ensure emulated behaviour
      * in redo is as similar as possible to original. We want the same bugs,
      * if any, not new ones.
      */
     oldcontext = MemoryContextSwitchTo(CurTransactionContext);
 
     ProcessInvalidationMessagesMulti(&transInvalInfo->CurrentCmdInvalidMsgs,
                                      MakeSharedInvalidMessagesArray);
     ProcessInvalidationMessagesMulti(&transInvalInfo->PriorCmdInvalidMsgs,
                                      MakeSharedInvalidMessagesArray);
     MemoryContextSwitchTo(oldcontext);
 
     Assert(!(numSharedInvalidMessagesArray > 0 &&
              SharedInvalidMessagesArray == NULL));
 
     *msgs = SharedInvalidMessagesArray;
 
     return numSharedInvalidMessagesArray;
 }

Variable Documentation

◆ maxSharedInvalidMessagesArray

int maxSharedInvalidMessagesArray

static

Definition at line 177 of file inval.c.

Referenced by MakeSharedInvalidMessagesArray().

◆ numSharedInvalidMessagesArray

int numSharedInvalidMessagesArray

static

Definition at line 176 of file inval.c.

Referenced by AtEOXact_Inval(), MakeSharedInvalidMessagesArray(), and xactGetCommittedInvalidationMessages().

◆ relcache_callback_count

int relcache_callback_count = 0

static

Definition at line 211 of file inval.c.

Referenced by CacheRegisterRelcacheCallback(), InvalidateSystemCaches(), and LocalExecuteInvalidationMessage().

◆ relcache_callback_list

struct RELCACHECALLBACK relcache_callback_list[MAX_RELCACHE_CALLBACKS]

static

Referenced by CacheRegisterRelcacheCallback(), InvalidateSystemCaches(), and LocalExecuteInvalidationMessage().

◆ SharedInvalidMessagesArray

SharedInvalidationMessage* SharedInvalidMessagesArray

static

Definition at line 175 of file inval.c.

Referenced by xactGetCommittedInvalidationMessages().

◆ syscache_callback_count

int syscache_callback_count = 0

static

Definition at line 203 of file inval.c.

Referenced by CacheRegisterSyscacheCallback(), and InvalidateSystemCaches().

◆ syscache_callback_links

int16 syscache_callback_links[SysCacheSize]

static

Definition at line 201 of file inval.c.

Referenced by CacheRegisterSyscacheCallback(), and CallSyscacheCallbacks().

◆ syscache_callback_list

struct SYSCACHECALLBACK syscache_callback_list[MAX_SYSCACHE_CALLBACKS]

static

Referenced by CacheRegisterSyscacheCallback(), CallSyscacheCallbacks(), and InvalidateSystemCaches().

◆ transInvalInfo

TransInvalidationInfo* transInvalInfo = NULL

static

Definition at line 173 of file inval.c.

Referenced by AtEOSubXact_Inval(), and PrepareInvalidationState().

Data Structures

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ FIRSTCHUNKSIZE

◆ MAX_RELCACHE_CALLBACKS

◆ MAX_SYSCACHE_CALLBACKS

◆ ProcessMessageList

◆ ProcessMessageListMulti

Typedef Documentation

◆ InvalidationChunk

◆ InvalidationListHeader

◆ TransInvalidationInfo

Function Documentation

◆ AcceptInvalidationMessages()

◆ AddCatalogInvalidationMessage()

◆ AddCatcacheInvalidationMessage()

◆ AddInvalidationMessage()

◆ AddRelcacheInvalidationMessage()

◆ AddSnapshotInvalidationMessage()

◆ AppendInvalidationMessageList()

◆ AppendInvalidationMessages()

◆ AtEOSubXact_Inval()

◆ AtEOXact_Inval()

◆ CacheInvalidateCatalog()

◆ CacheInvalidateHeapTuple()

◆ CacheInvalidateRelcache()

◆ CacheInvalidateRelcacheAll()

◆ CacheInvalidateRelcacheByRelid()

◆ CacheInvalidateRelcacheByTuple()

◆ CacheInvalidateRelmap()

◆ CacheInvalidateSmgr()

◆ CacheRegisterRelcacheCallback()

◆ CacheRegisterSyscacheCallback()

◆ CallSyscacheCallbacks()

◆ CommandEndInvalidationMessages()

◆ InvalidateSystemCaches()

◆ LocalExecuteInvalidationMessage()

◆ MakeSharedInvalidMessagesArray()

◆ PostPrepare_Inval()

◆ PrepareInvalidationState()

◆ ProcessCommittedInvalidationMessages()

◆ ProcessInvalidationMessages()

◆ ProcessInvalidationMessagesMulti()

◆ RegisterCatalogInvalidation()

◆ RegisterCatcacheInvalidation()

◆ RegisterRelcacheInvalidation()

◆ RegisterSnapshotInvalidation()

◆ xactGetCommittedInvalidationMessages()

Variable Documentation

◆ maxSharedInvalidMessagesArray

◆ numSharedInvalidMessagesArray

◆ relcache_callback_count

◆ relcache_callback_list

◆ SharedInvalidMessagesArray

◆ syscache_callback_count

◆ syscache_callback_links

◆ syscache_callback_list

◆ transInvalInfo