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 <unistd.h>
  33 #include <fcntl.h>
  34 #include <time.h>
  35 #include <errno.h>
  36 #include <sys/time.h>
  37 #include <signal.h>
  38 #ifdef __FreeBSD__
  39 #include <sys/param.h>
  40 #endif
  41
  42 #ifdef _WIN32
  43 #include <windows.h>
  44 #include <mmsystem.h>
  45 #endif
  46
  47 #include "qemu-timer.h"
  48
  49 /* Conversion factor from emulated instructions to virtual clock ticks.  */
  50 int icount_time_shift;
  51 /* Arbitrarily pick 1MIPS as the minimum allowable speed.  */
  52 #define MAX_ICOUNT_SHIFT 10
  53 /* Compensate for varying guest execution speed.  */
  54 int64_t qemu_icount_bias;
  55 static QEMUTimer *icount_rt_timer;
  56 static QEMUTimer *icount_vm_timer;
  57
  58 /***********************************************************/
  59 /* guest cycle counter */
  60
  61 typedef struct TimersState {
  62     int64_t cpu_ticks_prev;
  63     int64_t cpu_ticks_offset;
  64     int64_t cpu_clock_offset;
  65     int32_t cpu_ticks_enabled;
  66     int64_t dummy;
  67 } TimersState;
  68
  69 TimersState timers_state;
  70
  71 /* return the host CPU cycle counter and handle stop/restart */
  72 int64_t cpu_get_ticks(void)
  73 {
  74     if (use_icount) {
  75         return cpu_get_icount();
  76     }
  77     if (!timers_state.cpu_ticks_enabled) {
  78         return timers_state.cpu_ticks_offset;
  79     } else {
  80         int64_t ticks;
  81         ticks = cpu_get_real_ticks();
  82         if (timers_state.cpu_ticks_prev > ticks) {
  83             /* Note: non increasing ticks may happen if the host uses
  84                software suspend */
  85             timers_state.cpu_ticks_offset += timers_state.cpu_ticks_prev - ticks;
  86         }
  87         timers_state.cpu_ticks_prev = ticks;
  88         return ticks + timers_state.cpu_ticks_offset;
  89     }
  90 }
  91
  92 /* return the host CPU monotonic timer and handle stop/restart */
  93 static int64_t cpu_get_clock(void)
  94 {
  95     int64_t ti;
  96     if (!timers_state.cpu_ticks_enabled) {
  97         return timers_state.cpu_clock_offset;
  98     } else {
  99         ti = get_clock();
 100         return ti + timers_state.cpu_clock_offset;
 101     }
 102 }
 103
 104 #ifndef CONFIG_IOTHREAD
 105 static int64_t qemu_icount_delta(void)
 106 {
 107     if (!use_icount) {
 108         return 5000 * (int64_t) 1000000;
 109     } else if (use_icount == 1) {
 110         /* When not using an adaptive execution frequency
 111            we tend to get badly out of sync with real time,
 112            so just delay for a reasonable amount of time.  */
 113         return 0;
 114     } else {
 115         return cpu_get_icount() - cpu_get_clock();
 116     }
 117 }
 118 #endif
 119
 120 /* enable cpu_get_ticks() */
 121 void cpu_enable_ticks(void)
 122 {
 123     if (!timers_state.cpu_ticks_enabled) {
 124         timers_state.cpu_ticks_offset -= cpu_get_real_ticks();
 125         timers_state.cpu_clock_offset -= get_clock();
 126         timers_state.cpu_ticks_enabled = 1;
 127     }
 128 }
 129
 130 /* disable cpu_get_ticks() : the clock is stopped. You must not call
 131    cpu_get_ticks() after that.  */
 132 void cpu_disable_ticks(void)
 133 {
 134     if (timers_state.cpu_ticks_enabled) {
 135         timers_state.cpu_ticks_offset = cpu_get_ticks();
 136         timers_state.cpu_clock_offset = cpu_get_clock();
 137         timers_state.cpu_ticks_enabled = 0;
 138     }
 139 }
 140
 141 /***********************************************************/
 142 /* timers */
 143
 144 #define QEMU_CLOCK_REALTIME 0
 145 #define QEMU_CLOCK_VIRTUAL  1
 146 #define QEMU_CLOCK_HOST     2
 147
 148 struct QEMUClock {
 149     int type;
 150     int enabled;
 151
 152     QEMUTimer *warp_timer;
 153
 154     NotifierList reset_notifiers;
 155     int64_t last;
 156 };
 157
 158 struct QEMUTimer {
 159     QEMUClock *clock;
 160     int64_t expire_time;        /* in nanoseconds */
 161     int scale;
 162     QEMUTimerCB *cb;
 163     void *opaque;
 164     struct QEMUTimer *next;
 165 };
 166
 167 struct qemu_alarm_timer {
 168     char const *name;
 169     int (*start)(struct qemu_alarm_timer *t);
 170     void (*stop)(struct qemu_alarm_timer *t);
 171     void (*rearm)(struct qemu_alarm_timer *t);
 172 #if defined(__linux__)
 173     int fd;
 174     timer_t timer;
 175 #elif defined(_WIN32)
 176     HANDLE timer;
 177 #endif
 178     char expired;
 179     char pending;
 180 };
 181
 182 static struct qemu_alarm_timer *alarm_timer;
 183
 184 static bool qemu_timer_expired_ns(QEMUTimer *timer_head, int64_t current_time)
 185 {
 186     return timer_head && (timer_head->expire_time <= current_time);
 187 }
 188
 189 int qemu_alarm_pending(void)
 190 {
 191     return alarm_timer->pending;
 192 }
 193
 194 static inline int alarm_has_dynticks(struct qemu_alarm_timer *t)
 195 {
 196     return !!t->rearm;
 197 }
 198
 199 static void qemu_rearm_alarm_timer(struct qemu_alarm_timer *t)
 200 {
 201     if (!alarm_has_dynticks(t))
 202         return;
 203
 204     t->rearm(t);
 205 }
 206
 207 /* TODO: MIN_TIMER_REARM_NS should be optimized */
 208 #define MIN_TIMER_REARM_NS 250000
 209
 210 #ifdef _WIN32
 211
 212 static int mm_start_timer(struct qemu_alarm_timer *t);
 213 static void mm_stop_timer(struct qemu_alarm_timer *t);
 214 static void mm_rearm_timer(struct qemu_alarm_timer *t);
 215
 216 static int win32_start_timer(struct qemu_alarm_timer *t);
 217 static void win32_stop_timer(struct qemu_alarm_timer *t);
 218 static void win32_rearm_timer(struct qemu_alarm_timer *t);
 219
 220 #else
 221
 222 static int unix_start_timer(struct qemu_alarm_timer *t);
 223 static void unix_stop_timer(struct qemu_alarm_timer *t);
 224 static void unix_rearm_timer(struct qemu_alarm_timer *t);
 225
 226 #ifdef __linux__
 227
 228 static int dynticks_start_timer(struct qemu_alarm_timer *t);
 229 static void dynticks_stop_timer(struct qemu_alarm_timer *t);
 230 static void dynticks_rearm_timer(struct qemu_alarm_timer *t);
 231
 232 #endif /* __linux__ */
 233
 234 #endif /* _WIN32 */
 235
 236 /* Correlation between real and virtual time is always going to be
 237    fairly approximate, so ignore small variation.
 238    When the guest is idle real and virtual time will be aligned in
 239    the IO wait loop.  */
 240 #define ICOUNT_WOBBLE (get_ticks_per_sec() / 10)
 241
 242 static void icount_adjust(void)
 243 {
 244     int64_t cur_time;
 245     int64_t cur_icount;
 246     int64_t delta;
 247     static int64_t last_delta;
 248     /* If the VM is not running, then do nothing.  */
 249     if (!vm_running)
 250         return;
 251
 252     cur_time = cpu_get_clock();
 253     cur_icount = qemu_get_clock_ns(vm_clock);
 254     delta = cur_icount - cur_time;
 255     /* FIXME: This is a very crude algorithm, somewhat prone to oscillation.  */
 256     if (delta > 0
 257         && last_delta + ICOUNT_WOBBLE < delta * 2
 258         && icount_time_shift > 0) {
 259         /* The guest is getting too far ahead.  Slow time down.  */
 260         icount_time_shift--;
 261     }
 262     if (delta < 0
 263         && last_delta - ICOUNT_WOBBLE > delta * 2
 264         && icount_time_shift < MAX_ICOUNT_SHIFT) {
 265         /* The guest is getting too far behind.  Speed time up.  */
 266         icount_time_shift++;
 267     }
 268     last_delta = delta;
 269     qemu_icount_bias = cur_icount - (qemu_icount << icount_time_shift);
 270 }
 271
 272 static void icount_adjust_rt(void * opaque)
 273 {
 274     qemu_mod_timer(icount_rt_timer,
 275                    qemu_get_clock_ms(rt_clock) + 1000);
 276     icount_adjust();
 277 }
 278
 279 static void icount_adjust_vm(void * opaque)
 280 {
 281     qemu_mod_timer(icount_vm_timer,
 282                    qemu_get_clock_ns(vm_clock) + get_ticks_per_sec() / 10);
 283     icount_adjust();
 284 }
 285
 286 int64_t qemu_icount_round(int64_t count)
 287 {
 288     return (count + (1 << icount_time_shift) - 1) >> icount_time_shift;
 289 }
 290
 291 static struct qemu_alarm_timer alarm_timers[] = {
 292 #ifndef _WIN32
 293 #ifdef __linux__
 294     {"dynticks", dynticks_start_timer,
 295      dynticks_stop_timer, dynticks_rearm_timer},
 296 #endif
 297     {"unix", unix_start_timer, unix_stop_timer, unix_rearm_timer},
 298 #else
 299     {"mmtimer", mm_start_timer, mm_stop_timer, NULL},
 300     {"mmtimer2", mm_start_timer, mm_stop_timer, mm_rearm_timer},
 301     {"dynticks", win32_start_timer, win32_stop_timer, win32_rearm_timer},
 302     {"win32", win32_start_timer, win32_stop_timer, NULL},
 303 #endif
 304     {NULL, }
 305 };
 306
 307 static void show_available_alarms(void)
 308 {
 309     int i;
 310
 311     printf("Available alarm timers, in order of precedence:\n");
 312     for (i = 0; alarm_timers[i].name; i++)
 313         printf("%s\n", alarm_timers[i].name);
 314 }
 315
 316 void configure_alarms(char const *opt)
 317 {
 318     int i;
 319     int cur = 0;
 320     int count = ARRAY_SIZE(alarm_timers) - 1;
 321     char *arg;
 322     char *name;
 323     struct qemu_alarm_timer tmp;
 324
 325     if (!strcmp(opt, "?")) {
 326         show_available_alarms();
 327         exit(0);
 328     }
 329
 330     arg = qemu_strdup(opt);
 331
 332     /* Reorder the array */
 333     name = strtok(arg, ",");
 334     while (name) {
 335         for (i = 0; i < count && alarm_timers[i].name; i++) {
 336             if (!strcmp(alarm_timers[i].name, name))
 337                 break;
 338         }
 339
 340         if (i == count) {
 341             fprintf(stderr, "Unknown clock %s\n", name);
 342             goto next;
 343         }
 344
 345         if (i < cur)
 346             /* Ignore */
 347             goto next;
 348
 349         /* Swap */
 350         tmp = alarm_timers[i];
 351         alarm_timers[i] = alarm_timers[cur];
 352         alarm_timers[cur] = tmp;
 353
 354         cur++;
 355 next:
 356         name = strtok(NULL, ",");
 357     }
 358
 359     qemu_free(arg);
 360
 361     if (cur) {
 362         /* Disable remaining timers */
 363         for (i = cur; i < count; i++)
 364             alarm_timers[i].name = NULL;
 365     } else {
 366         show_available_alarms();
 367         exit(1);
 368     }
 369 }
 370
 371 #define QEMU_NUM_CLOCKS 3
 372
 373 QEMUClock *rt_clock;
 374 QEMUClock *vm_clock;
 375 QEMUClock *host_clock;
 376
 377 static QEMUTimer *active_timers[QEMU_NUM_CLOCKS];
 378
 379 static QEMUClock *qemu_new_clock(int type)
 380 {
 381     QEMUClock *clock;
 382
 383     clock = qemu_mallocz(sizeof(QEMUClock));
 384     clock->type = type;
 385     clock->enabled = 1;
 386     notifier_list_init(&clock->reset_notifiers);
 387     /* required to detect & report backward jumps */
 388     if (type == QEMU_CLOCK_HOST) {
 389         clock->last = get_clock_realtime();
 390     }
 391     return clock;
 392 }
 393
 394 void qemu_clock_enable(QEMUClock *clock, int enabled)
 395 {
 396     clock->enabled = enabled;
 397 }
 398
 399 static int64_t vm_clock_warp_start;
 400
 401 static void icount_warp_rt(void *opaque)
 402 {
 403     if (vm_clock_warp_start == -1) {
 404         return;
 405     }
 406
 407     if (vm_running) {
 408         int64_t clock = qemu_get_clock_ns(rt_clock);
 409         int64_t warp_delta = clock - vm_clock_warp_start;
 410         if (use_icount == 1) {
 411             qemu_icount_bias += warp_delta;
 412         } else {
 413             /*
 414              * In adaptive mode, do not let the vm_clock run too
 415              * far ahead of real time.
 416              */
 417             int64_t cur_time = cpu_get_clock();
 418             int64_t cur_icount = qemu_get_clock_ns(vm_clock);
 419             int64_t delta = cur_time - cur_icount;
 420             qemu_icount_bias += MIN(warp_delta, delta);
 421         }
 422         if (qemu_timer_expired(active_timers[QEMU_CLOCK_VIRTUAL],
 423                                qemu_get_clock_ns(vm_clock))) {
 424             qemu_notify_event();
 425         }
 426     }
 427     vm_clock_warp_start = -1;
 428 }
 429
 430 void qemu_clock_warp(QEMUClock *clock)
 431 {
 432     int64_t deadline;
 433
 434     if (!clock->warp_timer) {
 435         return;
 436     }
 437
 438     /*
 439      * There are too many global variables to make the "warp" behavior
 440      * applicable to other clocks.  But a clock argument removes the
 441      * need for if statements all over the place.
 442      */
 443     assert(clock == vm_clock);
 444
 445     /*
 446      * If the CPUs have been sleeping, advance the vm_clock timer now.  This
 447      * ensures that the deadline for the timer is computed correctly below.
 448      * This also makes sure that the insn counter is synchronized before the
 449      * CPU starts running, in case the CPU is woken by an event other than
 450      * the earliest vm_clock timer.
 451      */
 452     icount_warp_rt(NULL);
 453     if (!all_cpu_threads_idle() || !active_timers[clock->type]) {
 454         qemu_del_timer(clock->warp_timer);
 455         return;
 456     }
 457
 458     vm_clock_warp_start = qemu_get_clock_ns(rt_clock);
 459     deadline = qemu_next_icount_deadline();
 460     if (deadline > 0) {
 461         /*
 462          * Ensure the vm_clock proceeds even when the virtual CPU goes to
 463          * sleep.  Otherwise, the CPU might be waiting for a future timer
 464          * interrupt to wake it up, but the interrupt never comes because
 465          * the vCPU isn't running any insns and thus doesn't advance the
 466          * vm_clock.
 467          *
 468          * An extreme solution for this problem would be to never let VCPUs
 469          * sleep in icount mode if there is a pending vm_clock timer; rather
 470          * time could just advance to the next vm_clock event.  Instead, we
 471          * do stop VCPUs and only advance vm_clock after some "real" time,
 472          * (related to the time left until the next event) has passed.  This
 473          * rt_clock timer will do this.  This avoids that the warps are too
 474          * visible externally---for example, you will not be sending network
 475          * packets continously instead of every 100ms.
 476          */
 477         qemu_mod_timer(clock->warp_timer, vm_clock_warp_start + deadline);
 478     } else {
 479         qemu_notify_event();
 480     }
 481 }
 482
 483 QEMUTimer *qemu_new_timer(QEMUClock *clock, int scale,
 484                           QEMUTimerCB *cb, void *opaque)
 485 {
 486     QEMUTimer *ts;
 487
 488     ts = qemu_mallocz(sizeof(QEMUTimer));
 489     ts->clock = clock;
 490     ts->cb = cb;
 491     ts->opaque = opaque;
 492     ts->scale = scale;
 493     return ts;
 494 }
 495
 496 void qemu_free_timer(QEMUTimer *ts)
 497 {
 498     qemu_free(ts);
 499 }
 500
 501 /* stop a timer, but do not dealloc it */
 502 void qemu_del_timer(QEMUTimer *ts)
 503 {
 504     QEMUTimer **pt, *t;
 505
 506     /* NOTE: this code must be signal safe because
 507        qemu_timer_expired() can be called from a signal. */
 508     pt = &active_timers[ts->clock->type];
 509     for(;;) {
 510         t = *pt;
 511         if (!t)
 512             break;
 513         if (t == ts) {
 514             *pt = t->next;
 515             break;
 516         }
 517         pt = &t->next;
 518     }
 519 }
 520
 521 /* modify the current timer so that it will be fired when current_time
 522    >= expire_time. The corresponding callback will be called. */
 523 static void qemu_mod_timer_ns(QEMUTimer *ts, int64_t expire_time)
 524 {
 525     QEMUTimer **pt, *t;
 526
 527     qemu_del_timer(ts);
 528
 529     /* add the timer in the sorted list */
 530     /* NOTE: this code must be signal safe because
 531        qemu_timer_expired() can be called from a signal. */
 532     pt = &active_timers[ts->clock->type];
 533     for(;;) {
 534         t = *pt;
 535         if (!qemu_timer_expired_ns(t, expire_time)) {
 536             break;
 537         }
 538         pt = &t->next;
 539     }
 540     ts->expire_time = expire_time;
 541     ts->next = *pt;
 542     *pt = ts;
 543
 544     /* Rearm if necessary  */
 545     if (pt == &active_timers[ts->clock->type]) {
 546         if (!alarm_timer->pending) {
 547             qemu_rearm_alarm_timer(alarm_timer);
 548         }
 549         /* Interrupt execution to force deadline recalculation.  */
 550         qemu_clock_warp(ts->clock);
 551         if (use_icount) {
 552             qemu_notify_event();
 553         }
 554     }
 555 }
 556
 557 /* modify the current timer so that it will be fired when current_time
 558    >= expire_time. The corresponding callback will be called. */
 559 void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time)
 560 {
 561     qemu_mod_timer_ns(ts, expire_time * ts->scale);
 562 }
 563
 564 int qemu_timer_pending(QEMUTimer *ts)
 565 {
 566     QEMUTimer *t;
 567     for(t = active_timers[ts->clock->type]; t != NULL; t = t->next) {
 568         if (t == ts)
 569             return 1;
 570     }
 571     return 0;
 572 }
 573
 574 int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time)
 575 {
 576     return qemu_timer_expired_ns(timer_head, current_time * timer_head->scale);
 577 }
 578
 579 static void qemu_run_timers(QEMUClock *clock)
 580 {
 581     QEMUTimer **ptimer_head, *ts;
 582     int64_t current_time;
 583
 584     if (!clock->enabled)
 585         return;
 586
 587     current_time = qemu_get_clock_ns(clock);
 588     ptimer_head = &active_timers[clock->type];
 589     for(;;) {
 590         ts = *ptimer_head;
 591         if (!qemu_timer_expired_ns(ts, current_time)) {
 592             break;
 593         }
 594         /* remove timer from the list before calling the callback */
 595         *ptimer_head = ts->next;
 596         ts->next = NULL;
 597
 598         /* run the callback (the timer list can be modified) */
 599         ts->cb(ts->opaque);
 600     }
 601 }
 602
 603 int64_t qemu_get_clock_ns(QEMUClock *clock)
 604 {
 605     int64_t now, last;
 606
 607     switch(clock->type) {
 608     case QEMU_CLOCK_REALTIME:
 609         return get_clock();
 610     default:
 611     case QEMU_CLOCK_VIRTUAL:
 612         if (use_icount) {
 613             return cpu_get_icount();
 614         } else {
 615             return cpu_get_clock();
 616         }
 617     case QEMU_CLOCK_HOST:
 618         now = get_clock_realtime();
 619         last = clock->last;
 620         clock->last = now;
 621         if (now < last) {
 622             notifier_list_notify(&clock->reset_notifiers, &now);
 623         }
 624         return now;
 625     }
 626 }
 627
 628 void qemu_register_clock_reset_notifier(QEMUClock *clock, Notifier *notifier)
 629 {
 630     notifier_list_add(&clock->reset_notifiers, notifier);
 631 }
 632
 633 void qemu_unregister_clock_reset_notifier(QEMUClock *clock, Notifier *notifier)
 634 {
 635     notifier_list_remove(&clock->reset_notifiers, notifier);
 636 }
 637
 638 void init_clocks(void)
 639 {
 640     rt_clock = qemu_new_clock(QEMU_CLOCK_REALTIME);
 641     vm_clock = qemu_new_clock(QEMU_CLOCK_VIRTUAL);
 642     host_clock = qemu_new_clock(QEMU_CLOCK_HOST);
 643
 644     rtc_clock = host_clock;
 645 }
 646
 647 /* save a timer */
 648 void qemu_put_timer(QEMUFile *f, QEMUTimer *ts)
 649 {
 650     uint64_t expire_time;
 651
 652     if (qemu_timer_pending(ts)) {
 653         expire_time = ts->expire_time;
 654     } else {
 655         expire_time = -1;
 656     }
 657     qemu_put_be64(f, expire_time);
 658 }
 659
 660 void qemu_get_timer(QEMUFile *f, QEMUTimer *ts)
 661 {
 662     uint64_t expire_time;
 663
 664     expire_time = qemu_get_be64(f);
 665     if (expire_time != -1) {
 666         qemu_mod_timer_ns(ts, expire_time);
 667     } else {
 668         qemu_del_timer(ts);
 669     }
 670 }
 671
 672 static const VMStateDescription vmstate_timers = {
 673     .name = "timer",
 674     .version_id = 2,
 675     .minimum_version_id = 1,
 676     .minimum_version_id_old = 1,
 677     .fields      = (VMStateField []) {
 678         VMSTATE_INT64(cpu_ticks_offset, TimersState),
 679         VMSTATE_INT64(dummy, TimersState),
 680         VMSTATE_INT64_V(cpu_clock_offset, TimersState, 2),
 681         VMSTATE_END_OF_LIST()
 682     }
 683 };
 684
 685 void configure_icount(const char *option)
 686 {
 687     vmstate_register(NULL, 0, &vmstate_timers, &timers_state);
 688     if (!option)
 689         return;
 690
 691 #ifdef CONFIG_IOTHREAD
 692     vm_clock->warp_timer = qemu_new_timer_ns(rt_clock, icount_warp_rt, NULL);
 693 #endif
 694
 695     if (strcmp(option, "auto") != 0) {
 696         icount_time_shift = strtol(option, NULL, 0);
 697         use_icount = 1;
 698         return;
 699     }
 700
 701     use_icount = 2;
 702
 703     /* 125MIPS seems a reasonable initial guess at the guest speed.
 704        It will be corrected fairly quickly anyway.  */
 705     icount_time_shift = 3;
 706
 707     /* Have both realtime and virtual time triggers for speed adjustment.
 708        The realtime trigger catches emulated time passing too slowly,
 709        the virtual time trigger catches emulated time passing too fast.
 710        Realtime triggers occur even when idle, so use them less frequently
 711        than VM triggers.  */
 712     icount_rt_timer = qemu_new_timer_ms(rt_clock, icount_adjust_rt, NULL);
 713     qemu_mod_timer(icount_rt_timer,
 714                    qemu_get_clock_ms(rt_clock) + 1000);
 715     icount_vm_timer = qemu_new_timer_ns(vm_clock, icount_adjust_vm, NULL);
 716     qemu_mod_timer(icount_vm_timer,
 717                    qemu_get_clock_ns(vm_clock) + get_ticks_per_sec() / 10);
 718 }
 719
 720 void qemu_run_all_timers(void)
 721 {
 722     alarm_timer->pending = 0;
 723
 724     /* rearm timer, if not periodic */
 725     if (alarm_timer->expired) {
 726         alarm_timer->expired = 0;
 727         qemu_rearm_alarm_timer(alarm_timer);
 728     }
 729
 730     /* vm time timers */
 731     if (vm_running) {
 732         qemu_run_timers(vm_clock);
 733     }
 734
 735     qemu_run_timers(rt_clock);
 736     qemu_run_timers(host_clock);
 737 }
 738
 739 static int64_t qemu_next_alarm_deadline(void);
 740
 741 #ifdef _WIN32
 742 static void CALLBACK host_alarm_handler(PVOID lpParam, BOOLEAN unused)
 743 #else
 744 static void host_alarm_handler(int host_signum)
 745 #endif
 746 {
 747     struct qemu_alarm_timer *t = alarm_timer;
 748     if (!t)
 749         return;
 750
 751 #if 0
 752 #define DISP_FREQ 1000
 753     {
 754         static int64_t delta_min = INT64_MAX;
 755         static int64_t delta_max, delta_cum, last_clock, delta, ti;
 756         static int count;
 757         ti = qemu_get_clock_ns(vm_clock);
 758         if (last_clock != 0) {
 759             delta = ti - last_clock;
 760             if (delta < delta_min)
 761                 delta_min = delta;
 762             if (delta > delta_max)
 763                 delta_max = delta;
 764             delta_cum += delta;
 765             if (++count == DISP_FREQ) {
 766                 printf("timer: min=%" PRId64 " us max=%" PRId64 " us avg=%" PRId64 " us avg_freq=%0.3f Hz\n",
 767                        muldiv64(delta_min, 1000000, get_ticks_per_sec()),
 768                        muldiv64(delta_max, 1000000, get_ticks_per_sec()),
 769                        muldiv64(delta_cum, 1000000 / DISP_FREQ, get_ticks_per_sec()),
 770                        (double)get_ticks_per_sec() / ((double)delta_cum / DISP_FREQ));
 771                 count = 0;
 772                 delta_min = INT64_MAX;
 773                 delta_max = 0;
 774                 delta_cum = 0;
 775             }
 776         }
 777         last_clock = ti;
 778     }
 779 #endif
 780     if (alarm_has_dynticks(t) ||
 781         qemu_next_alarm_deadline () <= 0) {
 782         t->expired = alarm_has_dynticks(t);
 783         t->pending = 1;
 784         qemu_notify_event();
 785     }
 786 }
 787
 788 int64_t qemu_next_icount_deadline(void)
 789 {
 790     /* To avoid problems with overflow limit this to 2^32.  */
 791     int64_t delta = INT32_MAX;
 792
 793     assert(use_icount);
 794     if (active_timers[QEMU_CLOCK_VIRTUAL]) {
 795         delta = active_timers[QEMU_CLOCK_VIRTUAL]->expire_time -
 796                      qemu_get_clock_ns(vm_clock);
 797     }
 798
 799     if (delta < 0)
 800         delta = 0;
 801
 802     return delta;
 803 }
 804
 805 static int64_t qemu_next_alarm_deadline(void)
 806 {
 807     int64_t delta;
 808     int64_t rtdelta;
 809
 810     if (!use_icount && active_timers[QEMU_CLOCK_VIRTUAL]) {
 811         delta = active_timers[QEMU_CLOCK_VIRTUAL]->expire_time -
 812                      qemu_get_clock_ns(vm_clock);
 813     } else {
 814         delta = INT32_MAX;
 815     }
 816     if (active_timers[QEMU_CLOCK_HOST]) {
 817         int64_t hdelta = active_timers[QEMU_CLOCK_HOST]->expire_time -
 818                  qemu_get_clock_ns(host_clock);
 819         if (hdelta < delta)
 820             delta = hdelta;
 821     }
 822     if (active_timers[QEMU_CLOCK_REALTIME]) {
 823         rtdelta = (active_timers[QEMU_CLOCK_REALTIME]->expire_time -
 824                  qemu_get_clock_ns(rt_clock));
 825         if (rtdelta < delta)
 826             delta = rtdelta;
 827     }
 828
 829     return delta;
 830 }
 831
 832 #if defined(__linux__)
 833
 834 #include "compatfd.h"
 835
 836 static int dynticks_start_timer(struct qemu_alarm_timer *t)
 837 {
 838     struct sigevent ev;
 839     timer_t host_timer;
 840     struct sigaction act;
 841
 842     sigfillset(&act.sa_mask);
 843     act.sa_flags = 0;
 844     act.sa_handler = host_alarm_handler;
 845
 846     sigaction(SIGALRM, &act, NULL);
 847
 848     /*
 849      * Initialize ev struct to 0 to avoid valgrind complaining
 850      * about uninitialized data in timer_create call
 851      */
 852     memset(&ev, 0, sizeof(ev));
 853     ev.sigev_value.sival_int = 0;
 854     ev.sigev_notify = SIGEV_SIGNAL;
 855 #ifdef SIGEV_THREAD_ID
 856     if (qemu_signalfd_available()) {
 857         ev.sigev_notify = SIGEV_THREAD_ID;
 858         ev._sigev_un._tid = qemu_get_thread_id();
 859     }
 860 #endif /* SIGEV_THREAD_ID */
 861     ev.sigev_signo = SIGALRM;
 862
 863     if (timer_create(CLOCK_REALTIME, &ev, &host_timer)) {
 864         perror("timer_create");
 865
 866         /* disable dynticks */
 867         fprintf(stderr, "Dynamic Ticks disabled\n");
 868
 869         return -1;
 870     }
 871
 872     t->timer = host_timer;
 873
 874     return 0;
 875 }
 876
 877 static void dynticks_stop_timer(struct qemu_alarm_timer *t)
 878 {
 879     timer_t host_timer = t->timer;
 880
 881     timer_delete(host_timer);
 882 }
 883
 884 static void dynticks_rearm_timer(struct qemu_alarm_timer *t)
 885 {
 886     timer_t host_timer = t->timer;
 887     struct itimerspec timeout;
 888     int64_t nearest_delta_ns = INT64_MAX;
 889     int64_t current_ns;
 890
 891     assert(alarm_has_dynticks(t));
 892     if (!active_timers[QEMU_CLOCK_REALTIME] &&
 893         !active_timers[QEMU_CLOCK_VIRTUAL] &&
 894         !active_timers[QEMU_CLOCK_HOST])
 895         return;
 896
 897     nearest_delta_ns = qemu_next_alarm_deadline();
 898     if (nearest_delta_ns < MIN_TIMER_REARM_NS)
 899         nearest_delta_ns = MIN_TIMER_REARM_NS;
 900
 901     /* check whether a timer is already running */
 902     if (timer_gettime(host_timer, &timeout)) {
 903         perror("gettime");
 904         fprintf(stderr, "Internal timer error: aborting\n");
 905         exit(1);
 906     }
 907     current_ns = timeout.it_value.tv_sec * 1000000000LL + timeout.it_value.tv_nsec;
 908     if (current_ns && current_ns <= nearest_delta_ns)
 909         return;
 910
 911     timeout.it_interval.tv_sec = 0;
 912     timeout.it_interval.tv_nsec = 0; /* 0 for one-shot timer */
 913     timeout.it_value.tv_sec =  nearest_delta_ns / 1000000000;
 914     timeout.it_value.tv_nsec = nearest_delta_ns % 1000000000;
 915     if (timer_settime(host_timer, 0 /* RELATIVE */, &timeout, NULL)) {
 916         perror("settime");
 917         fprintf(stderr, "Internal timer error: aborting\n");
 918         exit(1);
 919     }
 920 }
 921
 922 #endif /* defined(__linux__) */
 923
 924 #if !defined(_WIN32)
 925
 926 static int unix_start_timer(struct qemu_alarm_timer *t)
 927 {
 928     struct sigaction act;
 929
 930     /* timer signal */
 931     sigfillset(&act.sa_mask);
 932     act.sa_flags = 0;
 933     act.sa_handler = host_alarm_handler;
 934
 935     sigaction(SIGALRM, &act, NULL);
 936     return 0;
 937 }
 938
 939 static void unix_rearm_timer(struct qemu_alarm_timer *t)
 940 {
 941     struct itimerval itv;
 942     int64_t nearest_delta_ns = INT64_MAX;
 943     int err;
 944
 945     assert(alarm_has_dynticks(t));
 946     if (!active_timers[QEMU_CLOCK_REALTIME] &&
 947         !active_timers[QEMU_CLOCK_VIRTUAL] &&
 948         !active_timers[QEMU_CLOCK_HOST])
 949         return;
 950
 951     nearest_delta_ns = qemu_next_alarm_deadline();
 952     if (nearest_delta_ns < MIN_TIMER_REARM_NS)
 953         nearest_delta_ns = MIN_TIMER_REARM_NS;
 954
 955     itv.it_interval.tv_sec = 0;
 956     itv.it_interval.tv_usec = 0; /* 0 for one-shot timer */
 957     itv.it_value.tv_sec =  nearest_delta_ns / 1000000000;
 958     itv.it_value.tv_usec = (nearest_delta_ns % 1000000000) / 1000;
 959     err = setitimer(ITIMER_REAL, &itv, NULL);
 960     if (err) {
 961         perror("setitimer");
 962         fprintf(stderr, "Internal timer error: aborting\n");
 963         exit(1);
 964     }
 965 }
 966
 967 static void unix_stop_timer(struct qemu_alarm_timer *t)
 968 {
 969     struct itimerval itv;
 970
 971     memset(&itv, 0, sizeof(itv));
 972     setitimer(ITIMER_REAL, &itv, NULL);
 973 }
 974
 975 #endif /* !defined(_WIN32) */
 976
 977
 978 #ifdef _WIN32
 979
 980 static MMRESULT mm_timer;
 981 static unsigned mm_period;
 982
 983 static void CALLBACK mm_alarm_handler(UINT uTimerID, UINT uMsg,
 984                                       DWORD_PTR dwUser, DWORD_PTR dw1,
 985                                       DWORD_PTR dw2)
 986 {
 987     struct qemu_alarm_timer *t = alarm_timer;
 988     if (!t) {
 989         return;
 990     }
 991     if (alarm_has_dynticks(t) || qemu_next_alarm_deadline() <= 0) {
 992         t->expired = alarm_has_dynticks(t);
 993         t->pending = 1;
 994         qemu_notify_event();
 995     }
 996 }
 997
 998 static int mm_start_timer(struct qemu_alarm_timer *t)
 999 {
1000     TIMECAPS tc;
1001     UINT flags;
1002
1003     memset(&tc, 0, sizeof(tc));
1004     timeGetDevCaps(&tc, sizeof(tc));
1005
1006     mm_period = tc.wPeriodMin;
1007     timeBeginPeriod(mm_period);
1008
1009     flags = TIME_CALLBACK_FUNCTION;
1010     if (alarm_has_dynticks(t)) {
1011         flags |= TIME_ONESHOT;
1012     } else {
1013         flags |= TIME_PERIODIC;
1014     }
1015
1016     mm_timer = timeSetEvent(1,                  /* interval (ms) */
1017                             mm_period,          /* resolution */
1018                             mm_alarm_handler,   /* function */
1019                             (DWORD_PTR)t,       /* parameter */
1020                             flags);
1021
1022     if (!mm_timer) {
1023         fprintf(stderr, "Failed to initialize win32 alarm timer: %ld\n",
1024                 GetLastError());
1025         timeEndPeriod(mm_period);
1026         return -1;
1027     }
1028
1029     return 0;
1030 }
1031
1032 static void mm_stop_timer(struct qemu_alarm_timer *t)
1033 {
1034     timeKillEvent(mm_timer);
1035     timeEndPeriod(mm_period);
1036 }
1037
1038 static void mm_rearm_timer(struct qemu_alarm_timer *t)
1039 {
1040     int nearest_delta_ms;
1041
1042     assert(alarm_has_dynticks(t));
1043     if (!active_timers[QEMU_CLOCK_REALTIME] &&
1044         !active_timers[QEMU_CLOCK_VIRTUAL] &&
1045         !active_timers[QEMU_CLOCK_HOST]) {
1046         return;
1047     }
1048
1049     timeKillEvent(mm_timer);
1050
1051     nearest_delta_ms = (qemu_next_alarm_deadline() + 999999) / 1000000;
1052     if (nearest_delta_ms < 1) {
1053         nearest_delta_ms = 1;
1054     }
1055     mm_timer = timeSetEvent(nearest_delta_ms,
1056                             mm_period,
1057                             mm_alarm_handler,
1058                             (DWORD_PTR)t,
1059                             TIME_ONESHOT | TIME_CALLBACK_FUNCTION);
1060
1061     if (!mm_timer) {
1062         fprintf(stderr, "Failed to re-arm win32 alarm timer %ld\n",
1063                 GetLastError());
1064
1065         timeEndPeriod(mm_period);
1066         exit(1);
1067     }
1068 }
1069
1070 static int win32_start_timer(struct qemu_alarm_timer *t)
1071 {
1072     HANDLE hTimer;
1073     BOOLEAN success;
1074
1075     /* If you call ChangeTimerQueueTimer on a one-shot timer (its period
1076        is zero) that has already expired, the timer is not updated.  Since
1077        creating a new timer is relatively expensive, set a bogus one-hour
1078        interval in the dynticks case.  */
1079     success = CreateTimerQueueTimer(&hTimer,
1080                           NULL,
1081                           host_alarm_handler,
1082                           t,
1083                           1,
1084                           alarm_has_dynticks(t) ? 3600000 : 1,
1085                           WT_EXECUTEINTIMERTHREAD);
1086
1087     if (!success) {
1088         fprintf(stderr, "Failed to initialize win32 alarm timer: %ld\n",
1089                 GetLastError());
1090         return -1;
1091     }
1092
1093     t->timer = hTimer;
1094     return 0;
1095 }
1096
1097 static void win32_stop_timer(struct qemu_alarm_timer *t)
1098 {
1099     HANDLE hTimer = t->timer;
1100
1101     if (hTimer) {
1102         DeleteTimerQueueTimer(NULL, hTimer, NULL);
1103     }
1104 }
1105
1106 static void win32_rearm_timer(struct qemu_alarm_timer *t)
1107 {
1108     HANDLE hTimer = t->timer;
1109     int nearest_delta_ms;
1110     BOOLEAN success;
1111
1112     assert(alarm_has_dynticks(t));
1113     if (!active_timers[QEMU_CLOCK_REALTIME] &&
1114         !active_timers[QEMU_CLOCK_VIRTUAL] &&
1115         !active_timers[QEMU_CLOCK_HOST])
1116         return;
1117
1118     nearest_delta_ms = (qemu_next_alarm_deadline() + 999999) / 1000000;
1119     if (nearest_delta_ms < 1) {
1120         nearest_delta_ms = 1;
1121     }
1122     success = ChangeTimerQueueTimer(NULL,
1123                                     hTimer,
1124                                     nearest_delta_ms,
1125                                     3600000);
1126
1127     if (!success) {
1128         fprintf(stderr, "Failed to rearm win32 alarm timer: %ld\n",
1129                 GetLastError());
1130         exit(-1);
1131     }
1132
1133 }
1134
1135 #endif /* _WIN32 */
1136
1137 static void alarm_timer_on_change_state_rearm(void *opaque, int running, int reason)
1138 {
1139     if (running)
1140         qemu_rearm_alarm_timer((struct qemu_alarm_timer *) opaque);
1141 }
1142
1143 int init_timer_alarm(void)
1144 {
1145     struct qemu_alarm_timer *t = NULL;
1146     int i, err = -1;
1147
1148     for (i = 0; alarm_timers[i].name; i++) {
1149         t = &alarm_timers[i];
1150
1151         err = t->start(t);
1152         if (!err)
1153             break;
1154     }
1155
1156     if (err) {
1157         err = -ENOENT;
1158         goto fail;
1159     }
1160
1161     /* first event is at time 0 */
1162     t->pending = 1;
1163     alarm_timer = t;
1164     qemu_add_vm_change_state_handler(alarm_timer_on_change_state_rearm, t);
1165
1166     return 0;
1167
1168 fail:
1169     return err;
1170 }
1171
1172 void quit_timers(void)
1173 {
1174     struct qemu_alarm_timer *t = alarm_timer;
1175     alarm_timer = NULL;
1176     t->stop(t);
1177 }
1178
1179 int qemu_calculate_timeout(void)
1180 {
1181 #ifndef CONFIG_IOTHREAD
1182     int timeout;
1183
1184     if (!vm_running)
1185         timeout = 5000;
1186     else {
1187      /* XXX: use timeout computed from timers */
1188         int64_t add;
1189         int64_t delta;
1190         /* Advance virtual time to the next event.  */
1191         delta = qemu_icount_delta();
1192         if (delta > 0) {
1193             /* If virtual time is ahead of real time then just
1194                wait for IO.  */
1195             timeout = (delta + 999999) / 1000000;
1196         } else {
1197             /* Wait for either IO to occur or the next
1198                timer event.  */
1199             add = qemu_next_icount_deadline();
1200             /* We advance the timer before checking for IO.
1201                Limit the amount we advance so that early IO
1202                activity won't get the guest too far ahead.  */
1203             if (add > 10000000)
1204                 add = 10000000;
1205             delta += add;
1206             qemu_icount += qemu_icount_round (add);
1207             timeout = delta / 1000000;
1208             if (timeout < 0)
1209                 timeout = 0;
1210         }
1211     }
1212
1213     return timeout;
1214 #else /* CONFIG_IOTHREAD */
1215     return 1000;
1216 #endif
1217 }
1218