Statistics
| Branch: | Revision:

root / cpus.c @ 55f8d6ac

History | View | Annotate | Download (22.6 kB)

1
/*
2
 * QEMU System Emulator
3
 *
4
 * Copyright (c) 2003-2008 Fabrice Bellard
5
 *
6
 * Permission is hereby granted, free of charge, to any person obtaining a copy
7
 * of this software and associated documentation files (the "Software"), to deal
8
 * in the Software without restriction, including without limitation the rights
9
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10
 * copies of the Software, and to permit persons to whom the Software is
11
 * furnished to do so, subject to the following conditions:
12
 *
13
 * The above copyright notice and this permission notice shall be included in
14
 * all copies or substantial portions of the Software.
15
 *
16
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22
 * THE SOFTWARE.
23
 */
24

    
25
/* Needed early for CONFIG_BSD etc. */
26
#include "config-host.h"
27

    
28
#include "monitor.h"
29
#include "sysemu.h"
30
#include "gdbstub.h"
31
#include "dma.h"
32
#include "kvm.h"
33
#include "exec-all.h"
34

    
35
#include "cpus.h"
36
#include "compatfd.h"
37
#ifdef CONFIG_LINUX
38
#include <sys/prctl.h>
39
#endif
40

    
41
#ifdef SIGRTMIN
42
#define SIG_IPI (SIGRTMIN+4)
43
#else
44
#define SIG_IPI SIGUSR1
45
#endif
46

    
47
#ifndef PR_MCE_KILL
48
#define PR_MCE_KILL 33
49
#endif
50

    
51
static CPUState *next_cpu;
52

    
53
/***********************************************************/
54
void hw_error(const char *fmt, ...)
55
{
56
    va_list ap;
57
    CPUState *env;
58

    
59
    va_start(ap, fmt);
60
    fprintf(stderr, "qemu: hardware error: ");
61
    vfprintf(stderr, fmt, ap);
62
    fprintf(stderr, "\n");
63
    for(env = first_cpu; env != NULL; env = env->next_cpu) {
64
        fprintf(stderr, "CPU #%d:\n", env->cpu_index);
65
#ifdef TARGET_I386
66
        cpu_dump_state(env, stderr, fprintf, X86_DUMP_FPU);
67
#else
68
        cpu_dump_state(env, stderr, fprintf, 0);
69
#endif
70
    }
71
    va_end(ap);
72
    abort();
73
}
74

    
75
void cpu_synchronize_all_states(void)
76
{
77
    CPUState *cpu;
78

    
79
    for (cpu = first_cpu; cpu; cpu = cpu->next_cpu) {
80
        cpu_synchronize_state(cpu);
81
    }
82
}
83

    
84
void cpu_synchronize_all_post_reset(void)
85
{
86
    CPUState *cpu;
87

    
88
    for (cpu = first_cpu; cpu; cpu = cpu->next_cpu) {
89
        cpu_synchronize_post_reset(cpu);
90
    }
91
}
92

    
93
void cpu_synchronize_all_post_init(void)
94
{
95
    CPUState *cpu;
96

    
97
    for (cpu = first_cpu; cpu; cpu = cpu->next_cpu) {
98
        cpu_synchronize_post_init(cpu);
99
    }
100
}
101

    
102
int cpu_is_stopped(CPUState *env)
103
{
104
    return !vm_running || env->stopped;
105
}
106

    
107
static void do_vm_stop(int reason)
108
{
109
    if (vm_running) {
110
        cpu_disable_ticks();
111
        vm_running = 0;
112
        pause_all_vcpus();
113
        vm_state_notify(0, reason);
114
        qemu_aio_flush();
115
        bdrv_flush_all();
116
        monitor_protocol_event(QEVENT_STOP, NULL);
117
    }
118
}
119

    
120
static int cpu_can_run(CPUState *env)
121
{
122
    if (env->stop)
123
        return 0;
124
    if (env->stopped || !vm_running)
125
        return 0;
126
    return 1;
127
}
128

    
129
static int cpu_has_work(CPUState *env)
130
{
131
    if (env->stop)
132
        return 1;
133
    if (env->queued_work_first)
134
        return 1;
135
    if (env->stopped || !vm_running)
136
        return 0;
137
    if (!env->halted)
138
        return 1;
139
    if (qemu_cpu_has_work(env))
140
        return 1;
141
    return 0;
142
}
143

    
144
static int any_cpu_has_work(void)
145
{
146
    CPUState *env;
147

    
148
    for (env = first_cpu; env != NULL; env = env->next_cpu)
149
        if (cpu_has_work(env))
150
            return 1;
151
    return 0;
152
}
153

    
154
static void cpu_debug_handler(CPUState *env)
155
{
156
    gdb_set_stop_cpu(env);
157
    debug_requested = EXCP_DEBUG;
158
    vm_stop(EXCP_DEBUG);
159
}
160

    
161
#ifndef _WIN32
162
static int io_thread_fd = -1;
163

    
164
static void qemu_event_increment(void)
165
{
166
    /* Write 8 bytes to be compatible with eventfd.  */
167
    static const uint64_t val = 1;
168
    ssize_t ret;
169

    
170
    if (io_thread_fd == -1)
171
        return;
172

    
173
    do {
174
        ret = write(io_thread_fd, &val, sizeof(val));
175
    } while (ret < 0 && errno == EINTR);
176

    
177
    /* EAGAIN is fine, a read must be pending.  */
178
    if (ret < 0 && errno != EAGAIN) {
179
        fprintf(stderr, "qemu_event_increment: write() filed: %s\n",
180
                strerror(errno));
181
        exit (1);
182
    }
183
}
184

    
185
static void qemu_event_read(void *opaque)
186
{
187
    int fd = (unsigned long)opaque;
188
    ssize_t len;
189
    char buffer[512];
190

    
191
    /* Drain the notify pipe.  For eventfd, only 8 bytes will be read.  */
192
    do {
193
        len = read(fd, buffer, sizeof(buffer));
194
    } while ((len == -1 && errno == EINTR) || len == sizeof(buffer));
195
}
196

    
197
static int qemu_event_init(void)
198
{
199
    int err;
200
    int fds[2];
201

    
202
    err = qemu_eventfd(fds);
203
    if (err == -1)
204
        return -errno;
205

    
206
    err = fcntl_setfl(fds[0], O_NONBLOCK);
207
    if (err < 0)
208
        goto fail;
209

    
210
    err = fcntl_setfl(fds[1], O_NONBLOCK);
211
    if (err < 0)
212
        goto fail;
213

    
214
    qemu_set_fd_handler2(fds[0], NULL, qemu_event_read, NULL,
215
                         (void *)(unsigned long)fds[0]);
216

    
217
    io_thread_fd = fds[1];
218
    return 0;
219

    
220
fail:
221
    close(fds[0]);
222
    close(fds[1]);
223
    return err;
224
}
225

    
226
#ifdef CONFIG_IOTHREAD
227
static void dummy_signal(int sig)
228
{
229
}
230
#endif
231

    
232
#else /* _WIN32 */
233

    
234
HANDLE qemu_event_handle;
235

    
236
static void dummy_event_handler(void *opaque)
237
{
238
}
239

    
240
static int qemu_event_init(void)
241
{
242
    qemu_event_handle = CreateEvent(NULL, FALSE, FALSE, NULL);
243
    if (!qemu_event_handle) {
244
        fprintf(stderr, "Failed CreateEvent: %ld\n", GetLastError());
245
        return -1;
246
    }
247
    qemu_add_wait_object(qemu_event_handle, dummy_event_handler, NULL);
248
    return 0;
249
}
250

    
251
static void qemu_event_increment(void)
252
{
253
    if (!SetEvent(qemu_event_handle)) {
254
        fprintf(stderr, "qemu_event_increment: SetEvent failed: %ld\n",
255
                GetLastError());
256
        exit (1);
257
    }
258
}
259
#endif /* _WIN32 */
260

    
261
#ifndef CONFIG_IOTHREAD
262
int qemu_init_main_loop(void)
263
{
264
    cpu_set_debug_excp_handler(cpu_debug_handler);
265

    
266
    return qemu_event_init();
267
}
268

    
269
void qemu_main_loop_start(void)
270
{
271
}
272

    
273
void qemu_init_vcpu(void *_env)
274
{
275
    CPUState *env = _env;
276
    int r;
277

    
278
    env->nr_cores = smp_cores;
279
    env->nr_threads = smp_threads;
280

    
281
    if (kvm_enabled()) {
282
        r = kvm_init_vcpu(env);
283
        if (r < 0) {
284
            fprintf(stderr, "kvm_init_vcpu failed: %s\n", strerror(-r));
285
            exit(1);
286
        }
287
    }
288
}
289

    
290
int qemu_cpu_self(void *env)
291
{
292
    return 1;
293
}
294

    
295
void run_on_cpu(CPUState *env, void (*func)(void *data), void *data)
296
{
297
    func(data);
298
}
299

    
300
void resume_all_vcpus(void)
301
{
302
}
303

    
304
void pause_all_vcpus(void)
305
{
306
}
307

    
308
void qemu_cpu_kick(void *env)
309
{
310
    return;
311
}
312

    
313
void qemu_notify_event(void)
314
{
315
    CPUState *env = cpu_single_env;
316

    
317
    qemu_event_increment ();
318
    if (env) {
319
        cpu_exit(env);
320
    }
321
    if (next_cpu && env != next_cpu) {
322
        cpu_exit(next_cpu);
323
    }
324
    exit_request = 1;
325
}
326

    
327
void qemu_mutex_lock_iothread(void) {}
328
void qemu_mutex_unlock_iothread(void) {}
329

    
330
void cpu_stop_current(void)
331
{
332
}
333

    
334
void vm_stop(int reason)
335
{
336
    do_vm_stop(reason);
337
}
338

    
339
#else /* CONFIG_IOTHREAD */
340

    
341
#include "qemu-thread.h"
342

    
343
QemuMutex qemu_global_mutex;
344
static QemuMutex qemu_fair_mutex;
345

    
346
static QemuThread io_thread;
347

    
348
static QemuThread *tcg_cpu_thread;
349
static QemuCond *tcg_halt_cond;
350

    
351
static int qemu_system_ready;
352
/* cpu creation */
353
static QemuCond qemu_cpu_cond;
354
/* system init */
355
static QemuCond qemu_system_cond;
356
static QemuCond qemu_pause_cond;
357
static QemuCond qemu_work_cond;
358

    
359
/* If we have signalfd, we mask out the signals we want to handle and then
360
 * use signalfd to listen for them.  We rely on whatever the current signal
361
 * handler is to dispatch the signals when we receive them.
362
 */
