1 /*
2 * QEMU System Emulator
3 *
4 * Copyright (c) 2003-2008 Fabrice Bellard
5 *
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:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
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.
23 */
24
25 #include "qemu/osdep.h"
26 #include "qemu/main-loop.h"
27 #include "qemu/timer.h"
28 #include "qemu/lockable.h"
29 #include "sysemu/cpu-timers.h"
30 #include "sysemu/replay.h"
31 #include "sysemu/cpus.h"
32
33 #ifdef CONFIG_POSIX
34 #include <pthread.h>
35 #endif
36
37 #ifdef CONFIG_PPOLL
38 #include <poll.h>
39 #endif
40
41 #ifdef CONFIG_PRCTL_PR_SET_TIMERSLACK
42 #include <sys/prctl.h>
43 #endif
44
45 /***********************************************************/
46 /* timers */
47
48 typedef struct QEMUClock {
49 /* We rely on BQL to protect the timerlists */
50 QLIST_HEAD(, QEMUTimerList) timerlists;
51
52 QEMUClockType type;
53 bool enabled;
54 } QEMUClock;
55
56 QEMUTimerListGroup main_loop_tlg;
57 static QEMUClock qemu_clocks[QEMU_CLOCK_MAX];
58
59 /* A QEMUTimerList is a list of timers attached to a clock. More
60 * than one QEMUTimerList can be attached to each clock, for instance
61 * used by different AioContexts / threads. Each clock also has
62 * a list of the QEMUTimerLists associated with it, in order that
63 * reenabling the clock can call all the notifiers.
64 */
65
66 struct QEMUTimerList {
67 QEMUClock *clock;
68 QemuMutex active_timers_lock;
69 QEMUTimer *active_timers;
70 QLIST_ENTRY(QEMUTimerList) list;
71 QEMUTimerListNotifyCB *notify_cb;
72 void *notify_opaque;
73
74 /* lightweight method to mark the end of timerlist's running */
75 QemuEvent timers_done_ev;
76 };
77
78 /**
79 * qemu_clock_ptr:
80 * @type: type of clock
81 *
82 * Translate a clock type into a pointer to QEMUClock object.
83 *
84 * Returns: a pointer to the QEMUClock object
85 */
qemu_clock_ptr(QEMUClockType type)86 static inline QEMUClock *qemu_clock_ptr(QEMUClockType type)
87 {
88 return &qemu_clocks[type];
89 }
90
timer_expired_ns(QEMUTimer * timer_head,int64_t current_time)91 static bool timer_expired_ns(QEMUTimer *timer_head, int64_t current_time)
92 {
93 return timer_head && (timer_head->expire_time <= current_time);
94 }
95
timerlist_new(QEMUClockType type,QEMUTimerListNotifyCB * cb,void * opaque)96 QEMUTimerList *timerlist_new(QEMUClockType type,
97 QEMUTimerListNotifyCB *cb,
98 void *opaque)
99 {
100 QEMUTimerList *timer_list;
101 QEMUClock *clock = qemu_clock_ptr(type);
102
103 timer_list = g_new0(QEMUTimerList, 1);
104 qemu_event_init(&timer_list->timers_done_ev, true);
105 timer_list->clock = clock;
106 timer_list->notify_cb = cb;
107 timer_list->notify_opaque = opaque;
108 qemu_mutex_init(&timer_list->active_timers_lock);
109 QLIST_INSERT_HEAD(&clock->timerlists, timer_list, list);
110 return timer_list;
111 }
112
timerlist_free(QEMUTimerList * timer_list)113 void timerlist_free(QEMUTimerList *timer_list)
114 {
115 assert(!timerlist_has_timers(timer_list));
116 if (timer_list->clock) {
117 QLIST_REMOVE(timer_list, list);
118 }
119 qemu_mutex_destroy(&timer_list->active_timers_lock);
120 g_free(timer_list);
121 }
122
qemu_clock_init(QEMUClockType type,QEMUTimerListNotifyCB * notify_cb)123 static void qemu_clock_init(QEMUClockType type, QEMUTimerListNotifyCB *notify_cb)
124 {
125 QEMUClock *clock = qemu_clock_ptr(type);
126
127 /* Assert that the clock of type TYPE has not been initialized yet. */
128 assert(main_loop_tlg.tl[type] == NULL);
129
130 clock->type = type;
131 clock->enabled = (type == QEMU_CLOCK_VIRTUAL ? false : true);
132 QLIST_INIT(&clock->timerlists);
133 main_loop_tlg.tl[type] = timerlist_new(type, notify_cb, NULL);
134 }
135
qemu_clock_use_for_deadline(QEMUClockType type)136 bool qemu_clock_use_for_deadline(QEMUClockType type)
137 {
138 return !(icount_enabled() && (type == QEMU_CLOCK_VIRTUAL));
139 }
140
qemu_clock_notify(QEMUClockType type)141 void qemu_clock_notify(QEMUClockType type)
142 {
143 QEMUTimerList *timer_list;
144 QEMUClock *clock = qemu_clock_ptr(type);
145 QLIST_FOREACH(timer_list, &clock->timerlists, list) {
146 timerlist_notify(timer_list);
147 }
148 }
149
150 /* Disabling the clock will wait for related timerlists to stop
151 * executing qemu_run_timers. Thus, this functions should not
152 * be used from the callback of a timer that is based on @clock.
153 * Doing so would cause a deadlock.
154 *
155 * Caller should hold BQL.
156 */
qemu_clock_enable(QEMUClockType type,bool enabled)157 void qemu_clock_enable(QEMUClockType type, bool enabled)
158 {
159 QEMUClock *clock = qemu_clock_ptr(type);
160 QEMUTimerList *tl;
161 bool old = clock->enabled;
162 clock->enabled = enabled;
163 if (enabled && !old) {
164 qemu_clock_notify(type);
165 } else if (!enabled && old) {
166 QLIST_FOREACH(tl, &clock->timerlists, list) {
167 qemu_event_wait(&tl->timers_done_ev);
168 }
169 }
170 }
171
timerlist_has_timers(QEMUTimerList * timer_list)172 bool timerlist_has_timers(QEMUTimerList *timer_list)
173 {
174 return !!qatomic_read(&timer_list->active_timers);
175 }
176
qemu_clock_has_timers(QEMUClockType type)177 bool qemu_clock_has_timers(QEMUClockType type)
178 {
179 return timerlist_has_timers(
180 main_loop_tlg.tl[type]);
181 }
182
timerlist_expired(QEMUTimerList * timer_list)183 bool timerlist_expired(QEMUTimerList *timer_list)
184 {
185 int64_t expire_time = 0;
186
187 if (!qatomic_read(&timer_list->active_timers)) {
188 return false;
189 }
190
191 WITH_QEMU_LOCK_GUARD(&timer_list->active_timers_lock) {
192 if (!timer_list->active_timers) {
193 return false;
194 }
195 expire_time = timer_list->active_timers->expire_time;
196 }
197
198 return expire_time <= qemu_clock_get_ns(timer_list->clock->type);
199 }
200
qemu_clock_expired(QEMUClockType type)201 bool qemu_clock_expired(QEMUClockType type)
202 {
203 return timerlist_expired(
204 main_loop_tlg.tl[type]);
205 }
206
207 /*
208 * As above, but return -1 for no deadline, and do not cap to 2^32
209 * as we know the result is always positive.
210 */
211
timerlist_deadline_ns(QEMUTimerList * timer_list)212 int64_t timerlist_deadline_ns(QEMUTimerList *timer_list)
213 {
214 int64_t delta;
215 int64_t expire_time = 0;
216
217 if (!qatomic_read(&timer_list->active_timers)) {
218 return -1;
219 }
220
221 if (!timer_list->clock->enabled) {
222 return -1;
223 }
224
225 /* The active timers list may be modified before the caller uses our return
226 * value but ->notify_cb() is called when the deadline changes. Therefore
227 * the caller should notice the change and there is no race condition.
228 */
229 WITH_QEMU_LOCK_GUARD(&timer_list->active_timers_lock) {
230 if (!timer_list->active_timers) {
231 return -1;
232 }
233 expire_time = timer_list->active_timers->expire_time;
234 }
235
236 delta = expire_time - qemu_clock_get_ns(timer_list->clock->type);
237
238 if (delta <= 0) {
239 return 0;
240 }
241
242 return delta;
243 }
244
245 /* Calculate the soonest deadline across all timerlists attached
246 * to the clock. This is used for the icount timeout so we
247 * ignore whether or not the clock should be used in deadline
248 * calculations.
249 */
qemu_clock_deadline_ns_all(QEMUClockType type,int attr_mask)250 int64_t qemu_clock_deadline_ns_all(QEMUClockType type, int attr_mask)
251 {
252 int64_t deadline = -1;
253 int64_t delta;
254 int64_t expire_time;
255 QEMUTimer *ts;
256 QEMUTimerList *timer_list;
257 QEMUClock *clock = qemu_clock_ptr(type);
258
259 if (!clock->enabled) {
260 return -1;
261 }
262
263 QLIST_FOREACH(timer_list, &clock->timerlists, list) {
264 if (!qatomic_read(&timer_list->active_timers)) {
265 continue;
266 }
267 qemu_mutex_lock(&timer_list->active_timers_lock);
268 ts = timer_list->active_timers;
269 /* Skip all external timers */
270 while (ts && (ts->attributes & ~attr_mask)) {
271 ts = ts->next;
272 }
273 if (!ts) {
274 qemu_mutex_unlock(&timer_list->active_timers_lock);
275 continue;
276 }
277 expire_time = ts->expire_time;
278 qemu_mutex_unlock(&timer_list->active_timers_lock);
279
280 delta = expire_time - qemu_clock_get_ns(type);
281 if (delta <= 0) {
282 delta = 0;
283 }
284 deadline = qemu_soonest_timeout(deadline, delta);
285 }
286 return deadline;
287 }
288
timerlist_notify(QEMUTimerList * timer_list)289 void timerlist_notify(QEMUTimerList *timer_list)
290 {
291 if (timer_list->notify_cb) {
292 timer_list->notify_cb(timer_list->notify_opaque, timer_list->clock->type);
293 } else {
294 qemu_notify_event();
295 }
296 }
297
298 /* Transition function to convert a nanosecond timeout to ms
299 * This is used where a system does not support ppoll
300 */
qemu_timeout_ns_to_ms(int64_t ns)301 int qemu_timeout_ns_to_ms(int64_t ns)
302 {
303 int64_t ms;
304 if (ns < 0) {
305 return -1;
306 }
307
308 if (!ns) {
309 return 0;
310 }
311
312 /* Always round up, because it's better to wait too long than to wait too
313 * little and effectively busy-wait
314 */
315 ms = DIV_ROUND_UP(ns, SCALE_MS);
316
317 /* To avoid overflow problems, limit this to 2^31, i.e. approx 25 days */
318 return MIN(ms, INT32_MAX);
319 }
320
321
322 /* qemu implementation of g_poll which uses a nanosecond timeout but is
323 * otherwise identical to g_poll
324 */
qemu_poll_ns(GPollFD * fds,guint nfds,int64_t timeout)325 int qemu_poll_ns(GPollFD *fds, guint nfds, int64_t timeout)
326 {
327 #ifdef CONFIG_PPOLL
328 if (timeout < 0) {
329 return ppoll((struct pollfd *)fds, nfds, NULL, NULL);
330 } else {
331 struct timespec ts;
332 int64_t tvsec = timeout / 1000000000LL;
333 /* Avoid possibly overflowing and specifying a negative number of
334 * seconds, which would turn a very long timeout into a busy-wait.
335 */
336 if (tvsec > (int64_t)INT32_MAX) {
337 tvsec = INT32_MAX;
338 }
339 ts.tv_sec = tvsec;
340 ts.tv_nsec = timeout % 1000000000LL;
341 return ppoll((struct pollfd *)fds, nfds, &ts, NULL);
342 }
343 #else
344 return g_poll(fds, nfds, qemu_timeout_ns_to_ms(timeout));
345 #endif
346 }
347
348
timer_init_full(QEMUTimer * ts,QEMUTimerListGroup * timer_list_group,QEMUClockType type,int scale,int attributes,QEMUTimerCB * cb,void * opaque)349 void timer_init_full(QEMUTimer *ts,
350 QEMUTimerListGroup *timer_list_group, QEMUClockType type,
351 int scale, int attributes,
352 QEMUTimerCB *cb, void *opaque)
353 {
354 if (!timer_list_group) {
355 timer_list_group = &main_loop_tlg;
356 }
357 ts->timer_list = timer_list_group->tl[type];
358 ts->cb = cb;
359 ts->opaque = opaque;
360 ts->scale = scale;
361 ts->attributes = attributes;
362 ts->expire_time = -1;
363 }
364
timer_deinit(QEMUTimer * ts)365 void timer_deinit(QEMUTimer *ts)
366 {
367 assert(ts->expire_time == -1);
368 ts->timer_list = NULL;
369 }
370
timer_del_locked(QEMUTimerList * timer_list,QEMUTimer * ts)371 static void timer_del_locked(QEMUTimerList *timer_list, QEMUTimer *ts)
372 {
373 QEMUTimer **pt, *t;
374
375 ts->expire_time = -1;
376 pt = &timer_list->active_timers;
377 for(;;) {
378 t = *pt;
379 if (!t)
380 break;
381 if (t == ts) {
382 qatomic_set(pt, t->next);
383 break;
384 }
385 pt = &t->next;
386 }
387 }
388
timer_mod_ns_locked(QEMUTimerList * timer_list,QEMUTimer * ts,int64_t expire_time)389 static bool timer_mod_ns_locked(QEMUTimerList *timer_list,
390 QEMUTimer *ts, int64_t expire_time)
391 {
392 QEMUTimer **pt, *t;
393
394 /* add the timer in the sorted list */
395 pt = &timer_list->active_timers;
396 for (;;) {
397 t = *pt;
398 if (!timer_expired_ns(t, expire_time)) {
399 break;
400 }
401 pt = &t->next;
402 }
403 ts->expire_time = MAX(expire_time, 0);
404 ts->next = *pt;
405 qatomic_set(pt, ts);
406
407 return pt == &timer_list->active_timers;
408 }
409
timerlist_rearm(QEMUTimerList * timer_list)410 static void timerlist_rearm(QEMUTimerList *timer_list)
411 {
412 timerlist_notify(timer_list);
413 }
414
415 /* stop a timer, but do not dealloc it */
timer_del(QEMUTimer * ts)416 void timer_del(QEMUTimer *ts)
417 {
418 QEMUTimerList *timer_list = ts->timer_list;
419
420 if (timer_list) {
421 qemu_mutex_lock(&timer_list->active_timers_lock);
422 timer_del_locked(timer_list, ts);
423 qemu_mutex_unlock(&timer_list->active_timers_lock);
424 }
425 }
426
427 /* modify the current timer so that it will be fired when current_time
428 >= expire_time. The corresponding callback will be called. */
timer_mod_ns(QEMUTimer * ts,int64_t expire_time)429 void timer_mod_ns(QEMUTimer *ts, int64_t expire_time)
430 {
431 QEMUTimerList *timer_list = ts->timer_list;
432 bool rearm;
433
434 qemu_mutex_lock(&timer_list->active_timers_lock);
435 timer_del_locked(timer_list, ts);
436 rearm = timer_mod_ns_locked(timer_list, ts, expire_time);
437 qemu_mutex_unlock(&timer_list->active_timers_lock);
438
439 if (rearm) {
440 timerlist_rearm(timer_list);
441 }
442 }
443
444 /* modify the current timer so that it will be fired when current_time
445 >= expire_time or the current deadline, whichever comes earlier.
446 The corresponding callback will be called. */
timer_mod_anticipate_ns(QEMUTimer * ts,int64_t expire_time)447 void timer_mod_anticipate_ns(QEMUTimer *ts, int64_t expire_time)
448 {
449 QEMUTimerList *timer_list = ts->timer_list;
450 bool rearm = false;
451
452 WITH_QEMU_LOCK_GUARD(&timer_list->active_timers_lock) {
453 if (ts->expire_time == -1 || ts->expire_time > expire_time) {
454 if (ts->expire_time != -1) {
455 timer_del_locked(timer_list, ts);
456 }
457 rearm = timer_mod_ns_locked(timer_list, ts, expire_time);
458 } else {
459 rearm = false;
460 }
461 }
462 if (rearm) {
463 timerlist_rearm(timer_list);
464 }
465 }
466
timer_mod(QEMUTimer * ts,int64_t expire_time)467 void timer_mod(QEMUTimer *ts, int64_t expire_time)
468 {
469 timer_mod_ns(ts, expire_time * ts->scale);
470 }
471
timer_mod_anticipate(QEMUTimer * ts,int64_t expire_time)472 void timer_mod_anticipate(QEMUTimer *ts, int64_t expire_time)
473 {
474 timer_mod_anticipate_ns(ts, expire_time * ts->scale);
475 }
476
timer_pending(QEMUTimer * ts)477 bool timer_pending(QEMUTimer *ts)
478 {
479 return ts->expire_time >= 0;
480 }
481
timer_expired(QEMUTimer * timer_head,int64_t current_time)482 bool timer_expired(QEMUTimer *timer_head, int64_t current_time)
483 {
484 return timer_expired_ns(timer_head, current_time * timer_head->scale);
485 }
486
timerlist_run_timers(QEMUTimerList * timer_list)487 bool timerlist_run_timers(QEMUTimerList *timer_list)
488 {
489 QEMUTimer *ts;
490 int64_t current_time;
491 bool progress = false;
492 QEMUTimerCB *cb;
493 void *opaque;
494
495 if (!qatomic_read(&timer_list->active_timers)) {
496 return false;
497 }
498
499 qemu_event_reset(&timer_list->timers_done_ev);
500 if (!timer_list->clock->enabled) {
501 goto out;
502 }
503
504 switch (timer_list->clock->type) {
505 case QEMU_CLOCK_REALTIME:
506 break;
507 default:
508 case QEMU_CLOCK_VIRTUAL:
509 break;
510 case QEMU_CLOCK_HOST:
511 if (!replay_checkpoint(CHECKPOINT_CLOCK_HOST)) {
512 goto out;
513 }
514 break;
515 case QEMU_CLOCK_VIRTUAL_RT:
516 if (!replay_checkpoint(CHECKPOINT_CLOCK_VIRTUAL_RT)) {
517 goto out;
518 }
519 break;
520 }
521
522 /*
523 * Extract expired timers from active timers list and process them.
524 *
525 * In rr mode we need "filtered" checkpointing for virtual clock. The
526 * checkpoint must be recorded/replayed before processing any non-EXTERNAL timer,
527 * and that must only be done once since the clock value stays the same. Because
528 * non-EXTERNAL timers may appear in the timers list while it being processed,
529 * the checkpoint can be issued at a time until no timers are left and we are
530 * done".
531 */
532 current_time = qemu_clock_get_ns(timer_list->clock->type);
533 qemu_mutex_lock(&timer_list->active_timers_lock);
534 while ((ts = timer_list->active_timers)) {
535 if (!timer_expired_ns(ts, current_time)) {
536 /* No expired timers left. The checkpoint can be skipped
537 * if no timers fired or they were all external.
538 */
539 break;
540 }
541 /* Checkpoint for virtual clock is redundant in cases where
542 * it's being triggered with only non-EXTERNAL timers, because
543 * these timers don't change guest state directly.
544 */
545 if (replay_mode != REPLAY_MODE_NONE
546 && timer_list->clock->type == QEMU_CLOCK_VIRTUAL
547 && !(ts->attributes & QEMU_TIMER_ATTR_EXTERNAL)
548 && !replay_checkpoint(CHECKPOINT_CLOCK_VIRTUAL)) {
549 qemu_mutex_unlock(&timer_list->active_timers_lock);
550 goto out;
551 }
552
553 /* remove timer from the list before calling the callback */
554 timer_list->active_timers = ts->next;
555 ts->next = NULL;
556 ts->expire_time = -1;
557 cb = ts->cb;
558 opaque = ts->opaque;
559
560 /* run the callback (the timer list can be modified) */
561 qemu_mutex_unlock(&timer_list->active_timers_lock);
562 cb(opaque);
563 qemu_mutex_lock(&timer_list->active_timers_lock);
564
565 progress = true;
566 }
567 qemu_mutex_unlock(&timer_list->active_timers_lock);
568
569 out:
570 qemu_event_set(&timer_list->timers_done_ev);
571 return progress;
572 }
573
qemu_clock_run_timers(QEMUClockType type)574 bool qemu_clock_run_timers(QEMUClockType type)
575 {
576 return timerlist_run_timers(main_loop_tlg.tl[type]);
577 }
578
timerlistgroup_init(QEMUTimerListGroup * tlg,QEMUTimerListNotifyCB * cb,void * opaque)579 void timerlistgroup_init(QEMUTimerListGroup *tlg,
580 QEMUTimerListNotifyCB *cb, void *opaque)
581 {
582 QEMUClockType type;
583 for (type = 0; type < QEMU_CLOCK_MAX; type++) {
584 tlg->tl[type] = timerlist_new(type, cb, opaque);
585 }
586 }
587
timerlistgroup_deinit(QEMUTimerListGroup * tlg)588 void timerlistgroup_deinit(QEMUTimerListGroup *tlg)
589 {
590 QEMUClockType type;
591 for (type = 0; type < QEMU_CLOCK_MAX; type++) {
592 timerlist_free(tlg->tl[type]);
593 }
594 }
595
timerlistgroup_run_timers(QEMUTimerListGroup * tlg)596 bool timerlistgroup_run_timers(QEMUTimerListGroup *tlg)
597 {
598 QEMUClockType type;
599 bool progress = false;
600 for (type = 0; type < QEMU_CLOCK_MAX; type++) {
601 progress |= timerlist_run_timers(tlg->tl[type]);
602 }
603 return progress;
604 }
605
timerlistgroup_deadline_ns(QEMUTimerListGroup * tlg)606 int64_t timerlistgroup_deadline_ns(QEMUTimerListGroup *tlg)
607 {
608 int64_t deadline = -1;
609 QEMUClockType type;
610 for (type = 0; type < QEMU_CLOCK_MAX; type++) {
611 if (qemu_clock_use_for_deadline(type)) {
612 deadline = qemu_soonest_timeout(deadline,
613 timerlist_deadline_ns(tlg->tl[type]));
614 }
615 }
616 return deadline;
617 }
618
qemu_clock_get_ns(QEMUClockType type)619 int64_t qemu_clock_get_ns(QEMUClockType type)
620 {
621 switch (type) {
622 case QEMU_CLOCK_REALTIME:
623 return get_clock();
624 default:
625 case QEMU_CLOCK_VIRTUAL:
626 return cpus_get_virtual_clock();
627 case QEMU_CLOCK_HOST:
628 return REPLAY_CLOCK(REPLAY_CLOCK_HOST, get_clock_realtime());
629 case QEMU_CLOCK_VIRTUAL_RT:
630 return REPLAY_CLOCK(REPLAY_CLOCK_VIRTUAL_RT, cpu_get_clock());
631 }
632 }
633
qemu_virtual_clock_set_ns(int64_t time)634 static void qemu_virtual_clock_set_ns(int64_t time)
635 {
636 return cpus_set_virtual_clock(time);
637 }
638
init_clocks(QEMUTimerListNotifyCB * notify_cb)639 void init_clocks(QEMUTimerListNotifyCB *notify_cb)
640 {
641 QEMUClockType type;
642 for (type = 0; type < QEMU_CLOCK_MAX; type++) {
643 qemu_clock_init(type, notify_cb);
644 }
645
646 #ifdef CONFIG_PRCTL_PR_SET_TIMERSLACK
647 prctl(PR_SET_TIMERSLACK, 1, 0, 0, 0);
648 #endif
649 }
650
timer_expire_time_ns(QEMUTimer * ts)651 uint64_t timer_expire_time_ns(QEMUTimer *ts)
652 {
653 return timer_pending(ts) ? ts->expire_time : -1;
654 }
655
qemu_clock_run_all_timers(void)656 bool qemu_clock_run_all_timers(void)
657 {
658 bool progress = false;
659 QEMUClockType type;
660
661 for (type = 0; type < QEMU_CLOCK_MAX; type++) {
662 if (qemu_clock_use_for_deadline(type)) {
663 progress |= qemu_clock_run_timers(type);
664 }
665 }
666
667 return progress;
668 }
669
qemu_clock_advance_virtual_time(int64_t dest)670 int64_t qemu_clock_advance_virtual_time(int64_t dest)
671 {
672 int64_t clock = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
673 AioContext *aio_context;
674 int64_t deadline;
675
676 aio_context = qemu_get_aio_context();
677
678 deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL,
679 QEMU_TIMER_ATTR_ALL);
680 /*
681 * A deadline of < 0 indicates this timer is not enabled, so we
682 * won't get far trying to run it forward.
683 */
684 while (deadline >= 0 && clock < dest) {
685 int64_t warp = qemu_soonest_timeout(dest - clock, deadline);
686
687 qemu_virtual_clock_set_ns(qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + warp);
688
689 qemu_clock_run_timers(QEMU_CLOCK_VIRTUAL);
690 timerlist_run_timers(aio_context->tlg.tl[QEMU_CLOCK_VIRTUAL]);
691 clock = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
692
693 deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL,
694 QEMU_TIMER_ATTR_ALL);
695 }
696 qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
697
698 return clock;
699 }
700