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