inval.c File Reference

#include "postgres.h"
#include <limits.h>
#include "access/htup_details.h"
#include "access/xact.h"
#include "access/xloginsert.h"
#include "catalog/catalog.h"
#include "catalog/pg_constraint.h"
#include "miscadmin.h"
#include "storage/procnumber.h"
#include "storage/sinval.h"
#include "storage/smgr.h"
#include "utils/catcache.h"
#include "utils/injection_point.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:

Go to the source code of this file.

Data Structures
struct	InvalMessageArray
struct	InvalidationMsgsGroup
struct	InvalidationInfo
struct	TransInvalidationInfo
struct	SYSCACHECALLBACK
struct	RELCACHECALLBACK
struct	RELSYNCCALLBACK

Macros
#define	CatCacheMsgs   0
#define	RelCacheMsgs   1
#define	SetSubGroupToFollow(targetgroup, priorgroup, subgroup)
#define	SetGroupToFollow(targetgroup, priorgroup)
#define	NumMessagesInSubGroup(group, subgroup)    ((group)->nextmsg[subgroup] - (group)->firstmsg[subgroup])
#define	NumMessagesInGroup(group)
#define	MAX_SYSCACHE_CALLBACKS   64
#define	MAX_RELCACHE_CALLBACKS   10
#define	MAX_RELSYNC_CALLBACKS   10
#define	ProcessMessageSubGroup(group, subgroup, codeFragment)
#define	ProcessMessageSubGroupMulti(group, subgroup, codeFragment)

Typedefs
typedef struct InvalMessageArray	InvalMessageArray
typedef struct InvalidationMsgsGroup	InvalidationMsgsGroup
typedef struct InvalidationInfo	InvalidationInfo
typedef struct TransInvalidationInfo	TransInvalidationInfo

