1 /*-------------------------------------------------------------------------
4 * POSTGRES shared cache invalidation communication code.
6 * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
7 * Portions Copyright (c) 1994, Regents of the University of California
11 * src/backend/storage/ipc/sinval.c
13 *-------------------------------------------------------------------------
17 #include "access/xact.h"
18 #include "miscadmin.h"
19 #include "storage/latch.h"
20 #include "storage/sinvaladt.h"
21 #include "utils/inval.h"
24 uint64 SharedInvalidMessageCounter
;
28 * Because backends sitting idle will not be reading sinval events, we
29 * need a way to give an idle backend a swift kick in the rear and make
30 * it catch up before the sinval queue overflows and forces it to go
31 * through a cache reset exercise. This is done by sending
32 * PROCSIG_CATCHUP_INTERRUPT to any backend that gets too far behind.
34 * The signal handler will set an interrupt pending flag and will set the
35 * processes latch. Whenever starting to read from the client, or when
36 * interrupted while doing so, ProcessClientReadInterrupt() will call
37 * ProcessCatchupEvent().
39 volatile sig_atomic_t catchupInterruptPending
= false;
43 * SendSharedInvalidMessages
44 * Add shared-cache-invalidation message(s) to the global SI message queue.
47 SendSharedInvalidMessages(const SharedInvalidationMessage
*msgs
, int n
)
49 SIInsertDataEntries(msgs
, n
);
53 * ReceiveSharedInvalidMessages
54 * Process shared-cache-invalidation messages waiting for this backend
56 * We guarantee to process all messages that had been queued before the
57 * routine was entered. It is of course possible for more messages to get
58 * queued right after our last SIGetDataEntries call.
60 * NOTE: it is entirely possible for this routine to be invoked recursively
61 * as a consequence of processing inside the invalFunction or resetFunction.
62 * Furthermore, such a recursive call must guarantee that all outstanding
63 * inval messages have been processed before it exits. This is the reason
64 * for the strange-looking choice to use a statically allocated buffer array
65 * and counters; it's so that a recursive call can process messages already
66 * sucked out of sinvaladt.c.
69 ReceiveSharedInvalidMessages(void (*invalFunction
) (SharedInvalidationMessage
*msg
),
70 void (*resetFunction
) (void))
72 #define MAXINVALMSGS 32
73 static SharedInvalidationMessage messages
[MAXINVALMSGS
];
76 * We use volatile here to prevent bugs if a compiler doesn't realize that
77 * recursion is a possibility ...
79 static volatile int nextmsg
= 0;
80 static volatile int nummsgs
= 0;
82 /* Deal with any messages still pending from an outer recursion */
83 while (nextmsg
< nummsgs
)
85 SharedInvalidationMessage msg
= messages
[nextmsg
++];
87 SharedInvalidMessageCounter
++;
95 nextmsg
= nummsgs
= 0;
97 /* Try to get some more messages */
98 getResult
= SIGetDataEntries(messages
, MAXINVALMSGS
);
102 /* got a reset message */
103 elog(DEBUG4
, "cache state reset");
104 SharedInvalidMessageCounter
++;
106 break; /* nothing more to do */
109 /* Process them, being wary that a recursive call might eat some */
113 while (nextmsg
< nummsgs
)
115 SharedInvalidationMessage msg
= messages
[nextmsg
++];
117 SharedInvalidMessageCounter
++;
122 * We only need to loop if the last SIGetDataEntries call (which might
123 * have been within a recursive call) returned a full buffer.
125 } while (nummsgs
== MAXINVALMSGS
);
128 * We are now caught up. If we received a catchup signal, reset that
129 * flag, and call SICleanupQueue(). This is not so much because we need
130 * to flush dead messages right now, as that we want to pass on the
131 * catchup signal to the next slowest backend. "Daisy chaining" the
132 * catchup signal this way avoids creating spikes in system load for what
133 * should be just a background maintenance activity.
135 if (catchupInterruptPending
)
137 catchupInterruptPending
= false;
138 elog(DEBUG4
, "sinval catchup complete, cleaning queue");
139 SICleanupQueue(false, 0);
145 * HandleCatchupInterrupt
147 * This is called when PROCSIG_CATCHUP_INTERRUPT is received.
149 * We used to directly call ProcessCatchupEvent directly when idle. These days
150 * we just set a flag to do it later and notify the process of that fact by
151 * setting the process's latch.
154 HandleCatchupInterrupt(void)
157 * Note: this is called by a SIGNAL HANDLER. You must be very wary what
161 catchupInterruptPending
= true;
163 /* make sure the event is processed in due course */
168 * ProcessCatchupInterrupt
170 * The portion of catchup interrupt handling that runs outside of the signal
171 * handler, which allows it to actually process pending invalidations.
174 ProcessCatchupInterrupt(void)
176 while (catchupInterruptPending
)
179 * What we need to do here is cause ReceiveSharedInvalidMessages() to
180 * run, which will do the necessary work and also reset the
181 * catchupInterruptPending flag. If we are inside a transaction we
182 * can just call AcceptInvalidationMessages() to do this. If we
183 * aren't, we start and immediately end a transaction; the call to
184 * AcceptInvalidationMessages() happens down inside transaction start.
186 * It is awfully tempting to just call AcceptInvalidationMessages()
187 * without the rest of the xact start/stop overhead, and I think that
188 * would actually work in the normal case; but I am not sure that
189 * things would clean up nicely if we got an error partway through.
191 if (IsTransactionOrTransactionBlock())
193 elog(DEBUG4
, "ProcessCatchupEvent inside transaction");
194 AcceptInvalidationMessages();
198 elog(DEBUG4
, "ProcessCatchupEvent outside transaction");
199 StartTransactionCommand();
200 CommitTransactionCommand();