]> git.proxmox.com Git - mirror_qemu.git/blob - cpus.c
TCG: Revert ppc64 tcg_out_movi32 change
[mirror_qemu.git] / 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 qemu_event_increment ();
294 if (env) {
295 cpu_exit(env);
296 }
297 if (next_cpu && env != next_cpu) {
298 cpu_exit(next_cpu);
299 }
300 }
301
302 void qemu_mutex_lock_iothread(void) {}
303 void qemu_mutex_unlock_iothread(void) {}
304
305 void vm_stop(int reason)
306 {
307 do_vm_stop(reason);
308 }
309
310 #else /* CONFIG_IOTHREAD */
311
312 #include "qemu-thread.h"
313
314 QemuMutex qemu_global_mutex;
315 static QemuMutex qemu_fair_mutex;
316
317 static QemuThread io_thread;
318
319 static QemuThread *tcg_cpu_thread;
320 static QemuCond *tcg_halt_cond;
321
322 static int qemu_system_ready;
323 /* cpu creation */
324 static QemuCond qemu_cpu_cond;
325 /* system init */
326 static QemuCond qemu_system_cond;
327 static QemuCond qemu_pause_cond;
328 static QemuCond qemu_work_cond;
329
330 static void tcg_init_ipi(void);
331 static void kvm_init_ipi(CPUState *env);
332 static void unblock_io_signals(void);
333
334 int qemu_init_main_loop(void)
335 {
336 int ret;
337
338 cpu_set_debug_excp_handler(cpu_debug_handler);
339
340 ret = qemu_event_init();
341 if (ret)
342 return ret;
343
344 qemu_cond_init(&qemu_pause_cond);
345 qemu_cond_init(&qemu_system_cond);
346 qemu_mutex_init(&qemu_fair_mutex);
347 qemu_mutex_init(&qemu_global_mutex);
348 qemu_mutex_lock(&qemu_global_mutex);
349
350 unblock_io_signals();
351 qemu_thread_self(&io_thread);
352
353 return 0;
354 }
355
356 void qemu_main_loop_start(void)
357 {
358 qemu_system_ready = 1;
359 qemu_cond_broadcast(&qemu_system_cond);
360 }
361
362 void run_on_cpu(CPUState *env, void (*func)(void *data), void *data)
363 {
364 struct qemu_work_item wi;
365
366 if (qemu_cpu_self(env)) {
367 func(data);
368 return;
369 }
370
371 wi.func = func;
372 wi.data = data;
373 if (!env->queued_work_first)
374 env->queued_work_first = &wi;
375 else
376 env->queued_work_last->next = &wi;
377 env->queued_work_last = &wi;
378 wi.next = NULL;
379 wi.done = false;
380
381 qemu_cpu_kick(env);
382 while (!wi.done) {
383 CPUState *self_env = cpu_single_env;
384
385 qemu_cond_wait(&qemu_work_cond, &qemu_global_mutex);
386 cpu_single_env = self_env;
387 }
388 }
389
390 static void flush_queued_work(CPUState *env)
391 {
392 struct qemu_work_item *wi;
393
394 if (!env->queued_work_first)
395 return;
396
397 while ((wi = env->queued_work_first)) {
398 env->queued_work_first = wi->next;
399 wi->func(wi->data);
400 wi->done = true;
401 }
402 env->queued_work_last = NULL;
403 qemu_cond_broadcast(&qemu_work_cond);
404 }
405
406 static void qemu_wait_io_event_common(CPUState *env)
407 {
408 if (env->stop) {
409 env->stop = 0;
410 env->stopped = 1;
411 qemu_cond_signal(&qemu_pause_cond);
412 }
413 flush_queued_work(env);
414 }
415
416 static void qemu_tcg_wait_io_event(void)
417 {
418 CPUState *env;
419
420 while (!any_cpu_has_work())
421 qemu_cond_timedwait(tcg_halt_cond, &qemu_global_mutex, 1000);
422
423 qemu_mutex_unlock(&qemu_global_mutex);
424
425 /*
426 * Users of qemu_global_mutex can be starved, having no chance
427 * to acquire it since this path will get to it first.
428 * So use another lock to provide fairness.
429 */
430 qemu_mutex_lock(&qemu_fair_mutex);
431 qemu_mutex_unlock(&qemu_fair_mutex);
432
433 qemu_mutex_lock(&qemu_global_mutex);
434
435 for (env = first_cpu; env != NULL; env = env->next_cpu) {
436 qemu_wait_io_event_common(env);
437 }
438 }
439
440 static void qemu_kvm_eat_signal(CPUState *env, int timeout)
441 {
442 struct timespec ts;
443 int r, e;
444 siginfo_t siginfo;
445 sigset_t waitset;
446
447 ts.tv_sec = timeout / 1000;
448 ts.tv_nsec = (timeout % 1000) * 1000000;
449
450 sigemptyset(&waitset);
451 sigaddset(&waitset, SIG_IPI);
452
453 qemu_mutex_unlock(&qemu_global_mutex);
454 r = sigtimedwait(&waitset, &siginfo, &ts);
455 e = errno;
456 qemu_mutex_lock(&qemu_global_mutex);
457
458 if (r == -1 && !(e == EAGAIN || e == EINTR)) {
459 fprintf(stderr, "sigtimedwait: %s\n", strerror(e));
460 exit(1);
461 }
462 }
463
464 static void qemu_kvm_wait_io_event(CPUState *env)
465 {
466 while (!cpu_has_work(env))
467 qemu_cond_timedwait(env->halt_cond, &qemu_global_mutex, 1000);
468
469 qemu_kvm_eat_signal(env, 0);
470 qemu_wait_io_event_common(env);
471 }
472
473 static int qemu_cpu_exec(CPUState *env);
474
475 static void *kvm_cpu_thread_fn(void *arg)
476 {
477 CPUState *env = arg;
478
479 qemu_mutex_lock(&qemu_global_mutex);
480 qemu_thread_self(env->thread);
481 if (kvm_enabled())
482 kvm_init_vcpu(env);
483
484 kvm_init_ipi(env);
485
486 /* signal CPU creation */
487 env->created = 1;
488 qemu_cond_signal(&qemu_cpu_cond);
489
490 /* and wait for machine initialization */
491 while (!qemu_system_ready)
492 qemu_cond_timedwait(&qemu_system_cond, &qemu_global_mutex, 100);
493
494 while (1) {
495 if (cpu_can_run(env))
496 qemu_cpu_exec(env);
497 qemu_kvm_wait_io_event(env);
498 }
499
500 return NULL;
501 }
502
503 static void *tcg_cpu_thread_fn(void *arg)
504 {
505 CPUState *env = arg;
506
507 tcg_init_ipi();
508 qemu_thread_self(env->thread);
509
510 /* signal CPU creation */
511 qemu_mutex_lock(&qemu_global_mutex);
512 for (env = first_cpu; env != NULL; env = env->next_cpu)
513 env->created = 1;
514 qemu_cond_signal(&qemu_cpu_cond);
515
516 /* and wait for machine initialization */
517 while (!qemu_system_ready)
518 qemu_cond_timedwait(&qemu_system_cond, &qemu_global_mutex, 100);
519
520 while (1) {
521 cpu_exec_all();
522 qemu_tcg_wait_io_event();
523 }
524
525 return NULL;
526 }
527
528 void qemu_cpu_kick(void *_env)
529 {
530 CPUState *env = _env;
531 qemu_cond_broadcast(env->halt_cond);
532 qemu_thread_signal(env->thread, SIG_IPI);
533 }
534
535 int qemu_cpu_self(void *_env)
536 {
537 CPUState *env = _env;
538 QemuThread this;
539
540 qemu_thread_self(&this);
541
542 return qemu_thread_equal(&this, env->thread);
543 }
544
545 static void cpu_signal(int sig)
546 {
547 if (cpu_single_env)
548 cpu_exit(cpu_single_env);
549 exit_request = 1;
550 }
551
552 static void tcg_init_ipi(void)
553 {
554 sigset_t set;
555 struct sigaction sigact;
556
557 memset(&sigact, 0, sizeof(sigact));
558 sigact.sa_handler = cpu_signal;
559 sigaction(SIG_IPI, &sigact, NULL);
560
561 sigemptyset(&set);
562 sigaddset(&set, SIG_IPI);
563 pthread_sigmask(SIG_UNBLOCK, &set, NULL);
564 }
565
566 static void dummy_signal(int sig)
567 {
568 }
569
570 static void kvm_init_ipi(CPUState *env)
571 {
572 int r;
573 sigset_t set;
574 struct sigaction sigact;
575
576 memset(&sigact, 0, sizeof(sigact));
577 sigact.sa_handler = dummy_signal;
578 sigaction(SIG_IPI, &sigact, NULL);
579
580 pthread_sigmask(SIG_BLOCK, NULL, &set);
581 sigdelset(&set, SIG_IPI);
582 r = kvm_set_signal_mask(env, &set);
583 if (r) {
584 fprintf(stderr, "kvm_set_signal_mask: %s\n", strerror(r));
585 exit(1);
586 }
587 }
588
589 static void unblock_io_signals(void)
590 {
591 sigset_t set;
592
593 sigemptyset(&set);
594 sigaddset(&set, SIGUSR2);
595 sigaddset(&set, SIGIO);
596 sigaddset(&set, SIGALRM);
597 pthread_sigmask(SIG_UNBLOCK, &set, NULL);
598
599 sigemptyset(&set);
600 sigaddset(&set, SIG_IPI);
601 pthread_sigmask(SIG_BLOCK, &set, NULL);
602 }
603
604 void qemu_mutex_lock_iothread(void)
605 {
606 if (kvm_enabled()) {
607 qemu_mutex_lock(&qemu_fair_mutex);
608 qemu_mutex_lock(&qemu_global_mutex);
609 qemu_mutex_unlock(&qemu_fair_mutex);
610 } else {
611 qemu_mutex_lock(&qemu_fair_mutex);
612 if (qemu_mutex_trylock(&qemu_global_mutex)) {
613 qemu_thread_signal(tcg_cpu_thread, SIG_IPI);
614 qemu_mutex_lock(&qemu_global_mutex);
615 }
616 qemu_mutex_unlock(&qemu_fair_mutex);
617 }
618 }
619
620 void qemu_mutex_unlock_iothread(void)
621 {
622 qemu_mutex_unlock(&qemu_global_mutex);
623 }
624
625 static int all_vcpus_paused(void)
626 {
627 CPUState *penv = first_cpu;
628
629 while (penv) {
630 if (!penv->stopped)
631 return 0;
632 penv = (CPUState *)penv->next_cpu;
633 }
634
635 return 1;
636 }
637
638 void pause_all_vcpus(void)
639 {
640 CPUState *penv = first_cpu;
641
642 while (penv) {
643 penv->stop = 1;
644 qemu_cpu_kick(penv);
645 penv = (CPUState *)penv->next_cpu;
646 }
647
648 while (!all_vcpus_paused()) {
649 qemu_cond_timedwait(&qemu_pause_cond, &qemu_global_mutex, 100);
650 penv = first_cpu;
651 while (penv) {
652 qemu_cpu_kick(penv);
653 penv = (CPUState *)penv->next_cpu;
654 }
655 }
656 }
657
658 void resume_all_vcpus(void)
659 {
660 CPUState *penv = first_cpu;
661
662 while (penv) {
663 penv->stop = 0;
664 penv->stopped = 0;
665 qemu_cpu_kick(penv);
666 penv = (CPUState *)penv->next_cpu;
667 }
668 }
669
670 static void tcg_init_vcpu(void *_env)
671 {
672 CPUState *env = _env;
673 /* share a single thread for all cpus with TCG */
674 if (!tcg_cpu_thread) {
675 env->thread = qemu_mallocz(sizeof(QemuThread));
676 env->halt_cond = qemu_mallocz(sizeof(QemuCond));
677 qemu_cond_init(env->halt_cond);
678 qemu_thread_create(env->thread, tcg_cpu_thread_fn, env);
679 while (env->created == 0)
680 qemu_cond_timedwait(&qemu_cpu_cond, &qemu_global_mutex, 100);
681 tcg_cpu_thread = env->thread;
682 tcg_halt_cond = env->halt_cond;
683 } else {
684 env->thread = tcg_cpu_thread;
685 env->halt_cond = tcg_halt_cond;
686 }
687 }
688
689 static void kvm_start_vcpu(CPUState *env)
690 {
691 env->thread = qemu_mallocz(sizeof(QemuThread));
692 env->halt_cond = qemu_mallocz(sizeof(QemuCond));
693 qemu_cond_init(env->halt_cond);
694 qemu_thread_create(env->thread, kvm_cpu_thread_fn, env);
695 while (env->created == 0)
696 qemu_cond_timedwait(&qemu_cpu_cond, &qemu_global_mutex, 100);
697 }
698
699 void qemu_init_vcpu(void *_env)
700 {
701 CPUState *env = _env;
702
703 env->nr_cores = smp_cores;
704 env->nr_threads = smp_threads;
705 if (kvm_enabled())
706 kvm_start_vcpu(env);
707 else
708 tcg_init_vcpu(env);
709 }
710
711 void qemu_notify_event(void)
712 {
713 qemu_event_increment();
714 }
715
716 static void qemu_system_vmstop_request(int reason)
717 {
718 vmstop_requested = reason;
719 qemu_notify_event();
720 }
721
722 void vm_stop(int reason)
723 {
724 QemuThread me;
725 qemu_thread_self(&me);
726
727 if (!qemu_thread_equal(&me, &io_thread)) {
728 qemu_system_vmstop_request(reason);
729 /*
730 * FIXME: should not return to device code in case
731 * vm_stop() has been requested.
732 */
733 if (cpu_single_env) {
734 cpu_exit(cpu_single_env);
735 cpu_single_env->stop = 1;
736 }
737 return;
738 }
739 do_vm_stop(reason);
740 }
741
742 #endif
743
744 static int qemu_cpu_exec(CPUState *env)
745 {
746 int ret;
747 #ifdef CONFIG_PROFILER
748 int64_t ti;
749 #endif
750
751 #ifdef CONFIG_PROFILER
752 ti = profile_getclock();
753 #endif
754 if (use_icount) {
755 int64_t count;
756 int decr;
757 qemu_icount -= (env->icount_decr.u16.low + env->icount_extra);
758 env->icount_decr.u16.low = 0;
759 env->icount_extra = 0;
760 count = qemu_icount_round (qemu_next_deadline());
761 qemu_icount += count;
762 decr = (count > 0xffff) ? 0xffff : count;
763 count -= decr;
764 env->icount_decr.u16.low = decr;
765 env->icount_extra = count;
766 }
767 ret = cpu_exec(env);
768 #ifdef CONFIG_PROFILER
769 qemu_time += profile_getclock() - ti;
770 #endif
771 if (use_icount) {
772 /* Fold pending instructions back into the
773 instruction counter, and clear the interrupt flag. */
774 qemu_icount -= (env->icount_decr.u16.low
775 + env->icount_extra);
776 env->icount_decr.u32 = 0;
777 env->icount_extra = 0;
778 }
779 return ret;
780 }
781
782 bool cpu_exec_all(void)
783 {
784 if (next_cpu == NULL)
785 next_cpu = first_cpu;
786 for (; next_cpu != NULL && !exit_request; next_cpu = next_cpu->next_cpu) {
787 CPUState *env = next_cpu;
788
789 qemu_clock_enable(vm_clock,
790 (env->singlestep_enabled & SSTEP_NOTIMER) == 0);
791
792 if (qemu_alarm_pending())
793 break;
794 if (cpu_can_run(env)) {
795 if (qemu_cpu_exec(env) == EXCP_DEBUG) {
796 break;
797 }
798 } else if (env->stop) {
799 break;
800 }
801 }
802 exit_request = 0;
803 return any_cpu_has_work();
804 }
805
806 void set_numa_modes(void)
807 {
808 CPUState *env;
809 int i;
810
811 for (env = first_cpu; env != NULL; env = env->next_cpu) {
812 for (i = 0; i < nb_numa_nodes; i++) {
813 if (node_cpumask[i] & (1 << env->cpu_index)) {
814 env->numa_node = i;
815 }
816 }
817 }
818 }
819
820 void set_cpu_log(const char *optarg)
821 {
822 int mask;
823 const CPULogItem *item;
824
825 mask = cpu_str_to_log_mask(optarg);
826 if (!mask) {
827 printf("Log items (comma separated):\n");
828 for (item = cpu_log_items; item->mask != 0; item++) {
829 printf("%-10s %s\n", item->name, item->help);
830 }
831 exit(1);
832 }
833 cpu_set_log(mask);
834 }
835
836 /* Return the virtual CPU time, based on the instruction counter. */
837 int64_t cpu_get_icount(void)
838 {
839 int64_t icount;
840 CPUState *env = cpu_single_env;;
841
842 icount = qemu_icount;
843 if (env) {
844 if (!can_do_io(env)) {
845 fprintf(stderr, "Bad clock read\n");
846 }
847 icount -= (env->icount_decr.u16.low + env->icount_extra);
848 }
849 return qemu_icount_bias + (icount << icount_time_shift);
850 }
851
852 void list_cpus(FILE *f, int (*cpu_fprintf)(FILE *f, const char *fmt, ...),
853 const char *optarg)
854 {
855 /* XXX: implement xxx_cpu_list for targets that still miss it */
856 #if defined(cpu_list_id)
857 cpu_list_id(f, cpu_fprintf, optarg);
858 #elif defined(cpu_list)
859 cpu_list(f, cpu_fprintf); /* deprecated */
860 #endif
861 }