Functions
static void	AddInvalidationMessage (InvalidationMsgsGroup *group, int subgroup, const SharedInvalidationMessage *msg)
static void	AppendInvalidationMessageSubGroup (InvalidationMsgsGroup *dest, InvalidationMsgsGroup *src, int subgroup)
static void	AddCatcacheInvalidationMessage (InvalidationMsgsGroup *group, int id, uint32 hashValue, Oid dbId)
static void	AddCatalogInvalidationMessage (InvalidationMsgsGroup *group, Oid dbId, Oid catId)
static void	AddRelcacheInvalidationMessage (InvalidationMsgsGroup *group, Oid dbId, Oid relId)
static void	AddRelsyncInvalidationMessage (InvalidationMsgsGroup *group, Oid dbId, Oid relId)
static void	AddSnapshotInvalidationMessage (InvalidationMsgsGroup *group, Oid dbId, Oid relId)
static void	AppendInvalidationMessages (InvalidationMsgsGroup *dest, InvalidationMsgsGroup *src)
static void	ProcessInvalidationMessages (InvalidationMsgsGroup *group, void(*func)(SharedInvalidationMessage *msg))
static void	ProcessInvalidationMessagesMulti (InvalidationMsgsGroup *group, void(*func)(const SharedInvalidationMessage *msgs, int n))
static void	RegisterCatcacheInvalidation (int cacheId, uint32 hashValue, Oid dbId, void *context)
static void	RegisterCatalogInvalidation (InvalidationInfo *info, Oid dbId, Oid catId)
static void	RegisterRelcacheInvalidation (InvalidationInfo *info, Oid dbId, Oid relId)
static void	RegisterRelsyncInvalidation (InvalidationInfo *info, Oid dbId, Oid relId)
static void	RegisterSnapshotInvalidation (InvalidationInfo *info, Oid dbId, Oid relId)
static InvalidationInfo *	PrepareInvalidationState (void)
static InvalidationInfo *	PrepareInplaceInvalidationState (void)
void	InvalidateSystemCachesExtended (bool debug_discard)
void	LocalExecuteInvalidationMessage (SharedInvalidationMessage *msg)
void	InvalidateSystemCaches (void)
void	AcceptInvalidationMessages (void)
void	PostPrepare_Inval (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	AtEOXact_Inval (bool isCommit)
void	PreInplace_Inval (void)
void	AtInplace_Inval (void)
void	ForgetInplace_Inval (void)
void	AtEOSubXact_Inval (bool isCommit)
void	CommandEndInvalidationMessages (void)
static void	CacheInvalidateHeapTupleCommon (Relation relation, HeapTuple tuple, HeapTuple newtuple, InvalidationInfo *(*prepare_callback)(void))
void	CacheInvalidateHeapTuple (Relation relation, HeapTuple tuple, HeapTuple newtuple)
void	CacheInvalidateHeapTupleInplace (Relation relation, HeapTuple key_equivalent_tuple)
void	CacheInvalidateCatalog (Oid catalogId)
void	CacheInvalidateRelcache (Relation relation)
void	CacheInvalidateRelcacheAll (void)
void	CacheInvalidateRelcacheByTuple (HeapTuple classTuple)
void	CacheInvalidateRelcacheByRelid (Oid relid)
void	CacheInvalidateRelSync (Oid relid)
void	CacheInvalidateRelSyncAll (void)
void	CacheInvalidateSmgr (RelFileLocatorBackend rlocator)
void	CacheInvalidateRelmap (Oid databaseId)
void	CacheRegisterSyscacheCallback (int cacheid, SyscacheCallbackFunction func, Datum arg)
void	CacheRegisterRelcacheCallback (RelcacheCallbackFunction func, Datum arg)
void	CacheRegisterRelSyncCallback (RelSyncCallbackFunction func, Datum arg)
void	CallSyscacheCallbacks (int cacheid, uint32 hashvalue)
void	CallRelSyncCallbacks (Oid relid)
void	LogLogicalInvalidations (void)

Variables
static InvalMessageArray	InvalMessageArrays [2]
static TransInvalidationInfo *	transInvalInfo = NULL
static InvalidationInfo *	inplaceInvalInfo = NULL
int	debug_discard_caches = 0
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
static struct RELSYNCCALLBACK	relsync_callback_list [MAX_RELSYNC_CALLBACKS]
static int	relsync_callback_count = 0

Macro Definition Documentation

CatCacheMsgs

#define CatCacheMsgs   0

Definition at line 171 of file inval.c.

MAX_RELCACHE_CALLBACKS

#define MAX_RELCACHE_CALLBACKS   10

Definition at line 273 of file inval.c.

MAX_RELSYNC_CALLBACKS

#define MAX_RELSYNC_CALLBACKS   10

Definition at line 274 of file inval.c.

MAX_SYSCACHE_CALLBACKS

#define MAX_SYSCACHE_CALLBACKS   64

Definition at line 272 of file inval.c.

NumMessagesInGroup

#define NumMessagesInGroup

(

group

)

Value:

    (NumMessagesInSubGroup(group, CatCacheMsgs) + \
	 NumMessagesInSubGroup(group, RelCacheMsgs))

Definition at line 207 of file inval.c.

{
    /* Events emitted by current command */
    InvalidationMsgsGroup CurrentCmdInvalidMsgs;
 
    /* init file must be invalidated? */
    bool        RelcacheInitFileInval;
} InvalidationInfo;
 
/* subclass adding fields specific to transactional invalidation */
typedef struct TransInvalidationInfo
{
    /* Base class */
    struct InvalidationInfo ii;
 
    /* Events emitted by previous commands of this (sub)transaction */
    InvalidationMsgsGroup PriorCmdInvalidMsgs;
 
    /* Back link to parent transaction's info */
    struct TransInvalidationInfo *parent;
 
    /* Subtransaction nesting depth */
    int         my_level;
} TransInvalidationInfo;
 
static TransInvalidationInfo *transInvalInfo = NULL;
 
static InvalidationInfo *inplaceInvalInfo = NULL;
 
/* GUC storage */
int         debug_discard_caches = 0;
 
/*
 * Dynamically-registered callback functions.  Current implementation
 * assumes there won't be enough of these to justify a dynamically resizable
 * array; it'd be easy to improve that if needed.
 *
 * To avoid searching in CallSyscacheCallbacks, all callbacks for a given
 * syscache are linked into a list pointed to by syscache_callback_links[id].
 * The link values are syscache_callback_list[] index plus 1, or 0 for none.
 */
 
#define MAX_SYSCACHE_CALLBACKS 64
#define MAX_RELCACHE_CALLBACKS 10
#define MAX_RELSYNC_CALLBACKS 10
 
static struct SYSCACHECALLBACK
{
    int16       id;             /* cache number */
    int16       link;           /* next callback index+1 for same cache */
    SyscacheCallbackFunction function;
    Datum       arg;
}           syscache_callback_list[MAX_SYSCACHE_CALLBACKS];
 
static int16 syscache_callback_links[SysCacheSize];
 
static int  syscache_callback_count = 0;
 
static struct RELCACHECALLBACK
{
    RelcacheCallbackFunction function;
    Datum       arg;
}           relcache_callback_list[MAX_RELCACHE_CALLBACKS];
 
static int  relcache_callback_count = 0;
 
static struct RELSYNCCALLBACK
{
    RelSyncCallbackFunction function;
    Datum       arg;
}           relsync_callback_list[MAX_RELSYNC_CALLBACKS];
 
static int  relsync_callback_count = 0;
 
 
/* ----------------------------------------------------------------
 *              Invalidation subgroup support functions
 * ----------------------------------------------------------------
 */
 
/*
 * AddInvalidationMessage
 *      Add an invalidation message to a (sub)group.
 *
 * The group must be the last active one, since we assume we can add to the
 * end of the relevant InvalMessageArray.
 *
 * subgroup must be CatCacheMsgs or RelCacheMsgs.
 */
static void
AddInvalidationMessage(InvalidationMsgsGroup *group, int subgroup,
                       const SharedInvalidationMessage *msg)
{
    InvalMessageArray *ima = &InvalMessageArrays[subgroup];
    int         nextindex = group->nextmsg[subgroup];
 
    if (nextindex >= ima->maxmsgs)
    {
        if (ima->msgs == NULL)
        {
            /* Create new storage array in TopTransactionContext */
            int         reqsize = 32;   /* arbitrary */
 
            ima->msgs = (SharedInvalidationMessage *)
                MemoryContextAlloc(TopTransactionContext,
                                   reqsize * sizeof(SharedInvalidationMessage));
            ima->maxmsgs = reqsize;
            Assert(nextindex == 0);
        }
        else
        {
            /* Enlarge storage array */
            int         reqsize = 2 * ima->maxmsgs;
 
            ima->msgs = (SharedInvalidationMessage *)
                repalloc(ima->msgs,
                         reqsize * sizeof(SharedInvalidationMessage));
            ima->maxmsgs = reqsize;
        }
    }
    /* Okay, add message to current group */
    ima->msgs[nextindex] = *msg;
    group->nextmsg[subgroup]++;
}
 
/*
 * Append one subgroup of invalidation messages to another, resetting
 * the source subgroup to empty.
 */
static void
AppendInvalidationMessageSubGroup(InvalidationMsgsGroup *dest,
                                  InvalidationMsgsGroup *src,
                                  int subgroup)
{
    /* Messages must be adjacent in main array */
    Assert(dest->nextmsg[subgroup] == src->firstmsg[subgroup]);
 
    /* ... which makes this easy: */
    dest->nextmsg[subgroup] = src->nextmsg[subgroup];
 
    /*
     * This is handy for some callers and irrelevant for others.  But we do it
     * always, reasoning that it's bad to leave different groups pointing at
     * the same fragment of the message array.
     */
    SetSubGroupToFollow(src, dest, subgroup);
}
 
/*
 * Process a subgroup of invalidation messages.
 *
 * This is a macro that executes the given code fragment for each message in
 * a message subgroup.  The fragment should refer to the message as *msg.
 */
#define ProcessMessageSubGroup(group, subgroup, codeFragment) \
    do { \
        int     _msgindex = (group)->firstmsg[subgroup]; \
        int     _endmsg = (group)->nextmsg[subgroup]; \
        for (; _msgindex < _endmsg; _msgindex++) \
        { \
            SharedInvalidationMessage *msg = \
                &InvalMessageArrays[subgroup].msgs[_msgindex]; \
            codeFragment; \
        } \
    } while (0)
 
/*
 * Process a subgroup of invalidation messages as an array.
 *
 * As above, but the code fragment can handle an array of messages.
 * The fragment should refer to the messages as msgs[], with n entries.
 */
#define ProcessMessageSubGroupMulti(group, subgroup, codeFragment) \
    do { \
        int     n = NumMessagesInSubGroup(group, subgroup); \
        if (n > 0) { \
            SharedInvalidationMessage *msgs = \
                &InvalMessageArrays[subgroup].msgs[(group)->firstmsg[subgroup]]; \
            codeFragment; \
        } \
    } while (0)
 
 
/* ----------------------------------------------------------------
 *              Invalidation group support functions
 *
 * These routines understand about the division of a logical invalidation
 * group into separate physical arrays for catcache and relcache entries.
 * ----------------------------------------------------------------
 */
 
/*
 * Add a catcache inval entry
 */
static void
AddCatcacheInvalidationMessage(InvalidationMsgsGroup *group,
                               int id, uint32 hashValue, Oid dbId)
{
    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(group, CatCacheMsgs, &msg);
}
 
/*
 * Add a whole-catalog inval entry
 */
static void
AddCatalogInvalidationMessage(InvalidationMsgsGroup *group,
                              Oid dbId, Oid catId)
{
    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(group, CatCacheMsgs, &msg);
}
 
/*
 * Add a relcache inval entry
 */
static void
AddRelcacheInvalidationMessage(InvalidationMsgsGroup *group,
                               Oid dbId, Oid relId)
{
    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.
     */
    ProcessMessageSubGroup(group, RelCacheMsgs,
                           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(group, RelCacheMsgs, &msg);
}
 
/*
 * Add a relsync inval entry
 *
 * We put these into the relcache subgroup for simplicity. This message is the
 * same as AddRelcacheInvalidationMessage() except that it is for
 * RelationSyncCache maintained by decoding plugin pgoutput.
 */
static void
AddRelsyncInvalidationMessage(InvalidationMsgsGroup *group,
                              Oid dbId, Oid relId)
{
    SharedInvalidationMessage msg;
 
    /* Don't add a duplicate item. */
    ProcessMessageSubGroup(group, RelCacheMsgs,
                           if (msg->rc.id == SHAREDINVALRELSYNC_ID &&
                               (msg->rc.relId == relId ||
                                msg->rc.relId == InvalidOid))
                           return);
 
    /* OK, add the item */
    msg.rc.id = SHAREDINVALRELSYNC_ID;
    msg.rc.dbId = dbId;
    msg.rc.relId = relId;
    /* check AddCatcacheInvalidationMessage() for an explanation */
    VALGRIND_MAKE_MEM_DEFINED(&msg, sizeof(msg));
 
    AddInvalidationMessage(group, RelCacheMsgs, &msg);
}
 
/*
 * Add a snapshot inval entry
 *
 * We put these into the relcache subgroup for simplicity.
 */
static void
AddSnapshotInvalidationMessage(InvalidationMsgsGroup *group,
                               Oid dbId, Oid relId)
{
    SharedInvalidationMessage msg;
 
    /* Don't add a duplicate item */
    /* We assume dbId need not be checked because it will never change */
    ProcessMessageSubGroup(group, RelCacheMsgs,
                           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(group, RelCacheMsgs, &msg);
}
 
/*
 * Append one group of invalidation messages to another, resetting
 * the source group to empty.
 */
static void
AppendInvalidationMessages(InvalidationMsgsGroup *dest,
                           InvalidationMsgsGroup *src)
{
    AppendInvalidationMessageSubGroup(dest, src, CatCacheMsgs);
    AppendInvalidationMessageSubGroup(dest, src, RelCacheMsgs);
}
 
/*
 * Execute the given function for all the messages in an invalidation group.
 * The group is not altered.
 *
 * catcache entries are processed first, for reasons mentioned above.
 */
static void
ProcessInvalidationMessages(InvalidationMsgsGroup *group,
                            void (*func) (SharedInvalidationMessage *msg))
{
    ProcessMessageSubGroup(group, CatCacheMsgs, func(msg));
    ProcessMessageSubGroup(group, RelCacheMsgs, func(msg));
}
 
/*
 * As above, but the function is able to process an array of messages
 * rather than just one at a time.
 */
static void
ProcessInvalidationMessagesMulti(InvalidationMsgsGroup *group,
                                 void (*func) (const SharedInvalidationMessage *msgs, int n))
{
    ProcessMessageSubGroupMulti(group, CatCacheMsgs, func(msgs, n));
    ProcessMessageSubGroupMulti(group, RelCacheMsgs, func(msgs, n));
}
 
/* ----------------------------------------------------------------
 *                    private support functions
 * ----------------------------------------------------------------
 */
 
/*
 * RegisterCatcacheInvalidation
 *
 * Register an invalidation event for a catcache tuple entry.
 */
static void
RegisterCatcacheInvalidation(int cacheId,
                             uint32 hashValue,
                             Oid dbId,
                             void *context)
{
    InvalidationInfo *info = (InvalidationInfo *) context;
 
    AddCatcacheInvalidationMessage(&info->CurrentCmdInvalidMsgs,
                                   cacheId, hashValue, dbId);
}
 
/*
 * RegisterCatalogInvalidation
 *
 * Register an invalidation event for all catcache entries from a catalog.
 */
static void
RegisterCatalogInvalidation(InvalidationInfo *info, Oid dbId, Oid catId)
{
    AddCatalogInvalidationMessage(&info->CurrentCmdInvalidMsgs, dbId, catId);
}
 
/*
 * RegisterRelcacheInvalidation
 *
 * As above, but register a relcache invalidation event.
 */
static void
RegisterRelcacheInvalidation(InvalidationInfo *info, Oid dbId, Oid relId)
{
    AddRelcacheInvalidationMessage(&info->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))
        info->RelcacheInitFileInval = true;
}
 
/*
 * RegisterRelsyncInvalidation
 *
 * As above, but register a relsynccache invalidation event.
 */
static void
RegisterRelsyncInvalidation(InvalidationInfo *info, Oid dbId, Oid relId)
{
    AddRelsyncInvalidationMessage(&info->CurrentCmdInvalidMsgs, dbId, relId);
}
 
/*
 * RegisterSnapshotInvalidation
 *
 * Register an invalidation event for MVCC scans against a given catalog.
 * Only needed for catalogs that don't have catcaches.
 */
static void
RegisterSnapshotInvalidation(InvalidationInfo *info, Oid dbId, Oid relId)
{
    AddSnapshotInvalidationMessage(&info->CurrentCmdInvalidMsgs, dbId, relId);
}
 
/*
 * PrepareInvalidationState
 *      Initialize inval data for the current (sub)transaction.
 */
static InvalidationInfo *
PrepareInvalidationState(void)
{
    TransInvalidationInfo *myInfo;
 
    /* PrepareToInvalidateCacheTuple() needs relcache */
    AssertCouldGetRelation();
    /* Can't queue transactional message while collecting inplace messages. */
    Assert(inplaceInvalInfo == NULL);
 
    if (transInvalInfo != NULL &&
        transInvalInfo->my_level == GetCurrentTransactionNestLevel())
        return (InvalidationInfo *) transInvalInfo;
 
    myInfo = (TransInvalidationInfo *)
        MemoryContextAllocZero(TopTransactionContext,
                               sizeof(TransInvalidationInfo));
    myInfo->parent = transInvalInfo;
    myInfo->my_level = GetCurrentTransactionNestLevel();
 
    /* Now, do we have a previous stack entry? */
    if (transInvalInfo != NULL)
    {
        /* Yes; this one should be for a deeper nesting level. */
        Assert(myInfo->my_level > transInvalInfo->my_level);
 
        /*
         * The parent (sub)transaction must not have any current (i.e.,
         * not-yet-locally-processed) messages.  If it did, we'd have a
         * semantic problem: the new subtransaction presumably ought not be
         * able to see those events yet, but since the CommandCounter is
         * linear, that can't work once the subtransaction advances the
         * counter.  This is a convenient place to check for that, as well as
         * being important to keep management of the message arrays simple.
         */
        if (NumMessagesInGroup(&transInvalInfo->ii.CurrentCmdInvalidMsgs) != 0)
            elog(ERROR, "cannot start a subtransaction when there are unprocessed inval messages");
 
        /*
         * MemoryContextAllocZero set firstmsg = nextmsg = 0 in each group,
         * which is fine for the first (sub)transaction, but otherwise we need
         * to update them to follow whatever is already in the arrays.
         */
        SetGroupToFollow(&myInfo->PriorCmdInvalidMsgs,
                         &transInvalInfo->ii.CurrentCmdInvalidMsgs);
        SetGroupToFollow(&myInfo->ii.CurrentCmdInvalidMsgs,
                         &myInfo->PriorCmdInvalidMsgs);
    }
    else
    {
        /*
         * Here, we need only clear any array pointers left over from a prior
         * transaction.
         */
        InvalMessageArrays[CatCacheMsgs].msgs = NULL;
        InvalMessageArrays[CatCacheMsgs].maxmsgs = 0;
        InvalMessageArrays[RelCacheMsgs].msgs = NULL;
        InvalMessageArrays[RelCacheMsgs].maxmsgs = 0;
    }
 
    transInvalInfo = myInfo;
    return (InvalidationInfo *) myInfo;
}
 
/*
 * PrepareInplaceInvalidationState
 *      Initialize inval data for an inplace update.
 *
 * See previous function for more background.
 */
static InvalidationInfo *
PrepareInplaceInvalidationState(void)
{
    InvalidationInfo *myInfo;
 
    AssertCouldGetRelation();
    /* limit of one inplace update under assembly */
    Assert(inplaceInvalInfo == NULL);
 
    /* gone after WAL insertion CritSection ends, so use current context */
    myInfo = palloc0_object(InvalidationInfo);
 
    /* Stash our messages past end of the transactional messages, if any. */
    if (transInvalInfo != NULL)
        SetGroupToFollow(&myInfo->CurrentCmdInvalidMsgs,
                         &transInvalInfo->ii.CurrentCmdInvalidMsgs);
    else
    {
        InvalMessageArrays[CatCacheMsgs].msgs = NULL;
        InvalMessageArrays[CatCacheMsgs].maxmsgs = 0;
        InvalMessageArrays[RelCacheMsgs].msgs = NULL;
        InvalMessageArrays[RelCacheMsgs].maxmsgs = 0;
    }
 
    inplaceInvalInfo = myInfo;
    return myInfo;
}
 
/* ----------------------------------------------------------------
 *                    public functions
 * ----------------------------------------------------------------
 */
 
void
InvalidateSystemCachesExtended(bool debug_discard)
{
    int         i;
 
    InvalidateCatalogSnapshot();
    ResetCatalogCachesExt(debug_discard);
    RelationCacheInvalidate(debug_discard); /* 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);
    }
 
    for (i = 0; i < relsync_callback_count; i++)
    {
        struct RELSYNCCALLBACK *ccitem = relsync_callback_list + i;
 
        ccitem->function(ccitem->arg, InvalidOid);
    }
}
 
/*
 * LocalExecuteInvalidationMessage
 *
 * Process a single invalidation message (which could be of any type).
 * Only the local caches are flushed; this does not transmit the message
 * to other backends.
 */
void
LocalExecuteInvalidationMessage(SharedInvalidationMessage *msg)
{
    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);
}
 
/*
 *      InvalidateSystemCaches
 *
 *      This blows away all tuples in the system catalog caches and
 *      all the cached relation descriptors and smgr cache entries.
 *      Relation descriptors that have positive refcounts are then rebuilt.
 *
 *      We call this when we see a shared-inval-queue overflow signal,
 *      since that tells us we've lost some shared-inval messages and hence
 *      don't know what needs to be invalidated.
 */
void
InvalidateSystemCaches(void)
{
    InvalidateSystemCachesExtended(false);
}
 
/*
 * AcceptInvalidationMessages
 *      Read and process invalidation messages from the shared invalidation
 *      message queue.
 *
 * Note:
 *      This should be called as the first step in processing a transaction.
 */
void
AcceptInvalidationMessages(void)
{
#ifdef USE_ASSERT_CHECKING
    /* message handlers shall access catalogs only during transactions */
    if (IsTransactionState())
        AssertCouldGetRelation();
#endif
 
    ReceiveSharedInvalidMessages(LocalExecuteInvalidationMessage,
                                 InvalidateSystemCaches);
 
    /*----------
     * Test code to force cache flushes anytime a flush could happen.
     *
     * This helps detect intermittent faults caused by code that reads a cache
     * entry and then performs an action that could invalidate the entry, but
     * rarely actually does so.  This can spot issues that would otherwise
     * only arise with badly timed concurrent DDL, for example.
     *
     * The default debug_discard_caches = 0 does no forced cache flushes.
     *
     * If used with CLOBBER_FREED_MEMORY,
     * debug_discard_caches = 1 (formerly known as 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
     * debug_discard_caches = 3 (formerly known as 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.
     *----------
     */
#ifdef DISCARD_CACHES_ENABLED
    {
        static int  recursion_depth = 0;
 
        if (recursion_depth < debug_discard_caches)
        {
            recursion_depth++;
            InvalidateSystemCachesExtended(true);
            recursion_depth--;
        }
    }
#endif
}
 
/*
 * PostPrepare_Inval
 *      Clean up after successful PREPARE.
 *
 * Here, we want to act as though the transaction aborted, so that we will
 * undo any syscache changes it made, thereby bringing us into sync with the
 * outside world, which doesn't believe the transaction committed yet.
 *
 * If the prepared transaction is later aborted, there is nothing more to
 * do; if it commits, we will receive the consequent inval messages just
 * like everyone else.
 */
void
PostPrepare_Inval(void)
{
    AtEOXact_Inval(false);
}
 
/*
 * xactGetCommittedInvalidationMessages() is called by
 * RecordTransactionCommit() to collect invalidation messages to add to the
 * commit record. This applies only to commit message types, never to
 * abort records. Must always run before AtEOXact_Inval(), since that
 * removes the data we need to see.
 *
 * Remember that this runs before we have officially committed, so we
 * must not do anything here to change what might occur *if* we should
 * fail between here and the actual commit.
 *
 * see also xact_redo_commit() and xact_desc_commit()
 */
int
xactGetCommittedInvalidationMessages(SharedInvalidationMessage **msgs,
                                     bool *RelcacheInitFileInval)
{
    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;
}
 
/*
 * inplaceGetInvalidationMessages() is called by the inplace update to collect
 * invalidation messages to add to its WAL record.  Like the previous
 * function, we might still fail.
 */
int
inplaceGetInvalidationMessages(SharedInvalidationMessage **msgs,
                               bool *RelcacheInitFileInval)
{
    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;
}
 
/*
 * ProcessCommittedInvalidationMessages is executed by xact_redo_commit() or
 * standby_redo() to process invalidation messages. Currently that happens
 * only at end-of-xact.
 *
 * Relcache init file invalidation requires processing both
 * before and after we send the SI messages. See AtEOXact_Inval()
 */
void
ProcessCommittedInvalidationMessages(SharedInvalidationMessage *msgs,
                                     int nmsgs, bool RelcacheInitFileInval,
                                     Oid dbid, Oid tsid)
{
    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();
}
 
/*
 * AtEOXact_Inval
 *      Process queued-up invalidation messages at end of main transaction.
 *
 * If isCommit, we must send out the messages in our PriorCmdInvalidMsgs list
 * to the shared invalidation message queue.  Note that these will be read
 * not only by other backends, but also by our own backend at the next
 * transaction start (via AcceptInvalidationMessages).  This means that
 * we can skip immediate local processing of anything that's still in
 * CurrentCmdInvalidMsgs, and just send that list out too.
 *
 * If not isCommit, we are aborting, and must locally process the messages
 * in PriorCmdInvalidMsgs.  No messages need be sent to other backends,
 * since they'll not have seen our changed tuples anyway.  We can forget
 * about CurrentCmdInvalidMsgs too, since those changes haven't touched
 * the caches yet.
 *
 * In any case, reset our state to empty.  We need not physically
 * free memory here, since TopTransactionContext is about to be emptied
 * anyway.
 *
 * Note:
 *      This should be called as the last step in processing a transaction.
 */
void
AtEOXact_Inval(bool isCommit)
{
    inplaceInvalInfo = NULL;
 
    /* Quick exit if no transactional messages */
    if (transInvalInfo == NULL)
        return;
 
    /* Must be at top of stack */
    Assert(transInvalInfo->my_level == 1 && transInvalInfo->parent == NULL);
 
    INJECTION_POINT("transaction-end-process-inval", 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->ii.RelcacheInitFileInval)
            RelationCacheInitFilePreInvalidate();
 
        AppendInvalidationMessages(&transInvalInfo->PriorCmdInvalidMsgs,
                                   &transInvalInfo->ii.CurrentCmdInvalidMsgs);
 
        ProcessInvalidationMessagesMulti(&transInvalInfo->PriorCmdInvalidMsgs,
                                         SendSharedInvalidMessages);
 
        if (transInvalInfo->ii.RelcacheInitFileInval)
            RelationCacheInitFilePostInvalidate();
    }
    else
    {
        ProcessInvalidationMessages(&transInvalInfo->PriorCmdInvalidMsgs,
                                    LocalExecuteInvalidationMessage);
    }
 
    /* Need not free anything explicitly */
    transInvalInfo = NULL;
}
 
/*
 * PreInplace_Inval
 *      Process queued-up invalidation before inplace update critical section.
 *
 * Tasks belong here if they are safe even if the inplace update does not
 * complete.  Currently, this just unlinks a cache file, which can fail.  The
 * sum of this and AtInplace_Inval() mirrors AtEOXact_Inval(isCommit=true).
 */
void
PreInplace_Inval(void)
{
    Assert(CritSectionCount == 0);
 
    if (inplaceInvalInfo && inplaceInvalInfo->RelcacheInitFileInval)
        RelationCacheInitFilePreInvalidate();
}
 
/*
 * AtInplace_Inval
 *      Process queued-up invalidations after inplace update buffer mutation.
 */
void
AtInplace_Inval(void)
{
    Assert(CritSectionCount > 0);
 
    if (inplaceInvalInfo == NULL)
        return;
 
    ProcessInvalidationMessagesMulti(&inplaceInvalInfo->CurrentCmdInvalidMsgs,
                                     SendSharedInvalidMessages);
 
    if (inplaceInvalInfo->RelcacheInitFileInval)
        RelationCacheInitFilePostInvalidate();
 
    inplaceInvalInfo = NULL;
}
 
/*
 * ForgetInplace_Inval
 *      Alternative to PreInplace_Inval()+AtInplace_Inval(): discard queued-up
 *      invalidations.  This lets inplace update enumerate invalidations
 *      optimistically, before locking the buffer.
 */
void
ForgetInplace_Inval(void)
{
    inplaceInvalInfo = NULL;
}
 
/*
 * AtEOSubXact_Inval
 *      Process queued-up invalidation messages at end of subtransaction.
 *
 * If isCommit, process CurrentCmdInvalidMsgs if any (there probably aren't),
 * and then attach both CurrentCmdInvalidMsgs and PriorCmdInvalidMsgs to the
 * parent's PriorCmdInvalidMsgs list.
 *
 * If not isCommit, we are aborting, and must locally process the messages
 * in PriorCmdInvalidMsgs.  No messages need be sent to other backends.
 * We can forget about CurrentCmdInvalidMsgs too, since those changes haven't
 * touched the caches yet.
 *
 * In any case, pop the transaction stack.  We need not physically free memory
 * here, since CurTransactionContext is about to be emptied anyway
 * (if aborting).  Beware of the possibility of aborting the same nesting
 * level twice, though.
 */
void
AtEOSubXact_Inval(bool isCommit)
{
    int         my_level;
    TransInvalidationInfo *myInfo;
 
    /*
     * Successful inplace update must clear this, but we clear it on abort.
     * Inplace updates allocate this in CurrentMemoryContext, which has
     * lifespan <= subtransaction lifespan.  Hence, don't free it explicitly.
     */
    if (isCommit)
        Assert(inplaceInvalInfo == NULL);
    else
        inplaceInvalInfo = NULL;
 
    /* Quick exit if no transactional messages. */
    myInfo = transInvalInfo;
    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.  Notice that we stick them in
         * PriorCmdInvalidMsgs, not CurrentCmdInvalidMsgs, since they've
         * already been locally processed.  (This would trigger the Assert in
         * AppendInvalidationMessageSubGroup if the parent's
         * CurrentCmdInvalidMsgs isn't empty; but we already checked that in
         * PrepareInvalidationState.)
         */
        AppendInvalidationMessages(&myInfo->parent->PriorCmdInvalidMsgs,
                                   &myInfo->PriorCmdInvalidMsgs);
 
        /* Must readjust parent's CurrentCmdInvalidMsgs indexes now */
        SetGroupToFollow(&myInfo->parent->ii.CurrentCmdInvalidMsgs,
                         &myInfo->parent->PriorCmdInvalidMsgs);
 
        /* Pending relcache inval becomes parent's problem too */
        if (myInfo->ii.RelcacheInitFileInval)
            myInfo->parent->ii.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);
    }
}
 
