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
39 #include <sys/param.h>
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> */
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
;
78 TimersState timers_state
;
80 /* return the host CPU cycle counter and handle stop/restart */
81 int64_t cpu_get_ticks(void)
84 return cpu_get_icount();
86 if (!timers_state
.cpu_ticks_enabled
) {
87 return timers_state
.cpu_ticks_offset
;
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
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)
105 if (!timers_state
.cpu_ticks_enabled
) {
106 return timers_state
.cpu_clock_offset
;
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. */
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 /***********************************************************/
149 #define QEMU_CLOCK_REALTIME 0
150 #define QEMU_CLOCK_VIRTUAL 1
151 #define QEMU_CLOCK_HOST 2
157 QEMUTimer
*warp_timer
;
162 int64_t expire_time
; /* in nanoseconds */
166 struct QEMUTimer
*next
;
169 struct qemu_alarm_timer
{
171 int (*start
)(struct qemu_alarm_timer
*t
);
172 void (*stop
)(struct qemu_alarm_timer
*t
);
173 void (*rearm
)(struct qemu_alarm_timer
*t
);
180 static struct qemu_alarm_timer
*alarm_timer
;
182 int qemu_alarm_pending(void)
184 return alarm_timer
->pending
;
187 static inline int alarm_has_dynticks(struct qemu_alarm_timer
*t
)
192 static void qemu_rearm_alarm_timer(struct qemu_alarm_timer
*t
)
194 if (!alarm_has_dynticks(t
))
200 /* TODO: MIN_TIMER_REARM_NS should be optimized */
201 #define MIN_TIMER_REARM_NS 250000
205 static int win32_start_timer(struct qemu_alarm_timer
*t
);
206 static void win32_stop_timer(struct qemu_alarm_timer
*t
);
207 static void win32_rearm_timer(struct qemu_alarm_timer
*t
);
211 static int unix_start_timer(struct qemu_alarm_timer
*t
);
212 static void unix_stop_timer(struct qemu_alarm_timer
*t
);
216 static int dynticks_start_timer(struct qemu_alarm_timer
*t
);
217 static void dynticks_stop_timer(struct qemu_alarm_timer
*t
);
218 static void dynticks_rearm_timer(struct qemu_alarm_timer
*t
);
220 static int hpet_start_timer(struct qemu_alarm_timer
*t
);
221 static void hpet_stop_timer(struct qemu_alarm_timer
*t
);
223 static int rtc_start_timer(struct qemu_alarm_timer
*t
);
224 static void rtc_stop_timer(struct qemu_alarm_timer
*t
);
226 #endif /* __linux__ */
230 /* Correlation between real and virtual time is always going to be
231 fairly approximate, so ignore small variation.
232 When the guest is idle real and virtual time will be aligned in
234 #define ICOUNT_WOBBLE (get_ticks_per_sec() / 10)
236 static void icount_adjust(void)
241 static int64_t last_delta
;
242 /* If the VM is not running, then do nothing. */
246 cur_time
= cpu_get_clock();
247 cur_icount
= qemu_get_clock_ns(vm_clock
);
248 delta
= cur_icount
- cur_time
;
249 /* FIXME: This is a very crude algorithm, somewhat prone to oscillation. */
251 && last_delta
+ ICOUNT_WOBBLE
< delta
* 2
252 && icount_time_shift
> 0) {
253 /* The guest is getting too far ahead. Slow time down. */
257 && last_delta
- ICOUNT_WOBBLE
> delta
* 2
258 && icount_time_shift
< MAX_ICOUNT_SHIFT
) {
259 /* The guest is getting too far behind. Speed time up. */
263 qemu_icount_bias
= cur_icount
- (qemu_icount
<< icount_time_shift
);
266 static void icount_adjust_rt(void * opaque
)
268 qemu_mod_timer(icount_rt_timer
,
269 qemu_get_clock_ms(rt_clock
) + 1000);
273 static void icount_adjust_vm(void * opaque
)
275 qemu_mod_timer(icount_vm_timer
,
276 qemu_get_clock_ns(vm_clock
) + get_ticks_per_sec() / 10);
280 int64_t qemu_icount_round(int64_t count
)
282 return (count
+ (1 << icount_time_shift
) - 1) >> icount_time_shift
;
285 static struct qemu_alarm_timer alarm_timers
[] = {
288 {"dynticks", dynticks_start_timer
,
289 dynticks_stop_timer
, dynticks_rearm_timer
, NULL
},
290 /* HPET - if available - is preferred */
291 {"hpet", hpet_start_timer
, hpet_stop_timer
, NULL
, NULL
},
292 /* ...otherwise try RTC */
293 {"rtc", rtc_start_timer
, rtc_stop_timer
, NULL
, NULL
},
295 {"unix", unix_start_timer
, unix_stop_timer
, NULL
, NULL
},
297 {"dynticks", win32_start_timer
,
298 win32_stop_timer
, win32_rearm_timer
, NULL
},
299 {"win32", win32_start_timer
,
300 win32_stop_timer
, NULL
, NULL
},
305 static void show_available_alarms(void)
309 printf("Available alarm timers, in order of precedence:\n");
310 for (i
= 0; alarm_timers
[i
].name
; i
++)
311 printf("%s\n", alarm_timers
[i
].name
);
314 void configure_alarms(char const *opt
)
318 int count
= ARRAY_SIZE(alarm_timers
) - 1;
321 struct qemu_alarm_timer tmp
;
323 if (!strcmp(opt
, "?")) {
324 show_available_alarms();
328 arg
= qemu_strdup(opt
);
330 /* Reorder the array */
331 name
= strtok(arg
, ",");
333 for (i
= 0; i
< count
&& alarm_timers
[i
].name
; i
++) {
334 if (!strcmp(alarm_timers
[i
].name
, name
))
339 fprintf(stderr
, "Unknown clock %s\n", name
);
348 tmp
= alarm_timers
[i
];
349 alarm_timers
[i
] = alarm_timers
[cur
];
350 alarm_timers
[cur
] = tmp
;
354 name
= strtok(NULL
, ",");
360 /* Disable remaining timers */
361 for (i
= cur
; i
< count
; i
++)
362 alarm_timers
[i
].name
= NULL
;
364 show_available_alarms();
369 #define QEMU_NUM_CLOCKS 3
373 QEMUClock
*host_clock
;
375 static QEMUTimer
*active_timers
[QEMU_NUM_CLOCKS
];
377 static QEMUClock
*qemu_new_clock(int type
)
380 clock
= qemu_mallocz(sizeof(QEMUClock
));
386 void qemu_clock_enable(QEMUClock
*clock
, int enabled
)
388 clock
->enabled
= enabled
;
391 static int64_t vm_clock_warp_start
;
393 static void icount_warp_rt(void *opaque
)
395 if (vm_clock_warp_start
== -1) {
400 int64_t clock
= qemu_get_clock_ns(rt_clock
);
401 int64_t warp_delta
= clock
- vm_clock_warp_start
;
402 if (use_icount
== 1) {
403 qemu_icount_bias
+= warp_delta
;
406 * In adaptive mode, do not let the vm_clock run too
407 * far ahead of real time.
409 int64_t cur_time
= cpu_get_clock();
410 int64_t cur_icount
= qemu_get_clock_ns(vm_clock
);
411 int64_t delta
= cur_time
- cur_icount
;
412 qemu_icount_bias
+= MIN(warp_delta
, delta
);
414 if (qemu_timer_expired(active_timers
[QEMU_CLOCK_VIRTUAL
],
415 qemu_get_clock_ns(vm_clock
))) {
419 vm_clock_warp_start
= -1;
422 void qemu_clock_warp(QEMUClock
*clock
)
426 if (!clock
->warp_timer
) {
431 * There are too many global variables to make the "warp" behavior
432 * applicable to other clocks. But a clock argument removes the
433 * need for if statements all over the place.
435 assert(clock
== vm_clock
);
438 * If the CPUs have been sleeping, advance the vm_clock timer now. This
439 * ensures that the deadline for the timer is computed correctly below.
440 * This also makes sure that the insn counter is synchronized before the
441 * CPU starts running, in case the CPU is woken by an event other than
442 * the earliest vm_clock timer.
444 icount_warp_rt(NULL
);
445 if (!all_cpu_threads_idle() || !active_timers
[clock
->type
]) {
446 qemu_del_timer(clock
->warp_timer
);
450 vm_clock_warp_start
= qemu_get_clock_ns(rt_clock
);
451 deadline
= qemu_next_deadline();
454 * Ensure the vm_clock proceeds even when the virtual CPU goes to
455 * sleep. Otherwise, the CPU might be waiting for a future timer
456 * interrupt to wake it up, but the interrupt never comes because
457 * the vCPU isn't running any insns and thus doesn't advance the
460 * An extreme solution for this problem would be to never let VCPUs
461 * sleep in icount mode if there is a pending vm_clock timer; rather
462 * time could just advance to the next vm_clock event. Instead, we
463 * do stop VCPUs and only advance vm_clock after some "real" time,
464 * (related to the time left until the next event) has passed. This
465 * rt_clock timer will do this. This avoids that the warps are too
466 * visible externally---for example, you will not be sending network
467 * packets continously instead of every 100ms.
469 qemu_mod_timer(clock
->warp_timer
, vm_clock_warp_start
+ deadline
);
475 QEMUTimer
*qemu_new_timer(QEMUClock
*clock
, int scale
,
476 QEMUTimerCB
*cb
, void *opaque
)
480 ts
= qemu_mallocz(sizeof(QEMUTimer
));
488 void qemu_free_timer(QEMUTimer
*ts
)
493 /* stop a timer, but do not dealloc it */
494 void qemu_del_timer(QEMUTimer
*ts
)
498 /* NOTE: this code must be signal safe because
499 qemu_timer_expired() can be called from a signal. */
500 pt
= &active_timers
[ts
->clock
->type
];
513 /* modify the current timer so that it will be fired when current_time
514 >= expire_time. The corresponding callback will be called. */
515 static void qemu_mod_timer_ns(QEMUTimer
*ts
, int64_t expire_time
)
521 /* add the timer in the sorted list */
522 /* NOTE: this code must be signal safe because
523 qemu_timer_expired() can be called from a signal. */
524 pt
= &active_timers
[ts
->clock
->type
];
529 if (t
->expire_time
> expire_time
)
533 ts
->expire_time
= expire_time
;
537 /* Rearm if necessary */
538 if (pt
== &active_timers
[ts
->clock
->type
]) {
539 if (!alarm_timer
->pending
) {
540 qemu_rearm_alarm_timer(alarm_timer
);
542 /* Interrupt execution to force deadline recalculation. */
543 qemu_clock_warp(ts
->clock
);
550 /* modify the current timer so that it will be fired when current_time
551 >= expire_time. The corresponding callback will be called. */
552 void qemu_mod_timer(QEMUTimer
*ts
, int64_t expire_time
)
554 qemu_mod_timer_ns(ts
, expire_time
* ts
->scale
);
557 int qemu_timer_pending(QEMUTimer
*ts
)
560 for(t
= active_timers
[ts
->clock
->type
]; t
!= NULL
; t
= t
->next
) {
567 int qemu_timer_expired(QEMUTimer
*timer_head
, int64_t current_time
)
571 return (timer_head
->expire_time
<= current_time
* timer_head
->scale
);
574 static void qemu_run_timers(QEMUClock
*clock
)
576 QEMUTimer
**ptimer_head
, *ts
;
577 int64_t current_time
;
582 current_time
= qemu_get_clock_ns(clock
);
583 ptimer_head
= &active_timers
[clock
->type
];
586 if (!ts
|| ts
->expire_time
> current_time
)
588 /* remove timer from the list before calling the callback */
589 *ptimer_head
= ts
->next
;
592 /* run the callback (the timer list can be modified) */
597 int64_t qemu_get_clock_ns(QEMUClock
*clock
)
599 switch(clock
->type
) {
600 case QEMU_CLOCK_REALTIME
:
603 case QEMU_CLOCK_VIRTUAL
:
605 return cpu_get_icount();
607 return cpu_get_clock();
609 case QEMU_CLOCK_HOST
:
610 return get_clock_realtime();
614 void init_clocks(void)
616 rt_clock
= qemu_new_clock(QEMU_CLOCK_REALTIME
);
617 vm_clock
= qemu_new_clock(QEMU_CLOCK_VIRTUAL
);
618 host_clock
= qemu_new_clock(QEMU_CLOCK_HOST
);
620 rtc_clock
= host_clock
;
624 void qemu_put_timer(QEMUFile
*f
, QEMUTimer
*ts
)
626 uint64_t expire_time
;
628 if (qemu_timer_pending(ts
)) {
629 expire_time
= ts
->expire_time
;
633 qemu_put_be64(f
, expire_time
);
636 void qemu_get_timer(QEMUFile
*f
, QEMUTimer
*ts
)
638 uint64_t expire_time
;
640 expire_time
= qemu_get_be64(f
);
641 if (expire_time
!= -1) {
642 qemu_mod_timer_ns(ts
, expire_time
);
648 static const VMStateDescription vmstate_timers
= {
651 .minimum_version_id
= 1,
652 .minimum_version_id_old
= 1,
653 .fields
= (VMStateField
[]) {
654 VMSTATE_INT64(cpu_ticks_offset
, TimersState
),
655 VMSTATE_INT64(dummy
, TimersState
),
656 VMSTATE_INT64_V(cpu_clock_offset
, TimersState
, 2),
657 VMSTATE_END_OF_LIST()
661 void configure_icount(const char *option
)
663 vmstate_register(NULL
, 0, &vmstate_timers
, &timers_state
);
667 #ifdef CONFIG_IOTHREAD
668 vm_clock
->warp_timer
= qemu_new_timer_ns(rt_clock
, icount_warp_rt
, NULL
);
671 if (strcmp(option
, "auto") != 0) {
672 icount_time_shift
= strtol(option
, NULL
, 0);
679 /* 125MIPS seems a reasonable initial guess at the guest speed.
680 It will be corrected fairly quickly anyway. */
681 icount_time_shift
= 3;
683 /* Have both realtime and virtual time triggers for speed adjustment.
684 The realtime trigger catches emulated time passing too slowly,
685 the virtual time trigger catches emulated time passing too fast.
686 Realtime triggers occur even when idle, so use them less frequently
688 icount_rt_timer
= qemu_new_timer_ms(rt_clock
, icount_adjust_rt
, NULL
);
689 qemu_mod_timer(icount_rt_timer
,
690 qemu_get_clock_ms(rt_clock
) + 1000);
691 icount_vm_timer
= qemu_new_timer_ns(vm_clock
, icount_adjust_vm
, NULL
);
692 qemu_mod_timer(icount_vm_timer
,
693 qemu_get_clock_ns(vm_clock
) + get_ticks_per_sec() / 10);
696 void qemu_run_all_timers(void)
698 alarm_timer
->pending
= 0;
700 /* rearm timer, if not periodic */
701 if (alarm_timer
->expired
) {
702 alarm_timer
->expired
= 0;
703 qemu_rearm_alarm_timer(alarm_timer
);
708 qemu_run_timers(vm_clock
);
711 qemu_run_timers(rt_clock
);
712 qemu_run_timers(host_clock
);
715 static int64_t qemu_next_alarm_deadline(void);
718 static void CALLBACK
host_alarm_handler(PVOID lpParam
, BOOLEAN unused
)
720 static void host_alarm_handler(int host_signum
)
723 struct qemu_alarm_timer
*t
= alarm_timer
;
728 #define DISP_FREQ 1000
730 static int64_t delta_min
= INT64_MAX
;
731 static int64_t delta_max
, delta_cum
, last_clock
, delta
, ti
;
733 ti
= qemu_get_clock_ns(vm_clock
);
734 if (last_clock
!= 0) {
735 delta
= ti
- last_clock
;
736 if (delta
< delta_min
)
738 if (delta
> delta_max
)
741 if (++count
== DISP_FREQ
) {
742 printf("timer: min=%" PRId64
" us max=%" PRId64
" us avg=%" PRId64
" us avg_freq=%0.3f Hz\n",
743 muldiv64(delta_min
, 1000000, get_ticks_per_sec()),
744 muldiv64(delta_max
, 1000000, get_ticks_per_sec()),
745 muldiv64(delta_cum
, 1000000 / DISP_FREQ
, get_ticks_per_sec()),
746 (double)get_ticks_per_sec() / ((double)delta_cum
/ DISP_FREQ
));
748 delta_min
= INT64_MAX
;
756 if (alarm_has_dynticks(t
) ||
757 qemu_next_alarm_deadline () <= 0) {
758 t
->expired
= alarm_has_dynticks(t
);
764 int64_t qemu_next_deadline(void)
766 /* To avoid problems with overflow limit this to 2^32. */
767 int64_t delta
= INT32_MAX
;
769 if (active_timers
[QEMU_CLOCK_VIRTUAL
]) {
770 delta
= active_timers
[QEMU_CLOCK_VIRTUAL
]->expire_time
-
771 qemu_get_clock_ns(vm_clock
);
773 if (active_timers
[QEMU_CLOCK_HOST
]) {
774 int64_t hdelta
= active_timers
[QEMU_CLOCK_HOST
]->expire_time
-
775 qemu_get_clock_ns(host_clock
);
786 static int64_t qemu_next_alarm_deadline(void)
791 if (!use_icount
&& active_timers
[QEMU_CLOCK_VIRTUAL
]) {
792 delta
= active_timers
[QEMU_CLOCK_VIRTUAL
]->expire_time
-
793 qemu_get_clock_ns(vm_clock
);
797 if (active_timers
[QEMU_CLOCK_HOST
]) {
798 int64_t hdelta
= active_timers
[QEMU_CLOCK_HOST
]->expire_time
-
799 qemu_get_clock_ns(host_clock
);
803 if (active_timers
[QEMU_CLOCK_REALTIME
]) {
804 rtdelta
= (active_timers
[QEMU_CLOCK_REALTIME
]->expire_time
-
805 qemu_get_clock_ns(rt_clock
));
813 #if defined(__linux__)
815 #define RTC_FREQ 1024
817 static void enable_sigio_timer(int fd
)
819 struct sigaction act
;
822 sigfillset(&act
.sa_mask
);
824 act
.sa_handler
= host_alarm_handler
;
826 sigaction(SIGIO
, &act
, NULL
);
827 fcntl_setfl(fd
, O_ASYNC
);
828 fcntl(fd
, F_SETOWN
, getpid());
831 static int hpet_start_timer(struct qemu_alarm_timer
*t
)
833 struct hpet_info info
;
836 fd
= qemu_open("/dev/hpet", O_RDONLY
);
841 r
= ioctl(fd
, HPET_IRQFREQ
, RTC_FREQ
);
843 fprintf(stderr
, "Could not configure '/dev/hpet' to have a 1024Hz timer. This is not a fatal\n"
844 "error, but for better emulation accuracy type:\n"
845 "'echo 1024 > /proc/sys/dev/hpet/max-user-freq' as root.\n");
849 /* Check capabilities */
850 r
= ioctl(fd
, HPET_INFO
, &info
);
854 /* Enable periodic mode */
855 r
= ioctl(fd
, HPET_EPI
, 0);
856 if (info
.hi_flags
&& (r
< 0))
859 /* Enable interrupt */
860 r
= ioctl(fd
, HPET_IE_ON
, 0);
864 enable_sigio_timer(fd
);
865 t
->priv
= (void *)(long)fd
;
873 static void hpet_stop_timer(struct qemu_alarm_timer
*t
)
875 int fd
= (long)t
->priv
;
880 static int rtc_start_timer(struct qemu_alarm_timer
*t
)
883 unsigned long current_rtc_freq
= 0;
885 TFR(rtc_fd
= qemu_open("/dev/rtc", O_RDONLY
));
888 ioctl(rtc_fd
, RTC_IRQP_READ
, ¤t_rtc_freq
);
889 if (current_rtc_freq
!= RTC_FREQ
&&
890 ioctl(rtc_fd
, RTC_IRQP_SET
, RTC_FREQ
) < 0) {
891 fprintf(stderr
, "Could not configure '/dev/rtc' to have a 1024 Hz timer. This is not a fatal\n"
892 "error, but for better emulation accuracy either use a 2.6 host Linux kernel or\n"
893 "type 'echo 1024 > /proc/sys/dev/rtc/max-user-freq' as root.\n");
896 if (ioctl(rtc_fd
, RTC_PIE_ON
, 0) < 0) {
902 enable_sigio_timer(rtc_fd
);
904 t
->priv
= (void *)(long)rtc_fd
;
909 static void rtc_stop_timer(struct qemu_alarm_timer
*t
)
911 int rtc_fd
= (long)t
->priv
;
916 static int dynticks_start_timer(struct qemu_alarm_timer
*t
)
920 struct sigaction act
;
922 sigfillset(&act
.sa_mask
);
924 act
.sa_handler
= host_alarm_handler
;
926 sigaction(SIGALRM
, &act
, NULL
);
929 * Initialize ev struct to 0 to avoid valgrind complaining
930 * about uninitialized data in timer_create call
932 memset(&ev
, 0, sizeof(ev
));
933 ev
.sigev_value
.sival_int
= 0;
934 ev
.sigev_notify
= SIGEV_SIGNAL
;
935 ev
.sigev_signo
= SIGALRM
;
937 if (timer_create(CLOCK_REALTIME
, &ev
, &host_timer
)) {
938 perror("timer_create");
940 /* disable dynticks */
941 fprintf(stderr
, "Dynamic Ticks disabled\n");
946 t
->priv
= (void *)(long)host_timer
;
951 static void dynticks_stop_timer(struct qemu_alarm_timer
*t
)
953 timer_t host_timer
= (timer_t
)(long)t
->priv
;
955 timer_delete(host_timer
);
958 static void dynticks_rearm_timer(struct qemu_alarm_timer
*t
)
960 timer_t host_timer
= (timer_t
)(long)t
->priv
;
961 struct itimerspec timeout
;
962 int64_t nearest_delta_ns
= INT64_MAX
;
965 assert(alarm_has_dynticks(t
));
966 if (!active_timers
[QEMU_CLOCK_REALTIME
] &&
967 !active_timers
[QEMU_CLOCK_VIRTUAL
] &&
968 !active_timers
[QEMU_CLOCK_HOST
])
971 nearest_delta_ns
= qemu_next_alarm_deadline();
972 if (nearest_delta_ns
< MIN_TIMER_REARM_NS
)
973 nearest_delta_ns
= MIN_TIMER_REARM_NS
;
975 /* check whether a timer is already running */
976 if (timer_gettime(host_timer
, &timeout
)) {
978 fprintf(stderr
, "Internal timer error: aborting\n");
981 current_ns
= timeout
.it_value
.tv_sec
* 1000000000LL + timeout
.it_value
.tv_nsec
;
982 if (current_ns
&& current_ns
<= nearest_delta_ns
)
985 timeout
.it_interval
.tv_sec
= 0;
986 timeout
.it_interval
.tv_nsec
= 0; /* 0 for one-shot timer */
987 timeout
.it_value
.tv_sec
= nearest_delta_ns
/ 1000000000;
988 timeout
.it_value
.tv_nsec
= nearest_delta_ns
% 1000000000;
989 if (timer_settime(host_timer
, 0 /* RELATIVE */, &timeout
, NULL
)) {
991 fprintf(stderr
, "Internal timer error: aborting\n");
996 #endif /* defined(__linux__) */
1000 static int unix_start_timer(struct qemu_alarm_timer
*t
)
1002 struct sigaction act
;
1003 struct itimerval itv
;
1007 sigfillset(&act
.sa_mask
);
1009 act
.sa_handler
= host_alarm_handler
;
1011 sigaction(SIGALRM
, &act
, NULL
);
1013 itv
.it_interval
.tv_sec
= 0;
1014 /* for i386 kernel 2.6 to get 1 ms */
1015 itv
.it_interval
.tv_usec
= 999;
1016 itv
.it_value
.tv_sec
= 0;
1017 itv
.it_value
.tv_usec
= 10 * 1000;
1019 err
= setitimer(ITIMER_REAL
, &itv
, NULL
);
1026 static void unix_stop_timer(struct qemu_alarm_timer
*t
)
1028 struct itimerval itv
;
1030 memset(&itv
, 0, sizeof(itv
));
1031 setitimer(ITIMER_REAL
, &itv
, NULL
);
1034 #endif /* !defined(_WIN32) */
1039 static int win32_start_timer(struct qemu_alarm_timer
*t
)
1044 /* If you call ChangeTimerQueueTimer on a one-shot timer (its period
1045 is zero) that has already expired, the timer is not updated. Since
1046 creating a new timer is relatively expensive, set a bogus one-hour
1047 interval in the dynticks case. */
1048 success
= CreateTimerQueueTimer(&hTimer
,
1053 alarm_has_dynticks(t
) ? 3600000 : 1,
1054 WT_EXECUTEINTIMERTHREAD
);
1057 fprintf(stderr
, "Failed to initialize win32 alarm timer: %ld\n",
1062 t
->priv
= (PVOID
) hTimer
;
1066 static void win32_stop_timer(struct qemu_alarm_timer
*t
)
1068 HANDLE hTimer
= t
->priv
;
1071 DeleteTimerQueueTimer(NULL
, hTimer
, NULL
);
1075 static void win32_rearm_timer(struct qemu_alarm_timer
*t
)
1077 HANDLE hTimer
= t
->priv
;
1078 int nearest_delta_ms
;
1081 assert(alarm_has_dynticks(t
));
1082 if (!active_timers
[QEMU_CLOCK_REALTIME
] &&
1083 !active_timers
[QEMU_CLOCK_VIRTUAL
] &&
1084 !active_timers
[QEMU_CLOCK_HOST
])
1087 nearest_delta_ms
= (qemu_next_alarm_deadline() + 999999) / 1000000;
1088 if (nearest_delta_ms
< 1) {
1089 nearest_delta_ms
= 1;
1091 success
= ChangeTimerQueueTimer(NULL
,
1097 fprintf(stderr
, "Failed to rearm win32 alarm timer: %ld\n",
1106 static void alarm_timer_on_change_state_rearm(void *opaque
, int running
, int reason
)
1109 qemu_rearm_alarm_timer((struct qemu_alarm_timer
*) opaque
);
1112 int init_timer_alarm(void)
1114 struct qemu_alarm_timer
*t
= NULL
;
1117 for (i
= 0; alarm_timers
[i
].name
; i
++) {
1118 t
= &alarm_timers
[i
];
1130 /* first event is at time 0 */
1133 qemu_add_vm_change_state_handler(alarm_timer_on_change_state_rearm
, t
);
1141 void quit_timers(void)
1143 struct qemu_alarm_timer
*t
= alarm_timer
;
1148 int qemu_calculate_timeout(void)
1154 /* When using icount, making forward progress with qemu_icount when the
1155 guest CPU is idle is critical. We only use the static io-thread timeout
1156 for non icount runs. */
1157 if (!use_icount
|| !vm_running
) {
1161 /* Advance virtual time to the next event. */
1162 delta
= qemu_icount_delta();
1164 /* If virtual time is ahead of real time then just
1166 timeout
= (delta
+ 999999) / 1000000;
1168 /* Wait for either IO to occur or the next
1170 add
= qemu_next_deadline();
1171 /* We advance the timer before checking for IO.
1172 Limit the amount we advance so that early IO
1173 activity won't get the guest too far ahead. */
1177 qemu_icount
+= qemu_icount_round (add
);
1178 timeout
= delta
/ 1000000;