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.h"
  26 #include "net.h"
  27 #include "monitor.h"
  28 #include "console.h"
  29
  30 #include "hw/hw.h"
  31
  32 #include "qemu-timer.h"
  33
  34 #ifdef __FreeBSD__
  35 #include <sys/param.h>
  36 #endif
  37
  38 #ifdef _WIN32
  39 #include <mmsystem.h>
  40 #endif
  41
  42 /***********************************************************/
  43 /* timers */
  44
  45 #define QEMU_CLOCK_REALTIME 0
  46 #define QEMU_CLOCK_VIRTUAL  1
  47 #define QEMU_CLOCK_HOST     2
  48
  49 struct QEMUClock {
  50     int type;
  51     int enabled;
  52
  53     QEMUTimer *active_timers;
  54
  55     NotifierList reset_notifiers;
  56     int64_t last;
  57 };
  58
  59 struct QEMUTimer {
  60     QEMUClock *clock;
  61     int64_t expire_time;        /* in nanoseconds */
  62     int scale;
  63     QEMUTimerCB *cb;
  64     void *opaque;
  65     struct QEMUTimer *next;
  66 };
  67
  68 struct qemu_alarm_timer {
  69     char const *name;
  70     int (*start)(struct qemu_alarm_timer *t);
  71     void (*stop)(struct qemu_alarm_timer *t);
  72     void (*rearm)(struct qemu_alarm_timer *t, int64_t nearest_delta_ns);
  73 #if defined(__linux__)
  74     int fd;
  75     timer_t timer;
  76 #elif defined(_WIN32)
  77     HANDLE timer;
  78 #endif
  79     char expired;
  80     char pending;
  81 };
  82
  83 static struct qemu_alarm_timer *alarm_timer;
  84
  85 static bool qemu_timer_expired_ns(QEMUTimer *timer_head, int64_t current_time)
  86 {
  87     return timer_head && (timer_head->expire_time <= current_time);
  88 }
  89
  90 int qemu_alarm_pending(void)
  91 {
  92     return alarm_timer->pending;
  93 }
  94
  95 static inline int alarm_has_dynticks(struct qemu_alarm_timer *t)
  96 {
  97     return !!t->rearm;
  98 }
  99
 100 static int64_t qemu_next_alarm_deadline(void)
 101 {
 102     int64_t delta = INT64_MAX;
 103     int64_t rtdelta;
 104
 105     if (!use_icount && vm_clock->enabled && vm_clock->active_timers) {
 106         delta = vm_clock->active_timers->expire_time -
 107                      qemu_get_clock_ns(vm_clock);
 108     }
 109     if (host_clock->enabled && host_clock->active_timers) {
 110         int64_t hdelta = host_clock->active_timers->expire_time -
 111                  qemu_get_clock_ns(host_clock);
 112         if (hdelta < delta) {
 113             delta = hdelta;
 114         }
 115     }
 116     if (rt_clock->enabled && rt_clock->active_timers) {
 117         rtdelta = (rt_clock->active_timers->expire_time -
 118                  qemu_get_clock_ns(rt_clock));
 119         if (rtdelta < delta) {
 120             delta = rtdelta;
 121         }
 122     }
 123
 124     return delta;
 125 }
 126
 127 static void qemu_rearm_alarm_timer(struct qemu_alarm_timer *t)
 128 {
 129     int64_t nearest_delta_ns;
 130     assert(alarm_has_dynticks(t));
 131     if (!rt_clock->active_timers &&
 132         !vm_clock->active_timers &&
 133         !host_clock->active_timers) {
 134         return;
 135     }
 136     nearest_delta_ns = qemu_next_alarm_deadline();
 137     t->rearm(t, nearest_delta_ns);
 138 }
 139
 140 /* TODO: MIN_TIMER_REARM_NS should be optimized */
 141 #define MIN_TIMER_REARM_NS 250000
 142
 143 #ifdef _WIN32
 144
 145 static int mm_start_timer(struct qemu_alarm_timer *t);
 146 static void mm_stop_timer(struct qemu_alarm_timer *t);
 147 static void mm_rearm_timer(struct qemu_alarm_timer *t, int64_t delta);
 148
 149 static int win32_start_timer(struct qemu_alarm_timer *t);
 150 static void win32_stop_timer(struct qemu_alarm_timer *t);
 151 static void win32_rearm_timer(struct qemu_alarm_timer *t, int64_t delta);
 152
 153 #else
 154
 155 static int unix_start_timer(struct qemu_alarm_timer *t);
 156 static void unix_stop_timer(struct qemu_alarm_timer *t);
 157 static void unix_rearm_timer(struct qemu_alarm_timer *t, int64_t delta);
 158
 159 #ifdef __linux__
 160
 161 static int dynticks_start_timer(struct qemu_alarm_timer *t);
 162 static void dynticks_stop_timer(struct qemu_alarm_timer *t);
 163 static void dynticks_rearm_timer(struct qemu_alarm_timer *t, int64_t delta);
 164
 165 #endif /* __linux__ */
 166
 167 #endif /* _WIN32 */
 168
 169 static struct qemu_alarm_timer alarm_timers[] = {
 170 #ifndef _WIN32
 171 #ifdef __linux__
 172     {"dynticks", dynticks_start_timer,
 173      dynticks_stop_timer, dynticks_rearm_timer},
 174 #endif
 175     {"unix", unix_start_timer, unix_stop_timer, unix_rearm_timer},
 176 #else
 177     {"mmtimer", mm_start_timer, mm_stop_timer, mm_rearm_timer},
 178     {"dynticks", win32_start_timer, win32_stop_timer, win32_rearm_timer},
 179 #endif
 180     {NULL, }
 181 };
 182
 183 static void show_available_alarms(void)
 184 {
 185     int i;
 186
 187     printf("Available alarm timers, in order of precedence:\n");
 188     for (i = 0; alarm_timers[i].name; i++)
 189         printf("%s\n", alarm_timers[i].name);
 190 }
 191
 192 void configure_alarms(char const *opt)
 193 {
 194     int i;
 195     int cur = 0;
 196     int count = ARRAY_SIZE(alarm_timers) - 1;
 197     char *arg;
 198     char *name;
 199     struct qemu_alarm_timer tmp;
 200
 201     if (!strcmp(opt, "?")) {
 202         show_available_alarms();
 203         exit(0);
 204     }
 205
 206     arg = g_strdup(opt);
 207
 208     /* Reorder the array */
 209     name = strtok(arg, ",");
 210     while (name) {
 211         for (i = 0; i < count && alarm_timers[i].name; i++) {
 212             if (!strcmp(alarm_timers[i].name, name))
 213                 break;
 214         }
 215
 216         if (i == count) {
 217             fprintf(stderr, "Unknown clock %s\n", name);
 218             goto next;
 219         }
 220
 221         if (i < cur)
 222             /* Ignore */
 223             goto next;
 224
 225         /* Swap */
 226         tmp = alarm_timers[i];
 227         alarm_timers[i] = alarm_timers[cur];
 228         alarm_timers[cur] = tmp;
 229
 230         cur++;
 231 next:
 232         name = strtok(NULL, ",");
 233     }
 234
 235     g_free(arg);
 236
 237     if (cur) {
 238         /* Disable remaining timers */
 239         for (i = cur; i < count; i++)
 240             alarm_timers[i].name = NULL;
 241     } else {
 242         show_available_alarms();
 243         exit(1);
 244     }
 245 }
 246
 247 QEMUClock *rt_clock;
 248 QEMUClock *vm_clock;
 249 QEMUClock *host_clock;
 250
 251 static QEMUClock *qemu_new_clock(int type)
 252 {
 253     QEMUClock *clock;
 254
 255     clock = g_malloc0(sizeof(QEMUClock));
 256     clock->type = type;
 257     clock->enabled = 1;
 258     clock->last = INT64_MIN;
 259     notifier_list_init(&clock->reset_notifiers);
 260     return clock;
 261 }
 262
 263 void qemu_clock_enable(QEMUClock *clock, int enabled)
 264 {
 265     bool old = clock->enabled;
 266     clock->enabled = enabled;
 267     if (enabled && !old) {
 268         qemu_rearm_alarm_timer(alarm_timer);
 269     }
 270 }
 271
 272 int64_t qemu_clock_has_timers(QEMUClock *clock)
 273 {
 274     return !!clock->active_timers;
 275 }
 276
 277 int64_t qemu_clock_expired(QEMUClock *clock)
 278 {
 279     return (clock->active_timers &&
 280             clock->active_timers->expire_time < qemu_get_clock_ns(clock));
 281 }
 282
 283 int64_t qemu_clock_deadline(QEMUClock *clock)
 284 {
 285     /* To avoid problems with overflow limit this to 2^32.  */
 286     int64_t delta = INT32_MAX;
 287
 288     if (clock->active_timers) {
 289         delta = clock->active_timers->expire_time - qemu_get_clock_ns(clock);
 290     }
 291     if (delta < 0) {
 292         delta = 0;
 293     }
 294     return delta;
 295 }
 296
 297 QEMUTimer *qemu_new_timer(QEMUClock *clock, int scale,
 298                           QEMUTimerCB *cb, void *opaque)
 299 {
 300     QEMUTimer *ts;
 301
 302     ts = g_malloc0(sizeof(QEMUTimer));
 303     ts->clock = clock;
 304     ts->cb = cb;
 305     ts->opaque = opaque;
 306     ts->scale = scale;
 307     return ts;
 308 }
 309
 310 void qemu_free_timer(QEMUTimer *ts)
 311 {
 312     g_free(ts);
 313 }
 314
 315 /* stop a timer, but do not dealloc it */
 316 void qemu_del_timer(QEMUTimer *ts)
 317 {
 318     QEMUTimer **pt, *t;
 319
 320     /* NOTE: this code must be signal safe because
 321        qemu_timer_expired() can be called from a signal. */
 322     pt = &ts->clock->active_timers;
 323     for(;;) {
 324         t = *pt;
 325         if (!t)
 326             break;
 327         if (t == ts) {
 328             *pt = t->next;
 329             break;
 330         }
 331         pt = &t->next;
 332     }
 333 }
 334
 335 /* modify the current timer so that it will be fired when current_time
 336    >= expire_time. The corresponding callback will be called. */
 337 void qemu_mod_timer_ns(QEMUTimer *ts, int64_t expire_time)
 338 {
 339     QEMUTimer **pt, *t;
 340
 341     qemu_del_timer(ts);
 342
 343     /* add the timer in the sorted list */
 344     /* NOTE: this code must be signal safe because
 345        qemu_timer_expired() can be called from a signal. */
 346     pt = &ts->clock->active_timers;
 347     for(;;) {
 348         t = *pt;
 349         if (!qemu_timer_expired_ns(t, expire_time)) {
 350             break;
 351         }
 352         pt = &t->next;
 353     }
 354     ts->expire_time = expire_time;
 355     ts->next = *pt;
 356     *pt = ts;
 357
 358     /* Rearm if necessary  */
 359     if (pt == &ts->clock->active_timers) {
 360         if (!alarm_timer->pending) {
 361             qemu_rearm_alarm_timer(alarm_timer);
 362         }
 363         /* Interrupt execution to force deadline recalculation.  */
 364         qemu_clock_warp(ts->clock);
 365         if (use_icount) {
 366             qemu_notify_event();
 367         }
 368     }
 369 }
 370
 371 void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time)
 372 {
 373     qemu_mod_timer_ns(ts, expire_time * ts->scale);
 374 }
 375
 376 int qemu_timer_pending(QEMUTimer *ts)
 377 {
 378     QEMUTimer *t;
 379     for (t = ts->clock->active_timers; t != NULL; t = t->next) {
 380         if (t == ts)
 381             return 1;
 382     }
 383     return 0;
 384 }
 385
 386 int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time)
 387 {
 388     return qemu_timer_expired_ns(timer_head, current_time * timer_head->scale);
 389 }
 390
 391 void qemu_run_timers(QEMUClock *clock)
 392 {
 393     QEMUTimer **ptimer_head, *ts;
 394     int64_t current_time;
 395
 396     if (!clock->enabled)
 397         return;
 398
 399     current_time = qemu_get_clock_ns(clock);
 400     ptimer_head = &clock->active_timers;
 401     for(;;) {
 402         ts = *ptimer_head;
 403         if (!qemu_timer_expired_ns(ts, current_time)) {
 404             break;
 405         }
 406         /* remove timer from the list before calling the callback */
 407         *ptimer_head = ts->next;
 408         ts->next = NULL;
 409
 410         /* run the callback (the timer list can be modified) */
 411         ts->cb(ts->opaque);
 412     }
 413 }
 414
 415 int64_t qemu_get_clock_ns(QEMUClock *clock)
 416 {
 417     int64_t now, last;
 418
 419     switch(clock->type) {
 420     case QEMU_CLOCK_REALTIME:
 421         return get_clock();
 422     default:
 423     case QEMU_CLOCK_VIRTUAL:
 424         if (use_icount) {
 425             return cpu_get_icount();
 426         } else {
 427             return cpu_get_clock();
 428         }
 429     case QEMU_CLOCK_HOST:
 430         now = get_clock_realtime();
 431         last = clock->last;
 432         clock->last = now;
 433         if (now < last) {
 434             notifier_list_notify(&clock->reset_notifiers, &now);
 435         }
 436         return now;
 437     }
 438 }
 439
 440 void qemu_register_clock_reset_notifier(QEMUClock *clock, Notifier *notifier)
 441 {
 442     notifier_list_add(&clock->reset_notifiers, notifier);
 443 }
 444
 445 void qemu_unregister_clock_reset_notifier(QEMUClock *clock, Notifier *notifier)
 446 {
 447     notifier_remove(notifier);
 448 }
 449
 450 void init_clocks(void)
 451 {
 452     rt_clock = qemu_new_clock(QEMU_CLOCK_REALTIME);
 453     vm_clock = qemu_new_clock(QEMU_CLOCK_VIRTUAL);
 454     host_clock = qemu_new_clock(QEMU_CLOCK_HOST);
 455 }
 456
 457 uint64_t qemu_timer_expire_time_ns(QEMUTimer *ts)
 458 {
 459     return qemu_timer_pending(ts) ? ts->expire_time : -1;
 460 }
 461
 462 void qemu_run_all_timers(void)
 463 {
 464     alarm_timer->pending = 0;
 465
 466     /* vm time timers */
 467     qemu_run_timers(vm_clock);
 468     qemu_run_timers(rt_clock);
 469     qemu_run_timers(host_clock);
 470
 471     /* rearm timer, if not periodic */
 472     if (alarm_timer->expired) {
 473         alarm_timer->expired = 0;
 474         qemu_rearm_alarm_timer(alarm_timer);
 475     }
 476 }
 477
 478 #ifdef _WIN32
 479 static void CALLBACK host_alarm_handler(PVOID lpParam, BOOLEAN unused)
 480 #else
 481 static void host_alarm_handler(int host_signum)
 482 #endif
 483 {
 484     struct qemu_alarm_timer *t = alarm_timer;
 485     if (!t)
 486         return;
 487
 488     if (alarm_has_dynticks(t) ||
 489         qemu_next_alarm_deadline () <= 0) {
 490         t->expired = alarm_has_dynticks(t);
 491         t->pending = 1;
 492         qemu_notify_event();
 493     }
 494 }
 495
 496 #if defined(__linux__)
 497
 498 #include "compatfd.h"
 499
 500 static int dynticks_start_timer(struct qemu_alarm_timer *t)
 501 {
 502     struct sigevent ev;
 503     timer_t host_timer;
 504     struct sigaction act;
 505
 506     sigfillset(&act.sa_mask);
 507     act.sa_flags = 0;
 508     act.sa_handler = host_alarm_handler;
 509
 510     sigaction(SIGALRM, &act, NULL);
 511
 512     /*
 513      * Initialize ev struct to 0 to avoid valgrind complaining
 514      * about uninitialized data in timer_create call
 515      */
 516     memset(&ev, 0, sizeof(ev));
 517     ev.sigev_value.sival_int = 0;
 518     ev.sigev_notify = SIGEV_SIGNAL;
 519 #ifdef SIGEV_THREAD_ID
 520     if (qemu_signalfd_available()) {
 521         ev.sigev_notify = SIGEV_THREAD_ID;
 522         ev._sigev_un._tid = qemu_get_thread_id();
 523     }
 524 #endif /* SIGEV_THREAD_ID */
 525     ev.sigev_signo = SIGALRM;
 526
 527     if (timer_create(CLOCK_REALTIME, &ev, &host_timer)) {
 528         perror("timer_create");
 529
 530         /* disable dynticks */
 531         fprintf(stderr, "Dynamic Ticks disabled\n");
 532
 533         return -1;
 534     }
 535
 536     t->timer = host_timer;
 537
 538     return 0;
 539 }
 540
 541 static void dynticks_stop_timer(struct qemu_alarm_timer *t)
 542 {
 543     timer_t host_timer = t->timer;
 544
 545     timer_delete(host_timer);
 546 }
 547
 548 static void dynticks_rearm_timer(struct qemu_alarm_timer *t,
 549                                  int64_t nearest_delta_ns)
 550 {
 551     timer_t host_timer = t->timer;
 552     struct itimerspec timeout;
 553     int64_t current_ns;
 554
 555     if (nearest_delta_ns < MIN_TIMER_REARM_NS)
 556         nearest_delta_ns = MIN_TIMER_REARM_NS;
 557
 558     /* check whether a timer is already running */
 559     if (timer_gettime(host_timer, &timeout)) {
 560         perror("gettime");
 561         fprintf(stderr, "Internal timer error: aborting\n");
 562         exit(1);
 563     }
 564     current_ns = timeout.it_value.tv_sec * 1000000000LL + timeout.it_value.tv_nsec;
 565     if (current_ns && current_ns <= nearest_delta_ns)
 566         return;
 567
 568     timeout.it_interval.tv_sec = 0;
 569     timeout.it_interval.tv_nsec = 0; /* 0 for one-shot timer */
 570     timeout.it_value.tv_sec =  nearest_delta_ns / 1000000000;
 571     timeout.it_value.tv_nsec = nearest_delta_ns % 1000000000;
 572     if (timer_settime(host_timer, 0 /* RELATIVE */, &timeout, NULL)) {
 573         perror("settime");
 574         fprintf(stderr, "Internal timer error: aborting\n");
 575         exit(1);
 576     }
 577 }
 578
 579 #endif /* defined(__linux__) */
 580
 581 #if !defined(_WIN32)
 582
 583 static int unix_start_timer(struct qemu_alarm_timer *t)
 584 {
 585     struct sigaction act;
 586
 587     /* timer signal */
 588     sigfillset(&act.sa_mask);
 589     act.sa_flags = 0;
 590     act.sa_handler = host_alarm_handler;
 591
 592     sigaction(SIGALRM, &act, NULL);
 593     return 0;
 594 }
 595
 596 static void unix_rearm_timer(struct qemu_alarm_timer *t,
 597                              int64_t nearest_delta_ns)
 598 {
 599     struct itimerval itv;
 600     int err;
 601
 602     if (nearest_delta_ns < MIN_TIMER_REARM_NS)
 603         nearest_delta_ns = MIN_TIMER_REARM_NS;
 604
 605     itv.it_interval.tv_sec = 0;
 606     itv.it_interval.tv_usec = 0; /* 0 for one-shot timer */
 607     itv.it_value.tv_sec =  nearest_delta_ns / 1000000000;
 608     itv.it_value.tv_usec = (nearest_delta_ns % 1000000000) / 1000;
 609     err = setitimer(ITIMER_REAL, &itv, NULL);
 610     if (err) {
 611         perror("setitimer");
 612         fprintf(stderr, "Internal timer error: aborting\n");
 613         exit(1);
 614     }
 615 }
 616
 617 static void unix_stop_timer(struct qemu_alarm_timer *t)
 618 {
 619     struct itimerval itv;
 620
 621     memset(&itv, 0, sizeof(itv));
 622     setitimer(ITIMER_REAL, &itv, NULL);
 623 }
 624
 625 #endif /* !defined(_WIN32) */
 626
 627
 628 #ifdef _WIN32
 629
 630 static MMRESULT mm_timer;
 631 static unsigned mm_period;
 632
 633 static void CALLBACK mm_alarm_handler(UINT uTimerID, UINT uMsg,
 634                                       DWORD_PTR dwUser, DWORD_PTR dw1,
 635                                       DWORD_PTR dw2)
 636 {
 637     struct qemu_alarm_timer *t = alarm_timer;
 638     if (!t) {
 639         return;
 640     }
 641     if (alarm_has_dynticks(t) || qemu_next_alarm_deadline() <= 0) {
 642         t->expired = alarm_has_dynticks(t);
 643         t->pending = 1;
 644         qemu_notify_event();
 645     }
 646 }
 647
 648 static int mm_start_timer(struct qemu_alarm_timer *t)
 649 {
 650     TIMECAPS tc;
 651     UINT flags;
 652
 653     memset(&tc, 0, sizeof(tc));
 654     timeGetDevCaps(&tc, sizeof(tc));
 655
 656     mm_period = tc.wPeriodMin;
 657     timeBeginPeriod(mm_period);
 658
 659     flags = TIME_CALLBACK_FUNCTION;
 660     if (alarm_has_dynticks(t)) {
 661         flags |= TIME_ONESHOT;
 662     } else {
 663         flags |= TIME_PERIODIC;
 664     }
 665
 666     mm_timer = timeSetEvent(1,                  /* interval (ms) */
 667                             mm_period,          /* resolution */
 668                             mm_alarm_handler,   /* function */
 669                             (DWORD_PTR)t,       /* parameter */
 670                             flags);
 671
 672     if (!mm_timer) {
 673         fprintf(stderr, "Failed to initialize win32 alarm timer: %ld\n",
 674                 GetLastError());
 675         timeEndPeriod(mm_period);
 676         return -1;
 677     }
 678
 679     return 0;
 680 }
 681
 682 static void mm_stop_timer(struct qemu_alarm_timer *t)
 683 {
 684     timeKillEvent(mm_timer);
 685     timeEndPeriod(mm_period);
 686 }
 687
 688 static void mm_rearm_timer(struct qemu_alarm_timer *t, int64_t delta)
 689 {
 690     int64_t nearest_delta_ms = delta / 1000000;
 691     if (nearest_delta_ms < 1) {
 692         nearest_delta_ms = 1;
 693     }
 694     /* UINT_MAX can be 32 bit */
 695     if (nearest_delta_ms > UINT_MAX) {
 696         nearest_delta_ms = UINT_MAX;
 697     }
 698
 699     timeKillEvent(mm_timer);
 700     mm_timer = timeSetEvent((unsigned int) nearest_delta_ms,
 701                             mm_period,
 702                             mm_alarm_handler,
 703                             (DWORD_PTR)t,
 704                             TIME_ONESHOT | TIME_CALLBACK_FUNCTION);
 705
 706     if (!mm_timer) {
 707         fprintf(stderr, "Failed to re-arm win32 alarm timer %ld\n",
 708                 GetLastError());
 709
 710         timeEndPeriod(mm_period);
 711         exit(1);
 712     }
 713 }
 714
 715 static int win32_start_timer(struct qemu_alarm_timer *t)
 716 {
 717     HANDLE hTimer;
 718     BOOLEAN success;
 719
 720     /* If you call ChangeTimerQueueTimer on a one-shot timer (its period
 721        is zero) that has already expired, the timer is not updated.  Since
 722        creating a new timer is relatively expensive, set a bogus one-hour
 723        interval in the dynticks case.  */
 724     success = CreateTimerQueueTimer(&hTimer,
 725                           NULL,
 726                           host_alarm_handler,
 727                           t,
 728                           1,
 729                           alarm_has_dynticks(t) ? 3600000 : 1,
 730                           WT_EXECUTEINTIMERTHREAD);
 731
 732     if (!success) {
 733         fprintf(stderr, "Failed to initialize win32 alarm timer: %ld\n",
 734                 GetLastError());
 735         return -1;
 736     }
 737
 738     t->timer = hTimer;
 739     return 0;
 740 }
 741
 742 static void win32_stop_timer(struct qemu_alarm_timer *t)
 743 {
 744     HANDLE hTimer = t->timer;
 745
 746     if (hTimer) {
 747         DeleteTimerQueueTimer(NULL, hTimer, NULL);
 748     }
 749 }
 750
 751 static void win32_rearm_timer(struct qemu_alarm_timer *t,
 752                               int64_t nearest_delta_ns)
 753 {
 754     HANDLE hTimer = t->timer;
 755     int64_t nearest_delta_ms;
 756     BOOLEAN success;
 757
 758     nearest_delta_ms = nearest_delta_ns / 1000000;
 759     if (nearest_delta_ms < 1) {
 760         nearest_delta_ms = 1;
 761     }
 762     /* ULONG_MAX can be 32 bit */
 763     if (nearest_delta_ms > ULONG_MAX) {
 764         nearest_delta_ms = ULONG_MAX;
 765     }
 766     success = ChangeTimerQueueTimer(NULL,
 767                                     hTimer,
 768                                     (unsigned long) nearest_delta_ms,
 769                                     3600000);
 770
 771     if (!success) {
 772         fprintf(stderr, "Failed to rearm win32 alarm timer: %ld\n",
 773                 GetLastError());
 774         exit(-1);
 775     }
 776
 777 }
 778
 779 #endif /* _WIN32 */
 780
 781 static void quit_timers(void)
 782 {
 783     struct qemu_alarm_timer *t = alarm_timer;
 784     alarm_timer = NULL;
 785     t->stop(t);
 786 }
 787
 788 int init_timer_alarm(void)
 789 {
 790     struct qemu_alarm_timer *t = NULL;
 791     int i, err = -1;
 792
 793     for (i = 0; alarm_timers[i].name; i++) {
 794         t = &alarm_timers[i];
 795
 796         err = t->start(t);
 797         if (!err)
 798             break;
 799     }
 800
 801     if (err) {
 802         err = -ENOENT;
 803         goto fail;
 804     }
 805
 806     /* first event is at time 0 */
 807     atexit(quit_timers);
 808     t->pending = 1;
 809     alarm_timer = t;
 810
 811     return 0;
 812
 813 fail:
 814     return err;
 815 }
 816