From ed9164a3549f93204d6b096136cda2ce54e9f03a Mon Sep 17 00:00:00 2001 From: Olivier Hainque Date: Tue, 9 Apr 2013 18:06:53 +0200 Subject: [PATCH 1/4] Check effective suspension of TCG thread On multi-core systems, SuspendThread does not guaranty immediate thread suspension. We add busy loop to wait for effective thread suspension after call to ThreadSuspend(). Signed-off-by: Fabien Chouteau Reviewed-by: Paolo Bonzini Signed-off-by: Stefan Weil --- cpus.c | 24 ++++++++++++++++++++++-- 1 file changed, 22 insertions(+), 2 deletions(-) diff --git a/cpus.c b/cpus.c index e919dd7fb6..97e9ab4c07 100644 --- a/cpus.c +++ b/cpus.c @@ -862,9 +862,29 @@ static void qemu_cpu_kick_thread(CPUState *cpu) } #else /* _WIN32 */ if (!qemu_cpu_is_self(cpu)) { - SuspendThread(cpu->hThread); + CONTEXT tcgContext; + + if (SuspendThread(cpu->hThread) == (DWORD)-1) { + fprintf(stderr, "qemu:%s: GetLastError:%d\n", __func__, + GetLastError()); + exit(1); + } + + /* On multi-core systems, we are not sure that the thread is actually + * suspended until we can get the context. + */ + tcgContext.ContextFlags = CONTEXT_CONTROL; + while (GetThreadContext(cpu->hThread, &tcgContext) != 0) { + continue; + } + cpu_signal(0); - ResumeThread(cpu->hThread); + + if (ResumeThread(cpu->hThread) == (DWORD)-1) { + fprintf(stderr, "qemu:%s: GetLastError:%d\n", __func__, + GetLastError()); + exit(1); + } } #endif } From ec9bd89fa48147e1d16e078217513c1235f9132a Mon Sep 17 00:00:00 2001 From: Olivier Hainque Date: Tue, 9 Apr 2013 18:06:54 +0200 Subject: [PATCH 2/4] Ensure good ordering of memory instruction in cpu_exec The IO thread, when it senses cpu_single_env == 0, expects exit_request to be checked later on. A compiler scheduling constraint is not strong enough to ensure this on modern architecture. A memory fence is needed as well. Signed-off-by: Olivier Hainque Signed-off-by: Fabien Chouteau Reviewed-by: Paolo Bonzini Signed-off-by: Stefan Weil --- cpu-exec.c | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/cpu-exec.c b/cpu-exec.c index e74e55656a..aa8fa893d9 100644 --- a/cpu-exec.c +++ b/cpu-exec.c @@ -217,6 +217,14 @@ int cpu_exec(CPUArchState *env) cpu_single_env = env; + /* As long as cpu_single_env is null, up to the assignment just above, + * requests by other threads to exit the execution loop are expected to + * be issued using the exit_request global. We must make sure that our + * evaluation of the global value is performed past the cpu_single_env + * value transition point, which requires a memory barrier as well as + * an instruction scheduling constraint on modern architectures. */ + smp_mb(); + if (unlikely(exit_request)) { cpu->exit_request = 1; } From 1046127d1fcc69359b3f5a44de08e6c5b16c90bc Mon Sep 17 00:00:00 2001 From: Fabien Chouteau Date: Tue, 9 Apr 2013 18:06:55 +0200 Subject: [PATCH 3/4] Release SMP restriction on Windows The previous patches make QEMU SMP safe on Windows, we can now release the restriction. Signed-off-by: Fabien Chouteau Reviewed-by: Paolo Bonzini Signed-off-by: Stefan Weil --- os-win32.c | 18 ------------------ 1 file changed, 18 deletions(-) diff --git a/os-win32.c b/os-win32.c index 9673a81c7d..c7f6b5c6b0 100644 --- a/os-win32.c +++ b/os-win32.c @@ -69,25 +69,7 @@ static BOOL WINAPI qemu_ctrl_handler(DWORD type) void os_setup_early_signal_handling(void) { - /* Note: cpu_interrupt() is currently not SMP safe, so we force - QEMU to run on a single CPU */ - HANDLE h; - DWORD_PTR mask, smask; - int i; - SetConsoleCtrlHandler(qemu_ctrl_handler, TRUE); - - h = GetCurrentProcess(); - if (GetProcessAffinityMask(h, &mask, &smask)) { - for(i = 0; i < 32; i++) { - if (mask & (1 << i)) - break; - } - if (i != 32) { - mask = 1 << i; - SetProcessAffinityMask(h, mask); - } - } } /* Look for support files in the same directory as the executable. */ From 0727b867542eea7fedfd2c53568e9782627fd3bd Mon Sep 17 00:00:00 2001 From: Paolo Bonzini Date: Wed, 20 Feb 2013 14:43:31 +0100 Subject: [PATCH 4/4] qemu-timer: move timeBeginPeriod/timeEndPeriod to os-win32 These are needed for any of the Win32 alarm timer implementations. They are not tied to mmtimer exclusively. Jacob tested this patch with both mmtimer and Win32 timers. Cc: qemu-stable@nongnu.org Tested-by: Jacob Kroon Signed-off-by: Paolo Bonzini Signed-off-by: Stefan Weil --- os-win32.c | 11 +++++++++++ qemu-timer.c | 24 ++++++------------------ 2 files changed, 17 insertions(+), 18 deletions(-) diff --git a/os-win32.c b/os-win32.c index c7f6b5c6b0..50b7f6f885 100644 --- a/os-win32.c +++ b/os-win32.c @@ -23,6 +23,7 @@ * THE SOFTWARE. */ #include +#include #include #include #include @@ -67,9 +68,19 @@ static BOOL WINAPI qemu_ctrl_handler(DWORD type) return TRUE; } +static TIMECAPS mm_tc; + +static void os_undo_timer_resolution(void) +{ + timeEndPeriod(mm_tc.wPeriodMin); +} + void os_setup_early_signal_handling(void) { SetConsoleCtrlHandler(qemu_ctrl_handler, TRUE); + timeGetDevCaps(&mm_tc, sizeof(mm_tc)); + timeBeginPeriod(mm_tc.wPeriodMin); + atexit(os_undo_timer_resolution); } /* Look for support files in the same directory as the executable. */ diff --git a/qemu-timer.c b/qemu-timer.c index 8fb5c75df7..b2d95e2fec 100644 --- a/qemu-timer.c +++ b/qemu-timer.c @@ -624,28 +624,14 @@ static void CALLBACK mm_alarm_handler(UINT uTimerID, UINT uMsg, static int mm_start_timer(struct qemu_alarm_timer *t) { timeGetDevCaps(&mm_tc, sizeof(mm_tc)); - - timeBeginPeriod(mm_tc.wPeriodMin); - - mm_timer = timeSetEvent(mm_tc.wPeriodMin, /* interval (ms) */ - mm_tc.wPeriodMin, /* resolution */ - mm_alarm_handler, /* function */ - (DWORD_PTR)t, /* parameter */ - TIME_ONESHOT | TIME_CALLBACK_FUNCTION); - - if (!mm_timer) { - fprintf(stderr, "Failed to initialize win32 alarm timer\n"); - timeEndPeriod(mm_tc.wPeriodMin); - return -1; - } - return 0; } static void mm_stop_timer(struct qemu_alarm_timer *t) { - timeKillEvent(mm_timer); - timeEndPeriod(mm_tc.wPeriodMin); + if (mm_timer) { + timeKillEvent(mm_timer); + } } static void mm_rearm_timer(struct qemu_alarm_timer *t, int64_t delta) @@ -657,7 +643,9 @@ static void mm_rearm_timer(struct qemu_alarm_timer *t, int64_t delta) nearest_delta_ms = mm_tc.wPeriodMax; } - timeKillEvent(mm_timer); + if (mm_timer) { + timeKillEvent(mm_timer); + } mm_timer = timeSetEvent((UINT)nearest_delta_ms, mm_tc.wPeriodMin, mm_alarm_handler,