nbtree: fix read page recheck typo.
[pgsql.git] / src / backend / storage / ipc / sinval.c
blobd9b16f84d19e1344219c239255fc389fb4032d5f
1 /*-------------------------------------------------------------------------
3 * sinval.c
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
10 * IDENTIFICATION
11 * src/backend/storage/ipc/sinval.c
13 *-------------------------------------------------------------------------
15 #include "postgres.h"
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.
46 void
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.
68 void
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++;
88 invalFunction(&msg);
93 int getResult;
95 nextmsg = nummsgs = 0;
97 /* Try to get some more messages */
98 getResult = SIGetDataEntries(messages, MAXINVALMSGS);
100 if (getResult < 0)
102 /* got a reset message */
103 elog(DEBUG4, "cache state reset");
104 SharedInvalidMessageCounter++;
105 resetFunction();
106 break; /* nothing more to do */
109 /* Process them, being wary that a recursive call might eat some */
110 nextmsg = 0;
111 nummsgs = getResult;
113 while (nextmsg < nummsgs)
115 SharedInvalidationMessage msg = messages[nextmsg++];
117 SharedInvalidMessageCounter++;
118 invalFunction(&msg);
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.
153 void
154 HandleCatchupInterrupt(void)
157 * Note: this is called by a SIGNAL HANDLER. You must be very wary what
158 * you do here.
161 catchupInterruptPending = true;
163 /* make sure the event is processed in due course */
164 SetLatch(MyLatch);
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.
173 void
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();
196 else
198 elog(DEBUG4, "ProcessCatchupEvent outside transaction");
199 StartTransactionCommand();
200 CommitTransactionCommand();