/*
 * CommandEndInvalidationMessages
 *      Process queued-up invalidation messages at end of one command
 *      in a transaction.
 *
 * Here, we send no messages to the shared queue, since we don't know yet if
 * we will commit.  We do need to locally process the CurrentCmdInvalidMsgs
 * list, so as to flush our caches of any entries we have outdated in the
 * current command.  We then move the current-cmd list over to become part
 * of the prior-cmds list.
 *
 * Note:
 *      This should be called during CommandCounterIncrement(),
 *      after we have advanced the command ID.
 */
void
CommandEndInvalidationMessages(void)
{
    /*
     * 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->ii.CurrentCmdInvalidMsgs,
                                LocalExecuteInvalidationMessage);
 
    /* WAL Log per-command invalidation messages for logical decoding */
    if (XLogLogicalInfoActive())
        LogLogicalInvalidations();
 
    AppendInvalidationMessages(&transInvalInfo->PriorCmdInvalidMsgs,
                               &transInvalInfo->ii.CurrentCmdInvalidMsgs);
}
 
 
/*
 * CacheInvalidateHeapTupleCommon
 *      Common logic for end-of-command and inplace variants.
 */
static void
CacheInvalidateHeapTupleCommon(Relation relation,
                               HeapTuple tuple,
                               HeapTuple newtuple,
                               InvalidationInfo *(*prepare_callback) (void))
{
    InvalidationInfo *info;
    Oid         tupleRelId;
    Oid         databaseId;
    Oid         relationId;
 
    /* PrepareToInvalidateCacheTuple() needs relcache */
    AssertCouldGetRelation();
 
    /* 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;
 
    /* Allocate any required resources. */
    info = prepare_callback();
 
    /*
     * First let the catcache do its thing
     */
    tupleRelId = RelationGetRelid(relation);
    if (RelationInvalidatesSnapshotsOnly(tupleRelId))
    {
        databaseId = IsSharedRelation(tupleRelId) ? InvalidOid : MyDatabaseId;
        RegisterSnapshotInvalidation(info, databaseId, tupleRelId);
    }
    else
        PrepareToInvalidateCacheTuple(relation, tuple, newtuple,
                                      RegisterCatcacheInvalidation,
                                      info);
 
    /*
     * 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(info, databaseId, relationId);
}
 
/*
 * CacheInvalidateHeapTuple
 *      Register the given tuple for invalidation at end of command
 *      (ie, current command is creating or outdating this tuple) and end of
 *      transaction.  Also, detect whether a relcache invalidation is implied.
 *
 * For an insert or delete, tuple is the target tuple and newtuple is NULL.
 * For an update, we are called just once, with tuple being the old tuple
 * version and newtuple the new version.  This allows avoidance of duplicate
 * effort during an update.
 */
void
CacheInvalidateHeapTuple(Relation relation,
                         HeapTuple tuple,
                         HeapTuple newtuple)
{
    CacheInvalidateHeapTupleCommon(relation, tuple, newtuple,
                                   PrepareInvalidationState);
}
 
/*
 * CacheInvalidateHeapTupleInplace
 *      Register the given tuple for nontransactional invalidation pertaining
 *      to an inplace update.  Also, detect whether a relcache invalidation is
 *      implied.
 *
 * Like CacheInvalidateHeapTuple(), but for inplace updates.
 *
 * Just before and just after the inplace update, the tuple's cache keys must
 * match those in key_equivalent_tuple.  Cache keys consist of catcache lookup
 * key columns and columns referencing pg_class.oid values,
 * e.g. pg_constraint.conrelid, which would trigger relcache inval.
 */
void
CacheInvalidateHeapTupleInplace(Relation relation,
                                HeapTuple key_equivalent_tuple)
{
    CacheInvalidateHeapTupleCommon(relation, key_equivalent_tuple, NULL,
                                   PrepareInplaceInvalidationState);
}
 
/*
 * CacheInvalidateCatalog
 *      Register invalidation of the whole content of a system catalog.
 *
 * This is normally used in VACUUM FULL/CLUSTER, where we haven't so much
 * changed any tuples as moved them around.  Some uses of catcache entries
 * expect their TIDs to be correct, so we have to blow away the entries.
 *
 * Note: we expect caller to verify that the rel actually is a system
 * catalog.  If it isn't, no great harm is done, just a wasted sinval message.
 */
void
CacheInvalidateCatalog(Oid catalogId)
{
    Oid         databaseId;
 
    if (IsSharedRelation(catalogId))
        databaseId = InvalidOid;
    else
        databaseId = MyDatabaseId;
 
    RegisterCatalogInvalidation(PrepareInvalidationState(),
                                databaseId, catalogId);
}
 
/*
 * CacheInvalidateRelcache
 *      Register invalidation of the specified relation's relcache entry
 *      at end of command.
 *
 * This is used in places that need to force relcache rebuild but aren't
 * changing any of the tuples recognized as contributors to the relcache
 * entry by CacheInvalidateHeapTuple.  (An example is dropping an index.)
 */
void
CacheInvalidateRelcache(Relation relation)
{
    Oid         databaseId;
    Oid         relationId;
 
    relationId = RelationGetRelid(relation);
    if (relation->rd_rel->relisshared)
        databaseId = InvalidOid;
    else
        databaseId = MyDatabaseId;
 
    RegisterRelcacheInvalidation(PrepareInvalidationState(),
                                 databaseId, relationId);
}
 
/*
 * CacheInvalidateRelcacheAll
 *      Register invalidation of the whole relcache at the end of command.
 *
 * This is used by alter publication as changes in publications may affect
 * large number of tables.
 */
void
CacheInvalidateRelcacheAll(void)
{
    RegisterRelcacheInvalidation(PrepareInvalidationState(),
                                 InvalidOid, InvalidOid);
}
 
/*
 * CacheInvalidateRelcacheByTuple
 *      As above, but relation is identified by passing its pg_class tuple.
 */
void
CacheInvalidateRelcacheByTuple(HeapTuple classTuple)
{
    Form_pg_class classtup = (Form_pg_class) GETSTRUCT(classTuple);
    Oid         databaseId;
    Oid         relationId;
 
    relationId = classtup->oid;
    if (classtup->relisshared)
        databaseId = InvalidOid;
    else
        databaseId = MyDatabaseId;
    RegisterRelcacheInvalidation(PrepareInvalidationState(),
                                 databaseId, relationId);
}
 
/*
 * CacheInvalidateRelcacheByRelid
 *      As above, but relation is identified by passing its OID.
 *      This is the least efficient of the three options; use one of
 *      the above routines if you have a Relation or pg_class tuple.
 */
void
CacheInvalidateRelcacheByRelid(Oid relid)
{
    HeapTuple   tup;
 
    tup = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
    if (!HeapTupleIsValid(tup))
        elog(ERROR, "cache lookup failed for relation %u", relid);
    CacheInvalidateRelcacheByTuple(tup);
    ReleaseSysCache(tup);
}
 
/*
 * CacheInvalidateRelSync
 *      Register invalidation of the cache in logical decoding output plugin
 *      for a database.
 *
 * This type of invalidation message is used for the specific purpose of output
 * plugins. Processes which do not decode WALs would do nothing even when it
 * receives the message.
 */
void
CacheInvalidateRelSync(Oid relid)
{
    RegisterRelsyncInvalidation(PrepareInvalidationState(),
                                MyDatabaseId, relid);
}
 
/*
 * CacheInvalidateRelSyncAll
 *      Register invalidation of the whole cache in logical decoding output
 *      plugin.
 */
void
CacheInvalidateRelSyncAll(void)
{
    CacheInvalidateRelSync(InvalidOid);
}
 
/*
 * CacheInvalidateSmgr
 *      Register invalidation of smgr references to a physical relation.
 *
 * Sending this type of invalidation msg forces other backends to close open
 * smgr entries for the rel.  This should be done to flush dangling open-file
 * references when the physical rel is being dropped or truncated.  Because
 * these are nontransactional (i.e., not-rollback-able) operations, we just
 * send the inval message immediately without any queuing.
 *
 * Note: in most cases there will have been a relcache flush issued against
 * the rel at the logical level.  We need a separate smgr-level flush because
 * it is possible for backends to have open smgr entries for rels they don't
 * have a relcache entry for, e.g. because the only thing they ever did with
 * the rel is write out dirty shared buffers.
 *
 * Note: because these messages are nontransactional, they won't be captured
 * in commit/abort WAL entries.  Instead, calls to CacheInvalidateSmgr()
 * should happen in low-level smgr.c routines, which are executed while
 * replaying WAL as well as when creating it.
 *
 * Note: In order to avoid bloating SharedInvalidationMessage, we store only
 * three bytes of the ProcNumber using what would otherwise be padding space.
 * Thus, the maximum possible ProcNumber is 2^23-1.
 */
void
CacheInvalidateSmgr(RelFileLocatorBackend rlocator)
{
    SharedInvalidationMessage msg;
 
    /* verify optimization stated above stays valid */
    StaticAssertDecl(MAX_BACKENDS_BITS <= 23,
                     "MAX_BACKENDS_BITS is too big for inval.c");
 
    msg.sm.id = SHAREDINVALSMGR_ID;
    msg.sm.backend_hi = rlocator.backend >> 16;
    msg.sm.backend_lo = rlocator.backend & 0xffff;
    msg.sm.rlocator = rlocator.locator;
    /* check AddCatcacheInvalidationMessage() for an explanation */
    VALGRIND_MAKE_MEM_DEFINED(&msg, sizeof(msg));
 
    SendSharedInvalidMessages(&msg, 1);
}
 
/*
 * CacheInvalidateRelmap
 *      Register invalidation of the relation mapping for a database,
 *      or for the shared catalogs if databaseId is zero.
 *
 * Sending this type of invalidation msg forces other backends to re-read
 * the indicated relation mapping file.  It is also necessary to send a
 * relcache inval for the specific relations whose mapping has been altered,
 * else the relcache won't get updated with the new filenode data.
 *
 * Note: because these messages are nontransactional, they won't be captured
 * in commit/abort WAL entries.  Instead, calls to CacheInvalidateRelmap()
 * should happen in low-level relmapper.c routines, which are executed while
 * replaying WAL as well as when creating it.
 */
void
CacheInvalidateRelmap(Oid databaseId)
{
    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);
}
 
 
/*
 * CacheRegisterSyscacheCallback
 *      Register the specified function to be called for all future
 *      invalidation events in the specified cache.  The cache ID and the
 *      hash value of the tuple being invalidated will be passed to the
 *      function.
 *
 * NOTE: Hash value zero will be passed if a cache reset request is received.
 * In this case the called routines should flush all cached state.
 * Yes, there's a possibility of a false match to zero, but it doesn't seem
 * worth troubling over, especially since most of the current callees just
 * flush all cached state anyway.
 */
