These changes are a raw update to a vanilla kernel 4.1.10, with the
[kvmfornfv.git] / qemu / 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/monitor.h"
29 #include "qapi/qmp/qerror.h"
30 #include "qemu/error-report.h"
31 #include "sysemu/sysemu.h"
32 #include "exec/gdbstub.h"
33 #include "sysemu/dma.h"
34 #include "sysemu/kvm.h"
35 #include "qmp-commands.h"
36
37 #include "qemu/thread.h"
38 #include "sysemu/cpus.h"
39 #include "sysemu/qtest.h"
40 #include "qemu/main-loop.h"
41 #include "qemu/bitmap.h"
42 #include "qemu/seqlock.h"
43 #include "qapi-event.h"
44 #include "hw/nmi.h"
45
46 #ifndef _WIN32
47 #include "qemu/compatfd.h"
48 #endif
49
50 #ifdef CONFIG_LINUX
51
52 #include <sys/prctl.h>
53
54 #ifndef PR_MCE_KILL
55 #define PR_MCE_KILL 33
56 #endif
57
58 #ifndef PR_MCE_KILL_SET
59 #define PR_MCE_KILL_SET 1
60 #endif
61
62 #ifndef PR_MCE_KILL_EARLY
63 #define PR_MCE_KILL_EARLY 1
64 #endif
65
66 #endif /* CONFIG_LINUX */
67
68 static CPUState *next_cpu;
69 int64_t max_delay;
70 int64_t max_advance;
71
72 bool cpu_is_stopped(CPUState *cpu)
73 {
74     return cpu->stopped || !runstate_is_running();
75 }
76
77 static bool cpu_thread_is_idle(CPUState *cpu)
78 {
79     if (cpu->stop || cpu->queued_work_first) {
80         return false;
81     }
82     if (cpu_is_stopped(cpu)) {
83         return true;
84     }
85     if (!cpu->halted || cpu_has_work(cpu) ||
86         kvm_halt_in_kernel()) {
87         return false;
88     }
89     return true;
90 }
91
92 static bool all_cpu_threads_idle(void)
93 {
94     CPUState *cpu;
95
96     CPU_FOREACH(cpu) {
97         if (!cpu_thread_is_idle(cpu)) {
98             return false;
99         }
100     }
101     return true;
102 }
103
104 /***********************************************************/
105 /* guest cycle counter */
106
107 /* Protected by TimersState seqlock */
108
109 static bool icount_sleep = true;
110 static int64_t vm_clock_warp_start = -1;
111 /* Conversion factor from emulated instructions to virtual clock ticks.  */
112 static int icount_time_shift;
113 /* Arbitrarily pick 1MIPS as the minimum allowable speed.  */
114 #define MAX_ICOUNT_SHIFT 10
115
116 static QEMUTimer *icount_rt_timer;
117 static QEMUTimer *icount_vm_timer;
118 static QEMUTimer *icount_warp_timer;
119
120 typedef struct TimersState {
121     /* Protected by BQL.  */
122     int64_t cpu_ticks_prev;
123     int64_t cpu_ticks_offset;
124
125     /* cpu_clock_offset can be read out of BQL, so protect it with
126      * this lock.
127      */
128     QemuSeqLock vm_clock_seqlock;
129     int64_t cpu_clock_offset;
130     int32_t cpu_ticks_enabled;
131     int64_t dummy;
132
133     /* Compensate for varying guest execution speed.  */
134     int64_t qemu_icount_bias;
135     /* Only written by TCG thread */
136     int64_t qemu_icount;
137 } TimersState;
138
139 static TimersState timers_state;
140
141 int64_t cpu_get_icount_raw(void)
142 {
143     int64_t icount;
144     CPUState *cpu = current_cpu;
145
146     icount = timers_state.qemu_icount;
147     if (cpu) {
148         if (!cpu_can_do_io(cpu)) {
149             fprintf(stderr, "Bad icount read\n");
150             exit(1);
151         }
152         icount -= (cpu->icount_decr.u16.low + cpu->icount_extra);
153     }
154     return icount;
155 }
156
157 /* Return the virtual CPU time, based on the instruction counter.  */
158 static int64_t cpu_get_icount_locked(void)
159 {
160     int64_t icount = cpu_get_icount_raw();
161     return timers_state.qemu_icount_bias + cpu_icount_to_ns(icount);
162 }
163
164 int64_t cpu_get_icount(void)
165 {
166     int64_t icount;
167     unsigned start;
168
169     do {
170         start = seqlock_read_begin(&timers_state.vm_clock_seqlock);
171         icount = cpu_get_icount_locked();
172     } while (seqlock_read_retry(&timers_state.vm_clock_seqlock, start));
173
174     return icount;
175 }
176
177 int64_t cpu_icount_to_ns(int64_t icount)
178 {
179     return icount << icount_time_shift;
180 }
181
182 /* return the host CPU cycle counter and handle stop/restart */
183 /* Caller must hold the BQL */
184 int64_t cpu_get_ticks(void)
185 {
186     int64_t ticks;
187
188     if (use_icount) {
189         return cpu_get_icount();
190     }
191
192     ticks = timers_state.cpu_ticks_offset;
193     if (timers_state.cpu_ticks_enabled) {
194         ticks += cpu_get_real_ticks();
195     }
196
197     if (timers_state.cpu_ticks_prev > ticks) {
198         /* Note: non increasing ticks may happen if the host uses
199            software suspend */
200         timers_state.cpu_ticks_offset += timers_state.cpu_ticks_prev - ticks;
201         ticks = timers_state.cpu_ticks_prev;
202     }
203
204     timers_state.cpu_ticks_prev = ticks;
205     return ticks;
206 }
207
208 static int64_t cpu_get_clock_locked(void)
209 {
210     int64_t ticks;
211
212     ticks = timers_state.cpu_clock_offset;
213     if (timers_state.cpu_ticks_enabled) {
214         ticks += get_clock();
215     }
216
217     return ticks;
218 }
219
220 /* return the host CPU monotonic timer and handle stop/restart */
221 int64_t cpu_get_clock(void)
222 {
223     int64_t ti;
224     unsigned start;
225
226     do {
227         start = seqlock_read_begin(&timers_state.vm_clock_seqlock);
228         ti = cpu_get_clock_locked();
229     } while (seqlock_read_retry(&timers_state.vm_clock_seqlock, start));
230
231     return ti;
232 }
233
234 /* enable cpu_get_ticks()
235  * Caller must hold BQL which server as mutex for vm_clock_seqlock.
236  */
237 void cpu_enable_ticks(void)
238 {
239     /* Here, the really thing protected by seqlock is cpu_clock_offset. */
240     seqlock_write_lock(&timers_state.vm_clock_seqlock);
241     if (!timers_state.cpu_ticks_enabled) {
242         timers_state.cpu_ticks_offset -= cpu_get_real_ticks();
243         timers_state.cpu_clock_offset -= get_clock();
244         timers_state.cpu_ticks_enabled = 1;
245     }
246     seqlock_write_unlock(&timers_state.vm_clock_seqlock);
247 }
248
249 /* disable cpu_get_ticks() : the clock is stopped. You must not call
250  * cpu_get_ticks() after that.
251  * Caller must hold BQL which server as mutex for vm_clock_seqlock.
252  */
253 void cpu_disable_ticks(void)
254 {
255     /* Here, the really thing protected by seqlock is cpu_clock_offset. */
256     seqlock_write_lock(&timers_state.vm_clock_seqlock);
257     if (timers_state.cpu_ticks_enabled) {
258         timers_state.cpu_ticks_offset += cpu_get_real_ticks();
259         timers_state.cpu_clock_offset = cpu_get_clock_locked();
260         timers_state.cpu_ticks_enabled = 0;
261     }
262     seqlock_write_unlock(&timers_state.vm_clock_seqlock);
263 }
264
265 /* Correlation between real and virtual time is always going to be
266    fairly approximate, so ignore small variation.
267    When the guest is idle real and virtual time will be aligned in
268    the IO wait loop.  */
269 #define ICOUNT_WOBBLE (get_ticks_per_sec() / 10)
270
271 static void icount_adjust(void)
272 {
273     int64_t cur_time;
274     int64_t cur_icount;
275     int64_t delta;
276
277     /* Protected by TimersState mutex.  */
278     static int64_t last_delta;
279
280     /* If the VM is not running, then do nothing.  */
281     if (!runstate_is_running()) {
282         return;
283     }
284
285     seqlock_write_lock(&timers_state.vm_clock_seqlock);
286     cur_time = cpu_get_clock_locked();
287     cur_icount = cpu_get_icount_locked();
288
289     delta = cur_icount - cur_time;
290     /* FIXME: This is a very crude algorithm, somewhat prone to oscillation.  */
291     if (delta > 0
292         && last_delta + ICOUNT_WOBBLE < delta * 2
293         && icount_time_shift > 0) {
294         /* The guest is getting too far ahead.  Slow time down.  */
295         icount_time_shift--;
296     }
297     if (delta < 0
298         && last_delta - ICOUNT_WOBBLE > delta * 2
299         && icount_time_shift < MAX_ICOUNT_SHIFT) {
300         /* The guest is getting too far behind.  Speed time up.  */
301         icount_time_shift++;
302     }
303     last_delta = delta;
304     timers_state.qemu_icount_bias = cur_icount
305                               - (timers_state.qemu_icount << icount_time_shift);
306     seqlock_write_unlock(&timers_state.vm_clock_seqlock);
307 }
308
309 static void icount_adjust_rt(void *opaque)
310 {
311     timer_mod(icount_rt_timer,
312               qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL_RT) + 1000);
313     icount_adjust();
314 }
315
316 static void icount_adjust_vm(void *opaque)
317 {
318     timer_mod(icount_vm_timer,
319                    qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) +
320                    get_ticks_per_sec() / 10);
321     icount_adjust();
322 }
323
324 static int64_t qemu_icount_round(int64_t count)
325 {
326     return (count + (1 << icount_time_shift) - 1) >> icount_time_shift;
327 }
328
329 static void icount_warp_rt(void *opaque)
330 {
331     /* The icount_warp_timer is rescheduled soon after vm_clock_warp_start
332      * changes from -1 to another value, so the race here is okay.
333      */
334     if (atomic_read(&vm_clock_warp_start) == -1) {
335         return;
336     }
337
338     seqlock_write_lock(&timers_state.vm_clock_seqlock);
339     if (runstate_is_running()) {
340         int64_t clock = cpu_get_clock_locked();
341         int64_t warp_delta;
342
343         warp_delta = clock - vm_clock_warp_start;
344         if (use_icount == 2) {
345             /*
346              * In adaptive mode, do not let QEMU_CLOCK_VIRTUAL run too
347              * far ahead of real time.
348              */
349             int64_t cur_icount = cpu_get_icount_locked();
350             int64_t delta = clock - cur_icount;
351             warp_delta = MIN(warp_delta, delta);
352         }
353         timers_state.qemu_icount_bias += warp_delta;
354     }
355     vm_clock_warp_start = -1;
356     seqlock_write_unlock(&timers_state.vm_clock_seqlock);
357
358     if (qemu_clock_expired(QEMU_CLOCK_VIRTUAL)) {
359         qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
360     }
361 }
362
363 void qtest_clock_warp(int64_t dest)
364 {
365     int64_t clock = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
366     AioContext *aio_context;
367     assert(qtest_enabled());
368     aio_context = qemu_get_aio_context();
369     while (clock < dest) {
370         int64_t deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL);
371         int64_t warp = qemu_soonest_timeout(dest - clock, deadline);
372
373         seqlock_write_lock(&timers_state.vm_clock_seqlock);
374         timers_state.qemu_icount_bias += warp;
375         seqlock_write_unlock(&timers_state.vm_clock_seqlock);
376
377         qemu_clock_run_timers(QEMU_CLOCK_VIRTUAL);
378         timerlist_run_timers(aio_context->tlg.tl[QEMU_CLOCK_VIRTUAL]);
379         clock = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
380     }
381     qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
382 }
383
384 void qemu_clock_warp(QEMUClockType type)
385 {
386     int64_t clock;
387     int64_t deadline;
388
389     /*
390      * There are too many global variables to make the "warp" behavior
391      * applicable to other clocks.  But a clock argument removes the
392      * need for if statements all over the place.
393      */
394     if (type != QEMU_CLOCK_VIRTUAL || !use_icount) {
395         return;
396     }
397
398     if (icount_sleep) {
399         /*
400          * If the CPUs have been sleeping, advance QEMU_CLOCK_VIRTUAL timer now.
401          * This ensures that the deadline for the timer is computed correctly
402          * below.
403          * This also makes sure that the insn counter is synchronized before
404          * the CPU starts running, in case the CPU is woken by an event other
405          * than the earliest QEMU_CLOCK_VIRTUAL timer.
406          */
407         icount_warp_rt(NULL);
408         timer_del(icount_warp_timer);
409     }
410     if (!all_cpu_threads_idle()) {
411         return;
412     }
413
414     if (qtest_enabled()) {
415         /* When testing, qtest commands advance icount.  */
416         return;
417     }
418
419     /* We want to use the earliest deadline from ALL vm_clocks */
420     clock = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL_RT);
421     deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL);
422     if (deadline < 0) {
423         static bool notified;
424         if (!icount_sleep && !notified) {
425             error_report("WARNING: icount sleep disabled and no active timers");
426             notified = true;
427         }
428         return;
429     }
430
431     if (deadline > 0) {
432         /*
433          * Ensure QEMU_CLOCK_VIRTUAL proceeds even when the virtual CPU goes to
434          * sleep.  Otherwise, the CPU might be waiting for a future timer
435          * interrupt to wake it up, but the interrupt never comes because
436          * the vCPU isn't running any insns and thus doesn't advance the
437          * QEMU_CLOCK_VIRTUAL.
438          */
439         if (!icount_sleep) {
440             /*
441              * We never let VCPUs sleep in no sleep icount mode.
442              * If there is a pending QEMU_CLOCK_VIRTUAL timer we just advance
443              * to the next QEMU_CLOCK_VIRTUAL event and notify it.
444              * It is useful when we want a deterministic execution time,
445              * isolated from host latencies.
446              */
447             seqlock_write_lock(&timers_state.vm_clock_seqlock);
448             timers_state.qemu_icount_bias += deadline;
449             seqlock_write_unlock(&timers_state.vm_clock_seqlock);
450             qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
451         } else {
452             /*
453              * We do stop VCPUs and only advance QEMU_CLOCK_VIRTUAL after some
454              * "real" time, (related to the time left until the next event) has
455              * passed. The QEMU_CLOCK_VIRTUAL_RT clock will do this.
456              * This avoids that the warps are visible externally; for example,
457              * you will not be sending network packets continuously instead of
458              * every 100ms.
459              */
460             seqlock_write_lock(&timers_state.vm_clock_seqlock);
461             if (vm_clock_warp_start == -1 || vm_clock_warp_start > clock) {
462                 vm_clock_warp_start = clock;
463             }
464             seqlock_write_unlock(&timers_state.vm_clock_seqlock);
465             timer_mod_anticipate(icount_warp_timer, clock + deadline);
466         }
467     } else if (deadline == 0) {
468         qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
469     }
470 }
471
472 static bool icount_state_needed(void *opaque)
473 {
474     return use_icount;
475 }
476
477 /*
478  * This is a subsection for icount migration.
479  */
480 static const VMStateDescription icount_vmstate_timers = {
481     .name = "timer/icount",
482     .version_id = 1,
483     .minimum_version_id = 1,
484     .needed = icount_state_needed,
485     .fields = (VMStateField[]) {
486         VMSTATE_INT64(qemu_icount_bias, TimersState),
487         VMSTATE_INT64(qemu_icount, TimersState),
488         VMSTATE_END_OF_LIST()
489     }
490 };
491
492 static const VMStateDescription vmstate_timers = {
493     .name = "timer",
494     .version_id = 2,
495     .minimum_version_id = 1,
496     .fields = (VMStateField[]) {
497         VMSTATE_INT64(cpu_ticks_offset, TimersState),
498         VMSTATE_INT64(dummy, TimersState),
499         VMSTATE_INT64_V(cpu_clock_offset, TimersState, 2),
500         VMSTATE_END_OF_LIST()
501     },
502     .subsections = (const VMStateDescription*[]) {
503         &icount_vmstate_timers,
504         NULL
505     }
506 };
507
508 void cpu_ticks_init(void)
509 {
510     seqlock_init(&timers_state.vm_clock_seqlock, NULL);
511     vmstate_register(NULL, 0, &vmstate_timers, &timers_state);
512 }
513
514 void configure_icount(QemuOpts *opts, Error **errp)
515 {
516     const char *option;
517     char *rem_str = NULL;
518
519     option = qemu_opt_get(opts, "shift");
520     if (!option) {
521         if (qemu_opt_get(opts, "align") != NULL) {
522             error_setg(errp, "Please specify shift option when using align");
523         }
524         return;
525     }
526
527     icount_sleep = qemu_opt_get_bool(opts, "sleep", true);
528     if (icount_sleep) {
529         icount_warp_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL_RT,
530                                          icount_warp_rt, NULL);
531     }
532
533     icount_align_option = qemu_opt_get_bool(opts, "align", false);
534
535     if (icount_align_option && !icount_sleep) {
536         error_setg(errp, "align=on and sleep=no are incompatible");
537     }
538     if (strcmp(option, "auto") != 0) {
539         errno = 0;
540         icount_time_shift = strtol(option, &rem_str, 0);
541         if (errno != 0 || *rem_str != '\0' || !strlen(option)) {
542             error_setg(errp, "icount: Invalid shift value");
543         }
544         use_icount = 1;
545         return;
546     } else if (icount_align_option) {
547         error_setg(errp, "shift=auto and align=on are incompatible");
548     } else if (!icount_sleep) {
549         error_setg(errp, "shift=auto and sleep=no are incompatible");
550     }
551
552     use_icount = 2;
553
554     /* 125MIPS seems a reasonable initial guess at the guest speed.
555        It will be corrected fairly quickly anyway.  */
556     icount_time_shift = 3;
557
558     /* Have both realtime and virtual time triggers for speed adjustment.
559        The realtime trigger catches emulated time passing too slowly,
560        the virtual time trigger catches emulated time passing too fast.
561        Realtime triggers occur even when idle, so use them less frequently
562        than VM triggers.  */
563     icount_rt_timer = timer_new_ms(QEMU_CLOCK_VIRTUAL_RT,
564                                    icount_adjust_rt, NULL);
565     timer_mod(icount_rt_timer,
566                    qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL_RT) + 1000);
567     icount_vm_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL,
568                                         icount_adjust_vm, NULL);
569     timer_mod(icount_vm_timer,
570                    qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) +
571                    get_ticks_per_sec() / 10);
572 }
573
574 /***********************************************************/
575 void hw_error(const char *fmt, ...)
576 {
577     va_list ap;
578     CPUState *cpu;
579
580     va_start(ap, fmt);
581     fprintf(stderr, "qemu: hardware error: ");
582     vfprintf(stderr, fmt, ap);
583     fprintf(stderr, "\n");
584     CPU_FOREACH(cpu) {
585         fprintf(stderr, "CPU #%d:\n", cpu->cpu_index);
586         cpu_dump_state(cpu, stderr, fprintf, CPU_DUMP_FPU);
587     }
588     va_end(ap);
589     abort();
590 }
591
592 void cpu_synchronize_all_states(void)
593 {
594     CPUState *cpu;
595
596     CPU_FOREACH(cpu) {
597         cpu_synchronize_state(cpu);
598     }
599 }
600
601 void cpu_synchronize_all_post_reset(void)
602 {
603     CPUState *cpu;
604
605     CPU_FOREACH(cpu) {
606         cpu_synchronize_post_reset(cpu);
607     }
608 }
609
610 void cpu_synchronize_all_post_init(void)
611 {
612     CPUState *cpu;
613
614     CPU_FOREACH(cpu) {
615         cpu_synchronize_post_init(cpu);
616     }
617 }
618
619 void cpu_clean_all_dirty(void)
620 {
621     CPUState *cpu;
622
623     CPU_FOREACH(cpu) {
624         cpu_clean_state(cpu);
625     }
626 }
627
628 static int do_vm_stop(RunState state)
629 {
630     int ret = 0;
631
632     if (runstate_is_running()) {
633         cpu_disable_ticks();
634         pause_all_vcpus();
635         runstate_set(state);
636         vm_state_notify(0, state);
637         qapi_event_send_stop(&error_abort);
638     }
639
640     bdrv_drain_all();
641     ret = bdrv_flush_all();
642
643     return ret;
644 }
645
646 static bool cpu_can_run(CPUState *cpu)
647 {
648     if (cpu->stop) {
649         return false;
650     }
651     if (cpu_is_stopped(cpu)) {
652         return false;
653     }
654     return true;
655 }
656
657 static void cpu_handle_guest_debug(CPUState *cpu)
658 {
659     gdb_set_stop_cpu(cpu);
660     qemu_system_debug_request();
661     cpu->stopped = true;
662 }
663
664 static void cpu_signal(int sig)
665 {
666     if (current_cpu) {
667         cpu_exit(current_cpu);
668     }
669     exit_request = 1;
670 }
671
672 #ifdef CONFIG_LINUX
673 static void sigbus_reraise(void)
674 {
675     sigset_t set;
676     struct sigaction action;
677
678     memset(&action, 0, sizeof(action));
679     action.sa_handler = SIG_DFL;
680     if (!sigaction(SIGBUS, &action, NULL)) {
681         raise(SIGBUS);
682         sigemptyset(&set);
683         sigaddset(&set, SIGBUS);
684         sigprocmask(SIG_UNBLOCK, &set, NULL);
685     }
686     perror("Failed to re-raise SIGBUS!\n");
687     abort();
688 }
689
690 static void sigbus_handler(int n, struct qemu_signalfd_siginfo *siginfo,
691                            void *ctx)
692 {
693     if (kvm_on_sigbus(siginfo->ssi_code,
694                       (void *)(intptr_t)siginfo->ssi_addr)) {
695         sigbus_reraise();
696     }
697 }
698
699 static void qemu_init_sigbus(void)
700 {
701     struct sigaction action;
702
703     memset(&action, 0, sizeof(action));
704     action.sa_flags = SA_SIGINFO;
705     action.sa_sigaction = (void (*)(int, siginfo_t*, void*))sigbus_handler;
706     sigaction(SIGBUS, &action, NULL);
707
708     prctl(PR_MCE_KILL, PR_MCE_KILL_SET, PR_MCE_KILL_EARLY, 0, 0);
709 }
710
711 static void qemu_kvm_eat_signals(CPUState *cpu)
712 {
713     struct timespec ts = { 0, 0 };
714     siginfo_t siginfo;
715     sigset_t waitset;
716     sigset_t chkset;
717     int r;
718
719     sigemptyset(&waitset);
720     sigaddset(&waitset, SIG_IPI);
721     sigaddset(&waitset, SIGBUS);
722
723     do {
724         r = sigtimedwait(&waitset, &siginfo, &ts);
725         if (r == -1 && !(errno == EAGAIN || errno == EINTR)) {
726             perror("sigtimedwait");
727             exit(1);
728         }
729
730         switch (r) {
731         case SIGBUS:
732             if (kvm_on_sigbus_vcpu(cpu, siginfo.si_code, siginfo.si_addr)) {
733                 sigbus_reraise();
734             }
735             break;
736         default:
737             break;
738         }
739
740         r = sigpending(&chkset);
741         if (r == -1) {
742             perror("sigpending");
743             exit(1);
744         }
745     } while (sigismember(&chkset, SIG_IPI) || sigismember(&chkset, SIGBUS));
746 }
747
748 #else /* !CONFIG_LINUX */
749
750 static void qemu_init_sigbus(void)
751 {
752 }
753
754 static void qemu_kvm_eat_signals(CPUState *cpu)
755 {
756 }
757 #endif /* !CONFIG_LINUX */
758
759 #ifndef _WIN32
760 static void dummy_signal(int sig)
761 {
762 }
763
764 static void qemu_kvm_init_cpu_signals(CPUState *cpu)
765 {
766     int r;
767     sigset_t set;
768     struct sigaction sigact;
769
770     memset(&sigact, 0, sizeof(sigact));
771     sigact.sa_handler = dummy_signal;
772     sigaction(SIG_IPI, &sigact, NULL);
773
774     pthread_sigmask(SIG_BLOCK, NULL, &set);
775     sigdelset(&set, SIG_IPI);
776     sigdelset(&set, SIGBUS);
777     r = kvm_set_signal_mask(cpu, &set);
778     if (r) {
779         fprintf(stderr, "kvm_set_signal_mask: %s\n", strerror(-r));
780         exit(1);
781     }
782 }
783
784 static void qemu_tcg_init_cpu_signals(void)
785 {
786     sigset_t set;
787     struct sigaction sigact;
788
789     memset(&sigact, 0, sizeof(sigact));
790     sigact.sa_handler = cpu_signal;
791     sigaction(SIG_IPI, &sigact, NULL);
792
793     sigemptyset(&set);
794     sigaddset(&set, SIG_IPI);
795     pthread_sigmask(SIG_UNBLOCK, &set, NULL);
796 }
797
798 #else /* _WIN32 */
799 static void qemu_kvm_init_cpu_signals(CPUState *cpu)
800 {
801     abort();
802 }
803
804 static void qemu_tcg_init_cpu_signals(void)
805 {
806 }
807 #endif /* _WIN32 */
808
809 static QemuMutex qemu_global_mutex;
810 static QemuCond qemu_io_proceeded_cond;
811 static unsigned iothread_requesting_mutex;
812
813 static QemuThread io_thread;
814
815 static QemuThread *tcg_cpu_thread;
816 static QemuCond *tcg_halt_cond;
817
818 /* cpu creation */
819 static QemuCond qemu_cpu_cond;
820 /* system init */
821 static QemuCond qemu_pause_cond;
822 static QemuCond qemu_work_cond;
823
824 void qemu_init_cpu_loop(void)
825 {
826     qemu_init_sigbus();
827     qemu_cond_init(&qemu_cpu_cond);
828     qemu_cond_init(&qemu_pause_cond);
829     qemu_cond_init(&qemu_work_cond);
830     qemu_cond_init(&qemu_io_proceeded_cond);
831     qemu_mutex_init(&qemu_global_mutex);
832
833     qemu_thread_get_self(&io_thread);
834 }
835
836 void run_on_cpu(CPUState *cpu, void (*func)(void *data), void *data)
837 {
838     struct qemu_work_item wi;
839
840     if (qemu_cpu_is_self(cpu)) {
841         func(data);
842         return;
843     }
844
845     wi.func = func;
846     wi.data = data;
847     wi.free = false;
848     if (cpu->queued_work_first == NULL) {
849         cpu->queued_work_first = &wi;
850     } else {
851         cpu->queued_work_last->next = &wi;
852     }
853     cpu->queued_work_last = &wi;
854     wi.next = NULL;
855     wi.done = false;
856
857     qemu_cpu_kick(cpu);
858     while (!wi.done) {
859         CPUState *self_cpu = current_cpu;
860
861         qemu_cond_wait(&qemu_work_cond, &qemu_global_mutex);
862         current_cpu = self_cpu;
863     }
864 }
865
866 void async_run_on_cpu(CPUState *cpu, void (*func)(void *data), void *data)
867 {
868     struct qemu_work_item *wi;
869
870     if (qemu_cpu_is_self(cpu)) {
871         func(data);
872         return;
873     }
874
875     wi = g_malloc0(sizeof(struct qemu_work_item));
876     wi->func = func;
877     wi->data = data;
878     wi->free = true;
879     if (cpu->queued_work_first == NULL) {
880         cpu->queued_work_first = wi;
881     } else {
882         cpu->queued_work_last->next = wi;
883     }
884     cpu->queued_work_last = wi;
885     wi->next = NULL;
886     wi->done = false;
887
888     qemu_cpu_kick(cpu);
889 }
890
891 static void flush_queued_work(CPUState *cpu)
892 {
893     struct qemu_work_item *wi;
894
895     if (cpu->queued_work_first == NULL) {
896         return;
897     }
898
899     while ((wi = cpu->queued_work_first)) {
900         cpu->queued_work_first = wi->next;
901         wi->func(wi->data);
902         wi->done = true;
903         if (wi->free) {
904             g_free(wi);
905         }
906     }
907     cpu->queued_work_last = NULL;
908     qemu_cond_broadcast(&qemu_work_cond);
909 }
910
911 static void qemu_wait_io_event_common(CPUState *cpu)
912 {
913     if (cpu->stop) {
914         cpu->stop = false;
915         cpu->stopped = true;
916         qemu_cond_signal(&qemu_pause_cond);
917     }
918     flush_queued_work(cpu);
919     cpu->thread_kicked = false;
920 }
921
922 static void qemu_tcg_wait_io_event(void)
923 {
924     CPUState *cpu;
925
926     while (all_cpu_threads_idle()) {
927        /* Start accounting real time to the virtual clock if the CPUs
928           are idle.  */
929         qemu_clock_warp(QEMU_CLOCK_VIRTUAL);
930         qemu_cond_wait(tcg_halt_cond, &qemu_global_mutex);
931     }
932
933     while (iothread_requesting_mutex) {
934         qemu_cond_wait(&qemu_io_proceeded_cond, &qemu_global_mutex);
935     }
936
937     CPU_FOREACH(cpu) {
938         qemu_wait_io_event_common(cpu);
939     }
940 }
941
942 static void qemu_kvm_wait_io_event(CPUState *cpu)
943 {
944     while (cpu_thread_is_idle(cpu)) {
945         qemu_cond_wait(cpu->halt_cond, &qemu_global_mutex);
946     }
947
948     qemu_kvm_eat_signals(cpu);
949     qemu_wait_io_event_common(cpu);
950 }
951
952 static void *qemu_kvm_cpu_thread_fn(void *arg)
953 {
954     CPUState *cpu = arg;
955     int r;
956
957     rcu_register_thread();
958
959     qemu_mutex_lock_iothread();
960     qemu_thread_get_self(cpu->thread);
961     cpu->thread_id = qemu_get_thread_id();
962     cpu->can_do_io = 1;
963     current_cpu = cpu;
964
965     r = kvm_init_vcpu(cpu);
966     if (r < 0) {
967         fprintf(stderr, "kvm_init_vcpu failed: %s\n", strerror(-r));
968         exit(1);
969     }
970
971     qemu_kvm_init_cpu_signals(cpu);
972
973     /* signal CPU creation */
974     cpu->created = true;
975     qemu_cond_signal(&qemu_cpu_cond);
976
977     while (1) {
978         if (cpu_can_run(cpu)) {
979             r = kvm_cpu_exec(cpu);
980             if (r == EXCP_DEBUG) {
981                 cpu_handle_guest_debug(cpu);
982             }
983         }
984         qemu_kvm_wait_io_event(cpu);
985     }
986
987     return NULL;
988 }
989
990 static void *qemu_dummy_cpu_thread_fn(void *arg)
991 {
992 #ifdef _WIN32
993     fprintf(stderr, "qtest is not supported under Windows\n");
994     exit(1);
995 #else
996     CPUState *cpu = arg;
997     sigset_t waitset;
998     int r;
999
1000     rcu_register_thread();
1001
1002     qemu_mutex_lock_iothread();
1003     qemu_thread_get_self(cpu->thread);
1004     cpu->thread_id = qemu_get_thread_id();
1005     cpu->can_do_io = 1;
1006
1007     sigemptyset(&waitset);
1008     sigaddset(&waitset, SIG_IPI);
1009
1010     /* signal CPU creation */
1011     cpu->created = true;
1012     qemu_cond_signal(&qemu_cpu_cond);
1013
1014     current_cpu = cpu;
1015     while (1) {
1016         current_cpu = NULL;
1017         qemu_mutex_unlock_iothread();
1018         do {
1019             int sig;
1020             r = sigwait(&waitset, &sig);
1021         } while (r == -1 && (errno == EAGAIN || errno == EINTR));
1022         if (r == -1) {
1023             perror("sigwait");
1024             exit(1);
1025         }
1026         qemu_mutex_lock_iothread();
1027         current_cpu = cpu;
1028         qemu_wait_io_event_common(cpu);
1029     }
1030
1031     return NULL;
1032 #endif
1033 }
1034
1035 static void tcg_exec_all(void);
1036
1037 static void *qemu_tcg_cpu_thread_fn(void *arg)
1038 {
1039     CPUState *cpu = arg;
1040
1041     rcu_register_thread();
1042
1043     qemu_mutex_lock_iothread();
1044     qemu_tcg_init_cpu_signals();
1045     qemu_thread_get_self(cpu->thread);
1046
1047     CPU_FOREACH(cpu) {
1048         cpu->thread_id = qemu_get_thread_id();
1049         cpu->created = true;
1050         cpu->can_do_io = 1;
1051     }
1052     qemu_cond_signal(&qemu_cpu_cond);
1053
1054     /* wait for initial kick-off after machine start */
1055     while (first_cpu->stopped) {
1056         qemu_cond_wait(tcg_halt_cond, &qemu_global_mutex);
1057
1058         /* process any pending work */
1059         CPU_FOREACH(cpu) {
1060             qemu_wait_io_event_common(cpu);
1061         }
1062     }
1063
1064     /* process any pending work */
1065     exit_request = 1;
1066
1067     while (1) {
1068         tcg_exec_all();
1069
1070         if (use_icount) {
1071             int64_t deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL);
1072
1073             if (deadline == 0) {
1074                 qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
1075             }
1076         }
1077         qemu_tcg_wait_io_event();
1078     }
1079
1080     return NULL;
1081 }
1082
1083 static void qemu_cpu_kick_thread(CPUState *cpu)
1084 {
1085 #ifndef _WIN32
1086     int err;
1087
1088     err = pthread_kill(cpu->thread->thread, SIG_IPI);
1089     if (err) {
1090         fprintf(stderr, "qemu:%s: %s", __func__, strerror(err));
1091         exit(1);
1092     }
1093 #else /* _WIN32 */
1094     if (!qemu_cpu_is_self(cpu)) {
1095         CONTEXT tcgContext;
1096
1097         if (SuspendThread(cpu->hThread) == (DWORD)-1) {
1098             fprintf(stderr, "qemu:%s: GetLastError:%lu\n", __func__,
1099                     GetLastError());
1100             exit(1);
1101         }
1102
1103         /* On multi-core systems, we are not sure that the thread is actually
1104          * suspended until we can get the context.
1105          */
1106         tcgContext.ContextFlags = CONTEXT_CONTROL;
1107         while (GetThreadContext(cpu->hThread, &tcgContext) != 0) {
1108             continue;
1109         }
1110
1111         cpu_signal(0);
1112
1113         if (ResumeThread(cpu->hThread) == (DWORD)-1) {
1114             fprintf(stderr, "qemu:%s: GetLastError:%lu\n", __func__,
1115                     GetLastError());
1116             exit(1);
1117         }
1118     }
1119 #endif
1120 }
1121
1122 void qemu_cpu_kick(CPUState *cpu)
1123 {
1124     qemu_cond_broadcast(cpu->halt_cond);
1125     if (!tcg_enabled() && !cpu->thread_kicked) {
1126         qemu_cpu_kick_thread(cpu);
1127         cpu->thread_kicked = true;
1128     }
1129 }
1130
1131 void qemu_cpu_kick_self(void)
1132 {
1133 #ifndef _WIN32
1134     assert(current_cpu);
1135
1136     if (!current_cpu->thread_kicked) {
1137         qemu_cpu_kick_thread(current_cpu);
1138         current_cpu->thread_kicked = true;
1139     }
1140 #else
1141     abort();
1142 #endif
1143 }
1144
1145 bool qemu_cpu_is_self(CPUState *cpu)
1146 {
1147     return qemu_thread_is_self(cpu->thread);
1148 }
1149
1150 bool qemu_in_vcpu_thread(void)
1151 {
1152     return current_cpu && qemu_cpu_is_self(current_cpu);
1153 }
1154
1155 static __thread bool iothread_locked = false;
1156
1157 bool qemu_mutex_iothread_locked(void)
1158 {
1159     return iothread_locked;
1160 }
1161
1162 void qemu_mutex_lock_iothread(void)
1163 {
1164     atomic_inc(&iothread_requesting_mutex);
1165     /* In the simple case there is no need to bump the VCPU thread out of
1166      * TCG code execution.
1167      */
1168     if (!tcg_enabled() || qemu_in_vcpu_thread() ||
1169         !first_cpu || !first_cpu->thread) {
1170         qemu_mutex_lock(&qemu_global_mutex);
1171         atomic_dec(&iothread_requesting_mutex);
1172     } else {
1173         if (qemu_mutex_trylock(&qemu_global_mutex)) {
1174             qemu_cpu_kick_thread(first_cpu);
1175             qemu_mutex_lock(&qemu_global_mutex);
1176         }
1177         atomic_dec(&iothread_requesting_mutex);
1178         qemu_cond_broadcast(&qemu_io_proceeded_cond);
1179     }
1180     iothread_locked = true;
1181 }
1182
1183 void qemu_mutex_unlock_iothread(void)
1184 {
1185     iothread_locked = false;
1186     qemu_mutex_unlock(&qemu_global_mutex);
1187 }
1188
1189 static int all_vcpus_paused(void)
1190 {
1191     CPUState *cpu;
1192
1193     CPU_FOREACH(cpu) {
1194         if (!cpu->stopped) {
1195             return 0;
1196         }
1197     }
1198
1199     return 1;
1200 }
1201
1202 void pause_all_vcpus(void)
1203 {
1204     CPUState *cpu;
1205
1206     qemu_clock_enable(QEMU_CLOCK_VIRTUAL, false);
1207     CPU_FOREACH(cpu) {
1208         cpu->stop = true;
1209         qemu_cpu_kick(cpu);
1210     }
1211
1212     if (qemu_in_vcpu_thread()) {
1213         cpu_stop_current();
1214         if (!kvm_enabled()) {
1215             CPU_FOREACH(cpu) {
1216                 cpu->stop = false;
1217                 cpu->stopped = true;
1218             }
1219             return;
1220         }
1221     }
1222
1223     while (!all_vcpus_paused()) {
1224         qemu_cond_wait(&qemu_pause_cond, &qemu_global_mutex);
1225         CPU_FOREACH(cpu) {
1226             qemu_cpu_kick(cpu);
1227         }
1228     }
1229 }
1230
1231 void cpu_resume(CPUState *cpu)
1232 {
1233     cpu->stop = false;
1234     cpu->stopped = false;
1235     qemu_cpu_kick(cpu);
1236 }
1237
1238 void resume_all_vcpus(void)
1239 {
1240     CPUState *cpu;
1241
1242     qemu_clock_enable(QEMU_CLOCK_VIRTUAL, true);
1243     CPU_FOREACH(cpu) {
1244         cpu_resume(cpu);
1245     }
1246 }
1247
1248 /* For temporary buffers for forming a name */
1249 #define VCPU_THREAD_NAME_SIZE 16
1250
1251 static void qemu_tcg_init_vcpu(CPUState *cpu)
1252 {
1253     char thread_name[VCPU_THREAD_NAME_SIZE];
1254
1255     tcg_cpu_address_space_init(cpu, cpu->as);
1256
1257     /* share a single thread for all cpus with TCG */
1258     if (!tcg_cpu_thread) {
1259         cpu->thread = g_malloc0(sizeof(QemuThread));
1260         cpu->halt_cond = g_malloc0(sizeof(QemuCond));
1261         qemu_cond_init(cpu->halt_cond);
1262         tcg_halt_cond = cpu->halt_cond;
1263         snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "CPU %d/TCG",
1264                  cpu->cpu_index);
1265         qemu_thread_create(cpu->thread, thread_name, qemu_tcg_cpu_thread_fn,
1266                            cpu, QEMU_THREAD_JOINABLE);
1267 #ifdef _WIN32
1268         cpu->hThread = qemu_thread_get_handle(cpu->thread);
1269 #endif
1270         while (!cpu->created) {
1271             qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
1272         }
1273         tcg_cpu_thread = cpu->thread;
1274     } else {
1275         cpu->thread = tcg_cpu_thread;
1276         cpu->halt_cond = tcg_halt_cond;
1277     }
1278 }
1279
1280 static void qemu_kvm_start_vcpu(CPUState *cpu)
1281 {
1282     char thread_name[VCPU_THREAD_NAME_SIZE];
1283
1284     cpu->thread = g_malloc0(sizeof(QemuThread));
1285     cpu->halt_cond = g_malloc0(sizeof(QemuCond));
1286     qemu_cond_init(cpu->halt_cond);
1287     snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "CPU %d/KVM",
1288              cpu->cpu_index);
1289     qemu_thread_create(cpu->thread, thread_name, qemu_kvm_cpu_thread_fn,
1290                        cpu, QEMU_THREAD_JOINABLE);
1291     while (!cpu->created) {
1292         qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
1293     }
1294 }
1295
1296 static void qemu_dummy_start_vcpu(CPUState *cpu)
1297 {
1298     char thread_name[VCPU_THREAD_NAME_SIZE];
1299
1300     cpu->thread = g_malloc0(sizeof(QemuThread));
1301     cpu->halt_cond = g_malloc0(sizeof(QemuCond));
1302     qemu_cond_init(cpu->halt_cond);
1303     snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "CPU %d/DUMMY",
1304              cpu->cpu_index);
1305     qemu_thread_create(cpu->thread, thread_name, qemu_dummy_cpu_thread_fn, cpu,
1306                        QEMU_THREAD_JOINABLE);
1307     while (!cpu->created) {
1308         qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
1309     }
1310 }
1311
1312 void qemu_init_vcpu(CPUState *cpu)
1313 {
1314     cpu->nr_cores = smp_cores;
1315     cpu->nr_threads = smp_threads;
1316     cpu->stopped = true;
1317     if (kvm_enabled()) {
1318         qemu_kvm_start_vcpu(cpu);
1319     } else if (tcg_enabled()) {
1320         qemu_tcg_init_vcpu(cpu);
1321     } else {
1322         qemu_dummy_start_vcpu(cpu);
1323     }
1324 }
1325
1326 void cpu_stop_current(void)
1327 {
1328     if (current_cpu) {
1329         current_cpu->stop = false;
1330         current_cpu->stopped = true;
1331         cpu_exit(current_cpu);
1332         qemu_cond_signal(&qemu_pause_cond);
1333     }
1334 }
1335
1336 int vm_stop(RunState state)
1337 {
1338     if (qemu_in_vcpu_thread()) {
1339         qemu_system_vmstop_request_prepare();
1340         qemu_system_vmstop_request(state);
1341         /*
1342          * FIXME: should not return to device code in case
1343          * vm_stop() has been requested.
1344          */
1345         cpu_stop_current();
1346         return 0;
1347     }
1348
1349     return do_vm_stop(state);
1350 }
1351
1352 /* does a state transition even if the VM is already stopped,
1353    current state is forgotten forever */
1354 int vm_stop_force_state(RunState state)
1355 {
1356     if (runstate_is_running()) {
1357         return vm_stop(state);
1358     } else {
1359         runstate_set(state);
1360         /* Make sure to return an error if the flush in a previous vm_stop()
1361          * failed. */
1362         return bdrv_flush_all();
1363     }
1364 }
1365
1366 static int tcg_cpu_exec(CPUState *cpu)
1367 {
1368     int ret;
1369 #ifdef CONFIG_PROFILER
1370     int64_t ti;
1371 #endif
1372
1373 #ifdef CONFIG_PROFILER
1374     ti = profile_getclock();
1375 #endif
1376     if (use_icount) {
1377         int64_t count;
1378         int64_t deadline;
1379         int decr;
1380         timers_state.qemu_icount -= (cpu->icount_decr.u16.low
1381                                     + cpu->icount_extra);
1382         cpu->icount_decr.u16.low = 0;
1383         cpu->icount_extra = 0;
1384         deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL);
1385
1386         /* Maintain prior (possibly buggy) behaviour where if no deadline
1387          * was set (as there is no QEMU_CLOCK_VIRTUAL timer) or it is more than
1388          * INT32_MAX nanoseconds ahead, we still use INT32_MAX
1389          * nanoseconds.
1390          */
1391         if ((deadline < 0) || (deadline > INT32_MAX)) {
1392             deadline = INT32_MAX;
1393         }
1394
1395         count = qemu_icount_round(deadline);
1396         timers_state.qemu_icount += count;
1397         decr = (count > 0xffff) ? 0xffff : count;
1398         count -= decr;
1399         cpu->icount_decr.u16.low = decr;
1400         cpu->icount_extra = count;
1401     }
1402     ret = cpu_exec(cpu);
1403 #ifdef CONFIG_PROFILER
1404     tcg_time += profile_getclock() - ti;
1405 #endif
1406     if (use_icount) {
1407         /* Fold pending instructions back into the
1408            instruction counter, and clear the interrupt flag.  */
1409         timers_state.qemu_icount -= (cpu->icount_decr.u16.low
1410                         + cpu->icount_extra);
1411         cpu->icount_decr.u32 = 0;
1412         cpu->icount_extra = 0;
1413     }
1414     return ret;
1415 }
1416
1417 static void tcg_exec_all(void)
1418 {
1419     int r;
1420
1421     /* Account partial waits to QEMU_CLOCK_VIRTUAL.  */
1422     qemu_clock_warp(QEMU_CLOCK_VIRTUAL);
1423
1424     if (next_cpu == NULL) {
1425         next_cpu = first_cpu;
1426     }
1427     for (; next_cpu != NULL && !exit_request; next_cpu = CPU_NEXT(next_cpu)) {
1428         CPUState *cpu = next_cpu;
1429
1430         qemu_clock_enable(QEMU_CLOCK_VIRTUAL,
1431                           (cpu->singlestep_enabled & SSTEP_NOTIMER) == 0);
1432
1433         if (cpu_can_run(cpu)) {
1434             r = tcg_cpu_exec(cpu);
1435             if (r == EXCP_DEBUG) {
1436                 cpu_handle_guest_debug(cpu);
1437                 break;
1438             }
1439         } else if (cpu->stop || cpu->stopped) {
1440             break;
1441         }
1442     }
1443     exit_request = 0;
1444 }
1445
1446 void list_cpus(FILE *f, fprintf_function cpu_fprintf, const char *optarg)
1447 {
1448     /* XXX: implement xxx_cpu_list for targets that still miss it */
1449 #if defined(cpu_list)
1450     cpu_list(f, cpu_fprintf);
1451 #endif
1452 }
1453
1454 CpuInfoList *qmp_query_cpus(Error **errp)
1455 {
1456     CpuInfoList *head = NULL, *cur_item = NULL;
1457     CPUState *cpu;
1458
1459     CPU_FOREACH(cpu) {
1460         CpuInfoList *info;
1461 #if defined(TARGET_I386)
1462         X86CPU *x86_cpu = X86_CPU(cpu);
1463         CPUX86State *env = &x86_cpu->env;
1464 #elif defined(TARGET_PPC)
1465         PowerPCCPU *ppc_cpu = POWERPC_CPU(cpu);
1466         CPUPPCState *env = &ppc_cpu->env;
1467 #elif defined(TARGET_SPARC)
1468         SPARCCPU *sparc_cpu = SPARC_CPU(cpu);
1469         CPUSPARCState *env = &sparc_cpu->env;
1470 #elif defined(TARGET_MIPS)
1471         MIPSCPU *mips_cpu = MIPS_CPU(cpu);
1472         CPUMIPSState *env = &mips_cpu->env;
1473 #elif defined(TARGET_TRICORE)
1474         TriCoreCPU *tricore_cpu = TRICORE_CPU(cpu);
1475         CPUTriCoreState *env = &tricore_cpu->env;
1476 #endif
1477
1478         cpu_synchronize_state(cpu);
1479
1480         info = g_malloc0(sizeof(*info));
1481         info->value = g_malloc0(sizeof(*info->value));
1482         info->value->CPU = cpu->cpu_index;
1483         info->value->current = (cpu == first_cpu);
1484         info->value->halted = cpu->halted;
1485         info->value->qom_path = object_get_canonical_path(OBJECT(cpu));
1486         info->value->thread_id = cpu->thread_id;
1487 #if defined(TARGET_I386)
1488         info->value->has_pc = true;
1489         info->value->pc = env->eip + env->segs[R_CS].base;
1490 #elif defined(TARGET_PPC)
1491         info->value->has_nip = true;
1492         info->value->nip = env->nip;
1493 #elif defined(TARGET_SPARC)
1494         info->value->has_pc = true;
1495         info->value->pc = env->pc;
1496         info->value->has_npc = true;
1497         info->value->npc = env->npc;
1498 #elif defined(TARGET_MIPS)
1499         info->value->has_PC = true;
1500         info->value->PC = env->active_tc.PC;
1501 #elif defined(TARGET_TRICORE)
1502         info->value->has_PC = true;
1503         info->value->PC = env->PC;
1504 #endif
1505
1506         /* XXX: waiting for the qapi to support GSList */
1507         if (!cur_item) {
1508             head = cur_item = info;
1509         } else {
1510             cur_item->next = info;
1511             cur_item = info;
1512         }
1513     }
1514
1515     return head;
1516 }
1517
1518 void qmp_memsave(int64_t addr, int64_t size, const char *filename,
1519                  bool has_cpu, int64_t cpu_index, Error **errp)
1520 {
1521     FILE *f;
1522     uint32_t l;
1523     CPUState *cpu;
1524     uint8_t buf[1024];
1525     int64_t orig_addr = addr, orig_size = size;
1526
1527     if (!has_cpu) {
1528         cpu_index = 0;
1529     }
1530
1531     cpu = qemu_get_cpu(cpu_index);
1532     if (cpu == NULL) {
1533         error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "cpu-index",
1534                    "a CPU number");
1535         return;
1536     }
1537
1538     f = fopen(filename, "wb");
1539     if (!f) {
1540         error_setg_file_open(errp, errno, filename);
1541         return;
1542     }
1543
1544     while (size != 0) {
1545         l = sizeof(buf);
1546         if (l > size)
1547             l = size;
1548         if (cpu_memory_rw_debug(cpu, addr, buf, l, 0) != 0) {
1549             error_setg(errp, "Invalid addr 0x%016" PRIx64 "/size %" PRId64
1550                              " specified", orig_addr, orig_size);
1551             goto exit;
1552         }
1553         if (fwrite(buf, 1, l, f) != l) {
1554             error_setg(errp, QERR_IO_ERROR);
1555             goto exit;
1556         }
1557         addr += l;
1558         size -= l;
1559     }
1560
1561 exit:
1562     fclose(f);
1563 }
1564
1565 void qmp_pmemsave(int64_t addr, int64_t size, const char *filename,
1566                   Error **errp)
1567 {
1568     FILE *f;
1569     uint32_t l;
1570     uint8_t buf[1024];
1571
1572     f = fopen(filename, "wb");
1573     if (!f) {
1574         error_setg_file_open(errp, errno, filename);
1575         return;
1576     }
1577
1578     while (size != 0) {
1579         l = sizeof(buf);
1580         if (l > size)
1581             l = size;
1582         cpu_physical_memory_read(addr, buf, l);
1583         if (fwrite(buf, 1, l, f) != l) {
1584             error_setg(errp, QERR_IO_ERROR);
1585             goto exit;
1586         }
1587         addr += l;
1588         size -= l;
1589     }
1590
1591 exit:
1592     fclose(f);
1593 }
1594
1595 void qmp_inject_nmi(Error **errp)
1596 {
1597 #if defined(TARGET_I386)
1598     CPUState *cs;
1599
1600     CPU_FOREACH(cs) {
1601         X86CPU *cpu = X86_CPU(cs);
1602
1603         if (!cpu->apic_state) {
1604             cpu_interrupt(cs, CPU_INTERRUPT_NMI);
1605         } else {
1606             apic_deliver_nmi(cpu->apic_state);
1607         }
1608     }
1609 #else
1610     nmi_monitor_handle(monitor_get_cpu_index(), errp);
1611 #endif
1612 }
1613
1614 void dump_drift_info(FILE *f, fprintf_function cpu_fprintf)
1615 {
1616     if (!use_icount) {
1617         return;
1618     }
1619
1620     cpu_fprintf(f, "Host - Guest clock  %"PRIi64" ms\n",
1621                 (cpu_get_clock() - cpu_get_icount())/SCALE_MS);
1622     if (icount_align_option) {
1623         cpu_fprintf(f, "Max guest delay     %"PRIi64" ms\n", -max_delay/SCALE_MS);
1624         cpu_fprintf(f, "Max guest advance   %"PRIi64" ms\n", max_advance/SCALE_MS);
1625     } else {
1626         cpu_fprintf(f, "Max guest delay     NA\n");
1627         cpu_fprintf(f, "Max guest advance   NA\n");
1628     }
1629 }