w32: Fix regression caused by new g_poll implementation

Commit 5a007547df tried to fix a
performance degradation caused by bad handling of small timeouts
in the original implementation of g_poll.

Since that commit, hard disk I/O no longer works.

Instead of rewriting the g_poll implementation, this patch simply copies
the original code (released under LGPL) from latest glib and only modifies
it where needed (see comments in the code). URL of the original code:
https://git.gnome.org/browse/glib/tree/glib/gpoll.c

Signed-off-by: Stefan Weil <sw@weilnetz.de>
Message-id: 1401291744-14314-1-git-send-email-sw@weilnetz.de
Reviewed-by: Peter Maydell <peter.maydell@linaro.org>
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>

util/oslib-win32.c

@@ -24,6 +24,10 @@
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
+ *
+ * The implementation of g_poll (functions poll_rest, g_poll) at the end of
+ * this file are based on code from GNOME glib-2 and use a different license,
+ * see the license comment there.
  */
 #include <windows.h>
 #include <glib.h>
@@ -138,7 +142,7 @@ int inet_aton(const char *cp, struct in_addr *ia)
 {
     uint32_t addr = inet_addr(cp);
     if (addr == 0xffffffff) {
-	return 0;
+        return 0;
     }
     ia->s_addr = addr;
     return 1;
@@ -240,113 +244,205 @@ char *qemu_get_exec_dir(void)
 }
 
 /*
- * g_poll has a problem on Windows when using
+ * The original implementation of g_poll from glib has a problem on Windows
- * timeouts < 10ms, in glib/gpoll.c:
+ * when using timeouts < 10 ms.
  *
- * // If not, and we have a significant timeout, poll again with
+ * Whenever g_poll is called with timeout < 10 ms, it does a quick poll instead
- * // timeout then. Note that this will return indication for only
+ * of wait. This causes significant performance degradation of QEMU.
- * // one event, or only for messages. We ignore timeouts less than
- * // ten milliseconds as they are mostly pointless on Windows, the
- * // MsgWaitForMultipleObjectsEx() call will timeout right away
- * // anyway.
  *
- * if (retval == 0 && (timeout == INFINITE || timeout >= 10))
+ * The following code is a copy of the original code from glib/gpoll.c
- *   retval = poll_rest (poll_msgs, handles, nhandles, fds, nfds, timeout);
+ * (glib commit 20f4d1820b8d4d0fc4447188e33efffd6d4a88d8 from 2014-02-19).
- *
+ * Some debug code was removed and the code was reformatted.
- * So whenever g_poll is called with timeout < 10ms it does
+ * All other code modifications are marked with 'QEMU'.
- * a quick poll instead of wait, this causes significant performance
- * degradation of QEMU, thus we should use WaitForMultipleObjectsEx
- * directly
  */
-gint g_poll_fixed(GPollFD *fds, guint nfds, gint timeout)
+
+/*
+ * gpoll.c: poll(2) abstraction
+ * Copyright 1998 Owen Taylor
+ * Copyright 2008 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+static int poll_rest(gboolean poll_msgs, HANDLE *handles, gint nhandles,
+                     GPollFD *fds, guint nfds, gint timeout)
 {
-    guint i;
+    DWORD ready;
-    HANDLE handles[MAXIMUM_WAIT_OBJECTS];
+    GPollFD *f;
-    gint nhandles = 0;
+    int recursed_result;
-    int num_completed = 0;
 
-    for (i = 0; i < nfds; i++) {
+    if (poll_msgs) {
-        gint j;
+        /* Wait for either messages or handles
-
+         * -> Use MsgWaitForMultipleObjectsEx
-        if (fds[i].fd <= 0) {
-            continue;
-        }
-
-        /* don't add same handle several times
          */
