sinval.h File Reference

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

Include dependency graph for sinval.h:

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

Go to the source code of this file.

Data Structures
struct	SharedInvalCatcacheMsg
struct	SharedInvalCatalogMsg
struct	SharedInvalRelcacheMsg
struct	SharedInvalSmgrMsg
struct	SharedInvalRelmapMsg
struct	SharedInvalSnapshotMsg
struct	SharedInvalRelSyncMsg
union	SharedInvalidationMessage

Macros
#define	SHAREDINVALCATALOG_ID   (-1)
#define	SHAREDINVALRELCACHE_ID   (-2)
#define	SHAREDINVALSMGR_ID   (-3)
#define	SHAREDINVALRELMAP_ID   (-4)
#define	SHAREDINVALSNAPSHOT_ID   (-5)
#define	SHAREDINVALRELSYNC_ID   (-6)

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)
int	inplaceGetInvalidationMessages (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 68 of file sinval.h.

SHAREDINVALRELCACHE_ID

#define SHAREDINVALRELCACHE_ID   (-2)

Definition at line 77 of file sinval.h.

SHAREDINVALRELMAP_ID

#define SHAREDINVALRELMAP_ID   (-4)

Definition at line 97 of file sinval.h.

SHAREDINVALRELSYNC_ID

#define SHAREDINVALRELSYNC_ID   (-6)

Definition at line 114 of file sinval.h.

SHAREDINVALSMGR_ID

#define SHAREDINVALSMGR_ID   (-3)

Definition at line 86 of file sinval.h.

SHAREDINVALSNAPSHOT_ID

#define SHAREDINVALSNAPSHOT_ID   (-5)

Definition at line 105 of file sinval.h.

Function Documentation

HandleCatchupInterrupt()

void HandleCatchupInterrupt

(

void

)

Definition at line 154 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().

inplaceGetInvalidationMessages()

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

Definition at line 1088 of file inval.c.

{
    SharedInvalidationMessage *msgarray;
    int         nummsgs;
    int         nmsgs;
 
    /* Quick exit if we haven't done anything with invalidation messages. */
    if (inplaceInvalInfo == NULL)
    {
        *RelcacheInitFileInval = false;
        *msgs = NULL;
        return 0;
    }
 
    *RelcacheInitFileInval = inplaceInvalInfo->RelcacheInitFileInval;
    nummsgs = NumMessagesInGroup(&inplaceInvalInfo->CurrentCmdInvalidMsgs);
    *msgs = msgarray = (SharedInvalidationMessage *)
        palloc(nummsgs * sizeof(SharedInvalidationMessage));
 
    nmsgs = 0;
    ProcessMessageSubGroupMulti(&inplaceInvalInfo->CurrentCmdInvalidMsgs,
                                CatCacheMsgs,
                                (memcpy(msgarray + nmsgs,
                                        msgs,
                                        n * sizeof(SharedInvalidationMessage)),
                                 nmsgs += n));
    ProcessMessageSubGroupMulti(&inplaceInvalInfo->CurrentCmdInvalidMsgs,
                                RelCacheMsgs,
                                (memcpy(msgarray + nmsgs,
                                        msgs,
                                        n * sizeof(SharedInvalidationMessage)),
                                 nmsgs += n));
    Assert(nmsgs == nummsgs);
 
    return nmsgs;
}

References Assert(), CatCacheMsgs, InvalidationInfo::CurrentCmdInvalidMsgs, inplaceInvalInfo, NumMessagesInGroup, palloc(), ProcessMessageSubGroupMulti, InvalidationInfo::RelcacheInitFileInval, and RelCacheMsgs.

Referenced by heap_inplace_update_and_unlock().

LocalExecuteInvalidationMessage()

void LocalExecuteInvalidationMessage

(

SharedInvalidationMessage *

msg

)

Definition at line 823 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;
        smgrreleaserellocator(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 if (msg->id == SHAREDINVALRELSYNC_ID)
    {
        /* We only care about our own database */
        if (msg->rs.dbId == MyDatabaseId)
            CallRelSyncCallbacks(msg->rs.relid);
    }
    else
        elog(FATAL, "unrecognized SI message ID: %d", msg->id);
}

References RELCACHECALLBACK::arg, RelFileLocatorBackend::backend, SharedInvalSmgrMsg::backend_hi, SharedInvalSmgrMsg::backend_lo, CallRelSyncCallbacks(), CallSyscacheCallbacks(), SharedInvalidationMessage::cat, CatalogCacheFlushCatalog(), SharedInvalCatalogMsg::catId, SharedInvalidationMessage::cc, SharedInvalCatcacheMsg::dbId, SharedInvalCatalogMsg::dbId, SharedInvalRelcacheMsg::dbId, SharedInvalRelmapMsg::dbId, SharedInvalSnapshotMsg::dbId, SharedInvalRelSyncMsg::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, SharedInvalRelSyncMsg::relid, SharedInvalSmgrMsg::rlocator, SharedInvalidationMessage::rm, SharedInvalidationMessage::rs, SHAREDINVALCATALOG_ID, SHAREDINVALRELCACHE_ID, SHAREDINVALRELMAP_ID, SHAREDINVALRELSYNC_ID, SHAREDINVALSMGR_ID, SHAREDINVALSNAPSHOT_ID, SharedInvalidationMessage::sm, smgrreleaserellocator(), SharedInvalidationMessage::sn, and SysCacheInvalidate().

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

ProcessCatchupInterrupt()

void ProcessCatchupInterrupt

(

void

)

Definition at line 174 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 ProcessAutoVacLauncherInterrupts(), and ProcessClientReadInterrupt().

ProcessCommittedInvalidationMessages()

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

Definition at line 1135 of file inval.c.

{
    if (nmsgs <= 0)
        return;
 
    elog(DEBUG4, "replaying commit with %d messages%s", nmsgs,
         (RelcacheInitFileInval ? " and relcache file invalidation" : ""));
 
    if (RelcacheInitFileInval)
    {
        elog(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(), and SendSharedInvalidMessages().

Referenced by heap_xlog_inplace(), standby_redo(), and xact_redo_commit().

ReceiveSharedInvalidMessages()

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

Definition at line 69 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 47 of file sinval.c.

{
    SIInsertDataEntries(msgs, n);
}

References SIInsertDataEntries().

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

xactGetCommittedInvalidationMessages()

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

Definition at line 1012 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->ii.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->ii.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->ii.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->ii.CurrentCmdInvalidMsgs,
                                RelCacheMsgs,
                                (memcpy(msgarray + nmsgs,
                                        msgs,
                                        n * sizeof(SharedInvalidationMessage)),
                                 nmsgs += n));
    Assert(nmsgs == nummsgs);
 
    return nmsgs;
}

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

Referenced by RecordTransactionCommit(), and StartPrepare().

Variable Documentation

catchupInterruptPending

PGDLLIMPORT volatile sig_atomic_t catchupInterruptPending

extern

Definition at line 39 of file sinval.c.

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

SharedInvalidMessageCounter

PGDLLIMPORT uint64 SharedInvalidMessageCounter

extern

Definition at line 24 of file sinval.c.

Referenced by get_object_address(), RangeVarGetAndCheckCreationNamespace(), RangeVarGetRelidExtended(), and ReceiveSharedInvalidMessages().