qemu

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 "qemu-thread-common.h"
18
#include "qemu/tsan.h"
19
#include "qemu/bitmap.h"
20

21
#ifdef CONFIG_PTHREAD_SET_NAME_NP
22
#include <pthread_np.h>
23
#endif
24

25
static bool name_threads;
26

27
void qemu_thread_naming(bool enable)
28
{
29
    name_threads = enable;
30

31
#if !defined CONFIG_PTHREAD_SETNAME_NP_W_TID && \
32
    !defined CONFIG_PTHREAD_SETNAME_NP_WO_TID && \
33
    !defined CONFIG_PTHREAD_SET_NAME_NP
34
    /* This is a debugging option, not fatal */
35
    if (enable) {
36
        fprintf(stderr, "qemu: thread naming not supported on this host\n");
37
    }
38
#endif
39
}
40

41
static void error_exit(int err, const char *msg)
42
{
43
    fprintf(stderr, "qemu: %s: %s\n", msg, strerror(err));
44
    abort();
45
}
46

47
static inline clockid_t qemu_timedwait_clockid(void)
48
{
49
#ifdef CONFIG_PTHREAD_CONDATTR_SETCLOCK
50
    return CLOCK_MONOTONIC;
51
#else
52
    return CLOCK_REALTIME;
53
#endif
54
}
55

56
static void compute_abs_deadline(struct timespec *ts, int ms)
57
{
58
    clock_gettime(qemu_timedwait_clockid(), ts);
59
    ts->tv_nsec += (ms % 1000) * 1000000;
60
    ts->tv_sec += ms / 1000;
61
    if (ts->tv_nsec >= 1000000000) {
62
        ts->tv_sec++;
63
        ts->tv_nsec -= 1000000000;
64
    }
65
}
66

67
void qemu_mutex_init(QemuMutex *mutex)
68
{
69
    int err;
70

71
    err = pthread_mutex_init(&mutex->lock, NULL);
72
    if (err)
73
        error_exit(err, __func__);
74
    qemu_mutex_post_init(mutex);
75
}
76

77
void qemu_mutex_destroy(QemuMutex *mutex)
78
{
79
    int err;
80

81
    assert(mutex->initialized);
82
    mutex->initialized = false;
83
    err = pthread_mutex_destroy(&mutex->lock);
84
    if (err)
85
        error_exit(err, __func__);
86
}
87

88
void qemu_mutex_lock_impl(QemuMutex *mutex, const char *file, const int line)
89
{
90
    int err;
91

92
    assert(mutex->initialized);
93
    qemu_mutex_pre_lock(mutex, file, line);
94
    err = pthread_mutex_lock(&mutex->lock);
95
    if (err)
96
        error_exit(err, __func__);
97
    qemu_mutex_post_lock(mutex, file, line);
98
}
99

100
int qemu_mutex_trylock_impl(QemuMutex *mutex, const char *file, const int line)
101
{
102
    int err;
103

104
    assert(mutex->initialized);
105
    err = pthread_mutex_trylock(&mutex->lock);
106
    if (err == 0) {
107
        qemu_mutex_post_lock(mutex, file, line);
108
        return 0;
109
    }
110
    if (err != EBUSY) {
111
        error_exit(err, __func__);
112
    }
113
    return -EBUSY;
114
}
115

116
void qemu_mutex_unlock_impl(QemuMutex *mutex, const char *file, const int line)
117
{
118
    int err;
119

120
    assert(mutex->initialized);
121
    qemu_mutex_pre_unlock(mutex, file, line);
122
    err = pthread_mutex_unlock(&mutex->lock);
123
    if (err)
124
        error_exit(err, __func__);
125
}
126

127
void qemu_rec_mutex_init(QemuRecMutex *mutex)
128
{
129
    int err;
130
    pthread_mutexattr_t attr;
131

132
    pthread_mutexattr_init(&attr);
133
    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
134
    err = pthread_mutex_init(&mutex->m.lock, &attr);
135
    pthread_mutexattr_destroy(&attr);
136
    if (err) {
137
        error_exit(err, __func__);
138
    }
139
    mutex->m.initialized = true;
140
}
141

142
void qemu_rec_mutex_destroy(QemuRecMutex *mutex)
143
{
144
    qemu_mutex_destroy(&mutex->m);
145
}
146

147
void qemu_rec_mutex_lock_impl(QemuRecMutex *mutex, const char *file, int line)
148
{
149
    qemu_mutex_lock_impl(&mutex->m, file, line);
150
}
151

152
int qemu_rec_mutex_trylock_impl(QemuRecMutex *mutex, const char *file, int line)
153
{
154
    return qemu_mutex_trylock_impl(&mutex->m, file, line);
155
}
156