void
CacheRegisterSyscacheCallback(int cacheid,
                              SyscacheCallbackFunction func,
                              Datum 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;
}
 
/*
 * CacheRegisterRelcacheCallback
 *      Register the specified function to be called for all future
 *      relcache invalidation events.  The OID of the relation being
 *      invalidated will be passed to the function.
 *
 * NOTE: InvalidOid will be passed if a cache reset request is received.
 * In this case the called routines should flush all cached state.
 */
void
CacheRegisterRelcacheCallback(RelcacheCallbackFunction func,
                              Datum arg)
{
    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;
}
 
/*
 * CacheRegisterRelSyncCallback
 *      Register the specified function to be called for all future
 *      relsynccache invalidation events.
 *
 * This function is intended to be call from the logical decoding output
 * plugins.
 */
void
CacheRegisterRelSyncCallback(RelSyncCallbackFunction func,
                             Datum arg)
{
    if (relsync_callback_count >= MAX_RELSYNC_CALLBACKS)
        elog(FATAL, "out of relsync_callback_list slots");
 
    relsync_callback_list[relsync_callback_count].function = func;
    relsync_callback_list[relsync_callback_count].arg = arg;
 
    ++relsync_callback_count;
}
 
/*
 * CallSyscacheCallbacks
 *
 * This is exported so that CatalogCacheFlushCatalog can call it, saving
 * this module from knowing which catcache IDs correspond to which catalogs.
 */
