Statistics
| Branch: | Revision:

root / cpus.c @ de758970

History | View | Annotate | Download (24 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
static void dummy_signal(int sig)
227
{
228
}
229

    
230
/* If we have signalfd, we mask out the signals we want to handle and then
231
 * use signalfd to listen for them.  We rely on whatever the current signal
232
 * handler is to dispatch the signals when we receive them.
233
 */
234
static void sigfd_handler(void *opaque)
235
{
236
    int fd = (unsigned long) opaque;
237
    struct qemu_signalfd_siginfo info;
238
    struct sigaction action;
239
    ssize_t len;
240

    
241
    while (1) {
242
        do {
243
            len = read(fd, &info, sizeof(info));
244
        } while (len == -1 && errno == EINTR);
245

    
246
        if (len == -1 && errno == EAGAIN) {
247
            break;
248
        }
249

    
250
        if (len != sizeof(info)) {
251
            printf("read from sigfd returned %zd: %m\n", len);
252
            return;
253
        }
254

    
255
        sigaction(info.ssi_signo, NULL, &action);
256
        if ((action.sa_flags & SA_SIGINFO) && action.sa_sigaction) {
257
            action.sa_sigaction(info.ssi_signo,
258
                                (siginfo_t *)&info, NULL);
259
        } else if (action.sa_handler) {
260
            action.sa_handler(info.ssi_signo);
261
        }
262
    }
263
}
264

    
265
static int qemu_signalfd_init(sigset_t mask)
266
{
267
    int sigfd;
268

    
269
    sigfd = qemu_signalfd(&mask);
270
    if (sigfd == -1) {
271
        fprintf(stderr, "failed to create signalfd\n");
272
        return -errno;
273
    }
274

    
275
    fcntl_setfl(sigfd, O_NONBLOCK);
276

    
277
    qemu_set_fd_handler2(sigfd, NULL, sigfd_handler, NULL,
278
                         (void *)(unsigned long) sigfd);
279

    
280
    return 0;
281
}
282

    
283
static void sigbus_reraise(void);
284

    
285
static void qemu_kvm_eat_signals(CPUState *env)
286
{
287
    struct timespec ts = { 0, 0 };
288
    siginfo_t siginfo;
289
    sigset_t waitset;
290
    sigset_t chkset;
291
    int r;
292

    
293
    sigemptyset(&waitset);
294
    sigaddset(&waitset, SIG_IPI);
295
    sigaddset(&waitset, SIGBUS);
296

    
297
    do {
298
        r = sigtimedwait(&waitset, &siginfo, &ts);
299
        if (r == -1 && !(errno == EAGAIN || errno == EINTR)) {
300
            perror("sigtimedwait");
301
            exit(1);
302
        }
303

    
304
        switch (r) {
305
#ifdef CONFIG_IOTHREAD
306
        case SIGBUS:
307
            if (kvm_on_sigbus_vcpu(env, siginfo.si_code, siginfo.si_addr)) {
308
                sigbus_reraise();
309
            }
310
            break;
311
#endif
312
        default:
313
            break;
314
        }
315

    
316
        r = sigpending(&chkset);
317
        if (r == -1) {
318
            perror("sigpending");
319
            exit(1);
320
        }
321
    } while (sigismember(&chkset, SIG_IPI) || sigismember(&chkset, SIGBUS));
322

    
323
#ifndef CONFIG_IOTHREAD
324
    if (sigismember(&chkset, SIGIO) || sigismember(&chkset, SIGALRM)) {
325
        qemu_notify_event();
326
    }
327
#endif
328
}
329

    
330
#else /* _WIN32 */
331

    
332
HANDLE qemu_event_handle;
333

    
334
static void dummy_event_handler(void *opaque)
335
{
336
}
337

    
338
static int qemu_event_init(void)
339
{
340
    qemu_event_handle = CreateEvent(NULL, FALSE, FALSE, NULL);
341
    if (!qemu_event_handle) {
342
        fprintf(stderr, "Failed CreateEvent: %ld\n", GetLastError());
343
        return -1;
344
    }
345
    qemu_add_wait_object(qemu_event_handle, dummy_event_handler, NULL);
346
    return 0;
347
}
348

    
349
static void qemu_event_increment(void)
350
{
351
    if (!SetEvent(qemu_event_handle)) {
352
        fprintf(stderr, "qemu_event_increment: SetEvent failed: %ld\n",
353
                GetLastError());
354
        exit (1);
355
    }
356
}
357

    
358
static void qemu_kvm_eat_signals(CPUState *env)
359
{
360
}
361
#endif /* _WIN32 */
362

    
363
#ifndef CONFIG_IOTHREAD
364
static void qemu_kvm_init_cpu_signals(CPUState *env)
365
{
366
#ifndef _WIN32
367
    int r;
368
    sigset_t set;
369
    struct sigaction sigact;
370

    
371
    memset(&sigact, 0, sizeof(sigact));
372
    sigact.sa_handler = dummy_signal;
373
    sigaction(SIG_IPI, &sigact, NULL);
374

    
375
    sigemptyset(&set);
376
    sigaddset(&set, SIG_IPI);
377
    sigaddset(&set, SIGIO);
378
    sigaddset(&set, SIGALRM);
379
    pthread_sigmask(SIG_BLOCK, &set, NULL);
380

    
381
    pthread_sigmask(SIG_BLOCK, NULL, &set);
382
    sigdelset(&set, SIG_IPI);
383
    sigdelset(&set, SIGBUS);
384
    sigdelset(&set, SIGIO);
385
    sigdelset(&set, SIGALRM);
386
    r = kvm_set_signal_mask(env, &set);
387
    if (r) {
388
        fprintf(stderr, "kvm_set_signal_mask: %s\n", strerror(-r));
389
        exit(1);
390
    }
391
#endif
392
}
393

    
394
#ifndef _WIN32
395
static sigset_t block_synchronous_signals(void)
396
{
397
    sigset_t set;
398

    
399
    sigemptyset(&set);
400
    if (kvm_enabled()) {
401
        /*
402
         * We need to process timer signals synchronously to avoid a race
403
         * between exit_request check and KVM vcpu entry.
404
         */
405
        sigaddset(&set, SIGIO);
406
        sigaddset(&set, SIGALRM);
407
    }
408

    
409
    return set;
410
}
411
#endif
412

    
413
int qemu_init_main_loop(void)
414
{
415
#ifndef _WIN32
416
    sigset_t blocked_signals;
417
    int ret;
418

    
419
    blocked_signals = block_synchronous_signals();
420

    
421
    ret = qemu_signalfd_init(blocked_signals);
422
    if (ret) {
423
        return ret;
424
    }
425
#endif
426
    cpu_set_debug_excp_handler(cpu_debug_handler);
427

    
428
    return qemu_event_init();
429
}
430

    
431
void qemu_main_loop_start(void)
432
{
433
}
434

    
435
void qemu_init_vcpu(void *_env)
436
{
437
    CPUState *env = _env;
438
    int r;
439

    
440
    env->nr_cores = smp_cores;
441
    env->nr_threads = smp_threads;
442

    
443
    if (kvm_enabled()) {
444
        r = kvm_init_vcpu(env);
445
        if (r < 0) {
446
            fprintf(stderr, "kvm_init_vcpu failed: %s\n", strerror(-r));
447
            exit(1);
448
        }
449
        qemu_kvm_init_cpu_signals(env);
450
    }
451
}
452

    
453
int qemu_cpu_self(void *env)
454
{
455
    return 1;
456
}
457

    
458
void run_on_cpu(CPUState *env, void (*func)(void *data), void *data)
459
{
460
    func(data);
461
}
462

    
463
void resume_all_vcpus(void)
464
{
465
}
466

    
467
void pause_all_vcpus(void)
468
{
469
}
470

    
471
void qemu_cpu_kick(void *env)
472
{
473
    return;
474
}
475

    
476
void qemu_notify_event(void)
477
{
478
    CPUState *env = cpu_single_env;
479

    
480
    qemu_event_increment ();
481
    if (env) {
482
        cpu_exit(env);
483
    }
484
    if (next_cpu && env != next_cpu) {
485
        cpu_exit(next_cpu);
486
    }
487
    exit_request = 1;
488
}
489

    
490
void qemu_mutex_lock_iothread(void) {}
491
void qemu_mutex_unlock_iothread(void) {}
492

    
493
void cpu_stop_current(void)
494
{
495
}
496

    
497
void vm_stop(int reason)
498
{
499
    do_vm_stop(reason);
500
}
501

    
502
#else /* CONFIG_IOTHREAD */
503

    
504
#include "qemu-thread.h"
505

    
506
QemuMutex qemu_global_mutex;
507
static QemuMutex qemu_fair_mutex;
508

    
509
static QemuThread io_thread;
510

    
511
static QemuThread *tcg_cpu_thread;
512
static QemuCond *tcg_halt_cond;
513

    
514
static int qemu_system_ready;
515
/* cpu creation */
516
static QemuCond qemu_cpu_cond;
517
/* system init */
518
static QemuCond qemu_system_cond;
519
static QemuCond qemu_pause_cond;
520
static QemuCond qemu_work_cond;
521

    
522
static void cpu_signal(int sig)
523
{
524
    if (cpu_single_env) {
525
        cpu_exit(cpu_single_env);
526
    }
527
    exit_request = 1;
528
}
529

    
530
static void qemu_kvm_init_cpu_signals(CPUState *env)
531
{
532
    int r;
533
    sigset_t set;
534
    struct sigaction sigact;
535

    
536
    memset(&sigact, 0, sizeof(sigact));
537
    sigact.sa_handler = dummy_signal;
538
    sigaction(SIG_IPI, &sigact, NULL);
539

    
540
    pthread_sigmask(SIG_BLOCK, NULL, &set);
541
    sigdelset(&set, SIG_IPI);
542
    sigdelset(&set, SIGBUS);
543
    r = kvm_set_signal_mask(env, &set);
544
    if (r) {
545
        fprintf(stderr, "kvm_set_signal_mask: %s\n", strerror(-r));
546
        exit(1);
547
    }
548
}
549

    
550
static void qemu_tcg_init_cpu_signals(void)
551
{
552
    sigset_t set;
553
    struct sigaction sigact;
554

    
555
    memset(&sigact, 0, sizeof(sigact));
556
    sigact.sa_handler = cpu_signal;
557
    sigaction(SIG_IPI, &sigact, NULL);
558

    
559
    sigemptyset(&set);
560
    sigaddset(&set, SIG_IPI);
561
    pthread_sigmask(SIG_UNBLOCK, &set, NULL);
562
}
563

    
564
static void sigbus_handler(int n, struct qemu_signalfd_siginfo *siginfo,
565
                           void *ctx);
566

    
567
static sigset_t block_io_signals(void)
568
{
569
    sigset_t set;
570
    struct sigaction action;
571

    
572
    /* SIGUSR2 used by posix-aio-compat.c */
573
    sigemptyset(&set);
574
    sigaddset(&set, SIGUSR2);
575
    pthread_sigmask(SIG_UNBLOCK, &set, NULL);
576

    
577
    sigemptyset(&set);
578
    sigaddset(&set, SIGIO);
579
    sigaddset(&set, SIGALRM);
580
    sigaddset(&set, SIG_IPI);
581
    sigaddset(&set, SIGBUS);
582
    pthread_sigmask(SIG_BLOCK, &set, NULL);
583

    
584
    memset(&action, 0, sizeof(action));
585
    action.sa_flags = SA_SIGINFO;
586
    action.sa_sigaction = (void (*)(int, siginfo_t*, void*))sigbus_handler;
587
    sigaction(SIGBUS, &action, NULL);
588
    prctl(PR_MCE_KILL, 1, 1, 0, 0);
589

    
590
    return set;
591
}
592

    
593
int qemu_init_main_loop(void)
594
{
595
    int ret;
596
    sigset_t blocked_signals;
597

    
598
    cpu_set_debug_excp_handler(cpu_debug_handler);
599

    
600
    blocked_signals = block_io_signals();
601

    
602
    ret = qemu_signalfd_init(blocked_signals);
603
    if (ret)
604
        return ret;
605

    
606
    /* Note eventfd must be drained before signalfd handlers run */
607
    ret = qemu_event_init();
608
    if (ret)
609
        return ret;
610

    
611
    qemu_cond_init(&qemu_pause_cond);
612
    qemu_cond_init(&qemu_system_cond);
613
    qemu_mutex_init(&qemu_fair_mutex);
614
    qemu_mutex_init(&qemu_global_mutex);
615
    qemu_mutex_lock(&qemu_global_mutex);
616

    
617
    qemu_thread_self(&io_thread);
618

    
619
    return 0;
620
}
621

    
622
void qemu_main_loop_start(void)
623
{
624
    qemu_system_ready = 1;
625
    qemu_cond_broadcast(&qemu_system_cond);
626
}
627

    
628
void run_on_cpu(CPUState *env, void (*func)(void *data), void *data)
629
{
630
    struct qemu_work_item wi;
631

    
632
    if (qemu_cpu_self(env)) {
633
        func(data);
634
        return;
635
    }
636

    
637
    wi.func = func;
638
    wi.data = data;
639
    if (!env->queued_work_first)
640
        env->queued_work_first = &wi;
641
    else
642
        env->queued_work_last->next = &wi;
643
    env->queued_work_last = &wi;
644
    wi.next = NULL;
645
    wi.done = false;
646

    
647
    qemu_cpu_kick(env);
648
    while (!wi.done) {
649
        CPUState *self_env = cpu_single_env;
650

    
651
        qemu_cond_wait(&qemu_work_cond, &qemu_global_mutex);
652
        cpu_single_env = self_env;
653
    }
654
}
655

    
656
static void flush_queued_work(CPUState *env)
657
{
658
    struct qemu_work_item *wi;
659

    
660
    if (!env->queued_work_first)
661
        return;
662

    
663
    while ((wi = env->queued_work_first)) {
664
        env->queued_work_first = wi->next;
665
        wi->func(wi->data);
666
        wi->done = true;
667
    }
668
    env->queued_work_last = NULL;
669
    qemu_cond_broadcast(&qemu_work_cond);
670
}
671

    
672
static void qemu_wait_io_event_common(CPUState *env)
673
{
674
    if (env->stop) {
675
        env->stop = 0;
676
        env->stopped = 1;
677
        qemu_cond_signal(&qemu_pause_cond);
678
    }
679
    flush_queued_work(env);
680
    env->thread_kicked = false;
681
}
682

    
683
static void qemu_tcg_wait_io_event(void)
684
{
685
    CPUState *env;
686

    
687
    while (!any_cpu_has_work())
688
        qemu_cond_timedwait(tcg_halt_cond, &qemu_global_mutex, 1000);
689

    
690
    qemu_mutex_unlock(&qemu_global_mutex);
691

    
692
    /*
693
     * Users of qemu_global_mutex can be starved, having no chance
694
     * to acquire it since this path will get to it first.
695
     * So use another lock to provide fairness.
696
     */
697
    qemu_mutex_lock(&qemu_fair_mutex);
698
    qemu_mutex_unlock(&qemu_fair_mutex);
699

    
700
    qemu_mutex_lock(&qemu_global_mutex);
701

    
702
    for (env = first_cpu; env != NULL; env = env->next_cpu) {
703
        qemu_wait_io_event_common(env);
704
    }
705
}
706

    
707
static void sigbus_reraise(void)
708
{
709
    sigset_t set;
710
    struct sigaction action;
711

    
712
    memset(&action, 0, sizeof(action));
713
    action.sa_handler = SIG_DFL;
714
    if (!sigaction(SIGBUS, &action, NULL)) {
715
        raise(SIGBUS);
716
        sigemptyset(&set);
717
        sigaddset(&set, SIGBUS);
718
        sigprocmask(SIG_UNBLOCK, &set, NULL);
719
    }
720
    perror("Failed to re-raise SIGBUS!\n");
721
    abort();
722
}
723

    
724
static void sigbus_handler(int n, struct qemu_signalfd_siginfo *siginfo,
725
                           void *ctx)
726
{
727
    if (kvm_on_sigbus(siginfo->ssi_code, (void *)(intptr_t)siginfo->ssi_addr)) {
728
        sigbus_reraise();
729
    }
730
}
731

    
732
static void qemu_kvm_wait_io_event(CPUState *env)
733
{
734
    while (!cpu_has_work(env))
735
        qemu_cond_timedwait(env->halt_cond, &qemu_global_mutex, 1000);
736

    
737
    qemu_kvm_eat_signals(env);
738
    qemu_wait_io_event_common(env);
739
}
740

    
741
static int qemu_cpu_exec(CPUState *env);
742

    
743
static void *kvm_cpu_thread_fn(void *arg)
744
{
745
    CPUState *env = arg;
746
    int r;
747

    
748
    qemu_mutex_lock(&qemu_global_mutex);
749
    qemu_thread_self(env->thread);
750

    
751
    r = kvm_init_vcpu(env);
752
    if (r < 0) {
753
        fprintf(stderr, "kvm_init_vcpu failed: %s\n", strerror(-r));
754
        exit(1);
755
    }
756

    
757
    qemu_kvm_init_cpu_signals(env);
758

    
759
    /* signal CPU creation */
760
    env->created = 1;
761
    qemu_cond_signal(&qemu_cpu_cond);
762

    
763
    /* and wait for machine initialization */
764
    while (!qemu_system_ready)
765
        qemu_cond_timedwait(&qemu_system_cond, &qemu_global_mutex, 100);
766

    
767
    while (1) {
768
        if (cpu_can_run(env))
769
            qemu_cpu_exec(env);
770
        qemu_kvm_wait_io_event(env);
771
    }
772

    
773
    return NULL;
774
}
775

    
776
static void *tcg_cpu_thread_fn(void *arg)
777
{
778
    CPUState *env = arg;
779

    
780
    qemu_tcg_init_cpu_signals();
781
    qemu_thread_self(env->thread);
782

    
783
    /* signal CPU creation */
784
    qemu_mutex_lock(&qemu_global_mutex);
785
    for (env = first_cpu; env != NULL; env = env->next_cpu)
786
        env->created = 1;
787
    qemu_cond_signal(&qemu_cpu_cond);
788

    
789
    /* and wait for machine initialization */
790
    while (!qemu_system_ready)
791
        qemu_cond_timedwait(&qemu_system_cond, &qemu_global_mutex, 100);
792

    
793
    while (1) {
794
        cpu_exec_all();
795
        qemu_tcg_wait_io_event();
796
    }
797

    
798
    return NULL;
799
}
800

    
801
void qemu_cpu_kick(void *_env)
802
{
803
    CPUState *env = _env;
804
    qemu_cond_broadcast(env->halt_cond);
805
    if (!env->thread_kicked) {
806
        qemu_thread_signal(env->thread, SIG_IPI);
807
        env->thread_kicked = true;
808
    }
809
}
810

    
811
int qemu_cpu_self(void *_env)
812
{
813
    CPUState *env = _env;
814
    QemuThread this;
815

    
816
    qemu_thread_self(&this);
817

    
818
    return qemu_thread_equal(&this, env->thread);
819
}
820

    
821
void qemu_mutex_lock_iothread(void)
822
{
823
    if (kvm_enabled()) {
824
        qemu_mutex_lock(&qemu_global_mutex);
825
    } else {
826
        qemu_mutex_lock(&qemu_fair_mutex);
827
        if (qemu_mutex_trylock(&qemu_global_mutex)) {
828
            qemu_thread_signal(tcg_cpu_thread, SIG_IPI);
829
            qemu_mutex_lock(&qemu_global_mutex);
830
        }
831
        qemu_mutex_unlock(&qemu_fair_mutex);
832
    }
833
}
834

    
835
void qemu_mutex_unlock_iothread(void)
836
{
837
    qemu_mutex_unlock(&qemu_global_mutex);
838
}
839

    
840
static int all_vcpus_paused(void)
841
{
842
    CPUState *penv = first_cpu;
843

    
844
    while (penv) {
845
        if (!penv->stopped)
846
            return 0;
847
        penv = (CPUState *)penv->next_cpu;
848
    }
849

    
850
    return 1;
851
}
852

    
853
void pause_all_vcpus(void)
854
{
855
    CPUState *penv = first_cpu;
856

    
857
    while (penv) {
858
        penv->stop = 1;
859
        qemu_cpu_kick(penv);
860
        penv = (CPUState *)penv->next_cpu;
861
    }
862

    
863
    while (!all_vcpus_paused()) {
864
        qemu_cond_timedwait(&qemu_pause_cond, &qemu_global_mutex, 100);
865
        penv = first_cpu;
866
        while (penv) {
867
            qemu_cpu_kick(penv);
868
            penv = (CPUState *)penv->next_cpu;
869
        }
870
    }
871
}
872

    
873
void resume_all_vcpus(void)
874
{
875
    CPUState *penv = first_cpu;
876

    
877
    while (penv) {
878
        penv->stop = 0;
879
        penv->stopped = 0;
880
        qemu_cpu_kick(penv);
881
        penv = (CPUState *)penv->next_cpu;
882
    }
883
}
884

    
885
static void tcg_init_vcpu(void *_env)
886
{
887
    CPUState *env = _env;
888
    /* share a single thread for all cpus with TCG */
889
    if (!tcg_cpu_thread) {
890
        env->thread = qemu_mallocz(sizeof(QemuThread));
891
        env->halt_cond = qemu_mallocz(sizeof(QemuCond));
892
        qemu_cond_init(env->halt_cond);
893
        qemu_thread_create(env->thread, tcg_cpu_thread_fn, env);
894
        while (env->created == 0)
895
            qemu_cond_timedwait(&qemu_cpu_cond, &qemu_global_mutex, 100);
896
        tcg_cpu_thread = env->thread;
897
        tcg_halt_cond = env->halt_cond;
898
    } else {
899
        env->thread = tcg_cpu_thread;
900
        env->halt_cond = tcg_halt_cond;
901
    }
902
}
903

    
904
static void kvm_start_vcpu(CPUState *env)
905
{
906
    env->thread = qemu_mallocz(sizeof(QemuThread));
907
    env->halt_cond = qemu_mallocz(sizeof(QemuCond));
908
    qemu_cond_init(env->halt_cond);
909
    qemu_thread_create(env->thread, kvm_cpu_thread_fn, env);
910
    while (env->created == 0)
911
        qemu_cond_timedwait(&qemu_cpu_cond, &qemu_global_mutex, 100);
912
}
913

    
914
void qemu_init_vcpu(void *_env)
915
{
916
    CPUState *env = _env;
917

    
918
    env->nr_cores = smp_cores;
919
    env->nr_threads = smp_threads;
920
    if (kvm_enabled())
921
        kvm_start_vcpu(env);
922
    else
923
        tcg_init_vcpu(env);
924
}
925

    
926
void qemu_notify_event(void)
927
{
928
    qemu_event_increment();
929
}
930

    
931
static void qemu_system_vmstop_request(int reason)
932
{
933
    vmstop_requested = reason;
934
    qemu_notify_event();
935
}
936

    
937
void cpu_stop_current(void)
938
{
939
    if (cpu_single_env) {
940
        cpu_single_env->stopped = 1;
941
        cpu_exit(cpu_single_env);
942
    }
943
}
944

    
945
void vm_stop(int reason)
946
{
947
    QemuThread me;
948
    qemu_thread_self(&me);
949

    
950
    if (!qemu_thread_equal(&me, &io_thread)) {
951
        qemu_system_vmstop_request(reason);
952
        /*
953
         * FIXME: should not return to device code in case
954
         * vm_stop() has been requested.
955
         */
956
        cpu_stop_current();
957
        return;
958
    }
959
    do_vm_stop(reason);
960
}
961

    
962
#endif
963

    
964
static int qemu_cpu_exec(CPUState *env)
965
{
966
    int ret;
967
#ifdef CONFIG_PROFILER
968
    int64_t ti;
969
#endif
970

    
971
#ifdef CONFIG_PROFILER
972
    ti = profile_getclock();
973
#endif
974
    if (use_icount) {
975
        int64_t count;
976
        int decr;
977
        qemu_icount -= (env->icount_decr.u16.low + env->icount_extra);
978
        env->icount_decr.u16.low = 0;
979
        env->icount_extra = 0;
980
        count = qemu_icount_round (qemu_next_deadline());
981
        qemu_icount += count;
982
        decr = (count > 0xffff) ? 0xffff : count;
983
        count -= decr;
984
        env->icount_decr.u16.low = decr;
985
        env->icount_extra = count;
986
    }
987
    ret = cpu_exec(env);
988
#ifdef CONFIG_PROFILER
989
    qemu_time += profile_getclock() - ti;
990
#endif
991
    if (use_icount) {
992
        /* Fold pending instructions back into the
993
           instruction counter, and clear the interrupt flag.  */
994
        qemu_icount -= (env->icount_decr.u16.low
995
                        + env->icount_extra);
996
        env->icount_decr.u32 = 0;
997
        env->icount_extra = 0;
998
    }
999
    return ret;
1000
}
1001

    
1002
bool cpu_exec_all(void)
1003
{
1004
    int r;
1005

    
1006
    if (next_cpu == NULL)
1007
        next_cpu = first_cpu;
1008
    for (; next_cpu != NULL && !exit_request; next_cpu = next_cpu->next_cpu) {
1009
        CPUState *env = next_cpu;
1010

    
1011
        qemu_clock_enable(vm_clock,
1012
                          (env->singlestep_enabled & SSTEP_NOTIMER) == 0);
1013

    
1014
        if (qemu_alarm_pending())
1015
            break;
1016
        if (cpu_can_run(env)) {
1017
            r = qemu_cpu_exec(env);
1018
            if (kvm_enabled()) {
1019
                qemu_kvm_eat_signals(env);
1020
            }
1021
            if (r == EXCP_DEBUG) {
1022
                break;
1023
            }
1024
        } else if (env->stop) {
1025
            break;
1026
        }
1027
    }
1028
    exit_request = 0;
1029
    return any_cpu_has_work();
1030
}
1031

    
1032
void set_numa_modes(void)
1033
{
1034
    CPUState *env;
1035
    int i;
1036

    
1037
    for (env = first_cpu; env != NULL; env = env->next_cpu) {
1038
        for (i = 0; i < nb_numa_nodes; i++) {
1039
            if (node_cpumask[i] & (1 << env->cpu_index)) {
1040
                env->numa_node = i;
1041
            }
1042
        }
1043
    }
1044
}
1045

    
1046
void set_cpu_log(const char *optarg)
1047
{
1048
    int mask;
1049
    const CPULogItem *item;
1050

    
1051
    mask = cpu_str_to_log_mask(optarg);
1052
    if (!mask) {
1053
        printf("Log items (comma separated):\n");
1054
        for (item = cpu_log_items; item->mask != 0; item++) {
1055
            printf("%-10s %s\n", item->name, item->help);
1056
        }
1057
        exit(1);
1058
    }
1059
    cpu_set_log(mask);
1060
}
1061

    
1062
/* Return the virtual CPU time, based on the instruction counter.  */
1063
int64_t cpu_get_icount(void)
1064
{
1065
    int64_t icount;
1066
    CPUState *env = cpu_single_env;;
1067

    
1068
    icount = qemu_icount;
1069
    if (env) {
1070
        if (!can_do_io(env)) {
1071
            fprintf(stderr, "Bad clock read\n");
1072
        }
1073
        icount -= (env->icount_decr.u16.low + env->icount_extra);
1074
    }
1075
    return qemu_icount_bias + (icount << icount_time_shift);
1076
}
1077

    
1078
void list_cpus(FILE *f, fprintf_function cpu_fprintf, const char *optarg)
1079
{
1080
    /* XXX: implement xxx_cpu_list for targets that still miss it */
1081
#if defined(cpu_list_id)
1082
    cpu_list_id(f, cpu_fprintf, optarg);
1083
#elif defined(cpu_list)
1084
    cpu_list(f, cpu_fprintf); /* deprecated */
1085
#endif
1086
}