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>
47 #include "qemu-timer.h"
49 /***********************************************************/
52 #define QEMU_CLOCK_REALTIME 0
53 #define QEMU_CLOCK_VIRTUAL 1
54 #define QEMU_CLOCK_HOST 2
60 QEMUTimer
*active_timers
;
62 NotifierList reset_notifiers
;
68 int64_t expire_time
; /* in nanoseconds */
72 struct QEMUTimer
*next
;
75 struct qemu_alarm_timer
{
77 int (*start
)(struct qemu_alarm_timer
*t
);
78 void (*stop
)(struct qemu_alarm_timer
*t
);
79 void (*rearm
)(struct qemu_alarm_timer
*t
, int64_t nearest_delta_ns
);
80 #if defined(__linux__)
90 static struct qemu_alarm_timer
*alarm_timer
;
92 static bool qemu_timer_expired_ns(QEMUTimer
*timer_head
, int64_t current_time
)
94 return timer_head
&& (timer_head
->expire_time
<= current_time
);
97 int qemu_alarm_pending(void)
99 return alarm_timer
->pending
;
102 static inline int alarm_has_dynticks(struct qemu_alarm_timer
*t
)
107 static int64_t qemu_next_alarm_deadline(void)
112 if (!use_icount
&& vm_clock
->active_timers
) {
113 delta
= vm_clock
->active_timers
->expire_time
-
114 qemu_get_clock_ns(vm_clock
);
118 if (host_clock
->active_timers
) {
119 int64_t hdelta
= host_clock
->active_timers
->expire_time
-
120 qemu_get_clock_ns(host_clock
);
121 if (hdelta
< delta
) {
125 if (rt_clock
->active_timers
) {
126 rtdelta
= (rt_clock
->active_timers
->expire_time
-
127 qemu_get_clock_ns(rt_clock
));
128 if (rtdelta
< delta
) {
136 static void qemu_rearm_alarm_timer(struct qemu_alarm_timer
*t
)
138 int64_t nearest_delta_ns
;
139 assert(alarm_has_dynticks(t
));
140 if (!rt_clock
->active_timers
&&
141 !vm_clock
->active_timers
&&
142 !host_clock
->active_timers
) {
145 nearest_delta_ns
= qemu_next_alarm_deadline();
146 t
->rearm(t
, nearest_delta_ns
);
149 /* TODO: MIN_TIMER_REARM_NS should be optimized */
150 #define MIN_TIMER_REARM_NS 250000
154 static int mm_start_timer(struct qemu_alarm_timer
*t
);
155 static void mm_stop_timer(struct qemu_alarm_timer
*t
);
156 static void mm_rearm_timer(struct qemu_alarm_timer
*t
, int64_t delta
);
158 static int win32_start_timer(struct qemu_alarm_timer
*t
);
159 static void win32_stop_timer(struct qemu_alarm_timer
*t
);
160 static void win32_rearm_timer(struct qemu_alarm_timer
*t
, int64_t delta
);
164 static int unix_start_timer(struct qemu_alarm_timer
*t
);
165 static void unix_stop_timer(struct qemu_alarm_timer
*t
);
166 static void unix_rearm_timer(struct qemu_alarm_timer
*t
, int64_t delta
);
170 static int dynticks_start_timer(struct qemu_alarm_timer
*t
);
171 static void dynticks_stop_timer(struct qemu_alarm_timer
*t
);
172 static void dynticks_rearm_timer(struct qemu_alarm_timer
*t
, int64_t delta
);
174 #endif /* __linux__ */
178 static struct qemu_alarm_timer alarm_timers
[] = {
181 {"dynticks", dynticks_start_timer
,
182 dynticks_stop_timer
, dynticks_rearm_timer
},
184 {"unix", unix_start_timer
, unix_stop_timer
, unix_rearm_timer
},
186 {"mmtimer", mm_start_timer
, mm_stop_timer
, NULL
},
187 {"mmtimer2", mm_start_timer
, mm_stop_timer
, mm_rearm_timer
},
188 {"dynticks", win32_start_timer
, win32_stop_timer
, win32_rearm_timer
},
189 {"win32", win32_start_timer
, win32_stop_timer
, NULL
},
194 static void show_available_alarms(void)
198 printf("Available alarm timers, in order of precedence:\n");
199 for (i
= 0; alarm_timers
[i
].name
; i
++)
200 printf("%s\n", alarm_timers
[i
].name
);
203 void configure_alarms(char const *opt
)
207 int count
= ARRAY_SIZE(alarm_timers
) - 1;
210 struct qemu_alarm_timer tmp
;
212 if (!strcmp(opt
, "?")) {
213 show_available_alarms();
219 /* Reorder the array */
220 name
= strtok(arg
, ",");
222 for (i
= 0; i
< count
&& alarm_timers
[i
].name
; i
++) {
223 if (!strcmp(alarm_timers
[i
].name
, name
))
228 fprintf(stderr
, "Unknown clock %s\n", name
);
237 tmp
= alarm_timers
[i
];
238 alarm_timers
[i
] = alarm_timers
[cur
];
239 alarm_timers
[cur
] = tmp
;
243 name
= strtok(NULL
, ",");
249 /* Disable remaining timers */
250 for (i
= cur
; i
< count
; i
++)
251 alarm_timers
[i
].name
= NULL
;
253 show_available_alarms();
260 QEMUClock
*host_clock
;
262 static QEMUClock
*qemu_new_clock(int type
)
266 clock
= g_malloc0(sizeof(QEMUClock
));
269 notifier_list_init(&clock
->reset_notifiers
);
270 /* required to detect & report backward jumps */
271 if (type
== QEMU_CLOCK_HOST
) {
272 clock
->last
= get_clock_realtime();
277 void qemu_clock_enable(QEMUClock
*clock
, int enabled
)
279 clock
->enabled
= enabled
;
282 int64_t qemu_clock_has_timers(QEMUClock
*clock
)
284 return !!clock
->active_timers
;
287 int64_t qemu_clock_expired(QEMUClock
*clock
)
289 return (clock
->active_timers
&&
290 clock
->active_timers
->expire_time
< qemu_get_clock_ns(clock
));
293 int64_t qemu_clock_deadline(QEMUClock
*clock
)
295 /* To avoid problems with overflow limit this to 2^32. */
296 int64_t delta
= INT32_MAX
;
298 if (clock
->active_timers
) {
299 delta
= clock
->active_timers
->expire_time
- qemu_get_clock_ns(clock
);
307 QEMUTimer
*qemu_new_timer(QEMUClock
*clock
, int scale
,
308 QEMUTimerCB
*cb
, void *opaque
)
312 ts
= g_malloc0(sizeof(QEMUTimer
));
320 void qemu_free_timer(QEMUTimer
*ts
)
325 /* stop a timer, but do not dealloc it */
326 void qemu_del_timer(QEMUTimer
*ts
)
330 /* NOTE: this code must be signal safe because
331 qemu_timer_expired() can be called from a signal. */
332 pt
= &ts
->clock
->active_timers
;
345 /* modify the current timer so that it will be fired when current_time
346 >= expire_time. The corresponding callback will be called. */
347 static void qemu_mod_timer_ns(QEMUTimer
*ts
, int64_t expire_time
)
353 /* add the timer in the sorted list */
354 /* NOTE: this code must be signal safe because
355 qemu_timer_expired() can be called from a signal. */
356 pt
= &ts
->clock
->active_timers
;
359 if (!qemu_timer_expired_ns(t
, expire_time
)) {
364 ts
->expire_time
= expire_time
;
368 /* Rearm if necessary */
369 if (pt
== &ts
->clock
->active_timers
) {
370 if (!alarm_timer
->pending
) {
371 qemu_rearm_alarm_timer(alarm_timer
);
373 /* Interrupt execution to force deadline recalculation. */
374 qemu_clock_warp(ts
->clock
);
381 /* modify the current timer so that it will be fired when current_time
382 >= expire_time. The corresponding callback will be called. */
383 void qemu_mod_timer(QEMUTimer
*ts
, int64_t expire_time
)
385 qemu_mod_timer_ns(ts
, expire_time
* ts
->scale
);
388 int qemu_timer_pending(QEMUTimer
*ts
)
391 for (t
= ts
->clock
->active_timers
; t
!= NULL
; t
= t
->next
) {
398 int qemu_timer_expired(QEMUTimer
*timer_head
, int64_t current_time
)
400 return qemu_timer_expired_ns(timer_head
, current_time
* timer_head
->scale
);
403 static void qemu_run_timers(QEMUClock
*clock
)
405 QEMUTimer
**ptimer_head
, *ts
;
406 int64_t current_time
;
411 current_time
= qemu_get_clock_ns(clock
);
412 ptimer_head
= &clock
->active_timers
;
415 if (!qemu_timer_expired_ns(ts
, current_time
)) {
418 /* remove timer from the list before calling the callback */
419 *ptimer_head
= ts
->next
;
422 /* run the callback (the timer list can be modified) */
427 int64_t qemu_get_clock_ns(QEMUClock
*clock
)
431 switch(clock
->type
) {
432 case QEMU_CLOCK_REALTIME
:
435 case QEMU_CLOCK_VIRTUAL
:
437 return cpu_get_icount();
439 return cpu_get_clock();
441 case QEMU_CLOCK_HOST
:
442 now
= get_clock_realtime();
446 notifier_list_notify(&clock
->reset_notifiers
, &now
);
452 void qemu_register_clock_reset_notifier(QEMUClock
*clock
, Notifier
*notifier
)
454 notifier_list_add(&clock
->reset_notifiers
, notifier
);
457 void qemu_unregister_clock_reset_notifier(QEMUClock
*clock
, Notifier
*notifier
)
459 notifier_list_remove(&clock
->reset_notifiers
, notifier
);
462 void init_clocks(void)
464 rt_clock
= qemu_new_clock(QEMU_CLOCK_REALTIME
);
465 vm_clock
= qemu_new_clock(QEMU_CLOCK_VIRTUAL
);
466 host_clock
= qemu_new_clock(QEMU_CLOCK_HOST
);
468 rtc_clock
= host_clock
;
472 void qemu_put_timer(QEMUFile
*f
, QEMUTimer
*ts
)
474 uint64_t expire_time
;
476 if (qemu_timer_pending(ts
)) {
477 expire_time
= ts
->expire_time
;
481 qemu_put_be64(f
, expire_time
);
484 void qemu_get_timer(QEMUFile
*f
, QEMUTimer
*ts
)
486 uint64_t expire_time
;
488 expire_time
= qemu_get_be64(f
);
489 if (expire_time
!= -1) {
490 qemu_mod_timer_ns(ts
, expire_time
);
496 void qemu_run_all_timers(void)
498 alarm_timer
->pending
= 0;
500 /* rearm timer, if not periodic */
501 if (alarm_timer
->expired
) {
502 alarm_timer
->expired
= 0;
503 qemu_rearm_alarm_timer(alarm_timer
);
507 qemu_run_timers(vm_clock
);
508 qemu_run_timers(rt_clock
);
509 qemu_run_timers(host_clock
);
513 static void CALLBACK
host_alarm_handler(PVOID lpParam
, BOOLEAN unused
)
515 static void host_alarm_handler(int host_signum
)
518 struct qemu_alarm_timer
*t
= alarm_timer
;
523 #define DISP_FREQ 1000
525 static int64_t delta_min
= INT64_MAX
;
526 static int64_t delta_max
, delta_cum
, last_clock
, delta
, ti
;
528 ti
= qemu_get_clock_ns(vm_clock
);
529 if (last_clock
!= 0) {
530 delta
= ti
- last_clock
;
531 if (delta
< delta_min
)
533 if (delta
> delta_max
)
536 if (++count
== DISP_FREQ
) {
537 printf("timer: min=%" PRId64
" us max=%" PRId64
" us avg=%" PRId64
" us avg_freq=%0.3f Hz\n",
538 muldiv64(delta_min
, 1000000, get_ticks_per_sec()),
539 muldiv64(delta_max
, 1000000, get_ticks_per_sec()),
540 muldiv64(delta_cum
, 1000000 / DISP_FREQ
, get_ticks_per_sec()),
541 (double)get_ticks_per_sec() / ((double)delta_cum
/ DISP_FREQ
));
543 delta_min
= INT64_MAX
;
551 if (alarm_has_dynticks(t
) ||
552 qemu_next_alarm_deadline () <= 0) {
553 t
->expired
= alarm_has_dynticks(t
);
559 #if defined(__linux__)
561 #include "compatfd.h"
563 static int dynticks_start_timer(struct qemu_alarm_timer
*t
)
567 struct sigaction act
;
569 sigfillset(&act
.sa_mask
);
571 act
.sa_handler
= host_alarm_handler
;
573 sigaction(SIGALRM
, &act
, NULL
);
576 * Initialize ev struct to 0 to avoid valgrind complaining
577 * about uninitialized data in timer_create call
579 memset(&ev
, 0, sizeof(ev
));
580 ev
.sigev_value
.sival_int
= 0;
581 ev
.sigev_notify
= SIGEV_SIGNAL
;
582 #ifdef SIGEV_THREAD_ID
583 if (qemu_signalfd_available()) {
584 ev
.sigev_notify
= SIGEV_THREAD_ID
;
585 ev
._sigev_un
._tid
= qemu_get_thread_id();
587 #endif /* SIGEV_THREAD_ID */
588 ev
.sigev_signo
= SIGALRM
;
590 if (timer_create(CLOCK_REALTIME
, &ev
, &host_timer
)) {
591 perror("timer_create");
593 /* disable dynticks */
594 fprintf(stderr
, "Dynamic Ticks disabled\n");
599 t
->timer
= host_timer
;
604 static void dynticks_stop_timer(struct qemu_alarm_timer
*t
)
606 timer_t host_timer
= t
->timer
;
608 timer_delete(host_timer
);
611 static void dynticks_rearm_timer(struct qemu_alarm_timer
*t
,
612 int64_t nearest_delta_ns
)
614 timer_t host_timer
= t
->timer
;
615 struct itimerspec timeout
;
618 if (nearest_delta_ns
< MIN_TIMER_REARM_NS
)
619 nearest_delta_ns
= MIN_TIMER_REARM_NS
;
621 /* check whether a timer is already running */
622 if (timer_gettime(host_timer
, &timeout
)) {
624 fprintf(stderr
, "Internal timer error: aborting\n");
627 current_ns
= timeout
.it_value
.tv_sec
* 1000000000LL + timeout
.it_value
.tv_nsec
;
628 if (current_ns
&& current_ns
<= nearest_delta_ns
)
631 timeout
.it_interval
.tv_sec
= 0;
632 timeout
.it_interval
.tv_nsec
= 0; /* 0 for one-shot timer */
633 timeout
.it_value
.tv_sec
= nearest_delta_ns
/ 1000000000;
634 timeout
.it_value
.tv_nsec
= nearest_delta_ns
% 1000000000;
635 if (timer_settime(host_timer
, 0 /* RELATIVE */, &timeout
, NULL
)) {
637 fprintf(stderr
, "Internal timer error: aborting\n");
642 #endif /* defined(__linux__) */
646 static int unix_start_timer(struct qemu_alarm_timer
*t
)
648 struct sigaction act
;
651 sigfillset(&act
.sa_mask
);
653 act
.sa_handler
= host_alarm_handler
;
655 sigaction(SIGALRM
, &act
, NULL
);
659 static void unix_rearm_timer(struct qemu_alarm_timer
*t
,
660 int64_t nearest_delta_ns
)
662 struct itimerval itv
;
665 if (nearest_delta_ns
< MIN_TIMER_REARM_NS
)
666 nearest_delta_ns
= MIN_TIMER_REARM_NS
;
668 itv
.it_interval
.tv_sec
= 0;
669 itv
.it_interval
.tv_usec
= 0; /* 0 for one-shot timer */
670 itv
.it_value
.tv_sec
= nearest_delta_ns
/ 1000000000;
671 itv
.it_value
.tv_usec
= (nearest_delta_ns
% 1000000000) / 1000;
672 err
= setitimer(ITIMER_REAL
, &itv
, NULL
);
675 fprintf(stderr
, "Internal timer error: aborting\n");
680 static void unix_stop_timer(struct qemu_alarm_timer
*t
)
682 struct itimerval itv
;
684 memset(&itv
, 0, sizeof(itv
));
685 setitimer(ITIMER_REAL
, &itv
, NULL
);
688 #endif /* !defined(_WIN32) */
693 static MMRESULT mm_timer
;
694 static unsigned mm_period
;
696 static void CALLBACK
mm_alarm_handler(UINT uTimerID
, UINT uMsg
,
697 DWORD_PTR dwUser
, DWORD_PTR dw1
,
700 struct qemu_alarm_timer
*t
= alarm_timer
;
704 if (alarm_has_dynticks(t
) || qemu_next_alarm_deadline() <= 0) {
705 t
->expired
= alarm_has_dynticks(t
);
711 static int mm_start_timer(struct qemu_alarm_timer
*t
)
716 memset(&tc
, 0, sizeof(tc
));
717 timeGetDevCaps(&tc
, sizeof(tc
));
719 mm_period
= tc
.wPeriodMin
;
720 timeBeginPeriod(mm_period
);
722 flags
= TIME_CALLBACK_FUNCTION
;
723 if (alarm_has_dynticks(t
)) {
724 flags
|= TIME_ONESHOT
;
726 flags
|= TIME_PERIODIC
;
729 mm_timer
= timeSetEvent(1, /* interval (ms) */
730 mm_period
, /* resolution */
731 mm_alarm_handler
, /* function */
732 (DWORD_PTR
)t
, /* parameter */
736 fprintf(stderr
, "Failed to initialize win32 alarm timer: %ld\n",
738 timeEndPeriod(mm_period
);
745 static void mm_stop_timer(struct qemu_alarm_timer
*t
)
747 timeKillEvent(mm_timer
);
748 timeEndPeriod(mm_period
);
751 static void mm_rearm_timer(struct qemu_alarm_timer
*t
, int64_t delta
)
753 int nearest_delta_ms
= (delta
+ 999999) / 1000000;
754 if (nearest_delta_ms
< 1) {
755 nearest_delta_ms
= 1;
758 timeKillEvent(mm_timer
);
759 mm_timer
= timeSetEvent(nearest_delta_ms
,
763 TIME_ONESHOT
| TIME_CALLBACK_FUNCTION
);
766 fprintf(stderr
, "Failed to re-arm win32 alarm timer %ld\n",
769 timeEndPeriod(mm_period
);
774 static int win32_start_timer(struct qemu_alarm_timer
*t
)
779 /* If you call ChangeTimerQueueTimer on a one-shot timer (its period
780 is zero) that has already expired, the timer is not updated. Since
781 creating a new timer is relatively expensive, set a bogus one-hour
782 interval in the dynticks case. */
783 success
= CreateTimerQueueTimer(&hTimer
,
788 alarm_has_dynticks(t
) ? 3600000 : 1,
789 WT_EXECUTEINTIMERTHREAD
);
792 fprintf(stderr
, "Failed to initialize win32 alarm timer: %ld\n",
801 static void win32_stop_timer(struct qemu_alarm_timer
*t
)
803 HANDLE hTimer
= t
->timer
;
806 DeleteTimerQueueTimer(NULL
, hTimer
, NULL
);
810 static void win32_rearm_timer(struct qemu_alarm_timer
*t
,
811 int64_t nearest_delta_ns
)
813 HANDLE hTimer
= t
->timer
;
814 int nearest_delta_ms
;
817 nearest_delta_ms
= (nearest_delta_ns
+ 999999) / 1000000;
818 if (nearest_delta_ms
< 1) {
819 nearest_delta_ms
= 1;
821 success
= ChangeTimerQueueTimer(NULL
,
827 fprintf(stderr
, "Failed to rearm win32 alarm timer: %ld\n",
836 static void alarm_timer_on_change_state_rearm(void *opaque
, int running
,
840 qemu_rearm_alarm_timer((struct qemu_alarm_timer
*) opaque
);
843 int init_timer_alarm(void)
845 struct qemu_alarm_timer
*t
= NULL
;
848 for (i
= 0; alarm_timers
[i
].name
; i
++) {
849 t
= &alarm_timers
[i
];
861 /* first event is at time 0 */
864 qemu_add_vm_change_state_handler(alarm_timer_on_change_state_rearm
, t
);
872 void quit_timers(void)
874 struct qemu_alarm_timer
*t
= alarm_timer
;
879 int qemu_calculate_timeout(void)