QEventDispatcher(Win): Always honor interrupted status to avoid races

There may be a race where e.g. thread 'B' is woken up by a queued invoke.
At the same time thread 'A' asks 'B' to quit, which will set various
atomics (some important ones are 'interrupt' in the dispatcher and
'exit' in the event loop), but it does _not_ try to send another wake
since there is already an unhandled wake triggered by 'B' itself.
Sadly 'B' reads the 'exit' atomic before 'A' updates it.
Then, slightly before, 'B' sets 'interrupt' back to 0, 'A' write 1 to
it, meaning 'A's interrupt is ignored. Then, since there is no
interrupt, 'B' goes back to waiting for events, leaving the thread alive
and running instead of quitting.

Maybe this has unforeseen consequences (one consequence is that it will
return and re-enter the event dispatcher once more, possible
unnecessarily)

Fixes: QTBUG-91539
Pick-to: 6.1 6.0 5.15
Change-Id: Ie6f861f42ffddf4817d5c8af2d764abe9d9103c2
Reviewed-by: Alex Trotsenko <alex1973tr@gmail.com>
Reviewed-by: Volker Hilsheimer <volker.hilsheimer@qt.io>
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>

1 files changed, 27 insertions, 0 deletions

diff --git a/tests/auto/corelib/kernel/qeventdispatcher/tst_qeventdispatcher.cpp b/tests/auto/corelib/kernel/qeventdispatcher/tst_qeventdispatcher.cpp
index 8d69314fa5..21aee94e5d 100644
--- a/tests/auto/corelib/kernel/qeventdispatcher/tst_qeventdispatcher.cpp
+++ b/tests/auto/corelib/kernel/qeventdispatcher/tst_qeventdispatcher.cpp
@@ -71,6 +71,7 @@ private slots:
     void processEventsOnlySendsQueuedEvents();
     void postedEventsPingPong();
     void eventLoopExit();
+    void interruptTrampling();
 };
 
 bool tst_QEventDispatcher::event(QEvent *e)
@@ -421,5 +422,31 @@ void tst_QEventDispatcher::eventLoopExit()
     QVERIFY(!timeoutObserved);
 }
 
+// Based on QTBUG-91539: In the event dispatcher on Windows we overwrite the
+// interrupt once we start processing events (this pattern is also in the 'unix' dispatcher)
+// which would lead the dispatcher to accidentally ignore certain interrupts and,
+// as in the bug report, would not quit, leaving the thread alive and running.
+void tst_QEventDispatcher::interruptTrampling()
+{
+    class WorkerThread : public QThread
+    {
+        void run() override {
+            auto dispatcher = eventDispatcher();
+            QVERIFY(dispatcher);
+            dispatcher->processEvents(QEventLoop::AllEvents);
+            QTimer::singleShot(0, [dispatcher]() {
+                dispatcher->wakeUp();
+            });
+            dispatcher->processEvents(QEventLoop::WaitForMoreEvents);
+            dispatcher->interrupt();
+            dispatcher->processEvents(QEventLoop::WaitForMoreEvents);
+        }
+    };
+    WorkerThread thread;
+    thread.start();
+    QVERIFY(thread.wait(1000));
+    QVERIFY(thread.isFinished());
+}
+
 QTEST_MAIN(tst_QEventDispatcher)
 #include "tst_qeventdispatcher.moc"