qed: Add support for zero clusters
[qemu.git] / qemu-timer.c
blob50f1943afddafeb29c39259ab631c2dd5260ab71
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;
158 struct QEMUTimer {
159 QEMUClock *clock;
160 int64_t expire_time; /* in nanoseconds */
161 int scale;
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 static int win32_start_timer(struct qemu_alarm_timer *t);
204 static void win32_stop_timer(struct qemu_alarm_timer *t);
205 static void win32_rearm_timer(struct qemu_alarm_timer *t);
207 #else
209 static int unix_start_timer(struct qemu_alarm_timer *t);
210 static void unix_stop_timer(struct qemu_alarm_timer *t);
212 #ifdef __linux__
214 static int dynticks_start_timer(struct qemu_alarm_timer *t);
215 static void dynticks_stop_timer(struct qemu_alarm_timer *t);
216 static void dynticks_rearm_timer(struct qemu_alarm_timer *t);
218 static int hpet_start_timer(struct qemu_alarm_timer *t);
219 static void hpet_stop_timer(struct qemu_alarm_timer *t);
221 static int rtc_start_timer(struct qemu_alarm_timer *t);
222 static void rtc_stop_timer(struct qemu_alarm_timer *t);
224 #endif /* __linux__ */
226 #endif /* _WIN32 */
228 /* Correlation between real and virtual time is always going to be
229 fairly approximate, so ignore small variation.
230 When the guest is idle real and virtual time will be aligned in
231 the IO wait loop. */
232 #define ICOUNT_WOBBLE (get_ticks_per_sec() / 10)
234 static void icount_adjust(void)
236 int64_t cur_time;
237 int64_t cur_icount;
238 int64_t delta;
239 static int64_t last_delta;
240 /* If the VM is not running, then do nothing. */
241 if (!vm_running)
242 return;
244 cur_time = cpu_get_clock();
245 cur_icount = qemu_get_clock_ns(vm_clock);
246 delta = cur_icount - cur_time;
247 /* FIXME: This is a very crude algorithm, somewhat prone to oscillation. */
248 if (delta > 0
249 && last_delta + ICOUNT_WOBBLE < delta * 2
250 && icount_time_shift > 0) {
251 /* The guest is getting too far ahead. Slow time down. */
252 icount_time_shift--;
254 if (delta < 0
255 && last_delta - ICOUNT_WOBBLE > delta * 2
256 && icount_time_shift < MAX_ICOUNT_SHIFT) {
257 /* The guest is getting too far behind. Speed time up. */
258 icount_time_shift++;
260 last_delta = delta;
261 qemu_icount_bias = cur_icount - (qemu_icount << icount_time_shift);
264 static void icount_adjust_rt(void * opaque)
266 qemu_mod_timer(icount_rt_timer,
267 qemu_get_clock_ms(rt_clock) + 1000);
268 icount_adjust();
271 static void icount_adjust_vm(void * opaque)
273 qemu_mod_timer(icount_vm_timer,
274 qemu_get_clock_ns(vm_clock) + get_ticks_per_sec() / 10);
275 icount_adjust();
278 int64_t qemu_icount_round(int64_t count)
280 return (count + (1 << icount_time_shift) - 1) >> icount_time_shift;
283 static struct qemu_alarm_timer alarm_timers[] = {
284 #ifndef _WIN32
285 #ifdef __linux__
286 {"dynticks", dynticks_start_timer,
287 dynticks_stop_timer, dynticks_rearm_timer, NULL},
288 /* HPET - if available - is preferred */
289 {"hpet", hpet_start_timer, hpet_stop_timer, NULL, NULL},
290 /* ...otherwise try RTC */
291 {"rtc", rtc_start_timer, rtc_stop_timer, NULL, NULL},
292 #endif
293 {"unix", unix_start_timer, unix_stop_timer, NULL, NULL},
294 #else
295 {"dynticks", win32_start_timer,
296 win32_stop_timer, win32_rearm_timer, NULL},
297 {"win32", win32_start_timer,
298 win32_stop_timer, NULL, NULL},
299 #endif
300 {NULL, }
303 static void show_available_alarms(void)
305 int i;
307 printf("Available alarm timers, in order of precedence:\n");
308 for (i = 0; alarm_timers[i].name; i++)
309 printf("%s\n", alarm_timers[i].name);
312 void configure_alarms(char const *opt)
314 int i;
315 int cur = 0;
316 int count = ARRAY_SIZE(alarm_timers) - 1;
317 char *arg;
318 char *name;
319 struct qemu_alarm_timer tmp;
321 if (!strcmp(opt, "?")) {
322 show_available_alarms();
323 exit(0);
326 arg = qemu_strdup(opt);
328 /* Reorder the array */
329 name = strtok(arg, ",");
330 while (name) {
331 for (i = 0; i < count && alarm_timers[i].name; i++) {
332 if (!strcmp(alarm_timers[i].name, name))
333 break;
336 if (i == count) {
337 fprintf(stderr, "Unknown clock %s\n", name);
338 goto next;
341 if (i < cur)
342 /* Ignore */
343 goto next;
345 /* Swap */
346 tmp = alarm_timers[i];
347 alarm_timers[i] = alarm_timers[cur];
348 alarm_timers[cur] = tmp;
350 cur++;
351 next:
352 name = strtok(NULL, ",");
355 qemu_free(arg);
357 if (cur) {
358 /* Disable remaining timers */
359 for (i = cur; i < count; i++)
360 alarm_timers[i].name = NULL;
361 } else {
362 show_available_alarms();
363 exit(1);
367 #define QEMU_NUM_CLOCKS 3
369 QEMUClock *rt_clock;
370 QEMUClock *vm_clock;
371 QEMUClock *host_clock;
373 static QEMUTimer *active_timers[QEMU_NUM_CLOCKS];
375 static QEMUClock *qemu_new_clock(int type)
377 QEMUClock *clock;
378 clock = qemu_mallocz(sizeof(QEMUClock));
379 clock->type = type;
380 clock->enabled = 1;
381 return clock;
384 void qemu_clock_enable(QEMUClock *clock, int enabled)
386 clock->enabled = enabled;
389 QEMUTimer *qemu_new_timer(QEMUClock *clock, int scale,
390 QEMUTimerCB *cb, void *opaque)
392 QEMUTimer *ts;
394 ts = qemu_mallocz(sizeof(QEMUTimer));
395 ts->clock = clock;
396 ts->cb = cb;
397 ts->opaque = opaque;
398 ts->scale = scale;
399 return ts;
402 void qemu_free_timer(QEMUTimer *ts)
404 qemu_free(ts);
407 /* stop a timer, but do not dealloc it */
408 void qemu_del_timer(QEMUTimer *ts)
410 QEMUTimer **pt, *t;
412 /* NOTE: this code must be signal safe because
413 qemu_timer_expired() can be called from a signal. */
414 pt = &active_timers[ts->clock->type];
415 for(;;) {
416 t = *pt;
417 if (!t)
418 break;
419 if (t == ts) {
420 *pt = t->next;
421 break;
423 pt = &t->next;
427 /* modify the current timer so that it will be fired when current_time
428 >= expire_time. The corresponding callback will be called. */
429 static void qemu_mod_timer_ns(QEMUTimer *ts, int64_t expire_time)
431 QEMUTimer **pt, *t;
433 qemu_del_timer(ts);
435 /* add the timer in the sorted list */
436 /* NOTE: this code must be signal safe because
437 qemu_timer_expired() can be called from a signal. */
438 pt = &active_timers[ts->clock->type];
439 for(;;) {
440 t = *pt;
441 if (!t)
442 break;
443 if (t->expire_time > expire_time)
444 break;
445 pt = &t->next;
447 ts->expire_time = expire_time;
448 ts->next = *pt;
449 *pt = ts;
451 /* Rearm if necessary */
452 if (pt == &active_timers[ts->clock->type]) {
453 if (!alarm_timer->pending) {
454 qemu_rearm_alarm_timer(alarm_timer);
456 /* Interrupt execution to force deadline recalculation. */
457 if (use_icount)
458 qemu_notify_event();
462 /* modify the current timer so that it will be fired when current_time
463 >= expire_time. The corresponding callback will be called. */
464 void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time)
466 qemu_mod_timer_ns(ts, expire_time * ts->scale);
469 int qemu_timer_pending(QEMUTimer *ts)
471 QEMUTimer *t;
472 for(t = active_timers[ts->clock->type]; t != NULL; t = t->next) {
473 if (t == ts)
474 return 1;
476 return 0;
479 int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time)
481 if (!timer_head)
482 return 0;
483 return (timer_head->expire_time <= current_time * timer_head->scale);
486 static void qemu_run_timers(QEMUClock *clock)
488 QEMUTimer **ptimer_head, *ts;
489 int64_t current_time;
491 if (!clock->enabled)
492 return;
494 current_time = qemu_get_clock_ns(clock);
495 ptimer_head = &active_timers[clock->type];
496 for(;;) {
497 ts = *ptimer_head;
498 if (!ts || ts->expire_time > current_time)
499 break;
500 /* remove timer from the list before calling the callback */
501 *ptimer_head = ts->next;
502 ts->next = NULL;
504 /* run the callback (the timer list can be modified) */
505 ts->cb(ts->opaque);
509 int64_t qemu_get_clock_ns(QEMUClock *clock)
511 switch(clock->type) {
512 case QEMU_CLOCK_REALTIME:
513 return get_clock();
514 default:
515 case QEMU_CLOCK_VIRTUAL:
516 if (use_icount) {
517 return cpu_get_icount();
518 } else {
519 return cpu_get_clock();
521 case QEMU_CLOCK_HOST:
522 return get_clock_realtime();
526 void init_clocks(void)
528 rt_clock = qemu_new_clock(QEMU_CLOCK_REALTIME);
529 vm_clock = qemu_new_clock(QEMU_CLOCK_VIRTUAL);
530 host_clock = qemu_new_clock(QEMU_CLOCK_HOST);
532 rtc_clock = host_clock;
535 /* save a timer */
536 void qemu_put_timer(QEMUFile *f, QEMUTimer *ts)
538 uint64_t expire_time;
540 if (qemu_timer_pending(ts)) {
541 expire_time = ts->expire_time;
542 } else {
543 expire_time = -1;
545 qemu_put_be64(f, expire_time);
548 void qemu_get_timer(QEMUFile *f, QEMUTimer *ts)
550 uint64_t expire_time;
552 expire_time = qemu_get_be64(f);
553 if (expire_time != -1) {
554 qemu_mod_timer_ns(ts, expire_time);
555 } else {
556 qemu_del_timer(ts);
560 static const VMStateDescription vmstate_timers = {
561 .name = "timer",
562 .version_id = 2,
563 .minimum_version_id = 1,
564 .minimum_version_id_old = 1,
565 .fields = (VMStateField []) {
566 VMSTATE_INT64(cpu_ticks_offset, TimersState),
567 VMSTATE_INT64(dummy, TimersState),
568 VMSTATE_INT64_V(cpu_clock_offset, TimersState, 2),
569 VMSTATE_END_OF_LIST()
573 void configure_icount(const char *option)
575 vmstate_register(NULL, 0, &vmstate_timers, &timers_state);
576 if (!option)
577 return;
579 if (strcmp(option, "auto") != 0) {
580 icount_time_shift = strtol(option, NULL, 0);
581 use_icount = 1;
582 return;
585 use_icount = 2;
587 /* 125MIPS seems a reasonable initial guess at the guest speed.
588 It will be corrected fairly quickly anyway. */
589 icount_time_shift = 3;
591 /* Have both realtime and virtual time triggers for speed adjustment.
592 The realtime trigger catches emulated time passing too slowly,
593 the virtual time trigger catches emulated time passing too fast.
594 Realtime triggers occur even when idle, so use them less frequently
595 than VM triggers. */
596 icount_rt_timer = qemu_new_timer_ms(rt_clock, icount_adjust_rt, NULL);
597 qemu_mod_timer(icount_rt_timer,
598 qemu_get_clock_ms(rt_clock) + 1000);
599 icount_vm_timer = qemu_new_timer_ns(vm_clock, icount_adjust_vm, NULL);
600 qemu_mod_timer(icount_vm_timer,
601 qemu_get_clock_ns(vm_clock) + get_ticks_per_sec() / 10);
604 void qemu_run_all_timers(void)
606 alarm_timer->pending = 0;
608 /* rearm timer, if not periodic */
609 if (alarm_timer->expired) {
610 alarm_timer->expired = 0;
611 qemu_rearm_alarm_timer(alarm_timer);
614 /* vm time timers */
615 if (vm_running) {
616 qemu_run_timers(vm_clock);
619 qemu_run_timers(rt_clock);
620 qemu_run_timers(host_clock);
623 static int64_t qemu_next_alarm_deadline(void);
625 #ifdef _WIN32
626 static void CALLBACK host_alarm_handler(PVOID lpParam, BOOLEAN unused)
627 #else
628 static void host_alarm_handler(int host_signum)
629 #endif
631 struct qemu_alarm_timer *t = alarm_timer;
632 if (!t)
633 return;
635 #if 0
636 #define DISP_FREQ 1000
638 static int64_t delta_min = INT64_MAX;
639 static int64_t delta_max, delta_cum, last_clock, delta, ti;
640 static int count;
641 ti = qemu_get_clock_ns(vm_clock);
642 if (last_clock != 0) {
643 delta = ti - last_clock;
644 if (delta < delta_min)
645 delta_min = delta;
646 if (delta > delta_max)
647 delta_max = delta;
648 delta_cum += delta;
649 if (++count == DISP_FREQ) {
650 printf("timer: min=%" PRId64 " us max=%" PRId64 " us avg=%" PRId64 " us avg_freq=%0.3f Hz\n",
651 muldiv64(delta_min, 1000000, get_ticks_per_sec()),
652 muldiv64(delta_max, 1000000, get_ticks_per_sec()),
653 muldiv64(delta_cum, 1000000 / DISP_FREQ, get_ticks_per_sec()),
654 (double)get_ticks_per_sec() / ((double)delta_cum / DISP_FREQ));
655 count = 0;
656 delta_min = INT64_MAX;
657 delta_max = 0;
658 delta_cum = 0;
661 last_clock = ti;
663 #endif
664 if (alarm_has_dynticks(t) ||
665 qemu_next_alarm_deadline () <= 0) {
666 t->expired = alarm_has_dynticks(t);
667 t->pending = 1;
668 qemu_notify_event();
672 int64_t qemu_next_deadline(void)
674 /* To avoid problems with overflow limit this to 2^32. */
675 int64_t delta = INT32_MAX;
677 if (active_timers[QEMU_CLOCK_VIRTUAL]) {
678 delta = active_timers[QEMU_CLOCK_VIRTUAL]->expire_time -
679 qemu_get_clock_ns(vm_clock);
681 if (active_timers[QEMU_CLOCK_HOST]) {
682 int64_t hdelta = active_timers[QEMU_CLOCK_HOST]->expire_time -
683 qemu_get_clock_ns(host_clock);
684 if (hdelta < delta)
685 delta = hdelta;
688 if (delta < 0)
689 delta = 0;
691 return delta;
694 static int64_t qemu_next_alarm_deadline(void)
696 int64_t delta;
697 int64_t rtdelta;
699 if (!use_icount && active_timers[QEMU_CLOCK_VIRTUAL]) {
700 delta = active_timers[QEMU_CLOCK_VIRTUAL]->expire_time -
701 qemu_get_clock_ns(vm_clock);
702 } else {
703 delta = INT32_MAX;
705 if (active_timers[QEMU_CLOCK_HOST]) {
706 int64_t hdelta = active_timers[QEMU_CLOCK_HOST]->expire_time -
707 qemu_get_clock_ns(host_clock);
708 if (hdelta < delta)
709 delta = hdelta;
711 if (active_timers[QEMU_CLOCK_REALTIME]) {
712 rtdelta = (active_timers[QEMU_CLOCK_REALTIME]->expire_time -
713 qemu_get_clock_ns(rt_clock));
714 if (rtdelta < delta)
715 delta = rtdelta;
718 return delta;
721 #if defined(__linux__)
723 #define RTC_FREQ 1024
725 static void enable_sigio_timer(int fd)
727 struct sigaction act;
729 /* timer signal */
730 sigfillset(&act.sa_mask);
731 act.sa_flags = 0;
732 act.sa_handler = host_alarm_handler;
734 sigaction(SIGIO, &act, NULL);
735 fcntl_setfl(fd, O_ASYNC);
736 fcntl(fd, F_SETOWN, getpid());
739 static int hpet_start_timer(struct qemu_alarm_timer *t)
741 struct hpet_info info;
742 int r, fd;
744 fd = qemu_open("/dev/hpet", O_RDONLY);
745 if (fd < 0)
746 return -1;
748 /* Set frequency */
749 r = ioctl(fd, HPET_IRQFREQ, RTC_FREQ);
750 if (r < 0) {
751 fprintf(stderr, "Could not configure '/dev/hpet' to have a 1024Hz timer. This is not a fatal\n"
752 "error, but for better emulation accuracy type:\n"
753 "'echo 1024 > /proc/sys/dev/hpet/max-user-freq' as root.\n");
754 goto fail;
757 /* Check capabilities */
758 r = ioctl(fd, HPET_INFO, &info);
759 if (r < 0)
760 goto fail;
762 /* Enable periodic mode */
763 r = ioctl(fd, HPET_EPI, 0);
764 if (info.hi_flags && (r < 0))
765 goto fail;
767 /* Enable interrupt */
768 r = ioctl(fd, HPET_IE_ON, 0);
769 if (r < 0)
770 goto fail;
772 enable_sigio_timer(fd);
773 t->priv = (void *)(long)fd;
775 return 0;
776 fail:
777 close(fd);
778 return -1;
781 static void hpet_stop_timer(struct qemu_alarm_timer *t)
783 int fd = (long)t->priv;
785 close(fd);
788 static int rtc_start_timer(struct qemu_alarm_timer *t)
790 int rtc_fd;
791 unsigned long current_rtc_freq = 0;
793 TFR(rtc_fd = qemu_open("/dev/rtc", O_RDONLY));
794 if (rtc_fd < 0)
795 return -1;
796 ioctl(rtc_fd, RTC_IRQP_READ, &current_rtc_freq);
797 if (current_rtc_freq != RTC_FREQ &&
798 ioctl(rtc_fd, RTC_IRQP_SET, RTC_FREQ) < 0) {
799 fprintf(stderr, "Could not configure '/dev/rtc' to have a 1024 Hz timer. This is not a fatal\n"
800 "error, but for better emulation accuracy either use a 2.6 host Linux kernel or\n"
801 "type 'echo 1024 > /proc/sys/dev/rtc/max-user-freq' as root.\n");
802 goto fail;
804 if (ioctl(rtc_fd, RTC_PIE_ON, 0) < 0) {
805 fail:
806 close(rtc_fd);
807 return -1;
810 enable_sigio_timer(rtc_fd);
812 t->priv = (void *)(long)rtc_fd;
814 return 0;
817 static void rtc_stop_timer(struct qemu_alarm_timer *t)
819 int rtc_fd = (long)t->priv;
821 close(rtc_fd);
824 static int dynticks_start_timer(struct qemu_alarm_timer *t)
826 struct sigevent ev;
827 timer_t host_timer;
828 struct sigaction act;
830 sigfillset(&act.sa_mask);
831 act.sa_flags = 0;
832 act.sa_handler = host_alarm_handler;
834 sigaction(SIGALRM, &act, NULL);
837 * Initialize ev struct to 0 to avoid valgrind complaining
838 * about uninitialized data in timer_create call
840 memset(&ev, 0, sizeof(ev));
841 ev.sigev_value.sival_int = 0;
842 ev.sigev_notify = SIGEV_SIGNAL;
843 ev.sigev_signo = SIGALRM;
845 if (timer_create(CLOCK_REALTIME, &ev, &host_timer)) {
846 perror("timer_create");
848 /* disable dynticks */
849 fprintf(stderr, "Dynamic Ticks disabled\n");
851 return -1;
854 t->priv = (void *)(long)host_timer;
856 return 0;
859 static void dynticks_stop_timer(struct qemu_alarm_timer *t)
861 timer_t host_timer = (timer_t)(long)t->priv;
863 timer_delete(host_timer);
866 static void dynticks_rearm_timer(struct qemu_alarm_timer *t)
868 timer_t host_timer = (timer_t)(long)t->priv;
869 struct itimerspec timeout;
870 int64_t nearest_delta_ns = INT64_MAX;
871 int64_t current_ns;
873 assert(alarm_has_dynticks(t));
874 if (!active_timers[QEMU_CLOCK_REALTIME] &&
875 !active_timers[QEMU_CLOCK_VIRTUAL] &&
876 !active_timers[QEMU_CLOCK_HOST])
877 return;
879 nearest_delta_ns = qemu_next_alarm_deadline();
880 if (nearest_delta_ns < MIN_TIMER_REARM_NS)
881 nearest_delta_ns = MIN_TIMER_REARM_NS;
883 /* check whether a timer is already running */
884 if (timer_gettime(host_timer, &timeout)) {
885 perror("gettime");
886 fprintf(stderr, "Internal timer error: aborting\n");
887 exit(1);
889 current_ns = timeout.it_value.tv_sec * 1000000000LL + timeout.it_value.tv_nsec;
890 if (current_ns && current_ns <= nearest_delta_ns)
891 return;
893 timeout.it_interval.tv_sec = 0;
894 timeout.it_interval.tv_nsec = 0; /* 0 for one-shot timer */
895 timeout.it_value.tv_sec = nearest_delta_ns / 1000000000;
896 timeout.it_value.tv_nsec = nearest_delta_ns % 1000000000;
897 if (timer_settime(host_timer, 0 /* RELATIVE */, &timeout, NULL)) {
898 perror("settime");
899 fprintf(stderr, "Internal timer error: aborting\n");
900 exit(1);
904 #endif /* defined(__linux__) */
906 #if !defined(_WIN32)
908 static int unix_start_timer(struct qemu_alarm_timer *t)
910 struct sigaction act;
911 struct itimerval itv;
912 int err;
914 /* timer signal */
915 sigfillset(&act.sa_mask);
916 act.sa_flags = 0;
917 act.sa_handler = host_alarm_handler;
919 sigaction(SIGALRM, &act, NULL);
921 itv.it_interval.tv_sec = 0;
922 /* for i386 kernel 2.6 to get 1 ms */
923 itv.it_interval.tv_usec = 999;
924 itv.it_value.tv_sec = 0;
925 itv.it_value.tv_usec = 10 * 1000;
927 err = setitimer(ITIMER_REAL, &itv, NULL);
928 if (err)
929 return -1;
931 return 0;
934 static void unix_stop_timer(struct qemu_alarm_timer *t)
936 struct itimerval itv;
938 memset(&itv, 0, sizeof(itv));
939 setitimer(ITIMER_REAL, &itv, NULL);
942 #endif /* !defined(_WIN32) */
945 #ifdef _WIN32
947 static int win32_start_timer(struct qemu_alarm_timer *t)
949 HANDLE hTimer;
950 BOOLEAN success;
952 /* If you call ChangeTimerQueueTimer on a one-shot timer (its period
953 is zero) that has already expired, the timer is not updated. Since
954 creating a new timer is relatively expensive, set a bogus one-hour
955 interval in the dynticks case. */
956 success = CreateTimerQueueTimer(&hTimer,
957 NULL,
958 host_alarm_handler,
961 alarm_has_dynticks(t) ? 3600000 : 1,
962 WT_EXECUTEINTIMERTHREAD);
964 if (!success) {
965 fprintf(stderr, "Failed to initialize win32 alarm timer: %ld\n",
966 GetLastError());
967 return -1;
970 t->priv = (PVOID) hTimer;
971 return 0;
974 static void win32_stop_timer(struct qemu_alarm_timer *t)
976 HANDLE hTimer = t->priv;
978 if (hTimer) {
979 DeleteTimerQueueTimer(NULL, hTimer, NULL);
983 static void win32_rearm_timer(struct qemu_alarm_timer *t)
985 HANDLE hTimer = t->priv;
986 int nearest_delta_ms;
987 BOOLEAN success;
989 assert(alarm_has_dynticks(t));
990 if (!active_timers[QEMU_CLOCK_REALTIME] &&
991 !active_timers[QEMU_CLOCK_VIRTUAL] &&
992 !active_timers[QEMU_CLOCK_HOST])
993 return;
995 nearest_delta_ms = (qemu_next_alarm_deadline() + 999999) / 1000000;
996 if (nearest_delta_ms < 1) {
997 nearest_delta_ms = 1;
999 success = ChangeTimerQueueTimer(NULL,
1000 hTimer,
1001 nearest_delta_ms,
1002 3600000);
1004 if (!success) {
1005 fprintf(stderr, "Failed to rearm win32 alarm timer: %ld\n",
1006 GetLastError());
1007 exit(-1);
1012 #endif /* _WIN32 */
1014 static void alarm_timer_on_change_state_rearm(void *opaque, int running, int reason)
1016 if (running)
1017 qemu_rearm_alarm_timer((struct qemu_alarm_timer *) opaque);
1020 int init_timer_alarm(void)
1022 struct qemu_alarm_timer *t = NULL;
1023 int i, err = -1;
1025 for (i = 0; alarm_timers[i].name; i++) {
1026 t = &alarm_timers[i];
1028 err = t->start(t);
1029 if (!err)
1030 break;
1033 if (err) {
1034 err = -ENOENT;
1035 goto fail;
1038 /* first event is at time 0 */
1039 t->pending = 1;
1040 alarm_timer = t;
1041 qemu_add_vm_change_state_handler(alarm_timer_on_change_state_rearm, t);
1043 return 0;
1045 fail:
1046 return err;
1049 void quit_timers(void)
1051 struct qemu_alarm_timer *t = alarm_timer;
1052 alarm_timer = NULL;
1053 t->stop(t);
1056 int qemu_calculate_timeout(void)
1058 int timeout;
1059 int64_t add;
1060 int64_t delta;
1062 /* When using icount, making forward progress with qemu_icount when the
1063 guest CPU is idle is critical. We only use the static io-thread timeout
1064 for non icount runs. */
1065 if (!use_icount || !vm_running) {
1066 return 5000;
1069 /* Advance virtual time to the next event. */
1070 delta = qemu_icount_delta();
1071 if (delta > 0) {
1072 /* If virtual time is ahead of real time then just
1073 wait for IO. */
1074 timeout = (delta + 999999) / 1000000;
1075 } else {
1076 /* Wait for either IO to occur or the next
1077 timer event. */
1078 add = qemu_next_deadline();
1079 /* We advance the timer before checking for IO.
1080 Limit the amount we advance so that early IO
1081 activity won't get the guest too far ahead. */
1082 if (add > 10000000)
1083 add = 10000000;
1084 delta += add;
1085 qemu_icount += qemu_icount_round (add);
1086 timeout = delta / 1000000;
1087 if (timeout < 0)
1088 timeout = 0;
1091 return timeout;