Annotation of qemu/cpus.c, revision 1.1.1.2

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

unix.superglobalmegacorp.com