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 _WIN32
  37 #include <mmsystem.h>
  38 #endif
  39
  40 #ifdef CONFIG_PPOLL
  41 #include <poll.h>
  42 #endif
  43
  44 #ifdef CONFIG_PRCTL_PR_SET_TIMERSLACK
  45 #include <sys/prctl.h>
  46 #endif
  47
  48 /***********************************************************/
  49 /* timers */
  50
  51 struct QEMUClock {
  52     QEMUTimerList *main_loop_timerlist;
  53     QLIST_HEAD(, QEMUTimerList) timerlists;
  54
  55     NotifierList reset_notifiers;
  56     int64_t last;
  57
  58     QEMUClockType type;
  59     bool enabled;
  60 };
  61
  62 QEMUClock *qemu_clocks[QEMU_CLOCK_MAX];
  63
  64 /* A QEMUTimerList is a list of timers attached to a clock. More
  65  * than one QEMUTimerList can be attached to each clock, for instance
  66  * used by different AioContexts / threads. Each clock also has
  67  * a list of the QEMUTimerLists associated with it, in order that
  68  * reenabling the clock can call all the notifiers.
  69  */
  70
  71 struct QEMUTimerList {
  72     QEMUClock *clock;
  73     QEMUTimer *active_timers;
  74     QLIST_ENTRY(QEMUTimerList) list;
  75 };
  76
  77 struct qemu_alarm_timer {
  78     char const *name;
  79     int (*start)(struct qemu_alarm_timer *t);
  80     void (*stop)(struct qemu_alarm_timer *t);
  81     void (*rearm)(struct qemu_alarm_timer *t, int64_t nearest_delta_ns);
  82 #if defined(__linux__)
  83     timer_t timer;
  84     int fd;
  85 #elif defined(_WIN32)
  86     HANDLE timer;
  87 #endif
  88     bool expired;
  89     bool pending;
  90 };
  91
  92 static struct qemu_alarm_timer *alarm_timer;
  93
  94 static bool timer_expired_ns(QEMUTimer *timer_head, int64_t current_time)
  95 {
  96     return timer_head && (timer_head->expire_time <= current_time);
  97 }
  98
  99 static int64_t qemu_next_alarm_deadline(void)
 100 {
 101     int64_t delta = INT64_MAX;
 102     int64_t rtdelta;
 103     int64_t hdelta;
 104
 105     if (!use_icount && vm_clock->enabled &&
 106         vm_clock->main_loop_timerlist->active_timers) {
 107         delta = vm_clock->main_loop_timerlist->active_timers->expire_time -
 108             qemu_get_clock_ns(vm_clock);
 109     }
 110     if (host_clock->enabled &&
 111         host_clock->main_loop_timerlist->active_timers) {
 112         hdelta = host_clock->main_loop_timerlist->active_timers->expire_time -
 113             qemu_get_clock_ns(host_clock);
 114         if (hdelta < delta) {
 115             delta = hdelta;
 116         }
 117     }
 118     if (rt_clock->enabled &&
 119         rt_clock->main_loop_timerlist->active_timers) {
 120         rtdelta = (rt_clock->main_loop_timerlist->active_timers->expire_time -
 121                    qemu_get_clock_ns(rt_clock));
 122         if (rtdelta < delta) {
 123             delta = rtdelta;
 124         }
 125     }
 126
 127     return delta;
 128 }
 129
 130 static void qemu_rearm_alarm_timer(struct qemu_alarm_timer *t)
 131 {
 132     int64_t nearest_delta_ns = qemu_next_alarm_deadline();
 133     if (nearest_delta_ns < INT64_MAX) {
 134         t->rearm(t, nearest_delta_ns);
 135     }
 136 }
 137
 138 /* TODO: MIN_TIMER_REARM_NS should be optimized */
 139 #define MIN_TIMER_REARM_NS 250000
 140
 141 #ifdef _WIN32
 142
 143 static int mm_start_timer(struct qemu_alarm_timer *t);
 144 static void mm_stop_timer(struct qemu_alarm_timer *t);
 145 static void mm_rearm_timer(struct qemu_alarm_timer *t, int64_t delta);
 146
 147 static int win32_start_timer(struct qemu_alarm_timer *t);
 148 static void win32_stop_timer(struct qemu_alarm_timer *t);
 149 static void win32_rearm_timer(struct qemu_alarm_timer *t, int64_t delta);
 150
 151 #else
 152
 153 static int unix_start_timer(struct qemu_alarm_timer *t);
 154 static void unix_stop_timer(struct qemu_alarm_timer *t);
 155 static void unix_rearm_timer(struct qemu_alarm_timer *t, int64_t delta);
 156
 157 #ifdef __linux__
 158
 159 static int dynticks_start_timer(struct qemu_alarm_timer *t);
 160 static void dynticks_stop_timer(struct qemu_alarm_timer *t);
 161 static void dynticks_rearm_timer(struct qemu_alarm_timer *t, int64_t delta);
 162
 163 #endif /* __linux__ */
 164
 165 #endif /* _WIN32 */
 166
 167 static struct qemu_alarm_timer alarm_timers[] = {
 168 #ifndef _WIN32
 169 #ifdef __linux__
 170     {"dynticks", dynticks_start_timer,
 171      dynticks_stop_timer, dynticks_rearm_timer},
 172 #endif
 173     {"unix", unix_start_timer, unix_stop_timer, unix_rearm_timer},
 174 #else
 175     {"mmtimer", mm_start_timer, mm_stop_timer, mm_rearm_timer},
 176     {"dynticks", win32_start_timer, win32_stop_timer, win32_rearm_timer},
 177 #endif
 178     {NULL, }
 179 };
 180
 181 static void show_available_alarms(void)
 182 {
 183     int i;
 184
 185     printf("Available alarm timers, in order of precedence:\n");
 186     for (i = 0; alarm_timers[i].name; i++)
 187         printf("%s\n", alarm_timers[i].name);
 188 }
 189
 190 void configure_alarms(char const *opt)
 191 {
 192     int i;
 193     int cur = 0;
 194     int count = ARRAY_SIZE(alarm_timers) - 1;
 195     char *arg;
 196     char *name;
 197     struct qemu_alarm_timer tmp;
 198
 199     if (is_help_option(opt)) {
 200         show_available_alarms();
 201         exit(0);
 202     }
 203
 204     arg = g_strdup(opt);
 205
 206     /* Reorder the array */
 207     name = strtok(arg, ",");
 208     while (name) {
 209         for (i = 0; i < count && alarm_timers[i].name; i++) {
 210             if (!strcmp(alarm_timers[i].name, name))
 211                 break;
 212         }
 213
 214         if (i == count) {
 215             fprintf(stderr, "Unknown clock %s\n", name);
 216             goto next;
 217         }
 218
 219         if (i < cur)
 220             /* Ignore */
 221             goto next;
 222
 223         /* Swap */
 224         tmp = alarm_timers[i];
 225         alarm_timers[i] = alarm_timers[cur];
 226         alarm_timers[cur] = tmp;
 227
 228         cur++;
 229 next:
 230         name = strtok(NULL, ",");
 231     }
 232
 233     g_free(arg);
 234
 235     if (cur) {
 236         /* Disable remaining timers */
 237         for (i = cur; i < count; i++)
 238             alarm_timers[i].name = NULL;
 239     } else {
 240         show_available_alarms();
 241         exit(1);
 242     }
 243 }
 244
 245 static QEMUTimerList *timerlist_new_from_clock(QEMUClock *clock)
 246 {
 247     QEMUTimerList *timer_list;
 248
 249     /* Assert if we do not have a clock. If you see this
 250      * assertion in means that the clocks have not been
 251      * initialised before a timerlist is needed. This
 252      * normally happens if an AioContext is used before
 253      * init_clocks() is called within main().
 254      */
 255     assert(clock);
 256
 257     timer_list = g_malloc0(sizeof(QEMUTimerList));
 258     timer_list->clock = clock;
 259     QLIST_INSERT_HEAD(&clock->timerlists, timer_list, list);
 260     return timer_list;
 261 }
 262
 263 QEMUTimerList *timerlist_new(QEMUClockType type)
 264 {
 265     return timerlist_new_from_clock(qemu_clock_ptr(type));
 266 }
 267
 268 void timerlist_free(QEMUTimerList *timer_list)
 269 {
 270     assert(!timerlist_has_timers(timer_list));
 271     if (timer_list->clock) {
 272         QLIST_REMOVE(timer_list, list);
 273         if (timer_list->clock->main_loop_timerlist == timer_list) {
 274             timer_list->clock->main_loop_timerlist = NULL;
 275         }
 276     }
 277     g_free(timer_list);
 278 }
 279
 280 static QEMUClock *qemu_clock_new(QEMUClockType type)
 281 {
 282     QEMUClock *clock;
 283
 284     clock = g_malloc0(sizeof(QEMUClock));
 285     clock->type = type;
 286     clock->enabled = true;
 287     clock->last = INT64_MIN;
 288     QLIST_INIT(&clock->timerlists);
 289     notifier_list_init(&clock->reset_notifiers);
 290     clock->main_loop_timerlist = timerlist_new_from_clock(clock);
 291     return clock;
 292 }
 293
 294 bool qemu_clock_use_for_deadline(QEMUClock *clock)
 295 {
 296     return !(use_icount && (clock->type == QEMU_CLOCK_VIRTUAL));
 297 }
 298
 299 void qemu_clock_enable(QEMUClock *clock, bool enabled)
 300 {
 301     bool old = clock->enabled;
 302     clock->enabled = enabled;
 303     if (enabled && !old) {
 304         qemu_rearm_alarm_timer(alarm_timer);
 305     }
 306 }
 307
 308 bool timerlist_has_timers(QEMUTimerList *timer_list)
 309 {
 310     return !!timer_list->active_timers;
 311 }
 312
 313 bool qemu_clock_has_timers(QEMUClock *clock)
 314 {
 315     return timerlist_has_timers(clock->main_loop_timerlist);
 316 }
 317
 318 bool timerlist_expired(QEMUTimerList *timer_list)
 319 {
 320     return (timer_list->active_timers &&
 321             timer_list->active_timers->expire_time <
 322             qemu_get_clock_ns(timer_list->clock));
 323 }
 324
 325 bool qemu_clock_expired(QEMUClock *clock)
 326 {
 327     return timerlist_expired(clock->main_loop_timerlist);
 328 }
 329
 330 int64_t timerlist_deadline(QEMUTimerList *timer_list)
 331 {
 332     /* To avoid problems with overflow limit this to 2^32.  */
 333     int64_t delta = INT32_MAX;
 334
 335     if (timer_list->clock->enabled && timer_list->active_timers) {
 336         delta = timer_list->active_timers->expire_time -
 337             qemu_get_clock_ns(timer_list->clock);
 338     }
 339     if (delta < 0) {
 340         delta = 0;
 341     }
 342     return delta;
 343 }
 344
 345 int64_t qemu_clock_deadline(QEMUClock *clock)
 346 {
 347     return timerlist_deadline(clock->main_loop_timerlist);
 348 }
 349
 350 /*
 351  * As above, but return -1 for no deadline, and do not cap to 2^32
 352  * as we know the result is always positive.
 353  */
 354
 355 int64_t timerlist_deadline_ns(QEMUTimerList *timer_list)
 356 {
 357     int64_t delta;
 358
 359     if (!timer_list->clock->enabled || !timer_list->active_timers) {
 360         return -1;
 361     }
 362
 363     delta = timer_list->active_timers->expire_time -
 364         qemu_get_clock_ns(timer_list->clock);
 365
 366     if (delta <= 0) {
 367         return 0;
 368     }
 369
 370     return delta;
 371 }
 372
 373 int64_t qemu_clock_deadline_ns(QEMUClock *clock)
 374 {
 375     return timerlist_deadline_ns(clock->main_loop_timerlist);
 376 }
 377
 378 QEMUClock *timerlist_get_clock(QEMUTimerList *timer_list)
 379 {
 380     return timer_list->clock;
 381 }
 382
 383 QEMUTimerList *qemu_clock_get_main_loop_timerlist(QEMUClock *clock)
 384 {
 385     return clock->main_loop_timerlist;
 386 }
 387
 388 /* Transition function to convert a nanosecond timeout to ms
 389  * This is used where a system does not support ppoll
 390  */
 391 int qemu_timeout_ns_to_ms(int64_t ns)
 392 {
 393     int64_t ms;
 394     if (ns < 0) {
 395         return -1;
 396     }
 397
 398     if (!ns) {
 399         return 0;
 400     }
 401
 402     /* Always round up, because it's better to wait too long than to wait too
 403      * little and effectively busy-wait
 404      */
 405     ms = (ns + SCALE_MS - 1) / SCALE_MS;
 406
 407     /* To avoid overflow problems, limit this to 2^31, i.e. approx 25 days */
 408     if (ms > (int64_t) INT32_MAX) {
 409         ms = INT32_MAX;
 410     }
 411
 412     return (int) ms;
 413 }
 414
 415
 416 /* qemu implementation of g_poll which uses a nanosecond timeout but is
 417  * otherwise identical to g_poll
 418  */
 419 int qemu_poll_ns(GPollFD *fds, guint nfds, int64_t timeout)
 420 {
 421 #ifdef CONFIG_PPOLL
 422     if (timeout < 0) {
 423         return ppoll((struct pollfd *)fds, nfds, NULL, NULL);
 424     } else {
 425         struct timespec ts;
 426         ts.tv_sec = timeout / 1000000000LL;
 427         ts.tv_nsec = timeout % 1000000000LL;
 428         return ppoll((struct pollfd *)fds, nfds, &ts, NULL);
 429     }
 430 #else
 431     return g_poll(fds, nfds, qemu_timeout_ns_to_ms(timeout));
 432 #endif
 433 }
 434
 435
 436 void timer_init(QEMUTimer *ts,
 437                 QEMUTimerList *timer_list, int scale,
 438                 QEMUTimerCB *cb, void *opaque)
 439 {
 440     ts->timer_list = timer_list;
 441     ts->cb = cb;
 442     ts->opaque = opaque;
 443     ts->scale = scale;
 444 }
 445
 446 QEMUTimer *qemu_new_timer(QEMUClock *clock, int scale,
 447                           QEMUTimerCB *cb, void *opaque)
 448 {
 449     return timer_new_tl(clock->main_loop_timerlist,
 450                      scale, cb, opaque);
 451 }
 452
 453 void qemu_free_timer(QEMUTimer *ts)
 454 {
 455     g_free(ts);
 456 }
 457
 458 /* stop a timer, but do not dealloc it */
 459 void qemu_del_timer(QEMUTimer *ts)
 460 {
 461     QEMUTimer **pt, *t;
 462
 463     /* NOTE: this code must be signal safe because
 464        timer_expired() can be called from a signal. */
 465     pt = &ts->timer_list->active_timers;
 466     for(;;) {
 467         t = *pt;
 468         if (!t)
 469             break;
 470         if (t == ts) {
 471             *pt = t->next;
 472             break;
 473         }
 474         pt = &t->next;
 475     }
 476 }
 477
 478 /* modify the current timer so that it will be fired when current_time
 479    >= expire_time. The corresponding callback will be called. */
 480 void qemu_mod_timer_ns(QEMUTimer *ts, int64_t expire_time)
 481 {
 482     QEMUTimer **pt, *t;
 483
 484     qemu_del_timer(ts);
 485
 486     /* add the timer in the sorted list */
 487     /* NOTE: this code must be signal safe because
 488        timer_expired() can be called from a signal. */
 489     pt = &ts->timer_list->active_timers;
 490     for(;;) {
 491         t = *pt;
 492         if (!timer_expired_ns(t, expire_time)) {
 493             break;
 494         }
 495         pt = &t->next;
 496     }
 497     ts->expire_time = expire_time;
 498     ts->next = *pt;
 499     *pt = ts;
 500
 501     /* Rearm if necessary  */
 502     if (pt == &ts->timer_list->active_timers) {
 503         if (!alarm_timer->pending) {
 504             qemu_rearm_alarm_timer(alarm_timer);
 505         }
 506         /* Interrupt execution to force deadline recalculation.  */
 507         qemu_clock_warp(ts->timer_list->clock);
 508         if (use_icount) {
 509             qemu_notify_event();
 510         }
 511     }
 512 }
 513
 514 void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time)
 515 {
 516     qemu_mod_timer_ns(ts, expire_time * ts->scale);
 517 }
 518
 519 bool timer_pending(QEMUTimer *ts)
 520 {
 521     QEMUTimer *t;
 522     for (t = ts->timer_list->active_timers; t != NULL; t = t->next) {
 523         if (t == ts) {
 524             return true;
 525         }
 526     }
 527     return false;
 528 }
 529
 530 bool timer_expired(QEMUTimer *timer_head, int64_t current_time)
 531 {
 532     return timer_expired_ns(timer_head, current_time * timer_head->scale);
 533 }
 534
 535 bool timerlist_run_timers(QEMUTimerList *timer_list)
 536 {
 537     QEMUTimer *ts;
 538     int64_t current_time;
 539     bool progress = false;
 540
 541     if (!timer_list->clock->enabled) {
 542         return progress;
 543     }
 544
 545     current_time = qemu_get_clock_ns(timer_list->clock);
 546     for(;;) {
 547         ts = timer_list->active_timers;
 548         if (!timer_expired_ns(ts, current_time)) {
 549             break;
 550         }
 551         /* remove timer from the list before calling the callback */
 552         timer_list->active_timers = ts->next;
 553         ts->next = NULL;
 554
 555         /* run the callback (the timer list can be modified) */
 556         ts->cb(ts->opaque);
 557         progress = true;
 558     }
 559     return progress;
 560 }
 561
 562 bool qemu_run_timers(QEMUClock *clock)
 563 {
 564     return timerlist_run_timers(clock->main_loop_timerlist);
 565 }
 566
 567 int64_t qemu_get_clock_ns(QEMUClock *clock)
 568 {
 569     int64_t now, last;
 570
 571     switch(clock->type) {
 572     case QEMU_CLOCK_REALTIME:
 573         return get_clock();
 574     default:
 575     case QEMU_CLOCK_VIRTUAL:
 576         if (use_icount) {
 577             return cpu_get_icount();
 578         } else {
 579             return cpu_get_clock();
 580         }
 581     case QEMU_CLOCK_HOST:
 582         now = get_clock_realtime();
 583         last = clock->last;
 584         clock->last = now;
 585         if (now < last) {
 586             notifier_list_notify(&clock->reset_notifiers, &now);
 587         }
 588         return now;
 589     }
 590 }
 591
 592 void qemu_register_clock_reset_notifier(QEMUClock *clock, Notifier *notifier)
 593 {
 594     notifier_list_add(&clock->reset_notifiers, notifier);
 595 }
 596
 597 void qemu_unregister_clock_reset_notifier(QEMUClock *clock, Notifier *notifier)
 598 {
 599     notifier_remove(notifier);
 600 }
 601
 602 void init_clocks(void)
 603 {
 604     QEMUClockType type;
 605     for (type = 0; type < QEMU_CLOCK_MAX; type++) {
 606         if (!qemu_clocks[type]) {
 607             qemu_clocks[type] = qemu_clock_new(type);
 608         }
 609     }
 610
 611 #ifdef CONFIG_PRCTL_PR_SET_TIMERSLACK
 612     prctl(PR_SET_TIMERSLACK, 1, 0, 0, 0);
 613 #endif
 614 }
 615
 616 uint64_t timer_expire_time_ns(QEMUTimer *ts)
 617 {
 618     return timer_pending(ts) ? ts->expire_time : -1;
 619 }
 620
 621 bool qemu_run_all_timers(void)
 622 {
 623     bool progress = false;
 624     alarm_timer->pending = false;
 625
 626     /* vm time timers */
 627     QEMUClockType type;
 628     for (type = 0; type < QEMU_CLOCK_MAX; type++) {
 629         progress |= qemu_run_timers(qemu_clock_ptr(type));
 630     }
 631
 632     /* rearm timer, if not periodic */
 633     if (alarm_timer->expired) {
 634         alarm_timer->expired = false;
 635         qemu_rearm_alarm_timer(alarm_timer);
 636     }
 637
 638     return progress;
 639 }
 640
 641 #ifdef _WIN32
 642 static void CALLBACK host_alarm_handler(PVOID lpParam, BOOLEAN unused)
 643 #else
 644 static void host_alarm_handler(int host_signum)
 645 #endif
 646 {
 647     struct qemu_alarm_timer *t = alarm_timer;
 648     if (!t)
 649         return;
 650
 651     t->expired = true;
 652     t->pending = true;
 653     qemu_notify_event();
 654 }
 655
 656 #if defined(__linux__)
 657
 658 #include "qemu/compatfd.h"
 659
 660 static int dynticks_start_timer(struct qemu_alarm_timer *t)
 661 {
 662     struct sigevent ev;
 663     timer_t host_timer;
 664     struct sigaction act;
 665
 666     sigfillset(&act.sa_mask);
 667     act.sa_flags = 0;
 668     act.sa_handler = host_alarm_handler;
 669
 670     sigaction(SIGALRM, &act, NULL);
 671
 672     /*
 673      * Initialize ev struct to 0 to avoid valgrind complaining
 674      * about uninitialized data in timer_create call
 675      */
 676     memset(&ev, 0, sizeof(ev));
 677     ev.sigev_value.sival_int = 0;
 678     ev.sigev_notify = SIGEV_SIGNAL;
 679 #ifdef CONFIG_SIGEV_THREAD_ID
 680     if (qemu_signalfd_available()) {
 681         ev.sigev_notify = SIGEV_THREAD_ID;
 682         ev._sigev_un._tid = qemu_get_thread_id();
 683     }
 684 #endif /* CONFIG_SIGEV_THREAD_ID */
 685     ev.sigev_signo = SIGALRM;
 686
 687     if (timer_create(CLOCK_REALTIME, &ev, &host_timer)) {
 688         perror("timer_create");
 689         return -1;
 690     }
 691
 692     t->timer = host_timer;
 693
 694     return 0;
 695 }
 696
 697 static void dynticks_stop_timer(struct qemu_alarm_timer *t)
 698 {
 699     timer_t host_timer = t->timer;
 700
 701     timer_delete(host_timer);
 702 }
 703
 704 static void dynticks_rearm_timer(struct qemu_alarm_timer *t,
 705                                  int64_t nearest_delta_ns)
 706 {
 707     timer_t host_timer = t->timer;
 708     struct itimerspec timeout;
 709     int64_t current_ns;
 710
 711     if (nearest_delta_ns < MIN_TIMER_REARM_NS)
 712         nearest_delta_ns = MIN_TIMER_REARM_NS;
 713
 714     /* check whether a timer is already running */
 715     if (timer_gettime(host_timer, &timeout)) {
 716         perror("gettime");
 717         fprintf(stderr, "Internal timer error: aborting\n");
 718         exit(1);
 719     }
 720     current_ns = timeout.it_value.tv_sec * 1000000000LL + timeout.it_value.tv_nsec;
 721     if (current_ns && current_ns <= nearest_delta_ns)
 722         return;
 723
 724     timeout.it_interval.tv_sec = 0;
 725     timeout.it_interval.tv_nsec = 0; /* 0 for one-shot timer */
 726     timeout.it_value.tv_sec =  nearest_delta_ns / 1000000000;
 727     timeout.it_value.tv_nsec = nearest_delta_ns % 1000000000;
 728     if (timer_settime(host_timer, 0 /* RELATIVE */, &timeout, NULL)) {
 729         perror("settime");
 730         fprintf(stderr, "Internal timer error: aborting\n");
 731         exit(1);
 732     }
 733 }
 734
 735 #endif /* defined(__linux__) */
 736
 737 #if !defined(_WIN32)
 738
 739 static int unix_start_timer(struct qemu_alarm_timer *t)
 740 {
 741     struct sigaction act;
 742
 743     /* timer signal */
 744     sigfillset(&act.sa_mask);
 745     act.sa_flags = 0;
 746     act.sa_handler = host_alarm_handler;
 747
 748     sigaction(SIGALRM, &act, NULL);
 749     return 0;
 750 }
 751
 752 static void unix_rearm_timer(struct qemu_alarm_timer *t,
 753                              int64_t nearest_delta_ns)
 754 {
 755     struct itimerval itv;
 756     int err;
 757
 758     if (nearest_delta_ns < MIN_TIMER_REARM_NS)
 759         nearest_delta_ns = MIN_TIMER_REARM_NS;
 760
 761     itv.it_interval.tv_sec = 0;
 762     itv.it_interval.tv_usec = 0; /* 0 for one-shot timer */
 763     itv.it_value.tv_sec =  nearest_delta_ns / 1000000000;
 764     itv.it_value.tv_usec = (nearest_delta_ns % 1000000000) / 1000;
 765     err = setitimer(ITIMER_REAL, &itv, NULL);
 766     if (err) {
 767         perror("setitimer");
 768         fprintf(stderr, "Internal timer error: aborting\n");
 769         exit(1);
 770     }
 771 }
 772
 773 static void unix_stop_timer(struct qemu_alarm_timer *t)
 774 {
 775     struct itimerval itv;
 776
 777     memset(&itv, 0, sizeof(itv));
 778     setitimer(ITIMER_REAL, &itv, NULL);
 779 }
 780
 781 #endif /* !defined(_WIN32) */
 782
 783
 784 #ifdef _WIN32
 785
 786 static MMRESULT mm_timer;
 787 static TIMECAPS mm_tc;
 788
 789 static void CALLBACK mm_alarm_handler(UINT uTimerID, UINT uMsg,
 790                                       DWORD_PTR dwUser, DWORD_PTR dw1,
 791                                       DWORD_PTR dw2)
 792 {
 793     struct qemu_alarm_timer *t = alarm_timer;
 794     if (!t) {
 795         return;
 796     }
 797     t->expired = true;
 798     t->pending = true;
 799     qemu_notify_event();
 800 }
 801
 802 static int mm_start_timer(struct qemu_alarm_timer *t)
 803 {
 804     timeGetDevCaps(&mm_tc, sizeof(mm_tc));
 805     return 0;
 806 }
 807
 808 static void mm_stop_timer(struct qemu_alarm_timer *t)
 809 {
 810     if (mm_timer) {
 811         timeKillEvent(mm_timer);
 812     }
 813 }
 814
 815 static void mm_rearm_timer(struct qemu_alarm_timer *t, int64_t delta)
 816 {
 817     int64_t nearest_delta_ms = delta / 1000000;
 818     if (nearest_delta_ms < mm_tc.wPeriodMin) {
 819         nearest_delta_ms = mm_tc.wPeriodMin;
 820     } else if (nearest_delta_ms > mm_tc.wPeriodMax) {
 821         nearest_delta_ms = mm_tc.wPeriodMax;
 822     }
 823
 824     if (mm_timer) {
 825         timeKillEvent(mm_timer);
 826     }
 827     mm_timer = timeSetEvent((UINT)nearest_delta_ms,
 828                             mm_tc.wPeriodMin,
 829                             mm_alarm_handler,
 830                             (DWORD_PTR)t,
 831                             TIME_ONESHOT | TIME_CALLBACK_FUNCTION);
 832
 833     if (!mm_timer) {
 834         fprintf(stderr, "Failed to re-arm win32 alarm timer\n");
 835         timeEndPeriod(mm_tc.wPeriodMin);
 836         exit(1);
 837     }
 838 }
 839
 840 static int win32_start_timer(struct qemu_alarm_timer *t)
 841 {
 842     HANDLE hTimer;
 843     BOOLEAN success;
 844
 845     /* If you call ChangeTimerQueueTimer on a one-shot timer (its period
 846        is zero) that has already expired, the timer is not updated.  Since
 847        creating a new timer is relatively expensive, set a bogus one-hour
 848        interval in the dynticks case.  */
 849     success = CreateTimerQueueTimer(&hTimer,
 850                           NULL,
 851                           host_alarm_handler,
 852                           t,
 853                           1,
 854                           3600000,
 855                           WT_EXECUTEINTIMERTHREAD);
 856
 857     if (!success) {
 858         fprintf(stderr, "Failed to initialize win32 alarm timer: %ld\n",
 859                 GetLastError());
 860         return -1;
 861     }
 862
 863     t->timer = hTimer;
 864     return 0;
 865 }
 866
 867 static void win32_stop_timer(struct qemu_alarm_timer *t)
 868 {
 869     HANDLE hTimer = t->timer;
 870
 871     if (hTimer) {
 872         DeleteTimerQueueTimer(NULL, hTimer, NULL);
 873     }
 874 }
 875
 876 static void win32_rearm_timer(struct qemu_alarm_timer *t,
 877                               int64_t nearest_delta_ns)
 878 {
 879     HANDLE hTimer = t->timer;
 880     int64_t nearest_delta_ms;
 881     BOOLEAN success;
 882
 883     nearest_delta_ms = nearest_delta_ns / 1000000;
 884     if (nearest_delta_ms < 1) {
 885         nearest_delta_ms = 1;
 886     }
 887     /* ULONG_MAX can be 32 bit */
 888     if (nearest_delta_ms > ULONG_MAX) {
 889         nearest_delta_ms = ULONG_MAX;
 890     }
 891     success = ChangeTimerQueueTimer(NULL,
 892                                     hTimer,
 893                                     (unsigned long) nearest_delta_ms,
 894                                     3600000);
 895
 896     if (!success) {
 897         fprintf(stderr, "Failed to rearm win32 alarm timer: %ld\n",
 898                 GetLastError());
 899         exit(-1);
 900     }
 901
 902 }
 903
 904 #endif /* _WIN32 */
 905
 906 static void quit_timers(void)
 907 {
 908     struct qemu_alarm_timer *t = alarm_timer;
 909     alarm_timer = NULL;
 910     t->stop(t);
 911 }
 912
 913 #ifdef CONFIG_POSIX
 914 static void reinit_timers(void)
 915 {
 916     struct qemu_alarm_timer *t = alarm_timer;
 917     t->stop(t);
 918     if (t->start(t)) {
 919         fprintf(stderr, "Internal timer error: aborting\n");
 920         exit(1);
 921     }
 922     qemu_rearm_alarm_timer(t);
 923 }
 924 #endif /* CONFIG_POSIX */
 925
 926 int init_timer_alarm(void)
 927 {
 928     struct qemu_alarm_timer *t = NULL;
 929     int i, err = -1;
 930
 931     if (alarm_timer) {
 932         return 0;
 933     }
 934
 935     for (i = 0; alarm_timers[i].name; i++) {
 936         t = &alarm_timers[i];
 937
 938         err = t->start(t);
 939         if (!err)
 940             break;
 941     }
 942
 943     if (err) {
 944         err = -ENOENT;
 945         goto fail;
 946     }
 947
 948     atexit(quit_timers);
 949 #ifdef CONFIG_POSIX
 950     pthread_atfork(NULL, NULL, reinit_timers);
 951 #endif
 952     alarm_timer = t;
 953     return 0;
 954
 955 fail:
 956     return err;
 957 }
 958