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