157
void qemu_rec_mutex_unlock_impl(QemuRecMutex *mutex, const char *file, int line)
158
{
159
    qemu_mutex_unlock_impl(&mutex->m, file, line);
160
}
161

162
void qemu_cond_init(QemuCond *cond)
163
{
164
    pthread_condattr_t attr;
165
    int err;
166

167
    err = pthread_condattr_init(&attr);
168
    if (err) {
169
        error_exit(err, __func__);
170
    }
171
#ifdef CONFIG_PTHREAD_CONDATTR_SETCLOCK
172
    err = pthread_condattr_setclock(&attr, qemu_timedwait_clockid());
173
    if (err) {
174
        error_exit(err, __func__);
175
    }
176
#endif
177
    err = pthread_cond_init(&cond->cond, &attr);
178
    if (err) {
179
        error_exit(err, __func__);
180
    }
181
    err = pthread_condattr_destroy(&attr);
182
    if (err) {
183
        error_exit(err, __func__);
184
    }
185
    cond->initialized = true;
186
}
187

188
void qemu_cond_destroy(QemuCond *cond)
189
{
190
    int err;
191

192
    assert(cond->initialized);
193
    cond->initialized = false;
194
    err = pthread_cond_destroy(&cond->cond);
195
    if (err)
196
        error_exit(err, __func__);
197
}
198

199
void qemu_cond_signal(QemuCond *cond)
200
{
201
    int err;
202

203
    assert(cond->initialized);
204
    err = pthread_cond_signal(&cond->cond);
205
    if (err)
206
        error_exit(err, __func__);
207
}
208

209
void qemu_cond_broadcast(QemuCond *cond)
210
{
211
    int err;
212

213
    assert(cond->initialized);
214
    err = pthread_cond_broadcast(&cond->cond);
215
    if (err)
216
        error_exit(err, __func__);
217
}
218

219
void qemu_cond_wait_impl(QemuCond *cond, QemuMutex *mutex, const char *file, const int line)
220
{
221
    int err;
222

223
    assert(cond->initialized);
224
    qemu_mutex_pre_unlock(mutex, file, line);
225
    err = pthread_cond_wait(&cond->cond, &mutex->lock);
226
    qemu_mutex_post_lock(mutex, file, line);
227
    if (err)
228
        error_exit(err, __func__);
229
}
230

231
static bool TSA_NO_TSA
232
qemu_cond_timedwait_ts(QemuCond *cond, QemuMutex *mutex, struct timespec *ts,
233
                       const char *file, const int line)
234
{
235
    int err;
236

237
    assert(cond->initialized);
238
    trace_qemu_mutex_unlock(mutex, file, line);
239
    err = pthread_cond_timedwait(&cond->cond, &mutex->lock, ts);
240
    trace_qemu_mutex_locked(mutex, file, line);
241
    if (err && err != ETIMEDOUT) {
242
        error_exit(err, __func__);
243
    }
244
    return err != ETIMEDOUT;
245
}
246

247
bool qemu_cond_timedwait_impl(QemuCond *cond, QemuMutex *mutex, int ms,
248
                              const char *file, const int line)
249
{
250
    struct timespec ts;
251

252
    compute_abs_deadline(&ts, ms);
253
    return qemu_cond_timedwait_ts(cond, mutex, &ts, file, line);
254
}
255

256
void qemu_sem_init(QemuSemaphore *sem, int init)
257
{
258
    qemu_mutex_init(&sem->mutex);
259
    qemu_cond_init(&sem->cond);
260

261
    if (init < 0) {
262
        error_exit(EINVAL, __func__);
263
    }
264
    sem->count = init;
265
}
266

267
void qemu_sem_destroy(QemuSemaphore *sem)
268
{
269
    qemu_cond_destroy(&sem->cond);
270
    qemu_mutex_destroy(&sem->mutex);
271
}
272

273
void qemu_sem_post(QemuSemaphore *sem)
274
{
275
    qemu_mutex_lock(&sem->mutex);
276
    if (sem->count == UINT_MAX) {
277
        error_exit(EINVAL, __func__);
278
    } else {
279
        sem->count++;
280
        qemu_cond_signal(&sem->cond);
281
    }
282
    qemu_mutex_unlock(&sem->mutex);
283
}
284

