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