void
CallSyscacheCallbacks(int cacheid, uint32 hashvalue)
{
    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;
    }
}
 
/*
 * CallSyscacheCallbacks
 */
void
CallRelSyncCallbacks(Oid relid)
{
    for (int i = 0; i < relsync_callback_count; i++)
    {
        struct RELSYNCCALLBACK *ccitem = relsync_callback_list + i;
 
        ccitem->function(ccitem->arg, relid);
    }
}
 
/*
 * LogLogicalInvalidations
 *
 * Emit WAL for invalidations caused by the current command.
 *
 * This is currently only used for logging invalidations at the command end
 * or at commit time if any invalidations are pending.
 */
void
LogLogicalInvalidations(void)
{
    xl_xact_invals xlrec;
    InvalidationMsgsGroup *group;
    int         nmsgs;
 
    /* Quick exit if we haven't done anything with invalidation messages. */
    if (transInvalInfo == NULL)
        return;
 
    group = &transInvalInfo->ii.CurrentCmdInvalidMsgs;
    nmsgs = NumMessagesInGroup(group);
 
    if (nmsgs > 0)
    {
        /* prepare record */
        memset(&xlrec, 0, MinSizeOfXactInvals);
        xlrec.nmsgs = nmsgs;
 
        /* perform insertion */
        XLogBeginInsert();
        XLogRegisterData(&xlrec, MinSizeOfXactInvals);
        ProcessMessageSubGroupMulti(group, CatCacheMsgs,
                                    XLogRegisterData(msgs,
                                                     n * sizeof(SharedInvalidationMessage)));
        ProcessMessageSubGroupMulti(group, RelCacheMsgs,
                                    XLogRegisterData(msgs,
                                                     n * sizeof(SharedInvalidationMessage)));
        XLogInsert(RM_XACT_ID, XLOG_XACT_INVALIDATIONS);
    }
}

NumMessagesInSubGroup

#define NumMessagesInSubGroup	(		group,
			subgroup
	)		((group)->nextmsg[subgroup] - (group)->firstmsg[subgroup])

Definition at line 204 of file inval.c.

ProcessMessageSubGroup

#define ProcessMessageSubGroup	(		group,
			subgroup,
			codeFragment
	)

Value:

    do { \
        int     _msgindex = (group)->firstmsg[subgroup]; \
        int     _endmsg = (group)->nextmsg[subgroup]; \
		for (; _msgindex < _endmsg; _msgindex++) \
        { \
            SharedInvalidationMessage *msg = \
                &InvalMessageArrays[subgroup].msgs[_msgindex]; \
            codeFragment; \
        } \
    } while (0)

Definition at line 384 of file inval.c.

       { \
        int     _msgindex = (group)->firstmsg[subgroup]; \
        int     _endmsg = (group)->nextmsg[subgroup]; \
		for (; _msgindex < _endmsg; _msgindex++) \
        { \
            SharedInvalidationMessage *msg = \
                &InvalMessageArrays[subgroup].msgs[_msgindex]; \
            codeFragment; \
        } \
    } while (0)

ProcessMessageSubGroupMulti

#define ProcessMessageSubGroupMulti	(		group,
			subgroup,
			codeFragment
	)

Value:

    do { \
        int     n = NumMessagesInSubGroup(group, subgroup); \
		if (n > 0) { \
            SharedInvalidationMessage *msgs = \
                &InvalMessageArrays[subgroup].msgs[(group)->firstmsg[subgroup]]; \
            codeFragment; \
        } \
    } while (0)

Definition at line 402 of file inval.c.

       { \
        int     n = NumMessagesInSubGroup(group, subgroup); \
		if (n > 0) { \
            SharedInvalidationMessage *msgs = \
                &InvalMessageArrays[subgroup].msgs[(group)->firstmsg[subgroup]]; \
            codeFragment; \
        } \
    } while (0)

RelCacheMsgs

#define RelCacheMsgs   1

Definition at line 172 of file inval.c.

SetGroupToFollow

#define SetGroupToFollow	(		targetgroup,
			priorgroup
	)

Value:

    do { \
		SetSubGroupToFollow(targetgroup, priorgroup, CatCacheMsgs); \
		SetSubGroupToFollow(targetgroup, priorgroup, RelCacheMsgs); \
    } while (0)

Definition at line 198 of file inval.c.

       { \
		SetSubGroupToFollow(targetgroup, priorgroup, CatCacheMsgs); \
		SetSubGroupToFollow(targetgroup, priorgroup, RelCacheMsgs); \
    } while (0)

SetSubGroupToFollow

#define SetSubGroupToFollow	(		targetgroup,
			priorgroup,
			subgroup
	)

Value:

    do { \
        (targetgroup)->firstmsg[subgroup] = \
            (targetgroup)->nextmsg[subgroup] = \
            (priorgroup)->nextmsg[subgroup]; \
    } while (0)

Definition at line 191 of file inval.c.

       { \
        (targetgroup)->firstmsg[subgroup] = \
            (targetgroup)->nextmsg[subgroup] = \
            (priorgroup)->nextmsg[subgroup]; \
    } while (0)

Typedef Documentation

InvalidationInfo

typedef struct InvalidationInfo InvalidationInfo

InvalidationMsgsGroup

typedef struct InvalidationMsgsGroup InvalidationMsgsGroup

InvalMessageArray

typedef struct InvalMessageArray InvalMessageArray

TransInvalidationInfo

typedef struct TransInvalidationInfo TransInvalidationInfo

Function Documentation

AcceptInvalidationMessages()

void AcceptInvalidationMessages

(

void

)

Definition at line 930 of file inval.c.

{
#ifdef USE_ASSERT_CHECKING
    /* message handlers shall access catalogs only during transactions */
    if (IsTransactionState())
        AssertCouldGetRelation();
#endif
 
    ReceiveSharedInvalidMessages(LocalExecuteInvalidationMessage,
                                 InvalidateSystemCaches);
 
    /*----------
     * Test code to force cache flushes anytime a flush could happen.
     *
     * This helps detect intermittent faults caused by code that reads a cache
     * entry and then performs an action that could invalidate the entry, but
     * rarely actually does so.  This can spot issues that would otherwise
     * only arise with badly timed concurrent DDL, for example.
     *
     * The default debug_discard_caches = 0 does no forced cache flushes.
     *
     * If used with CLOBBER_FREED_MEMORY,
     * debug_discard_caches = 1 (formerly known as 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
     * debug_discard_caches = 3 (formerly known as 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.
     *----------
     */
#ifdef DISCARD_CACHES_ENABLED
    {
        static int  recursion_depth = 0;
 
        if (recursion_depth < debug_discard_caches)
        {
            recursion_depth++;
            InvalidateSystemCachesExtended(true);
            recursion_depth--;
        }
    }
#endif
}

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

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

AddCatalogInvalidationMessage()

static void AddCatalogInvalidationMessage ( InvalidationMsgsGroup *  group, Oid  dbId, Oid  catId  )

static

Definition at line 453 of file inval.c.

{
    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(group, CatCacheMsgs, &msg);
}

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

Referenced by RegisterCatalogInvalidation().

AddCatcacheInvalidationMessage()

static void AddCatcacheInvalidationMessage ( InvalidationMsgsGroup *  group, int  id, uint32  hashValue, Oid  dbId  )

static

Definition at line 425 of file inval.c.

{
    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(group, CatCacheMsgs, &msg);
}

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

Referenced by RegisterCatcacheInvalidation().

AddInvalidationMessage()

static void AddInvalidationMessage ( InvalidationMsgsGroup *  group, int  subgroup, const SharedInvalidationMessage *  msg  )

static

Definition at line 320 of file inval.c.

{
    InvalMessageArray *ima = &InvalMessageArrays[subgroup];
    int         nextindex = group->nextmsg[subgroup];
 
    if (nextindex >= ima->maxmsgs)
    {
        if (ima->msgs == NULL)
        {
            /* Create new storage array in TopTransactionContext */
            int         reqsize = 32;   /* arbitrary */
 
            ima->msgs = (SharedInvalidationMessage *)
                MemoryContextAlloc(TopTransactionContext,
                                   reqsize * sizeof(SharedInvalidationMessage));
            ima->maxmsgs = reqsize;
            Assert(nextindex == 0);
        }
        else
        {
            /* Enlarge storage array */
            int         reqsize = 2 * ima->maxmsgs;
 
            ima->msgs = (SharedInvalidationMessage *)
                repalloc(ima->msgs,
                         reqsize * sizeof(SharedInvalidationMessage));
            ima->maxmsgs = reqsize;
        }
    }
    /* Okay, add message to current group */
    ima->msgs[nextindex] = *msg;
    group->nextmsg[subgroup]++;
}