363
static void sigfd_handler(void *opaque)
364
{
365
    int fd = (unsigned long) opaque;
366
    struct qemu_signalfd_siginfo info;
367
    struct sigaction action;
368
    ssize_t len;
369

    
370
    while (1) {
371
        do {
372
            len = read(fd, &info, sizeof(info));
373
        } while (len == -1 && errno == EINTR);
374

    
375
        if (len == -1 && errno == EAGAIN) {
376
            break;
377
        }
378

    
379
        if (len != sizeof(info)) {
380
            printf("read from sigfd returned %zd: %m\n", len);
381
            return;
382
        }
383

    
384
        sigaction(info.ssi_signo, NULL, &action);
385
        if ((action.sa_flags & SA_SIGINFO) && action.sa_sigaction) {
386
            action.sa_sigaction(info.ssi_signo,
387
                                (siginfo_t *)&info, NULL);
388
        } else if (action.sa_handler) {
389
            action.sa_handler(info.ssi_signo);
390
        }
391
    }
392
}
393

    
394
static void cpu_signal(int sig)
395
{
396
    if (cpu_single_env) {
397
        cpu_exit(cpu_single_env);
398
    }
399
    exit_request = 1;
400
}
401

    
402
static void qemu_kvm_init_cpu_signals(CPUState *env)
403
{
404
    int r;
405
    sigset_t set;
406
    struct sigaction sigact;
407

    
408
    memset(&sigact, 0, sizeof(sigact));
409
    sigact.sa_handler = dummy_signal;
410
    sigaction(SIG_IPI, &sigact, NULL);
411

    
412
    pthread_sigmask(SIG_BLOCK, NULL, &set);
413
    sigdelset(&set, SIG_IPI);
414
    sigdelset(&set, SIGBUS);
415
    r = kvm_set_signal_mask(env, &set);
416
    if (r) {
417
        fprintf(stderr, "kvm_set_signal_mask: %s\n", strerror(-r));
418
        exit(1);
419
    }
420
}
421

    
422
static void qemu_tcg_init_cpu_signals(void)
423
{
424
    sigset_t set;
425
    struct sigaction sigact;
426

    
427
    memset(&sigact, 0, sizeof(sigact));
428
    sigact.sa_handler = cpu_signal;
429
    sigaction(SIG_IPI, &sigact, NULL);
430

    
431
    sigemptyset(&set);
432
    sigaddset(&set, SIG_IPI);
433
    pthread_sigmask(SIG_UNBLOCK, &set, NULL);
434
}
435

    
436
static void sigbus_handler(int n, struct qemu_signalfd_siginfo *siginfo,
437
                           void *ctx);
