util/qemu-thread-win32.c

   1 /*
   2  * Win32 implementation for mutex/cond/thread functions
   3  *
   4  * Copyright Red Hat, Inc. 2010
   5  *
   6  * Author:
   7  *  Paolo Bonzini <pbonzini@redhat.com>
   8  *
   9  * This work is licensed under the terms of the GNU GPL, version 2 or later.
  10  * See the COPYING file in the top-level directory.
  11  *
  12  */
  13
  14 #include "qemu/osdep.h"
  15 #include "qemu/thread.h"
  16 #include "qemu/notify.h"
  17 #include "qemu-thread-common.h"
  18 #include <process.h>
  19
  20 static bool name_threads;
  21
  22 typedef HRESULT (WINAPI *pSetThreadDescription) (HANDLE hThread,
  23                                                  PCWSTR lpThreadDescription);
  24 static pSetThreadDescription SetThreadDescriptionFunc;
  25 static HMODULE kernel32_module;
  26
  27 static bool load_set_thread_description(void)
  28 {
  29     static gsize _init_once = 0;
  30
  31     if (g_once_init_enter(&_init_once)) {
  32         kernel32_module = LoadLibrary("kernel32.dll");
  33         if (kernel32_module) {
  34 #pragma GCC diagnostic ignored "-Wcast-function-type"
  35             SetThreadDescriptionFunc =
  36                 (pSetThreadDescription)GetProcAddress(kernel32_module,
  37                                                       "SetThreadDescription");
  38             if (!SetThreadDescriptionFunc) {
  39                 FreeLibrary(kernel32_module);
  40             }
  41         }
  42         g_once_init_leave(&_init_once, 1);
  43     }
  44
  45     return !!SetThreadDescriptionFunc;
  46 }
  47
  48 void qemu_thread_naming(bool enable)
  49 {
  50     name_threads = enable;
  51
  52     if (enable && !load_set_thread_description()) {
  53         fprintf(stderr, "qemu: thread naming not supported on this host\n");
  54         name_threads = false;
  55     }
  56 }
  57
  58 static void error_exit(int err, const char *msg)
  59 {
  60     char *pstr;
  61
  62     FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER,
  63                   NULL, err, 0, (LPTSTR)&pstr, 2, NULL);
  64     fprintf(stderr, "qemu: %s: %s\n", msg, pstr);
  65     LocalFree(pstr);
  66     abort();
  67 }
  68
  69 void qemu_mutex_init(QemuMutex *mutex)
  70 {
  71     InitializeSRWLock(&mutex->lock);
  72     qemu_mutex_post_init(mutex);
  73 }
  74
  75 void qemu_mutex_destroy(QemuMutex *mutex)
  76 {
  77     assert(mutex->initialized);
  78     mutex->initialized = false;
  79     InitializeSRWLock(&mutex->lock);
  80 }
  81
  82 void qemu_mutex_lock_impl(QemuMutex *mutex, const char *file, const int line)
  83 {
  84     assert(mutex->initialized);
  85     qemu_mutex_pre_lock(mutex, file, line);
  86     AcquireSRWLockExclusive(&mutex->lock);
  87     qemu_mutex_post_lock(mutex, file, line);
  88 }
  89
  90 int qemu_mutex_trylock_impl(QemuMutex *mutex, const char *file, const int line)
  91 {
  92     int owned;
  93
  94     assert(mutex->initialized);
  95     owned = TryAcquireSRWLockExclusive(&mutex->lock);
  96     if (owned) {
  97         qemu_mutex_post_lock(mutex, file, line);
  98         return 0;
  99     }
 100     return -EBUSY;
 101 }
 102
 103 void qemu_mutex_unlock_impl(QemuMutex *mutex, const char *file, const int line)
 104 {
 105     assert(mutex->initialized);
 106     qemu_mutex_pre_unlock(mutex, file, line);
 107     ReleaseSRWLockExclusive(&mutex->lock);
 108 }
 109
 110 void qemu_rec_mutex_init(QemuRecMutex *mutex)
 111 {
 112     InitializeCriticalSection(&mutex->lock);
 113     mutex->initialized = true;
 114 }
 115
 116 void qemu_rec_mutex_destroy(QemuRecMutex *mutex)
 117 {
 118     assert(mutex->initialized);
 119     mutex->initialized = false;
 120     DeleteCriticalSection(&mutex->lock);
 121 }
 122
 123 void qemu_rec_mutex_lock_impl(QemuRecMutex *mutex, const char *file, int line)
 124 {
 125     assert(mutex->initialized);
 126     EnterCriticalSection(&mutex->lock);
 127 }
 128
 129 int qemu_rec_mutex_trylock_impl(QemuRecMutex *mutex, const char *file, int line)
 130 {
 131     assert(mutex->initialized);
 132     return !TryEnterCriticalSection(&mutex->lock);
 133 }
 134
 135 void qemu_rec_mutex_unlock_impl(QemuRecMutex *mutex, const char *file, int line)
 136 {
 137     assert(mutex->initialized);
 138     LeaveCriticalSection(&mutex->lock);
 139 }
 140
 141 void qemu_cond_init(QemuCond *cond)
 142 {
 143     memset(cond, 0, sizeof(*cond));
 144     InitializeConditionVariable(&cond->var);
 145     cond->initialized = true;
 146 }
 147
 148 void qemu_cond_destroy(QemuCond *cond)
 149 {
 150     assert(cond->initialized);
 151     cond->initialized = false;
 152     InitializeConditionVariable(&cond->var);
 153 }
 154
 155 void qemu_cond_signal(QemuCond *cond)
 156 {
 157     assert(cond->initialized);
 158     WakeConditionVariable(&cond->var);
 159 }
 160
 161 void qemu_cond_broadcast(QemuCond *cond)
 162 {
 163     assert(cond->initialized);
 164     WakeAllConditionVariable(&cond->var);
 165 }
 166
 167 void qemu_cond_wait_impl(QemuCond *cond, QemuMutex *mutex, const char *file, const int line)
 168 {
 169     assert(cond->initialized);
 170     qemu_mutex_pre_unlock(mutex, file, line);
 171     SleepConditionVariableSRW(&cond->var, &mutex->lock, INFINITE, 0);
 172     qemu_mutex_post_lock(mutex, file, line);
 173 }
 174
 175 bool qemu_cond_timedwait_impl(QemuCond *cond, QemuMutex *mutex, int ms,
 176                               const char *file, const int line)
 177 {
 178     int rc = 0;
 179
 180     assert(cond->initialized);
 181     trace_qemu_mutex_unlock(mutex, file, line);
 182     if (!SleepConditionVariableSRW(&cond->var, &mutex->lock, ms, 0)) {
 183         rc = GetLastError();
 184     }
 185     trace_qemu_mutex_locked(mutex, file, line);
 186     if (rc && rc != ERROR_TIMEOUT) {
 187         error_exit(rc, __func__);
 188     }
 189     return rc != ERROR_TIMEOUT;
 190 }
 191
 192 void qemu_sem_init(QemuSemaphore *sem, int init)
 193 {
 194     /* Manual reset.  */
 195     sem->sema = CreateSemaphore(NULL, init, LONG_MAX, NULL);
 196     sem->initialized = true;
 197 }
 198
 199 void qemu_sem_destroy(QemuSemaphore *sem)
 200 {
 201     assert(sem->initialized);
 202     sem->initialized = false;
 203     CloseHandle(sem->sema);
 204 }
 205
 206 void qemu_sem_post(QemuSemaphore *sem)
 207 {
 208     assert(sem->initialized);
 209     ReleaseSemaphore(sem->sema, 1, NULL);
 210 }
 211
 212 int qemu_sem_timedwait(QemuSemaphore *sem, int ms)
 213 {
 214     int rc;
 215
 216     assert(sem->initialized);
 217     rc = WaitForSingleObject(sem->sema, ms);
 218     if (rc == WAIT_OBJECT_0) {
 219         return 0;
 220     }
 221     if (rc != WAIT_TIMEOUT) {
 222         error_exit(GetLastError(), __func__);
 223     }
 224     return -1;
 225 }
 226
 227 void qemu_sem_wait(QemuSemaphore *sem)
 228 {
 229     assert(sem->initialized);
 230     if (WaitForSingleObject(sem->sema, INFINITE) != WAIT_OBJECT_0) {
 231         error_exit(GetLastError(), __func__);
 232     }
 233 }
 234
 235 /* Wrap a Win32 manual-reset event with a fast userspace path.  The idea
 236  * is to reset the Win32 event lazily, as part of a test-reset-test-wait
 237  * sequence.  Such a sequence is, indeed, how QemuEvents are used by
 238  * RCU and other subsystems!
 239  *
 240  * Valid transitions:
 241  * - free->set, when setting the event
 242  * - busy->set, when setting the event, followed by SetEvent
 243  * - set->free, when resetting the event
 244  * - free->busy, when waiting
 245  *
 246  * set->busy does not happen (it can be observed from the outside but
 247  * it really is set->free->busy).
 248  *
 249  * busy->free provably cannot happen; to enforce it, the set->free transition
 250  * is done with an OR, which becomes a no-op if the event has concurrently
 251  * transitioned to free or busy (and is faster than cmpxchg).
 252  */
 253
 254 #define EV_SET         0
 255 #define EV_FREE        1
 256 #define EV_BUSY       -1
 257
 258 void qemu_event_init(QemuEvent *ev, bool init)
 259 {
 260     /* Manual reset.  */
 261     ev->event = CreateEvent(NULL, TRUE, TRUE, NULL);
 262     ev->value = (init ? EV_SET : EV_FREE);
 263     ev->initialized = true;
 264 }
 265
 266 void qemu_event_destroy(QemuEvent *ev)
 267 {
 268     assert(ev->initialized);
 269     ev->initialized = false;
 270     CloseHandle(ev->event);
 271 }
 272
 273 void qemu_event_set(QemuEvent *ev)
 274 {
 275     assert(ev->initialized);
 276
 277     /*
 278      * Pairs with both qemu_event_reset() and qemu_event_wait().
 279      *
 280      * qemu_event_set has release semantics, but because it *loads*
 281      * ev->value we need a full memory barrier here.
 282      */
 283     smp_mb();
 284     if (qatomic_read(&ev->value) != EV_SET) {
 285         int old = qatomic_xchg(&ev->value, EV_SET);
 286
 287         /* Pairs with memory barrier after ResetEvent.  */
 288         smp_mb__after_rmw();
 289         if (old == EV_BUSY) {
 290             /* There were waiters, wake them up.  */
 291             SetEvent(ev->event);
 292         }
 293     }
 294 }
 295
 296 void qemu_event_reset(QemuEvent *ev)
 297 {
 298     assert(ev->initialized);
 299
 300     /*
 301      * If there was a concurrent reset (or even reset+wait),
 302      * do nothing.  Otherwise change EV_SET->EV_FREE.
 303      */
 304     qatomic_or(&ev->value, EV_FREE);
 305
 306     /*
 307      * Order reset before checking the condition in the caller.
 308      * Pairs with the first memory barrier in qemu_event_set().
 309      */
 310     smp_mb__after_rmw();
 311 }
 312
 313 void qemu_event_wait(QemuEvent *ev)
 314 {
 315     unsigned value;
 316
 317     assert(ev->initialized);
 318
 319     /*
 320      * qemu_event_wait must synchronize with qemu_event_set even if it does
 321      * not go down the slow path, so this load-acquire is needed that
 322      * synchronizes with the first memory barrier in qemu_event_set().
 323      *
 324      * If we do go down the slow path, there is no requirement at all: we
 325      * might miss a qemu_event_set() here but ultimately the memory barrier in
 326      * qemu_futex_wait() will ensure the check is done correctly.
 327      */
 328     value = qatomic_load_acquire(&ev->value);
 329     if (value != EV_SET) {
 330         if (value == EV_FREE) {
 331             /*
 332              * Here the underlying kernel event is reset, but qemu_event_set is
 333              * not yet going to call SetEvent.  However, there will be another
 334              * check for EV_SET below when setting EV_BUSY.  At that point it
 335              * is safe to call WaitForSingleObject.
 336              */
 337             ResetEvent(ev->event);
 338
 339             /*
 340              * It is not clear whether ResetEvent provides this barrier; kernel
 341              * APIs (KeResetEvent/KeClearEvent) do not.  Better safe than sorry!
 342              */
 343             smp_mb();
 344
 345             /*
 346              * Leave the event reset and tell qemu_event_set that there are
 347              * waiters.  No need to retry, because there cannot be a concurrent
 348              * busy->free transition.  After the CAS, the event will be either
 349              * set or busy.
 350              */
 351             if (qatomic_cmpxchg(&ev->value, EV_FREE, EV_BUSY) == EV_SET) {
 352                 return;
 353             }
 354         }
 355
 356         /*
 357          * ev->value is now EV_BUSY.  Since we didn't observe EV_SET,
 358          * qemu_event_set() must observe EV_BUSY and call SetEvent().
 359          */
 360         WaitForSingleObject(ev->event, INFINITE);
 361     }
 362 }
 363
 364 struct QemuThreadData {
 365     /* Passed to win32_start_routine.  */
 366     void             *(*start_routine)(void *);
 367     void             *arg;
 368     short             mode;
 369     NotifierList      exit;
 370
 371     /* Only used for joinable threads. */
 372     bool              exited;
 373     void             *ret;
 374     CRITICAL_SECTION  cs;
 375 };
 376
 377 static bool atexit_registered;
 378 static NotifierList main_thread_exit;
 379
 380 static __thread QemuThreadData *qemu_thread_data;
 381
 382 static void run_main_thread_exit(void)
 383 {
 384     notifier_list_notify(&main_thread_exit, NULL);
 385 }
 386
 387 void qemu_thread_atexit_add(Notifier *notifier)
 388 {
 389     if (!qemu_thread_data) {
 390         if (!atexit_registered) {
 391             atexit_registered = true;
 392             atexit(run_main_thread_exit);
 393         }
 394         notifier_list_add(&main_thread_exit, notifier);
 395     } else {
 396         notifier_list_add(&qemu_thread_data->exit, notifier);
 397     }
 398 }
 399
 400 void qemu_thread_atexit_remove(Notifier *notifier)
 401 {
 402     notifier_remove(notifier);
 403 }
 404
 405 static unsigned __stdcall win32_start_routine(void *arg)
 406 {
 407     QemuThreadData *data = (QemuThreadData *) arg;
 408     void *(*start_routine)(void *) = data->start_routine;
 409     void *thread_arg = data->arg;
 410
 411     qemu_thread_data = data;
 412     qemu_thread_exit(start_routine(thread_arg));
 413     abort();
 414 }
 415
 416 void qemu_thread_exit(void *arg)
 417 {
 418     QemuThreadData *data = qemu_thread_data;
 419
 420     notifier_list_notify(&data->exit, NULL);
 421     if (data->mode == QEMU_THREAD_JOINABLE) {
 422         data->ret = arg;
 423         EnterCriticalSection(&data->cs);
 424         data->exited = true;
 425         LeaveCriticalSection(&data->cs);
 426     } else {
 427         g_free(data);
 428     }
 429     _endthreadex(0);
 430 }
 431
 432 void *qemu_thread_join(QemuThread *thread)
 433 {
 434     QemuThreadData *data;
 435     void *ret;
 436     HANDLE handle;
 437
 438     data = thread->data;
 439     if (data->mode == QEMU_THREAD_DETACHED) {
 440         return NULL;
 441     }
 442
 443     /*
 444      * Because multiple copies of the QemuThread can exist via
 445      * qemu_thread_get_self, we need to store a value that cannot
 446      * leak there.  The simplest, non racy way is to store the TID,
 447      * discard the handle that _beginthreadex gives back, and
 448      * get another copy of the handle here.
 449      */
 450     handle = qemu_thread_get_handle(thread);
 451     if (handle) {
 452         WaitForSingleObject(handle, INFINITE);
 453         CloseHandle(handle);
 454     }
 455     ret = data->ret;
 456     DeleteCriticalSection(&data->cs);
 457     g_free(data);
 458     return ret;
 459 }
 460
 461 static bool set_thread_description(HANDLE h, const char *name)
 462 {
 463     HRESULT hr;
 464     g_autofree wchar_t *namew = NULL;
 465
 466     if (!load_set_thread_description()) {
 467         return false;
 468     }
 469
 470     namew = g_utf8_to_utf16(name, -1, NULL, NULL, NULL);
 471     if (!namew) {
 472         return false;
 473     }
 474
 475     hr = SetThreadDescriptionFunc(h, namew);
 476
 477     return SUCCEEDED(hr);
 478 }
 479
 480 void qemu_thread_create(QemuThread *thread, const char *name,
 481                        void *(*start_routine)(void *),
 482                        void *arg, int mode)
 483 {
 484     HANDLE hThread;
 485     struct QemuThreadData *data;
 486
 487     data = g_malloc(sizeof *data);
 488     data->start_routine = start_routine;
 489     data->arg = arg;
 490     data->mode = mode;
 491     data->exited = false;
 492     notifier_list_init(&data->exit);
 493
 494     if (data->mode != QEMU_THREAD_DETACHED) {
 495         InitializeCriticalSection(&data->cs);
 496     }
 497
 498     hThread = (HANDLE) _beginthreadex(NULL, 0, win32_start_routine,
 499                                       data, 0, &thread->tid);
 500     if (!hThread) {
 501         error_exit(GetLastError(), __func__);
 502     }
 503     if (name_threads && name && !set_thread_description(hThread, name)) {
 504         fprintf(stderr, "qemu: failed to set thread description: %s\n", name);
 505     }
 506     CloseHandle(hThread);
 507
 508     thread->data = data;
 509 }
 510
 511 int qemu_thread_set_affinity(QemuThread *thread, unsigned long *host_cpus,
 512                              unsigned long nbits)
 513 {
 514     return -ENOSYS;
 515 }
 516
 517 int qemu_thread_get_affinity(QemuThread *thread, unsigned long **host_cpus,
 518                              unsigned long *nbits)
 519 {
 520     return -ENOSYS;
 521 }
 522
 523 void qemu_thread_get_self(QemuThread *thread)
 524 {
 525     thread->data = qemu_thread_data;
 526     thread->tid = GetCurrentThreadId();
 527 }
 528
 529 HANDLE qemu_thread_get_handle(QemuThread *thread)
 530 {
 531     QemuThreadData *data;
 532     HANDLE handle;
 533
 534     data = thread->data;
 535     if (data->mode == QEMU_THREAD_DETACHED) {
 536         return NULL;
 537     }
 538
 539     EnterCriticalSection(&data->cs);
 540     if (!data->exited) {
 541         handle = OpenThread(SYNCHRONIZE | THREAD_SUSPEND_RESUME |
 542                             THREAD_SET_CONTEXT, FALSE, thread->tid);
 543     } else {
 544         handle = NULL;
 545     }
 546     LeaveCriticalSection(&data->cs);
 547     return handle;
 548 }
 549
 550 bool qemu_thread_is_self(QemuThread *thread)
 551 {
 552     return GetCurrentThreadId() == thread->tid;
 553 }