Re: [Qemu-devel] [PATCH] w32: Fix regression caused by new g_poll implementation

[Sangho Park]

Thanks for the quick patch.
Best Regards,
Sangho Park

-----Original Message-----
From: address@hidden
[mailto:address@hidden On Behalf
Of Stefan Weil
Sent: Saturday, May 17, 2014 5:35 PM
To: address@hidden; Peter Maydell
Cc: Stanislav Vorobiov; Stefan Weil; Stefan Hajnoczi; Sangho Park
Subject: [Qemu-devel] [PATCH] 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 <address@hidden>
---

Hello Peter,

please apply this patch directly (regression fix) after it was reviewed.

I tested the patch on Linux with wine32 and wine64 (both behave here like
native Windows: qemu-system-i386 hangs when reading the hard disk in BIOS
without the patch).

Still missing: compilation test with MinGW instead of MinGW-w64 (my Linux
cross build only supports MinGW-w64).

Thanks,
Stefan

PS. An additional patch could remove the g_poll_fixed hack and simply
    implement g_poll here.

 util/oslib-win32.c |  231
++++++++++++++++++++++++++++++++++------------------
 1 file changed, 152 insertions(+), 79 deletions(-)

diff --git a/util/oslib-win32.c b/util/oslib-win32.c index 3077df3..d04dc8f
100644
--- a/util/oslib-win32.c
+++ b/util/oslib-win32.c
@@ -138,7 +138,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;
@@ -256,113 +256,186 @@ 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);
- *
- * 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
+ * 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'.
  */
-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
          */
-        for (j = res - WAIT_OBJECT_0 + 1; j < nhandles; j++) {
-            handles[j - 1] = handles[j];
+        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.
+         */
+        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;
 }
--
1.7.10.4