Patchwork fix win32 build

On Windows, cpus.c needs access to the hThread.  Add a Windows-specific
function to grab it.  This requires changing the CPU threads to
joinable.  There is no substantial change because the threads run
in an infinite loop.

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
---
 cpu-defs.h          |    9 +++++++++
 cpus.c              |   11 +++++++----
 qemu-thread-win32.c |   29 +++++++++++++++++++++++------
 qemu-thread-win32.h |    3 +++
 4 files changed, 42 insertions(+), 10 deletions(-)

On 12/13/2011 06:43 AM, Paolo Bonzini wrote:
> On Windows, cpus.c needs access to the hThread.  Add a Windows-specific
> function to grab it.  This requires changing the CPU threads to
> joinable.  There is no substantial change because the threads run
> in an infinite loop.
>
> Signed-off-by: Paolo Bonzini<pbonzini@redhat.com>

Applied.  Thanks.

Regards,

Anthony Liguori

> ---
>   cpu-defs.h          |    9 +++++++++
>   cpus.c              |   11 +++++++----
>   qemu-thread-win32.c |   29 +++++++++++++++++++++++------
>   qemu-thread-win32.h |    3 +++
>   4 files changed, 42 insertions(+), 10 deletions(-)
>
> diff --git a/cpu-defs.h b/cpu-defs.h
> index db48a7a..57a709b 100644
> --- a/cpu-defs.h
> +++ b/cpu-defs.h
> @@ -153,6 +153,14 @@ typedef struct CPUWatchpoint {
>       QTAILQ_ENTRY(CPUWatchpoint) entry;
>   } CPUWatchpoint;
>
> +#ifdef _WIN32
> +#define CPU_COMMON_THREAD \
> +    void *hThread;
> +
> +#else
> +#define CPU_COMMON_THREAD
> +#endif
> +
>   #define CPU_TEMP_BUF_NLONGS 128
>   #define CPU_COMMON                                                      \
>       struct TranslationBlock *current_tb; /* currently executing TB  */  \
> @@ -211,6 +219,7 @@ typedef struct CPUWatchpoint {
>       uint32_t stop;   /* Stop request */                                 \
>       uint32_t stopped; /* Artificially stopped */                        \
>       struct QemuThread *thread;                                          \
> +    CPU_COMMON_THREAD                                                   \
>       struct QemuCond *halt_cond;                                         \
>       int thread_kicked;                                                  \
>       struct qemu_work_item *queued_work_first, *queued_work_last;        \
> diff --git a/cpus.c b/cpus.c
> index 1ada0f5..11893d5 100644
> --- a/cpus.c
> +++ b/cpus.c
> @@ -793,9 +793,9 @@ static void qemu_cpu_kick_thread(CPUState *env)
>       }
>   #else /* _WIN32 */
>       if (!qemu_cpu_is_self(env)) {
> -        SuspendThread(env->thread->thread);
> +        SuspendThread(env->hThread);
>           cpu_signal(0);
> -        ResumeThread(env->thread->thread);
> +        ResumeThread(env->hThread);
>       }
>   #endif
>   }
> @@ -911,7 +911,10 @@ static void qemu_tcg_init_vcpu(void *_env)
>           qemu_cond_init(env->halt_cond);
>           tcg_halt_cond = env->halt_cond;
>           qemu_thread_create(env->thread, qemu_tcg_cpu_thread_fn, env,
> -                           QEMU_THREAD_DETACHED);
> +                           QEMU_THREAD_JOINABLE);
> +#ifdef _WIN32
> +        env->hThread = qemu_thread_get_handle(env->thread);
> +#endif
>           while (env->created == 0) {
>               qemu_cond_wait(&qemu_cpu_cond,&qemu_global_mutex);
>           }
> @@ -928,7 +931,7 @@ static void qemu_kvm_start_vcpu(CPUState *env)
>       env->halt_cond = g_malloc0(sizeof(QemuCond));
>       qemu_cond_init(env->halt_cond);
>       qemu_thread_create(env->thread, qemu_kvm_cpu_thread_fn, env,
> -                       QEMU_THREAD_DETACHED);
> +                       QEMU_THREAD_JOINABLE);
>       while (env->created == 0) {
>           qemu_cond_wait(&qemu_cpu_cond,&qemu_global_mutex);
>       }
> diff --git a/qemu-thread-win32.c b/qemu-thread-win32.c
> index a13ffcc..fe9b931 100644
> --- a/qemu-thread-win32.c
> +++ b/qemu-thread-win32.c
> @@ -252,14 +252,10 @@ void *qemu_thread_join(QemuThread *thread)
>        * discard the handle that _beginthreadex gives back, and
>        * get another copy of the handle here.
>        */
> -    EnterCriticalSection(&data->cs);
> -    if (!data->exited) {
> -        handle = OpenThread(SYNCHRONIZE, FALSE, thread->tid);
> -        LeaveCriticalSection(&data->cs);
> +    handle = qemu_thread_get_handle(thread);
> +    if (handle) {
>           WaitForSingleObject(handle, INFINITE);
>           CloseHandle(handle);
> -    } else {
> -        LeaveCriticalSection(&data->cs);
>       }
>       ret = data->ret;
>       DeleteCriticalSection(&data->cs);
> @@ -308,6 +304,27 @@ void qemu_thread_get_self(QemuThread *thread)
>       thread->tid = GetCurrentThreadId();
>   }
>
> +HANDLE qemu_thread_get_handle(QemuThread *thread)
> +{
> +    QemuThreadData *data;
> +    HANDLE handle;
> +
> +    data = thread->data;
> +    if (!data) {
> +        return NULL;
> +    }
> +
> +    EnterCriticalSection(&data->cs);
> +    if (!data->exited) {
> +        handle = OpenThread(SYNCHRONIZE | THREAD_SUSPEND_RESUME, FALSE,
> +                            thread->tid);
> +    } else {
> +        handle = NULL;
> +    }
> +    LeaveCriticalSection(&data->cs);
> +    return handle;
> +}
> +
>   int qemu_thread_is_self(QemuThread *thread)
>   {
>       return GetCurrentThreadId() == thread->tid;
> diff --git a/qemu-thread-win32.h b/qemu-thread-win32.h
> index 2983490..b9d1be8 100644
> --- a/qemu-thread-win32.h
> +++ b/qemu-thread-win32.h
> @@ -19,4 +19,7 @@ struct QemuThread {
>       unsigned tid;
>   };
>
> +/* Only valid for joinable threads.  */
> +HANDLE qemu_thread_get_handle(QemuThread *thread);
> +
>   #endif