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