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 "sysemu/sysemu.h"
  26 #include "monitor/monitor.h"
  27 #include "ui/console.h"
  28
  29 #include "hw/hw.h"
  30
  31 #include "qemu/timer.h"
  32 #ifdef CONFIG_POSIX
  33 #include <pthread.h>
  34 #endif
  35
  36 #ifdef CONFIG_PPOLL
  37 #include <poll.h>
  38 #endif
  39
  40 #ifdef CONFIG_PRCTL_PR_SET_TIMERSLACK
  41 #include <sys/prctl.h>
  42 #endif
  43
  44 /***********************************************************/
  45 /* timers */
  46
  47 typedef struct QEMUClock {
  48     QLIST_HEAD(, QEMUTimerList) timerlists;
  49
  50     NotifierList reset_notifiers;
  51     int64_t last;
  52
  53     QEMUClockType type;
  54     bool enabled;
  55 } QEMUClock;
  56
  57 QEMUTimerListGroup main_loop_tlg;
  58 QEMUClock qemu_clocks[QEMU_CLOCK_MAX];
  59
  60 /* A QEMUTimerList is a list of timers attached to a clock. More
  61  * than one QEMUTimerList can be attached to each clock, for instance
  62  * used by different AioContexts / threads. Each clock also has
  63  * a list of the QEMUTimerLists associated with it, in order that
  64  * reenabling the clock can call all the notifiers.
  65  */
  66
  67 struct QEMUTimerList {
  68     QEMUClock *clock;
  69     QemuMutex active_timers_lock;
  70     QEMUTimer *active_timers;
  71     QLIST_ENTRY(QEMUTimerList) list;
  72     QEMUTimerListNotifyCB *notify_cb;
  73     void *notify_opaque;
  74 };
  75
  76 /**
  77  * qemu_clock_ptr:
  78  * @type: type of clock
  79  *
  80  * Translate a clock type into a pointer to QEMUClock object.
  81  *
  82  * Returns: a pointer to the QEMUClock object
  83  */
  84 static inline QEMUClock *qemu_clock_ptr(QEMUClockType type)
  85 {
  86     return &qemu_clocks[type];
  87 }
  88
  89 static bool timer_expired_ns(QEMUTimer *timer_head, int64_t current_time)
  90 {
  91     return timer_head && (timer_head->expire_time <= current_time);
  92 }
  93
  94 QEMUTimerList *timerlist_new(QEMUClockType type,
  95                              QEMUTimerListNotifyCB *cb,
  96                              void *opaque)
  97 {
  98     QEMUTimerList *timer_list;
  99     QEMUClock *clock = qemu_clock_ptr(type);
 100
 101     timer_list = g_malloc0(sizeof(QEMUTimerList));
 102     timer_list->clock = clock;
 103     timer_list->notify_cb = cb;
 104     timer_list->notify_opaque = opaque;
 105     qemu_mutex_init(&timer_list->active_timers_lock);
 106     QLIST_INSERT_HEAD(&clock->timerlists, timer_list, list);
 107     return timer_list;
 108 }
 109
 110 void timerlist_free(QEMUTimerList *timer_list)
 111 {
 112     assert(!timerlist_has_timers(timer_list));
 113     if (timer_list->clock) {
 114         QLIST_REMOVE(timer_list, list);
 115     }
 116     qemu_mutex_destroy(&timer_list->active_timers_lock);
 117     g_free(timer_list);
 118 }
 119
 120 static void qemu_clock_init(QEMUClockType type)
 121 {
 122     QEMUClock *clock = qemu_clock_ptr(type);
 123
 124     clock->type = type;
 125     clock->enabled = true;
 126     clock->last = INT64_MIN;
 127     QLIST_INIT(&clock->timerlists);
 128     notifier_list_init(&clock->reset_notifiers);
 129     main_loop_tlg.tl[type] = timerlist_new(type, NULL, NULL);
 130 }
 131
 132 bool qemu_clock_use_for_deadline(QEMUClockType type)
 133 {
 134     return !(use_icount && (type == QEMU_CLOCK_VIRTUAL));
 135 }
 136
 137 void qemu_clock_notify(QEMUClockType type)
 138 {
 139     QEMUTimerList *timer_list;
 140     QEMUClock *clock = qemu_clock_ptr(type);
 141     QLIST_FOREACH(timer_list, &clock->timerlists, list) {
 142         timerlist_notify(timer_list);
 143     }
 144 }
 145
 146 void qemu_clock_enable(QEMUClockType type, bool enabled)
 147 {
 148     QEMUClock *clock = qemu_clock_ptr(type);
 149     bool old = clock->enabled;
 150     clock->enabled = enabled;
 151     if (enabled && !old) {
 152         qemu_clock_notify(type);
 153     }
 154 }
 155
 156 bool timerlist_has_timers(QEMUTimerList *timer_list)
 157 {
 158     return !!timer_list->active_timers;
 159 }
 160
 161 bool qemu_clock_has_timers(QEMUClockType type)
 162 {
 163     return timerlist_has_timers(
 164         main_loop_tlg.tl[type]);
 165 }
 166
 167 bool timerlist_expired(QEMUTimerList *timer_list)
 168 {
 169     int64_t expire_time;
 170
 171     qemu_mutex_lock(&timer_list->active_timers_lock);
 172     if (!timer_list->active_timers) {
 173         qemu_mutex_unlock(&timer_list->active_timers_lock);
 174         return false;
 175     }
 176     expire_time = timer_list->active_timers->expire_time;
 177     qemu_mutex_unlock(&timer_list->active_timers_lock);
 178
 179     return expire_time < qemu_clock_get_ns(timer_list->clock->type);
 180 }
 181
 182 bool qemu_clock_expired(QEMUClockType type)
 183 {
 184     return timerlist_expired(
 185         main_loop_tlg.tl[type]);
 186 }
 187
 188 /*
 189  * As above, but return -1 for no deadline, and do not cap to 2^32
 190  * as we know the result is always positive.
 191  */
 192
 193 int64_t timerlist_deadline_ns(QEMUTimerList *timer_list)
 194 {
 195     int64_t delta;
 196     int64_t expire_time;
 197
 198     if (!timer_list->clock->enabled) {
 199         return -1;
 200     }
 201
 202     /* The active timers list may be modified before the caller uses our return
 203      * value but ->notify_cb() is called when the deadline changes.  Therefore
 204      * the caller should notice the change and there is no race condition.
 205      */
 206     qemu_mutex_lock(&timer_list->active_timers_lock);
 207     if (!timer_list->active_timers) {
 208         qemu_mutex_unlock(&timer_list->active_timers_lock);
 209         return -1;
 210     }
 211     expire_time = timer_list->active_timers->expire_time;
 212     qemu_mutex_unlock(&timer_list->active_timers_lock);
 213
 214     delta = expire_time - qemu_clock_get_ns(timer_list->clock->type);
 215
 216     if (delta <= 0) {
 217         return 0;
 218     }
 219
 220     return delta;
 221 }
 222
 223 /* Calculate the soonest deadline across all timerlists attached
 224  * to the clock. This is used for the icount timeout so we
 225  * ignore whether or not the clock should be used in deadline
 226  * calculations.
 227  */
 228 int64_t qemu_clock_deadline_ns_all(QEMUClockType type)
 229 {
 230     int64_t deadline = -1;
 231     QEMUTimerList *timer_list;
 232     QEMUClock *clock = qemu_clock_ptr(type);
 233     QLIST_FOREACH(timer_list, &clock->timerlists, list) {
 234         deadline = qemu_soonest_timeout(deadline,
 235                                         timerlist_deadline_ns(timer_list));
 236     }
 237     return deadline;
 238 }
 239
 240 QEMUClockType timerlist_get_clock(QEMUTimerList *timer_list)
 241 {
 242     return timer_list->clock->type;
 243 }
 244
 245 QEMUTimerList *qemu_clock_get_main_loop_timerlist(QEMUClockType type)
 246 {
 247     return main_loop_tlg.tl[type];
 248 }
 249
 250 void timerlist_notify(QEMUTimerList *timer_list)
 251 {
 252     if (timer_list->notify_cb) {
 253         timer_list->notify_cb(timer_list->notify_opaque);
 254     } else {
 255         qemu_notify_event();
 256     }
 257 }
 258
 259 /* Transition function to convert a nanosecond timeout to ms
 260  * This is used where a system does not support ppoll
 261  */
 262 int qemu_timeout_ns_to_ms(int64_t ns)
 263 {
 264     int64_t ms;
 265     if (ns < 0) {
 266         return -1;
 267     }
 268
 269     if (!ns) {
 270         return 0;
 271     }
 272
 273     /* Always round up, because it's better to wait too long than to wait too
 274      * little and effectively busy-wait
 275      */
 276     ms = (ns + SCALE_MS - 1) / SCALE_MS;
 277
 278     /* To avoid overflow problems, limit this to 2^31, i.e. approx 25 days */
 279     if (ms > (int64_t) INT32_MAX) {
 280         ms = INT32_MAX;
 281     }
 282
 283     return (int) ms;
 284 }
 285
 286
 287 /* qemu implementation of g_poll which uses a nanosecond timeout but is
 288  * otherwise identical to g_poll
 289  */
 290 int qemu_poll_ns(GPollFD *fds, guint nfds, int64_t timeout)
 291 {
 292 #ifdef CONFIG_PPOLL
 293     if (timeout < 0) {
 294         return ppoll((struct pollfd *)fds, nfds, NULL, NULL);
 295     } else {
 296         struct timespec ts;
 297         ts.tv_sec = timeout / 1000000000LL;
 298         ts.tv_nsec = timeout % 1000000000LL;
 299         return ppoll((struct pollfd *)fds, nfds, &ts, NULL);
 300     }
 301 #else
 302     return g_poll(fds, nfds, qemu_timeout_ns_to_ms(timeout));
 303 #endif
 304 }
 305
 306
 307 void timer_init(QEMUTimer *ts,
 308                 QEMUTimerList *timer_list, int scale,
 309                 QEMUTimerCB *cb, void *opaque)
 310 {
 311     ts->timer_list = timer_list;
 312     ts->cb = cb;
 313     ts->opaque = opaque;
 314     ts->scale = scale;
 315 }
 316
 317 void timer_free(QEMUTimer *ts)
 318 {
 319     g_free(ts);
 320 }
 321
 322 static void timer_del_locked(QEMUTimerList *timer_list, QEMUTimer *ts)
 323 {
 324     QEMUTimer **pt, *t;
 325
 326     pt = &timer_list->active_timers;
 327     for(;;) {
 328         t = *pt;
 329         if (!t)
 330             break;
 331         if (t == ts) {
 332             *pt = t->next;
 333             break;
 334         }
 335         pt = &t->next;
 336     }
 337 }
 338
 339 /* stop a timer, but do not dealloc it */
 340 void timer_del(QEMUTimer *ts)
 341 {
 342     QEMUTimerList *timer_list = ts->timer_list;
 343
 344     qemu_mutex_lock(&timer_list->active_timers_lock);
 345     timer_del_locked(timer_list, ts);
 346     qemu_mutex_unlock(&timer_list->active_timers_lock);
 347 }
 348
 349 /* modify the current timer so that it will be fired when current_time
 350    >= expire_time. The corresponding callback will be called. */
 351 void timer_mod_ns(QEMUTimer *ts, int64_t expire_time)
 352 {
 353     QEMUTimerList *timer_list = ts->timer_list;
 354     QEMUTimer **pt, *t;
 355
 356     qemu_mutex_lock(&timer_list->active_timers_lock);
 357     timer_del_locked(timer_list, ts);
 358
 359     /* add the timer in the sorted list */
 360     pt = &timer_list->active_timers;
 361     for(;;) {
 362         t = *pt;
 363         if (!timer_expired_ns(t, expire_time)) {
 364             break;
 365         }
 366         pt = &t->next;
 367     }
 368     ts->expire_time = expire_time;
 369     ts->next = *pt;
 370     *pt = ts;
 371     qemu_mutex_unlock(&timer_list->active_timers_lock);
 372
 373     /* Rearm if necessary  */
 374     if (pt == &timer_list->active_timers) {
 375         /* Interrupt execution to force deadline recalculation.  */
 376         qemu_clock_warp(timer_list->clock->type);
 377         timerlist_notify(timer_list);
 378     }
 379 }
 380
 381 void timer_mod(QEMUTimer *ts, int64_t expire_time)
 382 {
 383     timer_mod_ns(ts, expire_time * ts->scale);
 384 }
 385
 386 bool timer_pending(QEMUTimer *ts)
 387 {
 388     QEMUTimerList *timer_list = ts->timer_list;
 389     QEMUTimer *t;
 390     bool found = false;
 391
 392     qemu_mutex_lock(&timer_list->active_timers_lock);
 393     for (t = timer_list->active_timers; t != NULL; t = t->next) {
 394         if (t == ts) {
 395             found = true;
 396             break;
 397         }
 398     }
 399     qemu_mutex_unlock(&timer_list->active_timers_lock);
 400     return found;
 401 }
 402
 403 bool timer_expired(QEMUTimer *timer_head, int64_t current_time)
 404 {
 405     return timer_expired_ns(timer_head, current_time * timer_head->scale);
 406 }
 407
 408 bool timerlist_run_timers(QEMUTimerList *timer_list)
 409 {
 410     QEMUTimer *ts;
 411     int64_t current_time;
 412     bool progress = false;
 413     QEMUTimerCB *cb;
 414     void *opaque;
 415
 416     if (!timer_list->clock->enabled) {
 417         return progress;
 418     }
 419
 420     current_time = qemu_clock_get_ns(timer_list->clock->type);
 421     for(;;) {
 422         qemu_mutex_lock(&timer_list->active_timers_lock);
 423         ts = timer_list->active_timers;
 424         if (!timer_expired_ns(ts, current_time)) {
 425             qemu_mutex_unlock(&timer_list->active_timers_lock);
 426             break;
 427         }
 428
 429         /* remove timer from the list before calling the callback */
 430         timer_list->active_timers = ts->next;
 431         ts->next = NULL;
 432         cb = ts->cb;
 433         opaque = ts->opaque;
 434         qemu_mutex_unlock(&timer_list->active_timers_lock);
 435
 436         /* run the callback (the timer list can be modified) */
 437         cb(opaque);
 438         progress = true;
 439     }
 440     return progress;
 441 }
 442
 443 bool qemu_clock_run_timers(QEMUClockType type)
 444 {
 445     return timerlist_run_timers(main_loop_tlg.tl[type]);
 446 }
 447
 448 void timerlistgroup_init(QEMUTimerListGroup *tlg,
 449                          QEMUTimerListNotifyCB *cb, void *opaque)
 450 {
 451     QEMUClockType type;
 452     for (type = 0; type < QEMU_CLOCK_MAX; type++) {
 453         tlg->tl[type] = timerlist_new(type, cb, opaque);
 454     }
 455 }
 456
 457 void timerlistgroup_deinit(QEMUTimerListGroup *tlg)
 458 {
 459     QEMUClockType type;
 460     for (type = 0; type < QEMU_CLOCK_MAX; type++) {
 461         timerlist_free(tlg->tl[type]);
 462     }
 463 }
 464
 465 bool timerlistgroup_run_timers(QEMUTimerListGroup *tlg)
 466 {
 467     QEMUClockType type;
 468     bool progress = false;
 469     for (type = 0; type < QEMU_CLOCK_MAX; type++) {
 470         progress |= timerlist_run_timers(tlg->tl[type]);
 471     }
 472     return progress;
 473 }
 474
 475 int64_t timerlistgroup_deadline_ns(QEMUTimerListGroup *tlg)
 476 {
 477     int64_t deadline = -1;
 478     QEMUClockType type;
 479     for (type = 0; type < QEMU_CLOCK_MAX; type++) {
 480         if (qemu_clock_use_for_deadline(tlg->tl[type]->clock->type)) {
 481             deadline = qemu_soonest_timeout(deadline,
 482                                             timerlist_deadline_ns(
 483                                                 tlg->tl[type]));
 484         }
 485     }
 486     return deadline;
 487 }
 488
 489 int64_t qemu_clock_get_ns(QEMUClockType type)
 490 {
 491     int64_t now, last;
 492     QEMUClock *clock = qemu_clock_ptr(type);
 493
 494     switch (type) {
 495     case QEMU_CLOCK_REALTIME:
 496         return get_clock();
 497     default:
 498     case QEMU_CLOCK_VIRTUAL:
 499         if (use_icount) {
 500             return cpu_get_icount();
 501         } else {
 502             return cpu_get_clock();
 503         }
 504     case QEMU_CLOCK_HOST:
 505         now = get_clock_realtime();
 506         last = clock->last;
 507         clock->last = now;
 508         if (now < last) {
 509             notifier_list_notify(&clock->reset_notifiers, &now);
 510         }
 511         return now;
 512     }
 513 }
 514
 515 void qemu_clock_register_reset_notifier(QEMUClockType type,
 516                                         Notifier *notifier)
 517 {
 518     QEMUClock *clock = qemu_clock_ptr(type);
 519     notifier_list_add(&clock->reset_notifiers, notifier);
 520 }
 521
 522 void qemu_clock_unregister_reset_notifier(QEMUClockType type,
 523                                           Notifier *notifier)
 524 {
 525     notifier_remove(notifier);
 526 }
 527
 528 void init_clocks(void)
 529 {
 530     QEMUClockType type;
 531     for (type = 0; type < QEMU_CLOCK_MAX; type++) {
 532         qemu_clock_init(type);
 533     }
 534
 535 #ifdef CONFIG_PRCTL_PR_SET_TIMERSLACK
 536     prctl(PR_SET_TIMERSLACK, 1, 0, 0, 0);
 537 #endif
 538 }
 539
 540 uint64_t timer_expire_time_ns(QEMUTimer *ts)
 541 {
 542     return timer_pending(ts) ? ts->expire_time : -1;
 543 }
 544
 545 bool qemu_clock_run_all_timers(void)
 546 {
 547     bool progress = false;
 548     QEMUClockType type;
 549
 550     for (type = 0; type < QEMU_CLOCK_MAX; type++) {
 551         progress |= qemu_clock_run_timers(type);
 552     }
 553
 554     return progress;
 555 }