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"
40 #ifdef CONFIG_PRCTL_PR_SET_TIMERSLACK
41 #include <sys/prctl.h>
44 /***********************************************************/
48 QEMUTimerList
*main_loop_timerlist
;
49 QLIST_HEAD(, QEMUTimerList
) timerlists
;
51 NotifierList reset_notifiers
;
58 QEMUTimerListGroup main_loop_tlg
;
59 QEMUClock
*qemu_clocks
[QEMU_CLOCK_MAX
];
61 /* A QEMUTimerList is a list of timers attached to a clock. More
62 * than one QEMUTimerList can be attached to each clock, for instance
63 * used by different AioContexts / threads. Each clock also has
64 * a list of the QEMUTimerLists associated with it, in order that
65 * reenabling the clock can call all the notifiers.
68 struct QEMUTimerList
{
70 QEMUTimer
*active_timers
;
71 QLIST_ENTRY(QEMUTimerList
) list
;
72 QEMUTimerListNotifyCB
*notify_cb
;
76 static bool timer_expired_ns(QEMUTimer
*timer_head
, int64_t current_time
)
78 return timer_head
&& (timer_head
->expire_time
<= current_time
);
81 static QEMUTimerList
*timerlist_new_from_clock(QEMUClock
*clock
,
82 QEMUTimerListNotifyCB
*cb
,
85 QEMUTimerList
*timer_list
;
87 /* Assert if we do not have a clock. If you see this
88 * assertion in means that the clocks have not been
89 * initialised before a timerlist is needed. This
90 * normally happens if an AioContext is used before
91 * init_clocks() is called within main().
95 timer_list
= g_malloc0(sizeof(QEMUTimerList
));
96 timer_list
->clock
= clock
;
97 timer_list
->notify_cb
= cb
;
98 timer_list
->notify_opaque
= opaque
;
99 QLIST_INSERT_HEAD(&clock
->timerlists
, timer_list
, list
);
103 QEMUTimerList
*timerlist_new(QEMUClockType type
,
104 QEMUTimerListNotifyCB
*cb
, void *opaque
)
106 return timerlist_new_from_clock(qemu_clock_ptr(type
), cb
, opaque
);
109 void timerlist_free(QEMUTimerList
*timer_list
)
111 assert(!timerlist_has_timers(timer_list
));
112 if (timer_list
->clock
) {
113 QLIST_REMOVE(timer_list
, list
);
114 if (timer_list
->clock
->main_loop_timerlist
== timer_list
) {
115 timer_list
->clock
->main_loop_timerlist
= NULL
;
121 static QEMUClock
*qemu_clock_new(QEMUClockType type
)
125 clock
= g_malloc0(sizeof(QEMUClock
));
127 clock
->enabled
= true;
128 clock
->last
= INT64_MIN
;
129 QLIST_INIT(&clock
->timerlists
);
130 notifier_list_init(&clock
->reset_notifiers
);
131 clock
->main_loop_timerlist
= timerlist_new_from_clock(clock
, NULL
, NULL
);
135 bool qemu_clock_use_for_deadline(QEMUClock
*clock
)
137 return !(use_icount
&& (clock
->type
== QEMU_CLOCK_VIRTUAL
));
140 void qemu_clock_notify(QEMUClock
*clock
)
142 QEMUTimerList
*timer_list
;
143 QLIST_FOREACH(timer_list
, &clock
->timerlists
, list
) {
144 timerlist_notify(timer_list
);
148 void qemu_clock_enable(QEMUClock
*clock
, bool enabled
)
150 bool old
= clock
->enabled
;
151 clock
->enabled
= enabled
;
152 if (enabled
&& !old
) {
153 qemu_clock_notify(clock
);
157 bool timerlist_has_timers(QEMUTimerList
*timer_list
)
159 return !!timer_list
->active_timers
;
162 bool qemu_clock_has_timers(QEMUClock
*clock
)
164 return timerlist_has_timers(clock
->main_loop_timerlist
);
167 bool timerlist_expired(QEMUTimerList
*timer_list
)
169 return (timer_list
->active_timers
&&
170 timer_list
->active_timers
->expire_time
<
171 qemu_get_clock_ns(timer_list
->clock
));
174 bool qemu_clock_expired(QEMUClock
*clock
)
176 return timerlist_expired(clock
->main_loop_timerlist
);
179 int64_t timerlist_deadline(QEMUTimerList
*timer_list
)
181 /* To avoid problems with overflow limit this to 2^32. */
182 int64_t delta
= INT32_MAX
;
184 if (timer_list
->clock
->enabled
&& timer_list
->active_timers
) {
185 delta
= timer_list
->active_timers
->expire_time
-
186 qemu_get_clock_ns(timer_list
->clock
);
194 int64_t qemu_clock_deadline(QEMUClock
*clock
)
196 return timerlist_deadline(clock
->main_loop_timerlist
);
200 * As above, but return -1 for no deadline, and do not cap to 2^32
201 * as we know the result is always positive.
204 int64_t timerlist_deadline_ns(QEMUTimerList
*timer_list
)
208 if (!timer_list
->clock
->enabled
|| !timer_list
->active_timers
) {
212 delta
= timer_list
->active_timers
->expire_time
-
213 qemu_get_clock_ns(timer_list
->clock
);
222 int64_t qemu_clock_deadline_ns(QEMUClock
*clock
)
224 return timerlist_deadline_ns(clock
->main_loop_timerlist
);
227 /* Calculate the soonest deadline across all timerlists attached
228 * to the clock. This is used for the icount timeout so we
229 * ignore whether or not the clock should be used in deadline
232 int64_t qemu_clock_deadline_ns_all(QEMUClock
*clock
)
234 int64_t deadline
= -1;
235 QEMUTimerList
*timer_list
;
236 QLIST_FOREACH(timer_list
, &clock
->timerlists
, list
) {
237 deadline
= qemu_soonest_timeout(deadline
,
238 timerlist_deadline_ns(timer_list
));
243 QEMUClock
*timerlist_get_clock(QEMUTimerList
*timer_list
)
245 return timer_list
->clock
;
248 QEMUTimerList
*qemu_clock_get_main_loop_timerlist(QEMUClock
*clock
)
250 return clock
->main_loop_timerlist
;
253 void timerlist_notify(QEMUTimerList
*timer_list
)
255 if (timer_list
->notify_cb
) {
256 timer_list
->notify_cb(timer_list
->notify_opaque
);
262 /* Transition function to convert a nanosecond timeout to ms
263 * This is used where a system does not support ppoll
265 int qemu_timeout_ns_to_ms(int64_t ns
)
276 /* Always round up, because it's better to wait too long than to wait too
277 * little and effectively busy-wait
279 ms
= (ns
+ SCALE_MS
- 1) / SCALE_MS
;
281 /* To avoid overflow problems, limit this to 2^31, i.e. approx 25 days */
282 if (ms
> (int64_t) INT32_MAX
) {
290 /* qemu implementation of g_poll which uses a nanosecond timeout but is
291 * otherwise identical to g_poll
293 int qemu_poll_ns(GPollFD
*fds
, guint nfds
, int64_t timeout
)
297 return ppoll((struct pollfd
*)fds
, nfds
, NULL
, NULL
);
300 ts
.tv_sec
= timeout
/ 1000000000LL;
301 ts
.tv_nsec
= timeout
% 1000000000LL;
302 return ppoll((struct pollfd
*)fds
, nfds
, &ts
, NULL
);
305 return g_poll(fds
, nfds
, qemu_timeout_ns_to_ms(timeout
));
310 void timer_init(QEMUTimer
*ts
,
311 QEMUTimerList
*timer_list
, int scale
,
312 QEMUTimerCB
*cb
, void *opaque
)
314 ts
->timer_list
= timer_list
;
320 QEMUTimer
*qemu_new_timer(QEMUClock
*clock
, int scale
,
321 QEMUTimerCB
*cb
, void *opaque
)
323 return timer_new_tl(clock
->main_loop_timerlist
,
327 void qemu_free_timer(QEMUTimer
*ts
)
332 /* stop a timer, but do not dealloc it */
333 void qemu_del_timer(QEMUTimer
*ts
)
337 /* NOTE: this code must be signal safe because
338 timer_expired() can be called from a signal. */
339 pt
= &ts
->timer_list
->active_timers
;
352 /* modify the current timer so that it will be fired when current_time
353 >= expire_time. The corresponding callback will be called. */
354 void qemu_mod_timer_ns(QEMUTimer
*ts
, int64_t expire_time
)
360 /* add the timer in the sorted list */
361 /* NOTE: this code must be signal safe because
362 timer_expired() can be called from a signal. */
363 pt
= &ts
->timer_list
->active_timers
;
366 if (!timer_expired_ns(t
, expire_time
)) {
371 ts
->expire_time
= expire_time
;
375 /* Rearm if necessary */
376 if (pt
== &ts
->timer_list
->active_timers
) {
377 /* Interrupt execution to force deadline recalculation. */
378 qemu_clock_warp(ts
->timer_list
->clock
);
379 timerlist_notify(ts
->timer_list
);
383 void qemu_mod_timer(QEMUTimer
*ts
, int64_t expire_time
)
385 qemu_mod_timer_ns(ts
, expire_time
* ts
->scale
);
388 bool timer_pending(QEMUTimer
*ts
)
391 for (t
= ts
->timer_list
->active_timers
; t
!= NULL
; t
= t
->next
) {
399 bool timer_expired(QEMUTimer
*timer_head
, int64_t current_time
)
401 return timer_expired_ns(timer_head
, current_time
* timer_head
->scale
);
404 bool timerlist_run_timers(QEMUTimerList
*timer_list
)
407 int64_t current_time
;
408 bool progress
= false;
410 if (!timer_list
->clock
->enabled
) {
414 current_time
= qemu_get_clock_ns(timer_list
->clock
);
416 ts
= timer_list
->active_timers
;
417 if (!timer_expired_ns(ts
, current_time
)) {
420 /* remove timer from the list before calling the callback */
421 timer_list
->active_timers
= ts
->next
;
424 /* run the callback (the timer list can be modified) */
431 bool qemu_run_timers(QEMUClock
*clock
)
433 return timerlist_run_timers(clock
->main_loop_timerlist
);
436 void timerlistgroup_init(QEMUTimerListGroup
*tlg
,
437 QEMUTimerListNotifyCB
*cb
, void *opaque
)
440 for (type
= 0; type
< QEMU_CLOCK_MAX
; type
++) {
441 tlg
->tl
[type
] = timerlist_new(type
, cb
, opaque
);
445 void timerlistgroup_deinit(QEMUTimerListGroup
*tlg
)
448 for (type
= 0; type
< QEMU_CLOCK_MAX
; type
++) {
449 timerlist_free(tlg
->tl
[type
]);
453 bool timerlistgroup_run_timers(QEMUTimerListGroup
*tlg
)
456 bool progress
= false;
457 for (type
= 0; type
< QEMU_CLOCK_MAX
; type
++) {
458 progress
|= timerlist_run_timers(tlg
->tl
[type
]);
463 int64_t timerlistgroup_deadline_ns(QEMUTimerListGroup
*tlg
)
465 int64_t deadline
= -1;
467 for (type
= 0; type
< QEMU_CLOCK_MAX
; type
++) {
468 if (qemu_clock_use_for_deadline(tlg
->tl
[type
]->clock
)) {
469 deadline
= qemu_soonest_timeout(deadline
,
470 timerlist_deadline_ns(
477 int64_t qemu_get_clock_ns(QEMUClock
*clock
)
481 switch(clock
->type
) {
482 case QEMU_CLOCK_REALTIME
:
485 case QEMU_CLOCK_VIRTUAL
:
487 return cpu_get_icount();
489 return cpu_get_clock();
491 case QEMU_CLOCK_HOST
:
492 now
= get_clock_realtime();
496 notifier_list_notify(&clock
->reset_notifiers
, &now
);
502 void qemu_register_clock_reset_notifier(QEMUClock
*clock
, Notifier
*notifier
)
504 notifier_list_add(&clock
->reset_notifiers
, notifier
);
507 void qemu_unregister_clock_reset_notifier(QEMUClock
*clock
, Notifier
*notifier
)
509 notifier_remove(notifier
);
512 void init_clocks(void)
515 for (type
= 0; type
< QEMU_CLOCK_MAX
; type
++) {
516 if (!qemu_clocks
[type
]) {
517 qemu_clocks
[type
] = qemu_clock_new(type
);
518 main_loop_tlg
.tl
[type
] = qemu_clocks
[type
]->main_loop_timerlist
;
522 #ifdef CONFIG_PRCTL_PR_SET_TIMERSLACK
523 prctl(PR_SET_TIMERSLACK
, 1, 0, 0, 0);
527 uint64_t timer_expire_time_ns(QEMUTimer
*ts
)
529 return timer_pending(ts
) ? ts
->expire_time
: -1;
532 bool qemu_run_all_timers(void)
534 bool progress
= false;
537 for (type
= 0; type
< QEMU_CLOCK_MAX
; type
++) {
538 progress
|= qemu_run_timers(qemu_clock_ptr(type
));