bitops: fix error on OpenBSD and mingw32
[qemu.git] / qemu-timer.c
blob88c7b28853f99a3a6b504ea481e1f5194a3cd21e
1 /*
2 * QEMU System Emulator
4 * Copyright (c) 2003-2008 Fabrice Bellard
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:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
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.
25 #include "sysemu.h"
26 #include "net.h"
27 #include "monitor.h"
28 #include "console.h"
30 #include "hw/hw.h"
32 #include <unistd.h>
33 #include <fcntl.h>
34 #include <time.h>
35 #include <errno.h>
36 #include <sys/time.h>
37 #include <signal.h>
38 #ifdef __FreeBSD__
39 #include <sys/param.h>
40 #endif
42 #ifdef __linux__
43 #include <sys/ioctl.h>
44 #include <linux/rtc.h>
45 /* For the benefit of older linux systems which don't supply it,
46 we use a local copy of hpet.h. */
47 /* #include <linux/hpet.h> */
48 #include "hpet.h"
49 #endif
51 #ifdef _WIN32
52 #include <windows.h>
53 #include <mmsystem.h>
54 #endif
56 #include "qemu-timer.h"
58 /* Conversion factor from emulated instructions to virtual clock ticks. */
59 int icount_time_shift;
60 /* Arbitrarily pick 1MIPS as the minimum allowable speed. */
61 #define MAX_ICOUNT_SHIFT 10
62 /* Compensate for varying guest execution speed. */
63 int64_t qemu_icount_bias;
64 static QEMUTimer *icount_rt_timer;
65 static QEMUTimer *icount_vm_timer;
67 /***********************************************************/
68 /* guest cycle counter */
70 typedef struct TimersState {
71 int64_t cpu_ticks_prev;
72 int64_t cpu_ticks_offset;
73 int64_t cpu_clock_offset;
74 int32_t cpu_ticks_enabled;
75 int64_t dummy;
76 } TimersState;
78 TimersState timers_state;
80 /* return the host CPU cycle counter and handle stop/restart */
81 int64_t cpu_get_ticks(void)
83 if (use_icount) {
84 return cpu_get_icount();
86 if (!timers_state.cpu_ticks_enabled) {
87 return timers_state.cpu_ticks_offset;
88 } else {
89 int64_t ticks;
90 ticks = cpu_get_real_ticks();
91 if (timers_state.cpu_ticks_prev > ticks) {
92 /* Note: non increasing ticks may happen if the host uses
93 software suspend */
94 timers_state.cpu_ticks_offset += timers_state.cpu_ticks_prev - ticks;
96 timers_state.cpu_ticks_prev = ticks;
97 return ticks + timers_state.cpu_ticks_offset;
101 /* return the host CPU monotonic timer and handle stop/restart */
102 static int64_t cpu_get_clock(void)
104 int64_t ti;
105 if (!timers_state.cpu_ticks_enabled) {
106 return timers_state.cpu_clock_offset;
107 } else {
108 ti = get_clock();
109 return ti + timers_state.cpu_clock_offset;
113 static int64_t qemu_icount_delta(void)
115 if (use_icount == 1) {
116 /* When not using an adaptive execution frequency
117 we tend to get badly out of sync with real time,
118 so just delay for a reasonable amount of time. */
119 return 0;
120 } else {
121 return cpu_get_icount() - cpu_get_clock();
125 /* enable cpu_get_ticks() */
126 void cpu_enable_ticks(void)
128 if (!timers_state.cpu_ticks_enabled) {
129 timers_state.cpu_ticks_offset -= cpu_get_real_ticks();
130 timers_state.cpu_clock_offset -= get_clock();
131 timers_state.cpu_ticks_enabled = 1;
135 /* disable cpu_get_ticks() : the clock is stopped. You must not call
136 cpu_get_ticks() after that. */
137 void cpu_disable_ticks(void)
139 if (timers_state.cpu_ticks_enabled) {
140 timers_state.cpu_ticks_offset = cpu_get_ticks();
141 timers_state.cpu_clock_offset = cpu_get_clock();
142 timers_state.cpu_ticks_enabled = 0;
146 /***********************************************************/
147 /* timers */
149 #define QEMU_CLOCK_REALTIME 0
150 #define QEMU_CLOCK_VIRTUAL 1
151 #define QEMU_CLOCK_HOST 2
153 struct QEMUClock {
154 int type;
155 int enabled;
156 /* XXX: add frequency */
159 struct QEMUTimer {
160 QEMUClock *clock;
161 int64_t expire_time;
162 QEMUTimerCB *cb;
163 void *opaque;
164 struct QEMUTimer *next;
167 struct qemu_alarm_timer {
168 char const *name;
169 int (*start)(struct qemu_alarm_timer *t);
170 void (*stop)(struct qemu_alarm_timer *t);
171 void (*rearm)(struct qemu_alarm_timer *t);
172 void *priv;
174 char expired;
175 char pending;
178 static struct qemu_alarm_timer *alarm_timer;
180 int qemu_alarm_pending(void)
182 return alarm_timer->pending;
185 static inline int alarm_has_dynticks(struct qemu_alarm_timer *t)
187 return !!t->rearm;
190 static void qemu_rearm_alarm_timer(struct qemu_alarm_timer *t)
192 if (!alarm_has_dynticks(t))
193 return;
195 t->rearm(t);
198 /* TODO: MIN_TIMER_REARM_NS should be optimized */
199 #define MIN_TIMER_REARM_NS 250000
201 #ifdef _WIN32
203 struct qemu_alarm_win32 {
204 MMRESULT timerId;
205 unsigned int period;
206 } alarm_win32_data = {0, 0};
208 static int win32_start_timer(struct qemu_alarm_timer *t);
209 static void win32_stop_timer(struct qemu_alarm_timer *t);
210 static void win32_rearm_timer(struct qemu_alarm_timer *t);
212 #else
214 static int unix_start_timer(struct qemu_alarm_timer *t);
215 static void unix_stop_timer(struct qemu_alarm_timer *t);
217 #ifdef __linux__
219 static int dynticks_start_timer(struct qemu_alarm_timer *t);
220 static void dynticks_stop_timer(struct qemu_alarm_timer *t);
221 static void dynticks_rearm_timer(struct qemu_alarm_timer *t);
223 static int hpet_start_timer(struct qemu_alarm_timer *t);
224 static void hpet_stop_timer(struct qemu_alarm_timer *t);
226 static int rtc_start_timer(struct qemu_alarm_timer *t);
227 static void rtc_stop_timer(struct qemu_alarm_timer *t);
229 #endif /* __linux__ */
231 #endif /* _WIN32 */
233 /* Correlation between real and virtual time is always going to be
234 fairly approximate, so ignore small variation.
235 When the guest is idle real and virtual time will be aligned in
236 the IO wait loop. */
237 #define ICOUNT_WOBBLE (get_ticks_per_sec() / 10)
239 static void icount_adjust(void)
241 int64_t cur_time;
242 int64_t cur_icount;
243 int64_t delta;
244 static int64_t last_delta;
245 /* If the VM is not running, then do nothing. */
246 if (!vm_running)
247 return;
249 cur_time = cpu_get_clock();
250 cur_icount = qemu_get_clock(vm_clock);
251 delta = cur_icount - cur_time;
252 /* FIXME: This is a very crude algorithm, somewhat prone to oscillation. */
253 if (delta > 0
254 && last_delta + ICOUNT_WOBBLE < delta * 2
255 && icount_time_shift > 0) {
256 /* The guest is getting too far ahead. Slow time down. */
257 icount_time_shift--;
259 if (delta < 0
260 && last_delta - ICOUNT_WOBBLE > delta * 2
261 && icount_time_shift < MAX_ICOUNT_SHIFT) {
262 /* The guest is getting too far behind. Speed time up. */
263 icount_time_shift++;
265 last_delta = delta;
266 qemu_icount_bias = cur_icount - (qemu_icount << icount_time_shift);
269 static void icount_adjust_rt(void * opaque)
271 qemu_mod_timer(icount_rt_timer,
272 qemu_get_clock(rt_clock) + 1000);
273 icount_adjust();
276 static void icount_adjust_vm(void * opaque)
278 qemu_mod_timer(icount_vm_timer,
279 qemu_get_clock(vm_clock) + get_ticks_per_sec() / 10);
280 icount_adjust();
283 int64_t qemu_icount_round(int64_t count)
285 return (count + (1 << icount_time_shift) - 1) >> icount_time_shift;
288 static struct qemu_alarm_timer alarm_timers[] = {
289 #ifndef _WIN32
290 #ifdef __linux__
291 {"dynticks", dynticks_start_timer,
292 dynticks_stop_timer, dynticks_rearm_timer, NULL},
293 /* HPET - if available - is preferred */
294 {"hpet", hpet_start_timer, hpet_stop_timer, NULL, NULL},
295 /* ...otherwise try RTC */
296 {"rtc", rtc_start_timer, rtc_stop_timer, NULL, NULL},
297 #endif
298 {"unix", unix_start_timer, unix_stop_timer, NULL, NULL},
299 #else
300 {"dynticks", win32_start_timer,
301 win32_stop_timer, win32_rearm_timer, &alarm_win32_data},
302 {"win32", win32_start_timer,
303 win32_stop_timer, NULL, &alarm_win32_data},
304 #endif
305 {NULL, }
308 static void show_available_alarms(void)
310 int i;
312 printf("Available alarm timers, in order of precedence:\n");
313 for (i = 0; alarm_timers[i].name; i++)
314 printf("%s\n", alarm_timers[i].name);
317 void configure_alarms(char const *opt)
319 int i;
320 int cur = 0;
321 int count = ARRAY_SIZE(alarm_timers) - 1;
322 char *arg;
323 char *name;
324 struct qemu_alarm_timer tmp;
326 if (!strcmp(opt, "?")) {
327 show_available_alarms();
328 exit(0);
331 arg = qemu_strdup(opt);
333 /* Reorder the array */
334 name = strtok(arg, ",");
335 while (name) {
336 for (i = 0; i < count && alarm_timers[i].name; i++) {
337 if (!strcmp(alarm_timers[i].name, name))
338 break;
341 if (i == count) {
342 fprintf(stderr, "Unknown clock %s\n", name);
343 goto next;
346 if (i < cur)
347 /* Ignore */
348 goto next;
350 /* Swap */
351 tmp = alarm_timers[i];
352 alarm_timers[i] = alarm_timers[cur];
353 alarm_timers[cur] = tmp;
355 cur++;
356 next:
357 name = strtok(NULL, ",");
360 qemu_free(arg);
362 if (cur) {
363 /* Disable remaining timers */
364 for (i = cur; i < count; i++)
365 alarm_timers[i].name = NULL;
366 } else {
367 show_available_alarms();
368 exit(1);
372 #define QEMU_NUM_CLOCKS 3
374 QEMUClock *rt_clock;
375 QEMUClock *vm_clock;
376 QEMUClock *host_clock;
378 static QEMUTimer *active_timers[QEMU_NUM_CLOCKS];
380 static QEMUClock *qemu_new_clock(int type)
382 QEMUClock *clock;
383 clock = qemu_mallocz(sizeof(QEMUClock));
384 clock->type = type;
385 clock->enabled = 1;
386 return clock;
389 void qemu_clock_enable(QEMUClock *clock, int enabled)
391 clock->enabled = enabled;
394 QEMUTimer *qemu_new_timer(QEMUClock *clock, QEMUTimerCB *cb, void *opaque)
396 QEMUTimer *ts;
398 ts = qemu_mallocz(sizeof(QEMUTimer));
399 ts->clock = clock;
400 ts->cb = cb;
401 ts->opaque = opaque;
402 return ts;
405 void qemu_free_timer(QEMUTimer *ts)
407 qemu_free(ts);
410 /* stop a timer, but do not dealloc it */
411 void qemu_del_timer(QEMUTimer *ts)
413 QEMUTimer **pt, *t;
415 /* NOTE: this code must be signal safe because
416 qemu_timer_expired() can be called from a signal. */
417 pt = &active_timers[ts->clock->type];
418 for(;;) {
419 t = *pt;
420 if (!t)
421 break;
422 if (t == ts) {
423 *pt = t->next;
424 break;
426 pt = &t->next;
430 /* modify the current timer so that it will be fired when current_time
431 >= expire_time. The corresponding callback will be called. */
432 void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time)
434 QEMUTimer **pt, *t;
436 qemu_del_timer(ts);
438 /* add the timer in the sorted list */
439 /* NOTE: this code must be signal safe because
440 qemu_timer_expired() can be called from a signal. */
441 pt = &active_timers[ts->clock->type];
442 for(;;) {
443 t = *pt;
444 if (!t)
445 break;
446 if (t->expire_time > expire_time)
447 break;
448 pt = &t->next;
450 ts->expire_time = expire_time;
451 ts->next = *pt;
452 *pt = ts;
454 /* Rearm if necessary */
455 if (pt == &active_timers[ts->clock->type]) {
456 if (!alarm_timer->pending) {
457 qemu_rearm_alarm_timer(alarm_timer);
459 /* Interrupt execution to force deadline recalculation. */
460 if (use_icount)
461 qemu_notify_event();
465 int qemu_timer_pending(QEMUTimer *ts)
467 QEMUTimer *t;
468 for(t = active_timers[ts->clock->type]; t != NULL; t = t->next) {
469 if (t == ts)
470 return 1;
472 return 0;
475 int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time)
477 if (!timer_head)
478 return 0;
479 return (timer_head->expire_time <= current_time);
482 static void qemu_run_timers(QEMUClock *clock)
484 QEMUTimer **ptimer_head, *ts;
485 int64_t current_time;
487 if (!clock->enabled)
488 return;
490 current_time = qemu_get_clock (clock);
491 ptimer_head = &active_timers[clock->type];
492 for(;;) {
493 ts = *ptimer_head;
494 if (!ts || ts->expire_time > current_time)
495 break;
496 /* remove timer from the list before calling the callback */
497 *ptimer_head = ts->next;
498 ts->next = NULL;
500 /* run the callback (the timer list can be modified) */
501 ts->cb(ts->opaque);
505 int64_t qemu_get_clock(QEMUClock *clock)
507 switch(clock->type) {
508 case QEMU_CLOCK_REALTIME:
509 return get_clock() / 1000000;
510 default:
511 case QEMU_CLOCK_VIRTUAL:
512 if (use_icount) {
513 return cpu_get_icount();
514 } else {
515 return cpu_get_clock();
517 case QEMU_CLOCK_HOST:
518 return get_clock_realtime();
522 int64_t qemu_get_clock_ns(QEMUClock *clock)
524 switch(clock->type) {
525 case QEMU_CLOCK_REALTIME:
526 return get_clock();
527 default:
528 case QEMU_CLOCK_VIRTUAL:
529 if (use_icount) {
530 return cpu_get_icount();
531 } else {
532 return cpu_get_clock();
534 case QEMU_CLOCK_HOST:
535 return get_clock_realtime();
539 void init_clocks(void)
541 rt_clock = qemu_new_clock(QEMU_CLOCK_REALTIME);
542 vm_clock = qemu_new_clock(QEMU_CLOCK_VIRTUAL);
543 host_clock = qemu_new_clock(QEMU_CLOCK_HOST);
545 rtc_clock = host_clock;
548 /* save a timer */
549 void qemu_put_timer(QEMUFile *f, QEMUTimer *ts)
551 uint64_t expire_time;
553 if (qemu_timer_pending(ts)) {
554 expire_time = ts->expire_time;
555 } else {
556 expire_time = -1;
558 qemu_put_be64(f, expire_time);
561 void qemu_get_timer(QEMUFile *f, QEMUTimer *ts)
563 uint64_t expire_time;
565 expire_time = qemu_get_be64(f);
566 if (expire_time != -1) {
567 qemu_mod_timer(ts, expire_time);
568 } else {
569 qemu_del_timer(ts);
573 static const VMStateDescription vmstate_timers = {
574 .name = "timer",
575 .version_id = 2,
576 .minimum_version_id = 1,
577 .minimum_version_id_old = 1,
578 .fields = (VMStateField []) {
579 VMSTATE_INT64(cpu_ticks_offset, TimersState),
580 VMSTATE_INT64(dummy, TimersState),
581 VMSTATE_INT64_V(cpu_clock_offset, TimersState, 2),
582 VMSTATE_END_OF_LIST()
586 void configure_icount(const char *option)
588 vmstate_register(NULL, 0, &vmstate_timers, &timers_state);
589 if (!option)
590 return;
592 if (strcmp(option, "auto") != 0) {
593 icount_time_shift = strtol(option, NULL, 0);
594 use_icount = 1;
595 return;
598 use_icount = 2;
600 /* 125MIPS seems a reasonable initial guess at the guest speed.
601 It will be corrected fairly quickly anyway. */
602 icount_time_shift = 3;
604 /* Have both realtime and virtual time triggers for speed adjustment.
605 The realtime trigger catches emulated time passing too slowly,
606 the virtual time trigger catches emulated time passing too fast.
607 Realtime triggers occur even when idle, so use them less frequently
608 than VM triggers. */
609 icount_rt_timer = qemu_new_timer(rt_clock, icount_adjust_rt, NULL);
610 qemu_mod_timer(icount_rt_timer,
611 qemu_get_clock(rt_clock) + 1000);
612 icount_vm_timer = qemu_new_timer(vm_clock, icount_adjust_vm, NULL);
613 qemu_mod_timer(icount_vm_timer,
614 qemu_get_clock(vm_clock) + get_ticks_per_sec() / 10);
617 void qemu_run_all_timers(void)
619 alarm_timer->pending = 0;
621 /* rearm timer, if not periodic */
622 if (alarm_timer->expired) {
623 alarm_timer->expired = 0;
624 qemu_rearm_alarm_timer(alarm_timer);
627 /* vm time timers */
628 if (vm_running) {
629 qemu_run_timers(vm_clock);
632 qemu_run_timers(rt_clock);
633 qemu_run_timers(host_clock);
636 static int64_t qemu_next_alarm_deadline(void);
638 #ifdef _WIN32
639 static void CALLBACK host_alarm_handler(UINT uTimerID, UINT uMsg,
640 DWORD_PTR dwUser, DWORD_PTR dw1,
641 DWORD_PTR dw2)
642 #else
643 static void host_alarm_handler(int host_signum)
644 #endif
646 struct qemu_alarm_timer *t = alarm_timer;
647 if (!t)
648 return;
650 #if 0
651 #define DISP_FREQ 1000
653 static int64_t delta_min = INT64_MAX;
654 static int64_t delta_max, delta_cum, last_clock, delta, ti;
655 static int count;
656 ti = qemu_get_clock(vm_clock);
657 if (last_clock != 0) {
658 delta = ti - last_clock;
659 if (delta < delta_min)
660 delta_min = delta;
661 if (delta > delta_max)
662 delta_max = delta;
663 delta_cum += delta;
664 if (++count == DISP_FREQ) {
665 printf("timer: min=%" PRId64 " us max=%" PRId64 " us avg=%" PRId64 " us avg_freq=%0.3f Hz\n",
666 muldiv64(delta_min, 1000000, get_ticks_per_sec()),
667 muldiv64(delta_max, 1000000, get_ticks_per_sec()),
668 muldiv64(delta_cum, 1000000 / DISP_FREQ, get_ticks_per_sec()),
669 (double)get_ticks_per_sec() / ((double)delta_cum / DISP_FREQ));
670 count = 0;
671 delta_min = INT64_MAX;
672 delta_max = 0;
673 delta_cum = 0;
676 last_clock = ti;
678 #endif
679 if (alarm_has_dynticks(t) ||
680 qemu_next_alarm_deadline () <= 0) {
681 t->expired = alarm_has_dynticks(t);
682 t->pending = 1;
683 qemu_notify_event();
687 int64_t qemu_next_deadline(void)
689 /* To avoid problems with overflow limit this to 2^32. */
690 int64_t delta = INT32_MAX;
692 if (active_timers[QEMU_CLOCK_VIRTUAL]) {
693 delta = active_timers[QEMU_CLOCK_VIRTUAL]->expire_time -
694 qemu_get_clock_ns(vm_clock);
696 if (active_timers[QEMU_CLOCK_HOST]) {
697 int64_t hdelta = active_timers[QEMU_CLOCK_HOST]->expire_time -
698 qemu_get_clock_ns(host_clock);
699 if (hdelta < delta)
700 delta = hdelta;
703 if (delta < 0)
704 delta = 0;
706 return delta;
709 static int64_t qemu_next_alarm_deadline(void)
711 int64_t delta;
712 int64_t rtdelta;
714 if (!use_icount && active_timers[QEMU_CLOCK_VIRTUAL]) {
715 delta = active_timers[QEMU_CLOCK_VIRTUAL]->expire_time -
716 qemu_get_clock(vm_clock);
717 } else {
718 delta = INT32_MAX;
720 if (active_timers[QEMU_CLOCK_HOST]) {
721 int64_t hdelta = active_timers[QEMU_CLOCK_HOST]->expire_time -
722 qemu_get_clock_ns(host_clock);
723 if (hdelta < delta)
724 delta = hdelta;
726 if (active_timers[QEMU_CLOCK_REALTIME]) {
727 rtdelta = (active_timers[QEMU_CLOCK_REALTIME]->expire_time * 1000000 -
728 qemu_get_clock_ns(rt_clock));
729 if (rtdelta < delta)
730 delta = rtdelta;
733 return delta;
736 #if defined(__linux__)
738 #define RTC_FREQ 1024
740 static void enable_sigio_timer(int fd)
742 struct sigaction act;
744 /* timer signal */
745 sigfillset(&act.sa_mask);
746 act.sa_flags = 0;
747 act.sa_handler = host_alarm_handler;
749 sigaction(SIGIO, &act, NULL);
750 fcntl_setfl(fd, O_ASYNC);
751 fcntl(fd, F_SETOWN, getpid());
754 static int hpet_start_timer(struct qemu_alarm_timer *t)
756 struct hpet_info info;
757 int r, fd;
759 fd = qemu_open("/dev/hpet", O_RDONLY);
760 if (fd < 0)
761 return -1;
763 /* Set frequency */
764 r = ioctl(fd, HPET_IRQFREQ, RTC_FREQ);
765 if (r < 0) {
766 fprintf(stderr, "Could not configure '/dev/hpet' to have a 1024Hz timer. This is not a fatal\n"
767 "error, but for better emulation accuracy type:\n"
768 "'echo 1024 > /proc/sys/dev/hpet/max-user-freq' as root.\n");
769 goto fail;
772 /* Check capabilities */
773 r = ioctl(fd, HPET_INFO, &info);
774 if (r < 0)
775 goto fail;
777 /* Enable periodic mode */
778 r = ioctl(fd, HPET_EPI, 0);
779 if (info.hi_flags && (r < 0))
780 goto fail;
782 /* Enable interrupt */
783 r = ioctl(fd, HPET_IE_ON, 0);
784 if (r < 0)
785 goto fail;
787 enable_sigio_timer(fd);
788 t->priv = (void *)(long)fd;
790 return 0;
791 fail:
792 close(fd);
793 return -1;
796 static void hpet_stop_timer(struct qemu_alarm_timer *t)
798 int fd = (long)t->priv;
800 close(fd);
803 static int rtc_start_timer(struct qemu_alarm_timer *t)
805 int rtc_fd;
806 unsigned long current_rtc_freq = 0;
808 TFR(rtc_fd = qemu_open("/dev/rtc", O_RDONLY));
809 if (rtc_fd < 0)
810 return -1;
811 ioctl(rtc_fd, RTC_IRQP_READ, &current_rtc_freq);
812 if (current_rtc_freq != RTC_FREQ &&
813 ioctl(rtc_fd, RTC_IRQP_SET, RTC_FREQ) < 0) {
814 fprintf(stderr, "Could not configure '/dev/rtc' to have a 1024 Hz timer. This is not a fatal\n"
815 "error, but for better emulation accuracy either use a 2.6 host Linux kernel or\n"
816 "type 'echo 1024 > /proc/sys/dev/rtc/max-user-freq' as root.\n");
817 goto fail;
819 if (ioctl(rtc_fd, RTC_PIE_ON, 0) < 0) {
820 fail:
821 close(rtc_fd);
822 return -1;
825 enable_sigio_timer(rtc_fd);
827 t->priv = (void *)(long)rtc_fd;
829 return 0;
832 static void rtc_stop_timer(struct qemu_alarm_timer *t)
834 int rtc_fd = (long)t->priv;
836 close(rtc_fd);
839 static int dynticks_start_timer(struct qemu_alarm_timer *t)
841 struct sigevent ev;
842 timer_t host_timer;
843 struct sigaction act;
845 sigfillset(&act.sa_mask);
846 act.sa_flags = 0;
847 act.sa_handler = host_alarm_handler;
849 sigaction(SIGALRM, &act, NULL);
852 * Initialize ev struct to 0 to avoid valgrind complaining
853 * about uninitialized data in timer_create call
855 memset(&ev, 0, sizeof(ev));
856 ev.sigev_value.sival_int = 0;
857 ev.sigev_notify = SIGEV_SIGNAL;
858 ev.sigev_signo = SIGALRM;
860 if (timer_create(CLOCK_REALTIME, &ev, &host_timer)) {
861 perror("timer_create");
863 /* disable dynticks */
864 fprintf(stderr, "Dynamic Ticks disabled\n");
866 return -1;
869 t->priv = (void *)(long)host_timer;
871 return 0;
874 static void dynticks_stop_timer(struct qemu_alarm_timer *t)
876 timer_t host_timer = (timer_t)(long)t->priv;
878 timer_delete(host_timer);
881 static void dynticks_rearm_timer(struct qemu_alarm_timer *t)
883 timer_t host_timer = (timer_t)(long)t->priv;
884 struct itimerspec timeout;
885 int64_t nearest_delta_ns = INT64_MAX;
886 int64_t current_ns;
888 assert(alarm_has_dynticks(t));
889 if (!active_timers[QEMU_CLOCK_REALTIME] &&
890 !active_timers[QEMU_CLOCK_VIRTUAL] &&
891 !active_timers[QEMU_CLOCK_HOST])
892 return;
894 nearest_delta_ns = qemu_next_alarm_deadline();
895 if (nearest_delta_ns < MIN_TIMER_REARM_NS)
896 nearest_delta_ns = MIN_TIMER_REARM_NS;
898 /* check whether a timer is already running */
899 if (timer_gettime(host_timer, &timeout)) {
900 perror("gettime");
901 fprintf(stderr, "Internal timer error: aborting\n");
902 exit(1);
904 current_ns = timeout.it_value.tv_sec * 1000000000LL + timeout.it_value.tv_nsec;
905 if (current_ns && current_ns <= nearest_delta_ns)
906 return;
908 timeout.it_interval.tv_sec = 0;
909 timeout.it_interval.tv_nsec = 0; /* 0 for one-shot timer */
910 timeout.it_value.tv_sec = nearest_delta_ns / 1000000000;
911 timeout.it_value.tv_nsec = nearest_delta_ns % 1000000000;
912 if (timer_settime(host_timer, 0 /* RELATIVE */, &timeout, NULL)) {
913 perror("settime");
914 fprintf(stderr, "Internal timer error: aborting\n");
915 exit(1);
919 #endif /* defined(__linux__) */
921 #if !defined(_WIN32)
923 static int unix_start_timer(struct qemu_alarm_timer *t)
925 struct sigaction act;
926 struct itimerval itv;
927 int err;
929 /* timer signal */
930 sigfillset(&act.sa_mask);
931 act.sa_flags = 0;
932 act.sa_handler = host_alarm_handler;
934 sigaction(SIGALRM, &act, NULL);
936 itv.it_interval.tv_sec = 0;
937 /* for i386 kernel 2.6 to get 1 ms */
938 itv.it_interval.tv_usec = 999;
939 itv.it_value.tv_sec = 0;
940 itv.it_value.tv_usec = 10 * 1000;
942 err = setitimer(ITIMER_REAL, &itv, NULL);
943 if (err)
944 return -1;
946 return 0;
949 static void unix_stop_timer(struct qemu_alarm_timer *t)
951 struct itimerval itv;
953 memset(&itv, 0, sizeof(itv));
954 setitimer(ITIMER_REAL, &itv, NULL);
957 #endif /* !defined(_WIN32) */
960 #ifdef _WIN32
962 static int win32_start_timer(struct qemu_alarm_timer *t)
964 TIMECAPS tc;
965 struct qemu_alarm_win32 *data = t->priv;
966 UINT flags;
968 memset(&tc, 0, sizeof(tc));
969 timeGetDevCaps(&tc, sizeof(tc));
971 data->period = tc.wPeriodMin;
972 timeBeginPeriod(data->period);
974 flags = TIME_CALLBACK_FUNCTION;
975 if (alarm_has_dynticks(t))
976 flags |= TIME_ONESHOT;
977 else
978 flags |= TIME_PERIODIC;
980 data->timerId = timeSetEvent(1, // interval (ms)
981 data->period, // resolution
982 host_alarm_handler, // function
983 (DWORD)t, // parameter
984 flags);
986 if (!data->timerId) {
987 fprintf(stderr, "Failed to initialize win32 alarm timer: %ld\n",
988 GetLastError());
989 timeEndPeriod(data->period);
990 return -1;
993 return 0;
996 static void win32_stop_timer(struct qemu_alarm_timer *t)
998 struct qemu_alarm_win32 *data = t->priv;
1000 timeKillEvent(data->timerId);
1001 timeEndPeriod(data->period);
1004 static void win32_rearm_timer(struct qemu_alarm_timer *t)
1006 struct qemu_alarm_win32 *data = t->priv;
1008 assert(alarm_has_dynticks(t));
1009 if (!active_timers[QEMU_CLOCK_REALTIME] &&
1010 !active_timers[QEMU_CLOCK_VIRTUAL] &&
1011 !active_timers[QEMU_CLOCK_HOST])
1012 return;
1014 timeKillEvent(data->timerId);
1016 data->timerId = timeSetEvent(1,
1017 data->period,
1018 host_alarm_handler,
1019 (DWORD)t,
1020 TIME_ONESHOT | TIME_CALLBACK_FUNCTION);
1022 if (!data->timerId) {
1023 fprintf(stderr, "Failed to re-arm win32 alarm timer %ld\n",
1024 GetLastError());
1026 timeEndPeriod(data->period);
1027 exit(1);
1031 #endif /* _WIN32 */
1033 static void alarm_timer_on_change_state_rearm(void *opaque, int running, int reason)
1035 if (running)
1036 qemu_rearm_alarm_timer((struct qemu_alarm_timer *) opaque);
1039 int init_timer_alarm(void)
1041 struct qemu_alarm_timer *t = NULL;
1042 int i, err = -1;
1044 for (i = 0; alarm_timers[i].name; i++) {
1045 t = &alarm_timers[i];
1047 err = t->start(t);
1048 if (!err)
1049 break;
1052 if (err) {
1053 err = -ENOENT;
1054 goto fail;
1057 /* first event is at time 0 */
1058 t->pending = 1;
1059 alarm_timer = t;
1060 qemu_add_vm_change_state_handler(alarm_timer_on_change_state_rearm, t);
1062 return 0;
1064 fail:
1065 return err;
1068 void quit_timers(void)
1070 struct qemu_alarm_timer *t = alarm_timer;
1071 alarm_timer = NULL;
1072 t->stop(t);
1075 int qemu_calculate_timeout(void)
1077 int timeout;
1078 int64_t add;
1079 int64_t delta;
1081 /* When using icount, making forward progress with qemu_icount when the
1082 guest CPU is idle is critical. We only use the static io-thread timeout
1083 for non icount runs. */
1084 if (!use_icount || !vm_running) {
1085 return 5000;
1088 /* Advance virtual time to the next event. */
1089 delta = qemu_icount_delta();
1090 if (delta > 0) {
1091 /* If virtual time is ahead of real time then just
1092 wait for IO. */
1093 timeout = (delta + 999999) / 1000000;
1094 } else {
1095 /* Wait for either IO to occur or the next
1096 timer event. */
1097 add = qemu_next_deadline();
1098 /* We advance the timer before checking for IO.
1099 Limit the amount we advance so that early IO
1100 activity won't get the guest too far ahead. */
1101 if (add > 10000000)
1102 add = 10000000;
1103 delta += add;
1104 qemu_icount += qemu_icount_round (add);
1105 timeout = delta / 1000000;
1106 if (timeout < 0)
1107 timeout = 0;
1110 return timeout;