#include <signal.h>
#include "storage/relfilelocator.h"

Include dependency graph for sinval.h:

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

Data Structures
struct	SharedInvalCatcacheMsg

struct	SharedInvalCatalogMsg

struct	SharedInvalRelcacheMsg

struct	SharedInvalSmgrMsg

struct	SharedInvalRelmapMsg

struct	SharedInvalSnapshotMsg

union	SharedInvalidationMessage

Macros
#define	SHAREDINVALCATALOG_ID (-1)

#define	SHAREDINVALRELCACHE_ID (-2)

#define	SHAREDINVALSMGR_ID (-3)

#define	SHAREDINVALRELMAP_ID (-4)

#define	SHAREDINVALSNAPSHOT_ID (-5)

Functions
void	SendSharedInvalidMessages (const SharedInvalidationMessage *msgs, int n)

void	ReceiveSharedInvalidMessages (void(invalFunction)(SharedInvalidationMessage msg), void(*resetFunction)(void))

void	HandleCatchupInterrupt (void)

void	ProcessCatchupInterrupt (void)

int	xactGetCommittedInvalidationMessages (SharedInvalidationMessage *msgs, bool RelcacheInitFileInval)

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

void	LocalExecuteInvalidationMessage (SharedInvalidationMessage *msg)

Variables
PGDLLIMPORT uint64	SharedInvalidMessageCounter

PGDLLIMPORT volatile sig_atomic_t	catchupInterruptPending

Macro Definition Documentation

◆ SHAREDINVALCATALOG_ID

#define SHAREDINVALCATALOG_ID (-1)

Definition at line 67 of file sinval.h.

◆ SHAREDINVALRELCACHE_ID

#define SHAREDINVALRELCACHE_ID (-2)

Definition at line 76 of file sinval.h.

◆ SHAREDINVALRELMAP_ID

#define SHAREDINVALRELMAP_ID (-4)

Definition at line 96 of file sinval.h.

◆ SHAREDINVALSMGR_ID

#define SHAREDINVALSMGR_ID (-3)

Definition at line 85 of file sinval.h.

◆ SHAREDINVALSNAPSHOT_ID

#define SHAREDINVALSNAPSHOT_ID (-5)

Definition at line 104 of file sinval.h.

Function Documentation

◆ HandleCatchupInterrupt()

void HandleCatchupInterrupt ( void )

Definition at line 156 of file sinval.c.

 {
     /*
      * Note: this is called by a SIGNAL HANDLER. You must be very wary what
      * you do here.
      */
  
     catchupInterruptPending = true;
  
     /* make sure the event is processed in due course */
     SetLatch(MyLatch);
 }

References catchupInterruptPending, MyLatch, and SetLatch().

Referenced by procsignal_sigusr1_handler().

◆ LocalExecuteInvalidationMessage()

void LocalExecuteInvalidationMessage ( SharedInvalidationMessage * msg )

Definition at line 615 of file inval.c.

 {
     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(false);
             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.
          */
         RelFileLocatorBackend rlocator;
  
         rlocator.locator = msg->sm.rlocator;
         rlocator.backend = (msg->sm.backend_hi << 16) | (int) msg->sm.backend_lo;
         smgrcloserellocator(rlocator);
     }
     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->sn.dbId == InvalidOid)
             InvalidateCatalogSnapshot();
         else if (msg->sn.dbId == MyDatabaseId)
             InvalidateCatalogSnapshot();
     }
     else
         elog(FATAL, "unrecognized SI message ID: %d", msg->id);
 }

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

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

◆ ProcessCatchupInterrupt()

void ProcessCatchupInterrupt ( void )

Definition at line 176 of file sinval.c.

 {
     while (catchupInterruptPending)
     {
         /*
          * What we need to do here is cause ReceiveSharedInvalidMessages() to
          * run, which will do the necessary work and also reset the
          * catchupInterruptPending flag.  If we are inside a transaction we
          * can just call AcceptInvalidationMessages() to do this.  If we
          * aren't, we start and immediately end a transaction; the call to
          * AcceptInvalidationMessages() happens down inside transaction start.
          *
          * It is awfully tempting to just call AcceptInvalidationMessages()
          * without the rest of the xact start/stop overhead, and I think that
          * would actually work in the normal case; but I am not sure that
          * things would clean up nicely if we got an error partway through.
          */
         if (IsTransactionOrTransactionBlock())
         {
             elog(DEBUG4, "ProcessCatchupEvent inside transaction");
             AcceptInvalidationMessages();
         }
         else
         {
             elog(DEBUG4, "ProcessCatchupEvent outside transaction");
             StartTransactionCommand();
             CommitTransactionCommand();
         }
     }
 }

References AcceptInvalidationMessages(), catchupInterruptPending, CommitTransactionCommand(), DEBUG4, elog(), IsTransactionOrTransactionBlock(), and StartTransactionCommand().

Referenced by HandleAutoVacLauncherInterrupts(), and ProcessClientReadInterrupt().

◆ ProcessCommittedInvalidationMessages()

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

Definition at line 963 of file inval.c.

 {
     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();
 }

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

Referenced by standby_redo(), and xact_redo_commit().

◆ ReceiveSharedInvalidMessages()

void ReceiveSharedInvalidMessages	(	void()(SharedInvalidationMessage msg)	invalFunction,
		void(*)(void)	resetFunction
	)

