Annotation of qemu/cpus.c, revision 1.1.1.1

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"
                     33: #include "exec-all.h"
                     34: 
                     35: #include "cpus.h"
                     36: 
                     37: #ifdef SIGRTMIN
                     38: #define SIG_IPI (SIGRTMIN+4)
                     39: #else
                     40: #define SIG_IPI SIGUSR1
                     41: #endif
                     42: 
                     43: static CPUState *next_cpu;
                     44: 
                     45: /***********************************************************/
                     46: void hw_error(const char *fmt, ...)
                     47: {
                     48:     va_list ap;
                     49:     CPUState *env;
                     50: 
                     51:     va_start(ap, fmt);
                     52:     fprintf(stderr, "qemu: hardware error: ");
                     53:     vfprintf(stderr, fmt, ap);
                     54:     fprintf(stderr, "\n");
                     55:     for(env = first_cpu; env != NULL; env = env->next_cpu) {
                     56:         fprintf(stderr, "CPU #%d:\n", env->cpu_index);
                     57: #ifdef TARGET_I386
                     58:         cpu_dump_state(env, stderr, fprintf, X86_DUMP_FPU);
                     59: #else
                     60:         cpu_dump_state(env, stderr, fprintf, 0);
                     61: #endif
                     62:     }
                     63:     va_end(ap);
                     64:     abort();
                     65: }
                     66: 
                     67: void cpu_synchronize_all_states(void)
                     68: {
                     69:     CPUState *cpu;
                     70: 
                     71:     for (cpu = first_cpu; cpu; cpu = cpu->next_cpu) {
                     72:         cpu_synchronize_state(cpu);
                     73:     }
                     74: }
                     75: 
                     76: void cpu_synchronize_all_post_reset(void)
                     77: {
                     78:     CPUState *cpu;
                     79: 
                     80:     for (cpu = first_cpu; cpu; cpu = cpu->next_cpu) {
                     81:         cpu_synchronize_post_reset(cpu);
                     82:     }
                     83: }
                     84: 
                     85: void cpu_synchronize_all_post_init(void)
                     86: {
                     87:     CPUState *cpu;
                     88: 
                     89:     for (cpu = first_cpu; cpu; cpu = cpu->next_cpu) {
                     90:         cpu_synchronize_post_init(cpu);
                     91:     }
                     92: }
                     93: 
                     94: int cpu_is_stopped(CPUState *env)
                     95: {
                     96:     return !vm_running || env->stopped;
                     97: }
                     98: 
                     99: static void do_vm_stop(int reason)
                    100: {
                    101:     if (vm_running) {
                    102:         cpu_disable_ticks();
                    103:         vm_running = 0;
                    104:         pause_all_vcpus();
                    105:         vm_state_notify(0, reason);
                    106:         monitor_protocol_event(QEVENT_STOP, NULL);
                    107:     }
                    108: }
                    109: 
                    110: static int cpu_can_run(CPUState *env)
                    111: {
                    112:     if (env->stop)
                    113:         return 0;
                    114:     if (env->stopped || !vm_running)
                    115:         return 0;
                    116:     return 1;
                    117: }
                    118: 
                    119: static int cpu_has_work(CPUState *env)
                    120: {
                    121:     if (env->stop)
                    122:         return 1;
                    123:     if (env->queued_work_first)
                    124:         return 1;
                    125:     if (env->stopped || !vm_running)
                    126:         return 0;
                    127:     if (!env->halted)
                    128:         return 1;
                    129:     if (qemu_cpu_has_work(env))
                    130:         return 1;
                    131:     return 0;
                    132: }
                    133: 
                    134: static int any_cpu_has_work(void)
                    135: {
                    136:     CPUState *env;
                    137: 
                    138:     for (env = first_cpu; env != NULL; env = env->next_cpu)
                    139:         if (cpu_has_work(env))
                    140:             return 1;
                    141:     return 0;
                    142: }
                    143: 
                    144: static void cpu_debug_handler(CPUState *env)
                    145: {
                    146:     gdb_set_stop_cpu(env);
                    147:     debug_requested = EXCP_DEBUG;
                    148:     vm_stop(EXCP_DEBUG);
                    149: }
                    150: 
                    151: #ifndef _WIN32
                    152: static int io_thread_fd = -1;
                    153: 
                    154: static void qemu_event_increment(void)
                    155: {
                    156:     /* Write 8 bytes to be compatible with eventfd.  */
                    157:     static const uint64_t val = 1;
                    158:     ssize_t ret;
                    159: 
                    160:     if (io_thread_fd == -1)
                    161:         return;
                    162: 
                    163:     do {
                    164:         ret = write(io_thread_fd, &val, sizeof(val));
                    165:     } while (ret < 0 && errno == EINTR);
                    166: 
                    167:     /* EAGAIN is fine, a read must be pending.  */
                    168:     if (ret < 0 && errno != EAGAIN) {
                    169:         fprintf(stderr, "qemu_event_increment: write() filed: %s\n",
                    170:                 strerror(errno));
                    171:         exit (1);
                    172:     }
                    173: }
                    174: 
                    175: static void qemu_event_read(void *opaque)
                    176: {
                    177:     int fd = (unsigned long)opaque;
                    178:     ssize_t len;
                    179:     char buffer[512];
                    180: 
                    181:     /* Drain the notify pipe.  For eventfd, only 8 bytes will be read.  */
                    182:     do {
                    183:         len = read(fd, buffer, sizeof(buffer));
                    184:     } while ((len == -1 && errno == EINTR) || len == sizeof(buffer));
                    185: }
                    186: 
                    187: static int qemu_event_init(void)
                    188: {
                    189:     int err;
                    190:     int fds[2];
                    191: 
                    192:     err = qemu_eventfd(fds);
                    193:     if (err == -1)
                    194:         return -errno;
                    195: 
                    196:     err = fcntl_setfl(fds[0], O_NONBLOCK);
                    197:     if (err < 0)
                    198:         goto fail;
                    199: 
                    200:     err = fcntl_setfl(fds[1], O_NONBLOCK);
                    201:     if (err < 0)
                    202:         goto fail;
                    203: 
                    204:     qemu_set_fd_handler2(fds[0], NULL, qemu_event_read, NULL,
                    205:                          (void *)(unsigned long)fds[0]);
                    206: 
                    207:     io_thread_fd = fds[1];
                    208:     return 0;
                    209: 
                    210: fail:
                    211:     close(fds[0]);
                    212:     close(fds[1]);
                    213:     return err;
                    214: }
                    215: #else
                    216: HANDLE qemu_event_handle;
                    217: 
                    218: static void dummy_event_handler(void *opaque)
                    219: {
                    220: }
                    221: 
                    222: static int qemu_event_init(void)
                    223: {
                    224:     qemu_event_handle = CreateEvent(NULL, FALSE, FALSE, NULL);
                    225:     if (!qemu_event_handle) {
                    226:         fprintf(stderr, "Failed CreateEvent: %ld\n", GetLastError());
                    227:         return -1;
                    228:     }
                    229:     qemu_add_wait_object(qemu_event_handle, dummy_event_handler, NULL);
                    230:     return 0;
                    231: }
                    232: 
                    233: static void qemu_event_increment(void)
                    234: {
                    235:     if (!SetEvent(qemu_event_handle)) {
                    236:         fprintf(stderr, "qemu_event_increment: SetEvent failed: %ld\n",
                    237:                 GetLastError());
                    238:         exit (1);
                    239:     }
                    240: }
                    241: #endif
                    242: 
                    243: #ifndef CONFIG_IOTHREAD
                    244: int qemu_init_main_loop(void)
                    245: {
                    246:     cpu_set_debug_excp_handler(cpu_debug_handler);
                    247: 
                    248:     return qemu_event_init();
                    249: }
                    250: 
                    251: void qemu_main_loop_start(void)
                    252: {
                    253: }
                    254: 
                    255: void qemu_init_vcpu(void *_env)
                    256: {
                    257:     CPUState *env = _env;
                    258: 
                    259:     env->nr_cores = smp_cores;
                    260:     env->nr_threads = smp_threads;
                    261:     if (kvm_enabled())
                    262:         kvm_init_vcpu(env);
                    263:     return;
                    264: }
                    265: 
                    266: int qemu_cpu_self(void *env)
                    267: {
                    268:     return 1;
                    269: }
                    270: 
                    271: void run_on_cpu(CPUState *env, void (*func)(void *data), void *data)
                    272: {
                    273:     func(data);
                    274: }
                    275: 
                    276: void resume_all_vcpus(void)
                    277: {
                    278: }
                    279: 
                    280: void pause_all_vcpus(void)
                    281: {
                    282: }
                    283: 
                    284: void qemu_cpu_kick(void *env)
                    285: {
                    286:     return;
                    287: }
                    288: 
                    289: void qemu_notify_event(void)
                    290: {
                    291:     CPUState *env = cpu_single_env;
                    292: 
                    293:     qemu_event_increment ();
                    294:     if (env) {
                    295:         cpu_exit(env);
                    296:     }
                    297:     if (next_cpu && env != next_cpu) {
                    298:         cpu_exit(next_cpu);
                    299:     }
                    300: }
                    301: 
                    302: void qemu_mutex_lock_iothread(void) {}
                    303: void qemu_mutex_unlock_iothread(void) {}
                    304: 
                    305: void vm_stop(int reason)
                    306: {
                    307:     do_vm_stop(reason);
                    308: }
                    309: 
                    310: #else /* CONFIG_IOTHREAD */
                    311: 
                    312: #include "qemu-thread.h"
                    313: 
                    314: QemuMutex qemu_global_mutex;
                    315: static QemuMutex qemu_fair_mutex;
                    316: 
                    317: static QemuThread io_thread;
                    318: 
                    319: static QemuThread *tcg_cpu_thread;
                    320: static QemuCond *tcg_halt_cond;
                    321: 
                    322: static int qemu_system_ready;
                    323: /* cpu creation */
                    324: static QemuCond qemu_cpu_cond;
                    325: /* system init */
                    326: static QemuCond qemu_system_cond;
                    327: static QemuCond qemu_pause_cond;
                    328: static QemuCond qemu_work_cond;
                    329: 
                    330: static void tcg_init_ipi(void);
                    331: static void kvm_init_ipi(CPUState *env);
                    332: static void unblock_io_signals(void);
                    333: 
                    334: int qemu_init_main_loop(void)
                    335: {
                    336:     int ret;
                    337: 
                    338:     cpu_set_debug_excp_handler(cpu_debug_handler);
                    339: 
                    340:     ret = qemu_event_init();
                    341:     if (ret)
                    342:         return ret;
                    343: 
                    344:     qemu_cond_init(&qemu_pause_cond);
                    345:     qemu_cond_init(&qemu_system_cond);
                    346:     qemu_mutex_init(&qemu_fair_mutex);
                    347:     qemu_mutex_init(&qemu_global_mutex);
                    348:     qemu_mutex_lock(&qemu_global_mutex);
                    349: 
                    350:     unblock_io_signals();
                    351:     qemu_thread_self(&io_thread);
                    352: 
                    353:     return 0;
                    354: }
                    355: 
                    356: void qemu_main_loop_start(void)
                    357: {
                    358:     qemu_system_ready = 1;
                    359:     qemu_cond_broadcast(&qemu_system_cond);
                    360: }
                    361: 
                    362: void run_on_cpu(CPUState *env, void (*func)(void *data), void *data)
                    363: {
                    364:     struct qemu_work_item wi;
                    365: 
                    366:     if (qemu_cpu_self(env)) {
                    367:         func(data);
                    368:         return;
                    369:     }
                    370: 
                    371:     wi.func = func;
                    372:     wi.data = data;
                    373:     if (!env->queued_work_first)
                    374:         env->queued_work_first = &wi;
                    375:     else
                    376:         env->queued_work_last->next = &wi;
                    377:     env->queued_work_last = &wi;
                    378:     wi.next = NULL;
                    379:     wi.done = false;
                    380: 
                    381:     qemu_cpu_kick(env);
                    382:     while (!wi.done) {
                    383:         CPUState *self_env = cpu_single_env;
                    384: 
                    385:         qemu_cond_wait(&qemu_work_cond, &qemu_global_mutex);
                    386:         cpu_single_env = self_env;
                    387:     }
                    388: }
                    389: 
                    390: static void flush_queued_work(CPUState *env)
                    391: {
                    392:     struct qemu_work_item *wi;
                    393: 
                    394:     if (!env->queued_work_first)
                    395:         return;
                    396: 
                    397:     while ((wi = env->queued_work_first)) {
                    398:         env->queued_work_first = wi->next;
                    399:         wi->func(wi->data);
                    400:         wi->done = true;
                    401:     }
                    402:     env->queued_work_last = NULL;
                    403:     qemu_cond_broadcast(&qemu_work_cond);
                    404: }
                    405: 
                    406: static void qemu_wait_io_event_common(CPUState *env)
                    407: {
                    408:     if (env->stop) {
                    409:         env->stop = 0;
                    410:         env->stopped = 1;
                    411:         qemu_cond_signal(&qemu_pause_cond);
                    412:     }
                    413:     flush_queued_work(env);
                    414: }
                    415: 
                    416: static void qemu_tcg_wait_io_event(void)
                    417: {
                    418:     CPUState *env;
                    419: 
                    420:     while (!any_cpu_has_work())
                    421:         qemu_cond_timedwait(tcg_halt_cond, &qemu_global_mutex, 1000);
                    422: 
                    423:     qemu_mutex_unlock(&qemu_global_mutex);
                    424: 
                    425:     /*
                    426:      * Users of qemu_global_mutex can be starved, having no chance
                    427:      * to acquire it since this path will get to it first.
                    428:      * So use another lock to provide fairness.
                    429:      */
                    430:     qemu_mutex_lock(&qemu_fair_mutex);
                    431:     qemu_mutex_unlock(&qemu_fair_mutex);
                    432: 
                    433:     qemu_mutex_lock(&qemu_global_mutex);
                    434: 
                    435:     for (env = first_cpu; env != NULL; env = env->next_cpu) {
                    436:         qemu_wait_io_event_common(env);
                    437:     }
                    438: }
                    439: 
                    440: static void qemu_kvm_eat_signal(CPUState *env, int timeout)
                    441: {
                    442:     struct timespec ts;
                    443:     int r, e;
                    444:     siginfo_t siginfo;
                    445:     sigset_t waitset;
                    446: 
                    447:     ts.tv_sec = timeout / 1000;
                    448:     ts.tv_nsec = (timeout % 1000) * 1000000;
                    449: 
                    450:     sigemptyset(&waitset);
                    451:     sigaddset(&waitset, SIG_IPI);
                    452: 
                    453:     qemu_mutex_unlock(&qemu_global_mutex);
                    454:     r = sigtimedwait(&waitset, &siginfo, &ts);
                    455:     e = errno;
                    456:     qemu_mutex_lock(&qemu_global_mutex);
                    457: 
                    458:     if (r == -1 && !(e == EAGAIN || e == EINTR)) {
                    459:         fprintf(stderr, "sigtimedwait: %s\n", strerror(e));
                    460:         exit(1);
                    461:     }
                    462: }
                    463: 
                    464: static void qemu_kvm_wait_io_event(CPUState *env)
                    465: {
                    466:     while (!cpu_has_work(env))
                    467:         qemu_cond_timedwait(env->halt_cond, &qemu_global_mutex, 1000);
                    468: 
                    469:     qemu_kvm_eat_signal(env, 0);
                    470:     qemu_wait_io_event_common(env);
                    471: }
                    472: 
                    473: static int qemu_cpu_exec(CPUState *env);
                    474: 
                    475: static void *kvm_cpu_thread_fn(void *arg)
                    476: {
                    477:     CPUState *env = arg;
                    478: 
                    479:     qemu_mutex_lock(&qemu_global_mutex);
                    480:     qemu_thread_self(env->thread);
                    481:     if (kvm_enabled())
                    482:         kvm_init_vcpu(env);
                    483: 
                    484:     kvm_init_ipi(env);
                    485: 
                    486:     /* signal CPU creation */
                    487:     env->created = 1;
                    488:     qemu_cond_signal(&qemu_cpu_cond);
                    489: 
                    490:     /* and wait for machine initialization */
                    491:     while (!qemu_system_ready)
                    492:         qemu_cond_timedwait(&qemu_system_cond, &qemu_global_mutex, 100);
                    493: 
                    494:     while (1) {
                    495:         if (cpu_can_run(env))
                    496:             qemu_cpu_exec(env);
                    497:         qemu_kvm_wait_io_event(env);
                    498:     }
                    499: 
                    500:     return NULL;
                    501: }
                    502: 
                    503: static void *tcg_cpu_thread_fn(void *arg)
                    504: {
                    505:     CPUState *env = arg;
                    506: 
                    507:     tcg_init_ipi();
                    508:     qemu_thread_self(env->thread);
                    509: 
                    510:     /* signal CPU creation */
                    511:     qemu_mutex_lock(&qemu_global_mutex);
                    512:     for (env = first_cpu; env != NULL; env = env->next_cpu)
                    513:         env->created = 1;
                    514:     qemu_cond_signal(&qemu_cpu_cond);
                    515: 
                    516:     /* and wait for machine initialization */
                    517:     while (!qemu_system_ready)
                    518:         qemu_cond_timedwait(&qemu_system_cond, &qemu_global_mutex, 100);
                    519: 
                    520:     while (1) {
                    521:         cpu_exec_all();
                    522:         qemu_tcg_wait_io_event();
                    523:     }
                    524: 
                    525:     return NULL;
                    526: }
                    527: 
                    528: void qemu_cpu_kick(void *_env)
                    529: {
                    530:     CPUState *env = _env;
                    531:     qemu_cond_broadcast(env->halt_cond);
                    532:     qemu_thread_signal(env->thread, SIG_IPI);
                    533: }
                    534: 
                    535: int qemu_cpu_self(void *_env)
                    536: {
                    537:     CPUState *env = _env;
                    538:     QemuThread this;
                    539: 
                    540:     qemu_thread_self(&this);
                    541: 
                    542:     return qemu_thread_equal(&this, env->thread);
                    543: }
                    544: 
                    545: static void cpu_signal(int sig)
                    546: {
                    547:     if (cpu_single_env)
                    548:         cpu_exit(cpu_single_env);
                    549:     exit_request = 1;
                    550: }
                    551: 
                    552: static void tcg_init_ipi(void)
                    553: {
                    554:     sigset_t set;
                    555:     struct sigaction sigact;
                    556: 
                    557:     memset(&sigact, 0, sizeof(sigact));
                    558:     sigact.sa_handler = cpu_signal;
                    559:     sigaction(SIG_IPI, &sigact, NULL);
                    560: 
                    561:     sigemptyset(&set);
                    562:     sigaddset(&set, SIG_IPI);
                    563:     pthread_sigmask(SIG_UNBLOCK, &set, NULL);
                    564: }
                    565: 
                    566: static void dummy_signal(int sig)
                    567: {
                    568: }
                    569: 
                    570: static void kvm_init_ipi(CPUState *env)
                    571: {
                    572:     int r;
                    573:     sigset_t set;
                    574:     struct sigaction sigact;
                    575: 
                    576:     memset(&sigact, 0, sizeof(sigact));
                    577:     sigact.sa_handler = dummy_signal;
                    578:     sigaction(SIG_IPI, &sigact, NULL);
                    579: 
                    580:     pthread_sigmask(SIG_BLOCK, NULL, &set);
                    581:     sigdelset(&set, SIG_IPI);
                    582:     r = kvm_set_signal_mask(env, &set);
                    583:     if (r) {
                    584:         fprintf(stderr, "kvm_set_signal_mask: %s\n", strerror(r));
                    585:         exit(1);
                    586:     }
                    587: }
                    588: 
                    589: static void unblock_io_signals(void)
                    590: {
                    591:     sigset_t set;
                    592: 
                    593:     sigemptyset(&set);
                    594:     sigaddset(&set, SIGUSR2);
                    595:     sigaddset(&set, SIGIO);
                    596:     sigaddset(&set, SIGALRM);
                    597:     pthread_sigmask(SIG_UNBLOCK, &set, NULL);
                    598: 
                    599:     sigemptyset(&set);
                    600:     sigaddset(&set, SIG_IPI);
                    601:     pthread_sigmask(SIG_BLOCK, &set, NULL);
                    602: }
                    603: 
                    604: void qemu_mutex_lock_iothread(void)
                    605: {
                    606:     if (kvm_enabled()) {
                    607:         qemu_mutex_lock(&qemu_fair_mutex);
                    608:         qemu_mutex_lock(&qemu_global_mutex);
                    609:         qemu_mutex_unlock(&qemu_fair_mutex);
                    610:     } else {
                    611:         qemu_mutex_lock(&qemu_fair_mutex);
                    612:         if (qemu_mutex_trylock(&qemu_global_mutex)) {
                    613:             qemu_thread_signal(tcg_cpu_thread, SIG_IPI);
                    614:             qemu_mutex_lock(&qemu_global_mutex);
                    615:         }
                    616:         qemu_mutex_unlock(&qemu_fair_mutex);
                    617:     }
                    618: }
                    619: 
                    620: void qemu_mutex_unlock_iothread(void)
                    621: {
                    622:     qemu_mutex_unlock(&qemu_global_mutex);
                    623: }
                    624: 
                    625: static int all_vcpus_paused(void)
                    626: {
                    627:     CPUState *penv = first_cpu;
                    628: 
                    629:     while (penv) {
                    630:         if (!penv->stopped)
                    631:             return 0;
                    632:         penv = (CPUState *)penv->next_cpu;
                    633:     }
                    634: 
                    635:     return 1;
                    636: }
                    637: 
                    638: void pause_all_vcpus(void)
                    639: {
                    640:     CPUState *penv = first_cpu;
                    641: 
                    642:     while (penv) {
                    643:         penv->stop = 1;
                    644:         qemu_cpu_kick(penv);
                    645:         penv = (CPUState *)penv->next_cpu;
                    646:     }
                    647: 
                    648:     while (!all_vcpus_paused()) {
                    649:         qemu_cond_timedwait(&qemu_pause_cond, &qemu_global_mutex, 100);
                    650:         penv = first_cpu;
                    651:         while (penv) {
                    652:             qemu_cpu_kick(penv);
                    653:             penv = (CPUState *)penv->next_cpu;
                    654:         }
                    655:     }
                    656: }
                    657: 
                    658: void resume_all_vcpus(void)
                    659: {
                    660:     CPUState *penv = first_cpu;
                    661: 
                    662:     while (penv) {
                    663:         penv->stop = 0;
                    664:         penv->stopped = 0;
                    665:         qemu_cpu_kick(penv);
                    666:         penv = (CPUState *)penv->next_cpu;
                    667:     }
                    668: }
                    669: 
                    670: static void tcg_init_vcpu(void *_env)
                    671: {
                    672:     CPUState *env = _env;
                    673:     /* share a single thread for all cpus with TCG */
                    674:     if (!tcg_cpu_thread) {
                    675:         env->thread = qemu_mallocz(sizeof(QemuThread));
                    676:         env->halt_cond = qemu_mallocz(sizeof(QemuCond));
                    677:         qemu_cond_init(env->halt_cond);
                    678:         qemu_thread_create(env->thread, tcg_cpu_thread_fn, env);
                    679:         while (env->created == 0)
                    680:             qemu_cond_timedwait(&qemu_cpu_cond, &qemu_global_mutex, 100);
                    681:         tcg_cpu_thread = env->thread;
                    682:         tcg_halt_cond = env->halt_cond;
                    683:     } else {
                    684:         env->thread = tcg_cpu_thread;
                    685:         env->halt_cond = tcg_halt_cond;
                    686:     }
                    687: }
                    688: 
                    689: static void kvm_start_vcpu(CPUState *env)
                    690: {
                    691:     env->thread = qemu_mallocz(sizeof(QemuThread));
                    692:     env->halt_cond = qemu_mallocz(sizeof(QemuCond));
                    693:     qemu_cond_init(env->halt_cond);
                    694:     qemu_thread_create(env->thread, kvm_cpu_thread_fn, env);
                    695:     while (env->created == 0)
                    696:         qemu_cond_timedwait(&qemu_cpu_cond, &qemu_global_mutex, 100);
                    697: }
                    698: 
                    699: void qemu_init_vcpu(void *_env)
                    700: {
                    701:     CPUState *env = _env;
                    702: 
                    703:     env->nr_cores = smp_cores;
                    704:     env->nr_threads = smp_threads;
                    705:     if (kvm_enabled())
                    706:         kvm_start_vcpu(env);
                    707:     else
                    708:         tcg_init_vcpu(env);
                    709: }
                    710: 
                    711: void qemu_notify_event(void)
                    712: {
                    713:     qemu_event_increment();
                    714: }
                    715: 
                    716: static void qemu_system_vmstop_request(int reason)
                    717: {
                    718:     vmstop_requested = reason;
                    719:     qemu_notify_event();
                    720: }
                    721: 
                    722: void vm_stop(int reason)
                    723: {
                    724:     QemuThread me;
                    725:     qemu_thread_self(&me);
                    726: 
                    727:     if (!qemu_thread_equal(&me, &io_thread)) {
                    728:         qemu_system_vmstop_request(reason);
                    729:         /*
                    730:          * FIXME: should not return to device code in case
                    731:          * vm_stop() has been requested.
                    732:          */
                    733:         if (cpu_single_env) {
                    734:             cpu_exit(cpu_single_env);
                    735:             cpu_single_env->stop = 1;
                    736:         }
                    737:         return;
                    738:     }
                    739:     do_vm_stop(reason);
                    740: }
                    741: 
                    742: #endif
                    743: 
                    744: static int qemu_cpu_exec(CPUState *env)
                    745: {
                    746:     int ret;
                    747: #ifdef CONFIG_PROFILER
                    748:     int64_t ti;
                    749: #endif
                    750: 
                    751: #ifdef CONFIG_PROFILER
                    752:     ti = profile_getclock();
                    753: #endif
                    754:     if (use_icount) {
                    755:         int64_t count;
                    756:         int decr;
                    757:         qemu_icount -= (env->icount_decr.u16.low + env->icount_extra);
                    758:         env->icount_decr.u16.low = 0;
                    759:         env->icount_extra = 0;
                    760:         count = qemu_icount_round (qemu_next_deadline());
                    761:         qemu_icount += count;
                    762:         decr = (count > 0xffff) ? 0xffff : count;
                    763:         count -= decr;
                    764:         env->icount_decr.u16.low = decr;
                    765:         env->icount_extra = count;
                    766:     }
                    767:     ret = cpu_exec(env);
                    768: #ifdef CONFIG_PROFILER
                    769:     qemu_time += profile_getclock() - ti;
                    770: #endif
                    771:     if (use_icount) {
                    772:         /* Fold pending instructions back into the
                    773:            instruction counter, and clear the interrupt flag.  */
                    774:         qemu_icount -= (env->icount_decr.u16.low
                    775:                         + env->icount_extra);
                    776:         env->icount_decr.u32 = 0;
                    777:         env->icount_extra = 0;
                    778:     }
                    779:     return ret;
                    780: }
                    781: 
                    782: bool cpu_exec_all(void)
                    783: {
                    784:     if (next_cpu == NULL)
                    785:         next_cpu = first_cpu;
                    786:     for (; next_cpu != NULL && !exit_request; next_cpu = next_cpu->next_cpu) {
                    787:         CPUState *env = next_cpu;
                    788: 
                    789:         qemu_clock_enable(vm_clock,
                    790:                           (env->singlestep_enabled & SSTEP_NOTIMER) == 0);
                    791: 
                    792:         if (qemu_alarm_pending())
                    793:             break;
                    794:         if (cpu_can_run(env)) {
                    795:             if (qemu_cpu_exec(env) == EXCP_DEBUG) {
                    796:                 break;
                    797:             }
                    798:         } else if (env->stop) {
                    799:             break;
                    800:         }
                    801:     }
                    802:     exit_request = 0;
                    803:     return any_cpu_has_work();
                    804: }
                    805: 
                    806: void set_numa_modes(void)
                    807: {
                    808:     CPUState *env;
                    809:     int i;
                    810: 
                    811:     for (env = first_cpu; env != NULL; env = env->next_cpu) {
                    812:         for (i = 0; i < nb_numa_nodes; i++) {
                    813:             if (node_cpumask[i] & (1 << env->cpu_index)) {
                    814:                 env->numa_node = i;
                    815:             }
                    816:         }
                    817:     }
                    818: }
                    819: 
                    820: void set_cpu_log(const char *optarg)
                    821: {
                    822:     int mask;
                    823:     const CPULogItem *item;
                    824: 
                    825:     mask = cpu_str_to_log_mask(optarg);
                    826:     if (!mask) {
                    827:         printf("Log items (comma separated):\n");
                    828:         for (item = cpu_log_items; item->mask != 0; item++) {
                    829:             printf("%-10s %s\n", item->name, item->help);
                    830:         }
                    831:         exit(1);
                    832:     }
                    833:     cpu_set_log(mask);
                    834: }
                    835: 
                    836: /* Return the virtual CPU time, based on the instruction counter.  */
                    837: int64_t cpu_get_icount(void)
                    838: {
                    839:     int64_t icount;
                    840:     CPUState *env = cpu_single_env;;
                    841: 
                    842:     icount = qemu_icount;
                    843:     if (env) {
                    844:         if (!can_do_io(env)) {
                    845:             fprintf(stderr, "Bad clock read\n");
                    846:         }
                    847:         icount -= (env->icount_decr.u16.low + env->icount_extra);
                    848:     }
                    849:     return qemu_icount_bias + (icount << icount_time_shift);
                    850: }
                    851: 
                    852: void list_cpus(FILE *f, int (*cpu_fprintf)(FILE *f, const char *fmt, ...),
                    853:                const char *optarg)
                    854: {
                    855:     /* XXX: implement xxx_cpu_list for targets that still miss it */
                    856: #if defined(cpu_list_id)
                    857:     cpu_list_id(f, cpu_fprintf, optarg);
                    858: #elif defined(cpu_list)
                    859:     cpu_list(f, cpu_fprintf); /* deprecated */
                    860: #endif
                    861: }

unix.superglobalmegacorp.com