File:  [Qemu by Fabrice Bellard] / qemu / cpus.c
Revision 1.1.1.2 (vendor branch): download - view: text, annotated - select for diffs
Tue Apr 24 18:34:10 2018 UTC (3 years, 1 month ago) by root
Branches: qemu, MAIN
CVS tags: qemu0150, qemu0141, qemu0140, HEAD
qemu 0.14.0

    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: #include "compatfd.h"
   37: #ifdef CONFIG_LINUX
   38: #include <sys/prctl.h>
   39: #endif
   40: 
   41: #ifdef SIGRTMIN
   42: #define SIG_IPI (SIGRTMIN+4)
   43: #else
   44: #define SIG_IPI SIGUSR1
   45: #endif
   46: 
   47: #ifndef PR_MCE_KILL
   48: #define PR_MCE_KILL 33
   49: #endif
   50: 
   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);
  114:         qemu_aio_flush();
  115:         bdrv_flush_all();
  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);
  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: }
  396: 
  397: int qemu_init_main_loop(void)
  398: {
  399:     int ret;
  400:     sigset_t blocked_signals;
  401: 
  402:     cpu_set_debug_excp_handler(cpu_debug_handler);
  403: 
  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 */
  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: 
  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: 
  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;
  542:     sigset_t chkset;
  543: 
  544:     ts.tv_sec = timeout / 1000;
  545:     ts.tv_nsec = (timeout % 1000) * 1000000;
  546: 
  547:     sigemptyset(&waitset);
  548:     sigaddset(&waitset, SIG_IPI);
  549:     sigaddset(&waitset, SIGBUS);
  550: 
  551:     do {
  552:         qemu_mutex_unlock(&qemu_global_mutex);
  553: 
  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));
  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);
  701:     sigdelset(&set, SIGBUS);
  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: 
  709: static sigset_t block_io_signals(void)
  710: {
  711:     sigset_t set;
  712:     struct sigaction action;
  713: 
  714:     /* SIGUSR2 used by posix-aio-compat.c */
  715:     sigemptyset(&set);
  716:     sigaddset(&set, SIGUSR2);
  717:     pthread_sigmask(SIG_UNBLOCK, &set, NULL);
  718: 
  719:     sigemptyset(&set);
  720:     sigaddset(&set, SIGIO);
  721:     sigaddset(&set, SIGALRM);
  722:     sigaddset(&set, SIG_IPI);
  723:     sigaddset(&set, SIGBUS);
  724:     pthread_sigmask(SIG_BLOCK, &set, NULL);
  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;
  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: 
  981: void list_cpus(FILE *f, fprintf_function cpu_fprintf, const char *optarg)
  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