285
int qemu_sem_timedwait(QemuSemaphore *sem, int ms)
286
{
287
    bool rc = true;
288
    struct timespec ts;
289

290
    compute_abs_deadline(&ts, ms);
291
    qemu_mutex_lock(&sem->mutex);
292
    while (sem->count == 0) {
293
        if (ms == 0) {
294
            rc = false;
295
        } else {
296
            rc = qemu_cond_timedwait_ts(&sem->cond, &sem->mutex, &ts,
297
                                        __FILE__, __LINE__);
298
        }
299
        if (!rc) { /* timeout */
300
            break;
301
        }
302
    }
303
    if (rc) {
304
        --sem->count;
305
    }
306
    qemu_mutex_unlock(&sem->mutex);
307
    return (rc ? 0 : -1);
308
}
309

310
void qemu_sem_wait(QemuSemaphore *sem)
311
{
312
    qemu_mutex_lock(&sem->mutex);
313
    while (sem->count == 0) {
314
        qemu_cond_wait(&sem->cond, &sem->mutex);
315
    }
316
    --sem->count;
317
    qemu_mutex_unlock(&sem->mutex);
318
}
319

320
#ifdef __linux__
321
#include "qemu/futex.h"
322
#else
323
static inline void qemu_futex_wake(QemuEvent *ev, int n)
324
{
325
    assert(ev->initialized);
326
    pthread_mutex_lock(&ev->lock);
327
    if (n == 1) {
328
        pthread_cond_signal(&ev->cond);
329
    } else {
330
        pthread_cond_broadcast(&ev->cond);
331
    }
332
    pthread_mutex_unlock(&ev->lock);
333
}
334

335
static inline void qemu_futex_wait(QemuEvent *ev, unsigned val)
336
{
337
    assert(ev->initialized);
338
    pthread_mutex_lock(&ev->lock);
339
    if (ev->value == val) {
340
        pthread_cond_wait(&ev->cond, &ev->lock);
341
    }
342
    pthread_mutex_unlock(&ev->lock);
343
}
344
#endif
345

346
/* Valid transitions:
347
 * - free->set, when setting the event
348
 * - busy->set, when setting the event, followed by qemu_futex_wake
349
 * - set->free, when resetting the event
350
 * - free->busy, when waiting
351
 *
352
 * set->busy does not happen (it can be observed from the outside but
353
 * it really is set->free->busy).
354
 *
355
 * busy->free provably cannot happen; to enforce it, the set->free transition
356
 * is done with an OR, which becomes a no-op if the event has concurrently
357
 * transitioned to free or busy.
358
 */
359

360
#define EV_SET         0
361
#define EV_FREE        1
362
#define EV_BUSY       -1
363

364
void qemu_event_init(QemuEvent *ev, bool init)
365
{
366
#ifndef __linux__
367
    pthread_mutex_init(&ev->lock, NULL);
368
    pthread_cond_init(&ev->cond, NULL);
369
#endif
370

371
    ev->value = (init ? EV_SET : EV_FREE);
372
    ev->initialized = true;
373
}
374

375
void qemu_event_destroy(QemuEvent *ev)
376
{
377
    assert(ev->initialized);
378
    ev->initialized = false;
379
#ifndef __linux__
380
    pthread_mutex_destroy(&ev->lock);
381
    pthread_cond_destroy(&ev->cond);
382
#endif
383
}
384

385
void qemu_event_set(QemuEvent *ev)
386
{
387
    assert(ev->initialized);
388

389
    /*
390
     * Pairs with both qemu_event_reset() and qemu_event_wait().
391
     *
392
     * qemu_event_set has release semantics, but because it *loads*
393
     * ev->value we need a full memory barrier here.
394
     */
395
    smp_mb();
396
    if (qatomic_read(&ev->value) != EV_SET) {
397
        int old = qatomic_xchg(&ev->value, EV_SET);
398

399
        /* Pairs with memory barrier in kernel futex_wait system call.  */
400
        smp_mb__after_rmw();
401
        if (old == EV_BUSY) {
402
            /* There were waiters, wake them up.  */
403
            qemu_futex_wake(ev, INT_MAX);
404
        }
405
    }
406
}
407

408
void qemu_event_reset(QemuEvent *ev)
409
{
410
    assert(ev->initialized);
411

412
    /*
413
     * If there was a concurrent reset (or even reset+wait),
414
     * do nothing.  Otherwise change EV_SET->EV_FREE.
415
     */
416
    qatomic_or(&ev->value, EV_FREE);
417

418
    /*
419
     * Order reset before checking the condition in the caller.
420
     * Pairs with the first memory barrier in qemu_event_set().
421
     */
422
    smp_mb__after_rmw();
423
}
424