References Assert, fb(), InvalMessageArrays, MemoryContextAlloc(), InvalidationMsgsGroup::nextmsg, repalloc(), and TopTransactionContext.

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

AddRelcacheInvalidationMessage()

static void AddRelcacheInvalidationMessage ( InvalidationMsgsGroup *  group, Oid  dbId, Oid  relId  )

static

Definition at line 471 of file inval.c.

{
    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.
     */
    ProcessMessageSubGroup(group, RelCacheMsgs,
                           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(group, RelCacheMsgs, &msg);
}

References AddInvalidationMessage(), SharedInvalRelcacheMsg::dbId, SharedInvalRelcacheMsg::id, InvalidOid, ProcessMessageSubGroup, SharedInvalidationMessage::rc, RelCacheMsgs, SharedInvalRelcacheMsg::relId, SHAREDINVALRELCACHE_ID, and VALGRIND_MAKE_MEM_DEFINED.

Referenced by RegisterRelcacheInvalidation().

AddRelsyncInvalidationMessage()

static void AddRelsyncInvalidationMessage ( InvalidationMsgsGroup *  group, Oid  dbId, Oid  relId  )

static

Definition at line 505 of file inval.c.

{
    SharedInvalidationMessage msg;
 
    /* Don't add a duplicate item. */
    ProcessMessageSubGroup(group, RelCacheMsgs,
                           if (msg->rc.id == SHAREDINVALRELSYNC_ID &&
                               (msg->rc.relId == relId ||
                                msg->rc.relId == InvalidOid))
                           return);
 
    /* OK, add the item */
    msg.rc.id = SHAREDINVALRELSYNC_ID;
    msg.rc.dbId = dbId;
    msg.rc.relId = relId;
    /* check AddCatcacheInvalidationMessage() for an explanation */
    VALGRIND_MAKE_MEM_DEFINED(&msg, sizeof(msg));
 
    AddInvalidationMessage(group, RelCacheMsgs, &msg);
}

References AddInvalidationMessage(), SharedInvalRelcacheMsg::dbId, SharedInvalRelcacheMsg::id, InvalidOid, ProcessMessageSubGroup, SharedInvalidationMessage::rc, RelCacheMsgs, SharedInvalRelcacheMsg::relId, SHAREDINVALRELSYNC_ID, and VALGRIND_MAKE_MEM_DEFINED.

Referenced by RegisterRelsyncInvalidation().

AddSnapshotInvalidationMessage()

static void AddSnapshotInvalidationMessage ( InvalidationMsgsGroup *  group, Oid  dbId, Oid  relId  )

static

Definition at line 533 of file inval.c.

{
    SharedInvalidationMessage msg;
 
    /* Don't add a duplicate item */
    /* We assume dbId need not be checked because it will never change */
    ProcessMessageSubGroup(group, RelCacheMsgs,
                           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(group, RelCacheMsgs, &msg);
}

References AddInvalidationMessage(), SharedInvalSnapshotMsg::dbId, SharedInvalSnapshotMsg::id, ProcessMessageSubGroup, RelCacheMsgs, SharedInvalSnapshotMsg::relId, SHAREDINVALSNAPSHOT_ID, SharedInvalidationMessage::sn, and VALGRIND_MAKE_MEM_DEFINED.

Referenced by RegisterSnapshotInvalidation().

AppendInvalidationMessages()

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

static

Definition at line 560 of file inval.c.

{
    AppendInvalidationMessageSubGroup(dest, src, CatCacheMsgs);
    AppendInvalidationMessageSubGroup(dest, src, RelCacheMsgs);
}

References AppendInvalidationMessageSubGroup(), CatCacheMsgs, and RelCacheMsgs.

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

AppendInvalidationMessageSubGroup()

static void AppendInvalidationMessageSubGroup ( InvalidationMsgsGroup *  dest, InvalidationMsgsGroup *  src, int  subgroup  )

static

Definition at line 360 of file inval.c.

{
    /* Messages must be adjacent in main array */
    Assert(dest->nextmsg[subgroup] == src->firstmsg[subgroup]);
 
    /* ... which makes this easy: */
    dest->nextmsg[subgroup] = src->nextmsg[subgroup];
 
    /*
     * This is handy for some callers and irrelevant for others.  But we do it
     * always, reasoning that it's bad to leave different groups pointing at
     * the same fragment of the message array.
     */
    SetSubGroupToFollow(src, dest, subgroup);
}

References Assert, fb(), InvalidationMsgsGroup::firstmsg, InvalidationMsgsGroup::nextmsg, and SetSubGroupToFollow.

Referenced by AppendInvalidationMessages().

AtEOSubXact_Inval()

void AtEOSubXact_Inval

(

bool

isCommit

)

Definition at line 1310 of file inval.c.

{
    int         my_level;
    TransInvalidationInfo *myInfo;
 
    /*
     * Successful inplace update must clear this, but we clear it on abort.
     * Inplace updates allocate this in CurrentMemoryContext, which has
     * lifespan <= subtransaction lifespan.  Hence, don't free it explicitly.
     */
    if (isCommit)
        Assert(inplaceInvalInfo == NULL);
    else
        inplaceInvalInfo = NULL;
 
    /* Quick exit if no transactional messages. */
    myInfo = transInvalInfo;
    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.  Notice that we stick them in
         * PriorCmdInvalidMsgs, not CurrentCmdInvalidMsgs, since they've
         * already been locally processed.  (This would trigger the Assert in
         * AppendInvalidationMessageSubGroup if the parent's
         * CurrentCmdInvalidMsgs isn't empty; but we already checked that in
         * PrepareInvalidationState.)
         */
        AppendInvalidationMessages(&myInfo->parent->PriorCmdInvalidMsgs,
                                   &myInfo->PriorCmdInvalidMsgs);
 
        /* Must readjust parent's CurrentCmdInvalidMsgs indexes now */
        SetGroupToFollow(&myInfo->parent->ii.CurrentCmdInvalidMsgs,
                         &myInfo->parent->PriorCmdInvalidMsgs);
 
        /* Pending relcache inval becomes parent's problem too */
        if (myInfo->ii.RelcacheInitFileInval)
            myInfo->parent->ii.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);
    }
}

References AppendInvalidationMessages(), Assert, CommandEndInvalidationMessages(), fb(), GetCurrentTransactionNestLevel(), inplaceInvalInfo, LocalExecuteInvalidationMessage(), TransInvalidationInfo::parent, pfree(), ProcessInvalidationMessages(), SetGroupToFollow, and transInvalInfo.

Referenced by AbortSubTransaction(), and CommitSubTransaction().

AtEOXact_Inval()

void AtEOXact_Inval

(

bool

isCommit

)

Definition at line 1199 of file inval.c.

{
    inplaceInvalInfo = NULL;
 
    /* Quick exit if no transactional messages */
    if (transInvalInfo == NULL)
        return;
 
    /* Must be at top of stack */
    Assert(transInvalInfo->my_level == 1 && transInvalInfo->parent == NULL);
 
    INJECTION_POINT("transaction-end-process-inval", 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->ii.RelcacheInitFileInval)
            RelationCacheInitFilePreInvalidate();
 
        AppendInvalidationMessages(&transInvalInfo->PriorCmdInvalidMsgs,
                                   &transInvalInfo->ii.CurrentCmdInvalidMsgs);
 
        ProcessInvalidationMessagesMulti(&transInvalInfo->PriorCmdInvalidMsgs,
                                         SendSharedInvalidMessages);
 
        if (transInvalInfo->ii.RelcacheInitFileInval)
            RelationCacheInitFilePostInvalidate();
    }
    else
    {
        ProcessInvalidationMessages(&transInvalInfo->PriorCmdInvalidMsgs,
                                    LocalExecuteInvalidationMessage);
    }
 
    /* Need not free anything explicitly */
    transInvalInfo = NULL;
}

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

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

AtInplace_Inval()

void AtInplace_Inval

(

void

)

Definition at line 1263 of file inval.c.

{
    Assert(CritSectionCount > 0);
 
    if (inplaceInvalInfo == NULL)
        return;
 
    ProcessInvalidationMessagesMulti(&inplaceInvalInfo->CurrentCmdInvalidMsgs,
                                     SendSharedInvalidMessages);
 
    if (inplaceInvalInfo->RelcacheInitFileInval)
        RelationCacheInitFilePostInvalidate();
 
    inplaceInvalInfo = NULL;
}

References Assert, CritSectionCount, InvalidationInfo::CurrentCmdInvalidMsgs, fb(), inplaceInvalInfo, ProcessInvalidationMessagesMulti(), RelationCacheInitFilePostInvalidate(), InvalidationInfo::RelcacheInitFileInval, and SendSharedInvalidMessages().

Referenced by heap_inplace_update_and_unlock().

CacheInvalidateCatalog()

void CacheInvalidateCatalog

(

Oid

catalogId

)

Definition at line 1612 of file inval.c.

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

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

Referenced by finish_heap_swap().

CacheInvalidateHeapTuple()

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

Definition at line 1571 of file inval.c.

{
    CacheInvalidateHeapTupleCommon(relation, tuple, newtuple,
                                   PrepareInvalidationState);
}

References CacheInvalidateHeapTupleCommon(), and PrepareInvalidationState().

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

CacheInvalidateHeapTupleCommon()

static void CacheInvalidateHeapTupleCommon ( Relation  relation, HeapTuple  tuple, HeapTuple  newtuple, InvalidationInfo *(*)(void)  prepare_callback  )

static

Definition at line 1436 of file inval.c.