-        for (j = 0; j < nhandles; j++) {
+        ready = MsgWaitForMultipleObjectsEx(nhandles, handles, timeout,
-            if (handles[j] == (HANDLE)fds[i].fd) {
+                                            QS_ALLINPUT, MWMO_ALERTABLE);
-                break;
+
+        if (ready == WAIT_FAILED) {
+            gchar *emsg = g_win32_error_message(GetLastError());
+            g_warning("MsgWaitForMultipleObjectsEx failed: %s", emsg);
+            g_free(emsg);
+        }
+    } else if (nhandles == 0) {
+        /* No handles to wait for, just the timeout */
+        if (timeout == INFINITE) {
+            ready = WAIT_FAILED;
+        } else {
+            SleepEx(timeout, TRUE);
+            ready = WAIT_TIMEOUT;
+        }
+    } else {
+        /* Wait for just handles
+         * -> Use WaitForMultipleObjectsEx
+         */
+        ready =
+            WaitForMultipleObjectsEx(nhandles, handles, FALSE, timeout, TRUE);
+        if (ready == WAIT_FAILED) {
+            gchar *emsg = g_win32_error_message(GetLastError());
+            g_warning("WaitForMultipleObjectsEx failed: %s", emsg);
+            g_free(emsg);
+        }
+    }
+
+    if (ready == WAIT_FAILED) {
+        return -1;
+    } else if (ready == WAIT_TIMEOUT || ready == WAIT_IO_COMPLETION) {
+        return 0;
+    } else if (poll_msgs && ready == WAIT_OBJECT_0 + nhandles) {
+        for (f = fds; f < &fds[nfds]; ++f) {
+            if (f->fd == G_WIN32_MSG_HANDLE && f->events & G_IO_IN) {
+                f->revents |= G_IO_IN;
             }
         }
 
-        if (j == nhandles) {
+        /* If we have a timeout, or no handles to poll, be satisfied
-            if (nhandles == MAXIMUM_WAIT_OBJECTS) {
+         * with just noticing we have messages waiting.
-                fprintf(stderr, "Too many handles to wait for!\n");
+         */
-                break;
+        if (timeout != 0 || nhandles == 0) {
-            } else {
+            return 1;
-                handles[nhandles++] = (HANDLE)fds[i].fd;
+        }
+
+        /* If no timeout and handles to poll, recurse to poll them,
+         * too.
+         */
+        recursed_result = poll_rest(FALSE, handles, nhandles, fds, nfds, 0);
+        return (recursed_result == -1) ? -1 : 1 + recursed_result;
+    } else if (/* QEMU: removed the following unneeded statement which causes
+                * a compiler warning: ready >= WAIT_OBJECT_0 && */
+               ready < WAIT_OBJECT_0 + nhandles) {
+        for (f = fds; f < &fds[nfds]; ++f) {
+            if ((HANDLE) f->fd == handles[ready - WAIT_OBJECT_0]) {
+                f->revents = f->events;
+            }
+        }
+
+        /* If no timeout and polling several handles, recurse to poll
+         * the rest of them.
+         */
+        if (timeout == 0 && nhandles > 1) {
+            /* Remove the handle that fired */
+            int i;
+            if (ready < nhandles - 1) {
+                for (i = ready - WAIT_OBJECT_0 + 1; i < nhandles; i++) {
+                    handles[i-1] = handles[i];
+                }
+            }
+            nhandles--;
+            recursed_result = poll_rest(FALSE, handles, nhandles, fds, nfds, 0);
+            return (recursed_result == -1) ? -1 : 1 + recursed_result;
+        }
+        return 1;
+    }
+
+    return 0;
+}
+
+gint g_poll(GPollFD *fds, guint nfds, gint timeout)
+{
+    HANDLE handles[MAXIMUM_WAIT_OBJECTS];
+    gboolean poll_msgs = FALSE;
+    GPollFD *f;
+    gint nhandles = 0;
+    int retval;
+
+    for (f = fds; f < &fds[nfds]; ++f) {
+        if (f->fd == G_WIN32_MSG_HANDLE && (f->events & G_IO_IN)) {
+            poll_msgs = TRUE;
+        } else if (f->fd > 0) {
+            /* Don't add the same handle several times into the array, as
+             * docs say that is not allowed, even if it actually does seem
+             * to work.
+             */
+            gint i;
+
+            for (i = 0; i < nhandles; i++) {
+                if (handles[i] == (HANDLE) f->fd) {
+                    break;
+                }
+            }
+
+            if (i == nhandles) {
+                if (nhandles == MAXIMUM_WAIT_OBJECTS) {
+                    g_warning("Too many handles to wait for!\n");
+                    break;
+                } else {
+                    handles[nhandles++] = (HANDLE) f->fd;
+                }
             }
         }
     }
 
-    for (i = 0; i < nfds; ++i) {
+    for (f = fds; f < &fds[nfds]; ++f) {
-        fds[i].revents = 0;
+        f->revents = 0;
     }
 
     if (timeout == -1) {
         timeout = INFINITE;
     }
 
-    if (nhandles == 0) {
+    /* Polling for several things? */
-        if (timeout == INFINITE) {
+    if (nhandles > 1 || (nhandles > 0 && poll_msgs)) {
-            return -1;
+        /* First check if one or several of them are immediately
-        } else {
+         * available
-            SleepEx(timeout, TRUE);
-            return 0;
-        }
-    }
-
-    while (1) {
-        DWORD res;
-        gint j;
-
-        res = WaitForMultipleObjectsEx(nhandles, handles, FALSE,
-            timeout, TRUE);
-
-        if (res == WAIT_FAILED) {
-            for (i = 0; i < nfds; ++i) {
-                fds[i].revents = 0;
-            }
-
-            return -1;
-        } else if ((res == WAIT_TIMEOUT) || (res == WAIT_IO_COMPLETION) ||
-                   ((int)res < (int)WAIT_OBJECT_0) ||
-                   (res >= (WAIT_OBJECT_0 + nhandles))) {
-            break;
-        }
-
-        for (i = 0; i < nfds; ++i) {
-            if (handles[res - WAIT_OBJECT_0] == (HANDLE)fds[i].fd) {
-                fds[i].revents = fds[i].events;
-            }
-        }
-
-        ++num_completed;
-
-        if (nhandles <= 1) {
-            break;
-        }
-
-        /* poll the rest of the handles
          */
-        for (j = res - WAIT_OBJECT_0 + 1; j < nhandles; j++) {
+        retval = poll_rest(poll_msgs, handles, nhandles, fds, nfds, 0);
-            handles[j - 1] = handles[j];
-        }
-        --nhandles;
 
-        timeout = 0;
+        /* If not, and we have a significant timeout, poll again with
+         * timeout then. Note that this will return indication for only
+         * one event, or only for messages. We ignore timeouts less than
+         * ten milliseconds as they are mostly pointless on Windows, the
+         * MsgWaitForMultipleObjectsEx() call will timeout right away
+         * anyway.
+         *
+         * Modification for QEMU: replaced timeout >= 10 by timeout > 0.
+         */
+        if (retval == 0 && (timeout == INFINITE || timeout > 0)) {
+            retval = poll_rest(poll_msgs, handles, nhandles,
+                               fds, nfds, timeout);
+        }
+    } else {
+        /* Just polling for one thing, so no need to check first if
+         * available immediately
+         */
+        retval = poll_rest(poll_msgs, handles, nhandles, fds, nfds, timeout);
     }
 
-    return num_completed;
+    if (retval == -1) {
+        for (f = fds; f < &fds[nfds]; ++f) {
+            f->revents = 0;
+        }
+    }
+
+    return retval;
 }