438

    
439
static sigset_t block_io_signals(void)
440
{
441
    sigset_t set;
442
    struct sigaction action;
443

    
444
    /* SIGUSR2 used by posix-aio-compat.c */
445
    sigemptyset(&set);
446
    sigaddset(&set, SIGUSR2);
447
    pthread_sigmask(SIG_UNBLOCK, &set, NULL);
448

    
449
    sigemptyset(&set);
450
    sigaddset(&set, SIGIO);
451
    sigaddset(&set, SIGALRM);
452
    sigaddset(&set, SIG_IPI);
453
    sigaddset(&set, SIGBUS);
454
    pthread_sigmask(SIG_BLOCK, &set, NULL);
455

    
456
    memset(&action, 0, sizeof(action));
457
    action.sa_flags = SA_SIGINFO;
458
    action.sa_sigaction = (void (*)(int, siginfo_t*, void*))sigbus_handler;
459
    sigaction(SIGBUS, &action, NULL);
460
    prctl(PR_MCE_KILL, 1, 1, 0, 0);
461

    
462
    return set;
463
}
464

    
465
static int qemu_signalfd_init(sigset_t mask)
466
{
467
    int sigfd;
468

    
469
    sigfd = qemu_signalfd(&mask);
470
    if (sigfd == -1) {
471
        fprintf(stderr, "failed to create signalfd\n");
472
        return -errno;
473
    }
474

    
475
    fcntl_setfl(sigfd, O_NONBLOCK);
476

    
477
    qemu_set_fd_handler2(sigfd, NULL, sigfd_handler, NULL,
478
                         (void *)(unsigned long) sigfd);
479

    
480
    return 0;
481
}
482

    
483
int qemu_init_main_loop(void)
484
{
485
    int ret;
486
    sigset_t blocked_signals;
487

    
488
    cpu_set_debug_excp_handler(cpu_debug_handler);
489

    
490
    blocked_signals = block_io_signals();
491

    
492
    ret = qemu_signalfd_init(blocked_signals);
493
    if (ret)
494
        return ret;
495

    
496
    /* Note eventfd must be drained before signalfd handlers run */
497
    ret = qemu_event_init();
498
    if (ret)
499
        return ret;
500

    
501
    qemu_cond_init(&qemu_pause_cond);
502
    qemu_cond_init(&qemu_system_cond);
503
    qemu_mutex_init(&qemu_fair_mutex);
504
    qemu_mutex_init(&qemu_global_mutex);
505
    qemu_mutex_lock(&qemu_global_mutex);
506

    
507
    qemu_thread_self(&io_thread);
508

    
509
    return 0;
510
}
511

    
512
void qemu_main_loop_start(void)
513
{
514
    qemu_system_ready = 1;
515
    qemu_cond_broadcast(&qemu_system_cond);
516
}
517

    
518
void run_on_cpu(CPUState *env, void (*func)(void *data), void *data)
519
{
520
    struct qemu_work_item wi;
521

    
522
    if (qemu_cpu_self(env)) {
523
        func(data);
524
        return;
525
    }
526

    
527
    wi.func = func;
528
    wi.data = data;
529
    if (!env->queued_work_first)
530
        env->queued_work_first = &wi;
531
    else
532
        env->queued_work_last->next = &wi;
533
    env->queued_work_last = &wi;
534
    wi.next = NULL;
535
    wi.done = false;
536

    
537
    qemu_cpu_kick(env);
538
    while (!wi.done) {
539
        CPUState *self_env = cpu_single_env;
540

    
541
        qemu_cond_wait(&qemu_work_cond, &qemu_global_mutex);
542
        cpu_single_env = self_env;
543
    }
544
}
545

    
546
static void flush_queued_work(CPUState *env)
547
{
548
    struct qemu_work_item *wi;
549

    
550
    if (!env->queued_work_first)
551
        return;
552

    
553
    while ((wi = env->queued_work_first)) {
554
        env->queued_work_first = wi->next;
555
        wi->func(wi->data);
556
        wi->done = true;
557
    }
558
    env->queued_work_last = NULL;
559
    qemu_cond_broadcast(&qemu_work_cond);
560
}
561

    
562
static void qemu_wait_io_event_common(CPUState *env)
563
{
564
    if (env->stop) {
565
        env->stop = 0;
566
        env->stopped = 1;
567
        qemu_cond_signal(&qemu_pause_cond);
568
    }
569
    flush_queued_work(env);
570
    env->thread_kicked = false;
571
}
572

    
573
static void qemu_tcg_wait_io_event(void)
574
{
575
    CPUState *env;
576

    
577
    while (!any_cpu_has_work())
578
        qemu_cond_timedwait(tcg_halt_cond, &qemu_global_mutex, 1000);
579

    
580
    qemu_mutex_unlock(&qemu_global_mutex);
581

    
582
    /*
583
     * Users of qemu_global_mutex can be starved, having no chance
584
     * to acquire it since this path will get to it first.
585
     * So use another lock to provide fairness.
586
     */
587
    qemu_mutex_lock(&qemu_fair_mutex);
588
    qemu_mutex_unlock(&qemu_fair_mutex);
589

    
590
    qemu_mutex_lock(&qemu_global_mutex);
591

    
592
    for (env = first_cpu; env != NULL; env = env->next_cpu) {
593
        qemu_wait_io_event_common(env);
594
    }
595
}
596

    
597
static void sigbus_reraise(void)
598
{
599
    sigset_t set;
600
    struct sigaction action;
601

    
602
    memset(&action, 0, sizeof(action));
603
    action.sa_handler = SIG_DFL;
604
    if (!sigaction(SIGBUS, &action, NULL)) {
605
        raise(SIGBUS);
606
        sigemptyset(&set);
607
        sigaddset(&set, SIGBUS);
608
        sigprocmask(SIG_UNBLOCK, &set, NULL);
609
    }
610
    perror("Failed to re-raise SIGBUS!\n");
611
    abort();
612
}
613

    
614
static void sigbus_handler(int n, struct qemu_signalfd_siginfo *siginfo,
615
                           void *ctx)
