sinval.c File Reference

#include "postgres.h"
#include "access/xact.h"
#include "commands/async.h"
#include "miscadmin.h"
#include "storage/ipc.h"
#include "storage/proc.h"
#include "storage/sinvaladt.h"
#include "utils/inval.h"

Include dependency graph for sinval.c:

Go to the source code of this file.

Macros
#define	MAXINVALMSGS   32

Functions
void	SendSharedInvalidMessages (const SharedInvalidationMessage *msgs, int n)
void	ReceiveSharedInvalidMessages (void(*invalFunction)(SharedInvalidationMessage *msg), void(*resetFunction)(void))
void	HandleCatchupInterrupt (void)
void	ProcessCatchupInterrupt (void)

Variables
uint64	SharedInvalidMessageCounter
volatile sig_atomic_t	catchupInterruptPending = false

Macro Definition Documentation

MAXINVALMSGS

#define MAXINVALMSGS   32

Function Documentation

HandleCatchupInterrupt()

void HandleCatchupInterrupt

(

void

)

Definition at line 156 of file sinval.c.

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

References catchupInterruptPending, MyLatch, and SetLatch().

Referenced by procsignal_sigusr1_handler().

ProcessCatchupInterrupt()

void ProcessCatchupInterrupt

(

void

)

Definition at line 176 of file sinval.c.

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

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

Referenced by HandleAutoVacLauncherInterrupts(), and ProcessClientReadInterrupt().

ReceiveSharedInvalidMessages()

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

Definition at line 71 of file sinval.c.

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

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

Referenced by AcceptInvalidationMessages().

SendSharedInvalidMessages()

void SendSharedInvalidMessages	(	const SharedInvalidationMessage *	msgs,
		int	n
	)

Definition at line 49 of file sinval.c.

{
    SIInsertDataEntries(msgs, n);
}

References SIInsertDataEntries().

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

Variable Documentation

catchupInterruptPending

volatile sig_atomic_t catchupInterruptPending = false

Definition at line 41 of file sinval.c.

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

SharedInvalidMessageCounter

uint64 SharedInvalidMessageCounter

Definition at line 26 of file sinval.c.

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