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
25 #include "sysemu/sysemu.h"
26 #include "monitor/monitor.h"
27 #include "ui/console.h"
31 #include "qemu/timer.h"
44 #ifdef CONFIG_PRCTL_PR_SET_TIMERSLACK
45 #include <sys/prctl.h>
48 /***********************************************************/
52 QEMUTimer
*active_timers
;
54 NotifierList reset_notifiers
;
62 int64_t expire_time
; /* in nanoseconds */
70 struct qemu_alarm_timer
{
72 int (*start
)(struct qemu_alarm_timer
*t
);
73 void (*stop
)(struct qemu_alarm_timer
*t
);
74 void (*rearm
)(struct qemu_alarm_timer
*t
, int64_t nearest_delta_ns
);
75 #if defined(__linux__)
85 static struct qemu_alarm_timer
*alarm_timer
;
87 static bool timer_expired_ns(QEMUTimer
*timer_head
, int64_t current_time
)
89 return timer_head
&& (timer_head
->expire_time
<= current_time
);
92 static int64_t qemu_next_alarm_deadline(void)
94 int64_t delta
= INT64_MAX
;
97 if (!use_icount
&& vm_clock
->enabled
&& vm_clock
->active_timers
) {
98 delta
= vm_clock
->active_timers
->expire_time
-
99 qemu_get_clock_ns(vm_clock
);
101 if (host_clock
->enabled
&& host_clock
->active_timers
) {
102 int64_t hdelta
= host_clock
->active_timers
->expire_time
-
103 qemu_get_clock_ns(host_clock
);
104 if (hdelta
< delta
) {
108 if (rt_clock
->enabled
&& rt_clock
->active_timers
) {
109 rtdelta
= (rt_clock
->active_timers
->expire_time
-
110 qemu_get_clock_ns(rt_clock
));
111 if (rtdelta
< delta
) {
119 static void qemu_rearm_alarm_timer(struct qemu_alarm_timer
*t
)
121 int64_t nearest_delta_ns
= qemu_next_alarm_deadline();
122 if (nearest_delta_ns
< INT64_MAX
) {
123 t
->rearm(t
, nearest_delta_ns
);
127 /* TODO: MIN_TIMER_REARM_NS should be optimized */
128 #define MIN_TIMER_REARM_NS 250000
132 static int mm_start_timer(struct qemu_alarm_timer
*t
);
133 static void mm_stop_timer(struct qemu_alarm_timer
*t
);
134 static void mm_rearm_timer(struct qemu_alarm_timer
*t
, int64_t delta
);
136 static int win32_start_timer(struct qemu_alarm_timer
*t
);
137 static void win32_stop_timer(struct qemu_alarm_timer
*t
);
138 static void win32_rearm_timer(struct qemu_alarm_timer
*t
, int64_t delta
);
142 static int unix_start_timer(struct qemu_alarm_timer
*t
);
143 static void unix_stop_timer(struct qemu_alarm_timer
*t
);
144 static void unix_rearm_timer(struct qemu_alarm_timer
*t
, int64_t delta
);
148 static int dynticks_start_timer(struct qemu_alarm_timer
*t
);
149 static void dynticks_stop_timer(struct qemu_alarm_timer
*t
);
150 static void dynticks_rearm_timer(struct qemu_alarm_timer
*t
, int64_t delta
);
152 #endif /* __linux__ */
156 static struct qemu_alarm_timer alarm_timers
[] = {
159 {"dynticks", dynticks_start_timer
,
160 dynticks_stop_timer
, dynticks_rearm_timer
},
162 {"unix", unix_start_timer
, unix_stop_timer
, unix_rearm_timer
},
164 {"mmtimer", mm_start_timer
, mm_stop_timer
, mm_rearm_timer
},
165 {"dynticks", win32_start_timer
, win32_stop_timer
, win32_rearm_timer
},
170 static void show_available_alarms(void)
174 printf("Available alarm timers, in order of precedence:\n");
175 for (i
= 0; alarm_timers
[i
].name
; i
++)
176 printf("%s\n", alarm_timers
[i
].name
);
179 void configure_alarms(char const *opt
)
183 int count
= ARRAY_SIZE(alarm_timers
) - 1;
186 struct qemu_alarm_timer tmp
;
188 if (is_help_option(opt
)) {
189 show_available_alarms();
195 /* Reorder the array */
196 name
= strtok(arg
, ",");
198 for (i
= 0; i
< count
&& alarm_timers
[i
].name
; i
++) {
199 if (!strcmp(alarm_timers
[i
].name
, name
))
204 fprintf(stderr
, "Unknown clock %s\n", name
);
213 tmp
= alarm_timers
[i
];
214 alarm_timers
[i
] = alarm_timers
[cur
];
215 alarm_timers
[cur
] = tmp
;
219 name
= strtok(NULL
, ",");
225 /* Disable remaining timers */
226 for (i
= cur
; i
< count
; i
++)
227 alarm_timers
[i
].name
= NULL
;
229 show_available_alarms();
236 QEMUClock
*host_clock
;
238 static QEMUClock
*qemu_clock_new(int type
)
242 clock
= g_malloc0(sizeof(QEMUClock
));
244 clock
->enabled
= true;
245 clock
->last
= INT64_MIN
;
246 notifier_list_init(&clock
->reset_notifiers
);
250 void qemu_clock_enable(QEMUClock
*clock
, bool enabled
)
252 bool old
= clock
->enabled
;
253 clock
->enabled
= enabled
;
254 if (enabled
&& !old
) {
255 qemu_rearm_alarm_timer(alarm_timer
);
259 int64_t qemu_clock_has_timers(QEMUClock
*clock
)
261 return !!clock
->active_timers
;
264 int64_t qemu_clock_expired(QEMUClock
*clock
)
266 return (clock
->active_timers
&&
267 clock
->active_timers
->expire_time
< qemu_get_clock_ns(clock
));
270 int64_t qemu_clock_deadline(QEMUClock
*clock
)
272 /* To avoid problems with overflow limit this to 2^32. */
273 int64_t delta
= INT32_MAX
;
275 if (clock
->enabled
&& clock
->active_timers
) {
276 delta
= clock
->active_timers
->expire_time
- qemu_get_clock_ns(clock
);
285 * As above, but return -1 for no deadline, and do not cap to 2^32
286 * as we know the result is always positive.
289 int64_t qemu_clock_deadline_ns(QEMUClock
*clock
)
293 if (!clock
->enabled
|| !clock
->active_timers
) {
297 delta
= clock
->active_timers
->expire_time
- qemu_get_clock_ns(clock
);
306 /* Transition function to convert a nanosecond timeout to ms
307 * This is used where a system does not support ppoll
309 int qemu_timeout_ns_to_ms(int64_t ns
)
320 /* Always round up, because it's better to wait too long than to wait too
321 * little and effectively busy-wait
323 ms
= (ns
+ SCALE_MS
- 1) / SCALE_MS
;
325 /* To avoid overflow problems, limit this to 2^31, i.e. approx 25 days */
326 if (ms
> (int64_t) INT32_MAX
) {
334 /* qemu implementation of g_poll which uses a nanosecond timeout but is
335 * otherwise identical to g_poll
337 int qemu_poll_ns(GPollFD
*fds
, guint nfds
, int64_t timeout
)
341 return ppoll((struct pollfd
*)fds
, nfds
, NULL
, NULL
);
344 ts
.tv_sec
= timeout
/ 1000000000LL;
345 ts
.tv_nsec
= timeout
% 1000000000LL;
346 return ppoll((struct pollfd
*)fds
, nfds
, &ts
, NULL
);
349 return g_poll(fds
, nfds
, qemu_timeout_ns_to_ms(timeout
));
354 QEMUTimer
*qemu_new_timer(QEMUClock
*clock
, int scale
,
355 QEMUTimerCB
*cb
, void *opaque
)
359 ts
= g_malloc0(sizeof(QEMUTimer
));
367 void qemu_free_timer(QEMUTimer
*ts
)
372 /* stop a timer, but do not dealloc it */
373 void qemu_del_timer(QEMUTimer
*ts
)
377 /* NOTE: this code must be signal safe because
378 timer_expired() can be called from a signal. */
379 pt
= &ts
->clock
->active_timers
;
392 /* modify the current timer so that it will be fired when current_time
393 >= expire_time. The corresponding callback will be called. */
394 void qemu_mod_timer_ns(QEMUTimer
*ts
, int64_t expire_time
)
400 /* add the timer in the sorted list */
401 /* NOTE: this code must be signal safe because
402 timer_expired() can be called from a signal. */
403 pt
= &ts
->clock
->active_timers
;
406 if (!timer_expired_ns(t
, expire_time
)) {
411 ts
->expire_time
= expire_time
;
415 /* Rearm if necessary */
416 if (pt
== &ts
->clock
->active_timers
) {
417 if (!alarm_timer
->pending
) {
418 qemu_rearm_alarm_timer(alarm_timer
);
420 /* Interrupt execution to force deadline recalculation. */
421 qemu_clock_warp(ts
->clock
);
428 void qemu_mod_timer(QEMUTimer
*ts
, int64_t expire_time
)
430 qemu_mod_timer_ns(ts
, expire_time
* ts
->scale
);
433 bool timer_pending(QEMUTimer
*ts
)
436 for (t
= ts
->clock
->active_timers
; t
!= NULL
; t
= t
->next
) {
444 bool timer_expired(QEMUTimer
*timer_head
, int64_t current_time
)
446 return timer_expired_ns(timer_head
, current_time
* timer_head
->scale
);
449 void qemu_run_timers(QEMUClock
*clock
)
452 int64_t current_time
;
457 current_time
= qemu_get_clock_ns(clock
);
459 ts
= clock
->active_timers
;
460 if (!timer_expired_ns(ts
, current_time
)) {
463 /* remove timer from the list before calling the callback */
464 clock
->active_timers
= ts
->next
;
467 /* run the callback (the timer list can be modified) */
472 int64_t qemu_get_clock_ns(QEMUClock
*clock
)
476 switch(clock
->type
) {
477 case QEMU_CLOCK_REALTIME
:
480 case QEMU_CLOCK_VIRTUAL
:
482 return cpu_get_icount();
484 return cpu_get_clock();
486 case QEMU_CLOCK_HOST
:
487 now
= get_clock_realtime();
491 notifier_list_notify(&clock
->reset_notifiers
, &now
);
497 void qemu_register_clock_reset_notifier(QEMUClock
*clock
, Notifier
*notifier
)
499 notifier_list_add(&clock
->reset_notifiers
, notifier
);
502 void qemu_unregister_clock_reset_notifier(QEMUClock
*clock
, Notifier
*notifier
)
504 notifier_remove(notifier
);
507 void init_clocks(void)
510 rt_clock
= qemu_clock_new(QEMU_CLOCK_REALTIME
);
511 vm_clock
= qemu_clock_new(QEMU_CLOCK_VIRTUAL
);
512 host_clock
= qemu_clock_new(QEMU_CLOCK_HOST
);
514 #ifdef CONFIG_PRCTL_PR_SET_TIMERSLACK
515 prctl(PR_SET_TIMERSLACK
, 1, 0, 0, 0);
519 uint64_t timer_expire_time_ns(QEMUTimer
*ts
)
521 return timer_pending(ts
) ? ts
->expire_time
: -1;
524 void qemu_run_all_timers(void)
526 alarm_timer
->pending
= false;
529 qemu_run_timers(vm_clock
);
530 qemu_run_timers(rt_clock
);
531 qemu_run_timers(host_clock
);
533 /* rearm timer, if not periodic */
534 if (alarm_timer
->expired
) {
535 alarm_timer
->expired
= false;
536 qemu_rearm_alarm_timer(alarm_timer
);
541 static void CALLBACK
host_alarm_handler(PVOID lpParam
, BOOLEAN unused
)
543 static void host_alarm_handler(int host_signum
)
546 struct qemu_alarm_timer
*t
= alarm_timer
;
555 #if defined(__linux__)
557 #include "qemu/compatfd.h"
559 static int dynticks_start_timer(struct qemu_alarm_timer
*t
)
563 struct sigaction act
;
565 sigfillset(&act
.sa_mask
);
567 act
.sa_handler
= host_alarm_handler
;
569 sigaction(SIGALRM
, &act
, NULL
);
572 * Initialize ev struct to 0 to avoid valgrind complaining
573 * about uninitialized data in timer_create call
575 memset(&ev
, 0, sizeof(ev
));
576 ev
.sigev_value
.sival_int
= 0;
577 ev
.sigev_notify
= SIGEV_SIGNAL
;
578 #ifdef CONFIG_SIGEV_THREAD_ID
579 if (qemu_signalfd_available()) {
580 ev
.sigev_notify
= SIGEV_THREAD_ID
;
581 ev
._sigev_un
._tid
= qemu_get_thread_id();
583 #endif /* CONFIG_SIGEV_THREAD_ID */
584 ev
.sigev_signo
= SIGALRM
;
586 if (timer_create(CLOCK_REALTIME
, &ev
, &host_timer
)) {
587 perror("timer_create");
591 t
->timer
= host_timer
;
596 static void dynticks_stop_timer(struct qemu_alarm_timer
*t
)
598 timer_t host_timer
= t
->timer
;
600 timer_delete(host_timer
);
603 static void dynticks_rearm_timer(struct qemu_alarm_timer
*t
,
604 int64_t nearest_delta_ns
)
606 timer_t host_timer
= t
->timer
;
607 struct itimerspec timeout
;
610 if (nearest_delta_ns
< MIN_TIMER_REARM_NS
)
611 nearest_delta_ns
= MIN_TIMER_REARM_NS
;
613 /* check whether a timer is already running */
614 if (timer_gettime(host_timer
, &timeout
)) {
616 fprintf(stderr
, "Internal timer error: aborting\n");
619 current_ns
= timeout
.it_value
.tv_sec
* 1000000000LL + timeout
.it_value
.tv_nsec
;
620 if (current_ns
&& current_ns
<= nearest_delta_ns
)
623 timeout
.it_interval
.tv_sec
= 0;
624 timeout
.it_interval
.tv_nsec
= 0; /* 0 for one-shot timer */
625 timeout
.it_value
.tv_sec
= nearest_delta_ns
/ 1000000000;
626 timeout
.it_value
.tv_nsec
= nearest_delta_ns
% 1000000000;
627 if (timer_settime(host_timer
, 0 /* RELATIVE */, &timeout
, NULL
)) {
629 fprintf(stderr
, "Internal timer error: aborting\n");
634 #endif /* defined(__linux__) */
638 static int unix_start_timer(struct qemu_alarm_timer
*t
)
640 struct sigaction act
;
643 sigfillset(&act
.sa_mask
);
645 act
.sa_handler
= host_alarm_handler
;
647 sigaction(SIGALRM
, &act
, NULL
);
651 static void unix_rearm_timer(struct qemu_alarm_timer
*t
,
652 int64_t nearest_delta_ns
)
654 struct itimerval itv
;
657 if (nearest_delta_ns
< MIN_TIMER_REARM_NS
)
658 nearest_delta_ns
= MIN_TIMER_REARM_NS
;
660 itv
.it_interval
.tv_sec
= 0;
661 itv
.it_interval
.tv_usec
= 0; /* 0 for one-shot timer */
662 itv
.it_value
.tv_sec
= nearest_delta_ns
/ 1000000000;
663 itv
.it_value
.tv_usec
= (nearest_delta_ns
% 1000000000) / 1000;
664 err
= setitimer(ITIMER_REAL
, &itv
, NULL
);
667 fprintf(stderr
, "Internal timer error: aborting\n");
672 static void unix_stop_timer(struct qemu_alarm_timer
*t
)
674 struct itimerval itv
;
676 memset(&itv
, 0, sizeof(itv
));
677 setitimer(ITIMER_REAL
, &itv
, NULL
);
680 #endif /* !defined(_WIN32) */
685 static MMRESULT mm_timer
;
686 static TIMECAPS mm_tc
;
688 static void CALLBACK
mm_alarm_handler(UINT uTimerID
, UINT uMsg
,
689 DWORD_PTR dwUser
, DWORD_PTR dw1
,
692 struct qemu_alarm_timer
*t
= alarm_timer
;
701 static int mm_start_timer(struct qemu_alarm_timer
*t
)
703 timeGetDevCaps(&mm_tc
, sizeof(mm_tc
));
707 static void mm_stop_timer(struct qemu_alarm_timer
*t
)
710 timeKillEvent(mm_timer
);
714 static void mm_rearm_timer(struct qemu_alarm_timer
*t
, int64_t delta
)
716 int64_t nearest_delta_ms
= delta
/ 1000000;
717 if (nearest_delta_ms
< mm_tc
.wPeriodMin
) {
718 nearest_delta_ms
= mm_tc
.wPeriodMin
;
719 } else if (nearest_delta_ms
> mm_tc
.wPeriodMax
) {
720 nearest_delta_ms
= mm_tc
.wPeriodMax
;
724 timeKillEvent(mm_timer
);
726 mm_timer
= timeSetEvent((UINT
)nearest_delta_ms
,
730 TIME_ONESHOT
| TIME_CALLBACK_FUNCTION
);
733 fprintf(stderr
, "Failed to re-arm win32 alarm timer\n");
734 timeEndPeriod(mm_tc
.wPeriodMin
);
739 static int win32_start_timer(struct qemu_alarm_timer
*t
)
744 /* If you call ChangeTimerQueueTimer on a one-shot timer (its period
745 is zero) that has already expired, the timer is not updated. Since
746 creating a new timer is relatively expensive, set a bogus one-hour
747 interval in the dynticks case. */
748 success
= CreateTimerQueueTimer(&hTimer
,
754 WT_EXECUTEINTIMERTHREAD
);
757 fprintf(stderr
, "Failed to initialize win32 alarm timer: %ld\n",
766 static void win32_stop_timer(struct qemu_alarm_timer
*t
)
768 HANDLE hTimer
= t
->timer
;
771 DeleteTimerQueueTimer(NULL
, hTimer
, NULL
);
775 static void win32_rearm_timer(struct qemu_alarm_timer
*t
,
776 int64_t nearest_delta_ns
)
778 HANDLE hTimer
= t
->timer
;
779 int64_t nearest_delta_ms
;
782 nearest_delta_ms
= nearest_delta_ns
/ 1000000;
783 if (nearest_delta_ms
< 1) {
784 nearest_delta_ms
= 1;
786 /* ULONG_MAX can be 32 bit */
787 if (nearest_delta_ms
> ULONG_MAX
) {
788 nearest_delta_ms
= ULONG_MAX
;
790 success
= ChangeTimerQueueTimer(NULL
,
792 (unsigned long) nearest_delta_ms
,
796 fprintf(stderr
, "Failed to rearm win32 alarm timer: %ld\n",
805 static void quit_timers(void)
807 struct qemu_alarm_timer
*t
= alarm_timer
;
813 static void reinit_timers(void)
815 struct qemu_alarm_timer
*t
= alarm_timer
;
818 fprintf(stderr
, "Internal timer error: aborting\n");
821 qemu_rearm_alarm_timer(t
);
823 #endif /* CONFIG_POSIX */
825 int init_timer_alarm(void)
827 struct qemu_alarm_timer
*t
= NULL
;
834 for (i
= 0; alarm_timers
[i
].name
; i
++) {
835 t
= &alarm_timers
[i
];
849 pthread_atfork(NULL
, NULL
, reinit_timers
);