cpus.c

   1 /*
   2  * QEMU System Emulator
   3  *
   4  * Copyright (c) 2003-2008 Fabrice Bellard
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24
  25 /* Needed early for CONFIG_BSD etc. */
  26 #include "config-host.h"
  27
  28 #include "monitor.h"
  29 #include "sysemu.h"
  30 #include "gdbstub.h"
  31 #include "dma.h"
  32 #include "kvm.h"
  33
  34 #include "cpus.h"
  35
  36 #ifdef SIGRTMIN
  37 #define SIG_IPI (SIGRTMIN+4)
  38 #else
  39 #define SIG_IPI SIGUSR1
  40 #endif
  41
  42 static CPUState *cur_cpu;
  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 tcg_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 #ifndef _WIN32
 145 static int io_thread_fd = -1;
 146
 147 static void qemu_event_increment(void)
 148 {
 149     /* Write 8 bytes to be compatible with eventfd.  */
 150     static const uint64_t val = 1;
 151     ssize_t ret;
 152
 153     if (io_thread_fd == -1)
 154         return;
 155
 156     do {
 157         ret = write(io_thread_fd, &val, sizeof(val));
 158     } while (ret < 0 && errno == EINTR);
 159
 160     /* EAGAIN is fine, a read must be pending.  */
 161     if (ret < 0 && errno != EAGAIN) {
 162         fprintf(stderr, "qemu_event_increment: write() filed: %s\n",
 163                 strerror(errno));
 164         exit (1);
 165     }
 166 }
 167
 168 static void qemu_event_read(void *opaque)
 169 {
 170     int fd = (unsigned long)opaque;
 171     ssize_t len;
 172     char buffer[512];
 173
 174     /* Drain the notify pipe.  For eventfd, only 8 bytes will be read.  */
 175     do {
 176         len = read(fd, buffer, sizeof(buffer));
 177     } while ((len == -1 && errno == EINTR) || len == sizeof(buffer));
 178 }
 179
 180 static int qemu_event_init(void)
 181 {
 182     int err;
 183     int fds[2];
 184
 185     err = qemu_eventfd(fds);
 186     if (err == -1)
 187         return -errno;
 188
 189     err = fcntl_setfl(fds[0], O_NONBLOCK);
 190     if (err < 0)
 191         goto fail;
 192
 193     err = fcntl_setfl(fds[1], O_NONBLOCK);
 194     if (err < 0)
 195         goto fail;
 196
 197     qemu_set_fd_handler2(fds[0], NULL, qemu_event_read, NULL,
 198                          (void *)(unsigned long)fds[0]);
 199
 200     io_thread_fd = fds[1];
 201     return 0;
 202
 203 fail:
 204     close(fds[0]);
 205     close(fds[1]);
 206     return err;
 207 }
 208 #else
 209 HANDLE qemu_event_handle;
 210
 211 static void dummy_event_handler(void *opaque)
 212 {
 213 }
 214
 215 static int qemu_event_init(void)
 216 {
 217     qemu_event_handle = CreateEvent(NULL, FALSE, FALSE, NULL);
 218     if (!qemu_event_handle) {
 219         fprintf(stderr, "Failed CreateEvent: %ld\n", GetLastError());
 220         return -1;
 221     }
 222     qemu_add_wait_object(qemu_event_handle, dummy_event_handler, NULL);
 223     return 0;
 224 }
 225
 226 static void qemu_event_increment(void)
 227 {
 228     if (!SetEvent(qemu_event_handle)) {
 229         fprintf(stderr, "qemu_event_increment: SetEvent failed: %ld\n",
 230                 GetLastError());
 231         exit (1);
 232     }
 233 }
 234 #endif
 235
 236 #ifndef CONFIG_IOTHREAD
 237 int qemu_init_main_loop(void)
 238 {
 239     return qemu_event_init();
 240 }
 241
 242 void qemu_main_loop_start(void)
 243 {
 244 }
 245
 246 void qemu_init_vcpu(void *_env)
 247 {
 248     CPUState *env = _env;
 249
 250     env->nr_cores = smp_cores;
 251     env->nr_threads = smp_threads;
 252     if (kvm_enabled())
 253         kvm_init_vcpu(env);
 254     return;
 255 }
 256
 257 int qemu_cpu_self(void *env)
 258 {
 259     return 1;
 260 }
 261
 262 void run_on_cpu(CPUState *env, void (*func)(void *data), void *data)
 263 {
 264     func(data);
 265 }
 266
 267 void resume_all_vcpus(void)
 268 {
 269 }
 270
 271 void pause_all_vcpus(void)
 272 {
 273 }
 274
 275 void qemu_cpu_kick(void *env)
 276 {
 277     return;
 278 }
 279
 280 void qemu_notify_event(void)
 281 {
 282     CPUState *env = cpu_single_env;
 283
 284     if (kvm_enabled()) {
 285         qemu_kvm_notify_work();
 286         return;
 287     }
 288
 289     qemu_event_increment ();
 290     if (env) {
 291         cpu_exit(env);
 292     }
 293     if (next_cpu && env != next_cpu) {
 294         cpu_exit(next_cpu);
 295     }
 296 }
 297
 298 #if defined(KVM_UPSTREAM) || !defined(CONFIG_KVM)
 299 void qemu_mutex_lock_iothread(void) {}
 300 void qemu_mutex_unlock_iothread(void) {}
 301 #endif
 302
 303 void vm_stop(int reason)
 304 {
 305     do_vm_stop(reason);
 306 }
 307
 308 #else /* CONFIG_IOTHREAD */
 309
 310 #include "qemu-thread.h"
 311
 312 QemuMutex qemu_global_mutex;
 313 static QemuMutex qemu_fair_mutex;
 314
 315 static QemuThread io_thread;
 316
 317 static QemuThread *tcg_cpu_thread;
 318 static QemuCond *tcg_halt_cond;
 319
 320 static int qemu_system_ready;
 321 /* cpu creation */
 322 static QemuCond qemu_cpu_cond;
 323 /* system init */
 324 static QemuCond qemu_system_cond;
 325 static QemuCond qemu_pause_cond;
 326 static QemuCond qemu_work_cond;
 327
 328 static void tcg_block_io_signals(void);
 329 static void kvm_block_io_signals(CPUState *env);
 330 static void unblock_io_signals(void);
 331
 332 int qemu_init_main_loop(void)
 333 {
 334     int ret;
 335
 336     ret = qemu_event_init();
 337     if (ret)
 338         return ret;
 339
 340     qemu_cond_init(&qemu_pause_cond);
 341     qemu_mutex_init(&qemu_fair_mutex);
 342     qemu_mutex_init(&qemu_global_mutex);
 343     qemu_mutex_lock(&qemu_global_mutex);
 344
 345     unblock_io_signals();
 346     qemu_thread_self(&io_thread);
 347
 348     return 0;
 349 }
 350
 351 void qemu_main_loop_start(void)
 352 {
 353     qemu_system_ready = 1;
 354     qemu_cond_broadcast(&qemu_system_cond);
 355 }
 356
 357 void run_on_cpu(CPUState *env, void (*func)(void *data), void *data)
 358 {
 359     struct qemu_work_item wi;
 360
 361     if (qemu_cpu_self(env)) {
 362         func(data);
 363         return;
 364     }
 365
 366     wi.func = func;
 367     wi.data = data;
 368     if (!env->queued_work_first)
 369         env->queued_work_first = &wi;
 370     else
 371         env->queued_work_last->next = &wi;
 372     env->queued_work_last = &wi;
 373     wi.next = NULL;
 374     wi.done = false;
 375
 376     qemu_cpu_kick(env);
 377     while (!wi.done) {
 378         CPUState *self_env = cpu_single_env;
 379
 380         qemu_cond_wait(&qemu_work_cond, &qemu_global_mutex);
 381         cpu_single_env = self_env;
 382     }
 383 }
 384
 385 static void flush_queued_work(CPUState *env)
 386 {
 387     struct qemu_work_item *wi;
 388
 389     if (!env->queued_work_first)
 390         return;
 391
 392     while ((wi = env->queued_work_first)) {
 393         env->queued_work_first = wi->next;
 394         wi->func(wi->data);
 395         wi->done = true;
 396     }
 397     env->queued_work_last = NULL;
 398     qemu_cond_broadcast(&qemu_work_cond);
 399 }
 400
 401 static void qemu_wait_io_event_common(CPUState *env)
 402 {
 403     if (env->stop) {
 404         env->stop = 0;
 405         env->stopped = 1;
 406         qemu_cond_signal(&qemu_pause_cond);
 407     }
 408     flush_queued_work(env);
 409 }
 410
 411 static void qemu_wait_io_event(CPUState *env)
 412 {
 413     while (!tcg_has_work())
 414         qemu_cond_timedwait(env->halt_cond, &qemu_global_mutex, 1000);
 415
 416     qemu_mutex_unlock(&qemu_global_mutex);
 417
 418     /*
 419      * Users of qemu_global_mutex can be starved, having no chance
 420      * to acquire it since this path will get to it first.
 421      * So use another lock to provide fairness.
 422      */
 423     qemu_mutex_lock(&qemu_fair_mutex);
 424     qemu_mutex_unlock(&qemu_fair_mutex);
 425
 426     qemu_mutex_lock(&qemu_global_mutex);
 427     qemu_wait_io_event_common(env);
 428 }
 429
 430 static void qemu_kvm_eat_signal(CPUState *env, int timeout)
 431 {
 432     struct timespec ts;
 433     int r, e;
 434     siginfo_t siginfo;
 435     sigset_t waitset;
 436
 437     ts.tv_sec = timeout / 1000;
 438     ts.tv_nsec = (timeout % 1000) * 1000000;
 439
 440     sigemptyset(&waitset);
 441     sigaddset(&waitset, SIG_IPI);
 442
 443     qemu_mutex_unlock(&qemu_global_mutex);
 444     r = sigtimedwait(&waitset, &siginfo, &ts);
 445     e = errno;
 446     qemu_mutex_lock(&qemu_global_mutex);
 447
 448     if (r == -1 && !(e == EAGAIN || e == EINTR)) {
 449         fprintf(stderr, "sigtimedwait: %s\n", strerror(e));
 450         exit(1);
 451     }
 452 }
 453
 454 static void qemu_kvm_wait_io_event(CPUState *env)
 455 {
 456     while (!cpu_has_work(env))
 457         qemu_cond_timedwait(env->halt_cond, &qemu_global_mutex, 1000);
 458
 459     qemu_kvm_eat_signal(env, 0);
 460     qemu_wait_io_event_common(env);
 461 }
 462
 463 static int qemu_cpu_exec(CPUState *env);
 464
 465 static void *kvm_cpu_thread_fn(void *arg)
 466 {
 467     CPUState *env = arg;
 468
 469     qemu_mutex_lock(&qemu_global_mutex);
 470     qemu_thread_self(env->thread);
 471     if (kvm_enabled())
 472         kvm_init_vcpu(env);
 473
 474     kvm_block_io_signals(env);
 475
 476     /* signal CPU creation */
 477     env->created = 1;
 478     qemu_cond_signal(&qemu_cpu_cond);
 479
 480     /* and wait for machine initialization */
 481     while (!qemu_system_ready)
 482         qemu_cond_timedwait(&qemu_system_cond, &qemu_global_mutex, 100);
 483
 484     while (1) {
 485         if (cpu_can_run(env))
 486             qemu_cpu_exec(env);
 487         qemu_kvm_wait_io_event(env);
 488     }
 489
 490     return NULL;
 491 }
 492
 493 static void *tcg_cpu_thread_fn(void *arg)
 494 {
 495     CPUState *env = arg;
 496
 497     tcg_block_io_signals();
 498     qemu_thread_self(env->thread);
 499
 500     /* signal CPU creation */
 501     qemu_mutex_lock(&qemu_global_mutex);
 502     for (env = first_cpu; env != NULL; env = env->next_cpu)
 503         env->created = 1;
 504     qemu_cond_signal(&qemu_cpu_cond);
 505
 506     /* and wait for machine initialization */
 507     while (!qemu_system_ready)
 508         qemu_cond_timedwait(&qemu_system_cond, &qemu_global_mutex, 100);
 509
 510     while (1) {
 511         tcg_cpu_exec();
 512         qemu_wait_io_event(cur_cpu);
 513     }
 514
 515     return NULL;
 516 }
 517
 518 void qemu_cpu_kick(void *_env)
 519 {
 520     CPUState *env = _env;
 521     qemu_cond_broadcast(env->halt_cond);
 522     qemu_thread_signal(env->thread, SIG_IPI);
 523 }
 524
 525 int qemu_cpu_self(void *_env)
 526 {
 527     CPUState *env = _env;
 528     QemuThread this;
 529
 530     qemu_thread_self(&this);
 531
 532     return qemu_thread_equal(&this, env->thread);
 533 }
 534
 535 static void cpu_signal(int sig)
 536 {
 537     if (cpu_single_env)
 538         cpu_exit(cpu_single_env);
 539     exit_request = 1;
 540 }
 541
 542 static void tcg_block_io_signals(void)
 543 {
 544     sigset_t set;
 545     struct sigaction sigact;
 546
 547     sigemptyset(&set);
 548     sigaddset(&set, SIGUSR2);
 549     sigaddset(&set, SIGIO);
 550     sigaddset(&set, SIGALRM);
 551     sigaddset(&set, SIGCHLD);
 552     pthread_sigmask(SIG_BLOCK, &set, NULL);
 553
 554     sigemptyset(&set);
 555     sigaddset(&set, SIG_IPI);
 556     pthread_sigmask(SIG_UNBLOCK, &set, NULL);
 557
 558     memset(&sigact, 0, sizeof(sigact));
 559     sigact.sa_handler = cpu_signal;
 560     sigaction(SIG_IPI, &sigact, NULL);
 561 }
 562
 563 static void dummy_signal(int sig)
 564 {
 565 }
 566
 567 static void kvm_block_io_signals(CPUState *env)
 568 {
 569     int r;
 570     sigset_t set;
 571     struct sigaction sigact;
 572
 573     sigemptyset(&set);
 574     sigaddset(&set, SIGUSR2);
 575     sigaddset(&set, SIGIO);
 576     sigaddset(&set, SIGALRM);
 577     sigaddset(&set, SIGCHLD);
 578     sigaddset(&set, SIG_IPI);
 579     pthread_sigmask(SIG_BLOCK, &set, NULL);
 580
 581     pthread_sigmask(SIG_BLOCK, NULL, &set);
 582     sigdelset(&set, SIG_IPI);
 583
 584     memset(&sigact, 0, sizeof(sigact));
 585     sigact.sa_handler = dummy_signal;
 586     sigaction(SIG_IPI, &sigact, NULL);
 587
 588     r = kvm_set_signal_mask(env, &set);
 589     if (r) {
 590         fprintf(stderr, "kvm_set_signal_mask: %s\n", strerror(r));
 591         exit(1);
 592     }
 593 }
 594
 595 static void unblock_io_signals(void)
 596 {
 597     sigset_t set;
 598
 599     sigemptyset(&set);
 600     sigaddset(&set, SIGUSR2);
 601     sigaddset(&set, SIGIO);
 602     sigaddset(&set, SIGALRM);
 603     pthread_sigmask(SIG_UNBLOCK, &set, NULL);
 604
 605     sigemptyset(&set);
 606     sigaddset(&set, SIG_IPI);
 607     pthread_sigmask(SIG_BLOCK, &set, NULL);
 608 }
 609
 610 void qemu_mutex_lock_iothread(void)
 611 {
 612     if (kvm_enabled()) {
 613         qemu_mutex_lock(&qemu_fair_mutex);
 614         qemu_mutex_lock(&qemu_global_mutex);
 615         qemu_mutex_unlock(&qemu_fair_mutex);
 616     } else {
 617         qemu_mutex_lock(&qemu_fair_mutex);
 618         if (qemu_mutex_trylock(&qemu_global_mutex)) {
 619             qemu_thread_signal(tcg_cpu_thread, SIG_IPI);
 620             qemu_mutex_lock(&qemu_global_mutex);
 621         }
 622         qemu_mutex_unlock(&qemu_fair_mutex);
 623     }
 624 }
 625
 626 void qemu_mutex_unlock_iothread(void)
 627 {
 628     qemu_mutex_unlock(&qemu_global_mutex);
 629 }
 630
 631 static int all_vcpus_paused(void)
 632 {
 633     CPUState *penv = first_cpu;
 634
 635     while (penv) {
 636         if (!penv->stopped)
 637             return 0;
 638         penv = (CPUState *)penv->next_cpu;
 639     }
 640
 641     return 1;
 642 }
 643
 644 void pause_all_vcpus(void)
 645 {
 646     CPUState *penv = first_cpu;
 647
 648     while (penv) {
 649         penv->stop = 1;
 650         qemu_cpu_kick(penv);
 651         penv = (CPUState *)penv->next_cpu;
 652     }
 653
 654     while (!all_vcpus_paused()) {
 655         qemu_cond_timedwait(&qemu_pause_cond, &qemu_global_mutex, 100);
 656         penv = first_cpu;
 657         while (penv) {
 658             qemu_cpu_kick(penv);
 659             penv = (CPUState *)penv->next_cpu;
 660         }
 661     }
 662 }
 663
 664 void resume_all_vcpus(void)
 665 {
 666     CPUState *penv = first_cpu;
 667
 668     while (penv) {
 669         penv->stop = 0;
 670         penv->stopped = 0;
 671         qemu_cpu_kick(penv);
 672         penv = (CPUState *)penv->next_cpu;
 673     }
 674 }
 675
 676 static void tcg_init_vcpu(void *_env)
 677 {
 678     CPUState *env = _env;
 679     /* share a single thread for all cpus with TCG */
 680     if (!tcg_cpu_thread) {
 681         env->thread = qemu_mallocz(sizeof(QemuThread));
 682         env->halt_cond = qemu_mallocz(sizeof(QemuCond));
 683         qemu_cond_init(env->halt_cond);
 684         qemu_thread_create(env->thread, tcg_cpu_thread_fn, env);
 685         while (env->created == 0)
 686             qemu_cond_timedwait(&qemu_cpu_cond, &qemu_global_mutex, 100);
 687         tcg_cpu_thread = env->thread;
 688         tcg_halt_cond = env->halt_cond;
 689     } else {
 690         env->thread = tcg_cpu_thread;
 691         env->halt_cond = tcg_halt_cond;
 692     }
 693 }
 694
 695 static void kvm_start_vcpu(CPUState *env)
 696 {
 697     env->thread = qemu_mallocz(sizeof(QemuThread));
 698     env->halt_cond = qemu_mallocz(sizeof(QemuCond));
 699     qemu_cond_init(env->halt_cond);
 700     qemu_thread_create(env->thread, kvm_cpu_thread_fn, env);
 701     while (env->created == 0)
 702         qemu_cond_timedwait(&qemu_cpu_cond, &qemu_global_mutex, 100);
 703 }
 704
 705 void qemu_init_vcpu(void *_env)
 706 {
 707     CPUState *env = _env;
 708
 709     env->nr_cores = smp_cores;
 710     env->nr_threads = smp_threads;
 711     if (kvm_enabled())
 712         kvm_start_vcpu(env);
 713     else
 714         tcg_init_vcpu(env);
 715 }
 716
 717 void qemu_notify_event(void)
 718 {
 719     qemu_event_increment();
 720 }
 721
 722 static void qemu_system_vmstop_request(int reason)
 723 {
 724     vmstop_requested = reason;
 725     qemu_notify_event();
 726 }
 727
 728 void vm_stop(int reason)
 729 {
 730     QemuThread me;
 731     qemu_thread_self(&me);
 732
 733     if (!qemu_thread_equal(&me, &io_thread)) {
 734         qemu_system_vmstop_request(reason);
 735         /*
 736          * FIXME: should not return to device code in case
 737          * vm_stop() has been requested.
 738          */
 739         if (cpu_single_env) {
 740             cpu_exit(cpu_single_env);
 741             cpu_single_env->stop = 1;
 742         }
 743         return;
 744     }
 745     do_vm_stop(reason);
 746 }
 747
 748 #endif
 749
 750 static int qemu_cpu_exec(CPUState *env)
 751 {
 752     int ret;
 753 #ifdef CONFIG_PROFILER
 754     int64_t ti;
 755 #endif
 756
 757 #ifdef CONFIG_PROFILER
 758     ti = profile_getclock();
 759 #endif
 760     if (use_icount) {
 761         int64_t count;
 762         int decr;
 763         qemu_icount -= (env->icount_decr.u16.low + env->icount_extra);
 764         env->icount_decr.u16.low = 0;
 765         env->icount_extra = 0;
 766         count = qemu_icount_round (qemu_next_deadline());
 767         qemu_icount += count;
 768         decr = (count > 0xffff) ? 0xffff : count;
 769         count -= decr;
 770         env->icount_decr.u16.low = decr;
 771         env->icount_extra = count;
 772     }
 773     ret = cpu_exec(env);
 774 #ifdef CONFIG_PROFILER
 775     qemu_time += profile_getclock() - ti;
 776 #endif
 777     if (use_icount) {
 778         /* Fold pending instructions back into the
 779            instruction counter, and clear the interrupt flag.  */
 780         qemu_icount -= (env->icount_decr.u16.low
 781                         + env->icount_extra);
 782         env->icount_decr.u32 = 0;
 783         env->icount_extra = 0;
 784     }
 785     return ret;
 786 }
 787
 788 bool tcg_cpu_exec(void)
 789 {
 790     int ret = 0;
 791
 792     if (next_cpu == NULL)
 793         next_cpu = first_cpu;
 794     for (; next_cpu != NULL; next_cpu = next_cpu->next_cpu) {
 795         CPUState *env = cur_cpu = next_cpu;
 796
 797         qemu_clock_enable(vm_clock,
 798                           (cur_cpu->singlestep_enabled & SSTEP_NOTIMER) == 0);
 799
 800         if (qemu_alarm_pending())
 801             break;
 802         if (cpu_can_run(env))
 803             ret = qemu_cpu_exec(env);
 804         else if (env->stop)
 805             break;
 806
 807         if (ret == EXCP_DEBUG) {
 808             gdb_set_stop_cpu(env);
 809             debug_requested = EXCP_DEBUG;
 810             break;
 811         }
 812     }
 813     return tcg_has_work();
 814 }
 815
 816 void set_numa_modes(void)
 817 {
 818     CPUState *env;
 819     int i;
 820
 821     for (env = first_cpu; env != NULL; env = env->next_cpu) {
 822         for (i = 0; i < nb_numa_nodes; i++) {
 823             if (node_cpumask[i] & (1 << env->cpu_index)) {
 824                 env->numa_node = i;
 825             }
 826         }
 827     }
 828 }
 829
 830 void set_cpu_log(const char *optarg)
 831 {
 832     int mask;
 833     const CPULogItem *item;
 834
 835     mask = cpu_str_to_log_mask(optarg);
 836     if (!mask) {
 837         printf("Log items (comma separated):\n");
 838         for (item = cpu_log_items; item->mask != 0; item++) {
 839             printf("%-10s %s\n", item->name, item->help);
 840         }
 841         exit(1);
 842     }
 843     cpu_set_log(mask);
 844 }
 845
 846 /* Return the virtual CPU time, based on the instruction counter.  */
 847 int64_t cpu_get_icount(void)
 848 {
 849     int64_t icount;
 850     CPUState *env = cpu_single_env;;
 851
 852     icount = qemu_icount;
 853     if (env) {
 854         if (!can_do_io(env)) {
 855             fprintf(stderr, "Bad clock read\n");
 856         }
 857         icount -= (env->icount_decr.u16.low + env->icount_extra);
 858     }
 859     return qemu_icount_bias + (icount << icount_time_shift);
 860 }
 861
 862 void list_cpus(FILE *f, int (*cpu_fprintf)(FILE *f, const char *fmt, ...),
 863                const char *optarg)
 864 {
 865     /* XXX: implement xxx_cpu_list for targets that still miss it */
 866 #if defined(cpu_list_id)
 867     cpu_list_id(f, cpu_fprintf, optarg);
 868 #elif defined(cpu_list)
 869     cpu_list(f, cpu_fprintf); /* deprecated */
 870 #endif
 871 }