util/qemu-timer.c

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