Refactor CHECK_FOR_INTERRUPTS() to add flexibility.

Split up CHECK_FOR_INTERRUPTS() to provide an additional macro
INTERRUPTS_PENDING_CONDITION(), which just tests whether an
interrupt is pending without attempting to service it.  This is
useful in situations where the caller knows that interrupts are
blocked, and would like to find out if it's worth the trouble
to unblock them.

Also add INTERRUPTS_CAN_BE_PROCESSED(), which indicates whether
CHECK_FOR_INTERRUPTS() can be relied on to clear the pending interrupt.

This commit doesn't actually add any uses of the new macros,
but a follow-on bug fix will do so.  Back-patch to all supported
branches to provide infrastructure for that fix.

Alvaro Herrera and Tom Lane

Discussion: https://postgr.es/m/20210513155351.GA7848@alvherre.pgsql

diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c
index 98d05763ac559b4bf74845593cb75fe08886d707..e033847538b818d4d67be8cdc90694b8e416c187 100644 (file)
--- a/src/backend/tcop/postgres.c
+++ b/src/backend/tcop/postgres.c
@@ -592,7 +592,7 @@ ProcessClientWriteInterrupt(bool blocked)
        {
            /*
             * Don't mess with whereToSendOutput if ProcessInterrupts wouldn't
-            * do anything.
+            * service ProcDiePending.
             */
            if (InterruptHoldoffCount == 0 && CritSectionCount == 0)
            {
@@ -2905,6 +2905,12 @@ RecoveryConflictInterrupt(ProcSignalReason reason)
  * If an interrupt condition is pending, and it's safe to service it,
  * then clear the flag and accept the interrupt.  Called only when
  * InterruptPending is true.
+ *
+ * Note: if INTERRUPTS_CAN_BE_PROCESSED() is true, then ProcessInterrupts
+ * is guaranteed to clear the InterruptPending flag before returning.
+ * (This is not the same as guaranteeing that it's still clear when we
+ * return; another interrupt could have arrived.  But we promise that
+ * any pre-existing one will have been serviced.)
  */
 void
 ProcessInterrupts(void)
@@ -3009,7 +3015,11 @@ ProcessInterrupts(void)
    {
        /*
         * Re-arm InterruptPending so that we process the cancel request as
-        * soon as we're done reading the message.
+        * soon as we're done reading the message.  (XXX this is seriously
+        * ugly: it complicates INTERRUPTS_CAN_BE_PROCESSED(), and it means we
+        * can't use that macro directly as the initial test in this function,
+        * meaning that this code also creates opportunities for other bugs to
+        * appear.)
         */
        InterruptPending = true;
    }

diff --git a/src/include/miscadmin.h b/src/include/miscadmin.h
index 802414553571704756c75777bc3b9c74d8dbda3a..7c9f319b67bb8971709e0d03d0804f0c9965c571 100644 (file)
--- a/src/include/miscadmin.h
+++ b/src/include/miscadmin.h
@@ -56,6 +56,15 @@
  * allowing die interrupts: HOLD_CANCEL_INTERRUPTS() and
  * RESUME_CANCEL_INTERRUPTS().
  *
+ * Note that ProcessInterrupts() has also acquired a number of tasks that
+ * do not necessarily cause a query-cancel-or-die response.  Hence, it's
+ * possible that it will just clear InterruptPending and return.
+ *
+ * INTERRUPTS_PENDING_CONDITION() can be checked to see whether an
+ * interrupt needs to be serviced, without trying to do so immediately.
+ * Some callers are also interested in INTERRUPTS_CAN_BE_PROCESSED(),
+ * which tells whether ProcessInterrupts is sure to clear the interrupt.
+ *
  * Special mechanisms are used to let an interrupt be accepted when we are
  * waiting for a lock or when we are waiting for command input (but, of
  * course, only if the interrupt holdoff counter is zero).  See the
@@ -93,24 +102,27 @@ extern PGDLLIMPORT volatile uint32 CritSectionCount;
 /* in tcop/postgres.c */
 extern void ProcessInterrupts(void);
 
+/* Test whether an interrupt is pending */
 #ifndef WIN32
+#define INTERRUPTS_PENDING_CONDITION() \
+   (unlikely(InterruptPending))
+#else
+#define INTERRUPTS_PENDING_CONDITION() \
+   (unlikely(UNBLOCKED_SIGNAL_QUEUE()) ? pgwin32_dispatch_queued_signals() : 0, \
+    unlikely(InterruptPending))
+#endif
 
+/* Service interrupt, if one is pending and it's safe to service it now */
 #define CHECK_FOR_INTERRUPTS() \
 do { \
-   if (unlikely(InterruptPending)) \
-       ProcessInterrupts(); \
-} while(0)
-#else                          /* WIN32 */
-
-#define CHECK_FOR_INTERRUPTS() \
-do { \
-   if (unlikely(UNBLOCKED_SIGNAL_QUEUE())) \
-       pgwin32_dispatch_queued_signals(); \
-   if (unlikely(InterruptPending)) \
+   if (INTERRUPTS_PENDING_CONDITION()) \
        ProcessInterrupts(); \
 } while(0)
-#endif                         /* WIN32 */
 
+/* Is ProcessInterrupts() guaranteed to clear InterruptPending? */
+#define INTERRUPTS_CAN_BE_PROCESSED() \
+   (InterruptHoldoffCount == 0 && CritSectionCount == 0 && \
+    QueryCancelHoldoffCount == 0)
 
 #define HOLD_INTERRUPTS()  (InterruptHoldoffCount++)