mirrors/qemu
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

w32: Fix regression caused by new g_poll implementation

Browse Source 
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>
This commit is contained in:
Stefan Weil 2014-05-28 17:42:24 +02:00 committed by Peter Maydell
parent d279279e2b
commit e637aa6647
1 changed files with 183 additions and 87 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

254
util/oslib-win32.c
View File

@ -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>
@ -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);
*
* 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)
/*
* 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;
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);
}
} 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);
}
}
/* don't add same handle several times
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 we have a timeout, or no handles to poll, be satisfied
* with just noticing we have messages waiting.
*/
for (j = 0; j < nhandles; j++) {
if (handles[j] == (HANDLE)fds[i].fd) {
if (timeout != 0 || nhandles == 0) {
return 1;
}
/* 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 (j == nhandles) {
if (i == nhandles) {
if (nhandles == MAXIMUM_WAIT_OBJECTS) {
fprintf(stderr, "Too many handles to wait for!\n");
g_warning("Too many handles to wait for!\n");
break;
} else {
handles[nhandles++] = (HANDLE)fds[i].fd;
handles[nhandles++] = (HANDLE) f->fd;
}
}
}
}
for (i = 0; i < nfds; ++i) {
fds[i].revents = 0;
for (f = fds; f < &fds[nfds]; ++f) {
f->revents = 0;
}
if (timeout == -1) {
timeout = INFINITE;
}
if (nhandles == 0) {
if (timeout == INFINITE) {
return -1;
} else {
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
/* 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];
}
--nhandles;
retval = poll_rest(poll_msgs, handles, nhandles, fds, nfds, 0);
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;
}