util/qemu-thread-posix.c

   1 /*
   2  * Wrappers around mutex/cond/thread functions
   3  *
   4  * Copyright Red Hat, Inc. 2009
   5  *
   6  * Author:
   7  *  Marcelo Tosatti <mtosatti@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 #include "qemu/osdep.h"
  14 #include "qemu/thread.h"
  15 #include "qemu/atomic.h"
  16 #include "qemu/notify.h"
  17 #include "trace.h"
  18
  19 static bool name_threads;
  20
  21 void qemu_thread_naming(bool enable)
  22 {
  23     name_threads = enable;
  24
  25 #ifndef CONFIG_THREAD_SETNAME_BYTHREAD
  26     /* This is a debugging option, not fatal */
  27     if (enable) {
  28         fprintf(stderr, "qemu: thread naming not supported on this host\n");
  29     }
  30 #endif
  31 }
  32
  33 static void error_exit(int err, const char *msg)
  34 {
  35     fprintf(stderr, "qemu: %s: %s\n", msg, strerror(err));
  36     abort();
  37 }
  38
  39 void qemu_mutex_init(QemuMutex *mutex)
  40 {
  41     int err;
  42
  43     err = pthread_mutex_init(&mutex->lock, NULL);
  44     if (err)
  45         error_exit(err, __func__);
  46     mutex->initialized = true;
  47 }
  48
  49 void qemu_mutex_destroy(QemuMutex *mutex)
  50 {
  51     int err;
  52
  53     assert(mutex->initialized);
  54     mutex->initialized = false;
  55     err = pthread_mutex_destroy(&mutex->lock);
  56     if (err)
  57         error_exit(err, __func__);
  58 }
  59
  60 void qemu_mutex_lock_impl(QemuMutex *mutex, const char *file, const int line)
  61 {
  62     int err;
  63
  64     assert(mutex->initialized);
  65     trace_qemu_mutex_lock(mutex, file, line);
  66
  67     err = pthread_mutex_lock(&mutex->lock);
  68     if (err)
  69         error_exit(err, __func__);
  70
  71     trace_qemu_mutex_locked(mutex, file, line);
  72 }
  73
  74 int qemu_mutex_trylock_impl(QemuMutex *mutex, const char *file, const int line)
  75 {
  76     int err;
  77
  78     assert(mutex->initialized);
  79     err = pthread_mutex_trylock(&mutex->lock);
  80     if (err == 0) {
  81         trace_qemu_mutex_locked(mutex, file, line);
  82         return 0;
  83     }
  84     if (err != EBUSY) {
  85         error_exit(err, __func__);
  86     }
  87     return -EBUSY;
  88 }
  89
  90 void qemu_mutex_unlock_impl(QemuMutex *mutex, const char *file, const int line)
  91 {
  92     int err;
  93
  94     assert(mutex->initialized);
  95     err = pthread_mutex_unlock(&mutex->lock);
  96     if (err)
  97         error_exit(err, __func__);
  98
  99     trace_qemu_mutex_unlock(mutex, file, line);
 100 }
 101
 102 void qemu_rec_mutex_init(QemuRecMutex *mutex)
 103 {
 104     int err;
 105     pthread_mutexattr_t attr;
 106
 107     pthread_mutexattr_init(&attr);
 108     pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
 109     err = pthread_mutex_init(&mutex->lock, &attr);
 110     pthread_mutexattr_destroy(&attr);
 111     if (err) {
 112         error_exit(err, __func__);
 113     }
 114     mutex->initialized = true;
 115 }
 116
 117 void qemu_cond_init(QemuCond *cond)
 118 {
 119     int err;
 120
 121     err = pthread_cond_init(&cond->cond, NULL);
 122     if (err)
 123         error_exit(err, __func__);
 124     cond->initialized = true;
 125 }
 126
 127 void qemu_cond_destroy(QemuCond *cond)
 128 {
 129     int err;
 130
 131     assert(cond->initialized);
 132     cond->initialized = false;
 133     err = pthread_cond_destroy(&cond->cond);
 134     if (err)
 135         error_exit(err, __func__);
 136 }
 137
 138 void qemu_cond_signal(QemuCond *cond)
 139 {
 140     int err;
 141
 142     assert(cond->initialized);
 143     err = pthread_cond_signal(&cond->cond);
 144     if (err)
 145         error_exit(err, __func__);
 146 }
 147
 148 void qemu_cond_broadcast(QemuCond *cond)
 149 {
 150     int err;
 151
 152     assert(cond->initialized);
 153     err = pthread_cond_broadcast(&cond->cond);
 154     if (err)
 155         error_exit(err, __func__);
 156 }
 157
 158 void qemu_cond_wait_impl(QemuCond *cond, QemuMutex *mutex, const char *file, const int line)
 159 {
 160     int err;
 161
 162     assert(cond->initialized);
 163     trace_qemu_mutex_unlock(mutex, file, line);
 164     err = pthread_cond_wait(&cond->cond, &mutex->lock);
 165     trace_qemu_mutex_locked(mutex, file, line);
 166     if (err)
 167         error_exit(err, __func__);
 168 }
 169
 170 void qemu_sem_init(QemuSemaphore *sem, int init)
 171 {
 172     int rc;
 173
 174 #ifndef CONFIG_SEM_TIMEDWAIT
 175     rc = pthread_mutex_init(&sem->lock, NULL);
 176     if (rc != 0) {
 177         error_exit(rc, __func__);
 178     }
 179     rc = pthread_cond_init(&sem->cond, NULL);
 180     if (rc != 0) {
 181         error_exit(rc, __func__);
 182     }
 183     if (init < 0) {
 184         error_exit(EINVAL, __func__);
 185     }
 186     sem->count = init;
 187 #else
 188     rc = sem_init(&sem->sem, 0, init);
 189     if (rc < 0) {
 190         error_exit(errno, __func__);
 191     }
 192 #endif
 193     sem->initialized = true;
 194 }
 195
 196 void qemu_sem_destroy(QemuSemaphore *sem)
 197 {
 198     int rc;
 199
 200     assert(sem->initialized);
 201     sem->initialized = false;
 202 #ifndef CONFIG_SEM_TIMEDWAIT
 203     rc = pthread_cond_destroy(&sem->cond);
 204     if (rc < 0) {
 205         error_exit(rc, __func__);
 206     }
 207     rc = pthread_mutex_destroy(&sem->lock);
 208     if (rc < 0) {
 209         error_exit(rc, __func__);
 210     }
 211 #else
 212     rc = sem_destroy(&sem->sem);
 213     if (rc < 0) {
 214         error_exit(errno, __func__);
 215     }
 216 #endif
 217 }
 218
 219 void qemu_sem_post(QemuSemaphore *sem)
 220 {
 221     int rc;
 222
 223     assert(sem->initialized);
 224 #ifndef CONFIG_SEM_TIMEDWAIT
 225     pthread_mutex_lock(&sem->lock);
 226     if (sem->count == UINT_MAX) {
 227         rc = EINVAL;
 228     } else {
 229         sem->count++;
 230         rc = pthread_cond_signal(&sem->cond);
 231     }
 232     pthread_mutex_unlock(&sem->lock);
 233     if (rc != 0) {
 234         error_exit(rc, __func__);
 235     }
 236 #else
 237     rc = sem_post(&sem->sem);
 238     if (rc < 0) {
 239         error_exit(errno, __func__);
 240     }
 241 #endif
 242 }
 243
 244 static void compute_abs_deadline(struct timespec *ts, int ms)
 245 {
 246     struct timeval tv;
 247     gettimeofday(&tv, NULL);
 248     ts->tv_nsec = tv.tv_usec * 1000 + (ms % 1000) * 1000000;
 249     ts->tv_sec = tv.tv_sec + ms / 1000;
 250     if (ts->tv_nsec >= 1000000000) {
 251         ts->tv_sec++;
 252         ts->tv_nsec -= 1000000000;
 253     }
 254 }
 255
 256 int qemu_sem_timedwait(QemuSemaphore *sem, int ms)
 257 {
 258     int rc;
 259     struct timespec ts;
 260
 261     assert(sem->initialized);
 262 #ifndef CONFIG_SEM_TIMEDWAIT
 263     rc = 0;
 264     compute_abs_deadline(&ts, ms);
 265     pthread_mutex_lock(&sem->lock);
 266     while (sem->count == 0) {
 267         rc = pthread_cond_timedwait(&sem->cond, &sem->lock, &ts);
 268         if (rc == ETIMEDOUT) {
 269             break;
 270         }
 271         if (rc != 0) {
 272             error_exit(rc, __func__);
 273         }
 274     }
 275     if (rc != ETIMEDOUT) {
 276         --sem->count;
 277     }
 278     pthread_mutex_unlock(&sem->lock);
 279     return (rc == ETIMEDOUT ? -1 : 0);
 280 #else
 281     if (ms <= 0) {
 282         /* This is cheaper than sem_timedwait.  */
 283         do {
 284             rc = sem_trywait(&sem->sem);
 285         } while (rc == -1 && errno == EINTR);
 286         if (rc == -1 && errno == EAGAIN) {
 287             return -1;
 288         }
 289     } else {
 290         compute_abs_deadline(&ts, ms);
 291         do {
 292             rc = sem_timedwait(&sem->sem, &ts);
 293         } while (rc == -1 && errno == EINTR);
 294         if (rc == -1 && errno == ETIMEDOUT) {
 295             return -1;
 296         }
 297     }
 298     if (rc < 0) {
 299         error_exit(errno, __func__);
 300     }
 301     return 0;
 302 #endif
 303 }
 304
 305 void qemu_sem_wait(QemuSemaphore *sem)
 306 {
 307     int rc;
 308
 309     assert(sem->initialized);
 310 #ifndef CONFIG_SEM_TIMEDWAIT
 311     pthread_mutex_lock(&sem->lock);
 312     while (sem->count == 0) {
 313         rc = pthread_cond_wait(&sem->cond, &sem->lock);
 314         if (rc != 0) {
 315             error_exit(rc, __func__);
 316         }
 317     }
 318     --sem->count;
 319     pthread_mutex_unlock(&sem->lock);
 320 #else
 321     do {
 322         rc = sem_wait(&sem->sem);
 323     } while (rc == -1 && errno == EINTR);
 324     if (rc < 0) {
 325         error_exit(errno, __func__);
 326     }
 327 #endif
 328 }
 329
 330 #ifdef __linux__
 331 #include "qemu/futex.h"
 332 #else
 333 static inline void qemu_futex_wake(QemuEvent *ev, int n)
 334 {
 335     assert(ev->initialized);
 336     pthread_mutex_lock(&ev->lock);
 337     if (n == 1) {
 338         pthread_cond_signal(&ev->cond);
 339     } else {
 340         pthread_cond_broadcast(&ev->cond);
 341     }
 342     pthread_mutex_unlock(&ev->lock);
 343 }
 344
 345 static inline void qemu_futex_wait(QemuEvent *ev, unsigned val)
 346 {
 347     assert(ev->initialized);
 348     pthread_mutex_lock(&ev->lock);
 349     if (ev->value == val) {
 350         pthread_cond_wait(&ev->cond, &ev->lock);
 351     }
 352     pthread_mutex_unlock(&ev->lock);
 353 }
 354 #endif
 355
 356 /* Valid transitions:
 357  * - free->set, when setting the event
 358  * - busy->set, when setting the event, followed by qemu_futex_wake
 359  * - set->free, when resetting the event
 360  * - free->busy, when waiting
 361  *
 362  * set->busy does not happen (it can be observed from the outside but
 363  * it really is set->free->busy).
 364  *
 365  * busy->free provably cannot happen; to enforce it, the set->free transition
 366  * is done with an OR, which becomes a no-op if the event has concurrently
 367  * transitioned to free or busy.
 368  */
 369
 370 #define EV_SET         0
 371 #define EV_FREE        1
 372 #define EV_BUSY       -1
 373
 374 void qemu_event_init(QemuEvent *ev, bool init)
 375 {
 376 #ifndef __linux__
 377     pthread_mutex_init(&ev->lock, NULL);
 378     pthread_cond_init(&ev->cond, NULL);
 379 #endif
 380
 381     ev->value = (init ? EV_SET : EV_FREE);
 382     ev->initialized = true;
 383 }
 384
 385 void qemu_event_destroy(QemuEvent *ev)
 386 {
 387     assert(ev->initialized);
 388     ev->initialized = false;
 389 #ifndef __linux__
 390     pthread_mutex_destroy(&ev->lock);
 391     pthread_cond_destroy(&ev->cond);
 392 #endif
 393 }
 394
 395 void qemu_event_set(QemuEvent *ev)
 396 {
 397     /* qemu_event_set has release semantics, but because it *loads*
 398      * ev->value we need a full memory barrier here.
 399      */
 400     assert(ev->initialized);
 401     smp_mb();
 402     if (atomic_read(&ev->value) != EV_SET) {
 403         if (atomic_xchg(&ev->value, EV_SET) == EV_BUSY) {
 404             /* There were waiters, wake them up.  */
 405             qemu_futex_wake(ev, INT_MAX);
 406         }
 407     }
 408 }
 409
 410 void qemu_event_reset(QemuEvent *ev)
 411 {
 412     unsigned value;
 413
 414     assert(ev->initialized);
 415     value = atomic_read(&ev->value);
 416     smp_mb_acquire();
 417     if (value == EV_SET) {
 418         /*
 419          * If there was a concurrent reset (or even reset+wait),
 420          * do nothing.  Otherwise change EV_SET->EV_FREE.
 421          */
 422         atomic_or(&ev->value, EV_FREE);
 423     }
 424 }
 425
 426 void qemu_event_wait(QemuEvent *ev)
 427 {
 428     unsigned value;
 429
 430     assert(ev->initialized);
 431     value = atomic_read(&ev->value);
 432     smp_mb_acquire();
 433     if (value != EV_SET) {
 434         if (value == EV_FREE) {
 435             /*
 436              * Leave the event reset and tell qemu_event_set that there
 437              * are waiters.  No need to retry, because there cannot be
 438              * a concurrent busy->free transition.  After the CAS, the
 439              * event will be either set or busy.
 440              */
 441             if (atomic_cmpxchg(&ev->value, EV_FREE, EV_BUSY) == EV_SET) {
 442                 return;
 443             }
 444         }
 445         qemu_futex_wait(ev, EV_BUSY);
 446     }
 447 }
 448
 449 static pthread_key_t exit_key;
 450
 451 union NotifierThreadData {
 452     void *ptr;
 453     NotifierList list;
 454 };
 455 QEMU_BUILD_BUG_ON(sizeof(union NotifierThreadData) != sizeof(void *));
 456
 457 void qemu_thread_atexit_add(Notifier *notifier)
 458 {
 459     union NotifierThreadData ntd;
 460     ntd.ptr = pthread_getspecific(exit_key);
 461     notifier_list_add(&ntd.list, notifier);
 462     pthread_setspecific(exit_key, ntd.ptr);
 463 }
 464
 465 void qemu_thread_atexit_remove(Notifier *notifier)
 466 {
 467     union NotifierThreadData ntd;
 468     ntd.ptr = pthread_getspecific(exit_key);
 469     notifier_remove(notifier);
 470     pthread_setspecific(exit_key, ntd.ptr);
 471 }
 472
 473 static void qemu_thread_atexit_run(void *arg)
 474 {
 475     union NotifierThreadData ntd = { .ptr = arg };
 476     notifier_list_notify(&ntd.list, NULL);
 477 }
 478
 479 static void __attribute__((constructor)) qemu_thread_atexit_init(void)
 480 {
 481     pthread_key_create(&exit_key, qemu_thread_atexit_run);
 482 }
 483
 484
 485 typedef struct {
 486     void *(*start_routine)(void *);
 487     void *arg;
 488     char *name;
 489 } QemuThreadArgs;
 490
 491 static void *qemu_thread_start(void *args)
 492 {
 493     QemuThreadArgs *qemu_thread_args = args;
 494     void *(*start_routine)(void *) = qemu_thread_args->start_routine;
 495     void *arg = qemu_thread_args->arg;
 496
 497 #ifdef CONFIG_PTHREAD_SETNAME_NP
 498     /* Attempt to set the threads name; note that this is for debug, so
 499      * we're not going to fail if we can't set it.
 500      */
 501     if (name_threads && qemu_thread_args->name) {
 502         pthread_setname_np(pthread_self(), qemu_thread_args->name);
 503     }
 504 #endif
 505     g_free(qemu_thread_args->name);
 506     g_free(qemu_thread_args);
 507     return start_routine(arg);
 508 }
 509
 510 void qemu_thread_create(QemuThread *thread, const char *name,
 511                        void *(*start_routine)(void*),
 512                        void *arg, int mode)
 513 {
 514     sigset_t set, oldset;
 515     int err;
 516     pthread_attr_t attr;
 517     QemuThreadArgs *qemu_thread_args;
 518
 519     err = pthread_attr_init(&attr);
 520     if (err) {
 521         error_exit(err, __func__);
 522     }
 523
 524     if (mode == QEMU_THREAD_DETACHED) {
 525         pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
 526     }
 527
 528     /* Leave signal handling to the iothread.  */
 529     sigfillset(&set);
 530     pthread_sigmask(SIG_SETMASK, &set, &oldset);
 531
 532     qemu_thread_args = g_new0(QemuThreadArgs, 1);
 533     qemu_thread_args->name = g_strdup(name);
 534     qemu_thread_args->start_routine = start_routine;
 535     qemu_thread_args->arg = arg;
 536
 537     err = pthread_create(&thread->thread, &attr,
 538                          qemu_thread_start, qemu_thread_args);
 539
 540     if (err)
 541         error_exit(err, __func__);
 542
 543     pthread_sigmask(SIG_SETMASK, &oldset, NULL);
 544
 545     pthread_attr_destroy(&attr);
 546 }
 547
 548 void qemu_thread_get_self(QemuThread *thread)
 549 {
 550     thread->thread = pthread_self();
 551 }
 552
 553 bool qemu_thread_is_self(QemuThread *thread)
 554 {
 555    return pthread_equal(pthread_self(), thread->thread);
 556 }
 557
 558 void qemu_thread_exit(void *retval)
 559 {
 560     pthread_exit(retval);
 561 }
 562
 563 void *qemu_thread_join(QemuThread *thread)
 564 {
 565     int err;
 566     void *ret;
 567
 568     err = pthread_join(thread->thread, &ret);
 569     if (err) {
 570         error_exit(err, __func__);
 571     }
 572     return ret;
 573 }