]> Git Repo - qemu.git/blob - cpus.c
zynq_slcr: Fixed ResetValues enum
[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.h"
29 #include "sysemu.h"
30 #include "gdbstub.h"
31 #include "dma.h"
32 #include "kvm.h"
33 #include "qmp-commands.h"
34
35 #include "qemu-thread.h"
36 #include "cpus.h"
37 #include "qtest.h"
38 #include "main-loop.h"
39 #include "bitmap.h"
40
41 #ifndef _WIN32
42 #include "compatfd.h"
43 #endif
44
45 #ifdef CONFIG_LINUX
46
47 #include <sys/prctl.h>
48
49 #ifndef PR_MCE_KILL
50 #define PR_MCE_KILL 33
51 #endif
52
53 #ifndef PR_MCE_KILL_SET
54 #define PR_MCE_KILL_SET 1
55 #endif
56
57 #ifndef PR_MCE_KILL_EARLY
58 #define PR_MCE_KILL_EARLY 1
59 #endif
60
61 #endif /* CONFIG_LINUX */
62
63 static CPUArchState *next_cpu;
64
65 static bool cpu_thread_is_idle(CPUArchState *env)
66 {
67     if (env->stop || env->queued_work_first) {
68         return false;
69     }
70     if (env->stopped || !runstate_is_running()) {
71         return true;
72     }
73     if (!env->halted || qemu_cpu_has_work(env) ||
74         kvm_async_interrupts_enabled()) {
75         return false;
76     }
77     return true;
78 }
79
80 static bool all_cpu_threads_idle(void)
81 {
82     CPUArchState *env;
83
84     for (env = first_cpu; env != NULL; env = env->next_cpu) {
85         if (!cpu_thread_is_idle(env)) {
86             return false;
87         }
88     }
89     return true;
90 }
91
92 /***********************************************************/
93 /* guest cycle counter */
94
95 /* Conversion factor from emulated instructions to virtual clock ticks.  */
96 static int icount_time_shift;
97 /* Arbitrarily pick 1MIPS as the minimum allowable speed.  */
98 #define MAX_ICOUNT_SHIFT 10
99 /* Compensate for varying guest execution speed.  */
100 static int64_t qemu_icount_bias;
101 static QEMUTimer *icount_rt_timer;
102 static QEMUTimer *icount_vm_timer;
103 static QEMUTimer *icount_warp_timer;
104 static int64_t vm_clock_warp_start;
105 static int64_t qemu_icount;
106
107 typedef struct TimersState {
108     int64_t cpu_ticks_prev;
109     int64_t cpu_ticks_offset;
110     int64_t cpu_clock_offset;
111     int32_t cpu_ticks_enabled;
112     int64_t dummy;
113 } TimersState;
114
115 TimersState timers_state;
116
117 /* Return the virtual CPU time, based on the instruction counter.  */
118 int64_t cpu_get_icount(void)
119 {
120     int64_t icount;
121     CPUArchState *env = cpu_single_env;
122
123     icount = qemu_icount;
124     if (env) {
125         if (!can_do_io(env)) {
126             fprintf(stderr, "Bad clock read\n");
127         }
128         icount -= (env->icount_decr.u16.low + env->icount_extra);
129     }
130     return qemu_icount_bias + (icount << icount_time_shift);
131 }
132
133 /* return the host CPU cycle counter and handle stop/restart */
134 int64_t cpu_get_ticks(void)
135 {
136     if (use_icount) {
137         return cpu_get_icount();
138     }
139     if (!timers_state.cpu_ticks_enabled) {
140         return timers_state.cpu_ticks_offset;
141     } else {
142         int64_t ticks;
143         ticks = cpu_get_real_ticks();
144         if (timers_state.cpu_ticks_prev > ticks) {
145             /* Note: non increasing ticks may happen if the host uses
146                software suspend */
147             timers_state.cpu_ticks_offset += timers_state.cpu_ticks_prev - ticks;
148         }
149         timers_state.cpu_ticks_prev = ticks;
150         return ticks + timers_state.cpu_ticks_offset;
151     }
152 }
153
154 /* return the host CPU monotonic timer and handle stop/restart */
155 int64_t cpu_get_clock(void)
156 {
157     int64_t ti;
158     if (!timers_state.cpu_ticks_enabled) {
159         return timers_state.cpu_clock_offset;
160     } else {
161         ti = get_clock();
162         return ti + timers_state.cpu_clock_offset;
163     }
164 }
165
166 /* enable cpu_get_ticks() */
167 void cpu_enable_ticks(void)
168 {
169     if (!timers_state.cpu_ticks_enabled) {
170         timers_state.cpu_ticks_offset -= cpu_get_real_ticks();
171         timers_state.cpu_clock_offset -= get_clock();
172         timers_state.cpu_ticks_enabled = 1;
173     }
174 }
175
176 /* disable cpu_get_ticks() : the clock is stopped. You must not call
177    cpu_get_ticks() after that.  */
178 void cpu_disable_ticks(void)
179 {
180     if (timers_state.cpu_ticks_enabled) {
181         timers_state.cpu_ticks_offset = cpu_get_ticks();
182         timers_state.cpu_clock_offset = cpu_get_clock();
183         timers_state.cpu_ticks_enabled = 0;
184     }
185 }
186
187 /* Correlation between real and virtual time is always going to be
188    fairly approximate, so ignore small variation.
189    When the guest is idle real and virtual time will be aligned in
190    the IO wait loop.  */
191 #define ICOUNT_WOBBLE (get_ticks_per_sec() / 10)
192
193 static void icount_adjust(void)
194 {
195     int64_t cur_time;
196     int64_t cur_icount;
197     int64_t delta;
198     static int64_t last_delta;
199     /* If the VM is not running, then do nothing.  */
200     if (!runstate_is_running()) {
201         return;
202     }
203     cur_time = cpu_get_clock();
204     cur_icount = qemu_get_clock_ns(vm_clock);
205     delta = cur_icount - cur_time;
206     /* FIXME: This is a very crude algorithm, somewhat prone to oscillation.  */
207     if (delta > 0
208         && last_delta + ICOUNT_WOBBLE < delta * 2
209         && icount_time_shift > 0) {
210         /* The guest is getting too far ahead.  Slow time down.  */
211         icount_time_shift--;
212     }
213     if (delta < 0
214         && last_delta - ICOUNT_WOBBLE > delta * 2
215         && icount_time_shift < MAX_ICOUNT_SHIFT) {
216         /* The guest is getting too far behind.  Speed time up.  */
217         icount_time_shift++;
218     }
219     last_delta = delta;
220     qemu_icount_bias = cur_icount - (qemu_icount << icount_time_shift);
221 }
222
223 static void icount_adjust_rt(void *opaque)
224 {
225     qemu_mod_timer(icount_rt_timer,
226                    qemu_get_clock_ms(rt_clock) + 1000);
227     icount_adjust();
228 }
229
230 static void icount_adjust_vm(void *opaque)
231 {
232     qemu_mod_timer(icount_vm_timer,
233                    qemu_get_clock_ns(vm_clock) + get_ticks_per_sec() / 10);
234     icount_adjust();
235 }
236
237 static int64_t qemu_icount_round(int64_t count)
238 {
239     return (count + (1 << icount_time_shift) - 1) >> icount_time_shift;
240 }
241
242 static void icount_warp_rt(void *opaque)
243 {
244     if (vm_clock_warp_start == -1) {
245         return;
246     }
247
248     if (runstate_is_running()) {
249         int64_t clock = qemu_get_clock_ns(rt_clock);
250         int64_t warp_delta = clock - vm_clock_warp_start;
251         if (use_icount == 1) {
252             qemu_icount_bias += warp_delta;
253         } else {
254             /*
255              * In adaptive mode, do not let the vm_clock run too
256              * far ahead of real time.
257              */
258             int64_t cur_time = cpu_get_clock();
259             int64_t cur_icount = qemu_get_clock_ns(vm_clock);
260             int64_t delta = cur_time - cur_icount;
261             qemu_icount_bias += MIN(warp_delta, delta);
262         }
263         if (qemu_clock_expired(vm_clock)) {
264             qemu_notify_event();
265         }
266     }
267     vm_clock_warp_start = -1;
268 }
269
270 void qtest_clock_warp(int64_t dest)
271 {
272     int64_t clock = qemu_get_clock_ns(vm_clock);
273     assert(qtest_enabled());
274     while (clock < dest) {
275         int64_t deadline = qemu_clock_deadline(vm_clock);
276         int64_t warp = MIN(dest - clock, deadline);
277         qemu_icount_bias += warp;
278         qemu_run_timers(vm_clock);
279         clock = qemu_get_clock_ns(vm_clock);
280     }
281     qemu_notify_event();
282 }
283
284 void qemu_clock_warp(QEMUClock *clock)
285 {
286     int64_t deadline;
287
288     /*
289      * There are too many global variables to make the "warp" behavior
290      * applicable to other clocks.  But a clock argument removes the
291      * need for if statements all over the place.
292      */
293     if (clock != vm_clock || !use_icount) {
294         return;
295     }
296
297     /*
298      * If the CPUs have been sleeping, advance the vm_clock timer now.  This
299      * ensures that the deadline for the timer is computed correctly below.
300      * This also makes sure that the insn counter is synchronized before the
301      * CPU starts running, in case the CPU is woken by an event other than
302      * the earliest vm_clock timer.
303      */
304     icount_warp_rt(NULL);
305     if (!all_cpu_threads_idle() || !qemu_clock_has_timers(vm_clock)) {
306         qemu_del_timer(icount_warp_timer);
307         return;
308     }
309
310     if (qtest_enabled()) {
311         /* When testing, qtest commands advance icount.  */
312         return;
313     }
314
315     vm_clock_warp_start = qemu_get_clock_ns(rt_clock);
316     deadline = qemu_clock_deadline(vm_clock);
317     if (deadline > 0) {
318         /*
319          * Ensure the vm_clock proceeds even when the virtual CPU goes to
320          * sleep.  Otherwise, the CPU might be waiting for a future timer
321          * interrupt to wake it up, but the interrupt never comes because
322          * the vCPU isn't running any insns and thus doesn't advance the
323          * vm_clock.
324          *
325          * An extreme solution for this problem would be to never let VCPUs
326          * sleep in icount mode if there is a pending vm_clock timer; rather
327          * time could just advance to the next vm_clock event.  Instead, we
328          * do stop VCPUs and only advance vm_clock after some "real" time,
329          * (related to the time left until the next event) has passed.  This
330          * rt_clock timer will do this.  This avoids that the warps are too
331          * visible externally---for example, you will not be sending network
332          * packets continuously instead of every 100ms.
333          */
334         qemu_mod_timer(icount_warp_timer, vm_clock_warp_start + deadline);
335     } else {
336         qemu_notify_event();
337     }
338 }
339
340 static const VMStateDescription vmstate_timers = {
341     .name = "timer",
342     .version_id = 2,
343     .minimum_version_id = 1,
344     .minimum_version_id_old = 1,
345     .fields      = (VMStateField[]) {
346         VMSTATE_INT64(cpu_ticks_offset, TimersState),
347         VMSTATE_INT64(dummy, TimersState),
348         VMSTATE_INT64_V(cpu_clock_offset, TimersState, 2),
349         VMSTATE_END_OF_LIST()
350     }
351 };
352
353 void configure_icount(const char *option)
354 {
355     vmstate_register(NULL, 0, &vmstate_timers, &timers_state);
356     if (!option) {
357         return;
358     }
359
360     icount_warp_timer = qemu_new_timer_ns(rt_clock, icount_warp_rt, NULL);
361     if (strcmp(option, "auto") != 0) {
362         icount_time_shift = strtol(option, NULL, 0);
363         use_icount = 1;
364         return;
365     }
366
367     use_icount = 2;
368
369     /* 125MIPS seems a reasonable initial guess at the guest speed.
370        It will be corrected fairly quickly anyway.  */
371     icount_time_shift = 3;
372
373     /* Have both realtime and virtual time triggers for speed adjustment.
374        The realtime trigger catches emulated time passing too slowly,
375        the virtual time trigger catches emulated time passing too fast.
376        Realtime triggers occur even when idle, so use them less frequently
377        than VM triggers.  */
378     icount_rt_timer = qemu_new_timer_ms(rt_clock, icount_adjust_rt, NULL);
379     qemu_mod_timer(icount_rt_timer,
380                    qemu_get_clock_ms(rt_clock) + 1000);
381     icount_vm_timer = qemu_new_timer_ns(vm_clock, icount_adjust_vm, NULL);
382     qemu_mod_timer(icount_vm_timer,
383                    qemu_get_clock_ns(vm_clock) + get_ticks_per_sec() / 10);
384 }
385
386 /***********************************************************/
387 void hw_error(const char *fmt, ...)
388 {
389     va_list ap;
390     CPUArchState *env;
391
392     va_start(ap, fmt);
393     fprintf(stderr, "qemu: hardware error: ");
394     vfprintf(stderr, fmt, ap);
395     fprintf(stderr, "\n");
396     for(env = first_cpu; env != NULL; env = env->next_cpu) {
397         fprintf(stderr, "CPU #%d:\n", env->cpu_index);
398         cpu_dump_state(env, stderr, fprintf, CPU_DUMP_FPU);
399     }
400     va_end(ap);
401     abort();
402 }
403
404 void cpu_synchronize_all_states(void)
405 {
406     CPUArchState *cpu;
407
408     for (cpu = first_cpu; cpu; cpu = cpu->next_cpu) {
409         cpu_synchronize_state(cpu);
410     }
411 }
412
413 void cpu_synchronize_all_post_reset(void)
414 {
415     CPUArchState *cpu;
416
417     for (cpu = first_cpu; cpu; cpu = cpu->next_cpu) {
418         cpu_synchronize_post_reset(cpu);
419     }
420 }
421
422 void cpu_synchronize_all_post_init(void)
423 {
424     CPUArchState *cpu;
425
426     for (cpu = first_cpu; cpu; cpu = cpu->next_cpu) {
427         cpu_synchronize_post_init(cpu);
428     }
429 }
430
431 int cpu_is_stopped(CPUArchState *env)
432 {
433     return !runstate_is_running() || env->stopped;
434 }
435
436 static void do_vm_stop(RunState state)
437 {
438     if (runstate_is_running()) {
439         cpu_disable_ticks();
440         pause_all_vcpus();
441         runstate_set(state);
442         vm_state_notify(0, state);
443         bdrv_drain_all();
444         bdrv_flush_all();
445         monitor_protocol_event(QEVENT_STOP, NULL);
446     }
447 }
448
449 static int cpu_can_run(CPUArchState *env)
450 {
451     if (env->stop) {
452         return 0;
453     }
454     if (env->stopped || !runstate_is_running()) {
455         return 0;
456     }
457     return 1;
458 }
459
460 static void cpu_handle_guest_debug(CPUArchState *env)
461 {
462     gdb_set_stop_cpu(env);
463     qemu_system_debug_request();
464     env->stopped = 1;
465 }
466
467 static void cpu_signal(int sig)
468 {
469     if (cpu_single_env) {
470         cpu_exit(cpu_single_env);
471     }
472     exit_request = 1;
473 }
474
475 #ifdef CONFIG_LINUX
476 static void sigbus_reraise(void)
477 {
478     sigset_t set;
479     struct sigaction action;
480
481     memset(&action, 0, sizeof(action));
482     action.sa_handler = SIG_DFL;
483     if (!sigaction(SIGBUS, &action, NULL)) {
484         raise(SIGBUS);
485         sigemptyset(&set);
486         sigaddset(&set, SIGBUS);
487         sigprocmask(SIG_UNBLOCK, &set, NULL);
488     }
489     perror("Failed to re-raise SIGBUS!\n");
490     abort();
491 }
492
493 static void sigbus_handler(int n, struct qemu_signalfd_siginfo *siginfo,
494                            void *ctx)
495 {
496     if (kvm_on_sigbus(siginfo->ssi_code,
497                       (void *)(intptr_t)siginfo->ssi_addr)) {
498         sigbus_reraise();
499     }
500 }
501
502 static void qemu_init_sigbus(void)
503 {
504     struct sigaction action;
505
506     memset(&action, 0, sizeof(action));
507     action.sa_flags = SA_SIGINFO;
508     action.sa_sigaction = (void (*)(int, siginfo_t*, void*))sigbus_handler;
509     sigaction(SIGBUS, &action, NULL);
510
511     prctl(PR_MCE_KILL, PR_MCE_KILL_SET, PR_MCE_KILL_EARLY, 0, 0);
512 }
513
514 static void qemu_kvm_eat_signals(CPUArchState *env)
515 {
516     struct timespec ts = { 0, 0 };
517     siginfo_t siginfo;
518     sigset_t waitset;
519     sigset_t chkset;
520     int r;
521
522     sigemptyset(&waitset);
523     sigaddset(&waitset, SIG_IPI);
524     sigaddset(&waitset, SIGBUS);
525
526     do {
527         r = sigtimedwait(&waitset, &siginfo, &ts);
528         if (r == -1 && !(errno == EAGAIN || errno == EINTR)) {
529             perror("sigtimedwait");
530             exit(1);
531         }
532
533         switch (r) {
534         case SIGBUS:
535             if (kvm_on_sigbus_vcpu(env, siginfo.si_code, siginfo.si_addr)) {
536                 sigbus_reraise();
537             }
538             break;
539         default:
540             break;
541         }
542
543         r = sigpending(&chkset);
544         if (r == -1) {
545             perror("sigpending");
546             exit(1);
547         }
548     } while (sigismember(&chkset, SIG_IPI) || sigismember(&chkset, SIGBUS));
549 }
550
551 #else /* !CONFIG_LINUX */
552
553 static void qemu_init_sigbus(void)
554 {
555 }
556
557 static void qemu_kvm_eat_signals(CPUArchState *env)
558 {
559 }
560 #endif /* !CONFIG_LINUX */
561
562 #ifndef _WIN32
563 static void dummy_signal(int sig)
564 {
565 }
566
567 static void qemu_kvm_init_cpu_signals(CPUArchState *env)
568 {
569     int r;
570     sigset_t set;
571     struct sigaction sigact;
572
573     memset(&sigact, 0, sizeof(sigact));
574     sigact.sa_handler = dummy_signal;
575     sigaction(SIG_IPI, &sigact, NULL);
576
577     pthread_sigmask(SIG_BLOCK, NULL, &set);
578     sigdelset(&set, SIG_IPI);
579     sigdelset(&set, SIGBUS);
580     r = kvm_set_signal_mask(env, &set);
581     if (r) {
582         fprintf(stderr, "kvm_set_signal_mask: %s\n", strerror(-r));
583         exit(1);
584     }
585 }
586
587 static void qemu_tcg_init_cpu_signals(void)
588 {
589     sigset_t set;
590     struct sigaction sigact;
591
592     memset(&sigact, 0, sizeof(sigact));
593     sigact.sa_handler = cpu_signal;
594     sigaction(SIG_IPI, &sigact, NULL);
595
596     sigemptyset(&set);
597     sigaddset(&set, SIG_IPI);
598     pthread_sigmask(SIG_UNBLOCK, &set, NULL);
599 }
600
601 #else /* _WIN32 */
602 static void qemu_kvm_init_cpu_signals(CPUArchState *env)
603 {
604     abort();
605 }
606
607 static void qemu_tcg_init_cpu_signals(void)
608 {
609 }
610 #endif /* _WIN32 */
611
612 static QemuMutex qemu_global_mutex;
613 static QemuCond qemu_io_proceeded_cond;
614 static bool iothread_requesting_mutex;
615
616 static QemuThread io_thread;
617
618 static QemuThread *tcg_cpu_thread;
619 static QemuCond *tcg_halt_cond;
620
621 /* cpu creation */
622 static QemuCond qemu_cpu_cond;
623 /* system init */
624 static QemuCond qemu_pause_cond;
625 static QemuCond qemu_work_cond;
626
627 void qemu_init_cpu_loop(void)
628 {
629     qemu_init_sigbus();
630     qemu_cond_init(&qemu_cpu_cond);
631     qemu_cond_init(&qemu_pause_cond);
632     qemu_cond_init(&qemu_work_cond);
633     qemu_cond_init(&qemu_io_proceeded_cond);
634     qemu_mutex_init(&qemu_global_mutex);
635
636     qemu_thread_get_self(&io_thread);
637 }
638
639 void run_on_cpu(CPUArchState *env, void (*func)(void *data), void *data)
640 {
641     struct qemu_work_item wi;
642
643     if (qemu_cpu_is_self(env)) {
644         func(data);
645         return;
646     }
647
648     wi.func = func;
649     wi.data = data;
650     if (!env->queued_work_first) {
651         env->queued_work_first = &wi;
652     } else {
653         env->queued_work_last->next = &wi;
654     }
655     env->queued_work_last = &wi;
656     wi.next = NULL;
657     wi.done = false;
658
659     qemu_cpu_kick(env);
660     while (!wi.done) {
661         CPUArchState *self_env = cpu_single_env;
662
663         qemu_cond_wait(&qemu_work_cond, &qemu_global_mutex);
664         cpu_single_env = self_env;
665     }
666 }
667
668 static void flush_queued_work(CPUArchState *env)
669 {
670     struct qemu_work_item *wi;
671
672     if (!env->queued_work_first) {
673         return;
674     }
675
676     while ((wi = env->queued_work_first)) {
677         env->queued_work_first = wi->next;
678         wi->func(wi->data);
679         wi->done = true;
680     }
681     env->queued_work_last = NULL;
682     qemu_cond_broadcast(&qemu_work_cond);
683 }
684
685 static void qemu_wait_io_event_common(CPUArchState *env)
686 {
687     CPUState *cpu = ENV_GET_CPU(env);
688
689     if (env->stop) {
690         env->stop = 0;
691         env->stopped = 1;
692         qemu_cond_signal(&qemu_pause_cond);
693     }
694     flush_queued_work(env);
695     cpu->thread_kicked = false;
696 }
697
698 static void qemu_tcg_wait_io_event(void)
699 {
700     CPUArchState *env;
701
702     while (all_cpu_threads_idle()) {
703        /* Start accounting real time to the virtual clock if the CPUs
704           are idle.  */
705         qemu_clock_warp(vm_clock);
706         qemu_cond_wait(tcg_halt_cond, &qemu_global_mutex);
707     }
708
709     while (iothread_requesting_mutex) {
710         qemu_cond_wait(&qemu_io_proceeded_cond, &qemu_global_mutex);
711     }
712
713     for (env = first_cpu; env != NULL; env = env->next_cpu) {
714         qemu_wait_io_event_common(env);
715     }
716 }
717
718 static void qemu_kvm_wait_io_event(CPUArchState *env)
719 {
720     while (cpu_thread_is_idle(env)) {
721         qemu_cond_wait(env->halt_cond, &qemu_global_mutex);
722     }
723
724     qemu_kvm_eat_signals(env);
725     qemu_wait_io_event_common(env);
726 }
727
728 static void *qemu_kvm_cpu_thread_fn(void *arg)
729 {
730     CPUArchState *env = arg;
731     CPUState *cpu = ENV_GET_CPU(env);
732     int r;
733
734     qemu_mutex_lock(&qemu_global_mutex);
735     qemu_thread_get_self(cpu->thread);
736     env->thread_id = qemu_get_thread_id();
737     cpu_single_env = env;
738
739     r = kvm_init_vcpu(env);
740     if (r < 0) {
741         fprintf(stderr, "kvm_init_vcpu failed: %s\n", strerror(-r));
742         exit(1);
743     }
744
745     qemu_kvm_init_cpu_signals(env);
746
747     /* signal CPU creation */
748     env->created = 1;
749     qemu_cond_signal(&qemu_cpu_cond);
750
751     while (1) {
752         if (cpu_can_run(env)) {
753             r = kvm_cpu_exec(env);
754             if (r == EXCP_DEBUG) {
755                 cpu_handle_guest_debug(env);
756             }
757         }
758         qemu_kvm_wait_io_event(env);
759     }
760
761     return NULL;
762 }
763
764 static void *qemu_dummy_cpu_thread_fn(void *arg)
765 {
766 #ifdef _WIN32
767     fprintf(stderr, "qtest is not supported under Windows\n");
768     exit(1);
769 #else
770     CPUArchState *env = arg;
771     CPUState *cpu = ENV_GET_CPU(env);
772     sigset_t waitset;
773     int r;
774
775     qemu_mutex_lock_iothread();
776     qemu_thread_get_self(cpu->thread);
777     env->thread_id = qemu_get_thread_id();
778
779     sigemptyset(&waitset);
780     sigaddset(&waitset, SIG_IPI);
781
782     /* signal CPU creation */
783     env->created = 1;
784     qemu_cond_signal(&qemu_cpu_cond);
785
786     cpu_single_env = env;
787     while (1) {
788         cpu_single_env = NULL;
789         qemu_mutex_unlock_iothread();
790         do {
791             int sig;
792             r = sigwait(&waitset, &sig);
793         } while (r == -1 && (errno == EAGAIN || errno == EINTR));
794         if (r == -1) {
795             perror("sigwait");
796             exit(1);
797         }
798         qemu_mutex_lock_iothread();
799         cpu_single_env = env;
800         qemu_wait_io_event_common(env);
801     }
802
803     return NULL;
804 #endif
805 }
806
807 static void tcg_exec_all(void);
808
809 static void *qemu_tcg_cpu_thread_fn(void *arg)
810 {
811     CPUArchState *env = arg;
812     CPUState *cpu = ENV_GET_CPU(env);
813
814     qemu_tcg_init_cpu_signals();
815     qemu_thread_get_self(cpu->thread);
816
817     /* signal CPU creation */
818     qemu_mutex_lock(&qemu_global_mutex);
819     for (env = first_cpu; env != NULL; env = env->next_cpu) {
820         env->thread_id = qemu_get_thread_id();
821         env->created = 1;
822     }
823     qemu_cond_signal(&qemu_cpu_cond);
824
825     /* wait for initial kick-off after machine start */
826     while (first_cpu->stopped) {
827         qemu_cond_wait(tcg_halt_cond, &qemu_global_mutex);
828
829         /* process any pending work */
830         for (env = first_cpu; env != NULL; env = env->next_cpu) {
831             qemu_wait_io_event_common(env);
832         }
833     }
834
835     while (1) {
836         tcg_exec_all();
837         if (use_icount && qemu_clock_deadline(vm_clock) <= 0) {
838             qemu_notify_event();
839         }
840         qemu_tcg_wait_io_event();
841     }
842
843     return NULL;
844 }
845
846 static void qemu_cpu_kick_thread(CPUArchState *env)
847 {
848     CPUState *cpu = ENV_GET_CPU(env);
849 #ifndef _WIN32
850     int err;
851
852     err = pthread_kill(cpu->thread->thread, SIG_IPI);
853     if (err) {
854         fprintf(stderr, "qemu:%s: %s", __func__, strerror(err));
855         exit(1);
856     }
857 #else /* _WIN32 */
858     if (!qemu_cpu_is_self(env)) {
859         SuspendThread(cpu->hThread);
860         cpu_signal(0);
861         ResumeThread(cpu->hThread);
862     }
863 #endif
864 }
865
866 void qemu_cpu_kick(void *_env)
867 {
868     CPUArchState *env = _env;
869     CPUState *cpu = ENV_GET_CPU(env);
870
871     qemu_cond_broadcast(env->halt_cond);
872     if (!tcg_enabled() && !cpu->thread_kicked) {
873         qemu_cpu_kick_thread(env);
874         cpu->thread_kicked = true;
875     }
876 }
877
878 void qemu_cpu_kick_self(void)
879 {
880 #ifndef _WIN32
881     assert(cpu_single_env);
882     CPUState *cpu_single_cpu = ENV_GET_CPU(cpu_single_env);
883
884     if (!cpu_single_cpu->thread_kicked) {
885         qemu_cpu_kick_thread(cpu_single_env);
886         cpu_single_cpu->thread_kicked = true;
887     }
888 #else
889     abort();
890 #endif
891 }
892
893 int qemu_cpu_is_self(void *_env)
894 {
895     CPUArchState *env = _env;
896     CPUState *cpu = ENV_GET_CPU(env);
897
898     return qemu_thread_is_self(cpu->thread);
899 }
900
901 void qemu_mutex_lock_iothread(void)
902 {
903     if (!tcg_enabled()) {
904         qemu_mutex_lock(&qemu_global_mutex);
905     } else {
906         iothread_requesting_mutex = true;
907         if (qemu_mutex_trylock(&qemu_global_mutex)) {
908             qemu_cpu_kick_thread(first_cpu);
909             qemu_mutex_lock(&qemu_global_mutex);
910         }
911         iothread_requesting_mutex = false;
912         qemu_cond_broadcast(&qemu_io_proceeded_cond);
913     }
914 }
915
916 void qemu_mutex_unlock_iothread(void)
917 {
918     qemu_mutex_unlock(&qemu_global_mutex);
919 }
920
921 static int all_vcpus_paused(void)
922 {
923     CPUArchState *penv = first_cpu;
924
925     while (penv) {
926         if (!penv->stopped) {
927             return 0;
928         }
929         penv = penv->next_cpu;
930     }
931
932     return 1;
933 }
934
935 void pause_all_vcpus(void)
936 {
937     CPUArchState *penv = first_cpu;
938
939     qemu_clock_enable(vm_clock, false);
940     while (penv) {
941         penv->stop = 1;
942         qemu_cpu_kick(penv);
943         penv = penv->next_cpu;
944     }
945
946     if (!qemu_thread_is_self(&io_thread)) {
947         cpu_stop_current();
948         if (!kvm_enabled()) {
949             while (penv) {
950                 penv->stop = 0;
951                 penv->stopped = 1;
952                 penv = penv->next_cpu;
953             }
954             return;
955         }
956     }
957
958     while (!all_vcpus_paused()) {
959         qemu_cond_wait(&qemu_pause_cond, &qemu_global_mutex);
960         penv = first_cpu;
961         while (penv) {
962             qemu_cpu_kick(penv);
963             penv = penv->next_cpu;
964         }
965     }
966 }
967
968 void resume_all_vcpus(void)
969 {
970     CPUArchState *penv = first_cpu;
971
972     qemu_clock_enable(vm_clock, true);
973     while (penv) {
974         penv->stop = 0;
975         penv->stopped = 0;
976         qemu_cpu_kick(penv);
977         penv = penv->next_cpu;
978     }
979 }
980
981 static void qemu_tcg_init_vcpu(void *_env)
982 {
983     CPUArchState *env = _env;
984     CPUState *cpu = ENV_GET_CPU(env);
985
986     /* share a single thread for all cpus with TCG */
987     if (!tcg_cpu_thread) {
988         cpu->thread = g_malloc0(sizeof(QemuThread));
989         env->halt_cond = g_malloc0(sizeof(QemuCond));
990         qemu_cond_init(env->halt_cond);
991         tcg_halt_cond = env->halt_cond;
992         qemu_thread_create(cpu->thread, qemu_tcg_cpu_thread_fn, env,
993                            QEMU_THREAD_JOINABLE);
994 #ifdef _WIN32
995         cpu->hThread = qemu_thread_get_handle(cpu->thread);
996 #endif
997         while (env->created == 0) {
998             qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
999         }
1000         tcg_cpu_thread = cpu->thread;
1001     } else {
1002         cpu->thread = tcg_cpu_thread;
1003         env->halt_cond = tcg_halt_cond;
1004     }
1005 }
1006
1007 static void qemu_kvm_start_vcpu(CPUArchState *env)
1008 {
1009     CPUState *cpu = ENV_GET_CPU(env);
1010
1011     cpu->thread = g_malloc0(sizeof(QemuThread));
1012     env->halt_cond = g_malloc0(sizeof(QemuCond));
1013     qemu_cond_init(env->halt_cond);
1014     qemu_thread_create(cpu->thread, qemu_kvm_cpu_thread_fn, env,
1015                        QEMU_THREAD_JOINABLE);
1016     while (env->created == 0) {
1017         qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
1018     }
1019 }
1020
1021 static void qemu_dummy_start_vcpu(CPUArchState *env)
1022 {
1023     CPUState *cpu = ENV_GET_CPU(env);
1024
1025     cpu->thread = g_malloc0(sizeof(QemuThread));
1026     env->halt_cond = g_malloc0(sizeof(QemuCond));
1027     qemu_cond_init(env->halt_cond);
1028     qemu_thread_create(cpu->thread, qemu_dummy_cpu_thread_fn, env,
1029                        QEMU_THREAD_JOINABLE);
1030     while (env->created == 0) {
1031         qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
1032     }
1033 }
1034
1035 void qemu_init_vcpu(void *_env)
1036 {
1037     CPUArchState *env = _env;
1038
1039     env->nr_cores = smp_cores;
1040     env->nr_threads = smp_threads;
1041     env->stopped = 1;
1042     if (kvm_enabled()) {
1043         qemu_kvm_start_vcpu(env);
1044     } else if (tcg_enabled()) {
1045         qemu_tcg_init_vcpu(env);
1046     } else {
1047         qemu_dummy_start_vcpu(env);
1048     }
1049 }
1050
1051 void cpu_stop_current(void)
1052 {
1053     if (cpu_single_env) {
1054         cpu_single_env->stop = 0;
1055         cpu_single_env->stopped = 1;
1056         cpu_exit(cpu_single_env);
1057         qemu_cond_signal(&qemu_pause_cond);
1058     }
1059 }
1060
1061 void vm_stop(RunState state)
1062 {
1063     if (!qemu_thread_is_self(&io_thread)) {
1064         qemu_system_vmstop_request(state);
1065         /*
1066          * FIXME: should not return to device code in case
1067          * vm_stop() has been requested.
1068          */
1069         cpu_stop_current();
1070         return;
1071     }
1072     do_vm_stop(state);
1073 }
1074
1075 /* does a state transition even if the VM is already stopped,
1076    current state is forgotten forever */
1077 void vm_stop_force_state(RunState state)
1078 {
1079     if (runstate_is_running()) {
1080         vm_stop(state);
1081     } else {
1082         runstate_set(state);
1083     }
1084 }
1085
1086 static int tcg_cpu_exec(CPUArchState *env)
1087 {
1088     int ret;
1089 #ifdef CONFIG_PROFILER
1090     int64_t ti;
1091 #endif
1092
1093 #ifdef CONFIG_PROFILER
1094     ti = profile_getclock();
1095 #endif
1096     if (use_icount) {
1097         int64_t count;
1098         int decr;
1099         qemu_icount -= (env->icount_decr.u16.low + env->icount_extra);
1100         env->icount_decr.u16.low = 0;
1101         env->icount_extra = 0;
1102         count = qemu_icount_round(qemu_clock_deadline(vm_clock));
1103         qemu_icount += count;
1104         decr = (count > 0xffff) ? 0xffff : count;
1105         count -= decr;
1106         env->icount_decr.u16.low = decr;
1107         env->icount_extra = count;
1108     }
1109     ret = cpu_exec(env);
1110 #ifdef CONFIG_PROFILER
1111     qemu_time += profile_getclock() - ti;
1112 #endif
1113     if (use_icount) {
1114         /* Fold pending instructions back into the
1115            instruction counter, and clear the interrupt flag.  */
1116         qemu_icount -= (env->icount_decr.u16.low
1117                         + env->icount_extra);
1118         env->icount_decr.u32 = 0;
1119         env->icount_extra = 0;
1120     }
1121     return ret;
1122 }
1123
1124 static void tcg_exec_all(void)
1125 {
1126     int r;
1127
1128     /* Account partial waits to the vm_clock.  */
1129     qemu_clock_warp(vm_clock);
1130
1131     if (next_cpu == NULL) {
1132         next_cpu = first_cpu;
1133     }
1134     for (; next_cpu != NULL && !exit_request; next_cpu = next_cpu->next_cpu) {
1135         CPUArchState *env = next_cpu;
1136
1137         qemu_clock_enable(vm_clock,
1138                           (env->singlestep_enabled & SSTEP_NOTIMER) == 0);
1139
1140         if (cpu_can_run(env)) {
1141             r = tcg_cpu_exec(env);
1142             if (r == EXCP_DEBUG) {
1143                 cpu_handle_guest_debug(env);
1144                 break;
1145             }
1146         } else if (env->stop || env->stopped) {
1147             break;
1148         }
1149     }
1150     exit_request = 0;
1151 }
1152
1153 void set_numa_modes(void)
1154 {
1155     CPUArchState *env;
1156     int i;
1157
1158     for (env = first_cpu; env != NULL; env = env->next_cpu) {
1159         for (i = 0; i < nb_numa_nodes; i++) {
1160             if (test_bit(env->cpu_index, node_cpumask[i])) {
1161                 env->numa_node = i;
1162             }
1163         }
1164     }
1165 }
1166
1167 void set_cpu_log(const char *optarg)
1168 {
1169     int mask;
1170     const CPULogItem *item;
1171
1172     mask = cpu_str_to_log_mask(optarg);
1173     if (!mask) {
1174         printf("Log items (comma separated):\n");
1175         for (item = cpu_log_items; item->mask != 0; item++) {
1176             printf("%-10s %s\n", item->name, item->help);
1177         }
1178         exit(1);
1179     }
1180     cpu_set_log(mask);
1181 }
1182
1183 void set_cpu_log_filename(const char *optarg)
1184 {
1185     cpu_set_log_filename(optarg);
1186 }
1187
1188 void list_cpus(FILE *f, fprintf_function cpu_fprintf, const char *optarg)
1189 {
1190     /* XXX: implement xxx_cpu_list for targets that still miss it */
1191 #if defined(cpu_list)
1192     cpu_list(f, cpu_fprintf);
1193 #endif
1194 }
1195
1196 CpuInfoList *qmp_query_cpus(Error **errp)
1197 {
1198     CpuInfoList *head = NULL, *cur_item = NULL;
1199     CPUArchState *env;
1200
1201     for(env = first_cpu; env != NULL; env = env->next_cpu) {
1202         CpuInfoList *info;
1203
1204         cpu_synchronize_state(env);
1205
1206         info = g_malloc0(sizeof(*info));
1207         info->value = g_malloc0(sizeof(*info->value));
1208         info->value->CPU = env->cpu_index;
1209         info->value->current = (env == first_cpu);
1210         info->value->halted = env->halted;
1211         info->value->thread_id = env->thread_id;
1212 #if defined(TARGET_I386)
1213         info->value->has_pc = true;
1214         info->value->pc = env->eip + env->segs[R_CS].base;
1215 #elif defined(TARGET_PPC)
1216         info->value->has_nip = true;
1217         info->value->nip = env->nip;
1218 #elif defined(TARGET_SPARC)
1219         info->value->has_pc = true;
1220         info->value->pc = env->pc;
1221         info->value->has_npc = true;
1222         info->value->npc = env->npc;
1223 #elif defined(TARGET_MIPS)
1224         info->value->has_PC = true;
1225         info->value->PC = env->active_tc.PC;
1226 #endif
1227
1228         /* XXX: waiting for the qapi to support GSList */
1229         if (!cur_item) {
1230             head = cur_item = info;
1231         } else {
1232             cur_item->next = info;
1233             cur_item = info;
1234         }
1235     }
1236
1237     return head;
1238 }
1239
1240 void qmp_memsave(int64_t addr, int64_t size, const char *filename,
1241                  bool has_cpu, int64_t cpu_index, Error **errp)
1242 {
1243     FILE *f;
1244     uint32_t l;
1245     CPUArchState *env;
1246     uint8_t buf[1024];
1247
1248     if (!has_cpu) {
1249         cpu_index = 0;
1250     }
1251
1252     for (env = first_cpu; env; env = env->next_cpu) {
1253         if (cpu_index == env->cpu_index) {
1254             break;
1255         }
1256     }
1257
1258     if (env == NULL) {
1259         error_set(errp, QERR_INVALID_PARAMETER_VALUE, "cpu-index",
1260                   "a CPU number");
1261         return;
1262     }
1263
1264     f = fopen(filename, "wb");
1265     if (!f) {
1266         error_set(errp, QERR_OPEN_FILE_FAILED, filename);
1267         return;
1268     }
1269
1270     while (size != 0) {
1271         l = sizeof(buf);
1272         if (l > size)
1273             l = size;
1274         cpu_memory_rw_debug(env, addr, buf, l, 0);
1275         if (fwrite(buf, 1, l, f) != l) {
1276             error_set(errp, QERR_IO_ERROR);
1277             goto exit;
1278         }
1279         addr += l;
1280         size -= l;
1281     }
1282
1283 exit:
1284     fclose(f);
1285 }
1286
1287 void qmp_pmemsave(int64_t addr, int64_t size, const char *filename,
1288                   Error **errp)
1289 {
1290     FILE *f;
1291     uint32_t l;
1292     uint8_t buf[1024];
1293
1294     f = fopen(filename, "wb");
1295     if (!f) {
1296         error_set(errp, QERR_OPEN_FILE_FAILED, filename);
1297         return;
1298     }
1299
1300     while (size != 0) {
1301         l = sizeof(buf);
1302         if (l > size)
1303             l = size;
1304         cpu_physical_memory_rw(addr, buf, l, 0);
1305         if (fwrite(buf, 1, l, f) != l) {
1306             error_set(errp, QERR_IO_ERROR);
1307             goto exit;
1308         }
1309         addr += l;
1310         size -= l;
1311     }
1312
1313 exit:
1314     fclose(f);
1315 }
1316
1317 void qmp_inject_nmi(Error **errp)
1318 {
1319 #if defined(TARGET_I386)
1320     CPUArchState *env;
1321
1322     for (env = first_cpu; env != NULL; env = env->next_cpu) {
1323         if (!env->apic_state) {
1324             cpu_interrupt(env, CPU_INTERRUPT_NMI);
1325         } else {
1326             apic_deliver_nmi(env->apic_state);
1327         }
1328     }
1329 #else
1330     error_set(errp, QERR_UNSUPPORTED);
1331 #endif
1332 }
This page took 0.095817 seconds and 4 git commands to generate.