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