{
    InvalidationInfo *info;
    Oid         tupleRelId;
    Oid         databaseId;
    Oid         relationId;
 
    /* PrepareToInvalidateCacheTuple() needs relcache */
    AssertCouldGetRelation();
 
    /* 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;
 
    /* Allocate any required resources. */
    info = prepare_callback();
 
    /*
     * First let the catcache do its thing
     */
    tupleRelId = RelationGetRelid(relation);
    if (RelationInvalidatesSnapshotsOnly(tupleRelId))
    {
        databaseId = IsSharedRelation(tupleRelId) ? InvalidOid : MyDatabaseId;
        RegisterSnapshotInvalidation(info, databaseId, tupleRelId);
    }
    else
        PrepareToInvalidateCacheTuple(relation, tuple, newtuple,
                                      RegisterCatcacheInvalidation,
                                      info);
 
    /*
     * 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(info, databaseId, relationId);
}

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

Referenced by CacheInvalidateHeapTuple(), and CacheInvalidateHeapTupleInplace().

CacheInvalidateHeapTupleInplace()

void CacheInvalidateHeapTupleInplace	(	Relation	relation,
		HeapTuple	key_equivalent_tuple
	)

Definition at line 1593 of file inval.c.

{
    CacheInvalidateHeapTupleCommon(relation, key_equivalent_tuple, NULL,
                                   PrepareInplaceInvalidationState);
}

References CacheInvalidateHeapTupleCommon(), fb(), and PrepareInplaceInvalidationState().

Referenced by heap_inplace_lock().

CacheInvalidateRelcache()

void CacheInvalidateRelcache

(

Relation

relation

)

Definition at line 1635 of file inval.c.

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

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

Referenced by AlterPolicy(), ATExecDetachPartition(), ATExecGenericOptions(), CreatePolicy(), CreateStatistics(), DetachPartitionFinalize(), EnableDisableRule(), EnableDisableTrigger(), index_concurrently_set_dead(), index_constraint_create(), index_create(), index_drop(), QueueCheckConstraintValidation(), QueueNNConstraintValidation(), reindex_index(), relation_mark_replica_identity(), RelationSetNewRelfilenumber(), RemovePolicyById(), RemoveRewriteRuleById(), RemoveTriggerById(), rename_constraint_internal(), rename_policy(), RenameRewriteRule(), renametrig_internal(), set_attnotnull(), SetRelationNumChecks(), StorePartitionBound(), and StorePartitionKey().

CacheInvalidateRelcacheAll()

void CacheInvalidateRelcacheAll

(

void

)

Definition at line 1658 of file inval.c.

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

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

Referenced by AlterPublicationOptions(), CreatePublication(), InvalidatePublicationRels(), and RemovePublicationById().

CacheInvalidateRelcacheByRelid()

void CacheInvalidateRelcacheByRelid

(

Oid

relid

)

Definition at line 1691 of file inval.c.

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

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

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

CacheInvalidateRelcacheByTuple()

void CacheInvalidateRelcacheByTuple

(

HeapTuple

classTuple

)

Definition at line 1669 of file inval.c.

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

References fb(), 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 1789 of file inval.c.

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

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

Referenced by write_relmap_file().

CacheInvalidateRelSync()

void CacheInvalidateRelSync

(

Oid

relid

)

Definition at line 1712 of file inval.c.

{
    RegisterRelsyncInvalidation(PrepareInvalidationState(),
                                MyDatabaseId, relid);
}

References MyDatabaseId, PrepareInvalidationState(), and RegisterRelsyncInvalidation().

Referenced by CacheInvalidateRelSyncAll(), and InvalidatePubRelSyncCache().

CacheInvalidateRelSyncAll()

void CacheInvalidateRelSyncAll

(

void

)

Definition at line 1724 of file inval.c.

{
    CacheInvalidateRelSync(InvalidOid);
}

References CacheInvalidateRelSync(), and InvalidOid.

Referenced by InvalidatePubRelSyncCache().

CacheInvalidateSmgr()

void CacheInvalidateSmgr

(

RelFileLocatorBackend

rlocator

)

Definition at line 1755 of file inval.c.

{
    SharedInvalidationMessage msg;
 
    /* verify optimization stated above stays valid */
    StaticAssertDecl(MAX_BACKENDS_BITS <= 23,
                     "MAX_BACKENDS_BITS is too big for inval.c");
 
    msg.sm.id = SHAREDINVALSMGR_ID;
    msg.sm.backend_hi = rlocator.backend >> 16;
    msg.sm.backend_lo = rlocator.backend & 0xffff;
    msg.sm.rlocator = rlocator.locator;
    /* check AddCatcacheInvalidationMessage() for an explanation */
    VALGRIND_MAKE_MEM_DEFINED(&msg, sizeof(msg));
 
    SendSharedInvalidMessages(&msg, 1);
}

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

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

CacheRegisterRelcacheCallback()

void CacheRegisterRelcacheCallback	(	RelcacheCallbackFunction	func,
		Datum	arg
	)

Definition at line 1858 of file inval.c.

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

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

CacheRegisterRelSyncCallback()

void CacheRegisterRelSyncCallback	(	RelSyncCallbackFunction	func,
		Datum	arg
	)

Definition at line 1879 of file inval.c.

{
    if (relsync_callback_count >= MAX_RELSYNC_CALLBACKS)
        elog(FATAL, "out of relsync_callback_list slots");
 
    relsync_callback_list[relsync_callback_count].function = func;
    relsync_callback_list[relsync_callback_count].arg = arg;
 
    ++relsync_callback_count;
}

References RELSYNCCALLBACK::arg, arg, elog, FATAL, RELSYNCCALLBACK::function, MAX_RELSYNC_CALLBACKS, relsync_callback_count, and relsync_callback_list.

Referenced by pgoutput_startup().

CacheRegisterSyscacheCallback()

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

Definition at line 1816 of file inval.c.

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

References SYSCACHECALLBACK::arg, arg, elog, FATAL, fb(), 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().

CallRelSyncCallbacks()

void CallRelSyncCallbacks

(

Oid

relid

)

Definition at line 1920 of file inval.c.

{
    for (int i = 0; i < relsync_callback_count; i++)
    {
        struct RELSYNCCALLBACK *ccitem = relsync_callback_list + i;
 
        ccitem->function(ccitem->arg, relid);
    }
}

References fb(), RELSYNCCALLBACK::function, i, relsync_callback_count, and relsync_callback_list.

Referenced by LocalExecuteInvalidationMessage().

CallSyscacheCallbacks()

void CallSyscacheCallbacks	(	int	cacheid,
		uint32	hashvalue
	)

Definition at line 1898 of file inval.c.

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

References Assert, elog, ERROR, fb(), i, syscache_callback_links, and syscache_callback_list.

Referenced by CatalogCacheFlushCatalog(), and LocalExecuteInvalidationMessage().

CommandEndInvalidationMessages()

void CommandEndInvalidationMessages

(

void

)

Definition at line 1409 of file inval.c.

{
    /*
     * 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->ii.CurrentCmdInvalidMsgs,
                                LocalExecuteInvalidationMessage);
 
    /* WAL Log per-command invalidation messages for logical decoding */
    if (XLogLogicalInfoActive())
        LogLogicalInvalidations();
 
    AppendInvalidationMessages(&transInvalInfo->PriorCmdInvalidMsgs,
                               &transInvalInfo->ii.CurrentCmdInvalidMsgs);
}

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

Referenced by AtCCI_LocalCache(), and AtEOSubXact_Inval().

ForgetInplace_Inval()

void ForgetInplace_Inval

(

void

)

Definition at line 1286 of file inval.c.

{
    inplaceInvalInfo = NULL;
}

References fb(), and inplaceInvalInfo.

Referenced by heap_inplace_lock(), and heap_inplace_unlock().

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, fb(), inplaceInvalInfo, NumMessagesInGroup, palloc(), ProcessMessageSubGroupMulti, InvalidationInfo::RelcacheInitFileInval, and RelCacheMsgs.

Referenced by heap_inplace_update_and_unlock().

InvalidateSystemCaches()

void InvalidateSystemCaches

(

void

)

Definition at line 916 of file inval.c.

{
    InvalidateSystemCachesExtended(false);
}

References InvalidateSystemCachesExtended().

Referenced by AcceptInvalidationMessages(), LogicalReplicationSlotHasPendingWal(), LogicalSlotAdvanceAndCheckSnapState(), ParallelWorkerMain(), pg_logical_slot_get_changes_guts(), and ReorderBufferProcessTXN().

InvalidateSystemCachesExtended()

void InvalidateSystemCachesExtended

(

bool

debug_discard

)

Definition at line 785 of file inval.c.

{
    int         i;
 
    InvalidateCatalogSnapshot();
    ResetCatalogCachesExt(debug_discard);
    RelationCacheInvalidate(debug_discard); /* 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);
    }
 
    for (i = 0; i < relsync_callback_count; i++)
    {
        struct RELSYNCCALLBACK *ccitem = relsync_callback_list + i;
 
        ccitem->function(ccitem->arg, InvalidOid);
    }
}

References fb(), SYSCACHECALLBACK::function, RELCACHECALLBACK::function, RELSYNCCALLBACK::function, i, InvalidateCatalogSnapshot(), InvalidOid, RelationCacheInvalidate(), relcache_callback_count, relcache_callback_list, relsync_callback_count, relsync_callback_list, ResetCatalogCachesExt(), syscache_callback_count, and syscache_callback_list.

Referenced by AcceptInvalidationMessages(), and InvalidateSystemCaches().

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

LogLogicalInvalidations()

void LogLogicalInvalidations

(

void

)

Definition at line 1939 of file inval.c.

{
    xl_xact_invals xlrec;
    InvalidationMsgsGroup *group;
    int         nmsgs;
 
    /* Quick exit if we haven't done anything with invalidation messages. */
    if (transInvalInfo == NULL)
        return;
 
    group = &transInvalInfo->ii.CurrentCmdInvalidMsgs;
    nmsgs = NumMessagesInGroup(group);
 
    if (nmsgs > 0)
    {
        /* prepare record */
        memset(&xlrec, 0, MinSizeOfXactInvals);
        xlrec.nmsgs = nmsgs;
 
        /* perform insertion */
        XLogBeginInsert();
        XLogRegisterData(&xlrec, MinSizeOfXactInvals);
        ProcessMessageSubGroupMulti(group, CatCacheMsgs,
                                    XLogRegisterData(msgs,
                                                     n * sizeof(SharedInvalidationMessage)));
        ProcessMessageSubGroupMulti(group, RelCacheMsgs,
                                    XLogRegisterData(msgs,
                                                     n * sizeof(SharedInvalidationMessage)));
        XLogInsert(RM_XACT_ID, XLOG_XACT_INVALIDATIONS);
    }
}

References CatCacheMsgs, InvalidationInfo::CurrentCmdInvalidMsgs, fb(), TransInvalidationInfo::ii, MinSizeOfXactInvals, 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 993 of file inval.c.

{
    AtEOXact_Inval(false);
}

References AtEOXact_Inval().

Referenced by PrepareTransaction().

PreInplace_Inval()

void PreInplace_Inval

(

void

)

Definition at line 1250 of file inval.c.

{
    Assert(CritSectionCount == 0);
 
    if (inplaceInvalInfo && inplaceInvalInfo->RelcacheInitFileInval)
        RelationCacheInitFilePreInvalidate();
}

References Assert, CritSectionCount, inplaceInvalInfo, RelationCacheInitFilePreInvalidate(), and InvalidationInfo::RelcacheInitFileInval.

Referenced by heap_inplace_update_and_unlock().

