import source from 0.14.1
[adaptation/panda/qemu-arm-static.git] / cpus.c
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 #else
226 HANDLE qemu_event_handle;
227
228 static void dummy_event_handler(void *opaque)
229 {
230 }
231
232 static int qemu_event_init(void)
233 {
234     qemu_event_handle = CreateEvent(NULL, FALSE, FALSE, NULL);
235     if (!qemu_event_handle) {
236         fprintf(stderr, "Failed CreateEvent: %ld\n", GetLastError());
237         return -1;
238     }
239     qemu_add_wait_object(qemu_event_handle, dummy_event_handler, NULL);
240     return 0;
241 }
242
243 static void qemu_event_increment(void)
244 {
245     if (!SetEvent(qemu_event_handle)) {
246         fprintf(stderr, "qemu_event_increment: SetEvent failed: %ld\n",
247                 GetLastError());
248         exit (1);
249     }
250 }
251 #endif
252
253 #ifndef CONFIG_IOTHREAD
254 int qemu_init_main_loop(void)
255 {
256     cpu_set_debug_excp_handler(cpu_debug_handler);
257
258     return qemu_event_init();
259 }
260
261 void qemu_main_loop_start(void)
262 {
263 }
264
265 void qemu_init_vcpu(void *_env)
266 {
267     CPUState *env = _env;
268
269     env->nr_cores = smp_cores;
270     env->nr_threads = smp_threads;
271     if (kvm_enabled())
272         kvm_init_vcpu(env);
273     return;
274 }
275
276 int qemu_cpu_self(void *env)
277 {
278     return 1;
279 }
280
281 void run_on_cpu(CPUState *env, void (*func)(void *data), void *data)
282 {
283     func(data);
284 }
285
286 void resume_all_vcpus(void)
287 {
288 }
289
290 void pause_all_vcpus(void)
291 {
292 }
293
294 void qemu_cpu_kick(void *env)
295 {
296     return;
297 }
298
299 void qemu_notify_event(void)
300 {
301     CPUState *env = cpu_single_env;
302
303     qemu_event_increment ();
304     if (env) {
305         cpu_exit(env);
306     }
307     if (next_cpu && env != next_cpu) {
308         cpu_exit(next_cpu);
309     }
310 }
311
312 void qemu_mutex_lock_iothread(void) {}
313 void qemu_mutex_unlock_iothread(void) {}
314
315 void vm_stop(int reason)
316 {
317     do_vm_stop(reason);
318 }
319
320 #else /* CONFIG_IOTHREAD */
321
322 #include "qemu-thread.h"
323
324 QemuMutex qemu_global_mutex;
325 static QemuMutex qemu_fair_mutex;
326
327 static QemuThread io_thread;
328
329 static QemuThread *tcg_cpu_thread;
330 static QemuCond *tcg_halt_cond;
331
332 static int qemu_system_ready;
333 /* cpu creation */
334 static QemuCond qemu_cpu_cond;
335 /* system init */
336 static QemuCond qemu_system_cond;
337 static QemuCond qemu_pause_cond;
338 static QemuCond qemu_work_cond;
339
340 static void tcg_init_ipi(void);
341 static void kvm_init_ipi(CPUState *env);
342 static sigset_t block_io_signals(void);
343
344 /* If we have signalfd, we mask out the signals we want to handle and then
345  * use signalfd to listen for them.  We rely on whatever the current signal
346  * handler is to dispatch the signals when we receive them.
347  */
348 static void sigfd_handler(void *opaque)
349 {
350     int fd = (unsigned long) opaque;
351     struct qemu_signalfd_siginfo info;
352     struct sigaction action;
353     ssize_t len;
354
355     while (1) {
356         do {
357             len = read(fd, &info, sizeof(info));
358         } while (len == -1 && errno == EINTR);
359
360         if (len == -1 && errno == EAGAIN) {
361             break;
362         }
363
364         if (len != sizeof(info)) {
365             printf("read from sigfd returned %zd: %m\n", len);
366             return;
367         }
368
369         sigaction(info.ssi_signo, NULL, &action);
370         if ((action.sa_flags & SA_SIGINFO) && action.sa_sigaction) {
371             action.sa_sigaction(info.ssi_signo,
372                                 (siginfo_t *)&info, NULL);
373         } else if (action.sa_handler) {
374             action.sa_handler(info.ssi_signo);
375         }
376     }
377 }
378
379 static int qemu_signalfd_init(sigset_t mask)
380 {
381     int sigfd;
382
383     sigfd = qemu_signalfd(&mask);
384     if (sigfd == -1) {
385         fprintf(stderr, "failed to create signalfd\n");
386         return -errno;
387     }
388
389     fcntl_setfl(sigfd, O_NONBLOCK);
390
391     qemu_set_fd_handler2(sigfd, NULL, sigfd_handler, NULL,
392                          (void *)(unsigned long) sigfd);
393
394     return 0;
395 }
396
397 int qemu_init_main_loop(void)
398 {
399     int ret;
400     sigset_t blocked_signals;
401
402     cpu_set_debug_excp_handler(cpu_debug_handler);
403
404     blocked_signals = block_io_signals();
405
406     ret = qemu_signalfd_init(blocked_signals);
407     if (ret)
408         return ret;
409
410     /* Note eventfd must be drained before signalfd handlers run */
411     ret = qemu_event_init();
412     if (ret)
413         return ret;
414
415     qemu_cond_init(&qemu_pause_cond);
416     qemu_cond_init(&qemu_system_cond);
417     qemu_mutex_init(&qemu_fair_mutex);
418     qemu_mutex_init(&qemu_global_mutex);
419     qemu_mutex_lock(&qemu_global_mutex);
420
421     qemu_thread_self(&io_thread);
422
423     return 0;
424 }
425
426 void qemu_main_loop_start(void)
427 {
428     qemu_system_ready = 1;
429     qemu_cond_broadcast(&qemu_system_cond);
430 }
431
432 void run_on_cpu(CPUState *env, void (*func)(void *data), void *data)
433 {
434     struct qemu_work_item wi;
435
436     if (qemu_cpu_self(env)) {
437         func(data);
438         return;
439     }
440
441     wi.func = func;
442     wi.data = data;
443     if (!env->queued_work_first)
444         env->queued_work_first = &wi;
445     else
446         env->queued_work_last->next = &wi;
447     env->queued_work_last = &wi;
448     wi.next = NULL;
449     wi.done = false;
450
451     qemu_cpu_kick(env);
452     while (!wi.done) {
453         CPUState *self_env = cpu_single_env;
454
455         qemu_cond_wait(&qemu_work_cond, &qemu_global_mutex);
456         cpu_single_env = self_env;
457     }
458 }
459
460 static void flush_queued_work(CPUState *env)
461 {
462     struct qemu_work_item *wi;
463
464     if (!env->queued_work_first)
465         return;
466
467     while ((wi = env->queued_work_first)) {
468         env->queued_work_first = wi->next;
469         wi->func(wi->data);
470         wi->done = true;
471     }
472     env->queued_work_last = NULL;
473     qemu_cond_broadcast(&qemu_work_cond);
474 }
475
476 static void qemu_wait_io_event_common(CPUState *env)
477 {
478     if (env->stop) {
479         env->stop = 0;
480         env->stopped = 1;
481         qemu_cond_signal(&qemu_pause_cond);
482     }
483     flush_queued_work(env);
484 }
485
486 static void qemu_tcg_wait_io_event(void)
487 {
488     CPUState *env;
489
490     while (!any_cpu_has_work())
491         qemu_cond_timedwait(tcg_halt_cond, &qemu_global_mutex, 1000);
492
493     qemu_mutex_unlock(&qemu_global_mutex);
494
495     /*
496      * Users of qemu_global_mutex can be starved, having no chance
497      * to acquire it since this path will get to it first.
498      * So use another lock to provide fairness.
499      */
500     qemu_mutex_lock(&qemu_fair_mutex);
501     qemu_mutex_unlock(&qemu_fair_mutex);
502
503     qemu_mutex_lock(&qemu_global_mutex);
504
505     for (env = first_cpu; env != NULL; env = env->next_cpu) {
506         qemu_wait_io_event_common(env);
507     }
508 }
509
510 static void sigbus_reraise(void)
511 {
512     sigset_t set;
513     struct sigaction action;
514
515     memset(&action, 0, sizeof(action));
516     action.sa_handler = SIG_DFL;
517     if (!sigaction(SIGBUS, &action, NULL)) {
518         raise(SIGBUS);
519         sigemptyset(&set);
520         sigaddset(&set, SIGBUS);
521         sigprocmask(SIG_UNBLOCK, &set, NULL);
522     }
523     perror("Failed to re-raise SIGBUS!\n");
524     abort();
525 }
526
527 static void sigbus_handler(int n, struct qemu_signalfd_siginfo *siginfo,
528                            void *ctx)
529 {
530 #if defined(TARGET_I386)
531     if (kvm_on_sigbus(siginfo->ssi_code, (void *)(intptr_t)siginfo->ssi_addr))
532 #endif
533         sigbus_reraise();
534 }
535
536 static void qemu_kvm_eat_signal(CPUState *env, int timeout)
537 {
538     struct timespec ts;
539     int r, e;
540     siginfo_t siginfo;
541     sigset_t waitset;
542     sigset_t chkset;
543
544     ts.tv_sec = timeout / 1000;
545     ts.tv_nsec = (timeout % 1000) * 1000000;
546
547     sigemptyset(&waitset);
548     sigaddset(&waitset, SIG_IPI);
549     sigaddset(&waitset, SIGBUS);
550
551     do {
552         qemu_mutex_unlock(&qemu_global_mutex);
553
554         r = sigtimedwait(&waitset, &siginfo, &ts);
555         e = errno;
556
557         qemu_mutex_lock(&qemu_global_mutex);
558
559         if (r == -1 && !(e == EAGAIN || e == EINTR)) {
560             fprintf(stderr, "sigtimedwait: %s\n", strerror(e));
561             exit(1);
562         }
563
564         switch (r) {
565         case SIGBUS:
566 #ifdef TARGET_I386
567             if (kvm_on_sigbus_vcpu(env, siginfo.si_code, siginfo.si_addr))
568 #endif
569                 sigbus_reraise();
570             break;
571         default:
572             break;
573         }
574
575         r = sigpending(&chkset);
576         if (r == -1) {
577             fprintf(stderr, "sigpending: %s\n", strerror(e));
578             exit(1);
579         }
580     } while (sigismember(&chkset, SIG_IPI) || sigismember(&chkset, SIGBUS));
581 }
582
583 static void qemu_kvm_wait_io_event(CPUState *env)
584 {
585     while (!cpu_has_work(env))
586         qemu_cond_timedwait(env->halt_cond, &qemu_global_mutex, 1000);
587
588     qemu_kvm_eat_signal(env, 0);
589     qemu_wait_io_event_common(env);
590 }
591
592 static int qemu_cpu_exec(CPUState *env);
593
594 static void *kvm_cpu_thread_fn(void *arg)
595 {
596     CPUState *env = arg;
597
598     qemu_mutex_lock(&qemu_global_mutex);
599     qemu_thread_self(env->thread);
600     if (kvm_enabled())
601         kvm_init_vcpu(env);
602
603     kvm_init_ipi(env);
604
605     /* signal CPU creation */
606     env->created = 1;
607     qemu_cond_signal(&qemu_cpu_cond);
608
609     /* and wait for machine initialization */
610     while (!qemu_system_ready)
611         qemu_cond_timedwait(&qemu_system_cond, &qemu_global_mutex, 100);
612
613     while (1) {
614         if (cpu_can_run(env))
615             qemu_cpu_exec(env);
616         qemu_kvm_wait_io_event(env);
617     }
618
619     return NULL;
620 }
621
622 static void *tcg_cpu_thread_fn(void *arg)
623 {
624     CPUState *env = arg;
625
626     tcg_init_ipi();
627     qemu_thread_self(env->thread);
628
629     /* signal CPU creation */
630     qemu_mutex_lock(&qemu_global_mutex);
631     for (env = first_cpu; env != NULL; env = env->next_cpu)
632         env->created = 1;
633     qemu_cond_signal(&qemu_cpu_cond);
634
635     /* and wait for machine initialization */
636     while (!qemu_system_ready)
637         qemu_cond_timedwait(&qemu_system_cond, &qemu_global_mutex, 100);
638
639     while (1) {
640         cpu_exec_all();
641         qemu_tcg_wait_io_event();
642     }
643
644     return NULL;
645 }
646
647 void qemu_cpu_kick(void *_env)
648 {
649     CPUState *env = _env;
650     qemu_cond_broadcast(env->halt_cond);
651     qemu_thread_signal(env->thread, SIG_IPI);
652 }
653
654 int qemu_cpu_self(void *_env)
655 {
656     CPUState *env = _env;
657     QemuThread this;
658
659     qemu_thread_self(&this);
660
661     return qemu_thread_equal(&this, env->thread);
662 }
663
664 static void cpu_signal(int sig)
665 {
666     if (cpu_single_env)
667         cpu_exit(cpu_single_env);
668     exit_request = 1;
669 }
670
671 static void tcg_init_ipi(void)
672 {
673     sigset_t set;
674     struct sigaction sigact;
675
676     memset(&sigact, 0, sizeof(sigact));
677     sigact.sa_handler = cpu_signal;
678     sigaction(SIG_IPI, &sigact, NULL);
679
680     sigemptyset(&set);
681     sigaddset(&set, SIG_IPI);
682     pthread_sigmask(SIG_UNBLOCK, &set, NULL);
683 }
684
685 static void dummy_signal(int sig)
686 {
687 }
688
689 static void kvm_init_ipi(CPUState *env)
690 {
691     int r;
692     sigset_t set;
693     struct sigaction sigact;
694
695     memset(&sigact, 0, sizeof(sigact));
696     sigact.sa_handler = dummy_signal;
697     sigaction(SIG_IPI, &sigact, NULL);
698
699     pthread_sigmask(SIG_BLOCK, NULL, &set);
700     sigdelset(&set, SIG_IPI);
701     sigdelset(&set, SIGBUS);
702     r = kvm_set_signal_mask(env, &set);
703     if (r) {
704         fprintf(stderr, "kvm_set_signal_mask: %s\n", strerror(r));
705         exit(1);
706     }
707 }
708
709 static sigset_t block_io_signals(void)
710 {
711     sigset_t set;
712     struct sigaction action;
713
714     /* SIGUSR2 used by posix-aio-compat.c */
715     sigemptyset(&set);
716     sigaddset(&set, SIGUSR2);
717     pthread_sigmask(SIG_UNBLOCK, &set, NULL);
718
719     sigemptyset(&set);
720     sigaddset(&set, SIGIO);
721     sigaddset(&set, SIGALRM);
722     sigaddset(&set, SIG_IPI);
723     sigaddset(&set, SIGBUS);
724     pthread_sigmask(SIG_BLOCK, &set, NULL);
725
726     memset(&action, 0, sizeof(action));
727     action.sa_flags = SA_SIGINFO;
728     action.sa_sigaction = (void (*)(int, siginfo_t*, void*))sigbus_handler;
729     sigaction(SIGBUS, &action, NULL);
730     prctl(PR_MCE_KILL, 1, 1, 0, 0);
731
732     return set;
733 }
734
735 void qemu_mutex_lock_iothread(void)
736 {
737     if (kvm_enabled()) {
738         qemu_mutex_lock(&qemu_global_mutex);
739     } else {
740         qemu_mutex_lock(&qemu_fair_mutex);
741         if (qemu_mutex_trylock(&qemu_global_mutex)) {
742             qemu_thread_signal(tcg_cpu_thread, SIG_IPI);
743             qemu_mutex_lock(&qemu_global_mutex);
744         }
745         qemu_mutex_unlock(&qemu_fair_mutex);
746     }
747 }
748
749 void qemu_mutex_unlock_iothread(void)
750 {
751     qemu_mutex_unlock(&qemu_global_mutex);
752 }
753
754 static int all_vcpus_paused(void)
755 {
756     CPUState *penv = first_cpu;
757
758     while (penv) {
759         if (!penv->stopped)
760             return 0;
761         penv = (CPUState *)penv->next_cpu;
762     }
763
764     return 1;
765 }
766
767 void pause_all_vcpus(void)
768 {
769     CPUState *penv = first_cpu;
770
771     while (penv) {
772         penv->stop = 1;
773         qemu_cpu_kick(penv);
774         penv = (CPUState *)penv->next_cpu;
775     }
776
777     while (!all_vcpus_paused()) {
778         qemu_cond_timedwait(&qemu_pause_cond, &qemu_global_mutex, 100);
779         penv = first_cpu;
780         while (penv) {
781             qemu_cpu_kick(penv);
782             penv = (CPUState *)penv->next_cpu;
783         }
784     }
785 }
786
787 void resume_all_vcpus(void)
788 {
789     CPUState *penv = first_cpu;
790
791     while (penv) {
792         penv->stop = 0;
793         penv->stopped = 0;
794         qemu_cpu_kick(penv);
795         penv = (CPUState *)penv->next_cpu;
796     }
797 }
798
799 static void tcg_init_vcpu(void *_env)
800 {
801     CPUState *env = _env;
802     /* share a single thread for all cpus with TCG */
803     if (!tcg_cpu_thread) {
804         env->thread = qemu_mallocz(sizeof(QemuThread));
805         env->halt_cond = qemu_mallocz(sizeof(QemuCond));
806         qemu_cond_init(env->halt_cond);
807         qemu_thread_create(env->thread, tcg_cpu_thread_fn, env);
808         while (env->created == 0)
809             qemu_cond_timedwait(&qemu_cpu_cond, &qemu_global_mutex, 100);
810         tcg_cpu_thread = env->thread;
811         tcg_halt_cond = env->halt_cond;
812     } else {
813         env->thread = tcg_cpu_thread;
814         env->halt_cond = tcg_halt_cond;
815     }
816 }
817
818 static void kvm_start_vcpu(CPUState *env)
819 {
820     env->thread = qemu_mallocz(sizeof(QemuThread));
821     env->halt_cond = qemu_mallocz(sizeof(QemuCond));
822     qemu_cond_init(env->halt_cond);
823     qemu_thread_create(env->thread, kvm_cpu_thread_fn, env);
824     while (env->created == 0)
825         qemu_cond_timedwait(&qemu_cpu_cond, &qemu_global_mutex, 100);
826 }
827
828 void qemu_init_vcpu(void *_env)
829 {
830     CPUState *env = _env;
831
832     env->nr_cores = smp_cores;
833     env->nr_threads = smp_threads;
834     if (kvm_enabled())
835         kvm_start_vcpu(env);
836     else
837         tcg_init_vcpu(env);
838 }
839
840 void qemu_notify_event(void)
841 {
842     qemu_event_increment();
843 }
844
845 static void qemu_system_vmstop_request(int reason)
846 {
847     vmstop_requested = reason;
848     qemu_notify_event();
849 }
850
851 void vm_stop(int reason)
852 {
853     QemuThread me;
854     qemu_thread_self(&me);
855
856     if (!qemu_thread_equal(&me, &io_thread)) {
857         qemu_system_vmstop_request(reason);
858         /*
859          * FIXME: should not return to device code in case
860          * vm_stop() has been requested.
861          */
862         if (cpu_single_env) {
863             cpu_exit(cpu_single_env);
864             cpu_single_env->stop = 1;
865         }
866         return;
867     }
868     do_vm_stop(reason);
869 }
870
871 #endif
872
873 static int qemu_cpu_exec(CPUState *env)
874 {
875     int ret;
876 #ifdef CONFIG_PROFILER
877     int64_t ti;
878 #endif
879
880 #ifdef CONFIG_PROFILER
881     ti = profile_getclock();
882 #endif
883     if (use_icount) {
884         int64_t count;
885         int decr;
886         qemu_icount -= (env->icount_decr.u16.low + env->icount_extra);
887         env->icount_decr.u16.low = 0;
888         env->icount_extra = 0;
889         count = qemu_icount_round (qemu_next_deadline());
890         qemu_icount += count;
891         decr = (count > 0xffff) ? 0xffff : count;
892         count -= decr;
893         env->icount_decr.u16.low = decr;
894         env->icount_extra = count;
895     }
896     ret = cpu_exec(env);
897 #ifdef CONFIG_PROFILER
898     qemu_time += profile_getclock() - ti;
899 #endif
900     if (use_icount) {
901         /* Fold pending instructions back into the
902            instruction counter, and clear the interrupt flag.  */
903         qemu_icount -= (env->icount_decr.u16.low
904                         + env->icount_extra);
905         env->icount_decr.u32 = 0;
906         env->icount_extra = 0;
907     }
908     return ret;
909 }
910
911 bool cpu_exec_all(void)
912 {
913     if (next_cpu == NULL)
914         next_cpu = first_cpu;
915     for (; next_cpu != NULL && !exit_request; next_cpu = next_cpu->next_cpu) {
916         CPUState *env = next_cpu;
917
918         qemu_clock_enable(vm_clock,
919                           (env->singlestep_enabled & SSTEP_NOTIMER) == 0);
920
921         if (qemu_alarm_pending())
922             break;
923         if (cpu_can_run(env)) {
924             if (qemu_cpu_exec(env) == EXCP_DEBUG) {
925                 break;
926             }
927         } else if (env->stop) {
928             break;
929         }
930     }
931     exit_request = 0;
932     return any_cpu_has_work();
933 }
934
935 void set_numa_modes(void)
936 {
937     CPUState *env;
938     int i;
939
940     for (env = first_cpu; env != NULL; env = env->next_cpu) {
941         for (i = 0; i < nb_numa_nodes; i++) {
942             if (node_cpumask[i] & (1 << env->cpu_index)) {
943                 env->numa_node = i;
944             }
945         }
946     }
947 }
948
949 void set_cpu_log(const char *optarg)
950 {
951     int mask;
952     const CPULogItem *item;
953
954     mask = cpu_str_to_log_mask(optarg);
955     if (!mask) {
956         printf("Log items (comma separated):\n");
957         for (item = cpu_log_items; item->mask != 0; item++) {
958             printf("%-10s %s\n", item->name, item->help);
959         }
960         exit(1);
961     }
962     cpu_set_log(mask);
963 }
964
965 /* Return the virtual CPU time, based on the instruction counter.  */
966 int64_t cpu_get_icount(void)
967 {
968     int64_t icount;
969     CPUState *env = cpu_single_env;;
970
971     icount = qemu_icount;
972     if (env) {
973         if (!can_do_io(env)) {
974             fprintf(stderr, "Bad clock read\n");
975         }
976         icount -= (env->icount_decr.u16.low + env->icount_extra);
977     }
978     return qemu_icount_bias + (icount << icount_time_shift);
979 }
980
981 void list_cpus(FILE *f, fprintf_function cpu_fprintf, const char *optarg)
982 {
983     /* XXX: implement xxx_cpu_list for targets that still miss it */
984 #if defined(cpu_list_id)
985     cpu_list_id(f, cpu_fprintf, optarg);
986 #elif defined(cpu_list)
987     cpu_list(f, cpu_fprintf); /* deprecated */
988 #endif
989 }