Definition at line 71 of file sinval.c.

 {
 #define MAXINVALMSGS 32
     static SharedInvalidationMessage messages[MAXINVALMSGS];
  
     /*
      * We use volatile here to prevent bugs if a compiler doesn't realize that
      * recursion is a possibility ...
      */
     static volatile int nextmsg = 0;
     static volatile int nummsgs = 0;
  
     /* Deal with any messages still pending from an outer recursion */
     while (nextmsg < nummsgs)
     {
         SharedInvalidationMessage msg = messages[nextmsg++];
  
         SharedInvalidMessageCounter++;
         invalFunction(&msg);
     }
  
     do
     {
         int         getResult;
  
         nextmsg = nummsgs = 0;
  
         /* Try to get some more messages */
         getResult = SIGetDataEntries(messages, MAXINVALMSGS);
  
         if (getResult < 0)
         {
             /* got a reset message */
             elog(DEBUG4, "cache state reset");
             SharedInvalidMessageCounter++;
             resetFunction();
             break;              /* nothing more to do */
         }
  
         /* Process them, being wary that a recursive call might eat some */
         nextmsg = 0;
         nummsgs = getResult;
  
         while (nextmsg < nummsgs)
         {
             SharedInvalidationMessage msg = messages[nextmsg++];
  
             SharedInvalidMessageCounter++;
             invalFunction(&msg);
         }
  
         /*
          * We only need to loop if the last SIGetDataEntries call (which might
          * have been within a recursive call) returned a full buffer.
          */
     } while (nummsgs == MAXINVALMSGS);
  
     /*
      * We are now caught up.  If we received a catchup signal, reset that
      * flag, and call SICleanupQueue().  This is not so much because we need
      * to flush dead messages right now, as that we want to pass on the
      * catchup signal to the next slowest backend.  "Daisy chaining" the
      * catchup signal this way avoids creating spikes in system load for what
      * should be just a background maintenance activity.
      */
     if (catchupInterruptPending)
     {
         catchupInterruptPending = false;
         elog(DEBUG4, "sinval catchup complete, cleaning queue");
         SICleanupQueue(false, 0);
     }
 }

References catchupInterruptPending, DEBUG4, elog(), MAXINVALMSGS, SharedInvalidMessageCounter, SICleanupQueue(), and SIGetDataEntries().

Referenced by AcceptInvalidationMessages().

◆ SendSharedInvalidMessages()

void SendSharedInvalidMessages	(	const SharedInvalidationMessage *	msgs,
		int	n
	)

Definition at line 49 of file sinval.c.

 {
     SIInsertDataEntries(msgs, n);
 }

References SIInsertDataEntries().

Referenced by AtEOXact_Inval(), CacheInvalidateRelmap(), CacheInvalidateSmgr(), FinishPreparedTransaction(), and ProcessCommittedInvalidationMessages().

◆ xactGetCommittedInvalidationMessages()

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

Definition at line 884 of file inval.c.

 {
     SharedInvalidationMessage *msgarray;
     int         nummsgs;
     int         nmsgs;
  
     /* 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;
  
     /*
      * Collect all the pending messages into a single contiguous array of
      * invalidation messages, to simplify what needs to happen while building
      * the commit 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.
      */
     nummsgs = NumMessagesInGroup(&transInvalInfo->PriorCmdInvalidMsgs) +
         NumMessagesInGroup(&transInvalInfo->CurrentCmdInvalidMsgs);
  
     *msgs = msgarray = (SharedInvalidationMessage *)
         MemoryContextAlloc(CurTransactionContext,
                            nummsgs * sizeof(SharedInvalidationMessage));
  
     nmsgs = 0;
     ProcessMessageSubGroupMulti(&transInvalInfo->PriorCmdInvalidMsgs,
                                 CatCacheMsgs,
                                 (memcpy(msgarray + nmsgs,
                                         msgs,
                                         n * sizeof(SharedInvalidationMessage)),
                                  nmsgs += n));
     ProcessMessageSubGroupMulti(&transInvalInfo->CurrentCmdInvalidMsgs,
                                 CatCacheMsgs,
                                 (memcpy(msgarray + nmsgs,
                                         msgs,
                                         n * sizeof(SharedInvalidationMessage)),
                                  nmsgs += n));
     ProcessMessageSubGroupMulti(&transInvalInfo->PriorCmdInvalidMsgs,
                                 RelCacheMsgs,
                                 (memcpy(msgarray + nmsgs,
                                         msgs,
                                         n * sizeof(SharedInvalidationMessage)),
                                  nmsgs += n));
     ProcessMessageSubGroupMulti(&transInvalInfo->CurrentCmdInvalidMsgs,
                                 RelCacheMsgs,
                                 (memcpy(msgarray + nmsgs,
                                         msgs,
                                         n * sizeof(SharedInvalidationMessage)),
                                  nmsgs += n));
     Assert(nmsgs == nummsgs);
  
     return nmsgs;
 }

References Assert(), CatCacheMsgs, TransInvalidationInfo::CurrentCmdInvalidMsgs, CurTransactionContext, MemoryContextAlloc(), TransInvalidationInfo::my_level, NumMessagesInGroup, TransInvalidationInfo::parent, TransInvalidationInfo::PriorCmdInvalidMsgs, ProcessMessageSubGroupMulti, TransInvalidationInfo::RelcacheInitFileInval, RelCacheMsgs, and transInvalInfo.

Referenced by RecordTransactionCommit(), and StartPrepare().

Variable Documentation

◆ catchupInterruptPending

PGDLLIMPORT volatile sig_atomic_t catchupInterruptPending

extern

Definition at line 41 of file sinval.c.

Referenced by HandleCatchupInterrupt(), ProcessCatchupInterrupt(), ProcessClientReadInterrupt(), and ReceiveSharedInvalidMessages().

◆ SharedInvalidMessageCounter

PGDLLIMPORT uint64 SharedInvalidMessageCounter