616
{
617
    if (kvm_on_sigbus(siginfo->ssi_code, (void *)(intptr_t)siginfo->ssi_addr)) {
618
        sigbus_reraise();
619
    }
620
}
621

    
622
static void qemu_kvm_eat_signal(CPUState *env, int timeout)
623
{
624
    struct timespec ts;
625
    int r, e;
626
    siginfo_t siginfo;
627
    sigset_t waitset;
628
    sigset_t chkset;
629

    
630
    ts.tv_sec = timeout / 1000;
631
    ts.tv_nsec = (timeout % 1000) * 1000000;
632

    
633
    sigemptyset(&waitset);
634
    sigaddset(&waitset, SIG_IPI);
635
    sigaddset(&waitset, SIGBUS);
636

    
637
    do {
638
        qemu_mutex_unlock(&qemu_global_mutex);
639

    
640
        r = sigtimedwait(&waitset, &siginfo, &ts);
641
        e = errno;
642

    
643
        qemu_mutex_lock(&qemu_global_mutex);
644

    
645
        if (r == -1 && !(e == EAGAIN || e == EINTR)) {
646
            fprintf(stderr, "sigtimedwait: %s\n", strerror(e));
647
            exit(1);
648
        }
649

    
650
        switch (r) {
651
        case SIGBUS:
652
            if (kvm_on_sigbus_vcpu(env, siginfo.si_code, siginfo.si_addr)) {
653
                sigbus_reraise();
654
            }
655
            break;
656
        default:
657
            break;
658
        }
659

    
660
        r = sigpending(&chkset);
661
        if (r == -1) {
662
            fprintf(stderr, "sigpending: %s\n", strerror(e));
663
            exit(1);
664
        }
665
    } while (sigismember(&chkset, SIG_IPI) || sigismember(&chkset, SIGBUS));
666
}
667

    
668
static void qemu_kvm_wait_io_event(CPUState *env)
669
{
670
    while (!cpu_has_work(env))
671
        qemu_cond_timedwait(env->halt_cond, &qemu_global_mutex, 1000);
672

    
673
    qemu_kvm_eat_signal(env, 0);
674
    qemu_wait_io_event_common(env);
675
}
676

    
677
static int qemu_cpu_exec(CPUState *env);
678

    
679
static void *kvm_cpu_thread_fn(void *arg)
680
{
681
    CPUState *env = arg;
682
    int r;
683

    
684
    qemu_mutex_lock(&qemu_global_mutex);
685
    qemu_thread_self(env->thread);
686

    
687
    r = kvm_init_vcpu(env);
688
    if (r < 0) {
689
        fprintf(stderr, "kvm_init_vcpu failed: %s\n", strerror(-r));
690
        exit(1);
691
    }
692

    
693
    qemu_kvm_init_cpu_signals(env);
694

    
695
    /* signal CPU creation */
696
    env->created = 1;
697
    qemu_cond_signal(&qemu_cpu_cond);
698

    
699
    /* and wait for machine initialization */
700
    while (!qemu_system_ready)
701
        qemu_cond_timedwait(&qemu_system_cond, &qemu_global_mutex, 100);
702

    
703
    while (1) {
704
        if (cpu_can_run(env))
705
            qemu_cpu_exec(env);
706
        qemu_kvm_wait_io_event(env);
707
    }
708

    
709
    return NULL;
710
}
711

    
712
static void *tcg_cpu_thread_fn(void *arg)
713
{
714
    CPUState *env = arg;
715

    
716
    qemu_tcg_init_cpu_signals();
717
    qemu_thread_self(env->thread);
718

    
719
    /* signal CPU creation */
720
    qemu_mutex_lock(&qemu_global_mutex);
721
    for (env = first_cpu; env != NULL; env = env->next_cpu)
722
        env->created = 1;
723
    qemu_cond_signal(&qemu_cpu_cond);
724

    
725
    /* and wait for machine initialization */
726
    while (!qemu_system_ready)
727
        qemu_cond_timedwait(&qemu_system_cond, &qemu_global_mutex, 100);
728

    
729
    while (1) {
730
        cpu_exec_all();
731
        qemu_tcg_wait_io_event();
732
    }
733

    
734
    return NULL;
735
}
736

    
737
void qemu_cpu_kick(void *_env)
738
{
739
    CPUState *env = _env;
740
    qemu_cond_broadcast(env->halt_cond);
741
    if (!env->thread_kicked) {
742
        qemu_thread_signal(env->thread, SIG_IPI);
743
        env->thread_kicked = true;
744
    }
745
}
746

    
747
int qemu_cpu_self(void *_env)
748
{
749
    CPUState *env = _env;
750
    QemuThread this;
751

    
752
    qemu_thread_self(&this);
753

    
754
    return qemu_thread_equal(&this, env->thread);
755
}
756

    
757
void qemu_mutex_lock_iothread(void)
758
{
759
    if (kvm_enabled()) {
760
        qemu_mutex_lock(&qemu_global_mutex);
761
    } else {
762
        qemu_mutex_lock(&qemu_fair_mutex);
763
        if (qemu_mutex_trylock(&qemu_global_mutex)) {
764
            qemu_thread_signal(tcg_cpu_thread, SIG_IPI);
765
            qemu_mutex_lock(&qemu_global_mutex);
766
        }
767
        qemu_mutex_unlock(&qemu_fair_mutex);
768
    }
769
}
770

    
771
void qemu_mutex_unlock_iothread(void)
772
{
773
    qemu_mutex_unlock(&qemu_global_mutex);
774
}
775

    
776
static int all_vcpus_paused(void)
777
{
778
    CPUState *penv = first_cpu;
779

    
780
    while (penv) {
781
        if (!penv->stopped)
782
            return 0;
783
        penv = (CPUState *)penv->next_cpu;
784
    }
785

    
786
    return 1;
787
}
788

    
789
void pause_all_vcpus(void)
790
{
791
    CPUState *penv = first_cpu;
792

    
793
    while (penv) {
794
        penv->stop = 1;
795
        qemu_cpu_kick(penv);
796
        penv = (CPUState *)penv->next_cpu;
797
    }
798

    
799
    while (!all_vcpus_paused()) {
800
        qemu_cond_timedwait(&qemu_pause_cond, &qemu_global_mutex, 100);
801
        penv = first_cpu;
802
        while (penv) {
803
            qemu_cpu_kick(penv);
804
            penv = (CPUState *)penv->next_cpu;
805
        }
806
    }
807
}
808

    
809
void resume_all_vcpus(void)
810
{
811
    CPUState *penv = first_cpu;
812

    
813
    while (penv) {
814
        penv->stop = 0;
815
        penv->stopped = 0;
816
        qemu_cpu_kick(penv);
817
        penv = (CPUState *)penv->next_cpu;
818
    }
819
}
820

    
821
static void tcg_init_vcpu(void *_env)
822
{
823
    CPUState *env = _env;
824
    /* share a single thread for all cpus with TCG */
825
    if (!tcg_cpu_thread) {
826
        env->thread = qemu_mallocz(sizeof(QemuThread));
827
        env->halt_cond = qemu_mallocz(sizeof(QemuCond));
828
        qemu_cond_init(env->halt_cond);
829
        qemu_thread_create(env->thread, tcg_cpu_thread_fn, env);
830
        while (env->created == 0)
831
            qemu_cond_timedwait(&qemu_cpu_cond, &qemu_global_mutex, 100);
832
        tcg_cpu_thread = env->thread;
833
        tcg_halt_cond = env->halt_cond;
834
    } else {
835
        env->thread = tcg_cpu_thread;
836
        env->halt_cond = tcg_halt_cond;
837
    }
838
}
839

    
840
static void kvm_start_vcpu(CPUState *env)
841
{
842
    env->thread = qemu_mallocz(sizeof(QemuThread));
843
    env->halt_cond = qemu_mallocz(sizeof(QemuCond));
844
    qemu_cond_init(env->halt_cond);
845
    qemu_thread_create(env->thread, kvm_cpu_thread_fn, env);
846
    while (env->created == 0)
847
        qemu_cond_timedwait(&qemu_cpu_cond, &qemu_global_mutex, 100);
848
}
849

    
850
void qemu_init_vcpu(void *_env)
851
{
852
    CPUState *env = _env;
853

    
854
    env->nr_cores = smp_cores;
855
    env->nr_threads = smp_threads;
856
    if (kvm_enabled())
857
        kvm_start_vcpu(env);
858
    else
859
        tcg_init_vcpu(env);
860
}
861

    
862
void qemu_notify_event(void)
863
{
864
    qemu_event_increment();
865
}
866

    
867
static void qemu_system_vmstop_request(int reason)
868
{
869
    vmstop_requested = reason;
870
    qemu_notify_event();
871
}
872

    
873
void cpu_stop_current(void)
874
{
875
    if (cpu_single_env) {
876
        cpu_single_env->stopped = 1;
877
        cpu_exit(cpu_single_env);
878
    }
879
}
880

    
881
void vm_stop(int reason)
882
{
883
    QemuThread me;
884
    qemu_thread_self(&me);
885

    
886
    if (!qemu_thread_equal(&me, &io_thread)) {
887
        qemu_system_vmstop_request(reason);
888
        /*
889
         * FIXME: should not return to device code in case
890
         * vm_stop() has been requested.
891
         */
892
        cpu_stop_current();
893
        return;
894
    }
895
    do_vm_stop(reason);
896
}
897

    
898
#endif
899

    
900
static int qemu_cpu_exec(CPUState *env)
901
{
902
    int ret;
903
#ifdef CONFIG_PROFILER
904
    int64_t ti;
905
#endif
906

    
907
#ifdef CONFIG_PROFILER
908
    ti = profile_getclock();
909
#endif
910
    if (use_icount) {
911
        int64_t count;
912
        int decr;
913
        qemu_icount -= (env->icount_decr.u16.low + env->icount_extra);
914
        env->icount_decr.u16.low = 0;
915
        env->icount_extra = 0;
916
        count = qemu_icount_round (qemu_next_deadline());
917
        qemu_icount += count;
918
        decr = (count > 0xffff) ? 0xffff : count;
919
        count -= decr;
920
        env->icount_decr.u16.low = decr;
921
        env->icount_extra = count;
922
    }
923
    ret = cpu_exec(env);
924
#ifdef CONFIG_PROFILER
925
    qemu_time += profile_getclock() - ti;
926
#endif
927
    if (use_icount) {
928
        /* Fold pending instructions back into the
929
           instruction counter, and clear the interrupt flag.  */
930
        qemu_icount -= (env->icount_decr.u16.low
931
                        + env->icount_extra);
932
        env->icount_decr.u32 = 0;
933
        env->icount_extra = 0;
934
    }
935
    return ret;
936
}
937

    
938
bool cpu_exec_all(void)
939
{
940
    if (next_cpu == NULL)
941
        next_cpu = first_cpu;
942
    for (; next_cpu != NULL && !exit_request; next_cpu = next_cpu->next_cpu) {
943
        CPUState *env = next_cpu;
944

    
945
        qemu_clock_enable(vm_clock,
946
                          (env->singlestep_enabled & SSTEP_NOTIMER) == 0);
947

    
948
        if (qemu_alarm_pending())
949
            break;
950
        if (cpu_can_run(env)) {
951
            if (qemu_cpu_exec(env) == EXCP_DEBUG) {
952
                break;
953
            }
954
        } else if (env->stop) {
955
            break;
956
        }
957
    }
958
    exit_request = 0;
959
    return any_cpu_has_work();
960
}
961

    
962
void set_numa_modes(void)
963
{
964
    CPUState *env;
965
    int i;
966

    
967
    for (env = first_cpu; env != NULL; env = env->next_cpu) {
968
        for (i = 0; i < nb_numa_nodes; i++) {
969
            if (node_cpumask[i] & (1 << env->cpu_index)) {
970
                env->numa_node = i;
971
            }
972
        }
973
    }
974
}
975

    
976
void set_cpu_log(const char *optarg)
977
{
978
    int mask;
979
    const CPULogItem *item;
980

    
981
    mask = cpu_str_to_log_mask(optarg);
982
    if (!mask) {
983
        printf("Log items (comma separated):\n");
984
        for (item = cpu_log_items; item->mask != 0; item++) {
985
            printf("%-10s %s\n", item->name, item->help);
986
        }
987
        exit(1);
988
    }
989
    cpu_set_log(mask);
990
}
991

    
992
/* Return the virtual CPU time, based on the instruction counter.  */
993
int64_t cpu_get_icount(void)
994
{
995
    int64_t icount;
996
    CPUState *env = cpu_single_env;;
997

    
998
    icount = qemu_icount;
999
    if (env) {
1000
        if (!can_do_io(env)) {
1001
            fprintf(stderr, "Bad clock read\n");
1002
        }
1003
        icount -= (env->icount_decr.u16.low + env->icount_extra);
1004
    }
1005
    return qemu_icount_bias + (icount << icount_time_shift);
1006
}
1007

    
1008
void list_cpus(FILE *f, fprintf_function cpu_fprintf, const char *optarg)
1009
{
1010
    /* XXX: implement xxx_cpu_list for targets that still miss it */
1011
#if defined(cpu_list_id)
1012
    cpu_list_id(f, cpu_fprintf, optarg);
1013
#elif defined(cpu_list)
1014
    cpu_list(f, cpu_fprintf); /* deprecated */
1015
#endif
1016
}