425
void qemu_event_wait(QemuEvent *ev)
426
{
427
    unsigned value;
428

429
    assert(ev->initialized);
430

431
    /*
432
     * qemu_event_wait must synchronize with qemu_event_set even if it does
433
     * not go down the slow path, so this load-acquire is needed that
434
     * synchronizes with the first memory barrier in qemu_event_set().
435
     *
436
     * If we do go down the slow path, there is no requirement at all: we
437
     * might miss a qemu_event_set() here but ultimately the memory barrier in
438
     * qemu_futex_wait() will ensure the check is done correctly.
439
     */
440
    value = qatomic_load_acquire(&ev->value);
441
    if (value != EV_SET) {
442
        if (value == EV_FREE) {
443
            /*
444
             * Leave the event reset and tell qemu_event_set that there are
445
             * waiters.  No need to retry, because there cannot be a concurrent
446
             * busy->free transition.  After the CAS, the event will be either
447
             * set or busy.
448
             *
449
             * This cmpxchg doesn't have particular ordering requirements if it
450
             * succeeds (moving the store earlier can only cause qemu_event_set()
451
             * to issue _more_ wakeups), the failing case needs acquire semantics
452
             * like the load above.
453
             */
454
            if (qatomic_cmpxchg(&ev->value, EV_FREE, EV_BUSY) == EV_SET) {
455
                return;
456
            }
457
        }
458

459
        /*
460
         * This is the final check for a concurrent set, so it does need
461
         * a smp_mb() pairing with the second barrier of qemu_event_set().
462
         * The barrier is inside the FUTEX_WAIT system call.
463
         */
464
        qemu_futex_wait(ev, EV_BUSY);
465
    }
466
}
467

468
static __thread NotifierList thread_exit;
469

470
/*
471
 * Note that in this implementation you can register a thread-exit
472
 * notifier for the main thread, but it will never be called.
473
 * This is OK because main thread exit can only happen when the
474
 * entire process is exiting, and the API allows notifiers to not
475
 * be called on process exit.
476
 */
477
void qemu_thread_atexit_add(Notifier *notifier)
478
{
479
    notifier_list_add(&thread_exit, notifier);
480
}
481

482
void qemu_thread_atexit_remove(Notifier *notifier)
483
{
484
    notifier_remove(notifier);
485
}
486

487
static void qemu_thread_atexit_notify(void *arg)
488
{
489
    /*
490
     * Called when non-main thread exits (via qemu_thread_exit()
491
     * or by returning from its start routine.)
492
     */
493
    notifier_list_notify(&thread_exit, NULL);
494
}
495

496
typedef struct {
497
    void *(*start_routine)(void *);
498
    void *arg;
499
    char *name;
500
} QemuThreadArgs;
501

502
static void *qemu_thread_start(void *args)
503
{
504
    QemuThreadArgs *qemu_thread_args = args;
505
    void *(*start_routine)(void *) = qemu_thread_args->start_routine;
506
    void *arg = qemu_thread_args->arg;
507
    void *r;
508

509
    /* Attempt to set the threads name; note that this is for debug, so
510
     * we're not going to fail if we can't set it.
511
     */
512
    if (name_threads && qemu_thread_args->name) {
513
# if defined(CONFIG_PTHREAD_SETNAME_NP_W_TID)
514
        pthread_setname_np(pthread_self(), qemu_thread_args->name);
515
# elif defined(CONFIG_PTHREAD_SETNAME_NP_WO_TID)
516
        pthread_setname_np(qemu_thread_args->name);
517
# elif defined(CONFIG_PTHREAD_SET_NAME_NP)
518
        pthread_set_name_np(pthread_self(), qemu_thread_args->name);
519
# endif
520
    }
521
    QEMU_TSAN_ANNOTATE_THREAD_NAME(qemu_thread_args->name);
522
    g_free(qemu_thread_args->name);
523
    g_free(qemu_thread_args);
524

525
    /*
526
     * GCC 11 with glibc 2.17 on PowerPC reports
527
     *
528
     * qemu-thread-posix.c:540:5: error: ‘__sigsetjmp’ accessing 656 bytes
529
     *   in a region of size 528 [-Werror=stringop-overflow=]
530
     * 540 |     pthread_cleanup_push(qemu_thread_atexit_notify, NULL);
531
     *     |     ^~~~~~~~~~~~~~~~~~~~
532
     *
533
     * which is clearly nonsense.
534
     */
535
#pragma GCC diagnostic push
536
#ifndef __clang__
537
#pragma GCC diagnostic ignored "-Wstringop-overflow"
538
#endif
539

540
    pthread_cleanup_push(qemu_thread_atexit_notify, NULL);
541
    r = start_routine(arg);
542
    pthread_cleanup_pop(1);
543

544
#pragma GCC diagnostic pop
545

546
    return r;
547
}
548

