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