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