PrepareInplaceInvalidationState()

static InvalidationInfo * PrepareInplaceInvalidationState ( void  )

static

Definition at line 752 of file inval.c.

{
    InvalidationInfo *myInfo;
 
    AssertCouldGetRelation();
    /* limit of one inplace update under assembly */
    Assert(inplaceInvalInfo == NULL);
 
    /* gone after WAL insertion CritSection ends, so use current context */
    myInfo = palloc0_object(InvalidationInfo);
 
    /* Stash our messages past end of the transactional messages, if any. */
    if (transInvalInfo != NULL)
        SetGroupToFollow(&myInfo->CurrentCmdInvalidMsgs,
                         &transInvalInfo->ii.CurrentCmdInvalidMsgs);
    else
    {
        InvalMessageArrays[CatCacheMsgs].msgs = NULL;
        InvalMessageArrays[CatCacheMsgs].maxmsgs = 0;
        InvalMessageArrays[RelCacheMsgs].msgs = NULL;
        InvalMessageArrays[RelCacheMsgs].maxmsgs = 0;
    }
 
    inplaceInvalInfo = myInfo;
    return myInfo;
}

References Assert, AssertCouldGetRelation(), CatCacheMsgs, InvalidationInfo::CurrentCmdInvalidMsgs, fb(), TransInvalidationInfo::ii, inplaceInvalInfo, InvalMessageArrays, InvalMessageArray::maxmsgs, InvalMessageArray::msgs, palloc0_object, RelCacheMsgs, SetGroupToFollow, and transInvalInfo.

Referenced by CacheInvalidateHeapTupleInplace().

PrepareInvalidationState()

static InvalidationInfo * PrepareInvalidationState ( void  )

static

Definition at line 682 of file inval.c.

{
    TransInvalidationInfo *myInfo;
 
    /* PrepareToInvalidateCacheTuple() needs relcache */
    AssertCouldGetRelation();
    /* Can't queue transactional message while collecting inplace messages. */
    Assert(inplaceInvalInfo == NULL);
 
    if (transInvalInfo != NULL &&
        transInvalInfo->my_level == GetCurrentTransactionNestLevel())
        return (InvalidationInfo *) transInvalInfo;
 
    myInfo = (TransInvalidationInfo *)
        MemoryContextAllocZero(TopTransactionContext,
                               sizeof(TransInvalidationInfo));
    myInfo->parent = transInvalInfo;
    myInfo->my_level = GetCurrentTransactionNestLevel();
 
    /* Now, do we have a previous stack entry? */
    if (transInvalInfo != NULL)
    {
        /* Yes; this one should be for a deeper nesting level. */
        Assert(myInfo->my_level > transInvalInfo->my_level);
 
        /*
         * The parent (sub)transaction must not have any current (i.e.,
         * not-yet-locally-processed) messages.  If it did, we'd have a
         * semantic problem: the new subtransaction presumably ought not be
         * able to see those events yet, but since the CommandCounter is
         * linear, that can't work once the subtransaction advances the
         * counter.  This is a convenient place to check for that, as well as
         * being important to keep management of the message arrays simple.
         */
        if (NumMessagesInGroup(&transInvalInfo->ii.CurrentCmdInvalidMsgs) != 0)
            elog(ERROR, "cannot start a subtransaction when there are unprocessed inval messages");
 
        /*
         * MemoryContextAllocZero set firstmsg = nextmsg = 0 in each group,
         * which is fine for the first (sub)transaction, but otherwise we need
         * to update them to follow whatever is already in the arrays.
         */
        SetGroupToFollow(&myInfo->PriorCmdInvalidMsgs,
                         &transInvalInfo->ii.CurrentCmdInvalidMsgs);
        SetGroupToFollow(&myInfo->ii.CurrentCmdInvalidMsgs,
                         &myInfo->PriorCmdInvalidMsgs);
    }
    else
    {
        /*
         * Here, we need only clear any array pointers left over from a prior
         * transaction.
         */
        InvalMessageArrays[CatCacheMsgs].msgs = NULL;
        InvalMessageArrays[CatCacheMsgs].maxmsgs = 0;
        InvalMessageArrays[RelCacheMsgs].msgs = NULL;
        InvalMessageArrays[RelCacheMsgs].maxmsgs = 0;
    }
 
    transInvalInfo = myInfo;
    return (InvalidationInfo *) myInfo;
}

References Assert, AssertCouldGetRelation(), CatCacheMsgs, InvalidationInfo::CurrentCmdInvalidMsgs, elog, ERROR, fb(), GetCurrentTransactionNestLevel(), TransInvalidationInfo::ii, inplaceInvalInfo, InvalMessageArrays, InvalMessageArray::maxmsgs, MemoryContextAllocZero(), InvalMessageArray::msgs, TransInvalidationInfo::my_level, NumMessagesInGroup, TransInvalidationInfo::parent, RelCacheMsgs, SetGroupToFollow, TopTransactionContext, and transInvalInfo.

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

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, fb(), GetDatabasePath(), OidIsValid, pfree(), RelationCacheInitFilePostInvalidate(), RelationCacheInitFilePreInvalidate(), and SendSharedInvalidMessages().

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

ProcessInvalidationMessages()

static void ProcessInvalidationMessages ( InvalidationMsgsGroup *  group, void(*)(SharedInvalidationMessage *msg)  func  )

static

Definition at line 574 of file inval.c.

{
    ProcessMessageSubGroup(group, CatCacheMsgs, func(msg));
    ProcessMessageSubGroup(group, RelCacheMsgs, func(msg));
}

References CatCacheMsgs, ProcessMessageSubGroup, and RelCacheMsgs.

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

ProcessInvalidationMessagesMulti()

static void ProcessInvalidationMessagesMulti ( InvalidationMsgsGroup *  group, void(*)(const SharedInvalidationMessage *msgs, int n)  func  )

static

Definition at line 586 of file inval.c.

{
    ProcessMessageSubGroupMulti(group, CatCacheMsgs, func(msgs, n));
    ProcessMessageSubGroupMulti(group, RelCacheMsgs, func(msgs, n));
}

References CatCacheMsgs, ProcessMessageSubGroupMulti, and RelCacheMsgs.

Referenced by AtEOXact_Inval(), and AtInplace_Inval().

RegisterCatalogInvalidation()

static void RegisterCatalogInvalidation ( InvalidationInfo *  info, Oid  dbId, Oid  catId  )

static

Definition at line 621 of file inval.c.

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

References AddCatalogInvalidationMessage(), and InvalidationInfo::CurrentCmdInvalidMsgs.

Referenced by CacheInvalidateCatalog().

RegisterCatcacheInvalidation()

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

static

Definition at line 604 of file inval.c.

{
    InvalidationInfo *info = (InvalidationInfo *) context;
 
    AddCatcacheInvalidationMessage(&info->CurrentCmdInvalidMsgs,
                                   cacheId, hashValue, dbId);
}

References AddCatcacheInvalidationMessage(), and InvalidationInfo::CurrentCmdInvalidMsgs.

Referenced by CacheInvalidateHeapTupleCommon().

RegisterRelcacheInvalidation()

static void RegisterRelcacheInvalidation ( InvalidationInfo *  info, Oid  dbId, Oid  relId  )

static

Definition at line 632 of file inval.c.

{
    AddRelcacheInvalidationMessage(&info->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))
        info->RelcacheInitFileInval = true;
}

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

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

RegisterRelsyncInvalidation()

static void RegisterRelsyncInvalidation ( InvalidationInfo *  info, Oid  dbId, Oid  relId  )

static

Definition at line 660 of file inval.c.

{
    AddRelsyncInvalidationMessage(&info->CurrentCmdInvalidMsgs, dbId, relId);
}

References AddRelsyncInvalidationMessage(), and InvalidationInfo::CurrentCmdInvalidMsgs.

Referenced by CacheInvalidateRelSync().

RegisterSnapshotInvalidation()

static void RegisterSnapshotInvalidation ( InvalidationInfo *  info, Oid  dbId, Oid  relId  )

static

Definition at line 672 of file inval.c.

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

References AddSnapshotInvalidationMessage(), and InvalidationInfo::CurrentCmdInvalidMsgs.

Referenced by CacheInvalidateHeapTupleCommon().

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, fb(), TransInvalidationInfo::ii, MemoryContextAlloc(), TransInvalidationInfo::my_level, NumMessagesInGroup, TransInvalidationInfo::parent, TransInvalidationInfo::PriorCmdInvalidMsgs, ProcessMessageSubGroupMulti, InvalidationInfo::RelcacheInitFileInval, RelCacheMsgs, and transInvalInfo.

Referenced by RecordTransactionCommit(), and StartPrepare().

Variable Documentation

debug_discard_caches

int debug_discard_caches = 0

Definition at line 260 of file inval.c.

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

inplaceInvalInfo

InvalidationInfo* inplaceInvalInfo = NULL

static

Definition at line 257 of file inval.c.

Referenced by AtEOSubXact_Inval(), AtEOXact_Inval(), AtInplace_Inval(), ForgetInplace_Inval(), inplaceGetInvalidationMessages(), PreInplace_Inval(), PrepareInplaceInvalidationState(), and PrepareInvalidationState().

InvalMessageArrays

InvalMessageArray InvalMessageArrays[2]

static

Definition at line 181 of file inval.c.

Referenced by AddInvalidationMessage(), PrepareInplaceInvalidationState(), and PrepareInvalidationState().

relcache_callback_count

int relcache_callback_count = 0

static

Definition at line 294 of file inval.c.

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

relcache_callback_list

struct RELCACHECALLBACK relcache_callback_list[MAX_RELCACHE_CALLBACKS]

static

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

relsync_callback_count

int relsync_callback_count = 0

static

Definition at line 302 of file inval.c.

Referenced by CacheRegisterRelSyncCallback(), CallRelSyncCallbacks(), and InvalidateSystemCachesExtended().

relsync_callback_list

struct RELSYNCCALLBACK relsync_callback_list[MAX_RELSYNC_CALLBACKS]

static

Referenced by CacheRegisterRelSyncCallback(), CallRelSyncCallbacks(), and InvalidateSystemCachesExtended().

syscache_callback_count

int syscache_callback_count = 0

static

Definition at line 286 of file inval.c.

Referenced by CacheRegisterSyscacheCallback(), and InvalidateSystemCachesExtended().

syscache_callback_links

int16 syscache_callback_links[SysCacheSize]

static

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

transInvalInfo

TransInvalidationInfo* transInvalInfo = NULL

static

Definition at line 255 of file inval.c.

Referenced by AtEOSubXact_Inval(), AtEOXact_Inval(), CommandEndInvalidationMessages(), LogLogicalInvalidations(), PrepareInplaceInvalidationState(), PrepareInvalidationState(), and xactGetCommittedInvalidationMessages().