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