Annotation of qemu/cpus.c, revision 1.1.1.4

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

unix.superglobalmegacorp.com