w32: Fix regression caused by new g_poll implementation

Commit 5a007547df76446ab891df93ebc55749716609bf 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>

1 files changed, 174 insertions, 78 deletions

diff --git a/util/oslib-win32.c b/util/oslib-win32.c
index 69552f7ec3..157f10fab2 100644
--- a/util/oslib-win32.c
+++ b/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
- * timeouts < 10ms, in glib/gpoll.c:
+ * The original implementation of g_poll from glib has a problem on Windows
+ * when using timeouts < 10 ms.
  *
- * // 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.
+ * Whenever g_poll is called with timeout < 10 ms, it does a quick poll instead
+ * of wait. This causes significant performance degradation of QEMU.
  *
- * if (retval == 0 && (timeout == INFINITE || timeout >= 10))
- *   retval = poll_rest (poll_msgs, handles, nhandles, fds, nfds, timeout);
+ * The following code is a copy of the original code from glib/gpoll.c
+ * (glib commit 20f4d1820b8d4d0fc4447188e33efffd6d4a88d8 from 2014-02-19).
+ * Some debug code was removed and the code was reformatted.
+ * All other code modifications are marked with 'QEMU'.
+ */
+
+/*
+ * gpoll.c: poll(2) abstraction
+ * Copyright 1998 Owen Taylor
+ * Copyright 2008 Red Hat, Inc.
  *
- * So whenever g_poll is called with timeout < 10ms it does
- * a quick poll instead of wait, this causes significant performance
- * degradation of QEMU, thus we should use WaitForMultipleObjectsEx
- * directly
+ * 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/>.
  */
-gint g_poll_fixed(GPollFD *fds, guint nfds, gint timeout)
+
+static int poll_rest(gboolean poll_msgs, HANDLE *handles, gint nhandles,
+                     GPollFD *fds, guint nfds, gint timeout)
 {
-    guint i;
-    HANDLE handles[MAXIMUM_WAIT_OBJECTS];
-    gint nhandles = 0;
-    int num_completed = 0;
+    DWORD ready;
+    GPollFD *f;
+    int recursed_result;
 
-    for (i = 0; i < nfds; i++) {
-        gint j;
+    if (poll_msgs) {
+        /* Wait for either messages or handles
+         * -> Use MsgWaitForMultipleObjectsEx
+         */
+        ready = MsgWaitForMultipleObjectsEx(nhandles, handles, timeout,
+                                            QS_ALLINPUT, MWMO_ALERTABLE);
 
-        if (fds[i].fd <= 0) {
-            continue;
+        if (ready == WAIT_FAILED) {
+            gchar *emsg = g_win32_error_message(GetLastError());
+            g_warning("MsgWaitForMultipleObjectsEx failed: %s", emsg);
+            g_free(emsg);
         }
-
-        /* don't add same handle several times
+    } 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
          */
-        for (j = 0; j < nhandles; j++) {
-            if (handles[j] == (HANDLE)fds[i].fd) {
-                break;
-            }
+        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 (j == nhandles) {
-            if (nhandles == MAXIMUM_WAIT_OBJECTS) {
-                fprintf(stderr, "Too many handles to wait for!\n");
-                break;
-            } else {
-                handles[nhandles++] = (HANDLE)fds[i].fd;
+    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;
             }
         }
-    }
 
-    for (i = 0; i < nfds; ++i) {
-        fds[i].revents = 0;
-    }
+        /* If we have a timeout, or no handles to poll, be satisfied
+         * with just noticing we have messages waiting.
+         */
+        if (timeout != 0 || nhandles == 0) {
+            return 1;
+        }
 
-    if (timeout == -1) {
-        timeout = INFINITE;
-    }
+        /* 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 (nhandles == 0) {
-        if (timeout == INFINITE) {
-            return -1;
-        } else {
-            SleepEx(timeout, TRUE);
-            return 0;
+        /* 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;
     }
 
-    while (1) {
-        DWORD res;
-        gint j;
-
-        res = WaitForMultipleObjectsEx(nhandles, handles, FALSE,
-            timeout, TRUE);
+    return 0;
+}
 
-        if (res == WAIT_FAILED) {
-            for (i = 0; i < nfds; ++i) {
-                fds[i].revents = 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;
+                }
             }
 
-            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;
+            if (i == nhandles) {
+                if (nhandles == MAXIMUM_WAIT_OBJECTS) {
+                    g_warning("Too many handles to wait for!\n");
+                    break;
+                } else {
+                    handles[nhandles++] = (HANDLE) f->fd;
+                }
             }
         }
+    }
 
-        ++num_completed;
+    for (f = fds; f < &fds[nfds]; ++f) {
+        f->revents = 0;
+    }
 
-        if (nhandles <= 1) {
-            break;
-        }
+    if (timeout == -1) {
+        timeout = INFINITE;
+    }
 
-        /* poll the rest of the handles
+    /* Polling for several things? */
+    if (nhandles > 1 || (nhandles > 0 && poll_msgs)) {
+        /* First check if one or several of them are immediately
+         * available
+         */
+        retval = poll_rest(poll_msgs, handles, nhandles, fds, nfds, 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.
          */
-        for (j = res - WAIT_OBJECT_0 + 1; j < nhandles; j++) {
-            handles[j - 1] = handles[j];
+        if (retval == 0 && (timeout == INFINITE || timeout > 0)) {
+            retval = poll_rest(poll_msgs, handles, nhandles,
+                               fds, nfds, timeout);
         }
-        --nhandles;
+    } 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);
+    }
 
-        timeout = 0;
+    if (retval == -1) {
+        for (f = fds; f < &fds[nfds]; ++f) {
+            f->revents = 0;
+        }
     }
 
-    return num_completed;
+    return retval;
 }