549
void qemu_thread_create(QemuThread *thread, const char *name,
550
                       void *(*start_routine)(void*),
551
                       void *arg, int mode)
552
{
553
    sigset_t set, oldset;
554
    int err;
555
    pthread_attr_t attr;
556
    QemuThreadArgs *qemu_thread_args;
557

558
    err = pthread_attr_init(&attr);
559
    if (err) {
560
        error_exit(err, __func__);
561
    }
562

563
    if (mode == QEMU_THREAD_DETACHED) {
564
        pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
565
    }
566

567
    /* Leave signal handling to the iothread.  */
568
    sigfillset(&set);
569
    /* Blocking the signals can result in undefined behaviour. */
570
    sigdelset(&set, SIGSEGV);
571
    sigdelset(&set, SIGFPE);
572
    sigdelset(&set, SIGILL);
573
    /* TODO avoid SIGBUS loss on macOS */
574
    pthread_sigmask(SIG_SETMASK, &set, &oldset);
575

576
    qemu_thread_args = g_new0(QemuThreadArgs, 1);
577
    qemu_thread_args->name = g_strdup(name);
578
    qemu_thread_args->start_routine = start_routine;
579
    qemu_thread_args->arg = arg;
580

581
    err = pthread_create(&thread->thread, &attr,
582
                         qemu_thread_start, qemu_thread_args);
583

584
    if (err)
585
        error_exit(err, __func__);
586

587
    pthread_sigmask(SIG_SETMASK, &oldset, NULL);
588

589
    pthread_attr_destroy(&attr);
590
}
591

592
int qemu_thread_set_affinity(QemuThread *thread, unsigned long *host_cpus,
593
                             unsigned long nbits)
594
{
595
#if defined(CONFIG_PTHREAD_AFFINITY_NP)
596
    const size_t setsize = CPU_ALLOC_SIZE(nbits);
597
    unsigned long value;
598
    cpu_set_t *cpuset;
599
    int err;
600

601
    cpuset = CPU_ALLOC(nbits);
602
    g_assert(cpuset);
603

604
    CPU_ZERO_S(setsize, cpuset);
605
    value = find_first_bit(host_cpus, nbits);
606
    while (value < nbits) {
607
        CPU_SET_S(value, setsize, cpuset);
608
        value = find_next_bit(host_cpus, nbits, value + 1);
609
    }
610

611
    err = pthread_setaffinity_np(thread->thread, setsize, cpuset);
612
    CPU_FREE(cpuset);
613
    return err;
614
#else
615
    return -ENOSYS;
616
#endif
617
}
618

619
int qemu_thread_get_affinity(QemuThread *thread, unsigned long **host_cpus,
620
                             unsigned long *nbits)
621
{
622
#if defined(CONFIG_PTHREAD_AFFINITY_NP)
623
    unsigned long tmpbits;
624
    cpu_set_t *cpuset;
625
    size_t setsize;
626
    int i, err;
627

628
    tmpbits = CPU_SETSIZE;
629
    while (true) {
630
        setsize = CPU_ALLOC_SIZE(tmpbits);
631
        cpuset = CPU_ALLOC(tmpbits);
632
        g_assert(cpuset);
633

634
        err = pthread_getaffinity_np(thread->thread, setsize, cpuset);
635
        if (err) {
636
            CPU_FREE(cpuset);
637
            if (err != -EINVAL) {
638
                return err;
639
            }
640
            tmpbits *= 2;
641
        } else {
642
            break;
643
        }
644
    }
645

646
    /* Convert the result into a proper bitmap. */
647
    *nbits = tmpbits;
648
    *host_cpus = bitmap_new(tmpbits);
649
    for (i = 0; i < tmpbits; i++) {
650
        if (CPU_ISSET(i, cpuset)) {
651
            set_bit(i, *host_cpus);
652
        }
653
    }
654
    CPU_FREE(cpuset);
655
    return 0;
656
#else
657
    return -ENOSYS;
658
#endif
659
}
660

661
void qemu_thread_get_self(QemuThread *thread)
662
{
663
    thread->thread = pthread_self();
664
}
665

666
bool qemu_thread_is_self(QemuThread *thread)
667
{
668
   return pthread_equal(pthread_self(), thread->thread);
669
}
670

671
void qemu_thread_exit(void *retval)
672
{
673
    pthread_exit(retval);
674
}
675

676
void *qemu_thread_join(QemuThread *thread)
677
{
678
    int err;
679
    void *ret;
680

681
    err = pthread_join(thread->thread, &ret);
682
    if (err) {
683
        error_exit(err, __func__);
684
    }
685
    return ret;
686
}
687